move repo.current to dirstate.parents()

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

move repo.current to dirstate.parents()

dirstate now tracks the parents for the working dir
add a parents command to show them

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

iD8DBQFCoMGuywK+sNU5EO8RAg5UAKCVLUrsJtkoIOTM+e0BLqEVN3Ni3gCeNDyy
ZF8jD728cl9K7S4sIN4gX4Y=
=P4bu
-----END PGP SIGNATURE-----

hg

@@ -1,533 +1,532 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.current
+            node1 = repo.dirstate.parents()[0]
         (c, a, d, u) = repo.diffdir(repo.root, node1)
-        a = [] # ignore unknown files in repo, by popular request
         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(repo.current, args)
+            repo.commit(args)
         else:
-            repo.commit(repo.current)
+            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(repo.current, files, text)
+        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.current)
     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,240 +1,252 b''
 import os, re, traceback, sys, signal, time
 from mercurial import fancyopts, ui, hg
 
 class UnknownCommand(Exception): pass
 
 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 relfilter(repo, args):
     if os.getcwd() != repo.root:
         p = os.getcwd()[len(repo.root) + 1: ]
         return filterfiles(p, args)
     return args
 
 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, 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 checkout(ui, repo, changeset=None):
     '''checkout a given changeset or the current tip'''
     (c, a, d, u) = repo.diffdir(repo.root, repo.current)
     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 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
+    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:
         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 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 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 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, repo.current)
     (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 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]'),
     "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]'),
+    "parents": (parents, [], 'hg parents [node]'),
     "status": (status, [], 'hg status'),
     "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)

mercurial/hg.py

@@ -1,1127 +1,1133 b''
 # hg.py - repository classes for mercurial
 #
 # 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.
 
 import sys, struct, sha, socket, os, time, re, urllib2, tempfile
 import urllib
 from mercurial import byterange, lock
 from mercurial.transaction import *
 from mercurial.revlog import *
 from difflib import SequenceMatcher
 
 class filelog(revlog):
     def __init__(self, opener, path):
         revlog.__init__(self, opener,
                         os.path.join("data", path + ".i"),
                         os.path.join("data", path + ".d"))
 
     def read(self, node):
         return self.revision(node)
     def add(self, text, transaction, link, p1=None, p2=None):
         return self.addrevision(text, transaction, link, p1, p2)
 
     def annotate(self, node):
 
         def decorate(text, rev):
             return [(rev, l) for l in text.splitlines(1)]
 
         def strip(annotation):
             return [e[1] for e in annotation]
 
         def pair(parent, child):
             new = []
             sm = SequenceMatcher(None, strip(parent), strip(child))
             for o, m, n, s, t in sm.get_opcodes():
                 if o == 'equal':
                     new += parent[m:n]
                 else:
                     new += child[s:t]
             return new
 
         # find all ancestors
         needed = {node:1}
         visit = [node]
         while visit:
             n = visit.pop(0)
             for p in self.parents(n):
                 if p not in needed:
                     needed[p] = 1
                     visit.append(p)
                 else:
                     # count how many times we'll use this
                     needed[p] += 1
 
         # sort by revision which is a topological order
         visit = needed.keys()
         visit = [ (self.rev(n), n) for n in visit ]
         visit.sort()
         visit = [ p[1] for p in visit ]
         hist = {}
 
         for n in visit:
             curr = decorate(self.read(n), self.linkrev(n))
             for p in self.parents(n):
                 if p != nullid:
                     curr = pair(hist[p], curr)
                     # trim the history of unneeded revs
                     needed[p] -= 1
                     if not needed[p]:
                         del hist[p]
             hist[n] = curr
 
         return hist[n]
 
 class manifest(revlog):
     def __init__(self, opener):
         self.mapcache = None
         self.listcache = None
         self.addlist = None
         revlog.__init__(self, opener, "00manifest.i", "00manifest.d")
 
     def read(self, node):
         if self.mapcache and self.mapcache[0] == node:
             return self.mapcache[1].copy()
         text = self.revision(node)
         map = {}
         self.listcache = (text, text.splitlines(1))
         for l in self.listcache[1]:
             (f, n) = l.split('\0')
             map[f] = bin(n[:40])
         self.mapcache = (node, map)
         return map
 
     def diff(self, a, b):
         # this is sneaky, as we're not actually using a and b
         if self.listcache and self.addlist and self.listcache[0] == a:
             d = mdiff.diff(self.listcache[1], self.addlist, 1)
             if mdiff.patch(a, d) != b:
                 sys.stderr.write("*** sortdiff failed, falling back ***\n")
                 return mdiff.textdiff(a, b)
             return d
         else:
             return mdiff.textdiff(a, b)
 
     def add(self, map, transaction, link, p1=None, p2=None):
         files = map.keys()
         files.sort()
 
         self.addlist = ["%s\000%s\n" % (f, hex(map[f])) for f in files]
         text = "".join(self.addlist)
 
         n = self.addrevision(text, transaction, link, p1, p2)
         self.mapcache = (n, map)
         self.listcache = (text, self.addlist)
         self.addlist = None
 
         return n
 
 class changelog(revlog):
     def __init__(self, opener):
         revlog.__init__(self, opener, "00changelog.i", "00changelog.d")
 
     def extract(self, text):
         if not text:
             return (nullid, "", "0", [], "")
         last = text.index("\n\n")
         desc = text[last + 2:]
         l = text[:last].splitlines()
         manifest = bin(l[0])
         user = l[1]
         date = l[2]
         files = l[3:]
         return (manifest, user, date, files, desc)
 
     def read(self, node):
         return self.extract(self.revision(node))
 
     def add(self, manifest, list, desc, transaction, p1=None, p2=None,
                   user=None, date=None):
         user = (user or
                 os.environ.get("HGUSER") or
                 os.environ.get("EMAIL") or
                 os.environ.get("LOGNAME", "unknown") + '@' + socket.getfqdn())
         date = date or "%d %d" % (time.time(), time.timezone)
         list.sort()
         l = [hex(manifest), user, date] + list + ["", desc]
         text = "\n".join(l)
         return self.addrevision(text, transaction, self.count(), p1, p2)
 
 class dirstate:
     def __init__(self, opener, ui):
         self.opener = opener
         self.dirty = 0
         self.ui = ui
         self.map = None
+        self.pl = None
 
     def __del__(self):
         if self.dirty:
             self.write()
 
     def __getitem__(self, key):
         try:
             return self.map[key]
         except TypeError:
             self.read()
             return self[key]
 
     def __contains__(self, key):
         if not self.map: self.read()
         return key in self.map
 
+    def parents(self):
+        if not self.pl:
+            self.read()
+        return self.pl
+
+    def setparents(self, p1, p2 = nullid):
+        self.dirty = 1
+        self.pl = p1, p2
+
     def state(self, key):
         try:
             return self[key][0]
         except KeyError:
             return "?"
 
     def read(self):
         if self.map is not None: return self.map
 
         self.map = {}
+        self.pl = [nullid, nullid]
         try:
             st = self.opener("dirstate").read()
         except: return
 
-        pos = 0
+        self.pl = [st[:20], st[20: 40]]
+
+        pos = 40
         while pos < len(st):
             e = struct.unpack(">cllll", st[pos:pos+17])
             l = e[4]
             pos += 17
             f = st[pos:pos + l]
             self.map[f] = e[:4]
             pos += l
         
     def update(self, files, state):
         ''' current states:
         n  normal
         i  invalid
         r  marked for removal
         a  marked for addition'''
 
         if not files: return
         self.read()
         self.dirty = 1
         for f in files:
             if state == "r":
                 self.map[f] = ('r', 0, 0, 0)
             else:
                 try:
                     s = os.stat(f)
                     self.map[f] = (state, s.st_mode, s.st_size, s.st_mtime)
                 except OSError:
                     if state != "i": raise
                     self.map[f] = ('r', 0, 0, 0)
 
     def forget(self, files):
         if not files: return
         self.read()
         self.dirty = 1
         for f in files:
             try:
                 del self.map[f]
             except KeyError:
                 self.ui.warn("not in dirstate: %s!\n" % f)
                 pass
 
     def clear(self):
         self.map = {}
         self.dirty = 1
 
     def write(self):
         st = self.opener("dirstate", "w")
+        st.write("".join(self.pl))
         for f, e in self.map.items():
             e = struct.pack(">cllll", e[0], e[1], e[2], e[3], len(f))
             st.write(e + f)
         self.dirty = 0
 
     def copy(self):
         self.read()
         return self.map.copy()
 
 # used to avoid circular references so destructors work
 def opener(base):
     p = base
     def o(path, mode="r"):
         if p[:7] == "http://":
             f = os.path.join(p, urllib.quote(path))
             return httprangereader(f)
 
         f = os.path.join(p, path)
 
         if mode != "r":
             try:
                 s = os.stat(f)
             except OSError:
                 d = os.path.dirname(f)
                 if not os.path.isdir(d):
                     os.makedirs(d)
             else:
                 if s.st_nlink > 1:
                     file(f + ".tmp", "w").write(file(f).read())
                     os.rename(f+".tmp", f)
 
         return file(f, mode)
 
     return o
 
 class localrepository:
     def __init__(self, ui, path=None, create=0):
         self.remote = 0
         if path and path[:7] == "http://":
             self.remote = 1
             self.path = path
         else:
             if not path:
                 p = os.getcwd()
                 while not os.path.isdir(os.path.join(p, ".hg")):
                     p = os.path.dirname(p)
                     if p == "/": raise "No repo found"
                 path = p
             self.path = os.path.join(path, ".hg")
 
         self.root = path
         self.ui = ui
 
         if create:
             os.mkdir(self.path)  
             os.mkdir(self.join("data"))
 
         self.opener = opener(self.path)
         self.manifest = manifest(self.opener)
         self.changelog = changelog(self.opener)
         self.ignorelist = None
         self.tags = None
 
         if not self.remote:
             self.dirstate = dirstate(self.opener, ui)
-            try:
-                self.current = bin(self.opener("current").read())
-            except IOError:
-                self.current = None
 
-    def setcurrent(self, node):
-        self.current = node
-        self.opener("current", "w").write(hex(node))
-      
     def ignore(self, f):
         if self.ignorelist is None:
             self.ignorelist = []
             try:
                 l = open(os.path.join(self.root, ".hgignore"))
                 for pat in l:
                     if pat != "\n":
                         self.ignorelist.append(re.compile(pat[:-1]))
             except IOError: pass
         for pat in self.ignorelist:
             if pat.search(f): return True
         return False
 
     def lookup(self, key):
         if self.tags is None:
             self.tags = {}
             try:
                 fl = self.file(".hgtags")
                 for l in fl.revision(fl.tip()).splitlines():
                     if l:
                         n, k = l.split(" ")
                         self.tags[k] = bin(n)
             except KeyError: pass
         try:
             return self.tags[key]
         except KeyError:
             return self.changelog.lookup(key)
 
     def join(self, f):
         return os.path.join(self.path, f)
 
     def file(self, f):
         if f[0] == '/': f = f[1:]
         return filelog(self.opener, f)
 
     def transaction(self):
         return transaction(self.opener, self.join("journal"),
                            self.join("undo"))
 
     def recover(self):
         lock = self.lock()
         if os.path.exists(self.join("recover")):
             self.ui.status("attempting to rollback interrupted transaction\n")
             return rollback(self.opener, self.join("recover"))
         else:
             self.ui.warn("no interrupted transaction available\n")
 
     def undo(self):
         lock = self.lock()
         if os.path.exists(self.join("undo")):
             f = self.changelog.read(self.changelog.tip())[3]
             self.ui.status("attempting to rollback last transaction\n")
             rollback(self.opener, self.join("undo"))
             self.manifest = manifest(self.opener)
             self.changelog = changelog(self.opener)
 
             self.ui.status("discarding dirstate\n")
             node = self.changelog.tip()
             f.sort()
 
-            self.setcurrent(node)
+            self.dirstate.setparents(node)
             self.dirstate.update(f, 'i')
         
         else:
             self.ui.warn("no undo information available\n")
 
     def lock(self, wait = 1):
         try:
             return lock.lock(self.join("lock"), 0)
         except lock.LockHeld, inst:
             if wait:
                 self.ui.warn("waiting for lock held by %s\n" % inst.args[0])
                 return lock.lock(self.join("lock"), wait)
             raise inst
 
     def rawcommit(self, files, text, user, date, p1=None, p2=None):
         p1 = p1 or self.current or nullid
         pchange = self.changelog.read(p1)
         pmmap = self.manifest.read(pchange[0])
         tr = self.transaction()
         mmap = {}
         linkrev = self.changelog.count()
         for f in files:
             try:
                 t = file(f).read()
             except IOError:
                 self.ui.warn("Read file %s error, skipped\n" % f)
                 continue
             r = self.file(f)
             prev = pmmap.get(f, nullid)
             mmap[f] = r.add(t, tr, linkrev, prev)
 
         mnode = self.manifest.add(mmap, tr, linkrev, pchange[0])
         n = self.changelog.add(mnode, files, text, tr, p1, p2, user ,date, )
         tr.close()
         self.setcurrent(n)
         self.dirstate.clear()
         self.dirstate.update(mmap.keys(), "n")
 
     def commit(self, parent, files = None, text = ""):
         self.lock()
 
         commit = []
         remove = []
         if files:
             for f in files:
                 s = self.dirstate.state(f)
                 if s in 'cai':
                     commit.append(f)
                 elif s == 'r':
                     remove.append(f)
                 else:
                     self.warn("%s not tracked!\n")
         else:
             (c, a, d, u) = self.diffdir(self.root, parent)
             commit = c + a
             remove = d
 
         if not commit and not remove:
             self.ui.status("nothing changed\n")
             return
 
         lock = self.lock()
         tr = self.transaction()
 
         # check in files
         new = {}
         linkrev = self.changelog.count()
         commit.sort()
         for f in commit:
             self.ui.note(f + "\n")
             try:
                 t = file(f).read()
             except IOError:
                 self.warn("trouble committing %s!\n" % f)
                 raise
 
             r = self.file(f)
             new[f] = r.add(t, tr, linkrev)
 
         # update manifest
         mmap = self.manifest.read(self.manifest.tip())
         mmap.update(new)
         for f in remove:
             del mmap[f]
         mnode = self.manifest.add(mmap, tr, linkrev)
 
         # add changeset
         new = new.keys()
         new.sort()
 
         edittext = text + "\n" + "HG: manifest hash %s\n" % hex(mnode)
         edittext += "".join(["HG: changed %s\n" % f for f in new])
         edittext += "".join(["HG: removed %s\n" % f for f in remove])
         edittext = self.ui.edit(edittext)
 
         n = self.changelog.add(mnode, new, edittext, tr)
         tr.close()
 
         self.setcurrent(n)
         self.dirstate.update(new, "n")
         self.dirstate.forget(remove)
 
     def checkout(self, node):
         # checkout is really dumb at the moment
         # it ought to basically merge
         change = self.changelog.read(node)
         l = self.manifest.read(change[0]).items()
         l.sort()
 
         for f,n in l:
             if f[0] == "/": continue
             self.ui.note(f, "\n")
             t = self.file(f).revision(n)
             try:
                 file(f, "w").write(t)
             except IOError:
                 os.makedirs(os.path.dirname(f))
                 file(f, "w").write(t)
 
-        self.setcurrent(node)
+        self.dirstate.setparents(node)
         self.dirstate.clear()
         self.dirstate.update([f for f,n in l], "n")
 
     def diffdir(self, path, changeset):
         changed = []
         added = []
         unknown = []
         mf = {}
 
         if changeset:
             change = self.changelog.read(changeset)
             mf = self.manifest.read(change[0])
 
         if changeset == self.current:
             dc = self.dirstate.copy()
         else:
             dc = dict.fromkeys(mf)
 
         def fcmp(fn):
             t1 = file(os.path.join(self.root, fn)).read()
             t2 = self.file(fn).revision(mf[fn])
             return cmp(t1, t2)
 
         for dir, subdirs, files in os.walk(self.root):
             d = dir[len(self.root)+1:]
             if ".hg" in subdirs: subdirs.remove(".hg")
             
             for f in files:
                 fn = os.path.join(d, f)
                 try: s = os.stat(os.path.join(self.root, fn))
                 except: continue
                 if fn in dc:
                     c = dc[fn]
                     del dc[fn]
                     if not c:
                         if fcmp(fn):
                             changed.append(fn)
                     if c[0] == 'i':
                         if fn not in mf:
                             added.append(fn)
                         elif fcmp(fn):
                             changed.append(fn)
                     elif c[0] == 'a':
                         added.append(fn)
                     elif c[0] == 'r':
                         unknown.append(fn)
                     elif c[2] != s.st_size:
                         changed.append(fn)
                     elif c[1] != s.st_mode or c[3] != s.st_mtime:
                         if fcmp(fn):
                             changed.append(fn)
                 else:
                     if self.ignore(fn): continue
                     unknown.append(fn)
 
         deleted = dc.keys()
         deleted.sort()
 
         return (changed, added, deleted, unknown)
 
     def diffrevs(self, node1, node2):
         changed, added = [], []
 
         change = self.changelog.read(node1)
         mf1 = self.manifest.read(change[0])
         change = self.changelog.read(node2)
         mf2 = self.manifest.read(change[0])
 
         for fn in mf2:
             if mf1.has_key(fn):
                 if mf1[fn] != mf2[fn]:
                     changed.append(fn)
                 del mf1[fn]
             else:
                 added.append(fn)
                 
         deleted = mf1.keys()
         deleted.sort()
     
         return (changed, added, deleted)
 
     def add(self, list):
         for f in list:
             p = os.path.join(self.root, f)
             if not os.path.isfile(p):
                 self.ui.warn("%s does not exist!\n" % f)
             elif self.dirstate.state(f) == 'n':
                 self.ui.warn("%s already tracked!\n" % f)
             else:
                 self.dirstate.update([f], "a")
 
     def forget(self, list):
         for f in list:
             if self.dirstate.state(f) not in 'ai':
                 self.ui.warn("%s not added!\n" % f)
             else:
                 self.dirstate.forget([f])
 
     def remove(self, list):
         for f in list:
             p = os.path.join(self.root, f)
             if os.path.isfile(p):
                 self.ui.warn("%s still exists!\n" % f)
             elif f not in self.dirstate:
                 self.ui.warn("%s not tracked!\n" % f)
             else:
                 self.dirstate.update([f], "r")
 
     def heads(self):
         return self.changelog.heads()
 
     def branches(self, nodes):
         if not nodes: nodes = [self.changelog.tip()]
         b = []
         for n in nodes:
             t = n
             while n:
                 p = self.changelog.parents(n)
                 if p[1] != nullid or p[0] == nullid:
                     b.append((t, n, p[0], p[1]))
                     break
                 n = p[0]
         return b
 
     def between(self, pairs):
         r = []
 
         for top, bottom in pairs:
             n, l, i = top, [], 0
             f = 1
 
             while n != bottom:
                 p = self.changelog.parents(n)[0]
                 if i == f:
                     l.append(n) 
                     f = f * 2
                 n = p
                 i += 1
 
             r.append(l)
 
         return r
 
     def newer(self, nodes):
         m = {}
         nl = []
         pm = {}
         cl = self.changelog
         t = l = cl.count()
 
         # find the lowest numbered node
         for n in nodes:
             l = min(l, cl.rev(n))
             m[n] = 1
 
         for i in xrange(l, t):
             n = cl.node(i)
             if n in m: # explicitly listed
                 pm[n] = 1
                 nl.append(n)
                 continue
             for p in cl.parents(n):
                 if p in pm: # parent listed
                     pm[n] = 1
                     nl.append(n)
                     break
 
         return nl
 
     def getchangegroup(self, remote):
         m = self.changelog.nodemap
         search = []
         fetch = []
         seen = {}
         seenbranch = {}
 
         # if we have an empty repo, fetch everything
         if self.changelog.tip() == nullid:
             self.ui.status("requesting all changes\n")
             return remote.changegroup([nullid])
 
         # otherwise, assume we're closer to the tip than the root
         self.ui.status("searching for changes\n")
         heads = remote.heads()
         unknown = []
         for h in heads:
             if h not in m:
                 unknown.append(h)
 
         if not unknown:
             self.ui.status("nothing to do!\n")
             return None
             
         unknown = remote.branches(unknown)
         while unknown:
             n = unknown.pop(0)
             seen[n[0]] = 1
             
             self.ui.debug("examining %s:%s\n" % (short(n[0]), short(n[1])))
             if n == nullid: break
             if n in seenbranch:
                 self.ui.debug("branch already found\n")
                 continue
             if n[1] and n[1] in m: # do we know the base?
                 self.ui.debug("found incomplete branch %s:%s\n"
                               % (short(n[0]), short(n[1])))
                 search.append(n) # schedule branch range for scanning
                 seenbranch[n] = 1
             else:
                 if n[2] in m and n[3] in m:
                     if n[1] not in fetch:
                         self.ui.debug("found new changeset %s\n" %
                                       short(n[1]))
                         fetch.append(n[1]) # earliest unknown
                         continue
 
                 r = []
                 for a in n[2:4]:
                     if a not in seen: r.append(a)
                     
                 if r:
                     self.ui.debug("requesting %s\n" %
                                 " ".join(map(short, r)))
                     for b in remote.branches(r):
                         self.ui.debug("received %s:%s\n" %
                                       (short(b[0]), short(b[1])))
                         if b[0] not in m and b[0] not in seen:
                             unknown.append(b)
   
         while search:
             n = search.pop(0)
             l = remote.between([(n[0], n[1])])[0]
             p = n[0]
             f = 1
             for i in l + [n[1]]:
                 if i in m:
                     if f <= 2:
                         self.ui.debug("found new branch changeset %s\n" %
                                           short(p))
                         fetch.append(p)
                     else:
                         self.ui.debug("narrowed branch search to %s:%s\n"
                                       % (short(p), short(i)))
                         search.append((p, i))
                     break
                 p, f = i, f * 2
 
         for f in fetch:
             if f in m:
                 raise "already have", short(f[:4])
 
         self.ui.note("adding new changesets starting at " +
                      " ".join([short(f) for f in fetch]) + "\n")
 
         return remote.changegroup(fetch)
     
     def changegroup(self, basenodes):
         nodes = self.newer(basenodes)
 
         # construct the link map
         linkmap = {}
         for n in nodes:
             linkmap[self.changelog.rev(n)] = n
 
         # construct a list of all changed files
         changed = {}
         for n in nodes:
             c = self.changelog.read(n)
             for f in c[3]:
                 changed[f] = 1
         changed = changed.keys()
         changed.sort()
 
         # the changegroup is changesets + manifests + all file revs
         revs = [ self.changelog.rev(n) for n in nodes ]
 
         for y in self.changelog.group(linkmap): yield y
         for y in self.manifest.group(linkmap): yield y
         for f in changed:
             yield struct.pack(">l", len(f) + 4) + f
             g = self.file(f).group(linkmap)
             for y in g:
                 yield y
 
     def addchangegroup(self, generator):
 
         class genread:
             def __init__(self, generator):
                 self.g = generator
                 self.buf = ""
             def read(self, l):
                 while l > len(self.buf):
                     try:
                         self.buf += self.g.next()
                     except StopIteration:
                         break
                 d, self.buf = self.buf[:l], self.buf[l:]
                 return d
                 
         def getchunk():
             d = source.read(4)
             if not d: return ""
             l = struct.unpack(">l", d)[0]
             if l <= 4: return ""
             return source.read(l - 4)
 
         def getgroup():
             while 1:
                 c = getchunk()
                 if not c: break
                 yield c
 
         def csmap(x):
             self.ui.debug("add changeset %s\n" % short(x))
             return self.changelog.count()
 
         def revmap(x):
             return self.changelog.rev(x)
 
         if not generator: return
         changesets = files = revisions = 0
 
         source = genread(generator)
         lock = self.lock()
         tr = self.transaction()
 
         # pull off the changeset group
         self.ui.status("adding changesets\n")
         co = self.changelog.tip()
         cn = self.changelog.addgroup(getgroup(), csmap, tr, 1) # unique
         changesets = self.changelog.rev(cn) - self.changelog.rev(co)
 
         # pull off the manifest group
         self.ui.status("adding manifests\n")
         mm = self.manifest.tip()
         mo = self.manifest.addgroup(getgroup(), revmap, tr)
 
         # process the files
         self.ui.status("adding file revisions\n")
         while 1:
             f = getchunk()
             if not f: break
             self.ui.debug("adding %s revisions\n" % f)
             fl = self.file(f)
             o = fl.tip()
             n = fl.addgroup(getgroup(), revmap, tr)
             revisions += fl.rev(n) - fl.rev(o)
             files += 1
 
         self.ui.status(("modified %d files, added %d changesets" +
                         " and %d new revisions\n")
                        % (files, changesets, revisions))
 
         tr.close()
         return
 
     def merge(self, generator):
         changesets = files = revisions = 0
 
         self.lock()
         class genread:
             def __init__(self, generator):
                 self.g = generator
                 self.buf = ""
             def read(self, l):
                 while l > len(self.buf):
                     try:
                         self.buf += self.g.next()
                     except StopIteration:
                         break
                 d, self.buf = self.buf[:l], self.buf[l:]
                 return d
                 
         if not generator: return
         source = genread(generator)
 
         def getchunk():
             d = source.read(4)
             if not d: return ""
             l = struct.unpack(">l", d)[0]
             if l <= 4: return ""
             return source.read(l - 4)
 
         def getgroup():
             while 1:
                 c = getchunk()
                 if not c: break
                 yield c
 
         tr = self.transaction()
         simple = True
         need = {}
 
         self.ui.status("adding changesets\n")
         # pull off the changeset group
         def report(x):
             self.ui.debug("add changeset %s\n" % short(x))
             return self.changelog.count()
 
         co = self.changelog.tip()
         cn = self.changelog.addgroup(getgroup(), report, tr)
 
         changesets = self.changelog.rev(cn) - self.changelog.rev(co)
 
         self.ui.status("adding manifests\n")
         # pull off the manifest group
         mm = self.manifest.tip()
         mo = self.manifest.addgroup(getgroup(),
                                     lambda x: self.changelog.rev(x), tr)
 
         # do we need a resolve?
         if self.changelog.ancestor(co, cn) != co:
             simple = False
             resolverev = self.changelog.count()
 
             # resolve the manifest to determine which files
             # we care about merging
             self.ui.status("resolving manifests\n")
             ma = self.manifest.ancestor(mm, mo)
             omap = self.manifest.read(mo) # other
             amap = self.manifest.read(ma) # ancestor
             mmap = self.manifest.read(mm) # mine
             nmap = {}
 
             self.ui.debug(" ancestor %s local %s remote %s\n" %
                           (short(ma), short(mm), short(mo)))
 
             for f, mid in mmap.iteritems():
                 if f in omap:
                     if mid != omap[f]:
                         self.ui.debug(" %s versions differ, do resolve\n" % f)
                         need[f] = mid # use merged version or local version
                     else:
                         nmap[f] = mid # keep ours
                     del omap[f]
                 elif f in amap:
                     if mid != amap[f]:
                         r = self.ui.prompt(
                             (" local changed %s which remote deleted\n" % f) +
                             "(k)eep or (d)elete?", "[kd]", "k")
                         if r == "k": nmap[f] = mid
                     else:
                         self.ui.debug("other deleted %s\n" % f)
                         pass # other deleted it
                 else:
                     self.ui.debug("local created %s\n" %f)
                     nmap[f] = mid # we created it
 
             del mmap
 
             for f, oid in omap.iteritems():
                 if f in amap:
                     if oid != amap[f]:
                         r = self.ui.prompt(
                             ("remote changed %s which local deleted\n" % f) +
                             "(k)eep or (d)elete?", "[kd]", "k")
                         if r == "k": nmap[f] = oid
                     else:
                         pass # probably safe
                 else:
                     self.ui.debug("remote created %s, do resolve\n" % f)
                     need[f] = oid
 
             del omap
             del amap
 
         new = need.keys()
         new.sort()
 
         # process the files
         self.ui.status("adding files\n")
         while 1:
             f = getchunk()
             if not f: break
             self.ui.debug("adding %s revisions\n" % f)
             fl = self.file(f)
             o = fl.tip()
             n = fl.addgroup(getgroup(), lambda x: self.changelog.rev(x), tr)
             revisions += fl.rev(n) - fl.rev(o)
             files += 1
             if f in need:
                 del need[f]
                 # manifest resolve determined we need to merge the tips
                 nmap[f] = self.merge3(fl, f, o, n, tr, resolverev)
 
         if need:
             # we need to do trivial merges on local files
             for f in new:
                 if f not in need: continue
                 fl = self.file(f)
                 nmap[f] = self.merge3(fl, f, need[f], fl.tip(), tr, resolverev)
                 revisions += 1
 
         # For simple merges, we don't need to resolve manifests or changesets
         if simple:
             self.ui.debug("simple merge, skipping resolve\n")
             self.ui.status(("modified %d files, added %d changesets" +
                            " and %d new revisions\n")
                            % (files, changesets, revisions))
             tr.close()
             return
 
         node = self.manifest.add(nmap, tr, resolverev, mm, mo)
         revisions += 1
 
         # Now all files and manifests are merged, we add the changed files
         # and manifest id to the changelog
         self.ui.status("committing merge changeset\n")
         if co == cn: cn = -1
 
         edittext = "\nHG: merge resolve\n" + \
                    "HG: manifest hash %s\n" % hex(node) + \
                    "".join(["HG: changed %s\n" % f for f in new])
         edittext = self.ui.edit(edittext)
         n = self.changelog.add(node, new, edittext, tr, co, cn)
         revisions += 1
 
         self.ui.status("added %d changesets, %d files, and %d new revisions\n"
                        % (changesets, files, revisions))
 
         tr.close()
 
     def merge3(self, fl, fn, my, other, transaction, link):
         """perform a 3-way merge and append the result"""
         
         def temp(prefix, node):
             pre = "%s~%s." % (os.path.basename(fn), prefix)
             (fd, name) = tempfile.mkstemp("", pre)
             f = os.fdopen(fd, "w")
             f.write(fl.revision(node))
             f.close()
             return name
 
         base = fl.ancestor(my, other)
         self.ui.note("resolving %s\n" % fn)
         self.ui.debug("local %s remote %s ancestor %s\n" %
                               (short(my), short(other), short(base)))
 
         if my == base: 
             text = fl.revision(other)
         else:
             a = temp("local", my)
             b = temp("remote", other)
             c = temp("parent", base)
 
             cmd = os.environ["HGMERGE"]
             self.ui.debug("invoking merge with %s\n" % cmd)
             r = os.system("%s %s %s %s %s" % (cmd, a, b, c, fn))
             if r:
                 raise "Merge failed!"
 
             text = open(a).read()
             os.unlink(a)
             os.unlink(b)
             os.unlink(c)
             
         return fl.add(text, transaction, link, my, other)
 
 class remoterepository:
     def __init__(self, ui, path):
         self.url = path
         self.ui = ui
 
     def do_cmd(self, cmd, **args):
         self.ui.debug("sending %s command\n" % cmd)
         q = {"cmd": cmd}
         q.update(args)
         qs = urllib.urlencode(q)
         cu = "%s?%s" % (self.url, qs)
         return urllib.urlopen(cu)
 
     def heads(self):
         d = self.do_cmd("heads").read()
         try:
             return map(bin, d[:-1].split(" "))
         except:
             self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n")
             raise
 
     def branches(self, nodes):
         n = " ".join(map(hex, nodes))
         d = self.do_cmd("branches", nodes=n).read()
         try:
             br = [ tuple(map(bin, b.split(" "))) for b in d.splitlines() ]
             return br
         except:
             self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n")
             raise
 
     def between(self, pairs):
         n = "\n".join(["-".join(map(hex, p)) for p in pairs])
         d = self.do_cmd("between", pairs=n).read()
         try:
             p = [ l and map(bin, l.split(" ")) or [] for l in d.splitlines() ]
             return p
         except:
             self.ui.warn("unexpected response:\n" + d[:400] + "\n...\n")
             raise
 
     def changegroup(self, nodes):
         n = " ".join(map(hex, nodes))
         zd = zlib.decompressobj()
         f = self.do_cmd("changegroup", roots=n)
         bytes = 0
         while 1:
             d = f.read(4096)
             bytes += len(d)
             if not d:
                 yield zd.flush()
                 break
             yield zd.decompress(d)
         self.ui.note("%d bytes of data transfered\n" % bytes)
 
 def repository(ui, path=None, create=0):
     if path and path[:7] == "http://":
         return remoterepository(ui, path)
     if path and path[:5] == "hg://":
         return remoterepository(ui, path.replace("hg://", "http://"))
     if path and path[:11] == "old-http://":
         return localrepository(ui, path.replace("old-http://", "http://"))
     else:
         return localrepository(ui, path, create)
 
 class httprangereader:
     def __init__(self, url):
         self.url = url
         self.pos = 0
     def seek(self, pos):
         self.pos = pos
     def read(self, bytes=None):
         opener = urllib2.build_opener(byterange.HTTPRangeHandler())
         urllib2.install_opener(opener)
         req = urllib2.Request(self.url)
         end = ''
         if bytes: end = self.pos + bytes
         req.add_header('Range', 'bytes=%d-%s' % (self.pos, end))
         f = urllib2.urlopen(req)
         return f.read()