convert: refactor sink initialisation, to remove hardcoding of hg

We also introduce options to explicitly set the source and destination
repository types.

Improve testing of corner cases a little.

hgext/convert/__init__.py

@@ -1,414 +1,398 b''
 # convert.py Foreign SCM converter
 #
 # 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, ui, util, commands
 from mercurial.i18n import _
 
 commands.norepo += " convert debugsvnlog"
 
-sink_converters = [mercurial_sink]
-source_converters = [convert_cvs, convert_git, svn_source,
-                     mercurial_source, darcs_source]
-def convertsource(ui, path, **opts):
-    for c in source_converters:
+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):
+    for name, source in source_converters:
         try:
-            return c.getcommit and c(ui, path, **opts)
-        except AttributeError:
-            pass
+            if not type or name == type:
+                return source(ui, path, rev)
         except NoRepo, inst:
             ui.note(_("convert: %s\n") % inst)
     raise util.Abort('%s: unknown repository type' % path)
 
-def convertsink(ui, path):
-    if not os.path.isdir(path):
-        raise util.Abort("%s: not a directory" % path)
-    for c in sink_converters:
+def convertsink(ui, path, type):
+    for name, sink in sink_converters:
         try:
-            return c.putcommit and c(ui, path)
-        except AttributeError:
-            pass
+            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]
         if commit.parents:
             prev = commit.parents[0]
             if prev not in self.commitcache:
                 self.cachecommit(prev)
             pbranch = self.commitcache[prev].branch
         else:
             pbranch = None
         self.dest.setbranch(commit.branch, pbranch, parents)
         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)
 
         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):
     """Convert a foreign SCM repository to a Mercurial one.
 
     Accepted source formats:
     - CVS
     - Darcs
     - git
     - Subversion
 
     Accepted destination formats:
     - Mercurial
 
     If no revision is given, all revisions will be converted. Otherwise,
     convert will only import up to the named revision (given in a format
     understood by the source).
 
     If no destination directory name is specified, it defaults to the
     basename of the source with '-hg' appended.  If the destination
     repository doesn't exist, it will be created.
 
     If <revmapfile> isn't given, it will be put in a default location
     (<dest>/.hg/shamap by default).  The <revmapfile> is a simple text
     file that maps each source commit ID to the destination ID for
     that revision, like so:
     <source ID> <destination ID>
 
     If the file doesn't exist, it's automatically created.  It's updated
     on each commit copied, so convert-repo can be interrupted and can
     be run repeatedly to copy new commits.
 
     The [username mapping] file is a simple text file that maps each source
     commit author to a destination commit author. It is handy for source SCMs
     that use unix logins to identify authors (eg: CVS). One line per author
     mapping and the line format is:
     srcauthor=whatever string you want
 
     The filemap is a file that allows filtering and remapping of files
     and directories.  Comment lines start with '#'.  Each line can
     contain one of the following directives:
 
       include path/to/file
 
       exclude path/to/file
 
       rename from/file to/file
     
     The 'include' directive causes a file, or all files under a
     directory, to be included in the destination repository.  The
     'exclude' directive causes files or directories to be omitted.
     The 'rename' directive renames a file or directory.  To rename
     from a subdirectory into the root of the repository, use '.' as
     the path to rename to.
     """
 
     util._encoding = 'UTF-8'
 
     if not dest:
         dest = hg.defaultdest(src) + "-hg"
         ui.status("assuming destination %s\n" % dest)
 
-    # Try to be smart and initalize things when required
-    created = False
-    if os.path.isdir(dest):
-        if len(os.listdir(dest)) > 0:
-            try:
-                hg.repository(ui, dest)
-                ui.status("destination %s is a Mercurial repository\n" % dest)
-            except hg.RepoError:
-                raise util.Abort(
-                    "destination directory %s is not empty.\n"
-                    "Please specify an empty directory to be initialized\n"
-                    "or an already initialized mercurial repository"
-                    % dest)
-        else:
-            ui.status("initializing destination %s repository\n" % dest)
-            hg.repository(ui, dest, create=True)
-            created = True
-    elif os.path.exists(dest):
-        raise util.Abort("destination %s exists and is not a directory" % dest)
-    else:
-        ui.status("initializing destination %s repository\n" % dest)
-        hg.repository(ui, dest, create=True)
-        created = True
-
-    destc = convertsink(ui, dest)
+    destc = convertsink(ui, dest, opts.get('dest_type'))
 
     try:
-        srcc = convertsource(ui, src, rev=opts.get('rev'))
+        srcc = convertsource(ui, src, opts.get('source_type'),
+                             opts.get('rev'))
     except Exception:
-        if created:
-            shutil.rmtree(dest, True)
+        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()
 
 
 cmdtable = {
     "convert":
         (convert,
          [('A', 'authors', '', 'username mapping filename'),
+          ('d', 'dest-type', '', 'destination repository type'),
           ('', 'filemap', '', 'remap file names using contents of file'),
           ('r', 'rev', '', 'import up to target revision REV'),
+          ('s', 'source-type', '', 'source repository type'),
           ('', 'datesort', None, 'try to sort changesets by date')],
          'hg convert [OPTION]... SOURCE [DEST [MAPFILE]]'),
     "debugsvnlog":
         (debugsvnlog,
          [],
          'hg debugsvnlog'),
 }
 

hgext/convert/common.py

@@ -1,182 +1,186 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)"""
+        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.ui = ui
+        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):
         """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"""
         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/hg.py

@@ -1,247 +1,259 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)
-        except:
-            raise NoRepo("could not open hg repo %s as sink" % 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)
+                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):
             return
 
         self.lastbranch = branch
         self.after()
         if not branch:
             branch = 'default'
         if not pbranch:
             pbranch = 'default'
 
         branchpath = os.path.join(self.path, branch)
         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()
 
     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
             self.repo.heads()
         except hg.RepoError:
             ui.print_exc()
             raise NoRepo("could not open hg repo %s as source" % 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]
 

tests/test-convert

@@ -1,21 +1,37 b''
 #!/bin/sh
 
 echo "[extensions]" >> $HGRCPATH
 echo "convert=" >> $HGRCPATH
 
+hg help convert
+
 hg init a
 cd a
 echo a > a
 hg ci -d'0 0' -Ama
 hg cp a b
 hg ci -d'1 0' -mb
 hg rm a
 hg ci -d'2 0' -mc
 hg mv b a
 hg ci -d'3 0' -md
 echo a >> a
 hg ci -d'4 0' -me
 
 cd ..
 hg convert a 2>&1 | grep -v 'subversion python bindings could not be loaded'
 hg --cwd a-hg pull ../a
+
+touch bogusfile
+echo % should fail
+hg convert a bogusfile
+
+mkdir bogusdir
+chmod 000 bogusdir
+
+echo % should fail
+hg convert a bogusdir
+
+echo % should succeed
+chmod 700 bogusdir
+hg convert a bogusdir

tests/test-convert.out

@@ -1,14 +1,93 b''
+hg convert [OPTION]... SOURCE [DEST [MAPFILE]]
+
+Convert a foreign SCM repository to a Mercurial one.
+
+    Accepted source formats:
+    - CVS
+    - Darcs
+    - git
+    - Subversion
+
+    Accepted destination formats:
+    - Mercurial
+
+    If no revision is given, all revisions will be converted. Otherwise,
+    convert will only import up to the named revision (given in a format
+    understood by the source).
+
+    If no destination directory name is specified, it defaults to the
+    basename of the source with '-hg' appended.  If the destination
+    repository doesn't exist, it will be created.
+
+    If <revmapfile> isn't given, it will be put in a default location
+    (<dest>/.hg/shamap by default).  The <revmapfile> is a simple text
+    file that maps each source commit ID to the destination ID for
+    that revision, like so:
+    <source ID> <destination ID>
+
+    If the file doesn't exist, it's automatically created.  It's updated
+    on each commit copied, so convert-repo can be interrupted and can
+    be run repeatedly to copy new commits.
+
+    The [username mapping] file is a simple text file that maps each source
+    commit author to a destination commit author. It is handy for source SCMs
+    that use unix logins to identify authors (eg: CVS). One line per author
+    mapping and the line format is:
+    srcauthor=whatever string you want
+
+    The filemap is a file that allows filtering and remapping of files
+    and directories.  Comment lines start with '#'.  Each line can
+    contain one of the following directives:
+
+      include path/to/file
+
+      exclude path/to/file
+
+      rename from/file to/file
+    
+    The 'include' directive causes a file, or all files under a
+    directory, to be included in the destination repository.  The
+    'exclude' directive causes files or directories to be omitted.
+    The 'rename' directive renames a file or directory.  To rename
+    from a subdirectory into the root of the repository, use '.' as
+    the path to rename to.
+
+options:
+
+ -A --authors      username mapping filename
+ -d --dest-type    destination repository type
+    --filemap      remap file names using contents of file
+ -r --rev          import up to target revision REV
+ -s --source-type  source repository type
+    --datesort     try to sort changesets by date
+
+use "hg -v help convert" to show global options
 adding a
 assuming destination a-hg
 initializing destination a-hg repository
 scanning source...
 sorting...
 converting...
 4 a
 3 b
 2 c
 1 d
 0 e
 pulling from ../a
 searching for changes
 no changes found
+% should fail
+initializing destination bogusfile repository
+abort: cannot create new bundle repository
+% should fail
+abort: Permission denied: bogusdir
+% should succeed
+initializing destination bogusdir repository
+scanning source...
+sorting...
+converting...
+4 a
+3 b
+2 c
+1 d
+0 e