Add post_processors override to apply_patch() and add more testing.

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 74 matching lines @@
     """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.
 
     Args:
       revision: The revision it should sync to, SCM specific.
     """
     raise NotImplementedError()
 
-  def apply_patch(self, patches):
+  def apply_patch(self, patches, post_processors=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.
     """
     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, revision):
     """Stubbed out."""
     pass
 
-  def apply_patch(self, patches):
+  def apply_patch(self, patches, post_processors=None):
     """Ignores svn properties."""
+    post_processors = post_processors or self.post_processors 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)
 
           filepath = os.path.join(self.project_path, p.filename)
           if p.is_binary:
             with open(filepath, 'wb') as f:
               f.write(p.get())
           else:
             if p.diff_hunks:
               stdout = subprocess2.check_output(
                   ['patch', '-p%s' % p.patchlevel],
                   stdin=p.get(),
                   stderr=subprocess2.STDOUT,
                   cwd=self.project_path)
             elif p.is_new and not os.path.exists(filepath):
               # There is only a header. Just create the file.
               open(filepath, 'w').close()
-        for post in (self.post_processors or []):
+        for post in post_processors:
           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 95 matching lines @@
     assert bool(self.commit_user) >= bool(self.commit_pwd)
 
   def prepare(self, revision):
     # Will checkout if the directory is not present.
     assert self.svn_url
     if not os.path.isdir(self.project_path):
       logging.info('Checking out %s in %s' %
           (self.project_name, self.project_path))
     return self._revert(revision)
 
-  def apply_patch(self, patches):
+  def apply_patch(self, patches, post_processors=None):
+    post_processors = post_processors or self.post_processors or []
     for p in patches:
       try:
         # It is important to use credentials=False otherwise credentials could
         # leak in the error message. Credentials are not necessary here for the
         # following commands anyway.
         stdout = ''
         if p.is_delete:
           stdout += self._check_output_svn(
               ['delete', p.filename, '--force'], credentials=False)
         else:
@@ skipping 32 matching lines @@
                 ['propset', prop[0], prop[1], p.filename], credentials=False)
           for prop, values in self.svn_config.auto_props.iteritems():
             if fnmatch.fnmatch(p.filename, prop):
               for value in values.split(';'):
                 if '=' not in value:
                   params = [value, '*']
                 else:
                   params = value.split('=', 1)
                 stdout += self._check_output_svn(
                     ['propset'] + params + [p.filename], credentials=False)
-        for post in (self.post_processors or []):
+        for post in post_processors:
           post(self, p)
       except OSError, e:
         raise PatchApplicationFailed(p.filename, '%s%s' % (stdout, e))
       except subprocess.CalledProcessError, e:
         raise PatchApplicationFailed(
             p.filename,
             'While running %s;\n%s%s' % (
               ' '.join(e.cmd), stdout, getattr(e, 'stdout', '')))
 
   def commit(self, commit_message, user):
@@ skipping 83 matching lines @@
         revision = self._check_output_git(['rev-parse', revision])
       self._check_call_git(['checkout', '--force', '--quiet', revision])
     else:
       branches, active = self._branches()
       if active != 'master':
         self._check_call_git(['checkout', '--force', '--quiet', 'master'])
       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):
+  def apply_patch(self, patches, post_processors=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_processors = post_processors or self.post_processors or []
     # It this throws, the checkout is corrupted. Maybe worth deleting it and
     # trying again?
     if self.remote_branch:
       self._check_call_git(
           ['checkout', '-b', self.working_branch,
             '%s/%s' % (self.remote, self.remote_branch), '--quiet'])
     for p in patches:
       try:
         stdout = ''
         if p.is_delete:
@@ skipping 16 matching lines @@
             # 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 (self.post_processors or []):
+        for post in post_processors:
           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.
@@ skipping 211 matching lines @@
            '-T', self.trunk,
            self.svn_url, self.project_path,
            '--quiet'],
           cwd=self.root_dir,
           stderr=subprocess2.STDOUT)
     return super(GitSvnCheckout, self).prepare(revision)
 
 
 class ReadOnlyCheckout(object):
   """Converts a checkout into a read-only one."""
-  def __init__(self, checkout):
+  def __init__(self, checkout, post_processors=None):
     super(ReadOnlyCheckout, self).__init__()
     self.checkout = checkout
+    self.post_processors = (post_processors or []) + (
+        self.checkout.post_processors or [])
 
   def prepare(self, revision):
     return self.checkout.prepare(revision)
 
   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_processors=None):

[M-A Ruel, 2011/09/28 19:28:07]

It's mainly for this edge case.

+    return self.checkout.apply_patch(
+        patches, post_processors or self.post_processors)
 
   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