Add black/whitelisting to apply_issue

checkout.py

 # coding=utf8
 # Copyright (c) 2012 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.
 """
 
 import ConfigParser
@@ skipping 114 matching lines @@
 
     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, post_processors=None, verbose=False,
-                  name=None, email=None):
+                  name=None, email=None, whitelist=None, blacklist=None):

[M-A Ruel, 2014/05/06 18:49:08]

I think you are doing it at the wrong abstraction level. You should clean up the
patches object first. It's not at application time that filtering should be
done.

[Ryan Tseng, 2014/05/06 19:31:53]

Done.

     """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()
 
@@ skipping 14 matching lines @@
 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, post_processors=None, verbose=False,
-                  name=None, email=None):
+                  name=None, email=None, whitelist=None, blacklist=None):
     """Ignores svn properties."""
     post_processors = post_processors or self.post_processors or []
     for p in patches:
       stdout = []
       try:
         filepath = os.path.join(self.project_path, p.filename)
+        if blacklist and p.filename in blacklist:
+          continue
+        if whitelist and p.filename not in whitelist:
+          continue
         if p.is_delete:
           os.remove(filepath)
           stdout.append('Deleted.')
         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)
             stdout.append('Created missing directory %s.' % dirname)
 
@@ skipping 158 matching lines @@
 
   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, post_processors=None, verbose=False,
-                  name=None, email=None):
+                  name=None, email=None, whitelist=None, blacklist=None):
     post_processors = post_processors or self.post_processors or []
     for p in patches:
       stdout = []
       try:
+        if blacklist and p.filename in blacklist:
+          continue
+        if whitelist and p.filename not in whitelist:
+          continue
         filepath = os.path.join(self.project_path, p.filename)
         # 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.
         if p.is_delete:
           stdout.append(self._check_output_svn(
               ['delete', p.filename, '--force'], credentials=False))
           stdout.append('Deleted.')
         else:
           # svn add while creating directories otherwise svn add on the
@@ skipping 255 matching lines @@
     self._check_call_git(
         ['pull', self.remote,
          '%s:%s' % (self.remote_branch, remote_tracked_path),
          '--quiet'])
 
   def _get_head_commit_hash(self):
     """Gets the current revision (in unicode) from the local branch."""
     return unicode(self._check_output_git(['rev-parse', 'HEAD']).strip())
 
   def apply_patch(self, patches, post_processors=None, verbose=False,
-                  name=None, email=None):
+                  name=None, email=None, whitelist=None, blacklist=None):
     """Applies a patch on 'working_branch' and switches to it.
 
     Also commits the changes on the local branch.
 
+    If ignore_deps is set, then files matching deps will not get patched.
+    If deps_only is set, then only files matching deps will get patched.
+
     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, '-t', self.remote_branch,
            '--quiet'])
 
     for index, p in enumerate(patches):
       stdout = []
       try:
+        if blacklist and p.filename in blacklist:
+          continue
+        if whitelist and p.filename not in whitelist:
+          continue
         filepath = os.path.join(self.project_path, p.filename)
         if p.is_delete:
           if (not os.path.exists(filepath) and
               any(p1.source_filename == p.filename for p1 in patches[0:index])):
             # The file was already deleted if a prior patch with file rename
             # was already processed because 'git apply' did it for us.
             pass
           else:
             stdout.append(self._check_output_git(['rm', p.filename]))
             stdout.append('Deleted.')
@@ skipping 19 matching lines @@
             if verbose:
               cmd.append('--verbose')
             stdout.append(self._check_output_git(cmd, stdin=p.get(True)))
           for name, value 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.
             stdout.append('Property %s=%s' % (name, value))
+            # TODO(hinoka): Also remove the executable flag if svn:executabe
+            #               is not set yet the file is executable.
             if not name in (
                 'svn:eol-style', 'svn:executable', 'svn:mime-type'):
               raise patch.UnsupportedPatchFormat(
                   p.filename,
                   'Cannot apply svn property %s to file %s.' % (
                         name, p.filename))
         for post in post_processors:
           post(self, p)
         if verbose:
           print p.filename
@@ skipping 16 matching lines @@
       cmd.append('--verbose')
     self._check_call_git(cmd)
     if self.base_ref:
       base_ref = self.base_ref
     else:
       base_ref = '%s/%s' % (self.remote,
                             self.remote_branch or self.master_branch)
     found_files = self._check_output_git(
         ['diff', base_ref, '--ignore-submodules',
          '--name-only']).splitlines(False)
-    assert sorted(patches.filenames) == sorted(found_files), (
-        sorted(patches.filenames), sorted(found_files))
+    expected_files = patches.filenames
+    if whitelist:
+      expected_files = whitelist
+    if blacklist:
+      expected_files = [f for f in expected_files if f not in blacklist]
+    assert sorted(expected_files) == sorted(found_files), (
+        sorted(expected_files), sorted(found_files))
 
   def commit(self, commit_message, user):
     """Commits, updates the commit message and pushes."""
     assert self.commit_user
     assert isinstance(commit_message, unicode)
     current_branch = self._check_output_git(
         ['rev-parse', '--abbrev-ref', 'HEAD']).strip()
     assert current_branch == self.working_branch
 
     commit_cmd = ['commit', '--amend', '-m', commit_message]
@@ skipping 78 matching lines @@
     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, post_processors=None, verbose=False,
-                  name=None, email=None):
+                  name=None, email=None, whitelist=None, blacklist=None):
+    if not whitelist:
+      whitelist = []
+    if not blacklist:
+      blacklist = []
     return self.checkout.apply_patch(
-        patches, post_processors or self.post_processors, verbose)
+        patches, post_processors or self.post_processors, verbose,
+        whitelist=whitelist,
+        blacklist=blacklist)
 
   def commit(self, message, user):  # pylint: disable=R0201
     logging.info('Would have committed for %s with message: %s' % (
         user, message))
     return 'FAKE'
 
   def revisions(self, rev1, rev2):
     return self.checkout.revisions(rev1, rev2)
 
   @property
   def project_name(self):
     return self.checkout.project_name
 
   @property
   def project_path(self):
     return self.checkout.project_path