commands: better argument processing, per-command help

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

commands: better argument processing, per-command help

This passes command line arguments as positional arguments rather than
as a list and attempt to catch exceptions if the arguments don't match up.

It also adds 'hg help [cmd]' which prints the syntax and docstring for
the given command.

manifest hash: cef3ac7076f99fce4265a5dc7acb57fb03d93270
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.0 (GNU/Linux)

iD8DBQFCnghXywK+sNU5EO8RAv+5AJ9MfCCRxE+pNu3i44v5I4IyQoRaiQCeNqEK
wBzAiP+Q6F/9PL2xOrrZGHw=
=EYdk
-----END PGP SIGNATURE-----

mercurial/commands.py

@@ -1,150 +1,169 b''
-import os, re
+import os, re, traceback, sys
 from mercurial import fancyopts, ui, hg
 
 class UnknownCommand(Exception): pass
 
 def relpath(repo, args):
     if os.getcwd() != repo.root:
         p = os.getcwd()[len(repo.root) + 1: ]
         return [ os.path.join(p, x) for x in args ]
     return args
     
-def help(ui, args):
+def help(ui, cmd=None):
+    '''show help'''
+    if cmd:
+        try:
+            i = find(cmd)
+            ui.write("%s\n\n" % i[2])
+            ui.write(i[0].__doc__, "\n")
+        except UnknownCommand:
+            ui.warn("unknown command %s", cmd)
+        sys.exit(0)
+    
     ui.status("""\
  hg commands:
 
  add [files...]        add the given files in the next commit
  addremove             add all new files, delete all missing files
  annotate [files...]   show changeset number per file line
  branch <path>         create a branch of <path> in this directory
  checkout [changeset]  checkout the latest or given changeset
  commit                commit all changes to the repository
  diff [files...]       diff working directory (or selected files)
  dump <file> [rev]     dump the latest or given revision of a file
  dumpmanifest [rev]    dump the latest or given revision of the manifest
  export <rev>          dump the changeset header and diffs for a revision
  history               show changeset history
  init                  create a new repository in this directory
  log <file>            show revision history of a single file
  merge <path>          merge changes from <path> into local repository
  recover               rollback an interrupted transaction
  remove [files...]     remove the given files in the next commit
  serve                 export the repository via HTTP
  status                show new, missing, and changed files in working dir
  tags                  show current changeset tags
  undo                  undo the last transaction
 """)
 
-def init(ui, args):
+def init(ui):
     """create a repository"""
     hg.repository(ui, ".", create=1)
 
-def checkout(u, repo, args):
+def checkout(u, repo, changeset=None):
+    '''checkout a given changeset or the current tip'''
     node = repo.changelog.tip()
-    if args:
-        node = repo.lookup(args[0])
+    if changeset:
+        node = repo.lookup(changeset)
     repo.checkout(node)
 
-def annotate(u, repo, args, **ops):
-    if not args:
-        return
-        
+def annotate(u, repo, *args, **ops):
     def getnode(rev):
         return hg.short(repo.changelog.node(rev))
 
     def getname(rev):
         try:
             return bcache[rev]
         except KeyError:
             cl = repo.changelog.read(repo.changelog.node(rev))
             name = cl[1]
             f = name.find('@')
             if f >= 0:
                 name = name[:f]
             bcache[rev] = name
             return name
     
     bcache = {}
     opmap = [['user', getname], ['number', str], ['changeset', getnode]]
     if not ops['user'] and not ops['changeset']:
         ops['number'] = 1
 
     args = relpath(repo, args)
     node = repo.current
     if ops['revision']:
         node = repo.changelog.lookup(ops['revision'])
     change = repo.changelog.read(node)
     mmap = repo.manifest.read(change[0])
     maxuserlen = 0
     maxchangelen = 0
     for f in args:
         lines = repo.file(f).annotate(mmap[f])
         pieces = []
 
         for o, f in opmap:
             if ops[o]:
                 l = [ f(n) for n,t in lines ]
                 m = max(map(len, l))
                 pieces.append([ "%*s" % (m, x) for x in l])
 
         for p,l in zip(zip(*pieces), lines):
             u.write(" ".join(p) + ": " + l[1])
 
-def undo(ui, repo, args):
+def undo(ui, repo):
     repo.undo()
 
 table = {
     "init": (init, [], 'hg init'),
-    "help": (help, [], 'hg help'),
-    "checkout|co": (checkout, [], 'hg checkout'),
+    "help": (help, [], 'hg help [command]'),
+    "checkout|co": (checkout, [], 'hg checkout [changeset]'),
     "ann|annotate": (annotate,
                      [('r', 'revision', '', 'revision'),
                       ('u', 'user', None, 'show user'),
                       ('n', 'number', None, 'show revision number'),
                       ('c', 'changeset', None, 'show changeset')],
                      'hg annotate [-u] [-c] [-n] [-r id] [files]'),
     "undo": (undo, [], 'hg undo'),
     }
 
 norepo = "init branch help"
 
+def find(cmd):
+    i = None
+    for e in table.keys():
+        if re.match(e + "$", cmd):
+            return table[e]
+
+    raise UnknownCommand(cmd)
+
 def dispatch(args):
     options = {}
     opts = [('v', 'verbose', None, 'verbose'),
             ('d', 'debug', None, 'debug'),
             ('q', 'quiet', None, 'quiet'),
             ('y', 'noninteractive', None, 'run non-interactively'),
             ]
 
     args = fancyopts.fancyopts(args, opts, options,
                                'hg [options] <command> [options] [files]')
 
     if not args:
         cmd = "help"
     else:
         cmd, args = args[0], args[1:]
 
     u = ui.ui(options["verbose"], options["debug"], options["quiet"],
            not options["noninteractive"])
 
-    i = None
-    for e in table.keys():
-        if re.match(e + "$", cmd):
-            i = table[e]
-
-    # deal with this internally later
-    if not i: raise UnknownCommand(cmd)
+    # deal with unfound commands later
+    i = find(cmd)
 
     cmdoptions = {}
     args = fancyopts.fancyopts(args, i[1], cmdoptions, i[2])
 
     if cmd not in norepo.split():
         repo = hg.repository(ui = u)
-        d = lambda: i[0](u, repo, args, **cmdoptions)
+        d = lambda: i[0](u, repo, *args, **cmdoptions)
     else:
-        d = lambda: i[0](u, args, **cmdoptions)
+        d = lambda: i[0](u, *args, **cmdoptions)
 
     try:
         d()
     except KeyboardInterrupt:
         u.warn("interrupted!\n")
+    except TypeError, inst:
+        # was this an argument error?
+        tb = traceback.extract_tb(sys.exc_info()[2])
+        if len(tb) > 2: # no
+            raise
+        u.warn("%s: invalid arguments\n" % i[0].__name__)
+        u.warn("syntax: %s\n" % i[2])
+        sys.exit(-1)