convert: mercurial source: convert global tags only - not local tags

Mercurial tags can be local (tag -l, stored in .hg/localtags) or global (normal
tags, tracked in .hgtags) ... or extensions can add other kind of tags.

Convert would take all tags (except "tip"), not just the ones from .hgtags, and
put them into .hgtags.

Instead, convert only the global tags that come from .hgtags.

hgext/convert/hg.py

@@ -1,446 +1,448
 # hg.py - hg backend for convert extension
 #
 #  Copyright 2005-2009 Matt Mackall <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 # Notes 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.
 #
 # * Using "--config convert.hg.saverev=true" will make the source
 #   identifier to be stored in the converted revision. This will cause
 #   the converted revision to have a different identity than the
 #   source.
 
 
 import os, time, cStringIO
 from mercurial.i18n import _
 from mercurial.node import bin, hex, nullid
 from mercurial import hg, util, context, bookmarks, error, scmutil
 
 from common import NoRepo, commit, converter_source, converter_sink
 
 import re
 sha1re = re.compile(r'\b[0-9a-f]{6,40}\b')
 
 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 repository')
                                  % path)
             except error.RepoError, err:
                 ui.traceback()
                 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 repository')
                                  % path)
                 self.created.append(path)
             except error.RepoError:
                 ui.traceback()
                 raise NoRepo(_("could not create hg repository %s as sink")
                              % path)
         self.lock = None
         self.wlock = None
         self.filemapmode = False
 
     def before(self):
         self.ui.debug('run hg sink pre-conversion action\n')
         self.wlock = self.repo.wlock()
         self.lock = self.repo.lock()
 
     def after(self):
         self.ui.debug('run hg sink post-conversion action\n')
         if self.lock:
             self.lock.release()
         if self.wlock:
             self.wlock.release()
 
     def revmapfile(self):
         return self.repo.join("shamap")
 
     def authorfile(self):
         return self.repo.join("authormap")
 
     def setbranch(self, branch, pbranches):
         if not self.clonebranches:
             return
 
         setbranch = (branch != self.lastbranch)
         self.lastbranch = branch
         if not branch:
             branch = '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 Exception:
                 self.repo = hg.repository(self.ui, branchpath, create=True)
             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 Exception:
                 missings.setdefault(b[1], []).append(b[0])
 
         if missings:
             self.after()
             for pbranch, heads in sorted(missings.iteritems()):
                 pbranchpath = os.path.join(self.path, pbranch)
                 prepo = hg.peer(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 _rewritetags(self, source, revmap, data):
         fp = cStringIO.StringIO()
         for line in data.splitlines():
             s = line.split(' ', 1)
             if len(s) != 2:
                 continue
             revid = revmap.get(source.lookuprev(s[0]))
             if not revid:
                 continue
             fp.write('%s %s\n' % (revid, s[1]))
         return fp.getvalue()
 
     def putcommit(self, files, copies, parents, commit, source, revmap):
 
         files = dict(files)
         def getfilectx(repo, memctx, f):
             v = files[f]
             data, mode = source.getfile(f, v)
             if f == '.hgtags':
                 data = self._rewritetags(source, revmap, data)
             return context.memfilectx(f, data, 'l' in mode, 'x' in mode,
                                       copies.get(f))
 
         pl = []
         for p in parents:
             if p not in pl:
                 pl.append(p)
         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(nullid)
         if len(parents) < 2:
             parents.append(nullid)
         p2 = parents.pop(0)
 
         text = commit.desc
 
         sha1s = re.findall(sha1re, text)
         for sha1 in sha1s:
             oldrev = source.lookuprev(sha1)
             newrev = revmap.get(oldrev)
             if newrev is not None:
                 text = text.replace(sha1, newrev[:len(sha1)])
 
         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)
             ctx = context.memctx(self.repo, (p1, p2), text, files.keys(),
                                  getfilectx, commit.author, commit.date, extra)
             self.repo.commitctx(ctx)
             text = "(octopus merge fixup)\n"
             p2 = hex(self.repo.changelog.tip())
 
         if self.filemapmode and nparents == 1:
             man = self.repo.manifest
             mnode = self.repo.changelog.read(bin(p2))[0]
             closed = 'close' in commit.extra
             if not closed and not man.cmp(m1node, man.revision(mnode)):
                 self.ui.status(_("filtering out empty revision\n"))
                 self.repo.rollback(force=True)
                 return parent
         return p2
 
     def puttags(self, tags):
         try:
             parentctx = self.repo[self.tagsbranch]
             tagparent = parentctx.node()
         except error.RepoError:
             parentctx = None
             tagparent = nullid
 
         oldlines = set()
         for branch, heads in self.repo.branchmap().iteritems():
             for h in heads:
                 if '.hgtags' in self.repo[h]:
                     oldlines.update(
                         set(self.repo[h]['.hgtags'].data().splitlines(True)))
         oldlines = sorted(list(oldlines))
 
         newlines = sorted([("%s %s\n" % (tags[tag], tag)) for tag in tags])
         if newlines == oldlines:
             return None, None
 
         # if the old and new tags match, then there is nothing to update
         oldtags = set()
         newtags = set()
         for line in oldlines:
             s = line.strip().split(' ', 1)
             if len(s) != 2:
                 continue
             oldtags.add(s[1])
         for line in newlines:
             s = line.strip().split(' ', 1)
             if len(s) != 2:
                 continue
             if s[1] not in oldtags:
                 newtags.add(s[1].strip())
 
         if not newtags:
             return None, None
 
         data = "".join(newlines)
         def getfilectx(repo, memctx, f):
             return context.memfilectx(f, data, False, False, None)
 
         self.ui.status(_("updating tags\n"))
         date = "%s 0" % int(time.mktime(time.gmtime()))
         extra = {'branch': self.tagsbranch}
         ctx = context.memctx(self.repo, (tagparent, None), "update tags",
                              [".hgtags"], getfilectx, "convert-repo", date,
                              extra)
         self.repo.commitctx(ctx)
         return hex(self.repo.changelog.tip()), hex(tagparent)
 
     def setfilemapmode(self, active):
         self.filemapmode = active
 
     def putbookmarks(self, updatedbookmark):
         if not len(updatedbookmark):
             return
 
         self.ui.status(_("updating bookmarks\n"))
         destmarks = self.repo._bookmarks
         for bookmark in updatedbookmark:
             destmarks[bookmark] = bin(updatedbookmark[bookmark])
         destmarks.write()
 
     def hascommit(self, rev):
         if rev not in self.repo and self.clonebranches:
             raise util.Abort(_('revision %s not found in destination '
                                'repository (lookups with clonebranches=true '
                                'are not implemented)') % rev)
         return rev in self.repo
 
 class mercurial_source(converter_source):
     def __init__(self, ui, path, rev=None):
         converter_source.__init__(self, ui, path, rev)
         self.ignoreerrors = ui.configbool('convert', 'hg.ignoreerrors', False)
         self.ignored = set()
         self.saverev = ui.configbool('convert', 'hg.saverev', False)
         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 error.RepoError
         except error.RepoError:
             ui.traceback()
             raise NoRepo(_("%s is not a local Mercurial repository") % path)
         self.lastrev = None
         self.lastctx = None
         self._changescache = None
         self.convertfp = None
         # Restrict converted revisions to startrev descendants
         startnode = ui.config('convert', 'hg.startrev')
         hgrevs = ui.config('convert', 'hg.revs')
         if hgrevs is None:
             if startnode is not None:
                 try:
                     startnode = self.repo.lookup(startnode)
                 except error.RepoError:
                     raise util.Abort(_('%s is not a valid start revision')
                                      % startnode)
                 startrev = self.repo.changelog.rev(startnode)
                 children = {startnode: 1}
                 for r in self.repo.changelog.descendants([startrev]):
                     children[self.repo.changelog.node(r)] = 1
                 self.keep = children.__contains__
             else:
                 self.keep = util.always
             if rev:
                 self._heads = [self.repo[rev].node()]
             else:
                 self._heads = self.repo.heads()
         else:
             if rev or startnode is not None:
                 raise util.Abort(_('hg.revs cannot be combined with '
                                    'hg.startrev or --rev'))
             nodes = set()
             parents = set()
             for r in scmutil.revrange(self.repo, [hgrevs]):
                 ctx = self.repo[r]
                 nodes.add(ctx.node())
                 parents.update(p.node() for p in ctx.parents())
             self.keep = nodes.__contains__
             self._heads = nodes - parents
 
     def changectx(self, rev):
         if self.lastrev != rev:
             self.lastctx = self.repo[rev]
             self.lastrev = rev
         return self.lastctx
 
     def parents(self, ctx):
         return [p for p in ctx.parents() if p and self.keep(p.node())]
 
     def getheads(self):
         return [hex(h) for h in self._heads if self.keep(h)]
 
     def getfile(self, name, rev):
         try:
             fctx = self.changectx(rev)[name]
             return fctx.data(), fctx.flags()
         except error.LookupError, err:
             raise IOError(err)
 
     def getchanges(self, rev):
         ctx = self.changectx(rev)
         parents = self.parents(ctx)
         if not parents:
             files = sorted(ctx.manifest())
             # getcopies() is not needed for roots, but it is a simple way to
             # detect missing revlogs and abort on errors or populate
             # self.ignored
             self.getcopies(ctx, parents, files)
             return [(f, rev) for f in files if f not in self.ignored], {}
         if self._changescache and self._changescache[0] == rev:
             m, a, r = self._changescache[1]
         else:
             m, a, r = self.repo.status(parents[0].node(), ctx.node())[:3]
         # getcopies() detects missing revlogs early, run it before
         # filtering the changes.
         copies = self.getcopies(ctx, parents, m + a)
         changes = [(name, rev) for name in m + a + r
                    if name not in self.ignored]
         return sorted(changes), copies
 
     def getcopies(self, ctx, parents, files):
         copies = {}
         for name in files:
             if name in self.ignored:
                 continue
             try:
                 copysource, _copynode = ctx.filectx(name).renamed()
                 if copysource in self.ignored:
                     continue
                 # Ignore copy sources not in parent revisions
                 found = False
                 for p in parents:
                     if copysource in p:
                         found = True
                         break
                 if not found:
                     continue
                 copies[name] = copysource
             except TypeError:
                 pass
             except error.LookupError, e:
                 if not self.ignoreerrors:
                     raise
                 self.ignored.add(name)
                 self.ui.warn(_('ignoring: %s\n') % e)
         return copies
 
     def getcommit(self, rev):
         ctx = self.changectx(rev)
         parents = [p.hex() for p in self.parents(ctx)]
         if self.saverev:
             crev = rev
         else:
             crev = None
         return commit(author=ctx.user(),
                       date=util.datestr(ctx.date(), '%Y-%m-%d %H:%M:%S %1%2'),
                       desc=ctx.description(), rev=crev, parents=parents,
                       branch=ctx.branch(), extra=ctx.extra(),
                       sortkey=ctx.rev())
 
     def gettags(self):
-        tags = [t for t in self.repo.tagslist() if t[0] != 'tip']
+        # This will get written to .hgtags, filter non global tags out.
+        tags = [t for t in self.repo.tagslist()
+                if self.repo.tagtype(t[0]) == 'global']
         return dict([(name, hex(node)) for name, node in tags
                      if self.keep(node)])
 
     def getchangedfiles(self, rev, i):
         ctx = self.changectx(rev)
         parents = self.parents(ctx)
         if not parents and i is None:
             i = 0
             changes = [], ctx.manifest().keys(), []
         else:
             i = i or 0
             changes = self.repo.status(parents[i].node(), ctx.node())[:3]
         changes = [[f for f in l if f not in self.ignored] for l in changes]
 
         if i == 0:
             self._changescache = (rev, changes)
 
         return changes[0] + changes[1] + changes[2]
 
     def converted(self, rev, destrev):
         if self.convertfp is None:
             self.convertfp = open(self.repo.join('shamap'), 'a')
         self.convertfp.write('%s %s\n' % (destrev, rev))
         self.convertfp.flush()
 
     def before(self):
         self.ui.debug('run hg source pre-conversion action\n')
 
     def after(self):
         self.ui.debug('run hg source post-conversion action\n')
 
     def hasnativeorder(self):
         return True
 
     def hasnativeclose(self):
         return True
 
     def lookuprev(self, rev):
         try:
             return hex(self.repo.lookup(rev))
         except error.RepoError:
             return None
 
     def getbookmarks(self):
         return bookmarks.listbookmarks(self.repo)
 
     def checkrevformat(self, revstr, mapname='splicemap'):
         """ Mercurial, revision string is a 40 byte hex """
         self.checkhexformat(revstr, mapname)

tests/test-convert-hg-sink.t

@@ -1,392 +1,394
 
   $ 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 tag -l local-tag
   $ hg log
   changeset:   3:593cbf6fb2b4
+  tag:         local-tag
   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:3c74706b1ff8
   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 ..