Use function decorator to simplify main()

gcl.py

 #!/usr/bin/python
 # Copyright (c) 2006-2009 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.
 
 """Wrapper script around Rietveld's upload.py that groups files into
 changelists."""
 
 import getpass
 import os
 import random
 import re
 import shutil
 import string
 import subprocess
 import sys
 import tempfile
 import time
 from third_party import upload
 import urllib2
 
 __pychecker__ = 'unusednames=breakpad'
 import breakpad
 __pychecker__ = ''
 
 # gcl now depends on gclient.
 from scm import SVN
 import gclient_utils
 
-__version__ = '1.1.3'
+__version__ = '1.1.4'
 
 
 CODEREVIEW_SETTINGS = {
   # Ideally, we want to set |CODE_REVIEW_SERVER| to a generic server like
   # codereview.appspot.com and remove |CC_LIST| and |VIEW_VC|. In practice, we
   # need these settings so developers making changes in directories such as
   # Chromium's src/third_party/WebKit will send change lists to the correct
   # server.
   #
   # To make gcl send reviews to a different server, check in a file named
@@ skipping 33 matching lines @@
   if sys.platform in ('cygwin', 'win32'):
     home_vars.append('USERPROFILE')
   for home_var in home_vars:
     home = os.getenv(home_var)
     if home != None:
       full_path = os.path.join(home, filename)
       if os.path.exists(full_path):
         return full_path
   return None
 
+
 def UnknownFiles(extra_args):
   """Runs svn status and returns unknown files.
 
   Any args in |extra_args| are passed to the tool to support giving alternate
   code locations.
   """
   return [item[1] for item in SVN.CaptureStatus(extra_args)
           if item[0][0] == '?']
 
 
@@ skipping 521 matching lines @@
   if (files.get('') or (show_unknown_files and len(unknown_files))):
     print "\n--- Not in any changelist:"
     for item in files.get('', []):
       print "".join(item)
     if show_unknown_files:
       for filename in unknown_files:
         print "?      %s" % filename
   return 0
 
 
-def CMDopened(argv):
+def CMDopened(args):
   """Lists modified files in the current directory down."""
-  __pychecker__ = 'unusednames=argv'
+  if args:
+    ErrorExit("Doesn't support arguments")
   return ListFiles(False)
 
 
-def CMDstatus(argv):
+def CMDstatus(args):
   """Lists modified and unknown files in the current directory down."""
-  __pychecker__ = 'unusednames=argv'
+  if args:
+    ErrorExit("Doesn't support arguments")
   return ListFiles(True)
 
 
-def CMDhelp(argv=None):
+def CMDhelp(args):
   """Prints this help or help for the given command."""
-  if argv and len(argv) > 2:
-    if argv[2] == 'try':
-      TryChange(None, ['--help'], swallow_exception=False)
-      return 0
-    if argv[2] == 'upload':
+  if args and len(args) > 2:
+    if args[2] == 'try':
+      return TryChange(None, ['--help'], swallow_exception=False)
+    if args[2] == 'upload':
       upload.RealMain(['upload.py', '--help'])
       return 0
 
   print (
 """GCL is a wrapper for Subversion that simplifies working with groups of files.
 version """ + __version__ + """
 
 Basic commands:
 -----------------------------------------
    gcl change change_name
@@ skipping 83 matching lines @@
 def GenerateDiff(files, root=None):
   return SVN.GenerateDiff(files, root=root)
 
 
 def OptionallyDoPresubmitChecks(change_info, committing, args):
   if FilterFlag(args, "--no_presubmit") or FilterFlag(args, "--force"):
     return True
   return DoPresubmitChecks(change_info, committing, True)
 
 
-def CMDupload(change_info, args):
+def need_change(function):
+  """Converts args -> change_info."""
+  def hook(args):
+    if not len(args) == 1:
+      ErrorExit("You need to pass a change list name")
+    change_info = ChangeInfo.Load(args[0], GetRepositoryRoot(), True, True)
+    return function(change_info)
+  return hook
+
+
+def CMDupload(args):
+  if not args:
+    ErrorExit("You need to pass a change list name")
+  change_info = ChangeInfo.Load(args.pop(0), GetRepositoryRoot(), True, True)
   if not change_info.GetFiles():
     print "Nothing to upload, changelist is empty."
-    return
+    return 0
   if not OptionallyDoPresubmitChecks(change_info, False, args):
-    return
+    return 1
   # Might want to support GetInfoDir()/GetRepositoryRoot() like
   # CheckHomeForFile() so the skip of tries can be per tree basis instead
   # of user global.
   no_try = FilterFlag(args, "--no_try") or \
            FilterFlag(args, "--no-try") or \
            not (CheckHomeForFile(".gcl_upload_no_try") is None)
   no_watchlists = FilterFlag(args, "--no_watchlists") or \
                   FilterFlag(args, "--no-watchlists")
 
   # Map --send-mail to --send_mail
@@ skipping 86 matching lines @@
   # consistent.
   os.chdir(previous_cwd)
 
   # Once uploaded to Rietveld, send it to the try server.
   if not no_try:
     try_on_upload = GetCodeReviewSetting('TRY_ON_UPLOAD')
     if try_on_upload and try_on_upload.lower() == 'true':
       trychange_args = []
       if clobber:
         trychange_args.append('--clobber')
-      TryChange(change_info, trychange_args, swallow_exception=True)
+      return TryChange(change_info, trychange_args, swallow_exception=True)
+  return 0
 
 
-
-def CMDpresubmit(change_info, argv):
+@need_change
+def CMDpresubmit(change_info):
   """Runs presubmit checks on the change."""
-  __pychecker__ = 'unusednames=argv'
   if not change_info.GetFiles():
     print "Nothing to presubmit check, changelist is empty."
     return 0
 
   print "*** Presubmit checks for UPLOAD would report: ***"
   result = DoPresubmitChecks(change_info, False, False)
 
   print "\n*** Presubmit checks for COMMIT would report: ***"
   result &= DoPresubmitChecks(change_info, True, False)
   return not result
 
 
 def TryChange(change_info, args, swallow_exception):
   """Create a diff file of change_info and send it to the try server."""
   try:
     import trychange
   except ImportError:
     if swallow_exception:
-      return
+      return 1
     ErrorExit("You need to install trychange.py to use the try server.")
 
   trychange_args = []
   if change_info:
     trychange_args.extend(['--name', change_info.name])
     if change_info.issue:
       trychange_args.extend(["--issue", str(change_info.issue)])
     if change_info.patchset:
       trychange_args.extend(["--patchset", str(change_info.patchset)])
     trychange_args.extend(args)
     file_list = change_info.GetFileNames()
   else:
     trychange_args.extend(args)
     file_list = None
-  trychange.TryChange(trychange_args,
-                      file_list=file_list,
-                      swallow_exception=swallow_exception,
-                      prog='gcl try')
+  return trychange.TryChange(trychange_args,
+                             file_list=file_list,
+                             swallow_exception=swallow_exception,
+                             prog='gcl try')
 
 
-def CMDcommit(change_info, args):
+@need_change
+def CMDcommit(change_info):
   if not change_info.GetFiles():
     print "Nothing to commit, changelist is empty."
     return 1
   if not OptionallyDoPresubmitChecks(change_info, True, args):
     return 1
 
   # We face a problem with svn here: Let's say change 'bleh' modifies
   # svn:ignore on dir1\. but another unrelated change 'pouet' modifies
   # dir1\foo.cc. When the user `gcl commit bleh`, foo.cc is *also committed*.
   # The only fix is to use --non-recursive but that has its issues too:
@@ skipping 36 matching lines @@
                             re.DOTALL).match(output).group(1)
       viewvc_url = GetCodeReviewSetting("VIEW_VC")
       change_info.description = change_info.description + '\n'
       if viewvc_url:
         change_info.description += "\nCommitted: " + viewvc_url + revision
       change_info.CloseIssue()
   os.chdir(previous_cwd)
   return 0
 
 
-def CMDchange(change_info, args):
+def CMDchange(args):
   """Creates/edits a changelist."""
+  if len(args) == 0:
+    # Generate a random changelist name.
+    changename = GenerateChangeName()
+  elif args[0] == '--force':
+    changename = GenerateChangeName()
+  else:
+    changename = args[0]
+  change_info = ChangeInfo.Load(changename, GetRepositoryRoot(), False, True)
   silent = FilterFlag(args, "--silent")
 
   # Verify the user is running the change command from a read-write checkout.
   svn_info = SVN.CaptureInfo('.')
   if not svn_info:
     ErrorExit("Current checkout is unversioned.  Please retry with a versioned "
               "directory.")
 
-  if (len(args) == 1):
-    filename = args[0]
-    f = open(filename, 'rU')
+  if len(args) == 2:
+    f = open(args[1], 'rU')
     override_description = f.read()
     f.close()
   else:
     override_description = None
 
   if change_info.issue and not change_info.NeedsUpload():
     try:
       description = GetIssueDescription(change_info.issue)
     except urllib2.HTTPError, err:
       if err.code == 404:
@@ skipping 81 matching lines @@
     Warn("WARNING: " + MISSING_TEST_MSG)
 
   # Update the Rietveld issue.
   if change_info.issue and change_info.NeedsUpload():
     change_info.UpdateRietveldDescription()
     change_info.needs_upload = False
     change_info.Save()
   return 0
 
 
-def CMDlint(change_info, args):
+@need_change
+def CMDlint(change_info):
   """Runs cpplint.py on all the files in |change_info|"""
   try:
     import cpplint
   except ImportError:
     ErrorExit("You need to install cpplint.py to lint C++ files.")
-
   # Change the current working directory before calling lint so that it
   # shows the correct base.
   previous_cwd = os.getcwd()
   os.chdir(change_info.GetLocalRoot())
 
   # Process cpplints arguments if any.
   filenames = cpplint.ParseArguments(args + change_info.GetFileNames())
 
   white_list = GetCodeReviewSetting("LINT_REGEX")
   if not white_list:
@@ skipping 33 matching lines @@
                                                verbose=False,
                                                output_stream=sys.stdout,
                                                input_stream=sys.stdin,
                                                default_presubmit=root_presubmit,
                                                may_prompt=may_prompt)
   if not result and may_prompt:
     print "\nPresubmit errors, can't continue (use --no_presubmit to bypass)"
   return result
 
 
-def CMDchanges(argv):
+def CMDchanges(args):
   """Lists all the changelists and their files."""
-  __pychecker__ = 'unusednames=argv'
+  if args:
+    ErrorExit("Doesn't support arguments")
   for cl in GetCLs():
     change_info = ChangeInfo.Load(cl, GetRepositoryRoot(), True, True)
     print "\n--- Changelist " + change_info.name + ":"
     for filename in change_info.GetFiles():
       print "".join(filename)
   return 0
 
 
-def CMDdeleteempties(argv):
+def CMDdeleteempties(args):
   """Delete all changelists that have no files."""
-  __pychecker__ = 'unusednames=argv'
+  if args:
+    ErrorExit("Doesn't support arguments")
   print "\n--- Deleting:"
   for cl in GetCLs():
     change_info = ChangeInfo.Load(cl, GetRepositoryRoot(), True, True)
     if not len(change_info._files):
       print change_info.name
       change_info.Delete()
   return 0
 
 
-def CMDnothave(argv):
+def CMDnothave(args):
   """Lists files unknown to Subversion."""
-  __pychecker__ = 'unusednames=argv'
-  for filename in UnknownFiles(argv[2:]):
+  if args:
+    ErrorExit("Doesn't support arguments")
+  for filename in UnknownFiles(args):
     print "?      " + "".join(filename)
   return 0
 
 
-def CMDdiff(argv):
+def CMDdiff(args):
   """Diffs all files in the changelist."""
-  __pychecker__ = 'unusednames=argv'
-  files = GetFilesNotInCL()
-  print GenerateDiff([x[1] for x in files])
-  return 0
+  files = None
+  if args:
+    change_info = ChangeInfo.Load(args[0], GetRepositoryRoot(), True, True)
+    args.pop(0)
+    files = change_info.GetFileNames()
+  else:
+    files = GetFilesNotInCL()
+  return RunShellWithReturnCode(['svn', 'diff'] + files + args,
+                                print_output=True)[1]
 
 
-def CMDsettings(argv):
+def CMDsettings(args):
   """Prints code review settings."""
-  __pychecker__ = 'unusednames=argv'
+  __pychecker__ = 'unusednames=args'
   # Force load settings
   GetCodeReviewSetting("UNKNOWN");
   del CODEREVIEW_SETTINGS['__just_initialized']
   print '\n'.join(("%s: %s" % (str(k), str(v))
                     for (k,v) in CODEREVIEW_SETTINGS.iteritems()))
   return 0
 
 
-def CMDdescription(change_info, argv):
+@need_change
+def CMDdescription(change_info):
   """Prints the description of the specified change to stdout."""
-  __pychecker__ = 'unusednames=argv'
   print change_info.description
   return 0
 
 
-def CMDdelete(change_info, argv):
+@need_change
+def CMDdelete(change_info):
   """Deletes a changelist."""
-  __pychecker__ = 'unusednames=argv'
   change_info.Delete()
   return 0
 
 
-def CMDtry(change_info, argv):
+def CMDtry(args):
   """Sends the change to the tryserver so a trybot can do a test run on your
   code.
 
   To send multiple changes as one path, use a comma-separated list of
   changenames. Use 'gcl help try' for more information!"""
   # When the change contains no file, send the "changename" positional
   # argument to trychange.py.
-  __pychecker__ = 'unusednames=argv'
+  # When the command is 'try' and --patchset is used, the patch to try
+  # is on the Rietveld server.
+  if not args:
+    ErrorExit("You need to pass a change list name")
+  if args[0].find(',') != -1:
+    change_info = LoadChangelistInfoForMultiple(args[0], GetRepositoryRoot(),
+                                                True, True)
+  else:
+    change_info = ChangeInfo.Load(args[0], GetRepositoryRoot(),
+                                  False, True)
   if change_info.GetFiles():
-    args = argv[3:]
+    args = args[1:]
   else:
     change_info = None
-    args = argv[2:]
-  TryChange(change_info, args, swallow_exception=False)
-  return 0
+  return TryChange(change_info, args, swallow_exception=False)
 
 
-def CMDrename(argv):
+def CMDrename(args):
   """Renames an existing change."""
-  if len(argv) != 4:
+  if len(args) != 2:
     ErrorExit("Usage: gcl rename <old-name> <new-name>.")
-  src, dst = argv[2:4]
+  src, dst = args
   src_file = GetChangelistInfoFile(src)
   if not os.path.isfile(src_file):
     ErrorExit("Change '%s' does not exist." % src)
   dst_file = GetChangelistInfoFile(dst)
   if os.path.isfile(dst_file):
     ErrorExit("Change '%s' already exists; pick a new name." % dst)
   os.rename(src_file, dst_file)
   print "Change '%s' renamed '%s'." % (src, dst)
   return 0
 
 
-def main(argv=None):
+def CMDpassthru(args):
+  # Everything else that is passed into gcl we redirect to svn, after adding
+  # the files.
+  # args is guaranteed to be len(args) >= 1
+  args = ["svn", args[0]]
+  if len(args) > 1:
+    root = GetRepositoryRoot()
+    change_info = ChangeInfo.Load(args[1], root, True, True)
+    args.extend([os.path.join(root, x) for x in change_info.GetFileNames()])
+  return RunShellWithReturnCode(args, print_output=True)[1]
+
+
+def main(argv):
   __pychecker__ = 'maxreturns=0'
-  if argv is None:
-    argv = sys.argv
-
-  if len(argv) == 1:
-    return CMDhelp()
-
   try:
     # Create the directories where we store information about changelists if it
     # doesn't exist.
     if not os.path.exists(GetInfoDir()):
       os.mkdir(GetInfoDir())
     if not os.path.exists(GetChangesDir()):
       os.mkdir(GetChangesDir())
     if not os.path.exists(GetCacheDir()):
       os.mkdir(GetCacheDir())
   except gclient_utils.Error:
     # Will throw an exception if not run in a svn checkout.
     pass
 
+  if not argv:
+    argv = ['help']
   # Commands that don't require an argument.
-  command = argv[1]
+  command = argv[0]
   if command == "opened":
-    return CMDopened(argv)
+    return CMDopened(argv[1:])
   if command == "status":
-    return CMDstatus(argv)
+    return CMDstatus(argv[1:])
   if command == "nothave":
-    return CMDnothave(argv)
+    return CMDnothave(argv[1:])
   if command == "changes":
-    return CMDchanges(argv)
+    return CMDchanges(argv[1:])
   if command == "help":
-    return CMDhelp(argv)
-  if command == "diff" and len(argv) == 2:
-    return CMDdiff(argv)
+    return CMDhelp(argv[1:])
+  if command == "diff":
+    return CMDdiff(argv[1:])
   if command == "settings":
-    return CMDsettings(argv)
+    return CMDsettings(argv[1:])
   if command == "deleteempties":
-    return CMDdeleteempties(argv)
+    return CMDdeleteempties(argv[1:])
   if command == "rename":
-    return CMDrename(argv)
-  if command == "change":
-    if len(argv) == 2:
-      # Generate a random changelist name.
-      changename = GenerateChangeName()
-    elif argv[2] == '--force':
-      changename = GenerateChangeName()
-      # argv[3:] is passed to Change() as |args| later. Change() should receive
-      # |args| which includes '--force'.
-      argv.insert(2, changename)
-    else:
-      changename = argv[2]
-  elif len(argv) == 2:
-    ErrorExit("Need a changelist name.")
+    return CMDrename(argv[1:])
+  elif command == "change":
+    return CMDchange(argv[1:])
+  elif command == "description":
+    return CMDdescription(argv[1:])
+  elif command == "lint":
+    return CMDlint(argv[1:])
+  elif command == "upload":
+    return CMDupload(argv[1:])
+  elif command == "presubmit":
+    return CMDpresubmit(argv[1:])
+  elif command in ("commit", "submit"):
+    return CMDcommit(argv[1:])
+  elif command == "delete":
+    return CMDdelete(argv[1:])
+  elif command == "try":
+    return CMDtry(argv[1:])
   else:
-    changename = argv[2]
-
-  # When the command is 'try' and --patchset is used, the patch to try
-  # is on the Rietveld server. 'change' creates a change so it's fine if the
-  # change didn't exist. All other commands require an existing change.
-  fail_on_not_found = command != "try" and command != "change"
-  if command == "try" and changename.find(',') != -1:
-    change_info = LoadChangelistInfoForMultiple(changename, GetRepositoryRoot(),
-                                                True, True)
-  else:
-    change_info = ChangeInfo.Load(changename, GetRepositoryRoot(),
-                                  fail_on_not_found, True)
-
-  if command == "change":
-    return CMDchange(change_info, argv[3:])
-  elif command == "description":
-    return CMDdescription(change_info, argv[3:])
-  elif command == "lint":
-    return CMDlint(change_info, argv[3:])
-  elif command == "upload":
-    return CMDupload(change_info, argv[3:])
-  elif command == "presubmit":
-    return CMDpresubmit(change_info, argv[3:])
-  elif command in ("commit", "submit"):
-    return CMDcommit(change_info, argv[3:])
-  elif command == "delete":
-    return CMDdelete(change_info, argv[3:])
-  elif command == "try":
-    return CMDtry(change_info, argv)
-  else:
-    # Everything else that is passed into gcl we redirect to svn, after adding
-    # the files. This allows commands such as 'gcl diff xxx' to work.
-    if command == "diff" and not change_info.GetFileNames():
-      return 0
-    args =["svn", command]
-    root = GetRepositoryRoot()
-    args.extend([os.path.join(root, x) for x in change_info.GetFileNames()])
-    RunShell(args, True)
-  return 0
+    return CMDpassthru(argv)
 
 
 if __name__ == "__main__":
-  sys.exit(main())
+  sys.exit(main(sys.argv[1:]))