Migrate rawcommit, import, export, history, and merge

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

Migrate rawcommit, import, export, history, and merge

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

iD8DBQFCoguVywK+sNU5EO8RAtohAKCe9Qr5R+YeLRluJlTxRGrJW/nnoQCfW/+F
I0BSOeNpb6jdUxTZY1jV0xo=
=hNXm
-----END PGP SIGNATURE-----

hg

@@ -1,411 +1,244 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
+import sys
 from mercurial import hg, mdiff, fancyopts, ui, commands
 
-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 == "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 == "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":
+if 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 == "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 == "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 == "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)
 
 else:
     if cmd: ui.warn("unknown command\n\n")
     sys.exit(1)

mercurial/commands.py

@@ -1,386 +1,502 b''
 import os, re, traceback, sys, signal, time, mdiff
 from mercurial import fancyopts, ui, hg
 
 class UnknownCommand(Exception): pass
 
 def filterfiles(filters, files):
     l = [ x for x in files if x in filters ]
 
     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, files):
     if os.getcwd() != repo.root:
         p = os.getcwd()[len(repo.root) + 1: ]
         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.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 add(ui, repo, file, *files):
     '''add the specified files on the next commit'''
     repo.add(relpath(repo, (file,) + files))
 
 def addremove(ui, repo):
     (c, a, d, u) = repo.diffdir(repo.root)
     repo.add(a)
     repo.remove(d)
 
 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
 
     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 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 export(ui, repo, changeset):
+    node = repo.lookup(changeset)
+    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].rstrip()
+    print
+    
+    dodiff(repo, None, prev, node)
+
 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 history(ui, repo):
+    """show the changelog 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]
+
+def patch(ui, repo, patches, opts):
+    """import an ordered set of patches"""
+    try:
+        import psyco
+        psyco.full()
+    except:
+        pass
+    
+    d = opts["base"]
+    strip = opts["strip"]
+    quiet = opts["quiet"] and "> /dev/null" or ""
+
+    for patch in patches:
+        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)
+
 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 pull(ui, repo, source):
+    """pull changes from the specified source"""
+    paths = {}
+    try:
+        pf = os.path.expanduser("~/.hgpaths")
+        for l in file(pf):
+            name, path = l.split()
+            paths[name] = path
+    except IOError:
+        pass
+
+    if source in paths: source = paths[source]
+    
+    other = hg.repository(ui, source)
+    cg = repo.getchangegroup(other)
+    repo.addchangegroup(cg)
+
+def rawcommit(ui, repo, files, rc):
+    "raw commit interface"
+
+    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"
+        return 1
+
+    files = relpath(repo, files)
+    if rc['files']:
+        files += open(rc['files']).read().splitlines()
+        
+    repo.rawcommit(files, text, rc['user'], rc['date'], *rc['parent'])
+ 
 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 = {
     "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]'),
+    "export": (export, [], "hg export <changeset>"),
     "forget": (forget, [], "hg forget [files]"),
     "heads": (heads, [], 'hg heads'),
+    "history": (history, [], 'hg history'),
     "help": (help, [], 'hg help [command]'),
     "init": (init, [], 'hg init'),
     "log": (log, [], 'hg log <file>'),
     "parents": (parents, [], 'hg parents [node]'),
+    "patch|import": (patch,
+                     [('p', 'strip', 1, 'path strip'),
+                      ('b', 'base', "", 'base path'),
+                      ('q', 'quiet', "", 'silence diff')],
+                     "hg import [options] patches"),
+    "pull|merge": (pull, [], 'hg pull [source]'),
+    "rawcommit": (rawcommit,
+                  [('p', 'parent', [], 'parent'),
+                   ('d', 'date', "", 'data'),
+                   ('u', 'user', "", 'user'),
+                   ('F', 'files', "", 'file list'),
+                   ('t', 'text', "", 'commit text'),
+                   ('l', 'logfile', "", 'commit text file')],
+                  'hg rawcommit [options] [files]'),
     "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()
+        return 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)