big heap of command clean-up work

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

big heap of command clean-up work

Migrate add, forget, remove, commit, diff, addremove, tip, log,
recover, and serve.

Fix up filterfiles, relfilter, and relpath to be a bit more bulletproof

Alphabetize functions and the command table

Make everything in commands.py relative-path aware

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

iD8DBQFCof6gywK+sNU5EO8RAoW1AJsHu8vchPSjls7wVbvsq/UKlGhqtgCgtnnl
xSBxyf/TEVWjHIk3uTa8WSE=
=YPMl
-----END PGP SIGNATURE-----

hg

@@ -1,532 +1,411 b''
 #!/usr/bin/env python
 #
 # mercurial - a minimal scalable distributed SCM
 # v0.5b "katje"
 #
 # Copyright 2005 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 # the psyco compiler makes commits a bit faster
 # and makes changegroup merge about 20 times slower!
 # try:
 #    import psyco
 #    psyco.full()
 # except:
 #    pass
 
 import sys, os, time
 from mercurial import hg, mdiff, fancyopts, ui, commands
 
-def help():
-    ui.status("""\
- 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 filterfiles(list, files):
     l = [ x for x in list if x in files ]
 
     for f in files:
         if f[-1] != os.sep: f += os.sep
         l += [ x for x in list if x.startswith(f) ]
     return l
 
 def diff(files = None, node1 = None, node2 = None):
     def date(c):
         return time.asctime(time.gmtime(float(c[2].split(' ')[0])))
 
     if node2:
         change = repo.changelog.read(node2)
         mmap2 = repo.manifest.read(change[0])
         (c, a, d) = repo.diffrevs(node1, node2)
         def read(f): return repo.file(f).read(mmap2[f])
         date2 = date(change)
     else:
         date2 = time.asctime()
         if not node1:
             node1 = repo.dirstate.parents()[0]
         (c, a, d, u) = repo.diffdir(repo.root, node1)
         def read(f): return file(os.path.join(repo.root, f)).read()
 
     change = repo.changelog.read(node1)
     mmap = repo.manifest.read(change[0])
     date1 = date(change)
 
     if files:
         c, a, d = map(lambda x: filterfiles(x, files), (c, a, d))
 
     for f in c:
         to = repo.file(f).read(mmap[f])
         tn = read(f)
         sys.stdout.write(mdiff.unidiff(to, date1, tn, date2, f))
     for f in a:
         to = ""
         tn = read(f)
         sys.stdout.write(mdiff.unidiff(to, date1, tn, date2, f))
     for f in d:
         to = repo.file(f).read(mmap[f])
         tn = ""
         sys.stdout.write(mdiff.unidiff(to, date1, tn, date2, f))
 
 
 try:
     sys.exit(commands.dispatch(sys.argv[1:]))
 except commands.UnknownCommand:
     # fall through
     pass
 
 options = {}
 opts = [('v', 'verbose', None, 'verbose'),
         ('d', 'debug', None, 'debug'),
         ('q', 'quiet', None, 'quiet'),
         ('y', 'noninteractive', None, 'run non-interactively'),
         ]
 
 args = fancyopts.fancyopts(sys.argv[1:], opts, options,
                            'hg [options] <command> [command options] [files]')
 
 try:
     cmd = args[0]
     args = args[1:]
 except:
     cmd = "help"
 
 ui = ui.ui(options["verbose"], options["debug"], options["quiet"],
            not options["noninteractive"])
     
 try:
     repo = hg.repository(ui=ui)
 except IOError:
     ui.warn("Unable to open repository\n")
     sys.exit(0)
 
 relpath = None
 if os.getcwd() != repo.root:
     relpath = os.getcwd()[len(repo.root) + 1: ]
 
-elif cmd == "add":
-    repo.add(args)
-
-elif cmd == "forget":
-    repo.forget(args)
-
-elif cmd == "remove" or cmd == "rm" or cmd == "del" or cmd == "delete":
-    repo.remove(args)
-
-elif cmd == "commit" or cmd == "checkin" or cmd == "ci":
-    if 1:
-        if len(args) > 0:
-            repo.commit(args)
-        else:
-            repo.commit()
 elif cmd == "rawcommit":
     "raw commit interface"
     rc = {}
     opts = [('p', 'parent', [], 'parent'),
             ('d', 'date', "", 'data'),
             ('u', 'user', "", 'user'),
             ('F', 'files', "", 'file list'),
             ('t', 'text', "", 'commit text'),
             ('l', 'logfile', "", 'commit text file')
             ]
     args = fancyopts.fancyopts(args, opts, rc,
                                "hg rawcommit [options] files")
     text = rc['text']
     if not text and rc['logfile']:
         try: text = open(rc['logfile']).read()
         except IOError: pass
     if not text and not rc['logfile']:
         print "missing commit text"
         sys.exit(0)
     if rc['files']:
         files = open(rc['files']).read().splitlines()
     else:
         files = args
         
     repo.rawcommit(files, text, rc['user'], rc['date'], *rc['parent'])
     
  
 elif cmd == "import" or cmd == "patch":
     try:
         import psyco
         psyco.full()
     except:
         pass
     
     ioptions = {}
     opts = [('p', 'strip', 1, 'path strip'),
             ('b', 'base', "", 'base path'),
             ('q', 'quiet', "", 'silence diff')
             ]
     
     args = fancyopts.fancyopts(args, opts, ioptions,
                               'hg import [options] <patch names>')
     d = ioptions["base"]
     strip = ioptions["strip"]
     quiet = ioptions["quiet"] and "> /dev/null" or ""
 
     for patch in args:
         ui.status("applying %s\n" % patch)
         pf = os.path.join(d, patch)
 
         text = ""
         for l in file(pf):
             if l[:4] == "--- ": break
             text += l
 
         f = os.popen("lsdiff --strip %d %s" % (strip, pf))
         files = filter(None, map(lambda x: x.rstrip(), f.read().splitlines()))
         f.close()
 
         if files:
             if os.system("patch -p%d < %s %s" % (strip, pf, quiet)):
                 raise "patch failed!"
         repo.commit(files, text)
 
-elif cmd == "diff":
-    revs = []
-
-    if args:
-        doptions = {}
-        opts = [('r', 'revision', [], 'revision')]
-        args = fancyopts.fancyopts(args, opts, doptions,
-                                   'hg diff [options] [files]')
-        revs = map(lambda x: repo.lookup(x), doptions['revision'])
-    
-    if len(revs) > 2:
-        self.ui.warn("too many revisions to diff\n")
-        sys.exit(1)
-
-    if relpath:
-        if not args: args = [ relpath ]
-        else: args = [ os.path.join(relpath, x) for x in args ]
-
-    diff(args, *revs)
-
 elif cmd == "export":
     node = repo.lookup(args[0])
     prev, other = repo.changelog.parents(node)
     change = repo.changelog.read(node)
     print "# HG changeset patch"
     print "# User %s" % change[1]
     print "# Node ID %s" % hg.hex(node)
     print "# Parent  %s" % hg.hex(prev)
     print
     if other != hg.nullid:
         print "# Parent  %s" % hg.hex(other)
     print change[4]
     
     diff(None, prev, node)
 
 elif cmd == "debugchangegroup":
     newer = repo.newer(map(repo.lookup, args))
     for chunk in repo.changegroup(newer):
         sys.stdout.write(chunk)
 
 elif cmd == "debugaddchangegroup":
     data = sys.stdin.read()
     repo.addchangegroup(data)
 
-elif cmd == "addremove":
-    (c, a, d, u) = repo.diffdir(repo.root)
-    repo.add(a)
-    repo.remove(d)
-    
 elif cmd == "history":
     for i in range(repo.changelog.count()):
         n = repo.changelog.node(i)
         changes = repo.changelog.read(n)
         (p1, p2) = repo.changelog.parents(n)
         (h, h1, h2) = map(hg.hex, (n, p1, p2))
         (i1, i2) = map(repo.changelog.rev, (p1, p2))
         print "rev:      %4d:%s" % (i, h)
         print "parents:  %4d:%s" % (i1, h1)
         if i2: print "          %4d:%s" % (i2, h2)
         print "manifest: %4d:%s" % (repo.manifest.rev(changes[0]),
                                     hg.hex(changes[0]))
         print "user:", changes[1]
         print "date:", time.asctime(
             time.localtime(float(changes[2].split(' ')[0])))
         if ui.verbose: print "files:", " ".join(changes[3])
         print "description:"
         print changes[4]
 
-elif cmd == "tip":
-    n = repo.changelog.tip()
-    t = repo.changelog.rev(n)
-    ui.status("%d:%s\n" % (t, hg.hex(n)))
-
-elif cmd == "log":
-
-    if len(args) == 1:
-        if relpath:
-            args[0] = os.path.join(relpath, args[0])
-
-        r = repo.file(args[0])
-        for i in range(r.count()):
-            n = r.node(i)
-            (p1, p2) = r.parents(n)
-            (h, h1, h2) = map(hg.hex, (n, p1, p2))
-            (i1, i2) = map(r.rev, (p1, p2))
-            cr = r.linkrev(n)
-            cn = hg.hex(repo.changelog.node(cr))
-            print "rev:       %4d:%s" % (i, h)
-            print "changeset: %4d:%s" % (cr, cn)
-            print "parents:   %4d:%s" % (i1, h1)
-            if i2: print "           %4d:%s" % (i2, h2)
-            changes = repo.changelog.read(repo.changelog.node(cr))
-            print "user: %s" % changes[1]
-            print "date: %s" % time.asctime(
-                time.localtime(float(changes[2].split(' ')[0])))
-            print "description:"
-            print changes[4]
-            print
-    elif len(args) > 1:
-        print "too many args"
-    else:
-        print "missing filename"
-
 elif cmd == "dump":
     if args:
         r = repo.file(args[0])
         n = r.tip()
         if len(args) > 1: n = r.lookup(args[1])
         sys.stdout.write(r.read(n))
     else:
         print "missing filename"
 
 elif cmd == "dumpmanifest":
     n = repo.manifest.tip()
     if len(args) > 0:
         n = repo.manifest.lookup(args[0])
     m = repo.manifest.read(n)
     files = m.keys()
     files.sort()
 
     for f in files:
         print hg.hex(m[f]), f
 
 elif cmd == "debugindex":
     if ".hg" not in args[0]:
         args[0] = ".hg/data/" + repo.file(args[0]).encodepath(args[0]) + "i"
     
     r = hg.revlog(open, args[0], "")
     print "   rev    offset  length   base linkrev"+\
           " p1           p2           nodeid"
     for i in range(r.count()):
         e = r.index[i]
         print "% 6d % 9d % 7d % 6d % 7d %s.. %s.. %s.." % (
             i, e[0], e[1], e[2], e[3],
             hg.hex(e[4][:5]), hg.hex(e[5][:5]), hg.hex(e[6][:5]))
 
 elif cmd == "debugindexdot":
     if ".hg" not in args[0]:
         args[0] = ".hg/data/" + repo.file(args[0]).encodepath(args[0]) + "i"
 
     r = hg.revlog(open, args[0], "")
     print "digraph G {"
     for i in range(r.count()):
         e = r.index[i]
         print "\t%d -> %d" % (r.rev(e[4]), i)
         if e[5] != hg.nullid:
             print "\t%d -> %d" % (r.rev(e[5]), i)
     print "}"
 
 elif cmd == "merge":
     if args:
         paths = {}
         try:
             pf = os.path.join(os.environ["HOME"], ".hgpaths")
             for l in file(pf):
                 name, path = l.split()
                 paths[name] = path
         except:
             pass
 
         if args[0] in paths: args[0] = paths[args[0]]
         
         other = hg.repository(ui, args[0])
         cg = repo.getchangegroup(other)
         repo.addchangegroup(cg)
     else:
         print "missing source repository"
 
 elif cmd == "tags":
     repo.lookup(0) # prime the cache
     i = repo.tags.items()
     i.sort()
     for k, n in i:
         try:
             r = repo.changelog.rev(n)
         except KeyError:
             r = "?"
         print "%-30s %5d:%s" % (k, repo.changelog.rev(n), hg.hex(n))
 
-elif cmd == "recover":
-    repo.recover()
-
 elif cmd == "verify":
     filelinkrevs = {}
     filenodes = {}
     manifestchangeset = {}
     changesets = revisions = files = 0
     errors = 0
 
     ui.status("checking changesets\n")
     for i in range(repo.changelog.count()):
         changesets += 1
         n = repo.changelog.node(i)
         for p in repo.changelog.parents(n):
             if p not in repo.changelog.nodemap:
                 ui.warn("changeset %s has unknown parent %s\n" %
                         (hg.short(n), hg.short(p)))
                 errors += 1
         try:
             changes = repo.changelog.read(n)
         except Exception, inst:
             ui.warn("unpacking changeset %s: %s\n" % (short(n), inst))
             errors += 1
             
         manifestchangeset[changes[0]] = n
         for f in changes[3]:
             filelinkrevs.setdefault(f, []).append(i)
 
     ui.status("checking manifests\n")
     for i in range(repo.manifest.count()):
         n = repo.manifest.node(i)
         for p in repo.manifest.parents(n):
             if p not in repo.manifest.nodemap:
                 ui.warn("manifest %s has unknown parent %s\n" %
                         (hg.short(n), hg.short(p)))
                 errors += 1
         ca = repo.changelog.node(repo.manifest.linkrev(n))
         cc = manifestchangeset[n]
         if ca != cc:
             ui.warn("manifest %s points to %s, not %s\n" %
                     (hg.hex(n), hg.hex(ca), hg.hex(cc)))
             errors += 1
 
         try:
             delta = mdiff.patchtext(repo.manifest.delta(n))
         except KeyboardInterrupt:
             print "aborted"
             sys.exit(0)
         except Exception, inst:
             ui.warn("unpacking manifest %s: %s\n" % (hg.short(n), inst))
             errors += 1
 
         ff = [ l.split('\0') for l in delta.splitlines() ]
         for f, fn in ff:
             filenodes.setdefault(f, {})[hg.bin(fn)] = 1
 
     ui.status("crosschecking files in changesets and manifests\n")
     for f in filenodes:
         if f not in filelinkrevs:
             ui.warn("file %s in manifest but not in changesets\n" % f)
             errors += 1
 
     for f in filelinkrevs:
         if f not in filenodes:
             ui.warn("file %s in changeset but not in manifest\n" % f)
             errors += 1
 
     ui.status("checking files\n")
     ff = filenodes.keys()
     ff.sort()
     for f in ff:
         if f == "/dev/null": continue
         files += 1
         fl = repo.file(f)
         nodes = { hg.nullid: 1 }
         for i in range(fl.count()):
             revisions += 1
             n = fl.node(i)
 
             if n not in filenodes[f]:
                 ui.warn("%s: %d:%s not in manifests\n" % (f, i, hg.short(n)))
                 print len(filenodes[f].keys()), fl.count(), f
                 errors += 1
             else:
                 del filenodes[f][n]
 
             flr = fl.linkrev(n)
             if flr not in filelinkrevs[f]:
                 ui.warn("%s:%s points to unexpected changeset rev %d\n"
                         % (f, hg.short(n), fl.linkrev(n)))
                 errors += 1
             else:
                 filelinkrevs[f].remove(flr)
 
             # verify contents
             try:
                 t = fl.read(n)
             except Exception, inst:
                 ui.warn("unpacking file %s %s: %s\n" % (f, hg.short(n), inst))
                 errors += 1
             
             # verify parents
             (p1, p2) = fl.parents(n)
             if p1 not in nodes:
                 ui.warn("file %s:%s unknown parent 1 %s" %
                         (f, hg.short(n), hg.short(p1)))
                 errors += 1
             if p2 not in nodes:
                 ui.warn("file %s:%s unknown parent 2 %s" %
                         (f, hg.short(n), hg.short(p1)))
                 errors += 1
             nodes[n] = 1
 
         # cross-check
         for node in filenodes[f]:
             ui.warn("node %s in manifests not in %s\n" % (hg.hex(n), f))
             errors += 1
 
     ui.status("%d files, %d changesets, %d total revisions\n" %
               (files, changesets, revisions))
     
     if errors:
         ui.warn("%d integrity errors encountered!\n" % errors)
         sys.exit(1)
 
-elif cmd == "serve":
-    from mercurial import hgweb
-    
-    soptions = {}
-    opts = [('p', 'port', 8000, 'listen port'),
-            ('a', 'address', '', 'interface address'),
-            ('n', 'name', os.getcwd(), 'repository name'),
-            ('t', 'templates', "", 'template map')
-            ]
-    
-    args = fancyopts.fancyopts(args, opts, soptions,
-                              'hg serve [options]')
-
-    hgweb.server(repo.root, soptions["name"], soptions["templates"],
-                 soptions["address"], soptions["port"])
-    
 else:
     if cmd: ui.warn("unknown command\n\n")
-    help()
     sys.exit(1)

mercurial/commands.py

@@ -1,261 +1,386 b''
-import os, re, traceback, sys, signal, time
+import os, re, traceback, sys, signal, time, mdiff
 from mercurial import fancyopts, ui, hg
 
 class UnknownCommand(Exception): pass
 
-def filterfiles(list, files):
-    l = [ x for x in list if x in files ]
+def filterfiles(filters, files):
+    l = [ x for x in files if x in filters ]
 
-    for f in files:
-        if f[-1] != os.sep: f += os.sep
-        l += [ x for x in list if x.startswith(f) ]
+    for t in filters:
+        if t and t[-1] != os.sep: t += os.sep
+        l += [ x for x in files if x.startswith(t) ]
     return l
 
-def relfilter(repo, args):
+def relfilter(repo, files):
     if os.getcwd() != repo.root:
         p = os.getcwd()[len(repo.root) + 1: ]
-        return filterfiles(p, args)
-    return args
+        return filterfiles(p, files)
+    return files
 
 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 [ os.path.normpath(os.path.join(p, x)) for x in args ]
     return args
     
+def dodiff(repo, files = None, node1 = None, node2 = None):
+    def date(c):
+        return time.asctime(time.gmtime(float(c[2].split(' ')[0])))
+
+    if node2:
+        change = repo.changelog.read(node2)
+        mmap2 = repo.manifest.read(change[0])
+        (c, a, d) = repo.diffrevs(node1, node2)
+        def read(f): return repo.file(f).read(mmap2[f])
+        date2 = date(change)
+    else:
+        date2 = time.asctime()
+        (c, a, d, u) = repo.diffdir(repo.root, node1)
+        if not node1:
+            node1 = repo.dirstate.parents()[0]
+        def read(f): return file(os.path.join(repo.root, f)).read()
+
+    change = repo.changelog.read(node1)
+    mmap = repo.manifest.read(change[0])
+    date1 = date(change)
+
+    if files:
+        c, a, d = map(lambda x: filterfiles(files, x), (c, a, d))
+
+    for f in c:
+        to = repo.file(f).read(mmap[f])
+        tn = read(f)
+        sys.stdout.write(mdiff.unidiff(to, date1, tn, date2, f))
+    for f in a:
+        to = ""
+        tn = read(f)
+        sys.stdout.write(mdiff.unidiff(to, date1, tn, date2, f))
+    for f in d:
+        to = repo.file(f).read(mmap[f])
+        tn = ""
+        sys.stdout.write(mdiff.unidiff(to, date1, tn, date2, f))
+    
 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):
-    """create a repository"""
-    hg.repository(ui, ".", create=1)
-
-def branch(ui, path):
-    '''branch from a local repository'''
-    # this should eventually support remote repos
-    os.system("cp -al %s/.hg .hg" % path)
+def add(ui, repo, file, *files):
+    '''add the specified files on the next commit'''
+    repo.add(relpath(repo, (file,) + files))
 
-def checkout(ui, repo, changeset=None):
-    '''checkout a given changeset or the current tip'''
+def addremove(ui, repo):
     (c, a, d, u) = repo.diffdir(repo.root)
-    if c or a or d:
-        ui.warn("aborting (outstanding changes in working directory)\n")
-        sys.exit(1)
+    repo.add(a)
+    repo.remove(d)
 
-    node = repo.changelog.tip()
-    if changeset:
-        node = repo.lookup(changeset)
-    repo.checkout(node)
-
-def annotate(u, repo, *args, **ops):
+def annotate(u, repo, file, *files, **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.dirstate.parents()[0]
     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:
+    for f in relpath(repo, (file,) + files):
         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 branch(ui, path):
+    '''branch from a local repository'''
+    # this should eventually support remote repos
+    os.system("cp -al %s/.hg .hg" % path)
+
+def checkout(ui, repo, changeset=None):
+    '''checkout a given changeset or the current tip'''
+    (c, a, d, u) = repo.diffdir(repo.root)
+    if c or a or d:
+        ui.warn("aborting (outstanding changes in working directory)\n")
+        sys.exit(1)
+
+    node = repo.changelog.tip()
+    if changeset:
+        node = repo.lookup(changeset)
+    repo.checkout(node)
+
+def commit(ui, repo, *files):
+    """commit the specified files or all outstanding changes"""
+    repo.commit(relpath(repo, files))
+
+def diff(ui, repo, *files, **opts):
+    revs = []
+    if opts['rev']:
+        revs = map(lambda x: repo.lookup(x), opts['rev'])
+    
+    if len(revs) > 2:
+        self.ui.warn("too many revisions to diff\n")
+        sys.exit(1)
+
+    if files:
+        files = relpath(repo, files)
+    else:
+        files = relpath(repo, [""])
+
+    dodiff(repo, files, *revs)
+
+def forget(ui, repo, file, *files):
+    """don't add the specified files on the next commit"""
+    repo.forget(relpath(repo, (file,) + files))
+
 def heads(ui, repo):
     '''show current repository heads'''
     for n in repo.changelog.heads():
         i = repo.changelog.rev(n)
         changes = repo.changelog.read(n)
         (p1, p2) = repo.changelog.parents(n)
         (h, h1, h2) = map(hg.hex, (n, p1, p2))
         (i1, i2) = map(repo.changelog.rev, (p1, p2))
         print "rev:      %4d:%s" % (i, h)
         print "parents:  %4d:%s" % (i1, h1)
         if i2: print "          %4d:%s" % (i2, h2)
         print "manifest: %4d:%s" % (repo.manifest.rev(changes[0]),
                                     hg.hex(changes[0]))
         print "user:", changes[1]
         print "date:", time.asctime(
             time.localtime(float(changes[2].split(' ')[0])))
         if ui.verbose: print "files:", " ".join(changes[3])
         print "description:"
         print changes[4]
 
+def init(ui):
+    """create a repository"""
+    hg.repository(ui, ".", create=1)
+
+def log(ui, repo, f):
+    f = relpath(repo, [f])[0]
+
+    r = repo.file(f)
+    for i in range(r.count()):
+        n = r.node(i)
+        (p1, p2) = r.parents(n)
+        (h, h1, h2) = map(hg.hex, (n, p1, p2))
+        (i1, i2) = map(r.rev, (p1, p2))
+        cr = r.linkrev(n)
+        cn = hg.hex(repo.changelog.node(cr))
+        print "rev:       %4d:%s" % (i, h)
+        print "changeset: %4d:%s" % (cr, cn)
+        print "parents:   %4d:%s" % (i1, h1)
+        if i2: print "           %4d:%s" % (i2, h2)
+        changes = repo.changelog.read(repo.changelog.node(cr))
+        print "user: %s" % changes[1]
+        print "date: %s" % time.asctime(
+            time.localtime(float(changes[2].split(' ')[0])))
+        print "description:"
+        print changes[4].rstrip()
+        print
+
 def parents(ui, repo, node = None):
     '''show the parents of the current working dir'''
     if node:
         p = repo.changelog.parents(repo.lookup(hg.bin(node)))
     else:
         p = repo.dirstate.parents()
 
     for n in p:
         if n != hg.nullid:
             ui.write("%d:%s\n" % (repo.changelog.rev(n), hg.hex(n)))
 
+def recover(ui, repo):
+    repo.recover()
+
+def remove(ui, repo, file, *files):
+    """remove the specified files on the next commit"""
+    repo.remove(relpath(repo, (file,) + files))
+
 def resolve(ui, repo, node = None):
     '''merge a given node or the current tip into the working dir'''
     if not node:
         node = repo.changelog.tip()
     else:
         node = repo.lookup(node)
     repo.resolve(node)
 
+def serve(ui, repo, **opts):
+    from mercurial import hgweb
+    hgweb.server(repo.root, opts["name"], opts["templates"],
+                 opts["address"], opts["port"])
+    
 def status(ui, repo):
     '''show changed files in the working directory
 
 C = changed
 A = added
 R = removed
 ? = not tracked'''
+    
     (c, a, d, u) = repo.diffdir(repo.root)
     (c, a, d, u) = map(lambda x: relfilter(repo, x), (c, a, d, u))
 
     for f in c: print "C", f
     for f in a: print "A", f
     for f in d: print "R", f
     for f in u: print "?", f
 
+def tip(ui, repo):
+    n = repo.changelog.tip()
+    t = repo.changelog.rev(n)
+    ui.status("%d:%s\n" % (t, hg.hex(n)))
+
 def undo(ui, repo):
     repo.undo()
 
 table = {
-    "init": (init, [], 'hg init'),
-    "branch|clone": (branch, [], 'hg branch [path]'),
-    "heads": (heads, [], 'hg heads'),
-    "help": (help, [], 'hg help [command]'),
-    "checkout|co": (checkout, [], 'hg checkout [changeset]'),
+    "add": (add, [], "hg add [files]"),
+    "addremove": (addremove, [], "hg addremove"),
     "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]'),
+    "branch|clone": (branch, [], 'hg branch [path]'),
+    "checkout|co": (checkout, [], 'hg checkout [changeset]'),
+    "commit|ci": (commit, [], 'hg commit [files]'),
+    "diff": (diff, [('r', 'rev', [], 'revision')],
+             'hg diff [-r A] [-r B] [files]'),
+    "forget": (forget, [], "hg forget [files]"),
+    "heads": (heads, [], 'hg heads'),
+    "help": (help, [], 'hg help [command]'),
+    "init": (init, [], 'hg init'),
+    "log": (log, [], 'hg log <file>'),
     "parents": (parents, [], 'hg parents [node]'),
+    "recover": (recover, [], "hg recover"),
+    "remove": (remove, [], "hg remove [files]"),
     "resolve": (resolve, [], 'hg resolve [node]'),
+    "serve": (serve, [('p', 'port', 8000, 'listen port'),
+                      ('a', 'address', '', 'interface address'),
+                      ('n', 'name', os.getcwd(), 'repository name'),
+                      ('t', 'templates', "", 'template map')],
+              "hg serve [options]"),
     "status": (status, [], 'hg status'),
+    "tip": (tip, [], 'hg tip'),
     "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)
 
 class SignalInterrupt(Exception): pass
 
 def catchterm(*args):
     raise SignalInterrupt
 
 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"])
 
     # deal with unfound commands later
     i = find(cmd)
 
     signal.signal(signal.SIGTERM, catchterm)
 
     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)
     else:
         d = lambda: i[0](u, *args, **cmdoptions)
 
     try:
         d()
     except SignalInterrupt:
         u.warn("killed!\n")
     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)