convert: hg.clonebranches must pull missing parents (issue941)

tests/test-convert-clonebranches

@@ -0,0 +1,54 b''
+#!/bin/sh
+
+echo "[extensions]" >> $HGRCPATH
+echo "hgext.convert = " >> $HGRCPATH
+echo "[convert]" >> $HGRCPATH
+echo "hg.tagsbranch=0" >> $HGRCPATH
+
+hg init source
+cd source
+echo a > a
+hg ci -qAm adda
+# Add a merge with one parent in the same branch
+echo a >> a
+hg ci -qAm changea
+hg up -qC 0
+hg branch branch0
+echo b > b
+hg ci -qAm addb
+hg up -qC
+hg merge
+hg ci -qm mergeab
+hg tag -ql mergeab
+cd ..
+
+# Miss perl... sometimes
+cat > filter.py <<EOF
+import sys, re
+
+r = re.compile(r'^(?:\d+|pulling from)')
+sys.stdout.writelines([l for l in sys.stdin if r.search(l)])
+EOF
+
+echo % convert
+hg convert -v --config convert.hg.clonebranches=1 source dest |
+    python filter.py
+
+# Add a merge with both parents and child in different branches
+cd source
+hg branch branch1
+echo a > file1
+hg ci -qAm c1
+hg up -qC mergeab
+hg branch branch2
+echo a > file2
+hg ci -qAm c2
+hg merge branch1
+hg branch branch3
+hg ci -qAm c3
+cd ..
+
+echo % incremental conversion
+hg convert -v --config convert.hg.clonebranches=1 source dest |
+    python filter.py
+

tests/test-convert-clonebranches.out

@@ -0,0 +1,29 b''
+marked working directory as branch branch0
+1 files updated, 0 files merged, 0 files removed, 0 files unresolved
+(branch merge, don't forget to commit)
+% convert
+3 adda
+2 addb
+pulling from default into branch0
+1 changesets found
+1 changea
+0 mergeab
+pulling from default into branch0
+1 changesets found
+marked working directory as branch branch1
+marked working directory as branch branch2
+1 files updated, 0 files merged, 0 files removed, 0 files unresolved
+(branch merge, don't forget to commit)
+marked working directory as branch branch3
+% incremental conversion
+2 c1
+pulling from branch0 into branch1
+2 changesets found
+1 c2
+pulling from branch0 into branch2
+2 changesets found
+0 c3
+pulling from branch2 into branch3
+3 changesets found
+pulling from branch1 into branch3
+1 changesets found

hgext/convert/common.py

@@ -1,186 +1,185 b''
 # common code for the convert extension
 import base64
 import cPickle as pickle
 
 def encodeargs(args):
     def encodearg(s):
         lines = base64.encodestring(s)
         lines = [l.splitlines()[0] for l in lines]
         return ''.join(lines)
 
     s = pickle.dumps(args)
     return encodearg(s)
 
 def decodeargs(s):
     s = base64.decodestring(s)
     return pickle.loads(s)
 
 class NoRepo(Exception): pass
 
 SKIPREV = 'SKIP'
 
 class commit(object):
     def __init__(self, author, date, desc, parents, branch=None, rev=None,
                  extra={}):
         self.author = author
         self.date = date
         self.desc = desc
         self.parents = parents
         self.branch = branch
         self.rev = rev
         self.extra = extra
 
 class converter_source(object):
     """Conversion source interface"""
 
     def __init__(self, ui, path, rev=None):
         """Initialize conversion source (or raise NoRepo("message")
         exception if path is not a valid repository)"""
         self.ui = ui
         self.path = path
         self.rev = rev
 
         self.encoding = 'utf-8'
 
     def before(self):
         pass
 
     def after(self):
         pass
 
     def setrevmap(self, revmap, order):
         """set the map of already-converted revisions
         
         order is a list with the keys from revmap in the order they
         appear in the revision map file."""
         pass
 
     def getheads(self):
         """Return a list of this repository's heads"""
         raise NotImplementedError()
 
     def getfile(self, name, rev):
         """Return file contents as a string"""
         raise NotImplementedError()
 
     def getmode(self, name, rev):
         """Return file mode, eg. '', 'x', or 'l'"""
         raise NotImplementedError()
 
     def getchanges(self, version):
         """Returns a tuple of (files, copies)
         Files is a sorted list of (filename, id) tuples for all files changed
         in version, where id is the source revision id of the file.
 
         copies is a dictionary of dest: source
         """
         raise NotImplementedError()
 
     def getcommit(self, version):
         """Return the commit object for version"""
         raise NotImplementedError()
 
     def gettags(self):
         """Return the tags as a dictionary of name: revision"""
         raise NotImplementedError()
 
     def recode(self, s, encoding=None):
         if not encoding:
             encoding = self.encoding or 'utf-8'
 
         if isinstance(s, unicode):
             return s.encode("utf-8")
         try:
             return s.decode(encoding).encode("utf-8")
         except:
             try:
                 return s.decode("latin-1").encode("utf-8")
             except:
                 return s.decode(encoding, "replace").encode("utf-8")
 
     def getchangedfiles(self, rev, i):
         """Return the files changed by rev compared to parent[i].
     
         i is an index selecting one of the parents of rev.  The return
         value should be the list of files that are different in rev and
         this parent.
 
         If rev has no parents, i is None.
     
         This function is only needed to support --filemap
         """
         raise NotImplementedError()
 
 class converter_sink(object):
     """Conversion sink (target) interface"""
 
     def __init__(self, ui, path):
         """Initialize conversion sink (or raise NoRepo("message")
         exception if path is not a valid repository)
 
         created is a list of paths to remove if a fatal error occurs
         later"""
         self.ui = ui
         self.path = path
         self.created = []
 
     def getheads(self):
         """Return a list of this repository's heads"""
         raise NotImplementedError()
 
     def revmapfile(self):
         """Path to a file that will contain lines
         source_rev_id sink_rev_id
         mapping equivalent revision identifiers for each system."""
         raise NotImplementedError()
 
     def authorfile(self):
         """Path to a file that will contain lines
         srcauthor=dstauthor
         mapping equivalent authors identifiers for each system."""
         return None
 
     def putfile(self, f, e, data):
         """Put file for next putcommit().
         f: path to file
         e: '', 'x', or 'l' (regular file, executable, or symlink)
         data: file contents"""
         raise NotImplementedError()
 
     def delfile(self, f):
         """Delete file for next putcommit().
         f: path to file"""
         raise NotImplementedError()
 
     def putcommit(self, files, parents, commit):
         """Create a revision with all changed files listed in 'files'
         and having listed parents. 'commit' is a commit object containing
         at a minimum the author, date, and message for this changeset.
         Called after putfile() and delfile() calls. Note that the sink
         repository is not told to update itself to a particular revision
         (or even what that revision would be) before it receives the
         file data."""
         raise NotImplementedError()
 
     def puttags(self, tags):
         """Put tags into sink.
         tags: {tagname: sink_rev_id, ...}"""
         raise NotImplementedError()
 
-    def setbranch(self, branch, pbranch, parents):
+    def setbranch(self, branch, pbranches):
         """Set the current branch name. Called before the first putfile
         on the branch.
         branch: branch name for subsequent commits
-        pbranch: branch name of parent commit
-        parents: destination revisions of parent"""
+        pbranches: (converted parent revision, parent branch) tuples"""
         pass
 
     def setfilemapmode(self, active):
         """Tell the destination that we're using a filemap
 
         Some converter_sources (svn in particular) can claim that a file
         was changed in a revision, even if there was no change.  This method
         tells the destination that we're using a filemap and that it should
         filter empty revisions.
         """
         pass

hgext/convert/convcmd.py

@@ -1,330 +1,330 b''
 # convcmd - convert extension commands definition
 #
 # Copyright 2005-2007 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.
 
 from common import NoRepo, SKIPREV, converter_source, converter_sink
 from cvs import convert_cvs
 from darcs import darcs_source
 from git import convert_git
 from hg import mercurial_source, mercurial_sink
 from subversion import svn_source, debugsvnlog
 import filemap
 
 import os, shutil
 from mercurial import hg, util
 from mercurial.i18n import _
 
 source_converters = [
     ('cvs', convert_cvs),
     ('git', convert_git),
     ('svn', svn_source),
     ('hg', mercurial_source),
     ('darcs', darcs_source),
     ]
 
 sink_converters = [
     ('hg', mercurial_sink),
     ]
 
 def convertsource(ui, path, type, rev):
     exceptions = []
     for name, source in source_converters:
         try:
             if not type or name == type:
                 return source(ui, path, rev)
         except NoRepo, inst:
             exceptions.append(inst)
     if not ui.quiet:
         for inst in exceptions:
             ui.write(_("%s\n") % inst)
     raise util.Abort('%s: unknown repository type' % path)
 
 def convertsink(ui, path, type):
     for name, sink in sink_converters:
         try:
             if not type or name == type:
                 return sink(ui, path)
         except NoRepo, inst:
             ui.note(_("convert: %s\n") % inst)
     raise util.Abort('%s: unknown repository type' % path)
 
 class converter(object):
     def __init__(self, ui, source, dest, revmapfile, opts):
 
         self.source = source
         self.dest = dest
         self.ui = ui
         self.opts = opts
         self.commitcache = {}
         self.revmapfile = revmapfile
         self.revmapfilefd = None
         self.authors = {}
         self.authorfile = None
 
         self.maporder = []
         self.map = {}
         try:
             origrevmapfile = open(self.revmapfile, 'r')
             for l in origrevmapfile:
                 sv, dv = l[:-1].split()
                 if sv not in self.map:
                     self.maporder.append(sv)
                 self.map[sv] = dv
             origrevmapfile.close()
         except IOError:
             pass
 
         # Read first the dst author map if any
         authorfile = self.dest.authorfile()
         if authorfile and os.path.exists(authorfile):
             self.readauthormap(authorfile)
         # Extend/Override with new author map if necessary
         if opts.get('authors'):
             self.readauthormap(opts.get('authors'))
             self.authorfile = self.dest.authorfile()
 
     def walktree(self, heads):
         '''Return a mapping that identifies the uncommitted parents of every
         uncommitted changeset.'''
         visit = heads
         known = {}
         parents = {}
         while visit:
             n = visit.pop(0)
             if n in known or n in self.map: continue
             known[n] = 1
             commit = self.cachecommit(n)
             parents[n] = []
             for p in commit.parents:
                 parents[n].append(p)
                 visit.append(p)
 
         return parents
 
     def toposort(self, parents):
         '''Return an ordering such that every uncommitted changeset is
         preceeded by all its uncommitted ancestors.'''
         visit = parents.keys()
         seen = {}
         children = {}
 
         while visit:
             n = visit.pop(0)
             if n in seen: continue
             seen[n] = 1
             # Ensure that nodes without parents are present in the 'children'
             # mapping.
             children.setdefault(n, [])
             for p in parents[n]:
                 if not p in self.map:
                     visit.append(p)
                 children.setdefault(p, []).append(n)
 
         s = []
         removed = {}
         visit = children.keys()
         while visit:
             n = visit.pop(0)
             if n in removed: continue
             dep = 0
             if n in parents:
                 for p in parents[n]:
                     if p in self.map: continue
                     if p not in removed:
                         # we're still dependent
                         visit.append(n)
                         dep = 1
                         break
 
             if not dep:
                 # all n's parents are in the list
                 removed[n] = 1
                 if n not in self.map:
                     s.append(n)
                 if n in children:
                     for c in children[n]:
                         visit.insert(0, c)
 
         if self.opts.get('datesort'):
             depth = {}
             for n in s:
                 depth[n] = 0
                 pl = [p for p in self.commitcache[n].parents
                       if p not in self.map]
                 if pl:
                     depth[n] = max([depth[p] for p in pl]) + 1
 
             s = [(depth[n], self.commitcache[n].date, n) for n in s]
             s.sort()
             s = [e[2] for e in s]
 
         return s
 
     def mapentry(self, src, dst):
         if self.revmapfilefd is None:
             try:
                 self.revmapfilefd = open(self.revmapfile, "a")
             except IOError, (errno, strerror):
                 raise util.Abort("Could not open map file %s: %s, %s\n" % (self.revmapfile, errno, strerror))
         self.map[src] = dst
         self.revmapfilefd.write("%s %s\n" % (src, dst))
         self.revmapfilefd.flush()
 
     def writeauthormap(self):
         authorfile = self.authorfile
         if authorfile:
            self.ui.status('Writing author map file %s\n' % authorfile)
            ofile = open(authorfile, 'w+')
            for author in self.authors:
                ofile.write("%s=%s\n" % (author, self.authors[author]))
            ofile.close()
 
     def readauthormap(self, authorfile):
         afile = open(authorfile, 'r')
         for line in afile:
             try:
                 srcauthor = line.split('=')[0].strip()
                 dstauthor = line.split('=')[1].strip()
                 if srcauthor in self.authors and dstauthor != self.authors[srcauthor]:
                     self.ui.status(
                         'Overriding mapping for author %s, was %s, will be %s\n'
                         % (srcauthor, self.authors[srcauthor], dstauthor))
                 else:
                     self.ui.debug('Mapping author %s to %s\n'
                                   % (srcauthor, dstauthor))
                     self.authors[srcauthor] = dstauthor
             except IndexError:
                 self.ui.warn(
                     'Ignoring bad line in author file map %s: %s\n'
                     % (authorfile, line))
         afile.close()
 
     def cachecommit(self, rev):
         commit = self.source.getcommit(rev)
         commit.author = self.authors.get(commit.author, commit.author)
         self.commitcache[rev] = commit
         return commit
 
     def copy(self, rev):
         commit = self.commitcache[rev]
         do_copies = hasattr(self.dest, 'copyfile')
         filenames = []
 
         changes = self.source.getchanges(rev)
         if isinstance(changes, basestring):
             if changes == SKIPREV:
                 dest = SKIPREV
             else:
                 dest = self.map[changes]
             self.mapentry(rev, dest)
             return
         files, copies = changes
-        parents = [self.map[r] for r in commit.parents]
+        pbranches = []
         if commit.parents:
-            prev = commit.parents[0]
+            for prev in commit.parents:
             if prev not in self.commitcache:
                 self.cachecommit(prev)
-            pbranch = self.commitcache[prev].branch
-        else:
-            pbranch = None
-        self.dest.setbranch(commit.branch, pbranch, parents)
+                pbranches.append((self.map[prev], 
+                                  self.commitcache[prev].branch))
+        self.dest.setbranch(commit.branch, pbranches)
         for f, v in files:
             filenames.append(f)
             try:
                 data = self.source.getfile(f, v)
             except IOError, inst:
                 self.dest.delfile(f)
             else:
                 e = self.source.getmode(f, v)
                 self.dest.putfile(f, e, data)
                 if do_copies:
                     if f in copies:
                         copyf = copies[f]
                         # Merely marks that a copy happened.
                         self.dest.copyfile(copyf, f)
 
+        parents = [b[0] for b in pbranches]
         newnode = self.dest.putcommit(filenames, parents, commit)
         self.mapentry(rev, newnode)
 
     def convert(self):
         try:
             self.source.before()
             self.dest.before()
             self.source.setrevmap(self.map, self.maporder)
             self.ui.status("scanning source...\n")
             heads = self.source.getheads()
             parents = self.walktree(heads)
             self.ui.status("sorting...\n")
             t = self.toposort(parents)
             num = len(t)
             c = None
 
             self.ui.status("converting...\n")
             for c in t:
                 num -= 1
                 desc = self.commitcache[c].desc
                 if "\n" in desc:
                     desc = desc.splitlines()[0]
                 self.ui.status("%d %s\n" % (num, desc))
                 self.copy(c)
 
             tags = self.source.gettags()
             ctags = {}
             for k in tags:
                 v = tags[k]
                 if self.map.get(v, SKIPREV) != SKIPREV:
                     ctags[k] = self.map[v]
 
             if c and ctags:
                 nrev = self.dest.puttags(ctags)
                 # write another hash correspondence to override the previous
                 # one so we don't end up with extra tag heads
                 if nrev:
                     self.mapentry(c, nrev)
 
             self.writeauthormap()
         finally:
             self.cleanup()
 
     def cleanup(self):
         try:
             self.dest.after()
         finally:
             self.source.after()
         if self.revmapfilefd:
             self.revmapfilefd.close()
 
 def convert(ui, src, dest=None, revmapfile=None, **opts):
     util._encoding = 'UTF-8'
 
     if not dest:
         dest = hg.defaultdest(src) + "-hg"
         ui.status("assuming destination %s\n" % dest)
 
     destc = convertsink(ui, dest, opts.get('dest_type'))
 
     try:
         srcc = convertsource(ui, src, opts.get('source_type'),
                              opts.get('rev'))
     except Exception:
         for path in destc.created:
             shutil.rmtree(path, True)
         raise
 
     fmap = opts.get('filemap')
     if fmap:
         srcc = filemap.filemap_source(ui, srcc, fmap)
         destc.setfilemapmode(True)
 
     if not revmapfile:
         try:
             revmapfile = destc.revmapfile()
         except:
             revmapfile = os.path.join(destc, "map")
 
     c = converter(ui, srcc, destc, revmapfile, opts)
     c.convert()
 

hgext/convert/hg.py

@@ -1,264 +1,277 b''
 # hg backend for convert extension
 
 # Note for hg->hg conversion: Old versions of Mercurial didn't trim
 # the whitespace from the ends of commit messages, but new versions
 # do.  Changesets created by those older versions, then converted, may
 # thus have different hashes for changesets that are otherwise
 # identical.
 
 
 import os, time
 from mercurial.i18n import _
 from mercurial.node import *
 from mercurial import hg, lock, revlog, util
 
 from common import NoRepo, commit, converter_source, converter_sink
 
 class mercurial_sink(converter_sink):
     def __init__(self, ui, path):
         converter_sink.__init__(self, ui, path)
         self.branchnames = ui.configbool('convert', 'hg.usebranchnames', True)
         self.clonebranches = ui.configbool('convert', 'hg.clonebranches', False)
         self.tagsbranch = ui.config('convert', 'hg.tagsbranch', 'default')
         self.lastbranch = None
         if os.path.isdir(path) and len(os.listdir(path)) > 0:
             try:
                 self.repo = hg.repository(self.ui, path)
                 if not self.repo.local():
                     raise NoRepo(_('%s is not a local Mercurial repo') % path)
                 ui.status(_('destination %s is a Mercurial repository\n') %
                           path)
             except hg.RepoError, err:
                 ui.print_exc()
                 raise NoRepo(err.args[0])
         else:
             try:
                 ui.status(_('initializing destination %s repository\n') % path)
                 self.repo = hg.repository(self.ui, path, create=True)
                 if not self.repo.local():
                     raise NoRepo(_('%s is not a local Mercurial repo') % path)
                 self.created.append(path)
             except hg.RepoError, err:
                 ui.print_exc()
                 raise NoRepo("could not create hg repo %s as sink" % path)
         self.lock = None
         self.wlock = None
         self.filemapmode = False
 
     def before(self):
         self.wlock = self.repo.wlock()
         self.lock = self.repo.lock()
         self.repo.dirstate.clear()
 
     def after(self):
         self.repo.dirstate.invalidate()
         self.lock = None
         self.wlock = None
 
     def revmapfile(self):
         return os.path.join(self.path, ".hg", "shamap")
 
     def authorfile(self):
         return os.path.join(self.path, ".hg", "authormap")
 
     def getheads(self):
         h = self.repo.changelog.heads()
         return [ hex(x) for x in h ]
 
     def putfile(self, f, e, data):
         self.repo.wwrite(f, data, e)
         if f not in self.repo.dirstate:
             self.repo.dirstate.normallookup(f)
 
     def copyfile(self, source, dest):
         self.repo.copy(source, dest)
 
     def delfile(self, f):
         try:
             util.unlink(self.repo.wjoin(f))
             #self.repo.remove([f])
         except OSError:
             pass
 
-    def setbranch(self, branch, pbranch, parents):
-        if (not self.clonebranches) or (branch == self.lastbranch):
+    def setbranch(self, branch, pbranches):
+        if not self.clonebranches:
             return
 
+        setbranch = (branch != self.lastbranch)
         self.lastbranch = branch
-        self.after()
         if not branch:
             branch = 'default'
-        if not pbranch:
-            pbranch = 'default'
+        pbranches = [(b[0], b[1] and b[1] or 'default') for b in pbranches]
+        pbranch = pbranches and pbranches[0][1] or 'default'
 
         branchpath = os.path.join(self.path, branch)
+        if setbranch:
+            self.after()
         try:
             self.repo = hg.repository(self.ui, branchpath)
         except:
-            if not parents:
                 self.repo = hg.repository(self.ui, branchpath, create=True)
-            else:
-                self.ui.note(_('cloning branch %s to %s\n') % (pbranch, branch))
-                hg.clone(self.ui, os.path.join(self.path, pbranch),
-                         branchpath, rev=parents, update=False,
-                         stream=True)
-                self.repo = hg.repository(self.ui, branchpath)
+            self.before()
+
+        # pbranches may bring revisions from other branches (merge parents)
+        # Make sure we have them, or pull them.
+        missings = {}
+        for b in pbranches:
+            try:
+                self.repo.lookup(b[0])
+            except:
+                missings.setdefault(b[1], []).append(b[0])
+        
+        if missings:
+            self.after()
+            for pbranch, heads in missings.iteritems():
+                pbranchpath = os.path.join(self.path, pbranch)
+                prepo = hg.repository(self.ui, pbranchpath)
+                self.ui.note(_('pulling from %s into %s\n') % (pbranch, branch))
+                self.repo.pull(prepo, [prepo.lookup(h) for h in heads])
         self.before()
 
     def putcommit(self, files, parents, commit):
         seen = {}
         pl = []
         for p in parents:
             if p not in seen:
                 pl.append(p)
                 seen[p] = 1
         parents = pl
         nparents = len(parents)
         if self.filemapmode and nparents == 1:
             m1node = self.repo.changelog.read(bin(parents[0]))[0]
             parent = parents[0]
 
         if len(parents) < 2: parents.append("0" * 40)
         if len(parents) < 2: parents.append("0" * 40)
         p2 = parents.pop(0)
 
         text = commit.desc
         extra = commit.extra.copy()
         if self.branchnames and commit.branch:
             extra['branch'] = commit.branch
         if commit.rev:
             extra['convert_revision'] = commit.rev
 
         while parents:
             p1 = p2
             p2 = parents.pop(0)
             a = self.repo.rawcommit(files, text, commit.author, commit.date,
                                     bin(p1), bin(p2), extra=extra)
             self.repo.dirstate.clear()
             text = "(octopus merge fixup)\n"
             p2 = hg.hex(self.repo.changelog.tip())
 
         if self.filemapmode and nparents == 1:
             man = self.repo.manifest
             mnode = self.repo.changelog.read(bin(p2))[0]
             if not man.cmp(m1node, man.revision(mnode)):
                 self.repo.rollback()
                 self.repo.dirstate.clear()
                 return parent
         return p2
 
     def puttags(self, tags):
         try:
             old = self.repo.wfile(".hgtags").read()
             oldlines = old.splitlines(1)
             oldlines.sort()
         except:
             oldlines = []
 
         k = tags.keys()
         k.sort()
         newlines = []
         for tag in k:
             newlines.append("%s %s\n" % (tags[tag], tag))
 
         newlines.sort()
 
         if newlines != oldlines:
             self.ui.status("updating tags\n")
             f = self.repo.wfile(".hgtags", "w")
             f.write("".join(newlines))
             f.close()
             if not oldlines: self.repo.add([".hgtags"])
             date = "%s 0" % int(time.mktime(time.gmtime()))
             extra = {}
             if self.tagsbranch != 'default':
                 extra['branch'] = self.tagsbranch
             try:
                 tagparent = self.repo.changectx(self.tagsbranch).node()
             except hg.RepoError, inst:
                 tagparent = nullid
             self.repo.rawcommit([".hgtags"], "update tags", "convert-repo",
                                 date, tagparent, nullid)
             return hex(self.repo.changelog.tip())
 
     def setfilemapmode(self, active):
         self.filemapmode = active
 
 class mercurial_source(converter_source):
     def __init__(self, ui, path, rev=None):
         converter_source.__init__(self, ui, path, rev)
         try:
             self.repo = hg.repository(self.ui, path)
             # try to provoke an exception if this isn't really a hg
             # repo, but some other bogus compatible-looking url
             if not self.repo.local():
                 raise hg.RepoError()
         except hg.RepoError:
             ui.print_exc()
             raise NoRepo("%s is not a local Mercurial repo" % path)
         self.lastrev = None
         self.lastctx = None
         self._changescache = None
 
     def changectx(self, rev):
         if self.lastrev != rev:
             self.lastctx = self.repo.changectx(rev)
             self.lastrev = rev
         return self.lastctx
 
     def getheads(self):
         if self.rev:
             return [hex(self.repo.changectx(self.rev).node())]
         else:
             return [hex(node) for node in self.repo.heads()]
 
     def getfile(self, name, rev):
         try:
             return self.changectx(rev).filectx(name).data()
         except revlog.LookupError, err:
             raise IOError(err)
 
     def getmode(self, name, rev):
         m = self.changectx(rev).manifest()
         return (m.execf(name) and 'x' or '') + (m.linkf(name) and 'l' or '')
 
     def getchanges(self, rev):
         ctx = self.changectx(rev)
         if self._changescache and self._changescache[0] == rev:
             m, a, r = self._changescache[1]
         else:
             m, a, r = self.repo.status(ctx.parents()[0].node(), ctx.node())[:3]
         changes = [(name, rev) for name in m + a + r]
         changes.sort()
         return (changes, self.getcopies(ctx, m + a))
 
     def getcopies(self, ctx, files):
         copies = {}
         for name in files:
             try:
                 copies[name] = ctx.filectx(name).renamed()[0]
             except TypeError:
                 pass
         return copies
 
     def getcommit(self, rev):
         ctx = self.changectx(rev)
         parents = [hex(p.node()) for p in ctx.parents() if p.node() != nullid]
         return commit(author=ctx.user(), date=util.datestr(ctx.date()),
                       desc=ctx.description(), parents=parents,
                       branch=ctx.branch(), extra=ctx.extra())
 
     def gettags(self):
         tags = [t for t in self.repo.tagslist() if t[0] != 'tip']
         return dict([(name, hex(node)) for name, node in tags])
 
     def getchangedfiles(self, rev, i):
         ctx = self.changectx(rev)
         i = i or 0
         changes = self.repo.status(ctx.parents()[i].node(), ctx.node())[:3]
 
         if i == 0:
             self._changescache = (rev, changes)
 
         return changes[0] + changes[1] + changes[2]