Get presubmit_support to compute diffs against a given upstream.

presubmit_support.py

 #!/usr/bin/env python
 # 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.
 
 """Enables directory-specific presubmit checks to run at upload and/or commit.
 """
 
 __version__ = '1.8.0'
 
@@ skipping 482 matching lines @@
       msgs.extend(pool.map_async(CallCommand, tests).get(99999))
       pool.close()
       pool.join()
     else:
       msgs.extend(map(CallCommand, tests))
     return [m for m in msgs if m]
 
 
 class _DiffCache(object):
   """Caches diffs retrieved from a particular SCM."""
+  def __init__(self, upstream=None):
+    """Stores the upstream revision against which all diffs will be computed."""
+    self._upstream = upstream
 
   def GetDiff(self, path, local_root):
     """Get the diff for a particular path."""
     raise NotImplementedError()
 
 
 class _SvnDiffCache(_DiffCache):
   """DiffCache implementation for subversion."""
-  def __init__(self):
-    super(_SvnDiffCache, self).__init__()
+  def __init__(self, *args, **kwargs):
+    super(_SvnDiffCache, self).__init__(*args, **kwargs)
     self._diffs_by_file = {}
 
   def GetDiff(self, path, local_root):
     if path not in self._diffs_by_file:
       self._diffs_by_file[path] = scm.SVN.GenerateDiff([path], local_root,
                                                        False, None)
     return self._diffs_by_file[path]
 
 
 class _GitDiffCache(_DiffCache):
   """DiffCache implementation for git; gets all file diffs at once."""
-  def __init__(self):
-    super(_GitDiffCache, self).__init__()
+  def __init__(self, upstream):
+    super(_GitDiffCache, self).__init__(upstream=upstream)
     self._diffs_by_file = None
 
   def GetDiff(self, path, local_root):
     if not self._diffs_by_file:
       # Compute a single diff for all files and parse the output; should
       # with git this is much faster than computing one diff for each file.
       diffs = {}
 
       # Don't specify any filenames below, because there are command line length
       # limits on some platforms and GenerateDiff would fail.
-      unified_diff = scm.GIT.GenerateDiff(local_root, files=[], full_move=True)
+      unified_diff = scm.GIT.GenerateDiff(local_root, files=[], full_move=True,
+                                          branch=self._upstream)
 
       # This regex matches the path twice, separated by a space. Note that
       # filename itself may contain spaces.
       file_marker = re.compile('^diff --git (?P<filename>.*) (?P=filename)$')
       current_diff = []
       keep_line_endings = True
       for x in unified_diff.splitlines(keep_line_endings):
         match = file_marker.match(x)
         if match:
           # Marks the start of a new per-file section.
@@ skipping 13 matching lines @@
     return self._diffs_by_file[path]
 
 
 class AffectedFile(object):
   """Representation of a file in a change."""
 
   DIFF_CACHE = _DiffCache
 
   # Method could be a function
   # pylint: disable=R0201
-  def __init__(self, path, action, repository_root, diff_cache=None):
+  def __init__(self, path, action, repository_root, diff_cache):
     self._path = path
     self._action = action
     self._local_root = repository_root
     self._is_directory = None
     self._properties = {}
     self._cached_changed_contents = None
     self._cached_new_contents = None
-    if diff_cache:
-      self._diff_cache = diff_cache
-    else:
-      self._diff_cache = self.DIFF_CACHE()
+    self._diff_cache = diff_cache
     logging.debug('%s(%s)' % (self.__class__.__name__, self._path))
 
   def ServerPath(self):
     """Returns a path string that identifies the file in the SCM system.
 
     Returns the empty string if the file does not exist in SCM.
     """
     return ''
 
   def LocalPath(self):
@@ skipping 193 matching lines @@
   """
 
   _AFFECTED_FILES = AffectedFile
 
   # Matches key/value (or "tag") lines in changelist descriptions.
   TAG_LINE_RE = re.compile(
       '^[ \t]*(?P<key>[A-Z][A-Z_0-9]*)[ \t]*=[ \t]*(?P<value>.*?)[ \t]*$')
   scm = ''
 
   def __init__(
-      self, name, description, local_root, files, issue, patchset, author):
+      self, name, description, local_root, files, issue, patchset, author,
+      upstream=None):
     if files is None:
       files = []
     self._name = name
     # Convert root into an absolute path.
     self._local_root = os.path.abspath(local_root)
+    self._upstream = upstream
     self.issue = issue
     self.patchset = patchset
     self.author_email = author
 
     self._full_description = ''
     self.tags = {}
     self._description_without_tags = ''
     self.SetDescriptionText(description)
 
     assert all(
         (isinstance(f, (list, tuple)) and len(f) == 2) for f in files), files
 
-    diff_cache = self._AFFECTED_FILES.DIFF_CACHE()
+    diff_cache = self._AFFECTED_FILES.DIFF_CACHE(self._upstream)
     self._affected_files = [
         self._AFFECTED_FILES(path, action.strip(), self._local_root, diff_cache)
         for action, path in files
     ]
 
   def Name(self):
     """Returns the change name."""
     return self._name
 
   def DescriptionText(self):
@@ skipping 781 matching lines @@
         def default(self, obj):
           if isinstance(obj, set):
             return sorted(obj)
           return json.JSONEncoder.default(self, obj)
       change = change_class(options.name,
                       options.description,
                       options.root,
                       files,
                       options.issue,
                       options.patchset,
-                      options.author)
+                      options.author,
+                      upstream=options.upstream)
       trybots = DoGetTrySlaves(
           change,
           change.LocalPaths(),
           change.RepositoryRoot(),
           None,
           None,
           options.verbose,
           sys.stdout)
       json.dump(trybots, f, cls=SetEncoder)
   try:
     with canned_check_filter(options.skip_canned):
       results = DoPresubmitChecks(
           change_class(options.name,
                       options.description,
                       options.root,
                       files,
                       options.issue,
                       options.patchset,
-                      options.author),
+                      options.author,
+                      upstream=options.upstream),
           options.commit,
           options.verbose,
           sys.stdout,
           sys.stdin,
           options.default_presubmit,
           options.may_prompt,
           rietveld_obj)
     return not results.should_continue()
   except NonexistantCannedCheckFilter, e:
     print >> sys.stderr, (
       'Attempted to skip nonexistent canned presubmit check: %s' % e.message)
     return 2
   except PresubmitFailure, e:
     print >> sys.stderr, e
     print >> sys.stderr, 'Maybe your depot_tools is out of date?'
     print >> sys.stderr, 'If all fails, contact maruel@'
     return 2
 
 
 if __name__ == '__main__':
   fix_encoding.fix_encoding()
   sys.exit(Main(None))