Mark outdated branches on 'cl status'

git_cl.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.
 
 # Copyright (C) 2008 Evan Martin <martine@danga.com>
 
 """A git-command for integrating reviews on Rietveld and Gerrit."""
 
 from distutils.version import LooseVersion
@@ skipping 2894 matching lines @@
   return {
     'unsent': Fore.RED,
     'waiting': Fore.BLUE,
     'reply': Fore.YELLOW,
     'lgtm': Fore.GREEN,
     'commit': Fore.MAGENTA,
     'closed': Fore.CYAN,
     'error': Fore.WHITE,
   }.get(status, Fore.WHITE)
 
+def split_diff_files(diff):
+  """Splits a diff for the individual files and outputs a dict
+  {file name: diff}.
+  """
+  files = {}
+  current_lines = []
+  current_file = ''
+  def append():
+    if current_file:
+      files[current_file] = '\n'.join(current_lines+[''])
+  for line in diff.splitlines():
+    if line.startswith('Index: '):
+      continue
+    if line.startswith('diff '):
+      append()
+      current_lines = []
+      full_file_name = line.split()[-1]
+      current_file = '/'.join(full_file_name.split('/')[1:])
+      line = re.sub(' [ab]/'+re.escape(current_file), ' '+current_file, line)
+    if line.startswith('+++ ') or line.startswith('--- '):
+      line = re.sub(' [ab]/'+re.escape(current_file), ' '+current_file, line)
+    current_lines.append(line)
+  append()
+  return files
+
+def diff_compare(left, right):
+  """Compares two diffs without regarding actual file names, line number
+  information or commit hashes.
+  Returns True if they are equal, False otherwise.
+  """
+  file_pattern = re.compile('^(diff |\+\+\+ |--- ).*$', re.MULTILINE)
+  line_pattern = re.compile('^@@[ +\-0-9,]+@@', re.MULTILINE)
+  index_pattern = re.compile('^index [0-9a-f]+\.\.[0-9a-f]+', re.MULTILINE)
+  left = re.sub(line_pattern, '@@', re.sub(index_pattern, 'index',
+                                           re.sub(file_pattern, '\\1', left)))
+  right = re.sub(line_pattern, '@@', re.sub(index_pattern, 'index',
+                                            re.sub(file_pattern, '\\1', right)))
+  return left == right
+
+def fetch_cl_status(cl, auth_config=None):
+  """Fetches information for an issue and returns (cl, status, outdated).
+  """
+  status = cl.GetStatus()
+  outdated = False
+  if cl.GetIssue():
+    latest_patchset = cl.GetMostRecentPatchset()
+    uploaded_diff = cl.GetPatchSetDiff(cl.GetIssue(), latest_patchset)
+    uploaded_file_diffs = split_diff_files(uploaded_diff)
+    change = cl.GetChange(cl.GetCommonAncestorWithUpstream(), None)
+    local_file_diffs = {f.LocalPath(): f.GenerateScmDiff()
+                        for f in change.AffectedFiles()}
+    files = sorted(uploaded_file_diffs.keys())
+    if local_file_diffs and \
+            (files != sorted(local_file_diffs.keys()) or \
+             any(not diff_compare(uploaded_file_diffs[f], local_file_diffs[f])
+                 for f in uploaded_file_diffs.keys())):
+      outdated = True
+
+  return (cl, status, outdated)
+
 def get_cl_statuses(
     changes, fine_grained, max_processes=None, auth_config=None):
-  """Returns a blocking iterable of (cl, status) for given branches.
+  """Returns a blocking iterable of (cl, status, outdated) for given branches.
 
   If fine_grained is true, this will fetch CL statuses from the server.
   Otherwise, simply indicate if there's a matching url for the given branches.
 
   If max_processes is specified, it is used as the maximum number of processes
   to spawn to fetch CL status from the server. Otherwise 1 process per branch is
   spawned.
   """
   # Silence upload.py otherwise it becomes unwieldly.
   upload.verbosity = 0
 
   change_cls = [Changelist(branchref=c, auth_config=auth_config)
                 if type(c) is str else c for c in changes]
   if fine_grained:
     # Process one branch synchronously to work through authentication, then
     # spawn processes to process all the other branches in parallel.
     if changes:
-      fetch = lambda cl: (cl, cl.GetStatus())
-      yield fetch(change_cls[0])
+      yield fetch_cl_status(change_cls[0])
 
       changes_to_fetch = change_cls[1:]
       pool = ThreadPool(
           min(max_processes, len(changes_to_fetch))
               if max_processes is not None
               else len(changes_to_fetch))
-      for x in pool.imap_unordered(fetch, changes_to_fetch):
+      for x in pool.imap_unordered(fetch_cl_status, changes_to_fetch):
         yield x
   else:
     # Do not use GetApprovingReviewers(), since it requires an HTTP request.
     for cl in change_cls:
-      yield (cl, 'waiting' if cl.GetIssueURL() else 'error')
+      yield (cl, 'waiting' if cl.GetIssueURL() else 'error', False)
 
 
 def upload_branch_deps(cl, args):
   """Uploads CLs of local branches that are dependents of the current branch.
 
   If the local branch dependency tree looks like:
   test1 -> test2.1 -> test3.1
                    -> test3.2
         -> test2.2 -> test3.3
 
@@ skipping 145 matching lines @@
   print 'Branches associated with reviews:'
   output = get_cl_statuses(changes,
                            fine_grained=not options.fast,
                            max_processes=options.maxjobs)
 
   branch_statuses = {}
   alignment = max(5, max(len(ShortBranchName(c.GetBranch())) for c in changes))
   for cl in sorted(changes, key=lambda c: c.GetBranch()):
     branch = cl.GetBranch()
     while branch not in branch_statuses:
-      c, status = output.next()
-      branch_statuses[c.GetBranch()] = status
-    status = branch_statuses.pop(branch)
+      c, status, outdated = output.next()
+      branch_statuses[c.GetBranch()] = (status, outdated)
+    status, outdated = branch_statuses.pop(branch)
     url = cl.GetIssueURL()
     if url and (not status or status == 'error'):
       # The issue probably doesn't exist anymore.
       url += ' (broken)'
-
-    color = color_for_status(status)
-    reset = Fore.RESET
-    if not setup_color.IS_TTY:
-      color = ''
-      reset = ''
+    make_color = lambda c : c if setup_color.IS_TTY else ''
+    color = make_color(color_for_status(status))
+    reset = make_color(Fore.RESET)
+    color_outdated = make_color(Fore.RED)
     status_str = '(%s)' % status if status else ''
-    print '  %*s : %s%s %s%s' % (
-          alignment, ShortBranchName(branch), color, url,
+    outdated_str = '%soutdated%s ' % (color_outdated, color) if outdated else ''
+    print '  %*s : %s%s %s%s%s' % (
+          alignment, ShortBranchName(branch), color, url, outdated_str,
           status_str, reset)
 
   cl = Changelist(auth_config=auth_config)
   print
   print 'Current branch:',
   print cl.GetBranch()
   if not cl.GetIssue():
     print 'No issue assigned.'
     return 0
   print 'Issue number: %s (%s)' % (cl.GetIssue(), cl.GetIssueURL())
@@ skipping 1708 matching lines @@
 if __name__ == '__main__':
   # These affect sys.stdout so do it outside of main() to simplify mocks in
   # unit testing.
   fix_encoding.fix_encoding()
   setup_color.init()
   try:
     sys.exit(main(sys.argv[1:]))
   except KeyboardInterrupt:
     sys.stderr.write('interrupted\n')
     sys.exit(1)