convert: apply the appropriate phases to the destination (issue4165)

If the conversion doesn't change the hash, and the cset is public in the source,
it should be public in the destination.  (This can happen if file remapping is
done that doesn't affect the initial commits.)  This also propagates the secret
phase from the source, regardless of the hash, because presumably the content is
what is secret.  Otherwise, the destination commit stays in the draft phase.

Maybe any draft cset with an unchanged hash should be changed to public, because
it has effectively been shared, but convert pretty strongly implies throwing
away (or at least readonly archiving) the source repo.

The change in the rollback output is because the name of the outer transaction
is now 'convert', which seems more accurate.  Unfortunately, the memctx won't
indicate the hash prior to committing, so the proper phase can't be applied with
the commit.

The repo is already write locked in mercurial_sink.before().

hgext/convert/common.py

@@ -1,470 +1,471
 # common.py - common code for the 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.
 
 import base64, errno, subprocess, os, datetime, re
 import cPickle as pickle
-from mercurial import util
+from mercurial import phases, util
 from mercurial.i18n import _
 
 propertycache = util.propertycache
 
 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 MissingTool(Exception):
     pass
 
 def checktool(exe, name=None, abort=True):
     name = name or exe
     if not util.findexe(exe):
         if abort:
             exc = util.Abort
         else:
             exc = MissingTool
         raise exc(_('cannot find required "%s" tool') % name)
 
 class NoRepo(Exception):
     pass
 
 SKIPREV = 'SKIP'
 
 class commit(object):
     def __init__(self, author, date, desc, parents, branch=None, rev=None,
-                 extra={}, sortkey=None, saverev=True):
+                 extra={}, sortkey=None, saverev=True, phase=phases.draft):
         self.author = author or 'unknown'
         self.date = date or '0 0'
         self.desc = desc
         self.parents = parents
         self.branch = branch
         self.rev = rev
         self.extra = extra
         self.sortkey = sortkey
         self.saverev = saverev
+        self.phase = phase
 
 class converter_source(object):
     """Conversion source interface"""
 
     def __init__(self, ui, path=None, 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 checkhexformat(self, revstr, mapname='splicemap'):
         """ fails if revstr is not a 40 byte hex. mercurial and git both uses
             such format for their revision numbering
         """
         if not re.match(r'[0-9a-fA-F]{40,40}$', revstr):
             raise util.Abort(_('%s entry %s is not a valid revision'
                                ' identifier') % (mapname, revstr))
 
     def before(self):
         pass
 
     def after(self):
         pass
 
     def setrevmap(self, revmap):
         """set the map of already-converted revisions"""
         pass
 
     def getheads(self):
         """Return a list of this repository's heads"""
         raise NotImplementedError
 
     def getfile(self, name, rev):
         """Return a pair (data, mode) where data is the file content
         as a string and mode one of '', 'x' or 'l'. rev is the
         identifier returned by a previous call to getchanges().
         Data is None if file is missing/deleted in rev.
         """
         raise NotImplementedError
 
     def getchanges(self, version, full):
         """Returns a tuple of (files, copies, cleanp2).
 
         files is a sorted list of (filename, id) tuples for all files
         changed between version and its first parent returned by
         getcommit(). If full, all files in that revision is returned.
         id is the source revision id of the file.
 
         copies is a dictionary of dest: source
 
         cleanp2 is the set of files filenames that are clean against p2.
         (Files that are clean against p1 are already not in files (unless
         full). This makes it possible to handle p2 clean files similarly.)
         """
         raise NotImplementedError
 
     def getcommit(self, version):
         """Return the commit object for version"""
         raise NotImplementedError
 
     def numcommits(self):
         """Return the number of commits in this source.
 
         If unknown, return None.
         """
         return None
 
     def gettags(self):
         """Return the tags as a dictionary of name: revision
 
         Tag names must be UTF-8 strings.
         """
         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 UnicodeError:
             try:
                 return s.decode("latin-1").encode("utf-8")
             except UnicodeError:
                 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
 
     def converted(self, rev, sinkrev):
         '''Notify the source that a revision has been converted.'''
         pass
 
     def hasnativeorder(self):
         """Return true if this source has a meaningful, native revision
         order. For instance, Mercurial revisions are store sequentially
         while there is no such global ordering with Darcs.
         """
         return False
 
     def hasnativeclose(self):
         """Return true if this source has ability to close branch.
         """
         return False
 
     def lookuprev(self, rev):
         """If rev is a meaningful revision reference in source, return
         the referenced identifier in the same format used by getcommit().
         return None otherwise.
         """
         return None
 
     def getbookmarks(self):
         """Return the bookmarks as a dictionary of name: revision
 
         Bookmark names are to be UTF-8 strings.
         """
         return {}
 
     def checkrevformat(self, revstr, mapname='splicemap'):
         """revstr is a string that describes a revision in the given
            source control system.  Return true if revstr has correct
            format.
         """
         return True
 
 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 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 putcommit(self, files, copies, parents, commit, source, revmap, full,
                   cleanp2):
         """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.  'files' is a list of (path, version) tuples,
         'copies' is a dictionary mapping destinations to sources,
         'source' is the source repository, and 'revmap' is a mapfile
         of source revisions to converted revisions. Only getfile() and
         lookuprev() should be called on 'source'. 'full' means that 'files'
         is complete and all other files should be removed.
         'cleanp2' is a set of the filenames that are unchanged from p2
         (only in the common merge case where there two parents).
 
         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, ...} where tagname is an UTF-8 string.
         Return a pair (tag_revision, tag_parent_revision), or (None, None)
         if nothing was changed.
         """
         raise NotImplementedError
 
     def setbranch(self, branch, pbranches):
         """Set the current branch name. Called before the first putcommit
         on the branch.
         branch: branch name for subsequent commits
         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
 
     def before(self):
         pass
 
     def after(self):
         pass
 
     def putbookmarks(self, bookmarks):
         """Put bookmarks into sink.
 
         bookmarks: {bookmarkname: sink_rev_id, ...}
         where bookmarkname is an UTF-8 string.
         """
         pass
 
     def hascommitfrommap(self, rev):
         """Return False if a rev mentioned in a filemap is known to not be
         present."""
         raise NotImplementedError
 
     def hascommitforsplicemap(self, rev):
         """This method is for the special needs for splicemap handling and not
         for general use. Returns True if the sink contains rev, aborts on some
         special cases."""
         raise NotImplementedError
 
 class commandline(object):
     def __init__(self, ui, command):
         self.ui = ui
         self.command = command
 
     def prerun(self):
         pass
 
     def postrun(self):
         pass
 
     def _cmdline(self, cmd, *args, **kwargs):
         cmdline = [self.command, cmd] + list(args)
         for k, v in kwargs.iteritems():
             if len(k) == 1:
                 cmdline.append('-' + k)
             else:
                 cmdline.append('--' + k.replace('_', '-'))
             try:
                 if len(k) == 1:
                     cmdline.append('' + v)
                 else:
                     cmdline[-1] += '=' + v
             except TypeError:
                 pass
         cmdline = [util.shellquote(arg) for arg in cmdline]
         if not self.ui.debugflag:
             cmdline += ['2>', os.devnull]
         cmdline = ' '.join(cmdline)
         return cmdline
 
     def _run(self, cmd, *args, **kwargs):
         def popen(cmdline):
             p = subprocess.Popen(cmdline, shell=True, bufsize=-1,
                     close_fds=util.closefds,
                     stdout=subprocess.PIPE)
             return p
         return self._dorun(popen, cmd, *args, **kwargs)
 
     def _run2(self, cmd, *args, **kwargs):
         return self._dorun(util.popen2, cmd, *args, **kwargs)
 
     def _dorun(self, openfunc, cmd,  *args, **kwargs):
         cmdline = self._cmdline(cmd, *args, **kwargs)
         self.ui.debug('running: %s\n' % (cmdline,))
         self.prerun()
         try:
             return openfunc(cmdline)
         finally:
             self.postrun()
 
     def run(self, cmd, *args, **kwargs):
         p = self._run(cmd, *args, **kwargs)
         output = p.communicate()[0]
         self.ui.debug(output)
         return output, p.returncode
 
     def runlines(self, cmd, *args, **kwargs):
         p = self._run(cmd, *args, **kwargs)
         output = p.stdout.readlines()
         p.wait()
         self.ui.debug(''.join(output))
         return output, p.returncode
 
     def checkexit(self, status, output=''):
         if status:
             if output:
                 self.ui.warn(_('%s error:\n') % self.command)
                 self.ui.warn(output)
             msg = util.explainexit(status)[0]
             raise util.Abort('%s %s' % (self.command, msg))
 
     def run0(self, cmd, *args, **kwargs):
         output, status = self.run(cmd, *args, **kwargs)
         self.checkexit(status, output)
         return output
 
     def runlines0(self, cmd, *args, **kwargs):
         output, status = self.runlines(cmd, *args, **kwargs)
         self.checkexit(status, ''.join(output))
         return output
 
     @propertycache
     def argmax(self):
         # POSIX requires at least 4096 bytes for ARG_MAX
         argmax = 4096
         try:
             argmax = os.sysconf("SC_ARG_MAX")
         except (AttributeError, ValueError):
             pass
 
         # Windows shells impose their own limits on command line length,
         # down to 2047 bytes for cmd.exe under Windows NT/2k and 2500 bytes
         # for older 4nt.exe. See http://support.microsoft.com/kb/830473 for
         # details about cmd.exe limitations.
 
         # Since ARG_MAX is for command line _and_ environment, lower our limit
         # (and make happy Windows shells while doing this).
         return argmax // 2 - 1
 
     def _limit_arglist(self, arglist, cmd, *args, **kwargs):
         cmdlen = len(self._cmdline(cmd, *args, **kwargs))
         limit = self.argmax - cmdlen
         bytes = 0
         fl = []
         for fn in arglist:
             b = len(fn) + 3
             if bytes + b < limit or len(fl) == 0:
                 fl.append(fn)
                 bytes += b
             else:
                 yield fl
                 fl = [fn]
                 bytes = b
         if fl:
             yield fl
 
     def xargs(self, arglist, cmd, *args, **kwargs):
         for l in self._limit_arglist(arglist, cmd, *args, **kwargs):
             self.run0(cmd, *(list(args) + l), **kwargs)
 
 class mapfile(dict):
     def __init__(self, ui, path):
         super(mapfile, self).__init__()
         self.ui = ui
         self.path = path
         self.fp = None
         self.order = []
         self._read()
 
     def _read(self):
         if not self.path:
             return
         try:
             fp = open(self.path, 'r')
         except IOError, err:
             if err.errno != errno.ENOENT:
                 raise
             return
         for i, line in enumerate(fp):
             line = line.splitlines()[0].rstrip()
             if not line:
                 # Ignore blank lines
                 continue
             try:
                 key, value = line.rsplit(' ', 1)
             except ValueError:
                 raise util.Abort(
                     _('syntax error in %s(%d): key/value pair expected')
                     % (self.path, i + 1))
             if key not in self:
                 self.order.append(key)
             super(mapfile, self).__setitem__(key, value)
         fp.close()
 
     def __setitem__(self, key, value):
         if self.fp is None:
             try:
                 self.fp = open(self.path, 'a')
             except IOError, err:
                 raise util.Abort(_('could not open map file %r: %s') %
                                  (self.path, err.strerror))
         self.fp.write('%s %s\n' % (key, value))
         self.fp.flush()
         super(mapfile, self).__setitem__(key, value)
 
     def close(self):
         if self.fp:
             self.fp.close()
             self.fp = None
 
 def makedatetimestamp(t):
     """Like util.makedate() but for time t instead of current time"""
     delta = (datetime.datetime.utcfromtimestamp(t) -
              datetime.datetime.fromtimestamp(t))
     tz = delta.days * 86400 + delta.seconds
     return t, tz

hgext/convert/hg.py

@@ -1,536 +1,560
 # 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, exchange
+from mercurial import phases
 
 from common import NoRepo, commit, converter_source, converter_sink, mapfile
 
 import re
 sha1re = re.compile(r'\b[0-9a-f]{12,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
         self.subrevmaps = {}
 
     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]
         if pbranches:
             pbranch = pbranches[0][1]
         else:
             pbranch = '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))
                 exchange.pull(self.repo, 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:
                 if s[0] == hex(nullid):
                     revid = s[0]
                 else:
                     continue
             fp.write('%s %s\n' % (revid, s[1]))
         return fp.getvalue()
 
     def _rewritesubstate(self, source, data):
         fp = cStringIO.StringIO()
         for line in data.splitlines():
             s = line.split(' ', 1)
             if len(s) != 2:
                 continue
 
             revid = s[0]
             subpath = s[1]
             if revid != hex(nullid):
                 revmap = self.subrevmaps.get(subpath)
                 if revmap is None:
                     revmap = mapfile(self.ui,
                                      self.repo.wjoin(subpath, '.hg/shamap'))
                     self.subrevmaps[subpath] = revmap
 
                     # It is reasonable that one or more of the subrepos don't
                     # need to be converted, in which case they can be cloned
                     # into place instead of converted.  Therefore, only warn
                     # once.
                     msg = _('no ".hgsubstate" updates will be made for "%s"\n')
                     if len(revmap) == 0:
                         sub = self.repo.wvfs.reljoin(subpath, '.hg')
 
                         if self.repo.wvfs.exists(sub):
                             self.ui.warn(msg % subpath)
 
                 newid = revmap.get(revid)
                 if not newid:
                     if len(revmap) > 0:
                         self.ui.warn(_("%s is missing from %s/.hg/shamap\n") %
                                      (revid, subpath))
                 else:
                     revid = newid
 
             fp.write('%s %s\n' % (revid, subpath))
 
         return fp.getvalue()
 
     def putcommit(self, files, copies, parents, commit, source, revmap, full,
                   cleanp2):
         files = dict(files)
 
         def getfilectx(repo, memctx, f):
             if p2ctx and f in cleanp2 and f not in copies:
                 self.ui.debug('reusing %s from p2\n' % f)
                 return p2ctx[f]
             try:
                 v = files[f]
             except KeyError:
                 return None
             data, mode = source.getfile(f, v)
             if data is None:
                 return None
             if f == '.hgtags':
                 data = self._rewritetags(source, revmap, data)
             if f == '.hgsubstate':
                 data = self._rewritesubstate(source, data)
             return context.memfilectx(self.repo, 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()
 
         for label in ('source', 'transplant_source', 'rebase_source'):
             node = extra.get(label)
 
             if node is None:
                 continue
 
             # Only transplant stores its reference in binary
             if label == 'transplant_source':
                 node = hex(node)
 
             newrev = revmap.get(node)
             if newrev is not None:
                 if label == 'transplant_source':
                     newrev = bin(newrev)
 
                 extra[label] = newrev
 
         if self.branchnames and commit.branch:
             extra['branch'] = commit.branch
         if commit.rev and commit.saverev:
             extra['convert_revision'] = commit.rev
 
         while parents:
             p1 = p2
             p2 = parents.pop(0)
             p2ctx = None
             if p2 != nullid:
                 p2ctx = self.repo[p2]
             fileset = set(files)
             if full:
                 fileset.update(self.repo[p1])
                 fileset.update(self.repo[p2])
             ctx = context.memctx(self.repo, (p1, p2), text, fileset,
                                  getfilectx, commit.author, commit.date, extra)
-            self.repo.commitctx(ctx)
+
+            # We won't know if the conversion changes the node until after the
+            # commit, so copy the source's phase for now.
+            self.repo.ui.setconfig('phases', 'new-commit',
+                                   phases.phasenames[commit.phase], 'convert')
+
+            tr = self.repo.transaction("convert")
+
+            try:
+                node = hex(self.repo.commitctx(ctx))
+
+                # If the node value has changed, but the phase is lower than
+                # draft, set it back to draft since it hasn't been exposed
+                # anywhere.
+                if commit.rev != node:
+                    ctx = self.repo[node]
+                    if ctx.phase() < phases.draft:
+                        phases.retractboundary(self.repo, tr, phases.draft,
+                                               [ctx.node()])
+                tr.close()
+            finally:
+                tr.release()
+
             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(repo, 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 hascommitfrommap(self, rev):
         # the exact semantics of clonebranches is unclear so we can't say no
         return rev in self.repo or self.clonebranches
 
     def hascommitforsplicemap(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, 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:
             return None, None
 
     def getchanges(self, rev, full):
         ctx = self.changectx(rev)
         parents = self.parents(ctx)
         if full or not parents:
             files = copyfiles = ctx.manifest()
         if parents:
             if self._changescache[0] == rev:
                 m, a, r = self._changescache[1]
             else:
                 m, a, r = self.repo.status(parents[0].node(), ctx.node())[:3]
             if not full:
                 files = m + a + r
             copyfiles = m + a
         # getcopies() is also run for roots and before filtering so missing
         # revlogs are detected early
         copies = self.getcopies(ctx, parents, copyfiles)
         cleanp2 = set()
         if len(parents) == 2:
             cleanp2.update(self.repo.status(parents[1].node(), ctx.node(),
                                             clean=True).clean)
         changes = [(f, rev) for f in files if f not in self.ignored]
         changes.sort()
         return changes, copies, cleanp2
 
     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)]
         crev = rev
 
         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(), saverev=self.saverev)
+                      sortkey=ctx.rev(), saverev=self.saverev,
+                      phase=ctx.phase())
 
     def gettags(self):
         # 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, error.LookupError):
             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-cvs.t

@@ -1,470 +1,470
 #require cvs
 
   $ cvscall()
   > {
   >     cvs -f "$@"
   > }
   $ hgcat()
   > {
   >     hg --cwd src-hg cat -r tip "$1"
   > }
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "convert = " >> $HGRCPATH
   $ cat > cvshooks.py <<EOF
   > def cvslog(ui,repo,hooktype,log):
   >     print "%s hook: %d entries"%(hooktype,len(log))
   > 
   > def cvschangesets(ui,repo,hooktype,changesets):
   >     print "%s hook: %d changesets"%(hooktype,len(changesets))
   > EOF
   $ hookpath=`pwd`
   $ cat <<EOF >> $HGRCPATH
   > [hooks]
   > cvslog = python:$hookpath/cvshooks.py:cvslog
   > cvschangesets = python:$hookpath/cvshooks.py:cvschangesets
   > EOF
 
 create cvs repository
 
   $ mkdir cvsrepo
   $ cd cvsrepo
   $ CVSROOT=`pwd`
   $ export CVSROOT
   $ CVS_OPTIONS=-f
   $ export CVS_OPTIONS
   $ cd ..
   $ rmdir cvsrepo
   $ cvscall -q -d "$CVSROOT" init
 
 create source directory
 
   $ mkdir src-temp
   $ cd src-temp
   $ echo a > a
   $ mkdir b
   $ cd b
   $ echo c > c
   $ cd ..
 
 import source directory
 
   $ cvscall -q import -m import src INITIAL start
   N src/a
   N src/b/c
   
   No conflicts created by this import
   
   $ cd ..
 
 checkout source directory
 
   $ cvscall -q checkout src
   U src/a
   U src/b/c
 
 commit a new revision changing b/c
 
   $ cd src
   $ sleep 1
   $ echo c >> b/c
   $ cvscall -q commit -mci0 . | grep '<--'
   $TESTTMP/cvsrepo/src/b/c,v  <--  *c (glob)
   $ cd ..
 
 convert fresh repo and also check localtimezone option
 
 NOTE: This doesn't check all time zones -- it merely determines that
 the configuration option is taking effect.
 
 An arbitrary (U.S.) time zone is used here.  TZ=US/Hawaii is selected
 since it does not use DST (unlike other U.S. time zones) and is always
 a fixed difference from UTC.
 
   $ TZ=US/Hawaii hg convert --config convert.localtimezone=True src src-hg
   initializing destination src-hg repository
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   5 log entries
   cvslog hook: 5 entries
   creating changesets
   3 changeset entries
   cvschangesets hook: 3 changesets
   sorting...
   converting...
   2 Initial revision
   1 ci0
   0 import
   updating tags
   $ hgcat a
   a
   $ hgcat b/c
   c
   c
 
 convert fresh repo with --filemap
 
   $ echo include b/c > filemap
   $ hg convert --filemap filemap src src-filemap
   initializing destination src-filemap repository
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   5 log entries
   cvslog hook: 5 entries
   creating changesets
   3 changeset entries
   cvschangesets hook: 3 changesets
   sorting...
   converting...
   2 Initial revision
   1 ci0
   0 import
   filtering out empty revision
-  repository tip rolled back to revision 1 (undo commit)
+  repository tip rolled back to revision 1 (undo convert)
   updating tags
   $ hgcat b/c
   c
   c
   $ hg -R src-filemap log --template '{rev} {desc} files: {files}\n'
   2 update tags files: .hgtags
   1 ci0 files: b/c
   0 Initial revision files: b/c
 
 convert full repository (issue1649)
 
   $ cvscall -q -d "$CVSROOT" checkout -d srcfull "." | grep -v CVSROOT
   U srcfull/src/a
   U srcfull/src/b/c
   $ ls srcfull
   CVS
   CVSROOT
   src
   $ hg convert srcfull srcfull-hg \
   >     | grep -v 'log entries' | grep -v 'hook:' \
   >     | grep -v '^[0-3] .*' # filter instable changeset order
   initializing destination srcfull-hg repository
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   creating changesets
   4 changeset entries
   sorting...
   converting...
   updating tags
   $ hg cat -r tip --cwd srcfull-hg src/a
   a
   $ hg cat -r tip --cwd srcfull-hg src/b/c
   c
   c
 
 commit new file revisions
 
   $ cd src
   $ echo a >> a
   $ echo c >> b/c
   $ cvscall -q commit -mci1 . | grep '<--'
   $TESTTMP/cvsrepo/src/a,v  <--  a
   $TESTTMP/cvsrepo/src/b/c,v  <--  *c (glob)
   $ cd ..
 
 convert again
 
   $ TZ=US/Hawaii hg convert --config convert.localtimezone=True src src-hg
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   7 log entries
   cvslog hook: 7 entries
   creating changesets
   4 changeset entries
   cvschangesets hook: 4 changesets
   sorting...
   converting...
   0 ci1
   $ hgcat a
   a
   a
   $ hgcat b/c
   c
   c
   c
 
 convert again with --filemap
 
   $ hg convert --filemap filemap src src-filemap
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   7 log entries
   cvslog hook: 7 entries
   creating changesets
   4 changeset entries
   cvschangesets hook: 4 changesets
   sorting...
   converting...
   0 ci1
   $ hgcat b/c
   c
   c
   c
   $ hg -R src-filemap log --template '{rev} {desc} files: {files}\n'
   3 ci1 files: b/c
   2 update tags files: .hgtags
   1 ci0 files: b/c
   0 Initial revision files: b/c
 
 commit branch
 
   $ cd src
   $ cvs -q update -r1.1 b/c
   U b/c
   $ cvs -q tag -b branch
   T a
   T b/c
   $ cvs -q update -r branch > /dev/null
   $ echo d >> b/c
   $ cvs -q commit -mci2 . | grep '<--'
   $TESTTMP/cvsrepo/src/b/c,v  <--  *c (glob)
   $ cd ..
 
 convert again
 
   $ TZ=US/Hawaii hg convert --config convert.localtimezone=True src src-hg
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   8 log entries
   cvslog hook: 8 entries
   creating changesets
   5 changeset entries
   cvschangesets hook: 5 changesets
   sorting...
   converting...
   0 ci2
   $ hgcat b/c
   c
   d
 
 convert again with --filemap
 
   $ TZ=US/Hawaii hg convert --config convert.localtimezone=True --filemap filemap src src-filemap
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   8 log entries
   cvslog hook: 8 entries
   creating changesets
   5 changeset entries
   cvschangesets hook: 5 changesets
   sorting...
   converting...
   0 ci2
   $ hgcat b/c
   c
   d
   $ hg -R src-filemap log --template '{rev} {desc} files: {files}\n'
   4 ci2 files: b/c
   3 ci1 files: b/c
   2 update tags files: .hgtags
   1 ci0 files: b/c
   0 Initial revision files: b/c
 
 commit a new revision with funny log message
 
   $ cd src
   $ sleep 1
   $ echo e >> a
   $ cvscall -q commit -m'funny
   > ----------------------------
   > log message' . | grep '<--' |\
   >  sed -e 's:.*src/\(.*\),v.*:checking in src/\1,v:g'
   checking in src/a,v
 
 commit new file revisions with some fuzz
 
   $ sleep 1
   $ echo f >> a
   $ cvscall -q commit -mfuzzy . | grep '<--'
   $TESTTMP/cvsrepo/src/a,v  <--  a
   $ sleep 4 # the two changes will be split if fuzz < 4
   $ echo g >> b/c
   $ cvscall -q commit -mfuzzy . | grep '<--'
   $TESTTMP/cvsrepo/src/b/c,v  <--  *c (glob)
   $ cd ..
 
 convert again
 
   $ TZ=US/Hawaii hg convert --config convert.cvsps.fuzz=2 --config convert.localtimezone=True src src-hg
   connecting to $TESTTMP/cvsrepo
   scanning source...
   collecting CVS rlog
   11 log entries
   cvslog hook: 11 entries
   creating changesets
   8 changeset entries
   cvschangesets hook: 8 changesets
   sorting...
   converting...
   2 funny
   1 fuzzy
   0 fuzzy
   $ hg -R src-hg log -G --template '{rev} ({branches}) {desc} date: {date|date} files: {files}\n'
   o  8 (branch) fuzzy date: * -1000 files: b/c (glob)
   |
   o  7 (branch) fuzzy date: * -1000 files: a (glob)
   |
   o  6 (branch) funny
   |  ----------------------------
   |  log message date: * -1000 files: a (glob)
   o  5 (branch) ci2 date: * -1000 files: b/c (glob)
   
   o  4 () ci1 date: * -1000 files: a b/c (glob)
   |
   o  3 () update tags date: * +0000 files: .hgtags (glob)
   |
   | o  2 (INITIAL) import date: * -1000 files: (glob)
   | |
   o |  1 () ci0 date: * -1000 files: b/c (glob)
   |/
   o  0 () Initial revision date: * -1000 files: a b/c (glob)
   
 
 testing debugcvsps
 
   $ cd src
   $ hg debugcvsps --fuzz=2
   collecting CVS rlog
   11 log entries
   cvslog hook: 11 entries
   creating changesets
   10 changeset entries
   cvschangesets hook: 10 changesets
   ---------------------
   PatchSet 1 
   Date: * (glob)
   Author: * (glob)
   Branch: HEAD
   Tag: (none) 
   Branchpoints: INITIAL 
   Log:
   Initial revision
   
   Members: 
   	a:INITIAL->1.1 
   
   ---------------------
   PatchSet 2 
   Date: * (glob)
   Author: * (glob)
   Branch: HEAD
   Tag: (none) 
   Branchpoints: INITIAL, branch 
   Log:
   Initial revision
   
   Members: 
   	b/c:INITIAL->1.1 
   
   ---------------------
   PatchSet 3 
   Date: * (glob)
   Author: * (glob)
   Branch: INITIAL
   Tag: start 
   Log:
   import
   
   Members: 
   	a:1.1->1.1.1.1 
   	b/c:1.1->1.1.1.1 
   
   ---------------------
   PatchSet 4 
   Date: * (glob)
   Author: * (glob)
   Branch: HEAD
   Tag: (none) 
   Log:
   ci0
   
   Members: 
   	b/c:1.1->1.2 
   
   ---------------------
   PatchSet 5 
   Date: * (glob)
   Author: * (glob)
   Branch: HEAD
   Tag: (none) 
   Branchpoints: branch 
   Log:
   ci1
   
   Members: 
   	a:1.1->1.2 
   
   ---------------------
   PatchSet 6 
   Date: * (glob)
   Author: * (glob)
   Branch: HEAD
   Tag: (none) 
   Log:
   ci1
   
   Members: 
   	b/c:1.2->1.3 
   
   ---------------------
   PatchSet 7 
   Date: * (glob)
   Author: * (glob)
   Branch: branch
   Tag: (none) 
   Log:
   ci2
   
   Members: 
   	b/c:1.1->1.1.2.1 
   
   ---------------------
   PatchSet 8 
   Date: * (glob)
   Author: * (glob)
   Branch: branch
   Tag: (none) 
   Log:
   funny
   ----------------------------
   log message
   
   Members: 
   	a:1.2->1.2.2.1 
   
   ---------------------
   PatchSet 9 
   Date: * (glob)
   Author: * (glob)
   Branch: branch
   Tag: (none) 
   Log:
   fuzzy
   
   Members: 
   	a:1.2.2.1->1.2.2.2 
   
   ---------------------
   PatchSet 10 
   Date: * (glob)
   Author: * (glob)
   Branch: branch
   Tag: (none) 
   Log:
   fuzzy
   
   Members: 
   	b/c:1.1.2.1->1.1.2.2 
   
 
   $ cd ..

tests/test-convert-filemap.t

@@ -1,673 +1,673
 
   $ HGMERGE=true; export HGMERGE
   $ echo '[extensions]' >> $HGRCPATH
   $ echo 'convert =' >> $HGRCPATH
   $ glog()
   > {
   >     hg log -G --template '{rev} "{desc}" files: {files}\n' "$@"
   > }
   $ hg init source
   $ cd source
   $ echo foo > foo
   $ echo baz > baz
   $ mkdir -p dir/subdir
   $ echo dir/file >> dir/file
   $ echo dir/file2 >> dir/file2
   $ echo dir/file3 >> dir/file3 # to be corrupted in rev 0
   $ echo dir/subdir/file3 >> dir/subdir/file3
   $ echo dir/subdir/file4 >> dir/subdir/file4
   $ hg ci -d '0 0' -qAm '0: add foo baz dir/'
   $ echo bar > bar
   $ echo quux > quux
   $ echo dir/file4 >> dir/file4 # to be corrupted in rev 1
   $ hg copy foo copied
   $ hg ci -d '1 0' -qAm '1: add bar quux; copy foo to copied'
   $ echo >> foo
   $ hg ci -d '2 0' -m '2: change foo'
   $ hg up -qC 1
   $ echo >> bar
   $ echo >> quux
   $ hg ci -d '3 0' -m '3: change bar quux'
   created new head
   $ hg up -qC 2
   $ hg merge -qr 3
   $ echo >> bar
   $ echo >> baz
   $ hg ci -d '4 0' -m '4: first merge; change bar baz'
   $ echo >> bar
   $ echo 1 >> baz
   $ echo >> quux
   $ hg ci -d '5 0' -m '5: change bar baz quux'
   $ hg up -qC 4
   $ echo >> foo
   $ echo 2 >> baz
   $ hg ci -d '6 0' -m '6: change foo baz'
   created new head
   $ hg up -qC 5
   $ hg merge -qr 6
   $ echo >> bar
   $ hg ci -d '7 0' -m '7: second merge; change bar'
   $ echo >> foo
   $ hg ci -m '8: change foo'
   $ glog
   @  8 "8: change foo" files: foo
   |
   o    7 "7: second merge; change bar" files: bar baz
   |\
   | o  6 "6: change foo baz" files: baz foo
   | |
   o |  5 "5: change bar baz quux" files: bar baz quux
   |/
   o    4 "4: first merge; change bar baz" files: bar baz
   |\
   | o  3 "3: change bar quux" files: bar quux
   | |
   o |  2 "2: change foo" files: foo
   |/
   o  1 "1: add bar quux; copy foo to copied" files: bar copied dir/file4 quux
   |
   o  0 "0: add foo baz dir/" files: baz dir/file dir/file2 dir/file3 dir/subdir/file3 dir/subdir/file4 foo
   
 
 final file versions in this repo:
 
   $ hg manifest --debug
   9463f52fe115e377cf2878d4fc548117211063f2 644   bar
   94c1be4dfde2ee8d78db8bbfcf81210813307c3d 644   baz
   7711d36246cc83e61fb29cd6d4ef394c63f1ceaf 644   copied
   3e20847584beff41d7cd16136b7331ab3d754be0 644   dir/file
   75e6d3f8328f5f6ace6bf10b98df793416a09dca 644   dir/file2
   e96dce0bc6a217656a3a410e5e6bec2c4f42bf7c 644   dir/file3
   6edd55f559cdce67132b12ca09e09cee08b60442 644   dir/file4
   5fe139720576e18e34bcc9f79174db8897c8afe9 644   dir/subdir/file3
   57a1c1511590f3de52874adfa04effe8a77d64af 644   dir/subdir/file4
   9a7b52012991e4873687192c3e17e61ba3e837a3 644   foo
   bc3eca3f47023a3e70ca0d8cc95a22a6827db19d 644   quux
   $ hg debugrename copied
   copied renamed from foo:2ed2a3912a0b24502043eae84ee4b279c18b90dd
 
   $ cd ..
 
 
 Test interaction with startrev and verify that changing it is handled properly:
 
   $ > empty
   $ hg convert --filemap empty source movingstart --config convert.hg.startrev=3 -r4
   initializing destination movingstart repository
   scanning source...
   sorting...
   converting...
   1 3: change bar quux
   0 4: first merge; change bar baz
   $ hg convert --filemap empty source movingstart
   scanning source...
   sorting...
   converting...
   3 5: change bar baz quux
   2 6: change foo baz
   1 7: second merge; change bar
   warning: af455ce4166b3c9c88e6309c2b9332171dcea595 parent 61e22ca76c3b3e93df20338c4e02ce286898e825 is missing
   warning: cf908b3eeedc301c9272ebae931da966d5b326c7 parent 59e1ab45c888289513b7354484dac8a88217beab is missing
   0 8: change foo
 
 
 splitrepo tests
 
   $ splitrepo()
   > {
   >     msg="$1"
   >     files="$2"
   >     opts=$3
   >     echo "% $files: $msg"
   >     prefix=`echo "$files" | sed -e 's/ /-/g'`
   >     fmap="$prefix.fmap"
   >     repo="$prefix.repo"
   >     for i in $files; do
   >         echo "include $i" >> "$fmap"
   >     done
   >     hg -q convert $opts --filemap "$fmap" --datesort source "$repo"
   >     hg up -q -R "$repo"
   >     glog -R "$repo"
   >     hg -R "$repo" manifest --debug
   > }
   $ splitrepo 'skip unwanted merges; use 1st parent in 1st merge, 2nd in 2nd' foo
   % foo: skip unwanted merges; use 1st parent in 1st merge, 2nd in 2nd
   @  3 "8: change foo" files: foo
   |
   o  2 "6: change foo baz" files: foo
   |
   o  1 "2: change foo" files: foo
   |
   o  0 "0: add foo baz dir/" files: foo
   
   9a7b52012991e4873687192c3e17e61ba3e837a3 644   foo
   $ splitrepo 'merges are not merges anymore' bar
   % bar: merges are not merges anymore
   @  4 "7: second merge; change bar" files: bar
   |
   o  3 "5: change bar baz quux" files: bar
   |
   o  2 "4: first merge; change bar baz" files: bar
   |
   o  1 "3: change bar quux" files: bar
   |
   o  0 "1: add bar quux; copy foo to copied" files: bar
   
   9463f52fe115e377cf2878d4fc548117211063f2 644   bar
   $ splitrepo '1st merge is not a merge anymore; 2nd still is' baz
   % baz: 1st merge is not a merge anymore; 2nd still is
   @    4 "7: second merge; change bar" files: baz
   |\
   | o  3 "6: change foo baz" files: baz
   | |
   o |  2 "5: change bar baz quux" files: baz
   |/
   o  1 "4: first merge; change bar baz" files: baz
   |
   o  0 "0: add foo baz dir/" files: baz
   
   94c1be4dfde2ee8d78db8bbfcf81210813307c3d 644   baz
   $ splitrepo 'we add additional merges when they are interesting' 'foo quux'
   % foo quux: we add additional merges when they are interesting
   @  8 "8: change foo" files: foo
   |
   o    7 "7: second merge; change bar" files:
   |\
   | o  6 "6: change foo baz" files: foo
   | |
   o |  5 "5: change bar baz quux" files: quux
   |/
   o    4 "4: first merge; change bar baz" files:
   |\
   | o  3 "3: change bar quux" files: quux
   | |
   o |  2 "2: change foo" files: foo
   |/
   o  1 "1: add bar quux; copy foo to copied" files: quux
   |
   o  0 "0: add foo baz dir/" files: foo
   
   9a7b52012991e4873687192c3e17e61ba3e837a3 644   foo
   bc3eca3f47023a3e70ca0d8cc95a22a6827db19d 644   quux
   $ splitrepo 'partial conversion' 'bar quux' '-r 3'
   % bar quux: partial conversion
   @  1 "3: change bar quux" files: bar quux
   |
   o  0 "1: add bar quux; copy foo to copied" files: bar quux
   
   b79105bedc55102f394e90a789c9c380117c1b4a 644   bar
   db0421cc6b685a458c8d86c7d5c004f94429ea23 644   quux
   $ splitrepo 'complete the partial conversion' 'bar quux'
   % bar quux: complete the partial conversion
   @  4 "7: second merge; change bar" files: bar
   |
   o  3 "5: change bar baz quux" files: bar quux
   |
   o  2 "4: first merge; change bar baz" files: bar
   |
   o  1 "3: change bar quux" files: bar quux
   |
   o  0 "1: add bar quux; copy foo to copied" files: bar quux
   
   9463f52fe115e377cf2878d4fc548117211063f2 644   bar
   bc3eca3f47023a3e70ca0d8cc95a22a6827db19d 644   quux
   $ rm -r foo.repo
   $ splitrepo 'partial conversion' 'foo' '-r 3'
   % foo: partial conversion
   @  0 "0: add foo baz dir/" files: foo
   
   2ed2a3912a0b24502043eae84ee4b279c18b90dd 644   foo
   $ splitrepo 'complete the partial conversion' 'foo'
   % foo: complete the partial conversion
   @  3 "8: change foo" files: foo
   |
   o  2 "6: change foo baz" files: foo
   |
   o  1 "2: change foo" files: foo
   |
   o  0 "0: add foo baz dir/" files: foo
   
   9a7b52012991e4873687192c3e17e61ba3e837a3 644   foo
   $ splitrepo 'copied file; source not included in new repo' copied
   % copied: copied file; source not included in new repo
   @  0 "1: add bar quux; copy foo to copied" files: copied
   
   2ed2a3912a0b24502043eae84ee4b279c18b90dd 644   copied
   $ hg --cwd copied.repo debugrename copied
   copied not renamed
   $ splitrepo 'copied file; source included in new repo' 'foo copied'
   % foo copied: copied file; source included in new repo
   @  4 "8: change foo" files: foo
   |
   o  3 "6: change foo baz" files: foo
   |
   o  2 "2: change foo" files: foo
   |
   o  1 "1: add bar quux; copy foo to copied" files: copied
   |
   o  0 "0: add foo baz dir/" files: foo
   
   7711d36246cc83e61fb29cd6d4ef394c63f1ceaf 644   copied
   9a7b52012991e4873687192c3e17e61ba3e837a3 644   foo
   $ hg --cwd foo-copied.repo debugrename copied
   copied renamed from foo:2ed2a3912a0b24502043eae84ee4b279c18b90dd
 
 verify the top level 'include .' if there is no other includes:
 
   $ echo "exclude something" > default.fmap
   $ hg convert -q --filemap default.fmap -r1 source dummydest2
   $ hg -R dummydest2 log --template '{rev} {node|short} {desc|firstline}\n'
   1 61e22ca76c3b 1: add bar quux; copy foo to copied
   0 c085cf2ee7fe 0: add foo baz dir/
 
   $ echo "include somethingelse" >> default.fmap
   $ hg convert -q --filemap default.fmap -r1 source dummydest3
   $ hg -R dummydest3 log --template '{rev} {node|short} {desc|firstline}\n'
 
   $ echo "include ." >> default.fmap
   $ hg convert -q --filemap default.fmap -r1 source dummydest4
   $ hg -R dummydest4 log --template '{rev} {node|short} {desc|firstline}\n'
   1 61e22ca76c3b 1: add bar quux; copy foo to copied
   0 c085cf2ee7fe 0: add foo baz dir/
 
 ensure that the filemap contains duplicated slashes (issue3612)
 
   $ cat > renames.fmap <<EOF
   > include dir
   > exclude dir/file2
   > rename dir dir2//dir3
   > include foo
   > include copied
   > rename foo foo2/
   > rename copied ./copied2
   > exclude dir/subdir
   > include dir/subdir/file3
   > EOF
   $ rm source/.hg/store/data/dir/file3.i
   $ rm source/.hg/store/data/dir/file4.i
   $ hg -q convert --filemap renames.fmap --datesort source dummydest
   abort: data/dir/file3.i@e96dce0bc6a2: no match found!
   [255]
   $ hg -q convert --filemap renames.fmap --datesort --config convert.hg.ignoreerrors=1 source renames.repo
   ignoring: data/dir/file3.i@e96dce0bc6a2: no match found
   ignoring: data/dir/file4.i@6edd55f559cd: no match found
   $ hg up -q -R renames.repo
   $ glog -R renames.repo
   @  4 "8: change foo" files: foo2
   |
   o  3 "6: change foo baz" files: foo2
   |
   o  2 "2: change foo" files: foo2
   |
   o  1 "1: add bar quux; copy foo to copied" files: copied2
   |
   o  0 "0: add foo baz dir/" files: dir2/dir3/file dir2/dir3/subdir/file3 foo2
   
   $ hg -R renames.repo verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   4 files, 5 changesets, 7 total revisions
 
   $ hg -R renames.repo manifest --debug
   d43feacba7a4f1f2080dde4a4b985bd8a0236d46 644   copied2
   3e20847584beff41d7cd16136b7331ab3d754be0 644   dir2/dir3/file
   5fe139720576e18e34bcc9f79174db8897c8afe9 644   dir2/dir3/subdir/file3
   9a7b52012991e4873687192c3e17e61ba3e837a3 644   foo2
   $ hg --cwd renames.repo debugrename copied2
   copied2 renamed from foo2:2ed2a3912a0b24502043eae84ee4b279c18b90dd
 
 copied:
 
   $ hg --cwd source cat copied
   foo
 
 copied2:
 
   $ hg --cwd renames.repo cat copied2
   foo
 
 filemap errors
 
   $ cat > errors.fmap <<EOF
   > include dir/ # beware that comments changes error line numbers!
   > exclude /dir
   > rename dir//dir /dir//dir/ "out of sync"
   > include
   > EOF
   $ hg -q convert --filemap errors.fmap source errors.repo
   errors.fmap:3: superfluous / in include '/dir'
   errors.fmap:3: superfluous / in rename '/dir'
   errors.fmap:4: unknown directive 'out of sync'
   errors.fmap:5: path to exclude is missing
   abort: errors in filemap
   [255]
 
 test branch closing revision pruning if branch is pruned
 
   $ hg init branchpruning
   $ cd branchpruning
   $ hg branch foo
   marked working directory as branch foo
   (branches are permanent and global, did you want a bookmark?)
   $ echo a > a
   $ hg ci -Am adda
   adding a
   $ hg ci --close-branch -m closefoo
   $ hg up 0
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch empty
   marked working directory as branch empty
   (branches are permanent and global, did you want a bookmark?)
   $ hg ci -m emptybranch
   $ hg ci --close-branch -m closeempty
   $ hg up 0
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch default
   marked working directory as branch default
   (branches are permanent and global, did you want a bookmark?)
   $ echo b > b
   $ hg ci -Am addb
   adding b
   $ hg ci --close-branch -m closedefault
   $ cat > filemap <<EOF
   > include b
   > EOF
   $ cd ..
   $ hg convert branchpruning branchpruning-hg1
   initializing destination branchpruning-hg1 repository
   scanning source...
   sorting...
   converting...
   5 adda
   4 closefoo
   3 emptybranch
   2 closeempty
   1 addb
   0 closedefault
   $ glog -R branchpruning-hg1
   _  5 "closedefault" files:
   |
   o  4 "addb" files: b
   |
   | _  3 "closeempty" files:
   | |
   | o  2 "emptybranch" files:
   |/
   | _  1 "closefoo" files:
   |/
   o  0 "adda" files: a
   
 
 exercise incremental conversion at the same time
 
   $ hg convert -r0 --filemap branchpruning/filemap branchpruning branchpruning-hg2
   initializing destination branchpruning-hg2 repository
   scanning source...
   sorting...
   converting...
   0 adda
   $ hg convert -r4 --filemap branchpruning/filemap branchpruning branchpruning-hg2
   scanning source...
   sorting...
   converting...
   0 addb
   $ hg convert --filemap branchpruning/filemap branchpruning branchpruning-hg2
   scanning source...
   sorting...
   converting...
   3 closefoo
   2 emptybranch
   1 closeempty
   0 closedefault
   $ glog -R branchpruning-hg2
   _  1 "closedefault" files:
   |
   o  0 "addb" files: b
   
 
 Test rebuilding of map with unknown revisions in shamap - it used to crash
 
   $ cd branchpruning
   $ hg up -r 2
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m 'merging something'
   $ cd ..
   $ echo "53792d18237d2b64971fa571936869156655338d 6d955580116e82c4b029bd30f321323bae71a7f0" >> branchpruning-hg2/.hg/shamap
   $ hg convert --filemap branchpruning/filemap branchpruning branchpruning-hg2 --debug --config progress.debug=true
   run hg source pre-conversion action
   run hg sink pre-conversion action
   scanning source...
   scanning: 1 revisions
   sorting...
   converting...
   0 merging something
   source: 2503605b178fe50e8fbbb0e77b97939540aa8c87
   converting: 0/1 revisions (0.00%)
   unknown revmap source: 53792d18237d2b64971fa571936869156655338d
   run hg sink post-conversion action
   run hg source post-conversion action
 
 
 filemap rename undoing revision rename
 
   $ hg init renameundo
   $ cd renameundo
   $ echo 1 > a
   $ echo 1 > c
   $ hg ci -qAm add
   $ hg mv -q a b/a
   $ hg mv -q c b/c
   $ hg ci -qm rename
   $ echo 2 > b/a
   $ echo 2 > b/c
   $ hg ci -qm modify
   $ cd ..
 
   $ echo "rename b ." > renameundo.fmap
   $ hg convert --filemap renameundo.fmap renameundo renameundo2
   initializing destination renameundo2 repository
   scanning source...
   sorting...
   converting...
   2 add
   1 rename
   filtering out empty revision
-  repository tip rolled back to revision 0 (undo commit)
+  repository tip rolled back to revision 0 (undo convert)
   0 modify
   $ glog -R renameundo2
   o  1 "modify" files: a c
   |
   o  0 "add" files: a c
   
 
 
 test merge parents/empty merges pruning
 
   $ glog()
   > {
   >     hg log -G --template '{rev}:{node|short}@{branch} "{desc}" files: {files}\n' "$@"
   > }
 
 test anonymous branch pruning
 
   $ hg init anonymousbranch
   $ cd anonymousbranch
   $ echo a > a
   $ echo b > b
   $ hg ci -Am add
   adding a
   adding b
   $ echo a >> a
   $ hg ci -m changea
   $ hg up 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo b >> b
   $ hg ci -m changeb
   created new head
   $ hg up 1
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m merge
   $ cd ..
 
   $ cat > filemap <<EOF
   > include a
   > EOF
   $ hg convert --filemap filemap anonymousbranch anonymousbranch-hg
   initializing destination anonymousbranch-hg repository
   scanning source...
   sorting...
   converting...
   3 add
   2 changea
   1 changeb
   0 merge
   $ glog -R anonymousbranch
   @    3:c71d5201a498@default "merge" files:
   |\
   | o  2:607eb44b17f9@default "changeb" files: b
   | |
   o |  1:1f60ea617824@default "changea" files: a
   |/
   o  0:0146e6129113@default "add" files: a b
   
   $ glog -R anonymousbranch-hg
   o  1:cda818e7219b@default "changea" files: a
   |
   o  0:c334dc3be0da@default "add" files: a
   
   $ cat anonymousbranch-hg/.hg/shamap
   0146e6129113dba9ac90207cfdf2d7ed35257ae5 c334dc3be0daa2a4e9ce4d2e2bdcba40c09d4916
   1f60ea61782421edf8d051ff4fcb61b330f26a4a cda818e7219b5f7f3fb9f49780054ed6a1905ec3
   607eb44b17f9348cd5cbd26e16af87ba77b0b037 c334dc3be0daa2a4e9ce4d2e2bdcba40c09d4916
   c71d5201a498b2658d105a6bf69d7a0df2649aea cda818e7219b5f7f3fb9f49780054ed6a1905ec3
 
   $ cat > filemap <<EOF
   > include b
   > EOF
   $ hg convert --filemap filemap anonymousbranch anonymousbranch-hg2
   initializing destination anonymousbranch-hg2 repository
   scanning source...
   sorting...
   converting...
   3 add
   2 changea
   1 changeb
   0 merge
   $ glog -R anonymousbranch
   @    3:c71d5201a498@default "merge" files:
   |\
   | o  2:607eb44b17f9@default "changeb" files: b
   | |
   o |  1:1f60ea617824@default "changea" files: a
   |/
   o  0:0146e6129113@default "add" files: a b
   
   $ glog -R anonymousbranch-hg2
   o  1:62dd350b0df6@default "changeb" files: b
   |
   o  0:4b9ced861657@default "add" files: b
   
   $ cat anonymousbranch-hg2/.hg/shamap
   0146e6129113dba9ac90207cfdf2d7ed35257ae5 4b9ced86165703791653059a1db6ed864630a523
   1f60ea61782421edf8d051ff4fcb61b330f26a4a 4b9ced86165703791653059a1db6ed864630a523
   607eb44b17f9348cd5cbd26e16af87ba77b0b037 62dd350b0df695f7d2c82a02e0499b16fd790f22
   c71d5201a498b2658d105a6bf69d7a0df2649aea 62dd350b0df695f7d2c82a02e0499b16fd790f22
 
 test named branch pruning
 
   $ hg init namedbranch
   $ cd namedbranch
   $ echo a > a
   $ echo b > b
   $ hg ci -Am add
   adding a
   adding b
   $ echo a >> a
   $ hg ci -m changea
   $ hg up 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch foo
   marked working directory as branch foo
   (branches are permanent and global, did you want a bookmark?)
   $ echo b >> b
   $ hg ci -m changeb
   $ hg up default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge foo
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m merge
   $ cd ..
 
   $ cat > filemap <<EOF
   > include a
   > EOF
   $ hg convert --filemap filemap namedbranch namedbranch-hg
   initializing destination namedbranch-hg repository
   scanning source...
   sorting...
   converting...
   3 add
   2 changea
   1 changeb
   0 merge
   $ glog -R namedbranch
   @    3:73899bcbe45c@default "merge" files:
   |\
   | o  2:8097982d19fc@foo "changeb" files: b
   | |
   o |  1:1f60ea617824@default "changea" files: a
   |/
   o  0:0146e6129113@default "add" files: a b
   
   $ glog -R namedbranch-hg
   o  1:cda818e7219b@default "changea" files: a
   |
   o  0:c334dc3be0da@default "add" files: a
   
 
   $ cd namedbranch
   $ hg --config extensions.mq= strip tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/namedbranch/.hg/strip-backup/73899bcbe45c-92adf160-backup.hg (glob)
   $ hg up foo
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m merge
   $ cd ..
 
   $ hg convert --filemap filemap namedbranch namedbranch-hg2
   initializing destination namedbranch-hg2 repository
   scanning source...
   sorting...
   converting...
   3 add
   2 changea
   1 changeb
   0 merge
   $ glog -R namedbranch
   @    3:e1959de76e1b@foo "merge" files:
   |\
   | o  2:8097982d19fc@foo "changeb" files: b
   | |
   o |  1:1f60ea617824@default "changea" files: a
   |/
   o  0:0146e6129113@default "add" files: a b
   
   $ glog -R namedbranch-hg2
   o    2:dcf314454667@foo "merge" files:
   |\
   | o  1:cda818e7219b@default "changea" files: a
   |/
   o  0:c334dc3be0da@default "add" files: a
   

tests/test-convert-hg-sink.t

@@ -1,552 +1,564
 
   $ 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
   
+  $ hg phase --public -r tip
   $ 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 log -G --template '{rev} {node|short} ({phase}) "{desc}"\n'
+  o  3 593cbf6fb2b4 (public) "Added tag some-tag for changeset ad681a868e44"
+  |
+  o  2 ad681a868e44 (public) "add foo/file"
+  |
+  o  1 cbba8ecc03b7 (public) "remove foo"
+  |
+  o  0 327daa9251fa (public) "add foo and bar"
+  
+
   $ 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' $*
+  >     hg log -G --template '{rev} {node|short} ({phase}) "{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
+  $ hg phase --public -r tip
   $ glog
-  @  6 0613c8e59a3d "6: change a" files: a
+  @  6 0613c8e59a3d (public) "6: change a" files: a
   |
-  o    5 717e9b37cdb7 "5: merge 2 and 3, copy b to dir/d" files: dir/d e
+  o    5 717e9b37cdb7 (public) "5: merge 2 and 3, copy b to dir/d" files: dir/d e
   |\
-  | o  4 86a55cb968d5 "4: change a" files: a
+  | o  4 86a55cb968d5 (public) "4: change a" files: a
   | |
-  o |  3 0e6e235919dd "3: copy a to e, change b" files: b e
+  o |  3 0e6e235919dd (public) "3: copy a to e, change b" files: b e
   | |
-  o |  2 0394b0d5e4f7 "2: add dir/c" files: dir/c
+  o |  2 0394b0d5e4f7 (public) "2: add dir/c" files: dir/c
   |/
-  o  1 333546584845 "1: add a and dir/b" files: a dir/b
+  o  1 333546584845 (public) "1: add a and dir/b" files: a dir/b
   |
-  o  0 d1a24e2ebd23 "0: add 0" files: 0
+  o  0 d1a24e2ebd23 (public) "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  4 78814e84a217 (draft) "6: change a" files: a
   |
-  o    3 f7cff662c5e5 "5: merge 2 and 3, copy b to dir/d" files: e
+  o    3 f7cff662c5e5 (draft) "5: merge 2 and 3, copy b to dir/d" files: e
   |\
-  | o  2 ab40a95b0072 "4: change a" files: a
+  | o  2 ab40a95b0072 (draft) "4: change a" files: a
   | |
-  o |  1 bd51f17597bf "3: copy a to e, change b" files: b e
+  o |  1 bd51f17597bf (draft) "3: copy a to e, change b" files: b e
   |/
-  o  0 a4a1dae0fe35 "1: add a and dir/b" files: 0 a
+  o  0 a4a1dae0fe35 (draft) "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
+  @  11 0c8927d1f7f4 (draft) "11: source change" files: a
   |
-  o    10 9ccb7ee8d261 "10: source merge" files: a
+  o    10 9ccb7ee8d261 (draft) "10: source merge" files: a
   |\
-  | o  9 f131b1518dba "9: source second branch" files: a
+  | o  9 f131b1518dba (draft) "9: source second branch" files: a
   | |
-  o |  8 669cf0e74b50 "8: source first branch" files: a
+  o |  8 669cf0e74b50 (draft) "8: source first branch" files: a
   | |
-  | o  7 e6d364a69ff1 "change in dest" files: dest
+  | o  7 e6d364a69ff1 (draft) "change in dest" files: dest
   |/
-  o  6 0613c8e59a3d "6: change a" files: a
+  o  6 0613c8e59a3d (public) "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  9 8432d597b263 (draft) "11: source change" files: a
   |
-  o    8 632ffacdcd6f "10: source merge" files: a
+  o    8 632ffacdcd6f (draft) "10: source merge" files: a
   |\
-  | o  7 049cfee90ee6 "9: source second branch" files: a
+  | o  7 049cfee90ee6 (draft) "9: source second branch" files: a
   | |
-  o |  6 9b6845e036e5 "8: source first branch" files: a
+  o |  6 9b6845e036e5 (draft) "8: source first branch" files: a
   | |
-  | @  5 a2e0e3cc6d1d "change in dest" files: dest
+  | @  5 a2e0e3cc6d1d (draft) "change in dest" files: dest
   |/
-  o  4 78814e84a217 "6: change a" files: a
+  o  4 78814e84a217 (draft) "6: change a" files: a
   |
-  o    3 f7cff662c5e5 "5: merge 2 and 3, copy b to dir/d" files: e
+  o    3 f7cff662c5e5 (draft) "5: merge 2 and 3, copy b to dir/d" files: e
   |\
-  | o  2 ab40a95b0072 "4: change a" files: a
+  | o  2 ab40a95b0072 (draft) "4: change a" files: a
   | |
-  o |  1 bd51f17597bf "3: copy a to e, change b" files: b e
+  o |  1 bd51f17597bf (draft) "3: copy a to e, change b" files: b e
   |/
-  o  0 a4a1dae0fe35 "1: add a and dir/b" files: 0 a
+  o  0 a4a1dae0fe35 (draft) "1: add a and dir/b" files: 0 a
   
   $ cd ..
 
 Two way tests
 
   $ hg init 0
   $ echo f > 0/f
   $ echo a > 0/a-only
   $ echo b > 0/b-only
   $ hg -R 0 ci -Aqm0
 
   $ cat << EOF > filemap-a
   > exclude b-only
   > EOF
   $ cat << EOF > filemap-b
   > exclude a-only
   > EOF
   $ hg convert --filemap filemap-a 0 a
   initializing destination a repository
   scanning source...
   sorting...
   converting...
   0 0
   $ hg -R a up -q
   $ echo a > a/f
   $ hg -R a ci -ma
 
   $ hg convert --filemap filemap-b 0 b
   initializing destination b repository
   scanning source...
   sorting...
   converting...
   0 0
   $ hg -R b up -q
   $ echo b > b/f
   $ hg -R b ci -mb
 
   $ tail */.hg/shamap
   ==> 0/.hg/shamap <==
   86f3f774ffb682bffb5dc3c1d3b3da637cb9a0d6 8a028c7c77f6c7bd6d63bc3f02ca9f779eabf16a
   dd9f218eb91fb857f2a62fe023e1d64a4e7812fe 8a028c7c77f6c7bd6d63bc3f02ca9f779eabf16a
   
   ==> a/.hg/shamap <==
   8a028c7c77f6c7bd6d63bc3f02ca9f779eabf16a 86f3f774ffb682bffb5dc3c1d3b3da637cb9a0d6
   
   ==> b/.hg/shamap <==
   8a028c7c77f6c7bd6d63bc3f02ca9f779eabf16a dd9f218eb91fb857f2a62fe023e1d64a4e7812fe
 
   $ hg convert a 0
   scanning source...
   sorting...
   converting...
   0 a
 
   $ hg convert b 0
   scanning source...
   sorting...
   converting...
   0 b
 
   $ hg -R 0 log -G
   o  changeset:   2:637fbbbe96b6
   |  tag:         tip
   |  parent:      0:8a028c7c77f6
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   | o  changeset:   1:ec7b9c96e692
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     a
   |
   @  changeset:   0:8a028c7c77f6
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     0
   
   $ hg convert --filemap filemap-b 0 a --config convert.hg.revs=1::
   scanning source...
   sorting...
   converting...
 
   $ hg -R 0 up -r1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo f >> 0/f
   $ hg -R 0 ci -mx
 
   $ hg convert --filemap filemap-b 0 a --config convert.hg.revs=1::
   scanning source...
   sorting...
   converting...
   0 x
 
   $ hg -R a log -G -T '{rev} {desc|firstline} ({files})\n'
   o  2 x (f)
   |
   @  1 a (f)
   |
   o  0 0 (a-only f)
   
   $ hg -R a mani -r tip
   a-only
   f
 
 An additional round, demonstrating that unchanged files don't get converted
 
   $ echo f >> 0/f
   $ echo f >> 0/a-only
   $ hg -R 0 ci -m "extra f+a-only change"
 
   $ hg convert --filemap filemap-b 0 a --config convert.hg.revs=1::
   scanning source...
   sorting...
   converting...
   0 extra f+a-only change
 
   $ hg -R a log -G -T '{rev} {desc|firstline} ({files})\n'
   o  3 extra f+a-only change (f)
   |
   o  2 x (f)
   |
   @  1 a (f)
   |
   o  0 0 (a-only f)
   
 
 Conversion after rollback
 
   $ hg -R a rollback -f
-  repository tip rolled back to revision 2 (undo commit)
+  repository tip rolled back to revision 2 (undo convert)
 
   $ hg convert --filemap filemap-b 0 a --config convert.hg.revs=1::
   scanning source...
   sorting...
   converting...
   0 extra f+a-only change
 
   $ hg -R a log -G -T '{rev} {desc|firstline} ({files})\n'
   o  3 extra f+a-only change (f)
   |
   o  2 x (f)
   |
   @  1 a (f)
   |
   o  0 0 (a-only f)
   
 Convert with --full adds and removes files that didn't change
 
   $ echo f >> 0/f
   $ hg -R 0 ci -m "f"
   $ hg convert --filemap filemap-b --full 0 a --config convert.hg.revs=1::
   scanning source...
   sorting...
   converting...
   0 f
   $ hg -R a status --change tip
   M f
   A b-only
   R a-only