Split generic subcommand code off its own module.

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."""
 
-import difflib
 from distutils.version import LooseVersion
 import json
 import logging
 import optparse
 import os
 import Queue
 import re
 import stat
 import sys
 import textwrap
 import threading
 import urllib2
 import urlparse
 
 try:
   import readline  # pylint: disable=F0401,W0611
 except ImportError:
   pass
 
 
 from third_party import colorama
 from third_party import upload
 import breakpad  # pylint: disable=W0611
 import fix_encoding
 import gclient_utils
 import presubmit_support
 import rietveld
 import scm
+import subcommand
 import subprocess2
 import watchlists
 
+__version__ = '1.0'
 
 DEFAULT_SERVER = 'https://codereview.appspot.com'
 POSTUPSTREAM_HOOK_PATTERN = '.git/hooks/post-cl-%s'
 DESCRIPTION_BACKUP_FILE = '~/.git_cl_description_backup'
 GIT_INSTRUCTIONS_URL = 'http://code.google.com/p/chromium/wiki/UsingNewGit'
 CHANGE_ID = 'Change-Id:'
 
 # Shortcut since it quickly becomes redundant.
 Fore = colorama.Fore
 
@@ skipping 39 matching lines @@
     return 1, ''
 
 
 def IsGitVersionAtLeast(min_version):
   prefix = 'git version '
   version = RunGit(['--version']).strip()
   return (version.startswith(prefix) and
       LooseVersion(version[len(prefix):]) >= LooseVersion(min_version))
 
 
-def usage(more):
-  def hook(fn):
-    fn.usage_more = more
-    return fn
-  return hook
-
-
 def ask_for_data(prompt):
   try:
     return raw_input(prompt)
   except KeyboardInterrupt:
     # Hide the exception.
     sys.exit(1)
 
 
 def git_set_branch_value(key, value):
   branch = Changelist().GetBranch()
@@ skipping 906 matching lines @@
       os.remove(dst)
     try:
       urlretrieve(src, dst)
       os.chmod(dst, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
     except Exception:
       if os.path.exists(dst):
         os.remove(dst)
       DieWithError('\nFailed to download hooks from %s' % src)
 
 
-@usage('[repo root containing codereview.settings]')
+@subcommand.usage('[repo root containing codereview.settings]')
 def CMDconfig(parser, args):
   """Edits configuration for this tree."""
 
   _, args = parser.parse_args(args)
   if len(args) == 0:
     GetCodereviewSettingsInteractively()
     DownloadHooks(True)
     return 0
 
   url = args[0]
@@ skipping 137 matching lines @@
   if not cl.GetIssue():
     print 'no issue assigned.'
     return 0
   print cl.GetBranch()
   print 'Issue number: %s (%s)' % (cl.GetIssue(), cl.GetIssueURL())
   print 'Issue description:'
   print cl.GetDescription(pretty=True)
   return 0
 
 
-@usage('[issue_number]')
+@subcommand.usage('[issue_number]')
 def CMDissue(parser, args):
   """Sets or displays the current code review issue number.
 
   Pass issue number 0 to clear the current issue.
   """
   _, args = parser.parse_args(args)
 
   cl = Changelist()
   if len(args) > 0:
     try:
@@ skipping 238 matching lines @@
   """Fixes a list so that comma separated items are put as individual items.
 
   So that "--reviewers joe@c,john@c --reviewers joa@c" results in
   options.reviewers == sorted(['joe@c', 'john@c', 'joa@c']).
   """
   items = sum((i.split(',') for i in l), [])
   stripped_items = (i.strip() for i in items)
   return sorted(filter(None, stripped_items))
 
 
-@usage('[args to "git diff"]')
+@subcommand.usage('[args to "git diff"]')
 def CMDupload(parser, args):
   """Uploads the current changelist to codereview."""
   parser.add_option('--bypass-hooks', action='store_true', dest='bypass_hooks',
                     help='bypass upload presubmit hook')
   parser.add_option('--bypass-watchlists', action='store_true',
                     dest='bypass_watchlists',
                     help='bypass watchlists auto CC-ing reviewers')
   parser.add_option('-f', action='store_true', dest='force',
                     help="force yes to questions (don't prompt)")
   parser.add_option('-m', dest='message', help='message for patchset')
@@ skipping 302 matching lines @@
     cl.SetIssue(None)
 
   if retcode == 0:
     hook = POSTUPSTREAM_HOOK_PATTERN % cmd
     if os.path.isfile(hook):
       RunCommand([hook, base_branch], error_ok=True)
 
   return 0
 
 
-@usage('[upstream branch to apply against]')
+@subcommand.usage('[upstream branch to apply against]')
 def CMDdcommit(parser, args):
   """Commits the current changelist via git-svn."""
   if not settings.GetIsGitSvn():
     message = """This doesn't appear to be an SVN repository.
 If your project has a git mirror with an upstream SVN master, you probably need
 to run 'git svn init', see your project's git mirror documentation.
 If your project has a true writeable upstream repository, you probably want
 to run 'git cl push' instead.
 Choose wisely, if you get this wrong, your commit might appear to succeed but
 will instead be silently ignored."""
     print(message)
     ask_for_data('[Press enter to dcommit or ctrl-C to quit]')
   return SendUpstream(parser, args, 'dcommit')
 
 
-@usage('[upstream branch to apply against]')
+@subcommand.usage('[upstream branch to apply against]')
 def CMDpush(parser, args):
   """Commits the current changelist via git."""
   if settings.GetIsGitSvn():
     print('This appears to be an SVN repository.')
     print('Are you sure you didn\'t mean \'git cl dcommit\'?')
     ask_for_data('[Press enter to push or ctrl-C to quit]')
   return SendUpstream(parser, args, 'push')
 
 
-@usage('<patch url or issue id>')
+@subcommand.usage('<patch url or issue id>')
 def CMDpatch(parser, args):
   """Patchs in a code review."""
   parser.add_option('-b', dest='newbranch',
                     help='create a new branch off trunk for the patch')
   parser.add_option('-f', action='store_true', dest='force',
                     help='with -b, clobber any existing branch')
   parser.add_option('--reject', action='store_true', dest='reject',
                     help='failed patches spew .rej files rather than '
                         'attempting a 3-way merge')
   parser.add_option('-n', '--no-commit', action='store_true', dest='nocommit',
@@ skipping 226 matching lines @@
   cl.RpcServer().trigger_try_jobs(
       cl.GetIssue(), patchset, options.name, options.clobber, options.revision,
       builders_and_tests)
   print('Tried jobs on:')
   length = max(len(builder) for builder in builders_and_tests)
   for builder in sorted(builders_and_tests):
     print '  %*s: %s' % (length, builder, ','.join(builders_and_tests[builder]))
   return 0
 
 
-@usage('[new upstream branch]')
+@subcommand.usage('[new upstream branch]')
 def CMDupstream(parser, args):
   """Prints or sets the name of the upstream branch, if any."""
   _, args = parser.parse_args(args)
   if len(args) > 1:
     parser.error('Unrecognized args: %s' % ' '.join(args))
     return 0
 
   cl = Changelist()
   if args:
     # One arg means set upstream branch.
@@ skipping 81 matching lines @@
     cfd_path = os.path.join('/usr', 'lib', 'clang-format',
                             'clang-format-diff.py')
     if not os.path.exists(cfd_path):
       DieWithError('Could not find clang-format-diff at %s.' % cfd_path)
     cmd = [sys.executable, cfd_path, '-style', 'Chromium']
     RunCommand(cmd, stdin=diff_output, cwd=top_dir)
 
   return 0
 
 
-### Glue code for subcommand handling.
-
-
-def Commands():
-  """Returns a dict of command and their handling function."""
-  module = sys.modules[__name__]
-  cmds = (fn[3:] for fn in dir(module) if fn.startswith('CMD'))
-  return dict((cmd, getattr(module, 'CMD' + cmd)) for cmd in cmds)
-
-
-def Command(name):
-  """Retrieves the function to handle a command."""
-  commands = Commands()
-  if name in commands:
-    return commands[name]
-
-  # Try to be smart and look if there's something similar.
-  commands_with_prefix = [c for c in commands if c.startswith(name)]
-  if len(commands_with_prefix) == 1:
-    return commands[commands_with_prefix[0]]
-
-  # A #closeenough approximation of levenshtein distance.
-  def close_enough(a, b):
-    return difflib.SequenceMatcher(a=a, b=b).ratio()
-
-  hamming_commands = sorted(
-      ((close_enough(c, name), c) for c in commands),
-      reverse=True)
-  if (hamming_commands[0][0] - hamming_commands[1][0]) < 0.3:
-    # Too ambiguous.
-    return
-
-  if hamming_commands[0][0] < 0.8:
-    # Not similar enough. Don't be a fool and run a random command.
-    return
-
-  return commands[hamming_commands[0][1]]
-
-
-def CMDhelp(parser, args):
-  """Prints list of commands or help for a specific command."""
-  _, args = parser.parse_args(args)
-  if len(args) == 1:
-    return main(args + ['--help'])
-  parser.print_help()
-  return 0
-
-
-def GenUsage(parser, command):
-  """Modify an OptParse object with the function's documentation."""
-  obj = Command(command)
-  # Get back the real command name in case Command() guess the actual command
-  # name.
-  command = obj.__name__[3:]
-  more = getattr(obj, 'usage_more', '')
-  if command == 'help':
-    command = '<command>'
-  else:
-    parser.description = obj.__doc__
-  parser.set_usage('usage: %%prog %s [options] %s' % (command, more))
-
-
 class OptionParser(optparse.OptionParser):
   """Creates the option parse and add --verbose support."""
   def __init__(self, *args, **kwargs):
-    optparse.OptionParser.__init__(self, *args, **kwargs)
+    optparse.OptionParser.__init__(
+        self, *args, prog='git cl', version=__version__, **kwargs)
     self.add_option(
         '-v', '--verbose', action='count', default=0,
         help='Use 2 times for more debugging info')
 
   def parse_args(self, args=None, values=None):
     options, args = optparse.OptionParser.parse_args(self, args, values)
     levels = [logging.WARNING, logging.INFO, logging.DEBUG]
     logging.basicConfig(level=levels[min(options.verbose, len(levels) - 1)])
     return options, args
 
   def format_description(self, _):
     """Disables automatic reformatting."""
     lines = self.description.rstrip().splitlines()
     lines_fixed = [lines[0]] + [l[2:] if len(l) >= 2 else l for l in lines[1:]]
     description = ''.join(l + '\n' for l in lines_fixed)
     return description[0].upper() + description[1:]
 
 
 def main(argv):
-  """Doesn't parse the arguments here, just find the right subcommand to
-  execute."""
   if sys.hexversion < 0x02060000:
     print >> sys.stderr, (
         '\nYour python version %s is unsupported, please upgrade.\n' %
         sys.version.split(' ', 1)[0])
     return 2
 
   # Reload settings.
   global settings
   settings = Settings()
 
-  # Do it late so all commands are listed.
-  commands = Commands()
-  length = max(len(c) for c in commands)
-
-  def gen_summary(x):
-    """Creates a oneline summary from the docstring."""
-    line = x.split('\n', 1)[0].rstrip('.')
-    return line[0].lower() + line[1:]
-
-  docs = sorted(
-      (name, gen_summary(handler.__doc__).strip())
-      for name, handler in commands.iteritems())
-  CMDhelp.usage_more = ('\n\nCommands are:\n' + '\n'.join(
-      '  %-*s %s' % (length, name, doc) for name, doc in docs))
-
-  parser = OptionParser()
-  if argv:
-    command = Command(argv[0])
-    if command:
-      # "fix" the usage and the description now that we know the subcommand.
-      GenUsage(parser, argv[0])
-      try:
-        return command(parser, argv[1:])
-      except urllib2.HTTPError, e:
-        if e.code != 500:
-          raise
-        DieWithError(
-            ('AppEngine is misbehaving and returned HTTP %d, again. Keep faith '
-             'and retry or visit go/isgaeup.\n%s') % (e.code, str(e)))
-
-  # Not a known command. Default to help.
-  GenUsage(parser, 'help')
-  return CMDhelp(parser, argv)
+  dispatcher = subcommand.CommandDispatcher(__name__)
+  try:
+    return dispatcher.execute(OptionParser(), argv)
+  except urllib2.HTTPError, e:
+    if e.code != 500:
+      raise
+    DieWithError(
+        ('AppEngine is misbehaving and returned HTTP %d, again. Keep faith '
+          'and retry or visit go/isgaeup.\n%s') % (e.code, str(e)))
 
 
 if __name__ == '__main__':
   # These affect sys.stdout so do it outside of main() to simplify mocks in
   # unit testing.
   fix_encoding.fix_encoding()
   colorama.init()
   sys.exit(main(sys.argv[1:]))