Add post_process argument to Checkout.apply_patch().

checkout.py

 # coding=utf8
 # Copyright (c) 2011 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.
 """Manages a project checkout.
 
 Includes support for svn, git-svn and git.
 """
 
 from __future__ import with_statement
@@ skipping 62 matching lines @@
     return get_code_review_setting(self.project_path, key)
 
   def prepare(self):
     """Checks out a clean copy of the tree and removes any local modification.
 
     This function shouldn't throw unless the remote repository is inaccessible,
     there is no free disk space or hard issues like that.
     """
     raise NotImplementedError()
 
-  def apply_patch(self, patches):
+  def apply_patch(self, patches, post_processor=None):
     """Applies a patch and returns the list of modified files.
 
     This function should throw patch.UnsupportedPatchFormat or
     PatchApplicationFailed when relevant.
+
+    Args:
+      patches: patch.PatchSet object.
+      post_processor: list of lambda(checkout, patches) to call on each of the
+                      modified files.
     """
     raise NotImplementedError()
 
   def commit(self, commit_message, user):
     """Commits the patch upstream, while impersonating 'user'."""
     raise NotImplementedError()
 
 
 class RawCheckout(CheckoutBase):
   """Used to apply a patch locally without any intent to commit it.
 
   To be used by the try server.
   """
   def prepare(self):
     """Stubbed out."""
     pass
 
-  def apply_patch(self, patches):
+  def apply_patch(self, patches, post_processor=None):
+    """Ignores svn properties."""
+    post_processor = post_processor or []
     for p in patches:
       try:
         stdout = ''
         filename = os.path.join(self.project_path, p.filename)
         if p.is_delete:
           os.remove(filename)
         else:
           dirname = os.path.dirname(p.filename)
           full_dir = os.path.join(self.project_path, dirname)
           if dirname and not os.path.isdir(full_dir):
             os.makedirs(full_dir)
           if p.is_binary:
             with open(os.path.join(filename), 'wb') as f:
               f.write(p.get())
           else:
             stdout = subprocess2.check_output(
                 ['patch', '-p%s' % p.patchlevel],
                 stdin=p.get(),
                 cwd=self.project_path)
-          # Ignore p.svn_properties.
+        for post in post_processor:
+          post(self, p)
       except OSError, e:
         raise PatchApplicationFailed(p.filename, '%s%s' % (stdout, e))
       except subprocess.CalledProcessError, e:
         raise PatchApplicationFailed(
             p.filename, '%s%s' % (stdout, getattr(e, 'stdout', None)))
 
   def commit(self, commit_message, user):
     """Stubbed out."""
     raise NotImplementedError('RawCheckout can\'t commit')
 
@@ skipping 80 matching lines @@
   """Manages a subversion checkout."""
   def __init__(self, root_dir, project_name, commit_user, commit_pwd, svn_url):
     super(SvnCheckout, self).__init__(root_dir, project_name)
     self.commit_user = commit_user
     self.commit_pwd = commit_pwd
     self.svn_url = svn_url
     assert bool(self.commit_user) >= bool(self.commit_pwd)
     assert self.svn_url
 
   def prepare(self):
-    """Creates the initial checkouts for the repo."""
     # Will checkout if the directory is not present.
     if not os.path.isdir(self.project_path):
       logging.info('Checking out %s in %s' %
           (self.project_name, self.project_path))
     revision = self._revert()
     if revision != self._last_seen_revision:
       logging.info('Updated at revision %d' % revision)
       self._last_seen_revision = revision
     return revision
 
-  def apply_patch(self, patches):
-    """Applies a patch."""
+  def apply_patch(self, patches, post_processor=None):
+    post_processor = post_processor or []
     for p in patches:
       try:
         stdout = ''
         if p.is_delete:
           stdout += self._check_output_svn(['delete', p.filename, '--force'])
         else:
           new = not os.path.exists(p.filename)
 
           # svn add while creating directories otherwise svn add on the
           # contained files will silently fail.
@@ skipping 18 matching lines @@
                 cmd, stdin=p.get(), cwd=self.project_path)
           if new:
             stdout += self._check_output_svn(['add', p.filename, '--force'])
           for prop in p.svn_properties:
             stdout += self._check_output_svn(
                 ['propset', prop[0], prop[1], p.filename])
           for prop, value in self.svn_config.auto_props.iteritems():
             if fnmatch.fnmatch(p.filename, prop):
               stdout += self._check_output_svn(
                   ['propset'] + value.split('=', 1) + [p.filename])
+        for post in post_processor:
+          post(self, p)
       except OSError, e:
         raise PatchApplicationFailed(p.filename, '%s%s' % (stdout, e))
       except subprocess.CalledProcessError, e:
         raise PatchApplicationFailed(
             p.filename, '%s%s' % (stdout, getattr(e, 'stdout', '')))
 
   def commit(self, commit_message, user):
     logging.info('Committing patch for %s' % user)
     assert self.commit_user
     handle, commit_filename = tempfile.mkstemp(text=True)
@@ skipping 58 matching lines @@
     """
     assert os.path.isdir(self.project_path)
     self._check_call_git(['reset', '--hard', '--quiet'])
     branches, active = self._branches()
     if active != 'master':
       self._check_call_git(['checkout', 'master', '--force', '--quiet'])
     self._check_call_git(['pull', self.remote, self.remote_branch, '--quiet'])
     if self.working_branch in branches:
       self._call_git(['branch', '-D', self.working_branch])
 
-  def apply_patch(self, patches):
-    """Applies a patch on 'working_branch' and switch to it."""
+  def apply_patch(self, patches, post_processor=None):
+    """Applies a patch on 'working_branch' and switch to it.
+
+    Also commits the changes on the local branch.
+
+    Ignores svn properties and raise an exception on unexpected ones.
+    """
+    post_processor = post_processor or []
     # It this throws, the checkout is corrupted. Maybe worth deleting it and
     # trying again?
     self._check_call_git(
         ['checkout', '-b', self.working_branch,
-          '%s/%s' % (self.remote, self.remote_branch)])
+          '%s/%s' % (self.remote, self.remote_branch), '--quiet'])
     for p in patches:
       try:
         stdout = ''
         if p.is_delete:
           stdout += self._check_output_git(['rm', p.filename])
         else:
           dirname = os.path.dirname(p.filename)
           full_dir = os.path.join(self.project_path, dirname)
           if dirname and not os.path.isdir(full_dir):
             os.makedirs(full_dir)
           if p.is_binary:
             with open(os.path.join(self.project_path, p.filename), 'wb') as f:
               f.write(p.get())
             stdout += self._check_output_git(['add', p.filename])
           else:
             stdout += self._check_output_git(
                 ['apply', '--index', '-p%s' % p.patchlevel], stdin=p.get())
           for prop in p.svn_properties:
             # Ignore some known auto-props flags through .subversion/config,
             # bails out on the other ones.
             # TODO(maruel): Read ~/.subversion/config and detect the rules that
             # applies here to figure out if the property will be correctly
             # handled.
             if not prop[0] in ('svn:eol-style', 'svn:executable'):
               raise patch.UnsupportedPatchFormat(
                   p.filename,
                   'Cannot apply svn property %s to file %s.' % (
                         prop[0], p.filename))
+        for post in post_processor:
+          post(self, p)
       except OSError, e:
         raise PatchApplicationFailed(p.filename, '%s%s' % (stdout, e))
       except subprocess.CalledProcessError, e:
         raise PatchApplicationFailed(
             p.filename, '%s%s' % (stdout, getattr(e, 'stdout', None)))
     # Once all the patches are processed and added to the index, commit the
     # index.
     self._check_call_git(['commit', '-m', 'Committed patch'])
     # TODO(maruel): Weirdly enough they don't match, need to investigate.
     #found_files = self._check_output_git(
@@ skipping 85 matching lines @@
     # Fix the commit message and author. It returns the git hash, which we
     # ignore unless it's None.
     if not super(GitSvnCheckoutBase, self).commit(commit_message, user):
       return None
     # TODO(maruel): git-svn ignores --config-dir as of git-svn version 1.7.4 and
     # doesn't support --with-revprop.
     # Either learn perl and upstream or suck it.
     kwargs = {}
     if self.commit_pwd:
       kwargs['stdin'] = self.commit_pwd + '\n'
+      kwargs['stderr'] = subprocess2.STDOUT
     self._check_call_git_svn(
         ['dcommit', '--rmdir', '--find-copies-harder',
           '--username', self.commit_user],
         **kwargs)
     revision = int(self._git_svn_info('revision'))
     return revision
 
   def _cache_svn_auth(self):
     """Caches the svn credentials. It is necessary since git-svn doesn't prompt
     for it."""
@@ skipping 35 matching lines @@
     assert self.git_url
 
   def prepare(self):
     """Creates the initial checkout for the repo."""
     if not os.path.isdir(self.project_path):
       logging.info('Checking out %s in %s' %
           (self.project_name, self.project_path))
       assert self.remote == 'origin'
       # self.project_path doesn't exist yet.
       self._check_call_git(
-          ['clone', self.git_url, self.project_name],
-          cwd=self.root_dir)
+          ['clone', self.git_url, self.project_name, '--quiet'],
+          cwd=self.root_dir,
+          stderr=subprocess2.STDOUT)
     try:
       configured_svn_url = self._check_output_git(
           ['config', 'svn-remote.svn.url']).strip()
     except subprocess.CalledProcessError:
       configured_svn_url = ''
 
     if configured_svn_url.strip() != self.svn_url:
       self._check_call_git_svn(
           ['init',
            '--prefix', self.remote + '/',
@@ skipping 22 matching lines @@
     """Creates the initial checkout for the repo."""
     if not os.path.isdir(self.project_path):
       logging.info('Checking out %s in %s' %
           (self.project_name, self.project_path))
       # TODO: Create a shallow clone.
       # self.project_path doesn't exist yet.
       self._check_call_git_svn(
           ['clone',
            '--prefix', self.remote + '/',
            '-T', self.trunk,
-           self.svn_url, self.project_path],
-          cwd=self.root_dir)
+           self.svn_url, self.project_path,
+           '--quiet'],
+          cwd=self.root_dir,
+          stderr=subprocess2.STDOUT)
     super(GitSvnCheckout, self).prepare()
     return self._get_revision()
 
 
 class ReadOnlyCheckout(object):
   """Converts a checkout into a read-only one."""
   def __init__(self, checkout):
     self.checkout = checkout
 
   def prepare(self):
     return self.checkout.prepare()
 
   def get_settings(self, key):
     return self.checkout.get_settings(key)
 
-  def apply_patch(self, patches):
-    return self.checkout.apply_patch(patches)
+  def apply_patch(self, patches, post_processor=None):
+    return self.checkout.apply_patch(patches, post_processor)
 
   def commit(self, message, user):  # pylint: disable=R0201
     logging.info('Would have committed for %s with message: %s' % (
         user, message))
     return 'FAKE'
 
   @property
   def project_name(self):
     return self.checkout.project_name
 
   @property
   def project_path(self):
     return self.checkout.project_path