Exclude codereview.settings from Crashpad

third_party/crashpad/update.py

 #!/usr/bin/env python
 # coding: utf-8
 
 # Copyright 2015 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import argparse
 import os
 import re
 import subprocess
 import sys
 import tempfile
 import textwrap
 
 
+EXCLUDED_FILES = ['codereview.settings']
+
 IS_WINDOWS = sys.platform.startswith('win')
 
 
 def SubprocessCheckCall0Or1(args):
     """Like subprocss.check_call(), but allows a return code of 1.
 
     Returns True if the subprocess exits with code 0, False if it exits with
     code 1, and re-raises the subprocess.check_call() exception otherwise.
     """
     try:
@@ skipping 73 matching lines @@
     # the update operation.
     if not GitMergeBaseIsAncestor(parsed.update_to, 'FETCH_HEAD'):
         raise Exception('update_to is not an ancestor of FETCH_HEAD',
                         parsed.update_to,
                         'FETCH_HEAD')
     if not GitMergeBaseIsAncestor(revision_old, parsed.update_to):
         raise Exception('revision_old is not an ancestor of update_to',
                         revision_old,
                         parsed.update_to)
 
+    cherry_pick_start_head = original_head
+
+    # Put excluded files back at the old revision, so that any changes to them
+    # can be made during the update. They’ll be deleted again before the update
+    # is committed.
+    git_root = subprocess.check_output(['git', 'rev-parse', '--show-toplevel'],
+                                       shell=IS_WINDOWS).rstrip()
+    excluded_full_paths = []
+    for excluded_file in EXCLUDED_FILES:
+        contents = subprocess.check_output(
+            ['git', 'cat-file', 'blob', revision_old + ':' + excluded_file],

[scottmg, 2017/03/01 18:38:15]

I can imagine this mucking up newlines on Windows, but I don't know either way.
I'll try it out next time I roll.

+            shell=IS_WINDOWS)
+        excluded_full_path = \

[agable, 2017/03/01 20:50:54]

Don't use \ for line continuations, use parentheses instead.

+            os.path.join(git_root, parsed.subtree, excluded_file)
+        excluded_full_paths.append(excluded_full_path)
+        with open(excluded_full_path, 'wbx') as file:

[scottmg, 2017/03/01 18:38:15]

I've never used 'x' before, why is it useful here?

[Mark Mentovai, 2017/03/01 21:00:36]

scottmg wrote:
It’s O_EXCL, but it also probably doesn’t work on all platforms.

I’m just using it to assert that the file isn’t already there. I can take it out
or use a more portable approach if you’d prefer.

+            file.write(contents)
+    if excluded_full_paths:
+        add_cmd = ['git', 'add']
+        add_cmd.extend(excluded_full_paths)
+        subprocess.check_call(add_cmd, shell=IS_WINDOWS)
+        commit_cmd = ['git', 'commit', '--message', 'Restore excluded files']
+        commit_cmd.extend(excluded_full_paths)
+        subprocess.check_call(commit_cmd, shell=IS_WINDOWS)
+
+        # Cherry-picking will begin from here.
+        cherry_pick_start_head = (
+            subprocess.check_output(['git', 'rev-parse', 'HEAD'],
+                                    shell=IS_WINDOWS).rstrip())
+
     update_range = revision_old + '..' + parsed.update_to
 
     # This cherry-picks each change in the window from the upstream project into
     # the current branch.
     assisted_cherry_pick = False
     try:
         if not SubprocessCheckCall0Or1(['git',
                                         'cherry-pick',
                                         '--keep-redundant-commits',
                                         '--strategy=subtree',
@@ skipping 23 matching lines @@
                                          '--abbrev-commit',
                                          '--pretty=oneline',
                                          '--reverse',
                                          update_range],
                                          shell=IS_WINDOWS).splitlines(False)
 
     if assisted_cherry_pick:
         # If the user had to help, count the number of cherry-picked commits,
         # expecting it to match.
         cherry_picked_commits = int(subprocess.check_output(
-            ['git', 'rev-list', '--count', original_head + '..HEAD']))
+            ['git', 'rev-list', '--count', cherry_pick_start + '..HEAD'],
+            shell=IS_WINDOWS))
         if cherry_picked_commits != len(log_lines):
             print >>sys.stderr, 'Something smells fishy, aborting anyway...'
             subprocess.call(['git', 'cherry-pick', '--abort'], shell=IS_WINDOWS)
             raise Exception('not all commits were cherry-picked',
                             len(log_lines),
                             cherry_picked_commits)
 
     # Make a nice commit message. Start with the full commit hash.
     revision_new = subprocess.check_output(
         ['git', 'rev-parse', parsed.update_to], shell=IS_WINDOWS).rstrip()
@@ skipping 25 matching lines @@
     # If the in-tree copy has no changes relative to the upstream, clear the
     # “Local Modifications” section of the README.
     has_local_modifications = True
     if SubprocessCheckCall0Or1(['git',
                                 'diff-tree',
                                 '--quiet',
                                 parsed.update_to,
                                 'HEAD:' + parsed.subtree]):
         has_local_modifications = False
 
+        if not EXCLUDED_FILES:
+            modifications = 'None.'
+        elif len(EXCLUDED_FILES) == 1:
+            modifications = \
+                ' - %s has been excluded.' % EXCLUDED_FILES[0]
+        else:
+            modifications =\
+                ' - The following files have been excluded:'
+            for excluded_file in sorted(EXCLUDED_FILES):
+                modifications += '\n    - ' + excluded_file
         readme_content_new = re.sub(r'\nLocal Modifications:\n.*$',
-                                    '\nLocal Modifications:\nNone.',
+                                    '\nLocal Modifications:\n' + modifications,
                                     readme_content_new,
                                     1)
 
-    # This soft-reset causes all of the cherry-picks to show up as staged,
-    # which will have the effect of squashing them along with the README update
-    # when committed below.
+    # Remove excluded files as promised.
+    if excluded_full_paths:
+        rm_cmd = ['git', 'rm']
+        rm_cmd.extend(excluded_full_paths)
+        subprocess.check_call(rm_cmd, shell=IS_WINDOWS)
+        commit_cmd = ['git', 'commit', '--message', 'Remove excluded files']
+        commit_cmd.extend(excluded_full_paths)
+        subprocess.check_call(commit_cmd, shell=IS_WINDOWS)
+
+    # This soft-reset causes all of the cherry-picks and any additions and
+    # removals of excluded files to show up as staged, which will have the
+    # effect of squashing them along with the README update when committed
+    # below.
     subprocess.check_call(['git', 'reset', '--soft', original_head],
                           shell=IS_WINDOWS)
 
     # Write the new README.
     open(readme_path, 'wb').write(readme_content_new)
 
     # Commit everything.
     subprocess.check_call(['git', 'add', readme_path], shell=IS_WINDOWS)
 
     try:
@@ skipping 11 matching lines @@
     if has_local_modifications:
         print >>sys.stderr, (
             'Remember to check the Local Modifications section in ' +
             readme_path)
 
     return 0
 
 
 if __name__ == '__main__':
     sys.exit(main(sys.argv[1:]))