Add "archive" command to git_cl.py.

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 2911 matching lines @@
 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)
+  return (branch, cl.GetIssue(), url, status)
 
 def get_cl_statuses(
     branches, fine_grained, max_processes=None, auth_config=None):
-  """Returns a blocking iterable of (branch, issue, status) for given branches.
+  """Returns a blocking iterable of (branch, issue ID, issue URL, status) 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.
 
   See GetStatus() for a list of possible statuses.
   """
   def fetch(branch):
     if not branch:
       return None
 
     return fetch_cl_status(branch, auth_config=auth_config)
 
   # Silence upload.py otherwise it becomes unwieldly.
   upload.verbosity = 0
 
   if fine_grained:
     # Process one branch synchronously to work through authentication, then
     # spawn processes to process all the other branches in parallel.
     if branches:
 
       yield fetch(branches[0])
 
       branches_to_fetch = branches[1:]
+      if len(branches_to_fetch) == 0:
+        # Exit early if there was only one branch to fetch.
+        return

[tandrii(chromium), 2016/05/20 20:56:19]

are you sure this works? I thought return can't be inside a function that uses
yield. You have to use raise StopIteration instead.

[Kevin M, 2016/05/20 22:18:14]

"return" from a generator raises a StopIteration.

+
       pool = ThreadPool(
           min(max_processes, len(branches_to_fetch))
               if max_processes is not None
               else len(branches_to_fetch))
 
       fetched_branches = set()
       it = pool.imap_unordered(fetch, branches_to_fetch).__iter__()
       while True:
         try:
           row = it.next(timeout=5)
         except multiprocessing.TimeoutError:
           break
 
         fetched_branches.add(row[0])
         yield row
 
       # Add any branches that failed to fetch.
       for b in set(branches_to_fetch) - fetched_branches:
         cl = Changelist(branchref=b, auth_config=auth_config)
-        yield (b, cl.GetIssueURL() if b else None, 'error')
+        yield (b, cl.GetIssue(), cl.GetIssueURL() if b else None, 'error')
 
   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() if b else None
-      yield (b, url, 'waiting' if url else 'error')
+      yield (b, cl.GetIssue(), url, 'waiting' if url 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 81 matching lines @@
 
   print
   print 'Upload complete for dependent branches!'
   for dependent_branch in dependents:
     upload_status = 'failed' if failures.get(dependent_branch) else 'succeeded'
     print '  %s : %s' % (dependent_branch, upload_status)
   print
 
   return 0
 
+def CMDcleanup(parser, args):
+  """Archives closed branches from the Git using tags and removes them from
+  the Git branch list."""
+  parser.add_option(
+      '-j', '--maxjobs', action='store', type=int,
+      help='The maximum number of jobs to use when retrieving review status')
+
+  parser.add_option(
+      '-y', action='store_true', dest='no_prompt', default=False,

[tandrii(chromium), 2016/05/20 20:56:19]

-f, --force to be inline with other cmds.

[Kevin M, 2016/05/20 22:18:14]

Done.

+      help='Bypasses the confirmation prompt.')
+
+  auth.add_auth_options(parser)
+  options, args = parser.parse_args(args)
+  if args:
+    parser.error('Unsupported args: %s' % args)
+  auth_config = auth.extract_auth_config_from_options(options)
+
+  branches = RunGit(['for-each-ref', '--format=%(refname)', 'refs/heads'])
+  if not branches:
+    print('No local branch found.')

[tandrii(chromium), 2016/05/20 20:56:19]

nit: why parenthesis here and not below?

[Kevin M, 2016/05/20 22:18:14]

C++ habits, I guess. Done.

+    return 0
+
+  print 'Finding all branches associated with closed issues...'
+  changes = (
+      Changelist(branchref=b, auth_config=auth_config)
+      for b in branches.splitlines())
+  branches = [c.GetBranch() for c in changes]

[martiniss, 2016/05/20 03:11:55]

Any reason to not combine this and the previous line?

[Kevin M, 2016/05/20 16:54:41]

No reason other than avoiding nested list comprehension. But if you're fine with
it, I'm fine with it.

Done.

+  alignment = max(5, max(len(b) for b in branches))
+  branch_statuses = get_cl_statuses(branches,
+                                    fine_grained=True,
+                                    max_processes=options.maxjobs,
+                                    auth_config=auth_config)
+  proposal = [(branch, 'submitted-%s-%s' % (branch, issue_id))
+              for branch, issue_id, _, status in branch_statuses
+              if status == 'closed']
+
+  if len(proposal) == 0:
+    print 'No closed branches found.'
+    return 0
+
+  print '\nBranches with closed issues that will be tagged and deleted:'
+  print "%*s | %s" % (alignment, "Branch name", "Archival tag name")
+  for next_item in proposal:
+    print '%*s   %s' % (alignment, next_item[0], next_item[1])
+
+  prompt = None
+  if not options.no_prompt:
+    prompt = raw_input('\nProceed with deletion (Y/N)? ')
+  if prompt == 'Y' or prompt == 'y' or options.no_prompt:
+    for next_item in proposal:
+      branch, tagname = next_item
+      RunGit(['tag', tagname, branch])

[martiniss, 2016/05/20 03:11:55]

What is the purpose of tagging the branch? Bookkeeping in case you look it up
later?

Personally I would just look at my closed CLs on the codereview site, but I can
understand if you want this.

[Kevin M, 2016/05/20 16:54:41]

The tags allow you to access your local Git commit history, which isn't
propagated when you upload your patches or land your code.

+      RunGit(['branch', '-D', branch])
+    print '\nJob\'s done!'
+  else:
+    print 'Aborted.'
+
+  return 0
 
 def CMDstatus(parser, args):
   """Show status of changelists.
 
   Colors are used to tell the state of the CL unless --fast is used:
     - Red      not sent for review or broken
     - Blue     waiting for review
     - Yellow   waiting for you to reply to review
     - Green    LGTM'ed
     - Magenta  in the commit queue
@@ skipping 47 matching lines @@
   print 'Branches associated with reviews:'
   output = get_cl_statuses(branches,
                            fine_grained=not options.fast,
                            max_processes=options.maxjobs,
                            auth_config=auth_config)
 
   branch_statuses = {}
   alignment = max(5, max(len(ShortBranchName(b)) for b in branches))
   for branch in sorted(branches):
     while branch not in branch_statuses:
-      b, i, status = output.next()
+      b, _, i, status = output.next()
       branch_statuses[b] = (i, status)
     issue_url, status = branch_statuses.pop(branch)
     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,
@@ skipping 1731 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)