convert: update source shamap when using filemap, just as when not using filemap

The reverse mapping was introduced in 2147a734dcf9 to make roundtrip
conversions possible ... but it did not work when using filemap.

Roundtrips with filemaps will of course only work flawlessly if inverse
mappings are used.

Especially, if a lossy convert mapping is used in one direction, then only
linear lines of development can be converted in the other direction. With this
constraint convert will do the right thing by assuming that excluded files
haven't been changed.)

A test case with general coverage of hg-hg roundtrips with filemap is added.

(There a cases where adding records of converted revisions to the shamap in the
source repository doesn't work - especially when converting the same repo to
several other repos and back. It would arguably be better if convert only
updated the shamaps in the target repo but read shamaps from both the source
and and target repo ... but that is a different story. Making the stuff we have
work consistently is step forward no matter what.)

hgext/convert/filemap.py

@@ -1,411 +1,414 b''
 # Copyright 2007 Bryan O'Sullivan <[e-mail]>
 # Copyright 2007 Alexis S. L. Carvalho <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 import posixpath
 import shlex
 from mercurial.i18n import _
 from mercurial import util, error
 from common import SKIPREV, converter_source
 
 def rpairs(name):
     e = len(name)
     while e != -1:
         yield name[:e], name[e + 1:]
         e = name.rfind('/', 0, e)
     yield '.', name
 
 def normalize(path):
     ''' We use posixpath.normpath to support cross-platform path format.
     However, it doesn't handle None input. So we wrap it up. '''
     if path is None:
         return None
     return posixpath.normpath(path)
 
 class filemapper(object):
     '''Map and filter filenames when importing.
     A name can be mapped to itself, a new name, or None (omit from new
     repository).'''
 
     def __init__(self, ui, path=None):
         self.ui = ui
         self.include = {}
         self.exclude = {}
         self.rename = {}
         if path:
             if self.parse(path):
                 raise util.Abort(_('errors in filemap'))
 
     def parse(self, path):
         errs = 0
         def check(name, mapping, listname):
             if not name:
                 self.ui.warn(_('%s:%d: path to %s is missing\n') %
                              (lex.infile, lex.lineno, listname))
                 return 1
             if name in mapping:
                 self.ui.warn(_('%s:%d: %r already in %s list\n') %
                              (lex.infile, lex.lineno, name, listname))
                 return 1
             if (name.startswith('/') or
                 name.endswith('/') or
                 '//' in name):
                 self.ui.warn(_('%s:%d: superfluous / in %s %r\n') %
                              (lex.infile, lex.lineno, listname, name))
                 return 1
             return 0
         lex = shlex.shlex(open(path), path, True)
         lex.wordchars += '!@#$%^&*()-=+[]{}|;:,./<>?'
         cmd = lex.get_token()
         while cmd:
             if cmd == 'include':
                 name = normalize(lex.get_token())
                 errs += check(name, self.exclude, 'exclude')
                 self.include[name] = name
             elif cmd == 'exclude':
                 name = normalize(lex.get_token())
                 errs += check(name, self.include, 'include')
                 errs += check(name, self.rename, 'rename')
                 self.exclude[name] = name
             elif cmd == 'rename':
                 src = normalize(lex.get_token())
                 dest = normalize(lex.get_token())
                 errs += check(src, self.exclude, 'exclude')
                 self.rename[src] = dest
             elif cmd == 'source':
                 errs += self.parse(normalize(lex.get_token()))
             else:
                 self.ui.warn(_('%s:%d: unknown directive %r\n') %
                              (lex.infile, lex.lineno, cmd))
                 errs += 1
             cmd = lex.get_token()
         return errs
 
     def lookup(self, name, mapping):
         name = normalize(name)
         for pre, suf in rpairs(name):
             try:
                 return mapping[pre], pre, suf
             except KeyError:
                 pass
         return '', name, ''
 
     def __call__(self, name):
         if self.include:
             inc = self.lookup(name, self.include)[0]
         else:
             inc = name
         if self.exclude:
             exc = self.lookup(name, self.exclude)[0]
         else:
             exc = ''
         if (not self.include and exc) or (len(inc) <= len(exc)):
             return None
         newpre, pre, suf = self.lookup(name, self.rename)
         if newpre:
             if newpre == '.':
                 return suf
             if suf:
                 if newpre.endswith('/'):
                     return newpre + suf
                 return newpre + '/' + suf
             return newpre
         return name
 
     def active(self):
         return bool(self.include or self.exclude or self.rename)
 
 # This class does two additional things compared to a regular source:
 #
 # - Filter and rename files.  This is mostly wrapped by the filemapper
 #   class above. We hide the original filename in the revision that is
 #   returned by getchanges to be able to find things later in getfile.
 #
 # - Return only revisions that matter for the files we're interested in.
 #   This involves rewriting the parents of the original revision to
 #   create a graph that is restricted to those revisions.
 #
 #   This set of revisions includes not only revisions that directly
 #   touch files we're interested in, but also merges that merge two
 #   or more interesting revisions.
 
 class filemap_source(converter_source):
     def __init__(self, ui, baseconverter, filemap):
         super(filemap_source, self).__init__(ui)
         self.base = baseconverter
         self.filemapper = filemapper(ui, filemap)
         self.commits = {}
         # if a revision rev has parent p in the original revision graph, then
         # rev will have parent self.parentmap[p] in the restricted graph.
         self.parentmap = {}
         # self.wantedancestors[rev] is the set of all ancestors of rev that
         # are in the restricted graph.
         self.wantedancestors = {}
         self.convertedorder = None
         self._rebuilt = False
         self.origparents = {}
         self.children = {}
         self.seenchildren = {}
 
     def before(self):
         self.base.before()
 
     def after(self):
         self.base.after()
 
     def setrevmap(self, revmap):
         # rebuild our state to make things restartable
         #
         # To avoid calling getcommit for every revision that has already
         # been converted, we rebuild only the parentmap, delaying the
         # rebuild of wantedancestors until we need it (i.e. until a
         # merge).
         #
         # We assume the order argument lists the revisions in
         # topological order, so that we can infer which revisions were
         # wanted by previous runs.
         self._rebuilt = not revmap
         seen = {SKIPREV: SKIPREV}
         dummyset = set()
         converted = []
         for rev in revmap.order:
             mapped = revmap[rev]
             wanted = mapped not in seen
             if wanted:
                 seen[mapped] = rev
                 self.parentmap[rev] = rev
             else:
                 self.parentmap[rev] = seen[mapped]
             self.wantedancestors[rev] = dummyset
             arg = seen[mapped]
             if arg == SKIPREV:
                 arg = None
             converted.append((rev, wanted, arg))
         self.convertedorder = converted
         return self.base.setrevmap(revmap)
 
     def rebuild(self):
         if self._rebuilt:
             return True
         self._rebuilt = True
         self.parentmap.clear()
         self.wantedancestors.clear()
         self.seenchildren.clear()
         for rev, wanted, arg in self.convertedorder:
             if rev not in self.origparents:
                 try:
                     self.origparents[rev] = self.getcommit(rev).parents
                 except error.RepoLookupError:
                     self.ui.debug("unknown revmap source: %s\n" % rev)
                     continue
             if arg is not None:
                 self.children[arg] = self.children.get(arg, 0) + 1
 
         for rev, wanted, arg in self.convertedorder:
             try:
                 parents = self.origparents[rev]
             except KeyError:
                 continue # unknown revmap source
             if wanted:
                 self.mark_wanted(rev, parents)
             else:
                 self.mark_not_wanted(rev, arg)
             self._discard(arg, *parents)
 
         return True
 
     def getheads(self):
         return self.base.getheads()
 
     def getcommit(self, rev):
         # We want to save a reference to the commit objects to be able
         # to rewrite their parents later on.
         c = self.commits[rev] = self.base.getcommit(rev)
         for p in c.parents:
             self.children[p] = self.children.get(p, 0) + 1
         return c
 
     def _cachedcommit(self, rev):
         if rev in self.commits:
             return self.commits[rev]
         return self.base.getcommit(rev)
 
     def _discard(self, *revs):
         for r in revs:
             if r is None:
                 continue
             self.seenchildren[r] = self.seenchildren.get(r, 0) + 1
             if self.seenchildren[r] == self.children[r]:
                 self.wantedancestors.pop(r, None)
                 self.parentmap.pop(r, None)
                 del self.seenchildren[r]
                 if self._rebuilt:
                     del self.children[r]
 
     def wanted(self, rev, i):
         # Return True if we're directly interested in rev.
         #
         # i is an index selecting one of the parents of rev (if rev
         # has no parents, i is None).  getchangedfiles will give us
         # the list of files that are different in rev and in the parent
         # indicated by i.  If we're interested in any of these files,
         # we're interested in rev.
         try:
             files = self.base.getchangedfiles(rev, i)
         except NotImplementedError:
             raise util.Abort(_("source repository doesn't support --filemap"))
         for f in files:
             if self.filemapper(f):
                 return True
         return False
 
     def mark_not_wanted(self, rev, p):
         # Mark rev as not interesting and update data structures.
 
         if p is None:
             # A root revision. Use SKIPREV to indicate that it doesn't
             # map to any revision in the restricted graph.  Put SKIPREV
             # in the set of wanted ancestors to simplify code elsewhere
             self.parentmap[rev] = SKIPREV
             self.wantedancestors[rev] = set((SKIPREV,))
             return
 
         # Reuse the data from our parent.
         self.parentmap[rev] = self.parentmap[p]
         self.wantedancestors[rev] = self.wantedancestors[p]
 
     def mark_wanted(self, rev, parents):
         # Mark rev ss wanted and update data structures.
 
         # rev will be in the restricted graph, so children of rev in
         # the original graph should still have rev as a parent in the
         # restricted graph.
         self.parentmap[rev] = rev
 
         # The set of wanted ancestors of rev is the union of the sets
         # of wanted ancestors of its parents. Plus rev itself.
         wrev = set()
         for p in parents:
             if p in self.wantedancestors:
                 wrev.update(self.wantedancestors[p])
             else:
                 self.ui.warn(_('warning: %s parent %s is missing\n') %
                              (rev, p))
         wrev.add(rev)
         self.wantedancestors[rev] = wrev
 
     def getchanges(self, rev):
         parents = self.commits[rev].parents
         if len(parents) > 1:
             self.rebuild()
 
         # To decide whether we're interested in rev we:
         #
         # - calculate what parents rev will have if it turns out we're
         #   interested in it.  If it's going to have more than 1 parent,
         #   we're interested in it.
         #
         # - otherwise, we'll compare it with the single parent we found.
         #   If any of the files we're interested in is different in the
         #   the two revisions, we're interested in rev.
 
         # A parent p is interesting if its mapped version (self.parentmap[p]):
         # - is not SKIPREV
         # - is still not in the list of parents (we don't want duplicates)
         # - is not an ancestor of the mapped versions of the other parents or
         #   there is no parent in the same branch than the current revision.
         mparents = []
         knownparents = set()
         branch = self.commits[rev].branch
         hasbranchparent = False
         for i, p1 in enumerate(parents):
             mp1 = self.parentmap[p1]
             if mp1 == SKIPREV or mp1 in knownparents:
                 continue
             isancestor = util.any(p2 for p2 in parents
                                   if p1 != p2 and mp1 != self.parentmap[p2]
                                   and mp1 in self.wantedancestors[p2])
             if not isancestor and not hasbranchparent and len(parents) > 1:
                 # This could be expensive, avoid unnecessary calls.
                 if self._cachedcommit(p1).branch == branch:
                     hasbranchparent = True
             mparents.append((p1, mp1, i, isancestor))
             knownparents.add(mp1)
         # Discard parents ancestors of other parents if there is a
         # non-ancestor one on the same branch than current revision.
         if hasbranchparent:
             mparents = [p for p in mparents if not p[3]]
         wp = None
         if mparents:
             wp = max(p[2] for p in mparents)
             mparents = [p[1] for p in mparents]
         elif parents:
             wp = 0
 
         self.origparents[rev] = parents
 
         closed = False
         if 'close' in self.commits[rev].extra:
             # A branch closing revision is only useful if one of its
             # parents belong to the branch being closed
             pbranches = [self._cachedcommit(p).branch for p in mparents]
             if branch in pbranches:
                 closed = True
 
         if len(mparents) < 2 and not closed and not self.wanted(rev, wp):
             # We don't want this revision.
             # Update our state and tell the convert process to map this
             # revision to the same revision its parent as mapped to.
             p = None
             if parents:
                 p = parents[wp]
             self.mark_not_wanted(rev, p)
             self.convertedorder.append((rev, False, p))
             self._discard(*parents)
             return self.parentmap[rev]
 
         # We want this revision.
         # Rewrite the parents of the commit object
         self.commits[rev].parents = mparents
         self.mark_wanted(rev, parents)
         self.convertedorder.append((rev, True, None))
         self._discard(*parents)
 
         # Get the real changes and do the filtering/mapping. To be
         # able to get the files later on in getfile, we hide the
         # original filename in the rev part of the return value.
         changes, copies = self.base.getchanges(rev)
         files = {}
         for f, r in changes:
             newf = self.filemapper(f)
             if newf and (newf != f or newf not in files):
                 files[newf] = (f, r)
         files = sorted(files.items())
 
         ncopies = {}
         for c in copies:
             newc = self.filemapper(c)
             if newc:
                 newsource = self.filemapper(copies[c])
                 if newsource:
                     ncopies[newc] = newsource
 
         return files, ncopies
 
     def getfile(self, name, rev):
         realname, realrev = rev
         return self.base.getfile(realname, realrev)
 
     def gettags(self):
         return self.base.gettags()
 
     def hasnativeorder(self):
         return self.base.hasnativeorder()
 
     def lookuprev(self, rev):
         return self.base.lookuprev(rev)
 
     def getbookmarks(self):
         return self.base.getbookmarks()
+
+    def converted(self, rev, sinkrev):
+        self.base.converted(rev, sinkrev)

tests/test-convert-hg-sink.t

@@ -1,124 +1,392 b''
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > convert=
   > [convert]
   > hg.saverev=False
   > EOF
   $ hg init orig
   $ cd orig
   $ echo foo > foo
   $ echo bar > bar
   $ hg ci -qAm 'add foo and bar'
   $ hg rm foo
   $ hg ci -m 'remove foo'
   $ mkdir foo
   $ echo file > foo/file
   $ hg ci -qAm 'add foo/file'
   $ hg tag some-tag
   $ hg log
   changeset:   3:593cbf6fb2b4
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Added tag some-tag for changeset ad681a868e44
   
   changeset:   2:ad681a868e44
   tag:         some-tag
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add foo/file
   
   changeset:   1:cbba8ecc03b7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     remove foo
   
   changeset:   0:327daa9251fa
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add foo and bar
   
   $ cd ..
   $ hg convert orig new 2>&1 | grep -v 'subversion python bindings could not be loaded'
   initializing destination new repository
   scanning source...
   sorting...
   converting...
   3 add foo and bar
   2 remove foo
   1 add foo/file
   0 Added tag some-tag for changeset ad681a868e44
   $ cd new
   $ hg out ../orig
   comparing with ../orig
   searching for changes
   no changes found
   [1]
 
 dirstate should be empty:
 
   $ hg debugstate
   $ hg parents -q
   $ hg up -C
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg copy bar baz
 
 put something in the dirstate:
 
   $ hg debugstate > debugstate
   $ grep baz debugstate
   a   0         -1 unset               baz
   copy: bar -> baz
 
 add a new revision in the original repo
 
   $ cd ../orig
   $ echo baz > baz
   $ hg ci -qAm 'add baz'
   $ cd ..
   $ hg convert orig new 2>&1 | grep -v 'subversion python bindings could not be loaded'
   scanning source...
   sorting...
   converting...
   0 add baz
   $ cd new
   $ hg out ../orig
   comparing with ../orig
   searching for changes
   no changes found
   [1]
 
 dirstate should be the same (no output below):
 
   $ hg debugstate > new-debugstate
   $ diff debugstate new-debugstate
 
 no copies
 
   $ hg up -C
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg debugrename baz
   baz not renamed
   $ cd ..
 
 test tag rewriting
 
   $ cat > filemap <<EOF
   > exclude foo
   > EOF
   $ hg convert --filemap filemap orig new-filemap 2>&1 | grep -v 'subversion python bindings could not be loaded'
   initializing destination new-filemap repository
   scanning source...
   sorting...
   converting...
   4 add foo and bar
   3 remove foo
   2 add foo/file
   1 Added tag some-tag for changeset ad681a868e44
   0 add baz
   $ cd new-filemap
   $ hg tags
   tip                                2:6f4fd1df87fb
   some-tag                           0:ba8636729451
   $ cd ..
+
+
+Test cases for hg-hg roundtrip
+
+Helper
+
+  $ glog()
+  > {
+  >     hg log -G --template '{rev} {node|short} "{desc}" files: {files}\n' $*
+  > }
+
+Create a tricky source repo
+
+  $ hg init source
+  $ cd source
+
+  $ echo 0 > 0
+  $ hg ci -Aqm '0: add 0'
+  $ echo a > a
+  $ mkdir dir
+  $ echo b > dir/b
+  $ hg ci -qAm '1: add a and dir/b'
+  $ echo c > dir/c
+  $ hg ci -qAm '2: add dir/c'
+  $ hg copy a e
+  $ echo b >> b
+  $ hg ci -qAm '3: copy a to e, change b'
+  $ hg up -qr -3
+  $ echo a >> a
+  $ hg ci -qAm '4: change a'
+  $ hg merge
+  merging a and e to e
+  2 files updated, 1 files merged, 0 files removed, 0 files unresolved
+  (branch merge, don't forget to commit)
+  $ hg copy b dir/d
+  $ hg ci -qAm '5: merge 2 and 3, copy b to dir/d'
+  $ echo a >> a
+  $ hg ci -qAm '6: change a'
+
+  $ hg mani
+  0
+  a
+  b
+  dir/b
+  dir/c
+  dir/d
+  e
+  $ glog
+  @  6 0613c8e59a3d "6: change a" files: a
+  |
+  o    5 717e9b37cdb7 "5: merge 2 and 3, copy b to dir/d" files: dir/d e
+  |\
+  | o  4 86a55cb968d5 "4: change a" files: a
+  | |
+  o |  3 0e6e235919dd "3: copy a to e, change b" files: b e
+  | |
+  o |  2 0394b0d5e4f7 "2: add dir/c" files: dir/c
+  |/
+  o  1 333546584845 "1: add a and dir/b" files: a dir/b
+  |
+  o  0 d1a24e2ebd23 "0: add 0" files: 0
+  
+  $ cd ..
+
+Convert excluding rev 0 and dir/ (and thus rev2):
+
+  $ cat << EOF > filemap
+  > exclude dir
+  > EOF
+
+  $ hg convert --filemap filemap source dest --config convert.hg.revs=1::
+  initializing destination dest repository
+  scanning source...
+  sorting...
+  converting...
+  5 1: add a and dir/b
+  4 2: add dir/c
+  3 3: copy a to e, change b
+  2 4: change a
+  1 5: merge 2 and 3, copy b to dir/d
+  0 6: change a
+
+Verify that conversion skipped rev 2:
+
+  $ glog -R dest
+  o  4 78814e84a217 "6: change a" files: a
+  |
+  o    3 f7cff662c5e5 "5: merge 2 and 3, copy b to dir/d" files: e
+  |\
+  | o  2 ab40a95b0072 "4: change a" files: a
+  | |
+  o |  1 bd51f17597bf "3: copy a to e, change b" files: b e
+  |/
+  o  0 a4a1dae0fe35 "1: add a and dir/b" files: 0 a
+  
+
+Verify mapping correct in both directions:
+
+  $ cat source/.hg/shamap
+  a4a1dae0fe3514cefd9b8541b7abbc8f44f946d5 333546584845f70c4cfecb992341aaef0e708166
+  bd51f17597bf32268e68a560b206898c3960cda2 0e6e235919dd8e9285ba8eb5adf703af9ad99378
+  ab40a95b00725307e79c2fd271000aa8af9759f4 86a55cb968d51770cba2a1630d6cc637b574580a
+  f7cff662c5e581e6f3f1a85ffdd2bcb35825f6ba 717e9b37cdb7eb9917ca8e30aa3f986e6d5b177d
+  78814e84a217894517c2de392b903ed05e6871a4 0613c8e59a3ddb9789072ef52f1ed13496489bb4
+  $ cat dest/.hg/shamap
+  333546584845f70c4cfecb992341aaef0e708166 a4a1dae0fe3514cefd9b8541b7abbc8f44f946d5
+  0394b0d5e4f761ced559fd0bbdc6afc16cb3f7d1 a4a1dae0fe3514cefd9b8541b7abbc8f44f946d5
+  0e6e235919dd8e9285ba8eb5adf703af9ad99378 bd51f17597bf32268e68a560b206898c3960cda2
+  86a55cb968d51770cba2a1630d6cc637b574580a ab40a95b00725307e79c2fd271000aa8af9759f4
+  717e9b37cdb7eb9917ca8e30aa3f986e6d5b177d f7cff662c5e581e6f3f1a85ffdd2bcb35825f6ba
+  0613c8e59a3ddb9789072ef52f1ed13496489bb4 78814e84a217894517c2de392b903ed05e6871a4
+
+Verify meta data converted correctly:
+
+  $ hg -R dest log -r 1 --debug -p --git
+  changeset:   1:bd51f17597bf32268e68a560b206898c3960cda2
+  phase:       draft
+  parent:      0:a4a1dae0fe3514cefd9b8541b7abbc8f44f946d5
+  parent:      -1:0000000000000000000000000000000000000000
+  manifest:    1:040c72ed9b101773c24ac314776bfc846943781f
+  user:        test
+  date:        Thu Jan 01 00:00:00 1970 +0000
+  files+:      b e
+  extra:       branch=default
+  description:
+  3: copy a to e, change b
+  
+  
+  diff --git a/b b/b
+  new file mode 100644
+  --- /dev/null
+  +++ b/b
+  @@ -0,0 +1,1 @@
+  +b
+  diff --git a/a b/e
+  copy from a
+  copy to e
+  
+Verify files included and excluded correctly:
+
+  $ hg -R dest manifest -r tip
+  0
+  a
+  b
+  e
+
+
+Make changes in dest and convert back:
+
+  $ hg -R dest up -q
+  $ echo dest > dest/dest
+  $ hg -R dest ci -Aqm 'change in dest'
+  $ hg -R dest tip
+  changeset:   5:a2e0e3cc6d1d
+  tag:         tip
+  user:        test
+  date:        Thu Jan 01 00:00:00 1970 +0000
+  summary:     change in dest
+  
+
+(converting merges back after using a filemap will probably cause chaos so we
+exclude merges.)
+
+  $ hg convert dest source --config convert.hg.revs='!merge()'
+  scanning source...
+  sorting...
+  converting...
+  0 change in dest
+
+Verify the conversion back:
+
+  $ hg -R source log --debug -r tip
+  changeset:   7:e6d364a69ff1248b2099e603b0c145504cade6f0
+  tag:         tip
+  phase:       draft
+  parent:      6:0613c8e59a3ddb9789072ef52f1ed13496489bb4
+  parent:      -1:0000000000000000000000000000000000000000
+  manifest:    7:aa3e9542f3b76d4f1f1b2e9c7ce9dbb48b6a95ec
+  user:        test
+  date:        Thu Jan 01 00:00:00 1970 +0000
+  files+:      dest
+  extra:       branch=default
+  description:
+  change in dest
+  
+  
+Files that had been excluded are still present:
+
+  $ hg -R source manifest -r tip
+  0
+  a
+  b
+  dest
+  dir/b
+  dir/c
+  dir/d
+  e
+
+More source changes
+
+  $ cd source
+  $ echo 1 >> a
+  $ hg ci -m '8: source first branch'
+  created new head
+  $ hg up -qr -2
+  $ echo 2 >> a
+  $ hg ci -m '9: source second branch'
+  $ hg merge -q --tool internal:local
+  $ hg ci -m '10: source merge'
+  $ echo >> a
+  $ hg ci -m '11: source change'
+
+  $ hg mani
+  0
+  a
+  b
+  dest
+  dir/b
+  dir/c
+  dir/d
+  e
+
+  $ glog -r 6:
+  @  11 0c8927d1f7f4 "11: source change" files: a
+  |
+  o    10 9ccb7ee8d261 "10: source merge" files: a
+  |\
+  | o  9 f131b1518dba "9: source second branch" files: a
+  | |
+  o |  8 669cf0e74b50 "8: source first branch" files: a
+  | |
+  | o  7 e6d364a69ff1 "change in dest" files: dest
+  |/
+  o  6 0613c8e59a3d "6: change a" files: a
+  |
+  $ cd ..
+
+  $ hg convert --filemap filemap source dest --config convert.hg.revs=3:
+  scanning source...
+  sorting...
+  converting...
+  3 8: source first branch
+  2 9: source second branch
+  1 10: source merge
+  0 11: source change
+
+  $ glog -R dest
+  o  9 8432d597b263 "11: source change" files: a
+  |
+  o    8 632ffacdcd6f "10: source merge" files: a
+  |\
+  | o  7 049cfee90ee6 "9: source second branch" files: a
+  | |
+  o |  6 9b6845e036e5 "8: source first branch" files: a
+  | |
+  | @  5 a2e0e3cc6d1d "change in dest" files: dest
+  |/
+  o  4 78814e84a217 "6: change a" files: a
+  |
+  o    3 f7cff662c5e5 "5: merge 2 and 3, copy b to dir/d" files: e
+  |\
+  | o  2 ab40a95b0072 "4: change a" files: a
+  | |
+  o |  1 bd51f17597bf "3: copy a to e, change b" files: b e
+  |/
+  o  0 a4a1dae0fe35 "1: add a and dir/b" files: 0 a
+  
+  $ cd ..