Make post_processors part of the Checkout object state.

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 41 matching lines @@
   def __init__(self, filename, status):
     super(PatchApplicationFailed, self).__init__(filename, status)
     self.filename = filename
     self.status = status
 
 
 class CheckoutBase(object):
   # Set to None to have verbose output.
   VOID = subprocess2.VOID
 
-  def __init__(self, root_dir, project_name):
+  def __init__(self, root_dir, project_name, post_processors):
+    """
+    Args:
+      post_processor: list of lambda(checkout, patches) to call on each of the
+                      modified files.
+    """
     self.root_dir = root_dir
     self.project_name = project_name
     if self.project_name is None:
       self.project_path = self.root_dir
     else:
       self.project_path = os.path.join(self.root_dir, self.project_name)
     # Only used for logging purposes.
     self._last_seen_revision = None
+    self.post_processors = None
     assert self.root_dir
     assert self.project_path
 
   def get_settings(self, key):
     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, post_processor=None):
+  def apply_patch(self, patches):
     """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, post_processor=None):
+  def apply_patch(self, patches):
     """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)
 
           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(),
                   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 post_processor:
+        for post in (self.post_processors or []):
           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 75 matching lines @@
       k, v = line.split(':', 1)
       k = k.strip().lower()
       v = v.strip()
       assert not k in values
       values[k] = v
     return values.get(key, None)
 
 
 class SvnCheckout(CheckoutBase, SvnMixIn):
   """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)
+  def __init__(self, root_dir, project_name, commit_user, commit_pwd, svn_url,
+      post_processors=None):
+    super(SvnCheckout, self).__init__(root_dir, project_name, post_processors)
     self.commit_user = commit_user
     self.commit_pwd = commit_pwd
     self.svn_url = svn_url
     assert bool(self.commit_user) >= bool(self.commit_pwd)
 
   def prepare(self):
     # 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))
     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, post_processor=None):
-    post_processor = post_processor or []
+  def apply_patch(self, patches):
     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 post_processor:
+        for post in (self.post_processors or []):
           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 42 matching lines @@
       scm.SVN.Revert(self.project_path)
       # Revive files that were deleted in scm.SVN.Revert().
       self._check_call_svn(['update', '--force'] + flags)
 
     out = self._check_output_svn(['info', '.'])
     return int(self._parse_svn_info(out, 'revision'))
 
 
 class GitCheckoutBase(CheckoutBase):
   """Base class for git checkout. Not to be used as-is."""
-  def __init__(self, root_dir, project_name, remote_branch):
-    super(GitCheckoutBase, self).__init__(root_dir, project_name)
+  def __init__(self, root_dir, project_name, remote_branch,
+      post_processors=None):
+    super(GitCheckoutBase, self).__init__(
+        root_dir, project_name, post_processors)
     # There is no reason to not hardcode it.
     self.remote = 'origin'
     self.remote_branch = remote_branch
     self.working_branch = 'working_branch'
 
   def prepare(self):
     """Resets the git repository in a clean state.
 
     Checks it out if not present and deletes the working branch.
     """
     assert self.remote_branch
     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, post_processor=None):
+  def apply_patch(self, patches):
     """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?
     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 post_processor:
+        for post in (self.post_processors or []):
           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 36 matching lines @@
         active = l[2:]
         break
     return branches, active
 
 
 class GitSvnCheckoutBase(GitCheckoutBase, SvnMixIn):
   """Base class for git-svn checkout. Not to be used as-is."""
   def __init__(self,
       root_dir, project_name, remote_branch,
       commit_user, commit_pwd,
-      svn_url, trunk):
+      svn_url, trunk, post_processors=None):
     """trunk is optional."""
     super(GitSvnCheckoutBase, self).__init__(
-        root_dir, project_name + '.git', remote_branch)
+        root_dir, project_name + '.git', remote_branch, post_processors)
     self.commit_user = commit_user
     self.commit_pwd = commit_pwd
     # svn_url in this case is the root of the svn repository.
     self.svn_url = svn_url
     self.trunk = trunk
     assert bool(self.commit_user) >= bool(self.commit_pwd)
     assert self.svn_url
     assert self.trunk
     self._cache_svn_auth()
 
@@ skipping 67 matching lines @@
 
 class GitSvnPremadeCheckout(GitSvnCheckoutBase):
   """Manages a git-svn clone made out from an initial git-svn seed.
 
   This class is very similar to GitSvnCheckout but is faster to bootstrap
   because it starts right off with an existing git-svn clone.
   """
   def __init__(self,
       root_dir, project_name, remote_branch,
       commit_user, commit_pwd,
-      svn_url, trunk, git_url):
+      svn_url, trunk, git_url, post_processors=None):
     super(GitSvnPremadeCheckout, self).__init__(
         root_dir, project_name, remote_branch,
         commit_user, commit_pwd,
-        svn_url, trunk)
+        svn_url, trunk, post_processors)
     self.git_url = git_url
     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.
@@ skipping 19 matching lines @@
 
 
 class GitSvnCheckout(GitSvnCheckoutBase):
   """Manages a git-svn clone.
 
   Using git-svn hides some of the complexity of using a svn checkout.
   """
   def __init__(self,
       root_dir, project_name,
       commit_user, commit_pwd,
-      svn_url, trunk):
+      svn_url, trunk, post_processors=None):
     super(GitSvnCheckout, self).__init__(
         root_dir, project_name, 'trunk',
         commit_user, commit_pwd,
-        svn_url, trunk)
+        svn_url, trunk, post_processors)
 
   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))
       # TODO: Create a shallow clone.
       # self.project_path doesn't exist yet.
       self._check_call_git_svn(
           ['clone',
@@ skipping 11 matching lines @@
   """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, post_processor=None):
-    return self.checkout.apply_patch(patches, post_processor)
+  def apply_patch(self, patches):
+    return self.checkout.apply_patch(patches)
 
   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