Use CLs more consistently instead of branch names

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
 from multiprocessing.pool import ThreadPool
 import base64
 import collections
 import glob
 import httplib
 import json
 import logging
 import optparse
 import os
-import Queue
 import re
 import stat
 import sys
-import tempfile
 import textwrap
 import time
 import traceback
 import urllib
 import urllib2
 import urlparse
 import uuid
 import webbrowser
 import zlib
 
@@ skipping 2121 matching lines @@
         # Some reply from non-owner.
         return 'reply'
 
     return 'waiting'
 
   def GetMostRecentPatchset(self):
     data = self._GetChangeDetail(['CURRENT_REVISION'])
     return data['revisions'][data['current_revision']]['_number']
 
   def FetchDescription(self):
     data = self._GetChangeDetail(['CURRENT_REVISION'])

[tandrii(chromium), 2016/04/26 09:49:51]

argh, rebase artifact.

     current_rev = data['current_revision']
     url = data['revisions'][current_rev]['fetch']['http']['url']
     return gerrit_util.GetChangeDescriptionFromGitiles(url, current_rev)
 
   def UpdateDescriptionRemote(self, description):
     # TODO(tandrii)
     raise NotImplementedError()
 
   def CloseIssue(self):
     gerrit_util.AbandonChange(self._GetGerritHost(), self.GetIssue(), msg='')
@@ skipping 717 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 fetch_cl_status(branch, auth_config=None):
-  """Fetches information for an issue and returns (branch, issue, status)."""
-  cl = Changelist(branchref=branch, auth_config=auth_config)
-  url = cl.GetIssueURL()
-  status = cl.GetStatus()
-
-  if url and (not status or status == 'error'):
-    # The issue probably doesn't exist anymore.
-    url += ' (broken)'
-
-  return (branch, url, status)
-
 def get_cl_statuses(
-    branches, fine_grained, max_processes=None, auth_config=None):
-  """Returns a blocking iterable of (branch, issue, color) for given branches.
+    changes, fine_grained, max_processes=None, auth_config=None):
+  """Returns a blocking iterable of (cl, status) for given branches.

[tandrii(chromium), 2016/04/26 09:49:51]

s/for given branches/for given changelists

 
   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

[tandrii(chromium), 2016/04/26 09:49:51]

s/branch/Changelist

   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]

[tandrii(chromium), 2016/04/26 09:49:51]

Let's keep get_cl_statuses() API clear: changes is list is of changelists, not
branches. And let BranchMapper comply with it by creating the list. Which means
same as your PS#3 + 2 line change in map branches.

   if fine_grained:
     # Process one branch synchronously to work through authentication, then
     # spawn processes to process all the other branches in parallel.
-    if branches:
-      fetch = lambda branch: fetch_cl_status(branch, auth_config=auth_config)
-      yield fetch(branches[0])
+    if changes:
+      fetch = lambda cl: (cl, cl.GetStatus())
+      yield fetch(change_cls[0])
 
-      branches_to_fetch = branches[1:]
+      changes_to_fetch = change_cls[1:]
       pool = ThreadPool(
-          min(max_processes, len(branches_to_fetch))
+          min(max_processes, len(changes_to_fetch))
               if max_processes is not None
-              else len(branches_to_fetch))
-      for x in pool.imap_unordered(fetch, branches_to_fetch):
+              else len(changes_to_fetch))
+      for x in pool.imap_unordered(fetch, changes_to_fetch):
         yield x
   else:
     # Do not use GetApprovingReviewers(), since it requires an HTTP request.
-    for b in branches:
-      cl = Changelist(branchref=b, auth_config=auth_config)
-      url = cl.GetIssueURL()
-      yield (b, url, 'waiting' if url else 'error')
+    for cl in change_cls:
+      yield (cl, 'waiting' if cl.GetIssueURL() else 'error')
 
 
 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 132 matching lines @@
       url = cl.GetIssueURL()
       if url:
         print url
     return 0
 
   branches = RunGit(['for-each-ref', '--format=%(refname)', 'refs/heads'])
   if not branches:
     print('No local branch found.')
     return 0
 
-  changes = (
+  changes = [
       Changelist(branchref=b, auth_config=auth_config)
-      for b in branches.splitlines())
-  # TODO(tandrii): refactor to use CLs list instead of branches list.
-  branches = [c.GetBranch() for c in changes]
-  alignment = max(5, max(len(b) for b in branches))
+      for b in branches.splitlines()]
   print 'Branches associated with reviews:'
-  output = get_cl_statuses(branches,
+  output = get_cl_statuses(changes,
                            fine_grained=not options.fast,
-                           max_processes=options.maxjobs,
-                           auth_config=auth_config)
+                           max_processes=options.maxjobs)
 
   branch_statuses = {}
-  alignment = max(5, max(len(ShortBranchName(b)) for b in branches))
-  for branch in sorted(branches):
+  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:
-      b, i, status = output.next()
-      branch_statuses[b] = (i, status)
-    issue_url, status = branch_statuses.pop(branch)
+      c, status = output.next()
+      branch_statuses[c.GetBranch()] = status
+    status = 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 = ''
     status_str = '(%s)' % status if status else ''
     print '  %*s : %s%s %s%s' % (
-          alignment, ShortBranchName(branch), color, issue_url, status_str,
-          reset)
+          alignment, ShortBranchName(branch), color, url,
+          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())
   if not options.fast:
@@ skipping 1690 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)