fileset: restrict getfileset() to not return a computed set (API)

And rename the functions accordingly. fileset.match() will be changed to
not compute the initial subset.

test-glog*.t get back to the state before 9f9ffe5f687c "match: compose
'set:' pattern as matcher."

mercurial/context.py

@@ -1,2545 +1,2545 b''
 # context.py - changeset and file context objects for mercurial
 #
 # Copyright 2006, 2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import errno
 import filecmp
 import os
 import stat
 
 from .i18n import _
 from .node import (
     addednodeid,
     bin,
     hex,
     modifiednodeid,
     nullid,
     nullrev,
     short,
     wdirfilenodeids,
     wdirid,
 )
 from . import (
     dagop,
     encoding,
     error,
     fileset,
     match as matchmod,
     obsolete as obsmod,
     patch,
     pathutil,
     phases,
     pycompat,
     repoview,
     revlog,
     scmutil,
     sparse,
     subrepo,
     subrepoutil,
     util,
 )
 from .utils import (
     dateutil,
     stringutil,
 )
 
 propertycache = util.propertycache
 
 class basectx(object):
     """A basectx object represents the common logic for its children:
     changectx: read-only context that is already present in the repo,
     workingctx: a context that represents the working directory and can
                 be committed,
     memctx: a context that represents changes in-memory and can also
             be committed."""
 
     def __init__(self, repo):
         self._repo = repo
 
     def __bytes__(self):
         return short(self.node())
 
     __str__ = encoding.strmethod(__bytes__)
 
     def __repr__(self):
         return r"<%s %s>" % (type(self).__name__, str(self))
 
     def __eq__(self, other):
         try:
             return type(self) == type(other) and self._rev == other._rev
         except AttributeError:
             return False
 
     def __ne__(self, other):
         return not (self == other)
 
     def __contains__(self, key):
         return key in self._manifest
 
     def __getitem__(self, key):
         return self.filectx(key)
 
     def __iter__(self):
         return iter(self._manifest)
 
     def _buildstatusmanifest(self, status):
         """Builds a manifest that includes the given status results, if this is
         a working copy context. For non-working copy contexts, it just returns
         the normal manifest."""
         return self.manifest()
 
     def _matchstatus(self, other, match):
         """This internal method provides a way for child objects to override the
         match operator.
         """
         return match
 
     def _buildstatus(self, other, s, match, listignored, listclean,
                      listunknown):
         """build a status with respect to another context"""
         # Load earliest manifest first for caching reasons. More specifically,
         # if you have revisions 1000 and 1001, 1001 is probably stored as a
         # delta against 1000. Thus, if you read 1000 first, we'll reconstruct
         # 1000 and cache it so that when you read 1001, we just need to apply a
         # delta to what's in the cache. So that's one full reconstruction + one
         # delta application.
         mf2 = None
         if self.rev() is not None and self.rev() < other.rev():
             mf2 = self._buildstatusmanifest(s)
         mf1 = other._buildstatusmanifest(s)
         if mf2 is None:
             mf2 = self._buildstatusmanifest(s)
 
         modified, added = [], []
         removed = []
         clean = []
         deleted, unknown, ignored = s.deleted, s.unknown, s.ignored
         deletedset = set(deleted)
         d = mf1.diff(mf2, match=match, clean=listclean)
         for fn, value in d.iteritems():
             if fn in deletedset:
                 continue
             if value is None:
                 clean.append(fn)
                 continue
             (node1, flag1), (node2, flag2) = value
             if node1 is None:
                 added.append(fn)
             elif node2 is None:
                 removed.append(fn)
             elif flag1 != flag2:
                 modified.append(fn)
             elif node2 not in wdirfilenodeids:
                 # When comparing files between two commits, we save time by
                 # not comparing the file contents when the nodeids differ.
                 # Note that this means we incorrectly report a reverted change
                 # to a file as a modification.
                 modified.append(fn)
             elif self[fn].cmp(other[fn]):
                 modified.append(fn)
             else:
                 clean.append(fn)
 
         if removed:
             # need to filter files if they are already reported as removed
             unknown = [fn for fn in unknown if fn not in mf1 and
                                                (not match or match(fn))]
             ignored = [fn for fn in ignored if fn not in mf1 and
                                                (not match or match(fn))]
             # if they're deleted, don't report them as removed
             removed = [fn for fn in removed if fn not in deletedset]
 
         return scmutil.status(modified, added, removed, deleted, unknown,
                               ignored, clean)
 
     @propertycache
     def substate(self):
         return subrepoutil.state(self, self._repo.ui)
 
     def subrev(self, subpath):
         return self.substate[subpath][1]
 
     def rev(self):
         return self._rev
     def node(self):
         return self._node
     def hex(self):
         return hex(self.node())
     def manifest(self):
         return self._manifest
     def manifestctx(self):
         return self._manifestctx
     def repo(self):
         return self._repo
     def phasestr(self):
         return phases.phasenames[self.phase()]
     def mutable(self):
         return self.phase() > phases.public
 
-    def getfileset(self, expr):
-        return fileset.getfileset(self, expr)
+    def matchfileset(self, expr, badfn=None):
+        return fileset.match(self, expr, badfn=badfn)
 
     def obsolete(self):
         """True if the changeset is obsolete"""
         return self.rev() in obsmod.getrevs(self._repo, 'obsolete')
 
     def extinct(self):
         """True if the changeset is extinct"""
         return self.rev() in obsmod.getrevs(self._repo, 'extinct')
 
     def orphan(self):
         """True if the changeset is not obsolete but it's ancestor are"""
         return self.rev() in obsmod.getrevs(self._repo, 'orphan')
 
     def phasedivergent(self):
         """True if the changeset try to be a successor of a public changeset
 
         Only non-public and non-obsolete changesets may be bumped.
         """
         return self.rev() in obsmod.getrevs(self._repo, 'phasedivergent')
 
     def contentdivergent(self):
         """Is a successors of a changeset with multiple possible successors set
 
         Only non-public and non-obsolete changesets may be divergent.
         """
         return self.rev() in obsmod.getrevs(self._repo, 'contentdivergent')
 
     def isunstable(self):
         """True if the changeset is either unstable, bumped or divergent"""
         return self.orphan() or self.phasedivergent() or self.contentdivergent()
 
     def instabilities(self):
         """return the list of instabilities affecting this changeset.
 
         Instabilities are returned as strings. possible values are:
         - orphan,
         - phase-divergent,
         - content-divergent.
         """
         instabilities = []
         if self.orphan():
             instabilities.append('orphan')
         if self.phasedivergent():
             instabilities.append('phase-divergent')
         if self.contentdivergent():
             instabilities.append('content-divergent')
         return instabilities
 
     def parents(self):
         """return contexts for each parent changeset"""
         return self._parents
 
     def p1(self):
         return self._parents[0]
 
     def p2(self):
         parents = self._parents
         if len(parents) == 2:
             return parents[1]
         return changectx(self._repo, nullrev)
 
     def _fileinfo(self, path):
         if r'_manifest' in self.__dict__:
             try:
                 return self._manifest[path], self._manifest.flags(path)
             except KeyError:
                 raise error.ManifestLookupError(self._node, path,
                                                 _('not found in manifest'))
         if r'_manifestdelta' in self.__dict__ or path in self.files():
             if path in self._manifestdelta:
                 return (self._manifestdelta[path],
                         self._manifestdelta.flags(path))
         mfl = self._repo.manifestlog
         try:
             node, flag = mfl[self._changeset.manifest].find(path)
         except KeyError:
             raise error.ManifestLookupError(self._node, path,
                                             _('not found in manifest'))
 
         return node, flag
 
     def filenode(self, path):
         return self._fileinfo(path)[0]
 
     def flags(self, path):
         try:
             return self._fileinfo(path)[1]
         except error.LookupError:
             return ''
 
     def sub(self, path, allowcreate=True):
         '''return a subrepo for the stored revision of path, never wdir()'''
         return subrepo.subrepo(self, path, allowcreate=allowcreate)
 
     def nullsub(self, path, pctx):
         return subrepo.nullsubrepo(self, path, pctx)
 
     def workingsub(self, path):
         '''return a subrepo for the stored revision, or wdir if this is a wdir
         context.
         '''
         return subrepo.subrepo(self, path, allowwdir=True)
 
     def match(self, pats=None, include=None, exclude=None, default='glob',
               listsubrepos=False, badfn=None):
         r = self._repo
         return matchmod.match(r.root, r.getcwd(), pats,
                               include, exclude, default,
                               auditor=r.nofsauditor, ctx=self,
                               listsubrepos=listsubrepos, badfn=badfn)
 
     def diff(self, ctx2=None, match=None, changes=None, opts=None,
              losedatafn=None, prefix='', relroot='', copy=None,
              hunksfilterfn=None):
         """Returns a diff generator for the given contexts and matcher"""
         if ctx2 is None:
             ctx2 = self.p1()
         if ctx2 is not None:
             ctx2 = self._repo[ctx2]
         return patch.diff(self._repo, ctx2, self, match=match, changes=changes,
                           opts=opts, losedatafn=losedatafn, prefix=prefix,
                           relroot=relroot, copy=copy,
                           hunksfilterfn=hunksfilterfn)
 
     def dirs(self):
         return self._manifest.dirs()
 
     def hasdir(self, dir):
         return self._manifest.hasdir(dir)
 
     def status(self, other=None, match=None, listignored=False,
                listclean=False, listunknown=False, listsubrepos=False):
         """return status of files between two nodes or node and working
         directory.
 
         If other is None, compare this node with working directory.
 
         returns (modified, added, removed, deleted, unknown, ignored, clean)
         """
 
         ctx1 = self
         ctx2 = self._repo[other]
 
         # This next code block is, admittedly, fragile logic that tests for
         # reversing the contexts and wouldn't need to exist if it weren't for
         # the fast (and common) code path of comparing the working directory
         # with its first parent.
         #
         # What we're aiming for here is the ability to call:
         #
         # workingctx.status(parentctx)
         #
         # If we always built the manifest for each context and compared those,
         # then we'd be done. But the special case of the above call means we
         # just copy the manifest of the parent.
         reversed = False
         if (not isinstance(ctx1, changectx)
             and isinstance(ctx2, changectx)):
             reversed = True
             ctx1, ctx2 = ctx2, ctx1
 
         match = match or matchmod.always(self._repo.root, self._repo.getcwd())
         match = ctx2._matchstatus(ctx1, match)
         r = scmutil.status([], [], [], [], [], [], [])
         r = ctx2._buildstatus(ctx1, r, match, listignored, listclean,
                               listunknown)
 
         if reversed:
             # Reverse added and removed. Clear deleted, unknown and ignored as
             # these make no sense to reverse.
             r = scmutil.status(r.modified, r.removed, r.added, [], [], [],
                                r.clean)
 
         if listsubrepos:
             for subpath, sub in scmutil.itersubrepos(ctx1, ctx2):
                 try:
                     rev2 = ctx2.subrev(subpath)
                 except KeyError:
                     # A subrepo that existed in node1 was deleted between
                     # node1 and node2 (inclusive). Thus, ctx2's substate
                     # won't contain that subpath. The best we can do ignore it.
                     rev2 = None
                 submatch = matchmod.subdirmatcher(subpath, match)
                 s = sub.status(rev2, match=submatch, ignored=listignored,
                                clean=listclean, unknown=listunknown,
                                listsubrepos=True)
                 for rfiles, sfiles in zip(r, s):
                     rfiles.extend("%s/%s" % (subpath, f) for f in sfiles)
 
         for l in r:
             l.sort()
 
         return r
 
 class changectx(basectx):
     """A changecontext object makes access to data related to a particular
     changeset convenient. It represents a read-only context already present in
     the repo."""
     def __init__(self, repo, changeid='.'):
         """changeid is a revision number, node, or tag"""
         super(changectx, self).__init__(repo)
 
         try:
             if isinstance(changeid, int):
                 self._node = repo.changelog.node(changeid)
                 self._rev = changeid
                 return
             elif changeid == 'null':
                 self._node = nullid
                 self._rev = nullrev
                 return
             elif changeid == 'tip':
                 self._node = repo.changelog.tip()
                 self._rev = repo.changelog.rev(self._node)
                 return
             elif (changeid == '.'
                   or repo.local() and changeid == repo.dirstate.p1()):
                 # this is a hack to delay/avoid loading obsmarkers
                 # when we know that '.' won't be hidden
                 self._node = repo.dirstate.p1()
                 self._rev = repo.unfiltered().changelog.rev(self._node)
                 return
             elif len(changeid) == 20:
                 try:
                     self._node = changeid
                     self._rev = repo.changelog.rev(changeid)
                     return
                 except error.FilteredLookupError:
                     raise
                 except LookupError:
                     # check if it might have come from damaged dirstate
                     #
                     # XXX we could avoid the unfiltered if we had a recognizable
                     # exception for filtered changeset access
                     if (repo.local()
                         and changeid in repo.unfiltered().dirstate.parents()):
                         msg = _("working directory has unknown parent '%s'!")
                         raise error.Abort(msg % short(changeid))
                     changeid = hex(changeid) # for the error message
 
             elif len(changeid) == 40:
                 try:
                     self._node = bin(changeid)
                     self._rev = repo.changelog.rev(self._node)
                     return
                 except error.FilteredLookupError:
                     raise
                 except (TypeError, LookupError):
                     pass
             else:
                 raise error.ProgrammingError(
                         "unsupported changeid '%s' of type %s" %
                         (changeid, type(changeid)))
 
             # lookup failed
         except (error.FilteredIndexError, error.FilteredLookupError):
             raise error.FilteredRepoLookupError(_("filtered revision '%s'")
                                                 % pycompat.bytestr(changeid))
         except error.FilteredRepoLookupError:
             raise
         except IndexError:
             pass
         raise error.RepoLookupError(
             _("unknown revision '%s'") % changeid)
 
     def __hash__(self):
         try:
             return hash(self._rev)
         except AttributeError:
             return id(self)
 
     def __nonzero__(self):
         return self._rev != nullrev
 
     __bool__ = __nonzero__
 
     @propertycache
     def _changeset(self):
         return self._repo.changelog.changelogrevision(self.rev())
 
     @propertycache
     def _manifest(self):
         return self._manifestctx.read()
 
     @property
     def _manifestctx(self):
         return self._repo.manifestlog[self._changeset.manifest]
 
     @propertycache
     def _manifestdelta(self):
         return self._manifestctx.readdelta()
 
     @propertycache
     def _parents(self):
         repo = self._repo
         p1, p2 = repo.changelog.parentrevs(self._rev)
         if p2 == nullrev:
             return [changectx(repo, p1)]
         return [changectx(repo, p1), changectx(repo, p2)]
 
     def changeset(self):
         c = self._changeset
         return (
             c.manifest,
             c.user,
             c.date,
             c.files,
             c.description,
             c.extra,
         )
     def manifestnode(self):
         return self._changeset.manifest
 
     def user(self):
         return self._changeset.user
     def date(self):
         return self._changeset.date
     def files(self):
         return self._changeset.files
     def description(self):
         return self._changeset.description
     def branch(self):
         return encoding.tolocal(self._changeset.extra.get("branch"))
     def closesbranch(self):
         return 'close' in self._changeset.extra
     def extra(self):
         """Return a dict of extra information."""
         return self._changeset.extra
     def tags(self):
         """Return a list of byte tag names"""
         return self._repo.nodetags(self._node)
     def bookmarks(self):
         """Return a list of byte bookmark names."""
         return self._repo.nodebookmarks(self._node)
     def phase(self):
         return self._repo._phasecache.phase(self._repo, self._rev)
     def hidden(self):
         return self._rev in repoview.filterrevs(self._repo, 'visible')
 
     def isinmemory(self):
         return False
 
     def children(self):
         """return list of changectx contexts for each child changeset.
 
         This returns only the immediate child changesets. Use descendants() to
         recursively walk children.
         """
         c = self._repo.changelog.children(self._node)
         return [changectx(self._repo, x) for x in c]
 
     def ancestors(self):
         for a in self._repo.changelog.ancestors([self._rev]):
             yield changectx(self._repo, a)
 
     def descendants(self):
         """Recursively yield all children of the changeset.
 
         For just the immediate children, use children()
         """
         for d in self._repo.changelog.descendants([self._rev]):
             yield changectx(self._repo, d)
 
     def filectx(self, path, fileid=None, filelog=None):
         """get a file context from this changeset"""
         if fileid is None:
             fileid = self.filenode(path)
         return filectx(self._repo, path, fileid=fileid,
                        changectx=self, filelog=filelog)
 
     def ancestor(self, c2, warn=False):
         """return the "best" ancestor context of self and c2
 
         If there are multiple candidates, it will show a message and check
         merge.preferancestor configuration before falling back to the
         revlog ancestor."""
         # deal with workingctxs
         n2 = c2._node
         if n2 is None:
             n2 = c2._parents[0]._node
         cahs = self._repo.changelog.commonancestorsheads(self._node, n2)
         if not cahs:
             anc = nullid
         elif len(cahs) == 1:
             anc = cahs[0]
         else:
             # experimental config: merge.preferancestor
             for r in self._repo.ui.configlist('merge', 'preferancestor'):
                 try:
                     ctx = scmutil.revsymbol(self._repo, r)
                 except error.RepoLookupError:
                     continue
                 anc = ctx.node()
                 if anc in cahs:
                     break
             else:
                 anc = self._repo.changelog.ancestor(self._node, n2)
             if warn:
                 self._repo.ui.status(
                     (_("note: using %s as ancestor of %s and %s\n") %
                      (short(anc), short(self._node), short(n2))) +
                     ''.join(_("      alternatively, use --config "
                               "merge.preferancestor=%s\n") %
                             short(n) for n in sorted(cahs) if n != anc))
         return changectx(self._repo, anc)
 
     def descendant(self, other):
         """True if other is descendant of this changeset"""
         return self._repo.changelog.descendant(self._rev, other._rev)
 
     def walk(self, match):
         '''Generates matching file names.'''
 
         # Wrap match.bad method to have message with nodeid
         def bad(fn, msg):
             # The manifest doesn't know about subrepos, so don't complain about
             # paths into valid subrepos.
             if any(fn == s or fn.startswith(s + '/')
                    for s in self.substate):
                 return
             match.bad(fn, _('no such file in rev %s') % self)
 
         m = matchmod.badmatch(match, bad)
         return self._manifest.walk(m)
 
     def matches(self, match):
         return self.walk(match)
 
 class basefilectx(object):
     """A filecontext object represents the common logic for its children:
     filectx: read-only access to a filerevision that is already present
              in the repo,
     workingfilectx: a filecontext that represents files from the working
                     directory,
     memfilectx: a filecontext that represents files in-memory,
     overlayfilectx: duplicate another filecontext with some fields overridden.
     """
     @propertycache
     def _filelog(self):
         return self._repo.file(self._path)
 
     @propertycache
     def _changeid(self):
         if r'_changeid' in self.__dict__:
             return self._changeid
         elif r'_changectx' in self.__dict__:
             return self._changectx.rev()
         elif r'_descendantrev' in self.__dict__:
             # this file context was created from a revision with a known
             # descendant, we can (lazily) correct for linkrev aliases
             return self._adjustlinkrev(self._descendantrev)
         else:
             return self._filelog.linkrev(self._filerev)
 
     @propertycache
     def _filenode(self):
         if r'_fileid' in self.__dict__:
             return self._filelog.lookup(self._fileid)
         else:
             return self._changectx.filenode(self._path)
 
     @propertycache
     def _filerev(self):
         return self._filelog.rev(self._filenode)
 
     @propertycache
     def _repopath(self):
         return self._path
 
     def __nonzero__(self):
         try:
             self._filenode
             return True
         except error.LookupError:
             # file is missing
             return False
 
     __bool__ = __nonzero__
 
     def __bytes__(self):
         try:
             return "%s@%s" % (self.path(), self._changectx)
         except error.LookupError:
             return "%s@???" % self.path()
 
     __str__ = encoding.strmethod(__bytes__)
 
     def __repr__(self):
         return r"<%s %s>" % (type(self).__name__, str(self))
 
     def __hash__(self):
         try:
             return hash((self._path, self._filenode))
         except AttributeError:
             return id(self)
 
     def __eq__(self, other):
         try:
             return (type(self) == type(other) and self._path == other._path
                     and self._filenode == other._filenode)
         except AttributeError:
             return False
 
     def __ne__(self, other):
         return not (self == other)
 
     def filerev(self):
         return self._filerev
     def filenode(self):
         return self._filenode
     @propertycache
     def _flags(self):
         return self._changectx.flags(self._path)
     def flags(self):
         return self._flags
     def filelog(self):
         return self._filelog
     def rev(self):
         return self._changeid
     def linkrev(self):
         return self._filelog.linkrev(self._filerev)
     def node(self):
         return self._changectx.node()
     def hex(self):
         return self._changectx.hex()
     def user(self):
         return self._changectx.user()
     def date(self):
         return self._changectx.date()
     def files(self):
         return self._changectx.files()
     def description(self):
         return self._changectx.description()
     def branch(self):
         return self._changectx.branch()
     def extra(self):
         return self._changectx.extra()
     def phase(self):
         return self._changectx.phase()
     def phasestr(self):
         return self._changectx.phasestr()
     def obsolete(self):
         return self._changectx.obsolete()
     def instabilities(self):
         return self._changectx.instabilities()
     def manifest(self):
         return self._changectx.manifest()
     def changectx(self):
         return self._changectx
     def renamed(self):
         return self._copied
     def repo(self):
         return self._repo
     def size(self):
         return len(self.data())
 
     def path(self):
         return self._path
 
     def isbinary(self):
         try:
             return stringutil.binary(self.data())
         except IOError:
             return False
     def isexec(self):
         return 'x' in self.flags()
     def islink(self):
         return 'l' in self.flags()
 
     def isabsent(self):
         """whether this filectx represents a file not in self._changectx
 
         This is mainly for merge code to detect change/delete conflicts. This is
         expected to be True for all subclasses of basectx."""
         return False
 
     _customcmp = False
     def cmp(self, fctx):
         """compare with other file context
 
         returns True if different than fctx.
         """
         if fctx._customcmp:
             return fctx.cmp(self)
 
         if (fctx._filenode is None
             and (self._repo._encodefilterpats
                  # if file data starts with '\1\n', empty metadata block is
                  # prepended, which adds 4 bytes to filelog.size().
                  or self.size() - 4 == fctx.size())
             or self.size() == fctx.size()):
             return self._filelog.cmp(self._filenode, fctx.data())
 
         return True
 
     def _adjustlinkrev(self, srcrev, inclusive=False):
         """return the first ancestor of <srcrev> introducing <fnode>
 
         If the linkrev of the file revision does not point to an ancestor of
         srcrev, we'll walk down the ancestors until we find one introducing
         this file revision.
 
         :srcrev: the changeset revision we search ancestors from
         :inclusive: if true, the src revision will also be checked
         """
         repo = self._repo
         cl = repo.unfiltered().changelog
         mfl = repo.manifestlog
         # fetch the linkrev
         lkr = self.linkrev()
         # hack to reuse ancestor computation when searching for renames
         memberanc = getattr(self, '_ancestrycontext', None)
         iteranc = None
         if srcrev is None:
             # wctx case, used by workingfilectx during mergecopy
             revs = [p.rev() for p in self._repo[None].parents()]
             inclusive = True # we skipped the real (revless) source
         else:
             revs = [srcrev]
         if memberanc is None:
             memberanc = iteranc = cl.ancestors(revs, lkr,
                                                inclusive=inclusive)
         # check if this linkrev is an ancestor of srcrev
         if lkr not in memberanc:
             if iteranc is None:
                 iteranc = cl.ancestors(revs, lkr, inclusive=inclusive)
             fnode = self._filenode
             path = self._path
             for a in iteranc:
                 ac = cl.read(a) # get changeset data (we avoid object creation)
                 if path in ac[3]: # checking the 'files' field.
                     # The file has been touched, check if the content is
                     # similar to the one we search for.
                     if fnode == mfl[ac[0]].readfast().get(path):
                         return a
             # In theory, we should never get out of that loop without a result.
             # But if manifest uses a buggy file revision (not children of the
             # one it replaces) we could. Such a buggy situation will likely
             # result is crash somewhere else at to some point.
         return lkr
 
     def introrev(self):
         """return the rev of the changeset which introduced this file revision
 
         This method is different from linkrev because it take into account the
         changeset the filectx was created from. It ensures the returned
         revision is one of its ancestors. This prevents bugs from
         'linkrev-shadowing' when a file revision is used by multiple
         changesets.
         """
         lkr = self.linkrev()
         attrs = vars(self)
         noctx = not (r'_changeid' in attrs or r'_changectx' in attrs)
         if noctx or self.rev() == lkr:
             return self.linkrev()
         return self._adjustlinkrev(self.rev(), inclusive=True)
 
     def introfilectx(self):
         """Return filectx having identical contents, but pointing to the
         changeset revision where this filectx was introduced"""
         introrev = self.introrev()
         if self.rev() == introrev:
             return self
         return self.filectx(self.filenode(), changeid=introrev)
 
     def _parentfilectx(self, path, fileid, filelog):
         """create parent filectx keeping ancestry info for _adjustlinkrev()"""
         fctx = filectx(self._repo, path, fileid=fileid, filelog=filelog)
         if r'_changeid' in vars(self) or r'_changectx' in vars(self):
             # If self is associated with a changeset (probably explicitly
             # fed), ensure the created filectx is associated with a
             # changeset that is an ancestor of self.changectx.
             # This lets us later use _adjustlinkrev to get a correct link.
             fctx._descendantrev = self.rev()
             fctx._ancestrycontext = getattr(self, '_ancestrycontext', None)
         elif r'_descendantrev' in vars(self):
             # Otherwise propagate _descendantrev if we have one associated.
             fctx._descendantrev = self._descendantrev
             fctx._ancestrycontext = getattr(self, '_ancestrycontext', None)
         return fctx
 
     def parents(self):
         _path = self._path
         fl = self._filelog
         parents = self._filelog.parents(self._filenode)
         pl = [(_path, node, fl) for node in parents if node != nullid]
 
         r = fl.renamed(self._filenode)
         if r:
             # - In the simple rename case, both parent are nullid, pl is empty.
             # - In case of merge, only one of the parent is null id and should
             # be replaced with the rename information. This parent is -always-
             # the first one.
             #
             # As null id have always been filtered out in the previous list
             # comprehension, inserting to 0 will always result in "replacing
             # first nullid parent with rename information.
             pl.insert(0, (r[0], r[1], self._repo.file(r[0])))
 
         return [self._parentfilectx(path, fnode, l) for path, fnode, l in pl]
 
     def p1(self):
         return self.parents()[0]
 
     def p2(self):
         p = self.parents()
         if len(p) == 2:
             return p[1]
         return filectx(self._repo, self._path, fileid=-1, filelog=self._filelog)
 
     def annotate(self, follow=False, skiprevs=None, diffopts=None):
         """Returns a list of annotateline objects for each line in the file
 
         - line.fctx is the filectx of the node where that line was last changed
         - line.lineno is the line number at the first appearance in the managed
           file
         - line.text is the data on that line (including newline character)
         """
         getlog = util.lrucachefunc(lambda x: self._repo.file(x))
 
         def parents(f):
             # Cut _descendantrev here to mitigate the penalty of lazy linkrev
             # adjustment. Otherwise, p._adjustlinkrev() would walk changelog
             # from the topmost introrev (= srcrev) down to p.linkrev() if it
             # isn't an ancestor of the srcrev.
             f._changeid
             pl = f.parents()
 
             # Don't return renamed parents if we aren't following.
             if not follow:
                 pl = [p for p in pl if p.path() == f.path()]
 
             # renamed filectx won't have a filelog yet, so set it
             # from the cache to save time
             for p in pl:
                 if not r'_filelog' in p.__dict__:
                     p._filelog = getlog(p.path())
 
             return pl
 
         # use linkrev to find the first changeset where self appeared
         base = self.introfilectx()
         if getattr(base, '_ancestrycontext', None) is None:
             cl = self._repo.changelog
             if base.rev() is None:
                 # wctx is not inclusive, but works because _ancestrycontext
                 # is used to test filelog revisions
                 ac = cl.ancestors([p.rev() for p in base.parents()],
                                   inclusive=True)
             else:
                 ac = cl.ancestors([base.rev()], inclusive=True)
             base._ancestrycontext = ac
 
         return dagop.annotate(base, parents, skiprevs=skiprevs,
                               diffopts=diffopts)
 
     def ancestors(self, followfirst=False):
         visit = {}
         c = self
         if followfirst:
             cut = 1
         else:
             cut = None
 
         while True:
             for parent in c.parents()[:cut]:
                 visit[(parent.linkrev(), parent.filenode())] = parent
             if not visit:
                 break
             c = visit.pop(max(visit))
             yield c
 
     def decodeddata(self):
         """Returns `data()` after running repository decoding filters.
 
         This is often equivalent to how the data would be expressed on disk.
         """
         return self._repo.wwritedata(self.path(), self.data())
 
 class filectx(basefilectx):
     """A filecontext object makes access to data related to a particular
        filerevision convenient."""
     def __init__(self, repo, path, changeid=None, fileid=None,
                  filelog=None, changectx=None):
         """changeid can be a changeset revision, node, or tag.
            fileid can be a file revision or node."""
         self._repo = repo
         self._path = path
 
         assert (changeid is not None
                 or fileid is not None
                 or changectx is not None), \
                 ("bad args: changeid=%r, fileid=%r, changectx=%r"
                  % (changeid, fileid, changectx))
 
         if filelog is not None:
             self._filelog = filelog
 
         if changeid is not None:
             self._changeid = changeid
         if changectx is not None:
             self._changectx = changectx
         if fileid is not None:
             self._fileid = fileid
 
     @propertycache
     def _changectx(self):
         try:
             return changectx(self._repo, self._changeid)
         except error.FilteredRepoLookupError:
             # Linkrev may point to any revision in the repository.  When the
             # repository is filtered this may lead to `filectx` trying to build
             # `changectx` for filtered revision. In such case we fallback to
             # creating `changectx` on the unfiltered version of the reposition.
             # This fallback should not be an issue because `changectx` from
             # `filectx` are not used in complex operations that care about
             # filtering.
             #
             # This fallback is a cheap and dirty fix that prevent several
             # crashes. It does not ensure the behavior is correct. However the
             # behavior was not correct before filtering either and "incorrect
             # behavior" is seen as better as "crash"
             #
             # Linkrevs have several serious troubles with filtering that are
             # complicated to solve. Proper handling of the issue here should be
             # considered when solving linkrev issue are on the table.
             return changectx(self._repo.unfiltered(), self._changeid)
 
     def filectx(self, fileid, changeid=None):
         '''opens an arbitrary revision of the file without
         opening a new filelog'''
         return filectx(self._repo, self._path, fileid=fileid,
                        filelog=self._filelog, changeid=changeid)
 
     def rawdata(self):
         return self._filelog.revision(self._filenode, raw=True)
 
     def rawflags(self):
         """low-level revlog flags"""
         return self._filelog.flags(self._filerev)
 
     def data(self):
         try:
             return self._filelog.read(self._filenode)
         except error.CensoredNodeError:
             if self._repo.ui.config("censor", "policy") == "ignore":
                 return ""
             raise error.Abort(_("censored node: %s") % short(self._filenode),
                              hint=_("set censor.policy to ignore errors"))
 
     def size(self):
         return self._filelog.size(self._filerev)
 
     @propertycache
     def _copied(self):
         """check if file was actually renamed in this changeset revision
 
         If rename logged in file revision, we report copy for changeset only
         if file revisions linkrev points back to the changeset in question
         or both changeset parents contain different file revisions.
         """
 
         renamed = self._filelog.renamed(self._filenode)
         if not renamed:
             return renamed
 
         if self.rev() == self.linkrev():
             return renamed
 
         name = self.path()
         fnode = self._filenode
         for p in self._changectx.parents():
             try:
                 if fnode == p.filenode(name):
                     return None
             except error.LookupError:
                 pass
         return renamed
 
     def children(self):
         # hard for renames
         c = self._filelog.children(self._filenode)
         return [filectx(self._repo, self._path, fileid=x,
                         filelog=self._filelog) for x in c]
 
 class committablectx(basectx):
     """A committablectx object provides common functionality for a context that
     wants the ability to commit, e.g. workingctx or memctx."""
     def __init__(self, repo, text="", user=None, date=None, extra=None,
                  changes=None):
         super(committablectx, self).__init__(repo)
         self._rev = None
         self._node = None
         self._text = text
         if date:
             self._date = dateutil.parsedate(date)
         if user:
             self._user = user
         if changes:
             self._status = changes
 
         self._extra = {}
         if extra:
             self._extra = extra.copy()
         if 'branch' not in self._extra:
             try:
                 branch = encoding.fromlocal(self._repo.dirstate.branch())
             except UnicodeDecodeError:
                 raise error.Abort(_('branch name not in UTF-8!'))
             self._extra['branch'] = branch
         if self._extra['branch'] == '':
             self._extra['branch'] = 'default'
 
     def __bytes__(self):
         return bytes(self._parents[0]) + "+"
 
     __str__ = encoding.strmethod(__bytes__)
 
     def __nonzero__(self):
         return True
 
     __bool__ = __nonzero__
 
     def _buildflagfunc(self):
         # Create a fallback function for getting file flags when the
         # filesystem doesn't support them
 
         copiesget = self._repo.dirstate.copies().get
         parents = self.parents()
         if len(parents) < 2:
             # when we have one parent, it's easy: copy from parent
             man = parents[0].manifest()
             def func(f):
                 f = copiesget(f, f)
                 return man.flags(f)
         else:
             # merges are tricky: we try to reconstruct the unstored
             # result from the merge (issue1802)
             p1, p2 = parents
             pa = p1.ancestor(p2)
             m1, m2, ma = p1.manifest(), p2.manifest(), pa.manifest()
 
             def func(f):
                 f = copiesget(f, f) # may be wrong for merges with copies
                 fl1, fl2, fla = m1.flags(f), m2.flags(f), ma.flags(f)
                 if fl1 == fl2:
                     return fl1
                 if fl1 == fla:
                     return fl2
                 if fl2 == fla:
                     return fl1
                 return '' # punt for conflicts
 
         return func
 
     @propertycache
     def _flagfunc(self):
         return self._repo.dirstate.flagfunc(self._buildflagfunc)
 
     @propertycache
     def _status(self):
         return self._repo.status()
 
     @propertycache
     def _user(self):
         return self._repo.ui.username()
 
     @propertycache
     def _date(self):
         ui = self._repo.ui
         date = ui.configdate('devel', 'default-date')
         if date is None:
             date = dateutil.makedate()
         return date
 
     def subrev(self, subpath):
         return None
 
     def manifestnode(self):
         return None
     def user(self):
         return self._user or self._repo.ui.username()
     def date(self):
         return self._date
     def description(self):
         return self._text
     def files(self):
         return sorted(self._status.modified + self._status.added +
                       self._status.removed)
 
     def modified(self):
         return self._status.modified
     def added(self):
         return self._status.added
     def removed(self):
         return self._status.removed
     def deleted(self):
         return self._status.deleted
     def branch(self):
         return encoding.tolocal(self._extra['branch'])
     def closesbranch(self):
         return 'close' in self._extra
     def extra(self):
         return self._extra
 
     def isinmemory(self):
         return False
 
     def tags(self):
         return []
 
     def bookmarks(self):
         b = []
         for p in self.parents():
             b.extend(p.bookmarks())
         return b
 
     def phase(self):
         phase = phases.draft # default phase to draft
         for p in self.parents():
             phase = max(phase, p.phase())
         return phase
 
     def hidden(self):
         return False
 
     def children(self):
         return []
 
     def flags(self, path):
         if r'_manifest' in self.__dict__:
             try:
                 return self._manifest.flags(path)
             except KeyError:
                 return ''
 
         try:
             return self._flagfunc(path)
         except OSError:
             return ''
 
     def ancestor(self, c2):
         """return the "best" ancestor context of self and c2"""
         return self._parents[0].ancestor(c2) # punt on two parents for now
 
     def walk(self, match):
         '''Generates matching file names.'''
         return sorted(self._repo.dirstate.walk(match,
                                                subrepos=sorted(self.substate),
                                                unknown=True, ignored=False))
 
     def matches(self, match):
         ds = self._repo.dirstate
         return sorted(f for f in ds.matches(match) if ds[f] != 'r')
 
     def ancestors(self):
         for p in self._parents:
             yield p
         for a in self._repo.changelog.ancestors(
             [p.rev() for p in self._parents]):
             yield changectx(self._repo, a)
 
     def markcommitted(self, node):
         """Perform post-commit cleanup necessary after committing this ctx
 
         Specifically, this updates backing stores this working context
         wraps to reflect the fact that the changes reflected by this
         workingctx have been committed.  For example, it marks
         modified and added files as normal in the dirstate.
 
         """
 
         with self._repo.dirstate.parentchange():
             for f in self.modified() + self.added():
                 self._repo.dirstate.normal(f)
             for f in self.removed():
                 self._repo.dirstate.drop(f)
             self._repo.dirstate.setparents(node)
 
         # write changes out explicitly, because nesting wlock at
         # runtime may prevent 'wlock.release()' in 'repo.commit()'
         # from immediately doing so for subsequent changing files
         self._repo.dirstate.write(self._repo.currenttransaction())
 
     def dirty(self, missing=False, merge=True, branch=True):
         return False
 
 class workingctx(committablectx):
     """A workingctx object makes access to data related to
     the current working directory convenient.
     date - any valid date string or (unixtime, offset), or None.
     user - username string, or None.
     extra - a dictionary of extra values, or None.
     changes - a list of file lists as returned by localrepo.status()
                or None to use the repository status.
     """
     def __init__(self, repo, text="", user=None, date=None, extra=None,
                  changes=None):
         super(workingctx, self).__init__(repo, text, user, date, extra, changes)
 
     def __iter__(self):
         d = self._repo.dirstate
         for f in d:
             if d[f] != 'r':
                 yield f
 
     def __contains__(self, key):
         return self._repo.dirstate[key] not in "?r"
 
     def hex(self):
         return hex(wdirid)
 
     @propertycache
     def _parents(self):
         p = self._repo.dirstate.parents()
         if p[1] == nullid:
             p = p[:-1]
         return [changectx(self._repo, x) for x in p]
 
     def _fileinfo(self, path):
         # populate __dict__['_manifest'] as workingctx has no _manifestdelta
         self._manifest
         return super(workingctx, self)._fileinfo(path)
 
     def filectx(self, path, filelog=None):
         """get a file context from the working directory"""
         return workingfilectx(self._repo, path, workingctx=self,
                               filelog=filelog)
 
     def dirty(self, missing=False, merge=True, branch=True):
         "check whether a working directory is modified"
         # check subrepos first
         for s in sorted(self.substate):
             if self.sub(s).dirty(missing=missing):
                 return True
         # check current working dir
         return ((merge and self.p2()) or
                 (branch and self.branch() != self.p1().branch()) or
                 self.modified() or self.added() or self.removed() or
                 (missing and self.deleted()))
 
     def add(self, list, prefix=""):
         with self._repo.wlock():
             ui, ds = self._repo.ui, self._repo.dirstate
             uipath = lambda f: ds.pathto(pathutil.join(prefix, f))
             rejected = []
             lstat = self._repo.wvfs.lstat
             for f in list:
                 # ds.pathto() returns an absolute file when this is invoked from
                 # the keyword extension.  That gets flagged as non-portable on
                 # Windows, since it contains the drive letter and colon.
                 scmutil.checkportable(ui, os.path.join(prefix, f))
                 try:
                     st = lstat(f)
                 except OSError:
                     ui.warn(_("%s does not exist!\n") % uipath(f))
                     rejected.append(f)
                     continue
                 limit = ui.configbytes('ui', 'large-file-limit')
                 if limit != 0 and st.st_size > limit:
                     ui.warn(_("%s: up to %d MB of RAM may be required "
                               "to manage this file\n"
                               "(use 'hg revert %s' to cancel the "
                               "pending addition)\n")
                             % (f, 3 * st.st_size // 1000000, uipath(f)))
                 if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
                     ui.warn(_("%s not added: only files and symlinks "
                               "supported currently\n") % uipath(f))
                     rejected.append(f)
                 elif ds[f] in 'amn':
                     ui.warn(_("%s already tracked!\n") % uipath(f))
                 elif ds[f] == 'r':
                     ds.normallookup(f)
                 else:
                     ds.add(f)
             return rejected
 
     def forget(self, files, prefix=""):
         with self._repo.wlock():
             ds = self._repo.dirstate
             uipath = lambda f: ds.pathto(pathutil.join(prefix, f))
             rejected = []
             for f in files:
                 if f not in self._repo.dirstate:
                     self._repo.ui.warn(_("%s not tracked!\n") % uipath(f))
                     rejected.append(f)
                 elif self._repo.dirstate[f] != 'a':
                     self._repo.dirstate.remove(f)
                 else:
                     self._repo.dirstate.drop(f)
             return rejected
 
     def undelete(self, list):
         pctxs = self.parents()
         with self._repo.wlock():
             ds = self._repo.dirstate
             for f in list:
                 if self._repo.dirstate[f] != 'r':
                     self._repo.ui.warn(_("%s not removed!\n") % ds.pathto(f))
                 else:
                     fctx = f in pctxs[0] and pctxs[0][f] or pctxs[1][f]
                     t = fctx.data()
                     self._repo.wwrite(f, t, fctx.flags())
                     self._repo.dirstate.normal(f)
 
     def copy(self, source, dest):
         try:
             st = self._repo.wvfs.lstat(dest)
         except OSError as err:
             if err.errno != errno.ENOENT:
                 raise
             self._repo.ui.warn(_("%s does not exist!\n")
                                % self._repo.dirstate.pathto(dest))
             return
         if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
             self._repo.ui.warn(_("copy failed: %s is not a file or a "
                                  "symbolic link\n")
                                % self._repo.dirstate.pathto(dest))
         else:
             with self._repo.wlock():
                 if self._repo.dirstate[dest] in '?':
                     self._repo.dirstate.add(dest)
                 elif self._repo.dirstate[dest] in 'r':
                     self._repo.dirstate.normallookup(dest)
                 self._repo.dirstate.copy(source, dest)
 
     def match(self, pats=None, include=None, exclude=None, default='glob',
               listsubrepos=False, badfn=None):
         r = self._repo
 
         # Only a case insensitive filesystem needs magic to translate user input
         # to actual case in the filesystem.
         icasefs = not util.fscasesensitive(r.root)
         return matchmod.match(r.root, r.getcwd(), pats, include, exclude,
                               default, auditor=r.auditor, ctx=self,
                               listsubrepos=listsubrepos, badfn=badfn,
                               icasefs=icasefs)
 
     def _filtersuspectsymlink(self, files):
         if not files or self._repo.dirstate._checklink:
             return files
 
         # Symlink placeholders may get non-symlink-like contents
         # via user error or dereferencing by NFS or Samba servers,
         # so we filter out any placeholders that don't look like a
         # symlink
         sane = []
         for f in files:
             if self.flags(f) == 'l':
                 d = self[f].data()
                 if (d == '' or len(d) >= 1024 or '\n' in d
                     or stringutil.binary(d)):
                     self._repo.ui.debug('ignoring suspect symlink placeholder'
                                         ' "%s"\n' % f)
                     continue
             sane.append(f)
         return sane
 
     def _checklookup(self, files):
         # check for any possibly clean files
         if not files:
             return [], [], []
 
         modified = []
         deleted = []
         fixup = []
         pctx = self._parents[0]
         # do a full compare of any files that might have changed
         for f in sorted(files):
             try:
                 # This will return True for a file that got replaced by a
                 # directory in the interim, but fixing that is pretty hard.
                 if (f not in pctx or self.flags(f) != pctx.flags(f)
                     or pctx[f].cmp(self[f])):
                     modified.append(f)
                 else:
                     fixup.append(f)
             except (IOError, OSError):
                 # A file become inaccessible in between? Mark it as deleted,
                 # matching dirstate behavior (issue5584).
                 # The dirstate has more complex behavior around whether a
                 # missing file matches a directory, etc, but we don't need to
                 # bother with that: if f has made it to this point, we're sure
                 # it's in the dirstate.
                 deleted.append(f)
 
         return modified, deleted, fixup
 
     def _poststatusfixup(self, status, fixup):
         """update dirstate for files that are actually clean"""
         poststatus = self._repo.postdsstatus()
         if fixup or poststatus:
             try:
                 oldid = self._repo.dirstate.identity()
 
                 # updating the dirstate is optional
                 # so we don't wait on the lock
                 # wlock can invalidate the dirstate, so cache normal _after_
                 # taking the lock
                 with self._repo.wlock(False):
                     if self._repo.dirstate.identity() == oldid:
                         if fixup:
                             normal = self._repo.dirstate.normal
                             for f in fixup:
                                 normal(f)
                             # write changes out explicitly, because nesting
                             # wlock at runtime may prevent 'wlock.release()'
                             # after this block from doing so for subsequent
                             # changing files
                             tr = self._repo.currenttransaction()
                             self._repo.dirstate.write(tr)
 
                         if poststatus:
                             for ps in poststatus:
                                 ps(self, status)
                     else:
                         # in this case, writing changes out breaks
                         # consistency, because .hg/dirstate was
                         # already changed simultaneously after last
                         # caching (see also issue5584 for detail)
                         self._repo.ui.debug('skip updating dirstate: '
                                             'identity mismatch\n')
             except error.LockError:
                 pass
             finally:
                 # Even if the wlock couldn't be grabbed, clear out the list.
                 self._repo.clearpostdsstatus()
 
     def _dirstatestatus(self, match, ignored=False, clean=False, unknown=False):
         '''Gets the status from the dirstate -- internal use only.'''
         subrepos = []
         if '.hgsub' in self:
             subrepos = sorted(self.substate)
         cmp, s = self._repo.dirstate.status(match, subrepos, ignored=ignored,
                                             clean=clean, unknown=unknown)
 
         # check for any possibly clean files
         fixup = []
         if cmp:
             modified2, deleted2, fixup = self._checklookup(cmp)
             s.modified.extend(modified2)
             s.deleted.extend(deleted2)
 
             if fixup and clean:
                 s.clean.extend(fixup)
 
         self._poststatusfixup(s, fixup)
 
         if match.always():
             # cache for performance
             if s.unknown or s.ignored or s.clean:
                 # "_status" is cached with list*=False in the normal route
                 self._status = scmutil.status(s.modified, s.added, s.removed,
                                               s.deleted, [], [], [])
             else:
                 self._status = s
 
         return s
 
     @propertycache
     def _manifest(self):
         """generate a manifest corresponding to the values in self._status
 
         This reuse the file nodeid from parent, but we use special node
         identifiers for added and modified files. This is used by manifests
         merge to see that files are different and by update logic to avoid
         deleting newly added files.
         """
         return self._buildstatusmanifest(self._status)
 
     def _buildstatusmanifest(self, status):
         """Builds a manifest that includes the given status results."""
         parents = self.parents()
 
         man = parents[0].manifest().copy()
 
         ff = self._flagfunc
         for i, l in ((addednodeid, status.added),
                      (modifiednodeid, status.modified)):
             for f in l:
                 man[f] = i
                 try:
                     man.setflag(f, ff(f))
                 except OSError:
                     pass
 
         for f in status.deleted + status.removed:
             if f in man:
                 del man[f]
 
         return man
 
     def _buildstatus(self, other, s, match, listignored, listclean,
                      listunknown):
         """build a status with respect to another context
 
         This includes logic for maintaining the fast path of status when
         comparing the working directory against its parent, which is to skip
         building a new manifest if self (working directory) is not comparing
         against its parent (repo['.']).
         """
         s = self._dirstatestatus(match, listignored, listclean, listunknown)
         # Filter out symlinks that, in the case of FAT32 and NTFS filesystems,
         # might have accidentally ended up with the entire contents of the file
         # they are supposed to be linking to.
         s.modified[:] = self._filtersuspectsymlink(s.modified)
         if other != self._repo['.']:
             s = super(workingctx, self)._buildstatus(other, s, match,
                                                      listignored, listclean,
                                                      listunknown)
         return s
 
     def _matchstatus(self, other, match):
         """override the match method with a filter for directory patterns
 
         We use inheritance to customize the match.bad method only in cases of
         workingctx since it belongs only to the working directory when
         comparing against the parent changeset.
 
         If we aren't comparing against the working directory's parent, then we
         just use the default match object sent to us.
         """
         if other != self._repo['.']:
             def bad(f, msg):
                 # 'f' may be a directory pattern from 'match.files()',
                 # so 'f not in ctx1' is not enough
                 if f not in other and not other.hasdir(f):
                     self._repo.ui.warn('%s: %s\n' %
                                        (self._repo.dirstate.pathto(f), msg))
             match.bad = bad
         return match
 
     def markcommitted(self, node):
         super(workingctx, self).markcommitted(node)
 
         sparse.aftercommit(self._repo, node)
 
 class committablefilectx(basefilectx):
     """A committablefilectx provides common functionality for a file context
     that wants the ability to commit, e.g. workingfilectx or memfilectx."""
     def __init__(self, repo, path, filelog=None, ctx=None):
         self._repo = repo
         self._path = path
         self._changeid = None
         self._filerev = self._filenode = None
 
         if filelog is not None:
             self._filelog = filelog
         if ctx:
             self._changectx = ctx
 
     def __nonzero__(self):
         return True
 
     __bool__ = __nonzero__
 
     def linkrev(self):
         # linked to self._changectx no matter if file is modified or not
         return self.rev()
 
     def parents(self):
         '''return parent filectxs, following copies if necessary'''
         def filenode(ctx, path):
             return ctx._manifest.get(path, nullid)
 
         path = self._path
         fl = self._filelog
         pcl = self._changectx._parents
         renamed = self.renamed()
 
         if renamed:
             pl = [renamed + (None,)]
         else:
             pl = [(path, filenode(pcl[0], path), fl)]
 
         for pc in pcl[1:]:
             pl.append((path, filenode(pc, path), fl))
 
         return [self._parentfilectx(p, fileid=n, filelog=l)
                 for p, n, l in pl if n != nullid]
 
     def children(self):
         return []
 
 class workingfilectx(committablefilectx):
     """A workingfilectx object makes access to data related to a particular
        file in the working directory convenient."""
     def __init__(self, repo, path, filelog=None, workingctx=None):
         super(workingfilectx, self).__init__(repo, path, filelog, workingctx)
 
     @propertycache
     def _changectx(self):
         return workingctx(self._repo)
 
     def data(self):
         return self._repo.wread(self._path)
     def renamed(self):
         rp = self._repo.dirstate.copied(self._path)
         if not rp:
             return None
         return rp, self._changectx._parents[0]._manifest.get(rp, nullid)
 
     def size(self):
         return self._repo.wvfs.lstat(self._path).st_size
     def date(self):
         t, tz = self._changectx.date()
         try:
             return (self._repo.wvfs.lstat(self._path)[stat.ST_MTIME], tz)
         except OSError as err:
             if err.errno != errno.ENOENT:
                 raise
             return (t, tz)
 
     def exists(self):
         return self._repo.wvfs.exists(self._path)
 
     def lexists(self):
         return self._repo.wvfs.lexists(self._path)
 
     def audit(self):
         return self._repo.wvfs.audit(self._path)
 
     def cmp(self, fctx):
         """compare with other file context
 
         returns True if different than fctx.
         """
         # fctx should be a filectx (not a workingfilectx)
         # invert comparison to reuse the same code path
         return fctx.cmp(self)
 
     def remove(self, ignoremissing=False):
         """wraps unlink for a repo's working directory"""
         rmdir = self._repo.ui.configbool('experimental', 'removeemptydirs')
         self._repo.wvfs.unlinkpath(self._path, ignoremissing=ignoremissing,
                                    rmdir=rmdir)
 
     def write(self, data, flags, backgroundclose=False, **kwargs):
         """wraps repo.wwrite"""
         self._repo.wwrite(self._path, data, flags,
                           backgroundclose=backgroundclose,
                           **kwargs)
 
     def markcopied(self, src):
         """marks this file a copy of `src`"""
         if self._repo.dirstate[self._path] in "nma":
             self._repo.dirstate.copy(src, self._path)
 
     def clearunknown(self):
         """Removes conflicting items in the working directory so that
         ``write()`` can be called successfully.
         """
         wvfs = self._repo.wvfs
         f = self._path
         wvfs.audit(f)
         if wvfs.isdir(f) and not wvfs.islink(f):
             wvfs.rmtree(f, forcibly=True)
         if self._repo.ui.configbool('experimental', 'merge.checkpathconflicts'):
             for p in reversed(list(util.finddirs(f))):
                 if wvfs.isfileorlink(p):
                     wvfs.unlink(p)
                     break
 
     def setflags(self, l, x):
         self._repo.wvfs.setflags(self._path, l, x)
 
 class overlayworkingctx(committablectx):
     """Wraps another mutable context with a write-back cache that can be
     converted into a commit context.
 
     self._cache[path] maps to a dict with keys: {
         'exists': bool?
         'date': date?
         'data': str?
         'flags': str?
         'copied': str? (path or None)
     }
     If `exists` is True, `flags` must be non-None and 'date' is non-None. If it
     is `False`, the file was deleted.
     """
 
     def __init__(self, repo):
         super(overlayworkingctx, self).__init__(repo)
         self.clean()
 
     def setbase(self, wrappedctx):
         self._wrappedctx = wrappedctx
         self._parents = [wrappedctx]
         # Drop old manifest cache as it is now out of date.
         # This is necessary when, e.g., rebasing several nodes with one
         # ``overlayworkingctx`` (e.g. with --collapse).
         util.clearcachedproperty(self, '_manifest')
 
     def data(self, path):
         if self.isdirty(path):
             if self._cache[path]['exists']:
                 if self._cache[path]['data']:
                     return self._cache[path]['data']
                 else:
                     # Must fallback here, too, because we only set flags.
                     return self._wrappedctx[path].data()
             else:
                 raise error.ProgrammingError("No such file or directory: %s" %
                                              path)
         else:
             return self._wrappedctx[path].data()
 
     @propertycache
     def _manifest(self):
         parents = self.parents()
         man = parents[0].manifest().copy()
 
         flag = self._flagfunc
         for path in self.added():
             man[path] = addednodeid
             man.setflag(path, flag(path))
         for path in self.modified():
             man[path] = modifiednodeid
             man.setflag(path, flag(path))
         for path in self.removed():
             del man[path]
         return man
 
     @propertycache
     def _flagfunc(self):
         def f(path):
             return self._cache[path]['flags']
         return f
 
     def files(self):
         return sorted(self.added() + self.modified() + self.removed())
 
     def modified(self):
         return [f for f in self._cache.keys() if self._cache[f]['exists'] and
                 self._existsinparent(f)]
 
     def added(self):
         return [f for f in self._cache.keys() if self._cache[f]['exists'] and
                 not self._existsinparent(f)]
 
     def removed(self):
         return [f for f in self._cache.keys() if
                 not self._cache[f]['exists'] and self._existsinparent(f)]
 
     def isinmemory(self):
         return True
 
     def filedate(self, path):
         if self.isdirty(path):
             return self._cache[path]['date']
         else:
             return self._wrappedctx[path].date()
 
     def markcopied(self, path, origin):
         if self.isdirty(path):
             self._cache[path]['copied'] = origin
         else:
             raise error.ProgrammingError('markcopied() called on clean context')
 
     def copydata(self, path):
         if self.isdirty(path):
             return self._cache[path]['copied']
         else:
             raise error.ProgrammingError('copydata() called on clean context')
 
     def flags(self, path):
         if self.isdirty(path):
             if self._cache[path]['exists']:
                 return self._cache[path]['flags']
             else:
                 raise error.ProgrammingError("No such file or directory: %s" %
                                              self._path)
         else:
             return self._wrappedctx[path].flags()
 
     def _existsinparent(self, path):
         try:
             # ``commitctx` raises a ``ManifestLookupError`` if a path does not
             # exist, unlike ``workingctx``, which returns a ``workingfilectx``
             # with an ``exists()`` function.
             self._wrappedctx[path]
             return True
         except error.ManifestLookupError:
             return False
 
     def _auditconflicts(self, path):
         """Replicates conflict checks done by wvfs.write().
 
         Since we never write to the filesystem and never call `applyupdates` in
         IMM, we'll never check that a path is actually writable -- e.g., because
         it adds `a/foo`, but `a` is actually a file in the other commit.
         """
         def fail(path, component):
             # p1() is the base and we're receiving "writes" for p2()'s
             # files.
             if 'l' in self.p1()[component].flags():
                 raise error.Abort("error: %s conflicts with symlink %s "
                                   "in %s." % (path, component,
                                               self.p1().rev()))
             else:
                 raise error.Abort("error: '%s' conflicts with file '%s' in "
                                   "%s." % (path, component,
                                            self.p1().rev()))
 
         # Test that each new directory to be created to write this path from p2
         # is not a file in p1.
         components = path.split('/')
         for i in xrange(len(components)):
             component = "/".join(components[0:i])
             if component in self.p1():
                 fail(path, component)
 
         # Test the other direction -- that this path from p2 isn't a directory
         # in p1 (test that p1 doesn't any paths matching `path/*`).
         match = matchmod.match('/', '', [path + '/'], default=b'relpath')
         matches = self.p1().manifest().matches(match)
         if len(matches) > 0:
             if len(matches) == 1 and matches.keys()[0] == path:
                 return
             raise error.Abort("error: file '%s' cannot be written because "
                               " '%s/' is a folder in %s (containing %d "
                               "entries: %s)"
                               % (path, path, self.p1(), len(matches),
                                  ', '.join(matches.keys())))
 
     def write(self, path, data, flags='', **kwargs):
         if data is None:
             raise error.ProgrammingError("data must be non-None")
         self._auditconflicts(path)
         self._markdirty(path, exists=True, data=data, date=dateutil.makedate(),
                         flags=flags)
 
     def setflags(self, path, l, x):
         self._markdirty(path, exists=True, date=dateutil.makedate(),
                         flags=(l and 'l' or '') + (x and 'x' or ''))
 
     def remove(self, path):
         self._markdirty(path, exists=False)
 
     def exists(self, path):
         """exists behaves like `lexists`, but needs to follow symlinks and
         return False if they are broken.
         """
         if self.isdirty(path):
             # If this path exists and is a symlink, "follow" it by calling
             # exists on the destination path.
             if (self._cache[path]['exists'] and
                         'l' in self._cache[path]['flags']):
                 return self.exists(self._cache[path]['data'].strip())
             else:
                 return self._cache[path]['exists']
 
         return self._existsinparent(path)
 
     def lexists(self, path):
         """lexists returns True if the path exists"""
         if self.isdirty(path):
             return self._cache[path]['exists']
 
         return self._existsinparent(path)
 
     def size(self, path):
         if self.isdirty(path):
             if self._cache[path]['exists']:
                 return len(self._cache[path]['data'])
             else:
                 raise error.ProgrammingError("No such file or directory: %s" %
                                              self._path)
         return self._wrappedctx[path].size()
 
     def tomemctx(self, text, branch=None, extra=None, date=None, parents=None,
                  user=None, editor=None):
         """Converts this ``overlayworkingctx`` into a ``memctx`` ready to be
         committed.
 
         ``text`` is the commit message.
         ``parents`` (optional) are rev numbers.
         """
         # Default parents to the wrapped contexts' if not passed.
         if parents is None:
             parents = self._wrappedctx.parents()
             if len(parents) == 1:
                 parents = (parents[0], None)
 
         # ``parents`` is passed as rev numbers; convert to ``commitctxs``.
         if parents[1] is None:
             parents = (self._repo[parents[0]], None)
         else:
             parents = (self._repo[parents[0]], self._repo[parents[1]])
 
         files = self._cache.keys()
         def getfile(repo, memctx, path):
             if self._cache[path]['exists']:
                 return memfilectx(repo, memctx, path,
                                   self._cache[path]['data'],
                                   'l' in self._cache[path]['flags'],
                                   'x' in self._cache[path]['flags'],
                                   self._cache[path]['copied'])
             else:
                 # Returning None, but including the path in `files`, is
                 # necessary for memctx to register a deletion.
                 return None
         return memctx(self._repo, parents, text, files, getfile, date=date,
                       extra=extra, user=user, branch=branch, editor=editor)
 
     def isdirty(self, path):
         return path in self._cache
 
     def isempty(self):
         # We need to discard any keys that are actually clean before the empty
         # commit check.
         self._compact()
         return len(self._cache) == 0
 
     def clean(self):
         self._cache = {}
 
     def _compact(self):
         """Removes keys from the cache that are actually clean, by comparing
         them with the underlying context.
 
         This can occur during the merge process, e.g. by passing --tool :local
         to resolve a conflict.
         """
         keys = []
         for path in self._cache.keys():
             cache = self._cache[path]
             try:
                 underlying = self._wrappedctx[path]
                 if (underlying.data() == cache['data'] and
                             underlying.flags() == cache['flags']):
                     keys.append(path)
             except error.ManifestLookupError:
                 # Path not in the underlying manifest (created).
                 continue
 
         for path in keys:
             del self._cache[path]
         return keys
 
     def _markdirty(self, path, exists, data=None, date=None, flags=''):
         self._cache[path] = {
             'exists': exists,
             'data': data,
             'date': date,
             'flags': flags,
             'copied': None,
         }
 
     def filectx(self, path, filelog=None):
         return overlayworkingfilectx(self._repo, path, parent=self,
                                      filelog=filelog)
 
 class overlayworkingfilectx(committablefilectx):
     """Wrap a ``workingfilectx`` but intercepts all writes into an in-memory
     cache, which can be flushed through later by calling ``flush()``."""
 
     def __init__(self, repo, path, filelog=None, parent=None):
         super(overlayworkingfilectx, self).__init__(repo, path, filelog,
                                                     parent)
         self._repo = repo
         self._parent = parent
         self._path = path
 
     def cmp(self, fctx):
         return self.data() != fctx.data()
 
     def changectx(self):
         return self._parent
 
     def data(self):
         return self._parent.data(self._path)
 
     def date(self):
         return self._parent.filedate(self._path)
 
     def exists(self):
         return self.lexists()
 
     def lexists(self):
         return self._parent.exists(self._path)
 
     def renamed(self):
         path = self._parent.copydata(self._path)
         if not path:
             return None
         return path, self._changectx._parents[0]._manifest.get(path, nullid)
 
     def size(self):
         return self._parent.size(self._path)
 
     def markcopied(self, origin):
         self._parent.markcopied(self._path, origin)
 
     def audit(self):
         pass
 
     def flags(self):
         return self._parent.flags(self._path)
 
     def setflags(self, islink, isexec):
         return self._parent.setflags(self._path, islink, isexec)
 
     def write(self, data, flags, backgroundclose=False, **kwargs):
         return self._parent.write(self._path, data, flags, **kwargs)
 
     def remove(self, ignoremissing=False):
         return self._parent.remove(self._path)
 
     def clearunknown(self):
         pass
 
 class workingcommitctx(workingctx):
     """A workingcommitctx object makes access to data related to
     the revision being committed convenient.
 
     This hides changes in the working directory, if they aren't
     committed in this context.
     """
     def __init__(self, repo, changes,
                  text="", user=None, date=None, extra=None):
         super(workingctx, self).__init__(repo, text, user, date, extra,
                                          changes)
 
     def _dirstatestatus(self, match, ignored=False, clean=False, unknown=False):
         """Return matched files only in ``self._status``
 
         Uncommitted files appear "clean" via this context, even if
         they aren't actually so in the working directory.
         """
         if clean:
             clean = [f for f in self._manifest if f not in self._changedset]
         else:
             clean = []
         return scmutil.status([f for f in self._status.modified if match(f)],
                               [f for f in self._status.added if match(f)],
                               [f for f in self._status.removed if match(f)],
                               [], [], [], clean)
 
     @propertycache
     def _changedset(self):
         """Return the set of files changed in this context
         """
         changed = set(self._status.modified)
         changed.update(self._status.added)
         changed.update(self._status.removed)
         return changed
 
 def makecachingfilectxfn(func):
     """Create a filectxfn that caches based on the path.
 
     We can't use util.cachefunc because it uses all arguments as the cache
     key and this creates a cycle since the arguments include the repo and
     memctx.
     """
     cache = {}
 
     def getfilectx(repo, memctx, path):
         if path not in cache:
             cache[path] = func(repo, memctx, path)
         return cache[path]
 
     return getfilectx
 
 def memfilefromctx(ctx):
     """Given a context return a memfilectx for ctx[path]
 
     This is a convenience method for building a memctx based on another
     context.
     """
     def getfilectx(repo, memctx, path):
         fctx = ctx[path]
         # this is weird but apparently we only keep track of one parent
         # (why not only store that instead of a tuple?)
         copied = fctx.renamed()
         if copied:
             copied = copied[0]
         return memfilectx(repo, memctx, path, fctx.data(),
                           islink=fctx.islink(), isexec=fctx.isexec(),
                           copied=copied)
 
     return getfilectx
 
 def memfilefrompatch(patchstore):
     """Given a patch (e.g. patchstore object) return a memfilectx
 
     This is a convenience method for building a memctx based on a patchstore.
     """
     def getfilectx(repo, memctx, path):
         data, mode, copied = patchstore.getfile(path)
         if data is None:
             return None
         islink, isexec = mode
         return memfilectx(repo, memctx, path, data, islink=islink,
                           isexec=isexec, copied=copied)
 
     return getfilectx
 
 class memctx(committablectx):
     """Use memctx to perform in-memory commits via localrepo.commitctx().
 
     Revision information is supplied at initialization time while
     related files data and is made available through a callback
     mechanism.  'repo' is the current localrepo, 'parents' is a
     sequence of two parent revisions identifiers (pass None for every
     missing parent), 'text' is the commit message and 'files' lists
     names of files touched by the revision (normalized and relative to
     repository root).
 
     filectxfn(repo, memctx, path) is a callable receiving the
     repository, the current memctx object and the normalized path of
     requested file, relative to repository root. It is fired by the
     commit function for every file in 'files', but calls order is
     undefined. If the file is available in the revision being
     committed (updated or added), filectxfn returns a memfilectx
     object. If the file was removed, filectxfn return None for recent
     Mercurial. Moved files are represented by marking the source file
     removed and the new file added with copy information (see
     memfilectx).
 
     user receives the committer name and defaults to current
     repository username, date is the commit date in any format
     supported by dateutil.parsedate() and defaults to current date, extra
     is a dictionary of metadata or is left empty.
     """
 
     # Mercurial <= 3.1 expects the filectxfn to raise IOError for missing files.
     # Extensions that need to retain compatibility across Mercurial 3.1 can use
     # this field to determine what to do in filectxfn.
     _returnnoneformissingfiles = True
 
     def __init__(self, repo, parents, text, files, filectxfn, user=None,
                  date=None, extra=None, branch=None, editor=False):
         super(memctx, self).__init__(repo, text, user, date, extra)
         self._rev = None
         self._node = None
         parents = [(p or nullid) for p in parents]
         p1, p2 = parents
         self._parents = [self._repo[p] for p in (p1, p2)]
         files = sorted(set(files))
         self._files = files
         if branch is not None:
             self._extra['branch'] = encoding.fromlocal(branch)
         self.substate = {}
 
         if isinstance(filectxfn, patch.filestore):
             filectxfn = memfilefrompatch(filectxfn)
         elif not callable(filectxfn):
             # if store is not callable, wrap it in a function
             filectxfn = memfilefromctx(filectxfn)
 
         # memoizing increases performance for e.g. vcs convert scenarios.
         self._filectxfn = makecachingfilectxfn(filectxfn)
 
         if editor:
             self._text = editor(self._repo, self, [])
             self._repo.savecommitmessage(self._text)
 
     def filectx(self, path, filelog=None):
         """get a file context from the working directory
 
         Returns None if file doesn't exist and should be removed."""
         return self._filectxfn(self._repo, self, path)
 
     def commit(self):
         """commit context to the repo"""
         return self._repo.commitctx(self)
 
     @propertycache
     def _manifest(self):
         """generate a manifest based on the return values of filectxfn"""
 
         # keep this simple for now; just worry about p1
         pctx = self._parents[0]
         man = pctx.manifest().copy()
 
         for f in self._status.modified:
             p1node = nullid
             p2node = nullid
             p = pctx[f].parents() # if file isn't in pctx, check p2?
             if len(p) > 0:
                 p1node = p[0].filenode()
                 if len(p) > 1:
                     p2node = p[1].filenode()
             man[f] = revlog.hash(self[f].data(), p1node, p2node)
 
         for f in self._status.added:
             man[f] = revlog.hash(self[f].data(), nullid, nullid)
 
         for f in self._status.removed:
             if f in man:
                 del man[f]
 
         return man
 
     @propertycache
     def _status(self):
         """Calculate exact status from ``files`` specified at construction
         """
         man1 = self.p1().manifest()
         p2 = self._parents[1]
         # "1 < len(self._parents)" can't be used for checking
         # existence of the 2nd parent, because "memctx._parents" is
         # explicitly initialized by the list, of which length is 2.
         if p2.node() != nullid:
             man2 = p2.manifest()
             managing = lambda f: f in man1 or f in man2
         else:
             managing = lambda f: f in man1
 
         modified, added, removed = [], [], []
         for f in self._files:
             if not managing(f):
                 added.append(f)
             elif self[f]:
                 modified.append(f)
             else:
                 removed.append(f)
 
         return scmutil.status(modified, added, removed, [], [], [], [])
 
 class memfilectx(committablefilectx):
     """memfilectx represents an in-memory file to commit.
 
     See memctx and committablefilectx for more details.
     """
     def __init__(self, repo, changectx, path, data, islink=False,
                  isexec=False, copied=None):
         """
         path is the normalized file path relative to repository root.
         data is the file content as a string.
         islink is True if the file is a symbolic link.
         isexec is True if the file is executable.
         copied is the source file path if current file was copied in the
         revision being committed, or None."""
         super(memfilectx, self).__init__(repo, path, None, changectx)
         self._data = data
         self._flags = (islink and 'l' or '') + (isexec and 'x' or '')
         self._copied = None
         if copied:
             self._copied = (copied, nullid)
 
     def data(self):
         return self._data
 
     def remove(self, ignoremissing=False):
         """wraps unlink for a repo's working directory"""
         # need to figure out what to do here
         del self._changectx[self._path]
 
     def write(self, data, flags, **kwargs):
         """wraps repo.wwrite"""
         self._data = data
 
 class overlayfilectx(committablefilectx):
     """Like memfilectx but take an original filectx and optional parameters to
     override parts of it. This is useful when fctx.data() is expensive (i.e.
     flag processor is expensive) and raw data, flags, and filenode could be
     reused (ex. rebase or mode-only amend a REVIDX_EXTSTORED file).
     """
 
     def __init__(self, originalfctx, datafunc=None, path=None, flags=None,
                  copied=None, ctx=None):
         """originalfctx: filecontext to duplicate
 
         datafunc: None or a function to override data (file content). It is a
         function to be lazy. path, flags, copied, ctx: None or overridden value
 
         copied could be (path, rev), or False. copied could also be just path,
         and will be converted to (path, nullid). This simplifies some callers.
         """
 
         if path is None:
             path = originalfctx.path()
         if ctx is None:
             ctx = originalfctx.changectx()
             ctxmatch = lambda: True
         else:
             ctxmatch = lambda: ctx == originalfctx.changectx()
 
         repo = originalfctx.repo()
         flog = originalfctx.filelog()
         super(overlayfilectx, self).__init__(repo, path, flog, ctx)
 
         if copied is None:
             copied = originalfctx.renamed()
             copiedmatch = lambda: True
         else:
             if copied and not isinstance(copied, tuple):
                 # repo._filecommit will recalculate copyrev so nullid is okay
                 copied = (copied, nullid)
             copiedmatch = lambda: copied == originalfctx.renamed()
 
         # When data, copied (could affect data), ctx (could affect filelog
         # parents) are not overridden, rawdata, rawflags, and filenode may be
         # reused (repo._filecommit should double check filelog parents).
         #
         # path, flags are not hashed in filelog (but in manifestlog) so they do
         # not affect reusable here.
         #
         # If ctx or copied is overridden to a same value with originalfctx,
         # still consider it's reusable. originalfctx.renamed() may be a bit
         # expensive so it's not called unless necessary. Assuming datafunc is
         # always expensive, do not call it for this "reusable" test.
         reusable = datafunc is None and ctxmatch() and copiedmatch()
 
         if datafunc is None:
             datafunc = originalfctx.data
         if flags is None:
             flags = originalfctx.flags()
 
         self._datafunc = datafunc
         self._flags = flags
         self._copied = copied
 
         if reusable:
             # copy extra fields from originalfctx
             attrs = ['rawdata', 'rawflags', '_filenode', '_filerev']
             for attr_ in attrs:
                 if util.safehasattr(originalfctx, attr_):
                     setattr(self, attr_, getattr(originalfctx, attr_))
 
     def data(self):
         return self._datafunc()
 
 class metadataonlyctx(committablectx):
     """Like memctx but it's reusing the manifest of different commit.
     Intended to be used by lightweight operations that are creating
     metadata-only changes.
 
     Revision information is supplied at initialization time.  'repo' is the
     current localrepo, 'ctx' is original revision which manifest we're reuisng
     'parents' is a sequence of two parent revisions identifiers (pass None for
     every missing parent), 'text' is the commit.
 
     user receives the committer name and defaults to current repository
     username, date is the commit date in any format supported by
     dateutil.parsedate() and defaults to current date, extra is a dictionary of
     metadata or is left empty.
     """
     def __init__(self, repo, originalctx, parents=None, text=None, user=None,
                  date=None, extra=None, editor=False):
         if text is None:
             text = originalctx.description()
         super(metadataonlyctx, self).__init__(repo, text, user, date, extra)
         self._rev = None
         self._node = None
         self._originalctx = originalctx
         self._manifestnode = originalctx.manifestnode()
         if parents is None:
             parents = originalctx.parents()
         else:
             parents = [repo[p] for p in parents if p is not None]
         parents = parents[:]
         while len(parents) < 2:
             parents.append(repo[nullid])
         p1, p2 = self._parents = parents
 
         # sanity check to ensure that the reused manifest parents are
         # manifests of our commit parents
         mp1, mp2 = self.manifestctx().parents
         if p1 != nullid and p1.manifestnode() != mp1:
             raise RuntimeError('can\'t reuse the manifest: '
                                'its p1 doesn\'t match the new ctx p1')
         if p2 != nullid and p2.manifestnode() != mp2:
             raise RuntimeError('can\'t reuse the manifest: '
                                'its p2 doesn\'t match the new ctx p2')
 
         self._files = originalctx.files()
         self.substate = {}
 
         if editor:
             self._text = editor(self._repo, self, [])
             self._repo.savecommitmessage(self._text)
 
     def manifestnode(self):
         return self._manifestnode
 
     @property
     def _manifestctx(self):
         return self._repo.manifestlog[self._manifestnode]
 
     def filectx(self, path, filelog=None):
         return self._originalctx.filectx(path, filelog=filelog)
 
     def commit(self):
         """commit context to the repo"""
         return self._repo.commitctx(self)
 
     @property
     def _manifest(self):
         return self._originalctx.manifest()
 
     @propertycache
     def _status(self):
         """Calculate exact status from ``files`` specified in the ``origctx``
         and parents manifests.
         """
         man1 = self.p1().manifest()
         p2 = self._parents[1]
         # "1 < len(self._parents)" can't be used for checking
         # existence of the 2nd parent, because "metadataonlyctx._parents" is
         # explicitly initialized by the list, of which length is 2.
         if p2.node() != nullid:
             man2 = p2.manifest()
             managing = lambda f: f in man1 or f in man2
         else:
             managing = lambda f: f in man1
 
         modified, added, removed = [], [], []
         for f in self._files:
             if not managing(f):
                 added.append(f)
             elif f in self:
                 modified.append(f)
             else:
                 removed.append(f)
 
         return scmutil.status(modified, added, removed, [], [], [], [])
 
 class arbitraryfilectx(object):
     """Allows you to use filectx-like functions on a file in an arbitrary
     location on disk, possibly not in the working directory.
     """
     def __init__(self, path, repo=None):
         # Repo is optional because contrib/simplemerge uses this class.
         self._repo = repo
         self._path = path
 
     def cmp(self, fctx):
         # filecmp follows symlinks whereas `cmp` should not, so skip the fast
         # path if either side is a symlink.
         symlinks = ('l' in self.flags() or 'l' in fctx.flags())
         if not symlinks and isinstance(fctx, workingfilectx) and self._repo:
             # Add a fast-path for merge if both sides are disk-backed.
             # Note that filecmp uses the opposite return values (True if same)
             # from our cmp functions (True if different).
             return not filecmp.cmp(self.path(), self._repo.wjoin(fctx.path()))
         return self.data() != fctx.data()
 
     def path(self):
         return self._path
 
     def flags(self):
         return ''
 
     def data(self):
         return util.readfile(self._path)
 
     def decodeddata(self):
         with open(self._path, "rb") as f:
             return f.read()
 
     def remove(self):
         util.unlink(self._path)
 
     def write(self, data, flags, **kwargs):
         assert not flags
         with open(self._path, "w") as f:
             f.write(data)

mercurial/debugcommands.py

@@ -1,3166 +1,3166 b''
 # debugcommands.py - command processing for debug* commands
 #
 # Copyright 2005-2016 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import codecs
 import collections
 import difflib
 import errno
 import operator
 import os
 import random
 import re
 import socket
 import ssl
 import stat
 import string
 import subprocess
 import sys
 import time
 
 from .i18n import _
 from .node import (
     bin,
     hex,
     nullhex,
     nullid,
     nullrev,
     short,
 )
 from .thirdparty import (
     cbor,
 )
 from . import (
     bundle2,
     changegroup,
     cmdutil,
     color,
     context,
     dagparser,
     dagutil,
     encoding,
     error,
     exchange,
     extensions,
     filemerge,
     fileset,
     formatter,
     hg,
     httppeer,
     localrepo,
     lock as lockmod,
     logcmdutil,
     merge as mergemod,
     obsolete,
     obsutil,
     phases,
     policy,
     pvec,
     pycompat,
     registrar,
     repair,
     revlog,
     revset,
     revsetlang,
     scmutil,
     setdiscovery,
     simplemerge,
     sshpeer,
     sslutil,
     streamclone,
     templater,
     treediscovery,
     upgrade,
     url as urlmod,
     util,
     vfs as vfsmod,
     wireprotoframing,
     wireprotoserver,
     wireprotov2peer,
 )
 from .utils import (
     dateutil,
     procutil,
     stringutil,
 )
 
 release = lockmod.release
 
 command = registrar.command()
 
 @command('debugancestor', [], _('[INDEX] REV1 REV2'), optionalrepo=True)
 def debugancestor(ui, repo, *args):
     """find the ancestor revision of two revisions in a given index"""
     if len(args) == 3:
         index, rev1, rev2 = args
         r = revlog.revlog(vfsmod.vfs(pycompat.getcwd(), audit=False), index)
         lookup = r.lookup
     elif len(args) == 2:
         if not repo:
             raise error.Abort(_('there is no Mercurial repository here '
                                 '(.hg not found)'))
         rev1, rev2 = args
         r = repo.changelog
         lookup = repo.lookup
     else:
         raise error.Abort(_('either two or three arguments required'))
     a = r.ancestor(lookup(rev1), lookup(rev2))
     ui.write('%d:%s\n' % (r.rev(a), hex(a)))
 
 @command('debugapplystreamclonebundle', [], 'FILE')
 def debugapplystreamclonebundle(ui, repo, fname):
     """apply a stream clone bundle file"""
     f = hg.openpath(ui, fname)
     gen = exchange.readbundle(ui, f, fname)
     gen.apply(repo)
 
 @command('debugbuilddag',
     [('m', 'mergeable-file', None, _('add single file mergeable changes')),
     ('o', 'overwritten-file', None, _('add single file all revs overwrite')),
     ('n', 'new-file', None, _('add new file at each rev'))],
     _('[OPTION]... [TEXT]'))
 def debugbuilddag(ui, repo, text=None,
                   mergeable_file=False,
                   overwritten_file=False,
                   new_file=False):
     """builds a repo with a given DAG from scratch in the current empty repo
 
     The description of the DAG is read from stdin if not given on the
     command line.
 
     Elements:
 
      - "+n" is a linear run of n nodes based on the current default parent
      - "." is a single node based on the current default parent
      - "$" resets the default parent to null (implied at the start);
            otherwise the default parent is always the last node created
      - "<p" sets the default parent to the backref p
      - "*p" is a fork at parent p, which is a backref
      - "*p1/p2" is a merge of parents p1 and p2, which are backrefs
      - "/p2" is a merge of the preceding node and p2
      - ":tag" defines a local tag for the preceding node
      - "@branch" sets the named branch for subsequent nodes
      - "#...\\n" is a comment up to the end of the line
 
     Whitespace between the above elements is ignored.
 
     A backref is either
 
      - a number n, which references the node curr-n, where curr is the current
        node, or
      - the name of a local tag you placed earlier using ":tag", or
      - empty to denote the default parent.
 
     All string valued-elements are either strictly alphanumeric, or must
     be enclosed in double quotes ("..."), with "\\" as escape character.
     """
 
     if text is None:
         ui.status(_("reading DAG from stdin\n"))
         text = ui.fin.read()
 
     cl = repo.changelog
     if len(cl) > 0:
         raise error.Abort(_('repository is not empty'))
 
     # determine number of revs in DAG
     total = 0
     for type, data in dagparser.parsedag(text):
         if type == 'n':
             total += 1
 
     if mergeable_file:
         linesperrev = 2
         # make a file with k lines per rev
         initialmergedlines = ['%d' % i for i in xrange(0, total * linesperrev)]
         initialmergedlines.append("")
 
     tags = []
     progress = ui.makeprogress(_('building'), unit=_('revisions'),
                                total=total)
     with progress, repo.wlock(), repo.lock(), repo.transaction("builddag"):
         at = -1
         atbranch = 'default'
         nodeids = []
         id = 0
         progress.update(id)
         for type, data in dagparser.parsedag(text):
             if type == 'n':
                 ui.note(('node %s\n' % pycompat.bytestr(data)))
                 id, ps = data
 
                 files = []
                 filecontent = {}
 
                 p2 = None
                 if mergeable_file:
                     fn = "mf"
                     p1 = repo[ps[0]]
                     if len(ps) > 1:
                         p2 = repo[ps[1]]
                         pa = p1.ancestor(p2)
                         base, local, other = [x[fn].data() for x in (pa, p1,
                                                                      p2)]
                         m3 = simplemerge.Merge3Text(base, local, other)
                         ml = [l.strip() for l in m3.merge_lines()]
                         ml.append("")
                     elif at > 0:
                         ml = p1[fn].data().split("\n")
                     else:
                         ml = initialmergedlines
                     ml[id * linesperrev] += " r%i" % id
                     mergedtext = "\n".join(ml)
                     files.append(fn)
                     filecontent[fn] = mergedtext
 
                 if overwritten_file:
                     fn = "of"
                     files.append(fn)
                     filecontent[fn] = "r%i\n" % id
 
                 if new_file:
                     fn = "nf%i" % id
                     files.append(fn)
                     filecontent[fn] = "r%i\n" % id
                     if len(ps) > 1:
                         if not p2:
                             p2 = repo[ps[1]]
                         for fn in p2:
                             if fn.startswith("nf"):
                                 files.append(fn)
                                 filecontent[fn] = p2[fn].data()
 
                 def fctxfn(repo, cx, path):
                     if path in filecontent:
                         return context.memfilectx(repo, cx, path,
                                                   filecontent[path])
                     return None
 
                 if len(ps) == 0 or ps[0] < 0:
                     pars = [None, None]
                 elif len(ps) == 1:
                     pars = [nodeids[ps[0]], None]
                 else:
                     pars = [nodeids[p] for p in ps]
                 cx = context.memctx(repo, pars, "r%i" % id, files, fctxfn,
                                     date=(id, 0),
                                     user="debugbuilddag",
                                     extra={'branch': atbranch})
                 nodeid = repo.commitctx(cx)
                 nodeids.append(nodeid)
                 at = id
             elif type == 'l':
                 id, name = data
                 ui.note(('tag %s\n' % name))
                 tags.append("%s %s\n" % (hex(repo.changelog.node(id)), name))
             elif type == 'a':
                 ui.note(('branch %s\n' % data))
                 atbranch = data
             progress.update(id)
 
         if tags:
             repo.vfs.write("localtags", "".join(tags))
 
 def _debugchangegroup(ui, gen, all=None, indent=0, **opts):
     indent_string = ' ' * indent
     if all:
         ui.write(("%sformat: id, p1, p2, cset, delta base, len(delta)\n")
                  % indent_string)
 
         def showchunks(named):
             ui.write("\n%s%s\n" % (indent_string, named))
             for deltadata in gen.deltaiter():
                 node, p1, p2, cs, deltabase, delta, flags = deltadata
                 ui.write("%s%s %s %s %s %s %d\n" %
                          (indent_string, hex(node), hex(p1), hex(p2),
                           hex(cs), hex(deltabase), len(delta)))
 
         chunkdata = gen.changelogheader()
         showchunks("changelog")
         chunkdata = gen.manifestheader()
         showchunks("manifest")
         for chunkdata in iter(gen.filelogheader, {}):
             fname = chunkdata['filename']
             showchunks(fname)
     else:
         if isinstance(gen, bundle2.unbundle20):
             raise error.Abort(_('use debugbundle2 for this file'))
         chunkdata = gen.changelogheader()
         for deltadata in gen.deltaiter():
             node, p1, p2, cs, deltabase, delta, flags = deltadata
             ui.write("%s%s\n" % (indent_string, hex(node)))
 
 def _debugobsmarkers(ui, part, indent=0, **opts):
     """display version and markers contained in 'data'"""
     opts = pycompat.byteskwargs(opts)
     data = part.read()
     indent_string = ' ' * indent
     try:
         version, markers = obsolete._readmarkers(data)
     except error.UnknownVersion as exc:
         msg = "%sunsupported version: %s (%d bytes)\n"
         msg %= indent_string, exc.version, len(data)
         ui.write(msg)
     else:
         msg = "%sversion: %d (%d bytes)\n"
         msg %= indent_string, version, len(data)
         ui.write(msg)
         fm = ui.formatter('debugobsolete', opts)
         for rawmarker in sorted(markers):
             m = obsutil.marker(None, rawmarker)
             fm.startitem()
             fm.plain(indent_string)
             cmdutil.showmarker(fm, m)
         fm.end()
 
 def _debugphaseheads(ui, data, indent=0):
     """display version and markers contained in 'data'"""
     indent_string = ' ' * indent
     headsbyphase = phases.binarydecode(data)
     for phase in phases.allphases:
         for head in headsbyphase[phase]:
             ui.write(indent_string)
             ui.write('%s %s\n' % (hex(head), phases.phasenames[phase]))
 
 def _quasirepr(thing):
     if isinstance(thing, (dict, util.sortdict, collections.OrderedDict)):
         return '{%s}' % (
             b', '.join(b'%s: %s' % (k, thing[k]) for k in sorted(thing)))
     return pycompat.bytestr(repr(thing))
 
 def _debugbundle2(ui, gen, all=None, **opts):
     """lists the contents of a bundle2"""
     if not isinstance(gen, bundle2.unbundle20):
         raise error.Abort(_('not a bundle2 file'))
     ui.write(('Stream params: %s\n' % _quasirepr(gen.params)))
     parttypes = opts.get(r'part_type', [])
     for part in gen.iterparts():
         if parttypes and part.type not in parttypes:
             continue
         msg = '%s -- %s (mandatory: %r)\n'
         ui.write((msg % (part.type, _quasirepr(part.params), part.mandatory)))
         if part.type == 'changegroup':
             version = part.params.get('version', '01')
             cg = changegroup.getunbundler(version, part, 'UN')
             if not ui.quiet:
                 _debugchangegroup(ui, cg, all=all, indent=4, **opts)
         if part.type == 'obsmarkers':
             if not ui.quiet:
                 _debugobsmarkers(ui, part, indent=4, **opts)
         if part.type == 'phase-heads':
             if not ui.quiet:
                 _debugphaseheads(ui, part, indent=4)
 
 @command('debugbundle',
         [('a', 'all', None, _('show all details')),
          ('', 'part-type', [], _('show only the named part type')),
          ('', 'spec', None, _('print the bundlespec of the bundle'))],
         _('FILE'),
         norepo=True)
 def debugbundle(ui, bundlepath, all=None, spec=None, **opts):
     """lists the contents of a bundle"""
     with hg.openpath(ui, bundlepath) as f:
         if spec:
             spec = exchange.getbundlespec(ui, f)
             ui.write('%s\n' % spec)
             return
 
         gen = exchange.readbundle(ui, f, bundlepath)
         if isinstance(gen, bundle2.unbundle20):
             return _debugbundle2(ui, gen, all=all, **opts)
         _debugchangegroup(ui, gen, all=all, **opts)
 
 @command('debugcapabilities',
         [], _('PATH'),
         norepo=True)
 def debugcapabilities(ui, path, **opts):
     """lists the capabilities of a remote peer"""
     opts = pycompat.byteskwargs(opts)
     peer = hg.peer(ui, opts, path)
     caps = peer.capabilities()
     ui.write(('Main capabilities:\n'))
     for c in sorted(caps):
         ui.write(('  %s\n') % c)
     b2caps = bundle2.bundle2caps(peer)
     if b2caps:
         ui.write(('Bundle2 capabilities:\n'))
         for key, values in sorted(b2caps.iteritems()):
             ui.write(('  %s\n') % key)
             for v in values:
                 ui.write(('    %s\n') % v)
 
 @command('debugcheckstate', [], '')
 def debugcheckstate(ui, repo):
     """validate the correctness of the current dirstate"""
     parent1, parent2 = repo.dirstate.parents()
     m1 = repo[parent1].manifest()
     m2 = repo[parent2].manifest()
     errors = 0
     for f in repo.dirstate:
         state = repo.dirstate[f]
         if state in "nr" and f not in m1:
             ui.warn(_("%s in state %s, but not in manifest1\n") % (f, state))
             errors += 1
         if state in "a" and f in m1:
             ui.warn(_("%s in state %s, but also in manifest1\n") % (f, state))
             errors += 1
         if state in "m" and f not in m1 and f not in m2:
             ui.warn(_("%s in state %s, but not in either manifest\n") %
                     (f, state))
             errors += 1
     for f in m1:
         state = repo.dirstate[f]
         if state not in "nrm":
             ui.warn(_("%s in manifest1, but listed as state %s") % (f, state))
             errors += 1
     if errors:
         error = _(".hg/dirstate inconsistent with current parent's manifest")
         raise error.Abort(error)
 
 @command('debugcolor',
         [('', 'style', None, _('show all configured styles'))],
         'hg debugcolor')
 def debugcolor(ui, repo, **opts):
     """show available color, effects or style"""
     ui.write(('color mode: %s\n') % stringutil.pprint(ui._colormode))
     if opts.get(r'style'):
         return _debugdisplaystyle(ui)
     else:
         return _debugdisplaycolor(ui)
 
 def _debugdisplaycolor(ui):
     ui = ui.copy()
     ui._styles.clear()
     for effect in color._activeeffects(ui).keys():
         ui._styles[effect] = effect
     if ui._terminfoparams:
         for k, v in ui.configitems('color'):
             if k.startswith('color.'):
                 ui._styles[k] = k[6:]
             elif k.startswith('terminfo.'):
                 ui._styles[k] = k[9:]
     ui.write(_('available colors:\n'))
     # sort label with a '_' after the other to group '_background' entry.
     items = sorted(ui._styles.items(),
                    key=lambda i: ('_' in i[0], i[0], i[1]))
     for colorname, label in items:
         ui.write(('%s\n') % colorname, label=label)
 
 def _debugdisplaystyle(ui):
     ui.write(_('available style:\n'))
     if not ui._styles:
         return
     width = max(len(s) for s in ui._styles)
     for label, effects in sorted(ui._styles.items()):
         ui.write('%s' % label, label=label)
         if effects:
             # 50
             ui.write(': ')
             ui.write(' ' * (max(0, width - len(label))))
             ui.write(', '.join(ui.label(e, e) for e in effects.split()))
         ui.write('\n')
 
 @command('debugcreatestreamclonebundle', [], 'FILE')
 def debugcreatestreamclonebundle(ui, repo, fname):
     """create a stream clone bundle file
 
     Stream bundles are special bundles that are essentially archives of
     revlog files. They are commonly used for cloning very quickly.
     """
     # TODO we may want to turn this into an abort when this functionality
     # is moved into `hg bundle`.
     if phases.hassecret(repo):
         ui.warn(_('(warning: stream clone bundle will contain secret '
                   'revisions)\n'))
 
     requirements, gen = streamclone.generatebundlev1(repo)
     changegroup.writechunks(ui, gen, fname)
 
     ui.write(_('bundle requirements: %s\n') % ', '.join(sorted(requirements)))
 
 @command('debugdag',
     [('t', 'tags', None, _('use tags as labels')),
     ('b', 'branches', None, _('annotate with branch names')),
     ('', 'dots', None, _('use dots for runs')),
     ('s', 'spaces', None, _('separate elements by spaces'))],
     _('[OPTION]... [FILE [REV]...]'),
     optionalrepo=True)
 def debugdag(ui, repo, file_=None, *revs, **opts):
     """format the changelog or an index DAG as a concise textual description
 
     If you pass a revlog index, the revlog's DAG is emitted. If you list
     revision numbers, they get labeled in the output as rN.
 
     Otherwise, the changelog DAG of the current repo is emitted.
     """
     spaces = opts.get(r'spaces')
     dots = opts.get(r'dots')
     if file_:
         rlog = revlog.revlog(vfsmod.vfs(pycompat.getcwd(), audit=False),
                              file_)
         revs = set((int(r) for r in revs))
         def events():
             for r in rlog:
                 yield 'n', (r, list(p for p in rlog.parentrevs(r)
                                         if p != -1))
                 if r in revs:
                     yield 'l', (r, "r%i" % r)
     elif repo:
         cl = repo.changelog
         tags = opts.get(r'tags')
         branches = opts.get(r'branches')
         if tags:
             labels = {}
             for l, n in repo.tags().items():
                 labels.setdefault(cl.rev(n), []).append(l)
         def events():
             b = "default"
             for r in cl:
                 if branches:
                     newb = cl.read(cl.node(r))[5]['branch']
                     if newb != b:
                         yield 'a', newb
                         b = newb
                 yield 'n', (r, list(p for p in cl.parentrevs(r)
                                         if p != -1))
                 if tags:
                     ls = labels.get(r)
                     if ls:
                         for l in ls:
                             yield 'l', (r, l)
     else:
         raise error.Abort(_('need repo for changelog dag'))
 
     for line in dagparser.dagtextlines(events(),
                                        addspaces=spaces,
                                        wraplabels=True,
                                        wrapannotations=True,
                                        wrapnonlinear=dots,
                                        usedots=dots,
                                        maxlinewidth=70):
         ui.write(line)
         ui.write("\n")
 
 @command('debugdata', cmdutil.debugrevlogopts, _('-c|-m|FILE REV'))
 def debugdata(ui, repo, file_, rev=None, **opts):
     """dump the contents of a data file revision"""
     opts = pycompat.byteskwargs(opts)
     if opts.get('changelog') or opts.get('manifest') or opts.get('dir'):
         if rev is not None:
             raise error.CommandError('debugdata', _('invalid arguments'))
         file_, rev = None, file_
     elif rev is None:
         raise error.CommandError('debugdata', _('invalid arguments'))
     r = cmdutil.openrevlog(repo, 'debugdata', file_, opts)
     try:
         ui.write(r.revision(r.lookup(rev), raw=True))
     except KeyError:
         raise error.Abort(_('invalid revision identifier %s') % rev)
 
 @command('debugdate',
     [('e', 'extended', None, _('try extended date formats'))],
     _('[-e] DATE [RANGE]'),
     norepo=True, optionalrepo=True)
 def debugdate(ui, date, range=None, **opts):
     """parse and display a date"""
     if opts[r"extended"]:
         d = dateutil.parsedate(date, util.extendeddateformats)
     else:
         d = dateutil.parsedate(date)
     ui.write(("internal: %d %d\n") % d)
     ui.write(("standard: %s\n") % dateutil.datestr(d))
     if range:
         m = dateutil.matchdate(range)
         ui.write(("match: %s\n") % m(d[0]))
 
 @command('debugdeltachain',
     cmdutil.debugrevlogopts + cmdutil.formatteropts,
     _('-c|-m|FILE'),
     optionalrepo=True)
 def debugdeltachain(ui, repo, file_=None, **opts):
     """dump information about delta chains in a revlog
 
     Output can be templatized. Available template keywords are:
 
     :``rev``:       revision number
     :``chainid``:   delta chain identifier (numbered by unique base)
     :``chainlen``:  delta chain length to this revision
     :``prevrev``:   previous revision in delta chain
     :``deltatype``: role of delta / how it was computed
     :``compsize``:  compressed size of revision
     :``uncompsize``: uncompressed size of revision
     :``chainsize``: total size of compressed revisions in chain
     :``chainratio``: total chain size divided by uncompressed revision size
                     (new delta chains typically start at ratio 2.00)
     :``lindist``:   linear distance from base revision in delta chain to end
                     of this revision
     :``extradist``: total size of revisions not part of this delta chain from
                     base of delta chain to end of this revision; a measurement
                     of how much extra data we need to read/seek across to read
                     the delta chain for this revision
     :``extraratio``: extradist divided by chainsize; another representation of
                     how much unrelated data is needed to load this delta chain
 
     If the repository is configured to use the sparse read, additional keywords
     are available:
 
     :``readsize``:     total size of data read from the disk for a revision
                        (sum of the sizes of all the blocks)
     :``largestblock``: size of the largest block of data read from the disk
     :``readdensity``:  density of useful bytes in the data read from the disk
     :``srchunks``:  in how many data hunks the whole revision would be read
 
     The sparse read can be enabled with experimental.sparse-read = True
     """
     opts = pycompat.byteskwargs(opts)
     r = cmdutil.openrevlog(repo, 'debugdeltachain', file_, opts)
     index = r.index
     start = r.start
     length = r.length
     generaldelta = r.version & revlog.FLAG_GENERALDELTA
     withsparseread = getattr(r, '_withsparseread', False)
 
     def revinfo(rev):
         e = index[rev]
         compsize = e[1]
         uncompsize = e[2]
         chainsize = 0
 
         if generaldelta:
             if e[3] == e[5]:
                 deltatype = 'p1'
             elif e[3] == e[6]:
                 deltatype = 'p2'
             elif e[3] == rev - 1:
                 deltatype = 'prev'
             elif e[3] == rev:
                 deltatype = 'base'
             else:
                 deltatype = 'other'
         else:
             if e[3] == rev:
                 deltatype = 'base'
             else:
                 deltatype = 'prev'
 
         chain = r._deltachain(rev)[0]
         for iterrev in chain:
             e = index[iterrev]
             chainsize += e[1]
 
         return compsize, uncompsize, deltatype, chain, chainsize
 
     fm = ui.formatter('debugdeltachain', opts)
 
     fm.plain('    rev  chain# chainlen     prev   delta       '
              'size    rawsize  chainsize     ratio   lindist extradist '
              'extraratio')
     if withsparseread:
         fm.plain('   readsize largestblk rddensity srchunks')
     fm.plain('\n')
 
     chainbases = {}
     for rev in r:
         comp, uncomp, deltatype, chain, chainsize = revinfo(rev)
         chainbase = chain[0]
         chainid = chainbases.setdefault(chainbase, len(chainbases) + 1)
         basestart = start(chainbase)
         revstart = start(rev)
         lineardist = revstart + comp - basestart
         extradist = lineardist - chainsize
         try:
             prevrev = chain[-2]
         except IndexError:
             prevrev = -1
 
         chainratio = float(chainsize) / float(uncomp)
         extraratio = float(extradist) / float(chainsize)
 
         fm.startitem()
         fm.write('rev chainid chainlen prevrev deltatype compsize '
                  'uncompsize chainsize chainratio lindist extradist '
                  'extraratio',
                  '%7d %7d %8d %8d %7s %10d %10d %10d %9.5f %9d %9d %10.5f',
                  rev, chainid, len(chain), prevrev, deltatype, comp,
                  uncomp, chainsize, chainratio, lineardist, extradist,
                  extraratio,
                  rev=rev, chainid=chainid, chainlen=len(chain),
                  prevrev=prevrev, deltatype=deltatype, compsize=comp,
                  uncompsize=uncomp, chainsize=chainsize,
                  chainratio=chainratio, lindist=lineardist,
                  extradist=extradist, extraratio=extraratio)
         if withsparseread:
             readsize = 0
             largestblock = 0
             srchunks = 0
 
             for revschunk in revlog._slicechunk(r, chain):
                 srchunks += 1
                 blkend = start(revschunk[-1]) + length(revschunk[-1])
                 blksize = blkend - start(revschunk[0])
 
                 readsize += blksize
                 if largestblock < blksize:
                     largestblock = blksize
 
             readdensity = float(chainsize) / float(readsize)
 
             fm.write('readsize largestblock readdensity srchunks',
                      ' %10d %10d %9.5f %8d',
                      readsize, largestblock, readdensity, srchunks,
                      readsize=readsize, largestblock=largestblock,
                      readdensity=readdensity, srchunks=srchunks)
 
         fm.plain('\n')
 
     fm.end()
 
 @command('debugdirstate|debugstate',
     [('', 'nodates', None, _('do not display the saved mtime')),
     ('', 'datesort', None, _('sort by saved mtime'))],
     _('[OPTION]...'))
 def debugstate(ui, repo, **opts):
     """show the contents of the current dirstate"""
 
     nodates = opts.get(r'nodates')
     datesort = opts.get(r'datesort')
 
     timestr = ""
     if datesort:
         keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename
     else:
         keyfunc = None # sort by filename
     for file_, ent in sorted(repo.dirstate._map.iteritems(), key=keyfunc):
         if ent[3] == -1:
             timestr = 'unset               '
         elif nodates:
             timestr = 'set                 '
         else:
             timestr = time.strftime(r"%Y-%m-%d %H:%M:%S ",
                                     time.localtime(ent[3]))
             timestr = encoding.strtolocal(timestr)
         if ent[1] & 0o20000:
             mode = 'lnk'
         else:
             mode = '%3o' % (ent[1] & 0o777 & ~util.umask)
         ui.write("%c %s %10d %s%s\n" % (ent[0], mode, ent[2], timestr, file_))
     for f in repo.dirstate.copies():
         ui.write(_("copy: %s -> %s\n") % (repo.dirstate.copied(f), f))
 
 @command('debugdiscovery',
     [('', 'old', None, _('use old-style discovery')),
     ('', 'nonheads', None,
      _('use old-style discovery with non-heads included')),
     ('', 'rev', [], 'restrict discovery to this set of revs'),
     ] + cmdutil.remoteopts,
     _('[--rev REV] [OTHER]'))
 def debugdiscovery(ui, repo, remoteurl="default", **opts):
     """runs the changeset discovery protocol in isolation"""
     opts = pycompat.byteskwargs(opts)
     remoteurl, branches = hg.parseurl(ui.expandpath(remoteurl))
     remote = hg.peer(repo, opts, remoteurl)
     ui.status(_('comparing with %s\n') % util.hidepassword(remoteurl))
 
     # make sure tests are repeatable
     random.seed(12323)
 
     def doit(pushedrevs, remoteheads, remote=remote):
         if opts.get('old'):
             if not util.safehasattr(remote, 'branches'):
                 # enable in-client legacy support
                 remote = localrepo.locallegacypeer(remote.local())
             common, _in, hds = treediscovery.findcommonincoming(repo, remote,
                                                                 force=True)
             common = set(common)
             if not opts.get('nonheads'):
                 ui.write(("unpruned common: %s\n") %
                          " ".join(sorted(short(n) for n in common)))
                 dag = dagutil.revlogdag(repo.changelog)
                 all = dag.ancestorset(dag.internalizeall(common))
                 common = dag.externalizeall(dag.headsetofconnecteds(all))
         else:
             nodes = None
             if pushedrevs:
                 revs = scmutil.revrange(repo, pushedrevs)
                 nodes = [repo[r].node() for r in revs]
             common, any, hds = setdiscovery.findcommonheads(ui, repo, remote,
                                                             ancestorsof=nodes)
         common = set(common)
         rheads = set(hds)
         lheads = set(repo.heads())
         ui.write(("common heads: %s\n") %
                  " ".join(sorted(short(n) for n in common)))
         if lheads <= common:
             ui.write(("local is subset\n"))
         elif rheads <= common:
             ui.write(("remote is subset\n"))
 
     remoterevs, _checkout = hg.addbranchrevs(repo, remote, branches, revs=None)
     localrevs = opts['rev']
     doit(localrevs, remoterevs)
 
 _chunksize = 4 << 10
 
 @command('debugdownload',
     [
         ('o', 'output', '', _('path')),
     ],
     optionalrepo=True)
 def debugdownload(ui, repo, url, output=None, **opts):
     """download a resource using Mercurial logic and config
     """
     fh = urlmod.open(ui, url, output)
 
     dest = ui
     if output:
         dest = open(output, "wb", _chunksize)
     try:
         data = fh.read(_chunksize)
         while data:
             dest.write(data)
             data = fh.read(_chunksize)
     finally:
         if output:
             dest.close()
 
 @command('debugextensions', cmdutil.formatteropts, [], optionalrepo=True)
 def debugextensions(ui, repo, **opts):
     '''show information about active extensions'''
     opts = pycompat.byteskwargs(opts)
     exts = extensions.extensions(ui)
     hgver = util.version()
     fm = ui.formatter('debugextensions', opts)
     for extname, extmod in sorted(exts, key=operator.itemgetter(0)):
         isinternal = extensions.ismoduleinternal(extmod)
         extsource = pycompat.fsencode(extmod.__file__)
         if isinternal:
             exttestedwith = []  # never expose magic string to users
         else:
             exttestedwith = getattr(extmod, 'testedwith', '').split()
         extbuglink = getattr(extmod, 'buglink', None)
 
         fm.startitem()
 
         if ui.quiet or ui.verbose:
             fm.write('name', '%s\n', extname)
         else:
             fm.write('name', '%s', extname)
             if isinternal or hgver in exttestedwith:
                 fm.plain('\n')
             elif not exttestedwith:
                 fm.plain(_(' (untested!)\n'))
             else:
                 lasttestedversion = exttestedwith[-1]
                 fm.plain(' (%s!)\n' % lasttestedversion)
 
         fm.condwrite(ui.verbose and extsource, 'source',
                  _('  location: %s\n'), extsource or "")
 
         if ui.verbose:
             fm.plain(_('  bundled: %s\n') % ['no', 'yes'][isinternal])
         fm.data(bundled=isinternal)
 
         fm.condwrite(ui.verbose and exttestedwith, 'testedwith',
                      _('  tested with: %s\n'),
                      fm.formatlist(exttestedwith, name='ver'))
 
         fm.condwrite(ui.verbose and extbuglink, 'buglink',
                  _('  bug reporting: %s\n'), extbuglink or "")
 
     fm.end()
 
 @command('debugfileset',
     [('r', 'rev', '', _('apply the filespec on this revision'), _('REV')),
      ('', 'all-files', False,
       _('test files from all revisions and working directory'))],
     _('[-r REV] [--all-files] FILESPEC'))
 def debugfileset(ui, repo, expr, **opts):
     '''parse and apply a fileset specification'''
     opts = pycompat.byteskwargs(opts)
     ctx = scmutil.revsingle(repo, opts.get('rev'), None)
     if ui.verbose:
         tree = fileset.parse(expr)
         ui.note(fileset.prettyformat(tree), "\n")
 
     files = set()
     if opts['all_files']:
         for r in repo:
             c = repo[r]
             files.update(c.files())
             files.update(c.substate)
     if opts['all_files'] or ctx.rev() is None:
         wctx = repo[None]
         files.update(repo.dirstate.walk(scmutil.matchall(repo),
                                         subrepos=list(wctx.substate),
                                         unknown=True, ignored=True))
         files.update(wctx.substate)
     else:
         files.update(ctx.files())
         files.update(ctx.substate)
 
-    m = scmutil.matchfiles(repo, ctx.getfileset(expr))
+    m = ctx.matchfileset(expr)
     for f in sorted(files):
         if not m(f):
             continue
         ui.write("%s\n" % f)
 
 @command('debugformat',
          [] + cmdutil.formatteropts,
         _(''))
 def debugformat(ui, repo, **opts):
     """display format information about the current repository
 
     Use --verbose to get extra information about current config value and
     Mercurial default."""
     opts = pycompat.byteskwargs(opts)
     maxvariantlength = max(len(fv.name) for fv in upgrade.allformatvariant)
     maxvariantlength = max(len('format-variant'), maxvariantlength)
 
     def makeformatname(name):
         return '%s:' + (' ' * (maxvariantlength - len(name)))
 
     fm = ui.formatter('debugformat', opts)
     if fm.isplain():
         def formatvalue(value):
             if util.safehasattr(value, 'startswith'):
                 return value
             if value:
                 return 'yes'
             else:
                 return 'no'
     else:
         formatvalue = pycompat.identity
 
     fm.plain('format-variant')
     fm.plain(' ' * (maxvariantlength - len('format-variant')))
     fm.plain(' repo')
     if ui.verbose:
         fm.plain(' config default')
     fm.plain('\n')
     for fv in upgrade.allformatvariant:
         fm.startitem()
         repovalue = fv.fromrepo(repo)
         configvalue = fv.fromconfig(repo)
 
         if repovalue != configvalue:
             namelabel = 'formatvariant.name.mismatchconfig'
             repolabel = 'formatvariant.repo.mismatchconfig'
         elif repovalue != fv.default:
             namelabel = 'formatvariant.name.mismatchdefault'
             repolabel = 'formatvariant.repo.mismatchdefault'
         else:
             namelabel = 'formatvariant.name.uptodate'
             repolabel = 'formatvariant.repo.uptodate'
 
         fm.write('name', makeformatname(fv.name), fv.name,
                  label=namelabel)
         fm.write('repo', ' %3s', formatvalue(repovalue),
                  label=repolabel)
         if fv.default != configvalue:
             configlabel = 'formatvariant.config.special'
         else:
             configlabel = 'formatvariant.config.default'
         fm.condwrite(ui.verbose, 'config', ' %6s', formatvalue(configvalue),
                      label=configlabel)
         fm.condwrite(ui.verbose, 'default', ' %7s', formatvalue(fv.default),
                      label='formatvariant.default')
         fm.plain('\n')
     fm.end()
 
 @command('debugfsinfo', [], _('[PATH]'), norepo=True)
 def debugfsinfo(ui, path="."):
     """show information detected about current filesystem"""
     ui.write(('path: %s\n') % path)
     ui.write(('mounted on: %s\n') % (util.getfsmountpoint(path) or '(unknown)'))
     ui.write(('exec: %s\n') % (util.checkexec(path) and 'yes' or 'no'))
     ui.write(('fstype: %s\n') % (util.getfstype(path) or '(unknown)'))
     ui.write(('symlink: %s\n') % (util.checklink(path) and 'yes' or 'no'))
     ui.write(('hardlink: %s\n') % (util.checknlink(path) and 'yes' or 'no'))
     casesensitive = '(unknown)'
     try:
         with pycompat.namedtempfile(prefix='.debugfsinfo', dir=path) as f:
             casesensitive = util.fscasesensitive(f.name) and 'yes' or 'no'
     except OSError:
         pass
     ui.write(('case-sensitive: %s\n') % casesensitive)
 
 @command('debuggetbundle',
     [('H', 'head', [], _('id of head node'), _('ID')),
     ('C', 'common', [], _('id of common node'), _('ID')),
     ('t', 'type', 'bzip2', _('bundle compression type to use'), _('TYPE'))],
     _('REPO FILE [-H|-C ID]...'),
     norepo=True)
 def debuggetbundle(ui, repopath, bundlepath, head=None, common=None, **opts):
     """retrieves a bundle from a repo
 
     Every ID must be a full-length hex node id string. Saves the bundle to the
     given file.
     """
     opts = pycompat.byteskwargs(opts)
     repo = hg.peer(ui, opts, repopath)
     if not repo.capable('getbundle'):
         raise error.Abort("getbundle() not supported by target repository")
     args = {}
     if common:
         args[r'common'] = [bin(s) for s in common]
     if head:
         args[r'heads'] = [bin(s) for s in head]
     # TODO: get desired bundlecaps from command line.
     args[r'bundlecaps'] = None
     bundle = repo.getbundle('debug', **args)
 
     bundletype = opts.get('type', 'bzip2').lower()
     btypes = {'none': 'HG10UN',
               'bzip2': 'HG10BZ',
               'gzip': 'HG10GZ',
               'bundle2': 'HG20'}
     bundletype = btypes.get(bundletype)
     if bundletype not in bundle2.bundletypes:
         raise error.Abort(_('unknown bundle type specified with --type'))
     bundle2.writebundle(ui, bundle, bundlepath, bundletype)
 
 @command('debugignore', [], '[FILE]')
 def debugignore(ui, repo, *files, **opts):
     """display the combined ignore pattern and information about ignored files
 
     With no argument display the combined ignore pattern.
 
     Given space separated file names, shows if the given file is ignored and
     if so, show the ignore rule (file and line number) that matched it.
     """
     ignore = repo.dirstate._ignore
     if not files:
         # Show all the patterns
         ui.write("%s\n" % pycompat.byterepr(ignore))
     else:
         m = scmutil.match(repo[None], pats=files)
         for f in m.files():
             nf = util.normpath(f)
             ignored = None
             ignoredata = None
             if nf != '.':
                 if ignore(nf):
                     ignored = nf
                     ignoredata = repo.dirstate._ignorefileandline(nf)
                 else:
                     for p in util.finddirs(nf):
                         if ignore(p):
                             ignored = p
                             ignoredata = repo.dirstate._ignorefileandline(p)
                             break
             if ignored:
                 if ignored == nf:
                     ui.write(_("%s is ignored\n") % m.uipath(f))
                 else:
                     ui.write(_("%s is ignored because of "
                                "containing folder %s\n")
                              % (m.uipath(f), ignored))
                 ignorefile, lineno, line = ignoredata
                 ui.write(_("(ignore rule in %s, line %d: '%s')\n")
                          % (ignorefile, lineno, line))
             else:
                 ui.write(_("%s is not ignored\n") % m.uipath(f))
 
 @command('debugindex', cmdutil.debugrevlogopts +
     [('f', 'format', 0, _('revlog format'), _('FORMAT'))],
     _('[-f FORMAT] -c|-m|FILE'),
     optionalrepo=True)
 def debugindex(ui, repo, file_=None, **opts):
     """dump the contents of an index file"""
     opts = pycompat.byteskwargs(opts)
     r = cmdutil.openrevlog(repo, 'debugindex', file_, opts)
     format = opts.get('format', 0)
     if format not in (0, 1):
         raise error.Abort(_("unknown format %d") % format)
 
     if ui.debugflag:
         shortfn = hex
     else:
         shortfn = short
 
     # There might not be anything in r, so have a sane default
     idlen = 12
     for i in r:
         idlen = len(shortfn(r.node(i)))
         break
 
     if format == 0:
         if ui.verbose:
             ui.write(("   rev    offset  length linkrev"
                      " %s %s p2\n") % ("nodeid".ljust(idlen),
                                        "p1".ljust(idlen)))
         else:
             ui.write(("   rev linkrev %s %s p2\n") % (
                 "nodeid".ljust(idlen), "p1".ljust(idlen)))
     elif format == 1:
         if ui.verbose:
             ui.write(("   rev flag   offset   length     size   link     p1"
                       "     p2 %s\n") % "nodeid".rjust(idlen))
         else:
             ui.write(("   rev flag     size   link     p1     p2 %s\n") %
                      "nodeid".rjust(idlen))
 
     for i in r:
         node = r.node(i)
         if format == 0:
             try:
                 pp = r.parents(node)
             except Exception:
                 pp = [nullid, nullid]
             if ui.verbose:
                 ui.write("% 6d % 9d % 7d % 7d %s %s %s\n" % (
                         i, r.start(i), r.length(i), r.linkrev(i),
                         shortfn(node), shortfn(pp[0]), shortfn(pp[1])))
             else:
                 ui.write("% 6d % 7d %s %s %s\n" % (
                     i, r.linkrev(i), shortfn(node), shortfn(pp[0]),
                     shortfn(pp[1])))
         elif format == 1:
             pr = r.parentrevs(i)
             if ui.verbose:
                 ui.write("% 6d %04x % 8d % 8d % 8d % 6d % 6d % 6d %s\n" % (
                         i, r.flags(i), r.start(i), r.length(i), r.rawsize(i),
                         r.linkrev(i), pr[0], pr[1], shortfn(node)))
             else:
                 ui.write("% 6d %04x % 8d % 6d % 6d % 6d %s\n" % (
                     i, r.flags(i), r.rawsize(i), r.linkrev(i), pr[0], pr[1],
                     shortfn(node)))
 
 @command('debugindexdot', cmdutil.debugrevlogopts,
     _('-c|-m|FILE'), optionalrepo=True)
 def debugindexdot(ui, repo, file_=None, **opts):
     """dump an index DAG as a graphviz dot file"""
     opts = pycompat.byteskwargs(opts)
     r = cmdutil.openrevlog(repo, 'debugindexdot', file_, opts)
     ui.write(("digraph G {\n"))
     for i in r:
         node = r.node(i)
         pp = r.parents(node)
         ui.write("\t%d -> %d\n" % (r.rev(pp[0]), i))
         if pp[1] != nullid:
             ui.write("\t%d -> %d\n" % (r.rev(pp[1]), i))
     ui.write("}\n")
 
 @command('debuginstall', [] + cmdutil.formatteropts, '', norepo=True)
 def debuginstall(ui, **opts):
     '''test Mercurial installation
 
     Returns 0 on success.
     '''
     opts = pycompat.byteskwargs(opts)
 
     def writetemp(contents):
         (fd, name) = pycompat.mkstemp(prefix="hg-debuginstall-")
         f = os.fdopen(fd, r"wb")
         f.write(contents)
         f.close()
         return name
 
     problems = 0
 
     fm = ui.formatter('debuginstall', opts)
     fm.startitem()
 
     # encoding
     fm.write('encoding', _("checking encoding (%s)...\n"), encoding.encoding)
     err = None
     try:
         codecs.lookup(pycompat.sysstr(encoding.encoding))
     except LookupError as inst:
         err = stringutil.forcebytestr(inst)
         problems += 1
     fm.condwrite(err, 'encodingerror', _(" %s\n"
                  " (check that your locale is properly set)\n"), err)
 
     # Python
     fm.write('pythonexe', _("checking Python executable (%s)\n"),
              pycompat.sysexecutable)
     fm.write('pythonver', _("checking Python version (%s)\n"),
              ("%d.%d.%d" % sys.version_info[:3]))
     fm.write('pythonlib', _("checking Python lib (%s)...\n"),
              os.path.dirname(pycompat.fsencode(os.__file__)))
 
     security = set(sslutil.supportedprotocols)
     if sslutil.hassni:
         security.add('sni')
 
     fm.write('pythonsecurity', _("checking Python security support (%s)\n"),
              fm.formatlist(sorted(security), name='protocol',
                            fmt='%s', sep=','))
 
     # These are warnings, not errors. So don't increment problem count. This
     # may change in the future.
     if 'tls1.2' not in security:
         fm.plain(_('  TLS 1.2 not supported by Python install; '
                    'network connections lack modern security\n'))
     if 'sni' not in security:
         fm.plain(_('  SNI not supported by Python install; may have '
                    'connectivity issues with some servers\n'))
 
     # TODO print CA cert info
 
     # hg version
     hgver = util.version()
     fm.write('hgver', _("checking Mercurial version (%s)\n"),
              hgver.split('+')[0])
     fm.write('hgverextra', _("checking Mercurial custom build (%s)\n"),
              '+'.join(hgver.split('+')[1:]))
 
     # compiled modules
     fm.write('hgmodulepolicy', _("checking module policy (%s)\n"),
              policy.policy)
     fm.write('hgmodules', _("checking installed modules (%s)...\n"),
              os.path.dirname(pycompat.fsencode(__file__)))
 
     if policy.policy in ('c', 'allow'):
         err = None
         try:
             from .cext import (
                 base85,
                 bdiff,
                 mpatch,
                 osutil,
             )
             dir(bdiff), dir(mpatch), dir(base85), dir(osutil) # quiet pyflakes
         except Exception as inst:
             err = stringutil.forcebytestr(inst)
             problems += 1
         fm.condwrite(err, 'extensionserror', " %s\n", err)
 
     compengines = util.compengines._engines.values()
     fm.write('compengines', _('checking registered compression engines (%s)\n'),
              fm.formatlist(sorted(e.name() for e in compengines),
                            name='compengine', fmt='%s', sep=', '))
     fm.write('compenginesavail', _('checking available compression engines '
                                    '(%s)\n'),
              fm.formatlist(sorted(e.name() for e in compengines
                                   if e.available()),
                            name='compengine', fmt='%s', sep=', '))
     wirecompengines = util.compengines.supportedwireengines(util.SERVERROLE)
     fm.write('compenginesserver', _('checking available compression engines '
                                     'for wire protocol (%s)\n'),
              fm.formatlist([e.name() for e in wirecompengines
                             if e.wireprotosupport()],
                            name='compengine', fmt='%s', sep=', '))
     re2 = 'missing'
     if util._re2:
         re2 = 'available'
     fm.plain(_('checking "re2" regexp engine (%s)\n') % re2)
     fm.data(re2=bool(util._re2))
 
     # templates
     p = templater.templatepaths()
     fm.write('templatedirs', 'checking templates (%s)...\n', ' '.join(p))
     fm.condwrite(not p, '', _(" no template directories found\n"))
     if p:
         m = templater.templatepath("map-cmdline.default")
         if m:
             # template found, check if it is working
             err = None
             try:
                 templater.templater.frommapfile(m)
             except Exception as inst:
                 err = stringutil.forcebytestr(inst)
                 p = None
             fm.condwrite(err, 'defaulttemplateerror', " %s\n", err)
         else:
             p = None
         fm.condwrite(p, 'defaulttemplate',
                      _("checking default template (%s)\n"), m)
         fm.condwrite(not m, 'defaulttemplatenotfound',
                      _(" template '%s' not found\n"), "default")
     if not p:
         problems += 1
     fm.condwrite(not p, '',
                  _(" (templates seem to have been installed incorrectly)\n"))
 
     # editor
     editor = ui.geteditor()
     editor = util.expandpath(editor)
     editorbin = procutil.shellsplit(editor)[0]
     fm.write('editor', _("checking commit editor... (%s)\n"), editorbin)
     cmdpath = procutil.findexe(editorbin)
     fm.condwrite(not cmdpath and editor == 'vi', 'vinotfound',
                  _(" No commit editor set and can't find %s in PATH\n"
                    " (specify a commit editor in your configuration"
                    " file)\n"), not cmdpath and editor == 'vi' and editorbin)
     fm.condwrite(not cmdpath and editor != 'vi', 'editornotfound',
                  _(" Can't find editor '%s' in PATH\n"
                    " (specify a commit editor in your configuration"
                    " file)\n"), not cmdpath and editorbin)
     if not cmdpath and editor != 'vi':
         problems += 1
 
     # check username
     username = None
     err = None
     try:
         username = ui.username()
     except error.Abort as e:
         err = stringutil.forcebytestr(e)
         problems += 1
 
     fm.condwrite(username, 'username',  _("checking username (%s)\n"), username)
     fm.condwrite(err, 'usernameerror', _("checking username...\n %s\n"
         " (specify a username in your configuration file)\n"), err)
 
     fm.condwrite(not problems, '',
                  _("no problems detected\n"))
     if not problems:
         fm.data(problems=problems)
     fm.condwrite(problems, 'problems',
                  _("%d problems detected,"
                    " please check your install!\n"), problems)
     fm.end()
 
     return problems
 
 @command('debugknown', [], _('REPO ID...'), norepo=True)
 def debugknown(ui, repopath, *ids, **opts):
     """test whether node ids are known to a repo
 
     Every ID must be a full-length hex node id string. Returns a list of 0s
     and 1s indicating unknown/known.
     """
     opts = pycompat.byteskwargs(opts)
     repo = hg.peer(ui, opts, repopath)
     if not repo.capable('known'):
         raise error.Abort("known() not supported by target repository")
     flags = repo.known([bin(s) for s in ids])
     ui.write("%s\n" % ("".join([f and "1" or "0" for f in flags])))
 
 @command('debuglabelcomplete', [], _('LABEL...'))
 def debuglabelcomplete(ui, repo, *args):
     '''backwards compatibility with old bash completion scripts (DEPRECATED)'''
     debugnamecomplete(ui, repo, *args)
 
 @command('debuglocks',
          [('L', 'force-lock', None, _('free the store lock (DANGEROUS)')),
           ('W', 'force-wlock', None,
            _('free the working state lock (DANGEROUS)')),
           ('s', 'set-lock', None, _('set the store lock until stopped')),
           ('S', 'set-wlock', None,
            _('set the working state lock until stopped'))],
          _('[OPTION]...'))
 def debuglocks(ui, repo, **opts):
     """show or modify state of locks
 
     By default, this command will show which locks are held. This
     includes the user and process holding the lock, the amount of time
     the lock has been held, and the machine name where the process is
     running if it's not local.
 
     Locks protect the integrity of Mercurial's data, so should be
     treated with care. System crashes or other interruptions may cause
     locks to not be properly released, though Mercurial will usually
     detect and remove such stale locks automatically.
 
     However, detecting stale locks may not always be possible (for
     instance, on a shared filesystem). Removing locks may also be
     blocked by filesystem permissions.
 
     Setting a lock will prevent other commands from changing the data.
     The command will wait until an interruption (SIGINT, SIGTERM, ...) occurs.
     The set locks are removed when the command exits.
 
     Returns 0 if no locks are held.
 
     """
 
     if opts.get(r'force_lock'):
         repo.svfs.unlink('lock')
     if opts.get(r'force_wlock'):
         repo.vfs.unlink('wlock')
     if opts.get(r'force_lock') or opts.get(r'force_wlock'):
         return 0
 
     locks = []
     try:
         if opts.get(r'set_wlock'):
             try:
                 locks.append(repo.wlock(False))
             except error.LockHeld:
                 raise error.Abort(_('wlock is already held'))
         if opts.get(r'set_lock'):
             try:
                 locks.append(repo.lock(False))
             except error.LockHeld:
                 raise error.Abort(_('lock is already held'))
         if len(locks):
             ui.promptchoice(_("ready to release the lock (y)? $$ &Yes"))
             return 0
     finally:
         release(*locks)
 
     now = time.time()
     held = 0
 
     def report(vfs, name, method):
         # this causes stale locks to get reaped for more accurate reporting
         try:
             l = method(False)
         except error.LockHeld:
             l = None
 
         if l:
             l.release()
         else:
             try:
                 st = vfs.lstat(name)
                 age = now - st[stat.ST_MTIME]
                 user = util.username(st.st_uid)
                 locker = vfs.readlock(name)
                 if ":" in locker:
                     host, pid = locker.split(':')
                     if host == socket.gethostname():
                         locker = 'user %s, process %s' % (user, pid)
                     else:
                         locker = 'user %s, process %s, host %s' \
                                  % (user, pid, host)
                 ui.write(("%-6s %s (%ds)\n") % (name + ":", locker, age))
                 return 1
             except OSError as e:
                 if e.errno != errno.ENOENT:
                     raise
 
         ui.write(("%-6s free\n") % (name + ":"))
         return 0
 
     held += report(repo.svfs, "lock", repo.lock)
     held += report(repo.vfs, "wlock", repo.wlock)
 
     return held
 
 @command('debugmergestate', [], '')
 def debugmergestate(ui, repo, *args):
     """print merge state
 
     Use --verbose to print out information about whether v1 or v2 merge state
     was chosen."""
     def _hashornull(h):
         if h == nullhex:
             return 'null'
         else:
             return h
 
     def printrecords(version):
         ui.write(('* version %d records\n') % version)
         if version == 1:
             records = v1records
         else:
             records = v2records
 
         for rtype, record in records:
             # pretty print some record types
             if rtype == 'L':
                 ui.write(('local: %s\n') % record)
             elif rtype == 'O':
                 ui.write(('other: %s\n') % record)
             elif rtype == 'm':
                 driver, mdstate = record.split('\0', 1)
                 ui.write(('merge driver: %s (state "%s")\n')
                          % (driver, mdstate))
             elif rtype in 'FDC':
                 r = record.split('\0')
                 f, state, hash, lfile, afile, anode, ofile = r[0:7]
                 if version == 1:
                     onode = 'not stored in v1 format'
                     flags = r[7]
                 else:
                     onode, flags = r[7:9]
                 ui.write(('file: %s (record type "%s", state "%s", hash %s)\n')
                          % (f, rtype, state, _hashornull(hash)))
                 ui.write(('  local path: %s (flags "%s")\n') % (lfile, flags))
                 ui.write(('  ancestor path: %s (node %s)\n')
                          % (afile, _hashornull(anode)))
                 ui.write(('  other path: %s (node %s)\n')
                          % (ofile, _hashornull(onode)))
             elif rtype == 'f':
                 filename, rawextras = record.split('\0', 1)
                 extras = rawextras.split('\0')
                 i = 0
                 extrastrings = []
                 while i < len(extras):
                     extrastrings.append('%s = %s' % (extras[i], extras[i + 1]))
                     i += 2
 
                 ui.write(('file extras: %s (%s)\n')
                          % (filename, ', '.join(extrastrings)))
             elif rtype == 'l':
                 labels = record.split('\0', 2)
                 labels = [l for l in labels if len(l) > 0]
                 ui.write(('labels:\n'))
                 ui.write(('  local: %s\n' % labels[0]))
                 ui.write(('  other: %s\n' % labels[1]))
                 if len(labels) > 2:
                     ui.write(('  base:  %s\n' % labels[2]))
             else:
                 ui.write(('unrecognized entry: %s\t%s\n')
                          % (rtype, record.replace('\0', '\t')))
 
     # Avoid mergestate.read() since it may raise an exception for unsupported
     # merge state records. We shouldn't be doing this, but this is OK since this
     # command is pretty low-level.
     ms = mergemod.mergestate(repo)
 
     # sort so that reasonable information is on top
     v1records = ms._readrecordsv1()
     v2records = ms._readrecordsv2()
     order = 'LOml'
     def key(r):
         idx = order.find(r[0])
         if idx == -1:
             return (1, r[1])
         else:
             return (0, idx)
     v1records.sort(key=key)
     v2records.sort(key=key)
 
     if not v1records and not v2records:
         ui.write(('no merge state found\n'))
     elif not v2records:
         ui.note(('no version 2 merge state\n'))
         printrecords(1)
     elif ms._v1v2match(v1records, v2records):
         ui.note(('v1 and v2 states match: using v2\n'))
         printrecords(2)
     else:
         ui.note(('v1 and v2 states mismatch: using v1\n'))
         printrecords(1)
         if ui.verbose:
             printrecords(2)
 
 @command('debugnamecomplete', [], _('NAME...'))
 def debugnamecomplete(ui, repo, *args):
     '''complete "names" - tags, open branch names, bookmark names'''
 
     names = set()
     # since we previously only listed open branches, we will handle that
     # specially (after this for loop)
     for name, ns in repo.names.iteritems():
         if name != 'branches':
             names.update(ns.listnames(repo))
     names.update(tag for (tag, heads, tip, closed)
                  in repo.branchmap().iterbranches() if not closed)
     completions = set()
     if not args:
         args = ['']
     for a in args:
         completions.update(n for n in names if n.startswith(a))
     ui.write('\n'.join(sorted(completions)))
     ui.write('\n')
 
 @command('debugobsolete',
         [('', 'flags', 0, _('markers flag')),
          ('', 'record-parents', False,
           _('record parent information for the precursor')),
          ('r', 'rev', [], _('display markers relevant to REV')),
          ('', 'exclusive', False, _('restrict display to markers only '
                                     'relevant to REV')),
          ('', 'index', False, _('display index of the marker')),
          ('', 'delete', [], _('delete markers specified by indices')),
         ] + cmdutil.commitopts2 + cmdutil.formatteropts,
          _('[OBSOLETED [REPLACEMENT ...]]'))
 def debugobsolete(ui, repo, precursor=None, *successors, **opts):
     """create arbitrary obsolete marker
 
     With no arguments, displays the list of obsolescence markers."""
 
     opts = pycompat.byteskwargs(opts)
 
     def parsenodeid(s):
         try:
             # We do not use revsingle/revrange functions here to accept
             # arbitrary node identifiers, possibly not present in the
             # local repository.
             n = bin(s)
             if len(n) != len(nullid):
                 raise TypeError()
             return n
         except TypeError:
             raise error.Abort('changeset references must be full hexadecimal '
                              'node identifiers')
 
     if opts.get('delete'):
         indices = []
         for v in opts.get('delete'):
             try:
                 indices.append(int(v))
             except ValueError:
                 raise error.Abort(_('invalid index value: %r') % v,
                                   hint=_('use integers for indices'))
 
         if repo.currenttransaction():
             raise error.Abort(_('cannot delete obsmarkers in the middle '
                                 'of transaction.'))
 
         with repo.lock():
             n = repair.deleteobsmarkers(repo.obsstore, indices)
             ui.write(_('deleted %i obsolescence markers\n') % n)
 
         return
 
     if precursor is not None:
         if opts['rev']:
             raise error.Abort('cannot select revision when creating marker')
         metadata = {}
         metadata['user'] = opts['user'] or ui.username()
         succs = tuple(parsenodeid(succ) for succ in successors)
         l = repo.lock()
         try:
             tr = repo.transaction('debugobsolete')
             try:
                 date = opts.get('date')
                 if date:
                     date = dateutil.parsedate(date)
                 else:
                     date = None
                 prec = parsenodeid(precursor)
                 parents = None
                 if opts['record_parents']:
                     if prec not in repo.unfiltered():
                         raise error.Abort('cannot used --record-parents on '
                                          'unknown changesets')
                     parents = repo.unfiltered()[prec].parents()
                     parents = tuple(p.node() for p in parents)
                 repo.obsstore.create(tr, prec, succs, opts['flags'],
                                      parents=parents, date=date,
                                      metadata=metadata, ui=ui)
                 tr.close()
             except ValueError as exc:
                 raise error.Abort(_('bad obsmarker input: %s') %
                                   pycompat.bytestr(exc))
             finally:
                 tr.release()
         finally:
             l.release()
     else:
         if opts['rev']:
             revs = scmutil.revrange(repo, opts['rev'])
             nodes = [repo[r].node() for r in revs]
             markers = list(obsutil.getmarkers(repo, nodes=nodes,
                                                exclusive=opts['exclusive']))
             markers.sort(key=lambda x: x._data)
         else:
             markers = obsutil.getmarkers(repo)
 
         markerstoiter = markers
         isrelevant = lambda m: True
         if opts.get('rev') and opts.get('index'):
             markerstoiter = obsutil.getmarkers(repo)
             markerset = set(markers)
             isrelevant = lambda m: m in markerset
 
         fm = ui.formatter('debugobsolete', opts)
         for i, m in enumerate(markerstoiter):
             if not isrelevant(m):
                 # marker can be irrelevant when we're iterating over a set
                 # of markers (markerstoiter) which is bigger than the set
                 # of markers we want to display (markers)
                 # this can happen if both --index and --rev options are
                 # provided and thus we need to iterate over all of the markers
                 # to get the correct indices, but only display the ones that
                 # are relevant to --rev value
                 continue
             fm.startitem()
             ind = i if opts.get('index') else None
             cmdutil.showmarker(fm, m, index=ind)
         fm.end()
 
 @command('debugpathcomplete',
          [('f', 'full', None, _('complete an entire path')),
           ('n', 'normal', None, _('show only normal files')),
           ('a', 'added', None, _('show only added files')),
           ('r', 'removed', None, _('show only removed files'))],
          _('FILESPEC...'))
 def debugpathcomplete(ui, repo, *specs, **opts):
     '''complete part or all of a tracked path
 
     This command supports shells that offer path name completion. It
     currently completes only files already known to the dirstate.
 
     Completion extends only to the next path segment unless
     --full is specified, in which case entire paths are used.'''
 
     def complete(path, acceptable):
         dirstate = repo.dirstate
         spec = os.path.normpath(os.path.join(pycompat.getcwd(), path))
         rootdir = repo.root + pycompat.ossep
         if spec != repo.root and not spec.startswith(rootdir):
             return [], []
         if os.path.isdir(spec):
             spec += '/'
         spec = spec[len(rootdir):]
         fixpaths = pycompat.ossep != '/'
         if fixpaths:
             spec = spec.replace(pycompat.ossep, '/')
         speclen = len(spec)
         fullpaths = opts[r'full']
         files, dirs = set(), set()
         adddir, addfile = dirs.add, files.add
         for f, st in dirstate.iteritems():
             if f.startswith(spec) and st[0] in acceptable:
                 if fixpaths:
                     f = f.replace('/', pycompat.ossep)
                 if fullpaths:
                     addfile(f)
                     continue
                 s = f.find(pycompat.ossep, speclen)
                 if s >= 0:
                     adddir(f[:s])
                 else:
                     addfile(f)
         return files, dirs
 
     acceptable = ''
     if opts[r'normal']:
         acceptable += 'nm'
     if opts[r'added']:
         acceptable += 'a'
     if opts[r'removed']:
         acceptable += 'r'
     cwd = repo.getcwd()
     if not specs:
         specs = ['.']
 
     files, dirs = set(), set()
     for spec in specs:
         f, d = complete(spec, acceptable or 'nmar')
         files.update(f)
         dirs.update(d)
     files.update(dirs)
     ui.write('\n'.join(repo.pathto(p, cwd) for p in sorted(files)))
     ui.write('\n')
 
 @command('debugpeer', [], _('PATH'), norepo=True)
 def debugpeer(ui, path):
     """establish a connection to a peer repository"""
     # Always enable peer request logging. Requires --debug to display
     # though.
     overrides = {
         ('devel', 'debug.peer-request'): True,
     }
 
     with ui.configoverride(overrides):
         peer = hg.peer(ui, {}, path)
 
         local = peer.local() is not None
         canpush = peer.canpush()
 
         ui.write(_('url: %s\n') % peer.url())
         ui.write(_('local: %s\n') % (_('yes') if local else _('no')))
         ui.write(_('pushable: %s\n') % (_('yes') if canpush else _('no')))
 
 @command('debugpickmergetool',
         [('r', 'rev', '', _('check for files in this revision'), _('REV')),
          ('', 'changedelete', None, _('emulate merging change and delete')),
         ] + cmdutil.walkopts + cmdutil.mergetoolopts,
         _('[PATTERN]...'),
         inferrepo=True)
 def debugpickmergetool(ui, repo, *pats, **opts):
     """examine which merge tool is chosen for specified file
 
     As described in :hg:`help merge-tools`, Mercurial examines
     configurations below in this order to decide which merge tool is
     chosen for specified file.
 
     1. ``--tool`` option
     2. ``HGMERGE`` environment variable
     3. configurations in ``merge-patterns`` section
     4. configuration of ``ui.merge``
     5. configurations in ``merge-tools`` section
     6. ``hgmerge`` tool (for historical reason only)
     7. default tool for fallback (``:merge`` or ``:prompt``)
 
     This command writes out examination result in the style below::
 
         FILE = MERGETOOL
 
     By default, all files known in the first parent context of the
     working directory are examined. Use file patterns and/or -I/-X
     options to limit target files. -r/--rev is also useful to examine
     files in another context without actual updating to it.
 
     With --debug, this command shows warning messages while matching
     against ``merge-patterns`` and so on, too. It is recommended to
     use this option with explicit file patterns and/or -I/-X options,
     because this option increases amount of output per file according
     to configurations in hgrc.
 
     With -v/--verbose, this command shows configurations below at
     first (only if specified).
 
     - ``--tool`` option
     - ``HGMERGE`` environment variable
     - configuration of ``ui.merge``
 
     If merge tool is chosen before matching against
     ``merge-patterns``, this command can't show any helpful
     information, even with --debug. In such case, information above is
     useful to know why a merge tool is chosen.
     """
     opts = pycompat.byteskwargs(opts)
     overrides = {}
     if opts['tool']:
         overrides[('ui', 'forcemerge')] = opts['tool']
         ui.note(('with --tool %r\n') % (pycompat.bytestr(opts['tool'])))
 
     with ui.configoverride(overrides, 'debugmergepatterns'):
         hgmerge = encoding.environ.get("HGMERGE")
         if hgmerge is not None:
             ui.note(('with HGMERGE=%r\n') % (pycompat.bytestr(hgmerge)))
         uimerge = ui.config("ui", "merge")
         if uimerge:
             ui.note(('with ui.merge=%r\n') % (pycompat.bytestr(uimerge)))
 
         ctx = scmutil.revsingle(repo, opts.get('rev'))
         m = scmutil.match(ctx, pats, opts)
         changedelete = opts['changedelete']
         for path in ctx.walk(m):
             fctx = ctx[path]
             try:
                 if not ui.debugflag:
                     ui.pushbuffer(error=True)
                 tool, toolpath = filemerge._picktool(repo, ui, path,
                                                      fctx.isbinary(),
                                                      'l' in fctx.flags(),
                                                      changedelete)
             finally:
                 if not ui.debugflag:
                     ui.popbuffer()
             ui.write(('%s = %s\n') % (path, tool))
 
 @command('debugpushkey', [], _('REPO NAMESPACE [KEY OLD NEW]'), norepo=True)
 def debugpushkey(ui, repopath, namespace, *keyinfo, **opts):
     '''access the pushkey key/value protocol
 
     With two args, list the keys in the given namespace.
 
     With five args, set a key to new if it currently is set to old.
     Reports success or failure.
     '''
 
     target = hg.peer(ui, {}, repopath)
     if keyinfo:
         key, old, new = keyinfo
         with target.commandexecutor() as e:
             r = e.callcommand('pushkey', {
                 'namespace': namespace,
                 'key': key,
                 'old': old,
                 'new': new,
             }).result()
 
         ui.status(pycompat.bytestr(r) + '\n')
         return not r
     else:
         for k, v in sorted(target.listkeys(namespace).iteritems()):
             ui.write("%s\t%s\n" % (stringutil.escapestr(k),
                                    stringutil.escapestr(v)))
 
 @command('debugpvec', [], _('A B'))
 def debugpvec(ui, repo, a, b=None):
     ca = scmutil.revsingle(repo, a)
     cb = scmutil.revsingle(repo, b)
     pa = pvec.ctxpvec(ca)
     pb = pvec.ctxpvec(cb)
     if pa == pb:
         rel = "="
     elif pa > pb:
         rel = ">"
     elif pa < pb:
         rel = "<"
     elif pa | pb:
         rel = "|"
     ui.write(_("a: %s\n") % pa)
     ui.write(_("b: %s\n") % pb)
     ui.write(_("depth(a): %d depth(b): %d\n") % (pa._depth, pb._depth))
     ui.write(_("delta: %d hdist: %d distance: %d relation: %s\n") %
              (abs(pa._depth - pb._depth), pvec._hamming(pa._vec, pb._vec),
               pa.distance(pb), rel))
 
 @command('debugrebuilddirstate|debugrebuildstate',
     [('r', 'rev', '', _('revision to rebuild to'), _('REV')),
      ('', 'minimal', None, _('only rebuild files that are inconsistent with '
                              'the working copy parent')),
     ],
     _('[-r REV]'))
 def debugrebuilddirstate(ui, repo, rev, **opts):
     """rebuild the dirstate as it would look like for the given revision
 
     If no revision is specified the first current parent will be used.
 
     The dirstate will be set to the files of the given revision.
     The actual working directory content or existing dirstate
     information such as adds or removes is not considered.
 
     ``minimal`` will only rebuild the dirstate status for files that claim to be
     tracked but are not in the parent manifest, or that exist in the parent
     manifest but are not in the dirstate. It will not change adds, removes, or
     modified files that are in the working copy parent.
 
     One use of this command is to make the next :hg:`status` invocation
     check the actual file content.
     """
     ctx = scmutil.revsingle(repo, rev)
     with repo.wlock():
         dirstate = repo.dirstate
         changedfiles = None
         # See command doc for what minimal does.
         if opts.get(r'minimal'):
             manifestfiles = set(ctx.manifest().keys())
             dirstatefiles = set(dirstate)
             manifestonly = manifestfiles - dirstatefiles
             dsonly = dirstatefiles - manifestfiles
             dsnotadded = set(f for f in dsonly if dirstate[f] != 'a')
             changedfiles = manifestonly | dsnotadded
 
         dirstate.rebuild(ctx.node(), ctx.manifest(), changedfiles)
 
 @command('debugrebuildfncache', [], '')
 def debugrebuildfncache(ui, repo):
     """rebuild the fncache file"""
     repair.rebuildfncache(ui, repo)
 
 @command('debugrename',
     [('r', 'rev', '', _('revision to debug'), _('REV'))],
     _('[-r REV] FILE'))
 def debugrename(ui, repo, file1, *pats, **opts):
     """dump rename information"""
 
     opts = pycompat.byteskwargs(opts)
     ctx = scmutil.revsingle(repo, opts.get('rev'))
     m = scmutil.match(ctx, (file1,) + pats, opts)
     for abs in ctx.walk(m):
         fctx = ctx[abs]
         o = fctx.filelog().renamed(fctx.filenode())
         rel = m.rel(abs)
         if o:
             ui.write(_("%s renamed from %s:%s\n") % (rel, o[0], hex(o[1])))
         else:
             ui.write(_("%s not renamed\n") % rel)
 
 @command('debugrevlog', cmdutil.debugrevlogopts +
     [('d', 'dump', False, _('dump index data'))],
     _('-c|-m|FILE'),
     optionalrepo=True)
 def debugrevlog(ui, repo, file_=None, **opts):
     """show data and statistics about a revlog"""
     opts = pycompat.byteskwargs(opts)
     r = cmdutil.openrevlog(repo, 'debugrevlog', file_, opts)
 
     if opts.get("dump"):
         numrevs = len(r)
         ui.write(("# rev p1rev p2rev start   end deltastart base   p1   p2"
                  " rawsize totalsize compression heads chainlen\n"))
         ts = 0
         heads = set()
 
         for rev in xrange(numrevs):
             dbase = r.deltaparent(rev)
             if dbase == -1:
                 dbase = rev
             cbase = r.chainbase(rev)
             clen = r.chainlen(rev)
             p1, p2 = r.parentrevs(rev)
             rs = r.rawsize(rev)
             ts = ts + rs
             heads -= set(r.parentrevs(rev))
             heads.add(rev)
             try:
                 compression = ts / r.end(rev)
             except ZeroDivisionError:
                 compression = 0
             ui.write("%5d %5d %5d %5d %5d %10d %4d %4d %4d %7d %9d "
                      "%11d %5d %8d\n" %
                      (rev, p1, p2, r.start(rev), r.end(rev),
                       r.start(dbase), r.start(cbase),
                       r.start(p1), r.start(p2),
                       rs, ts, compression, len(heads), clen))
         return 0
 
     v = r.version
     format = v & 0xFFFF
     flags = []
     gdelta = False
     if v & revlog.FLAG_INLINE_DATA:
         flags.append('inline')
     if v & revlog.FLAG_GENERALDELTA:
         gdelta = True
         flags.append('generaldelta')
     if not flags:
         flags = ['(none)']
 
     nummerges = 0
     numfull = 0
     numprev = 0
     nump1 = 0
     nump2 = 0
     numother = 0
     nump1prev = 0
     nump2prev = 0
     chainlengths = []
     chainbases = []
     chainspans = []
 
     datasize = [None, 0, 0]
     fullsize = [None, 0, 0]
     deltasize = [None, 0, 0]
     chunktypecounts = {}
     chunktypesizes = {}
 
     def addsize(size, l):
         if l[0] is None or size < l[0]:
             l[0] = size
         if size > l[1]:
             l[1] = size
         l[2] += size
 
     numrevs = len(r)
     for rev in xrange(numrevs):
         p1, p2 = r.parentrevs(rev)
         delta = r.deltaparent(rev)
         if format > 0:
             addsize(r.rawsize(rev), datasize)
         if p2 != nullrev:
             nummerges += 1
         size = r.length(rev)
         if delta == nullrev:
             chainlengths.append(0)
             chainbases.append(r.start(rev))
             chainspans.append(size)
             numfull += 1
             addsize(size, fullsize)
         else:
             chainlengths.append(chainlengths[delta] + 1)
             baseaddr = chainbases[delta]
             revaddr = r.start(rev)
             chainbases.append(baseaddr)
             chainspans.append((revaddr - baseaddr) + size)
             addsize(size, deltasize)
             if delta == rev - 1:
                 numprev += 1
                 if delta == p1:
                     nump1prev += 1
                 elif delta == p2:
                     nump2prev += 1
             elif delta == p1:
                 nump1 += 1
             elif delta == p2:
                 nump2 += 1
             elif delta != nullrev:
                 numother += 1
 
         # Obtain data on the raw chunks in the revlog.
         segment = r._getsegmentforrevs(rev, rev)[1]
         if segment:
             chunktype = bytes(segment[0:1])
         else:
             chunktype = 'empty'
 
         if chunktype not in chunktypecounts:
             chunktypecounts[chunktype] = 0
             chunktypesizes[chunktype] = 0
 
         chunktypecounts[chunktype] += 1
         chunktypesizes[chunktype] += size
 
     # Adjust size min value for empty cases
     for size in (datasize, fullsize, deltasize):
         if size[0] is None:
             size[0] = 0
 
     numdeltas = numrevs - numfull
     numoprev = numprev - nump1prev - nump2prev
     totalrawsize = datasize[2]
     datasize[2] /= numrevs
     fulltotal = fullsize[2]
     fullsize[2] /= numfull
     deltatotal = deltasize[2]
     if numrevs - numfull > 0:
         deltasize[2] /= numrevs - numfull
     totalsize = fulltotal + deltatotal
     avgchainlen = sum(chainlengths) / numrevs
     maxchainlen = max(chainlengths)
     maxchainspan = max(chainspans)
     compratio = 1
     if totalsize:
         compratio = totalrawsize / totalsize
 
     basedfmtstr = '%%%dd\n'
     basepcfmtstr = '%%%dd %s(%%5.2f%%%%)\n'
 
     def dfmtstr(max):
         return basedfmtstr % len(str(max))
     def pcfmtstr(max, padding=0):
         return basepcfmtstr % (len(str(max)), ' ' * padding)
 
     def pcfmt(value, total):
         if total:
             return (value, 100 * float(value) / total)
         else:
             return value, 100.0
 
     ui.write(('format : %d\n') % format)
     ui.write(('flags  : %s\n') % ', '.join(flags))
 
     ui.write('\n')
     fmt = pcfmtstr(totalsize)
     fmt2 = dfmtstr(totalsize)
     ui.write(('revisions     : ') + fmt2 % numrevs)
     ui.write(('    merges    : ') + fmt % pcfmt(nummerges, numrevs))
     ui.write(('    normal    : ') + fmt % pcfmt(numrevs - nummerges, numrevs))
     ui.write(('revisions     : ') + fmt2 % numrevs)
     ui.write(('    full      : ') + fmt % pcfmt(numfull, numrevs))
     ui.write(('    deltas    : ') + fmt % pcfmt(numdeltas, numrevs))
     ui.write(('revision size : ') + fmt2 % totalsize)
     ui.write(('    full      : ') + fmt % pcfmt(fulltotal, totalsize))
     ui.write(('    deltas    : ') + fmt % pcfmt(deltatotal, totalsize))
 
     def fmtchunktype(chunktype):
         if chunktype == 'empty':
             return '    %s     : ' % chunktype
         elif chunktype in pycompat.bytestr(string.ascii_letters):
             return '    0x%s (%s)  : ' % (hex(chunktype), chunktype)
         else:
             return '    0x%s      : ' % hex(chunktype)
 
     ui.write('\n')
     ui.write(('chunks        : ') + fmt2 % numrevs)
     for chunktype in sorted(chunktypecounts):
         ui.write(fmtchunktype(chunktype))
         ui.write(fmt % pcfmt(chunktypecounts[chunktype], numrevs))
     ui.write(('chunks size   : ') + fmt2 % totalsize)
     for chunktype in sorted(chunktypecounts):
         ui.write(fmtchunktype(chunktype))
         ui.write(fmt % pcfmt(chunktypesizes[chunktype], totalsize))
 
     ui.write('\n')
     fmt = dfmtstr(max(avgchainlen, maxchainlen, maxchainspan, compratio))
     ui.write(('avg chain length  : ') + fmt % avgchainlen)
     ui.write(('max chain length  : ') + fmt % maxchainlen)
     ui.write(('max chain reach   : ') + fmt % maxchainspan)
     ui.write(('compression ratio : ') + fmt % compratio)
 
     if format > 0:
         ui.write('\n')
         ui.write(('uncompressed data size (min/max/avg) : %d / %d / %d\n')
                  % tuple(datasize))
     ui.write(('full revision size (min/max/avg)     : %d / %d / %d\n')
              % tuple(fullsize))
     ui.write(('delta size (min/max/avg)             : %d / %d / %d\n')
              % tuple(deltasize))
 
     if numdeltas > 0:
         ui.write('\n')
         fmt = pcfmtstr(numdeltas)
         fmt2 = pcfmtstr(numdeltas, 4)
         ui.write(('deltas against prev  : ') + fmt % pcfmt(numprev, numdeltas))
         if numprev > 0:
             ui.write(('    where prev = p1  : ') + fmt2 % pcfmt(nump1prev,
                                                               numprev))
             ui.write(('    where prev = p2  : ') + fmt2 % pcfmt(nump2prev,
                                                               numprev))
             ui.write(('    other            : ') + fmt2 % pcfmt(numoprev,
                                                               numprev))
         if gdelta:
             ui.write(('deltas against p1    : ')
                      + fmt % pcfmt(nump1, numdeltas))
             ui.write(('deltas against p2    : ')
                      + fmt % pcfmt(nump2, numdeltas))
             ui.write(('deltas against other : ') + fmt % pcfmt(numother,
                                                              numdeltas))
 
 @command('debugrevspec',
     [('', 'optimize', None,
       _('print parsed tree after optimizing (DEPRECATED)')),
      ('', 'show-revs', True, _('print list of result revisions (default)')),
      ('s', 'show-set', None, _('print internal representation of result set')),
      ('p', 'show-stage', [],
       _('print parsed tree at the given stage'), _('NAME')),
      ('', 'no-optimized', False, _('evaluate tree without optimization')),
      ('', 'verify-optimized', False, _('verify optimized result')),
      ],
     ('REVSPEC'))
 def debugrevspec(ui, repo, expr, **opts):
     """parse and apply a revision specification
 
     Use -p/--show-stage option to print the parsed tree at the given stages.
     Use -p all to print tree at every stage.
 
     Use --no-show-revs option with -s or -p to print only the set
     representation or the parsed tree respectively.
 
     Use --verify-optimized to compare the optimized result with the unoptimized
     one. Returns 1 if the optimized result differs.
     """
     opts = pycompat.byteskwargs(opts)
     aliases = ui.configitems('revsetalias')
     stages = [
         ('parsed', lambda tree: tree),
         ('expanded', lambda tree: revsetlang.expandaliases(tree, aliases,
                                                            ui.warn)),
         ('concatenated', revsetlang.foldconcat),
         ('analyzed', revsetlang.analyze),
         ('optimized', revsetlang.optimize),
     ]
     if opts['no_optimized']:
         stages = stages[:-1]
     if opts['verify_optimized'] and opts['no_optimized']:
         raise error.Abort(_('cannot use --verify-optimized with '
                             '--no-optimized'))
     stagenames = set(n for n, f in stages)
 
     showalways = set()
     showchanged = set()
     if ui.verbose and not opts['show_stage']:
         # show parsed tree by --verbose (deprecated)
         showalways.add('parsed')
         showchanged.update(['expanded', 'concatenated'])
         if opts['optimize']:
             showalways.add('optimized')
     if opts['show_stage'] and opts['optimize']:
         raise error.Abort(_('cannot use --optimize with --show-stage'))
     if opts['show_stage'] == ['all']:
         showalways.update(stagenames)
     else:
         for n in opts['show_stage']:
             if n not in stagenames:
                 raise error.Abort(_('invalid stage name: %s') % n)
         showalways.update(opts['show_stage'])
 
     treebystage = {}
     printedtree = None
     tree = revsetlang.parse(expr, lookup=revset.lookupfn(repo))
     for n, f in stages:
         treebystage[n] = tree = f(tree)
         if n in showalways or (n in showchanged and tree != printedtree):
             if opts['show_stage'] or n != 'parsed':
                 ui.write(("* %s:\n") % n)
             ui.write(revsetlang.prettyformat(tree), "\n")
             printedtree = tree
 
     if opts['verify_optimized']:
         arevs = revset.makematcher(treebystage['analyzed'])(repo)
         brevs = revset.makematcher(treebystage['optimized'])(repo)
         if opts['show_set'] or (opts['show_set'] is None and ui.verbose):
             ui.write(("* analyzed set:\n"), stringutil.prettyrepr(arevs), "\n")
             ui.write(("* optimized set:\n"), stringutil.prettyrepr(brevs), "\n")
         arevs = list(arevs)
         brevs = list(brevs)
         if arevs == brevs:
             return 0
         ui.write(('--- analyzed\n'), label='diff.file_a')
         ui.write(('+++ optimized\n'), label='diff.file_b')
         sm = difflib.SequenceMatcher(None, arevs, brevs)
         for tag, alo, ahi, blo, bhi in sm.get_opcodes():
             if tag in ('delete', 'replace'):
                 for c in arevs[alo:ahi]:
                     ui.write('-%s\n' % c, label='diff.deleted')
             if tag in ('insert', 'replace'):
                 for c in brevs[blo:bhi]:
                     ui.write('+%s\n' % c, label='diff.inserted')
             if tag == 'equal':
                 for c in arevs[alo:ahi]:
                     ui.write(' %s\n' % c)
         return 1
 
     func = revset.makematcher(tree)
     revs = func(repo)
     if opts['show_set'] or (opts['show_set'] is None and ui.verbose):
         ui.write(("* set:\n"), stringutil.prettyrepr(revs), "\n")
     if not opts['show_revs']:
         return
     for c in revs:
         ui.write("%d\n" % c)
 
 @command('debugserve', [
     ('', 'sshstdio', False, _('run an SSH server bound to process handles')),
     ('', 'logiofd', '', _('file descriptor to log server I/O to')),
     ('', 'logiofile', '', _('file to log server I/O to')),
 ], '')
 def debugserve(ui, repo, **opts):
     """run a server with advanced settings
 
     This command is similar to :hg:`serve`. It exists partially as a
     workaround to the fact that ``hg serve --stdio`` must have specific
     arguments for security reasons.
     """
     opts = pycompat.byteskwargs(opts)
 
     if not opts['sshstdio']:
         raise error.Abort(_('only --sshstdio is currently supported'))
 
     logfh = None
 
     if opts['logiofd'] and opts['logiofile']:
         raise error.Abort(_('cannot use both --logiofd and --logiofile'))
 
     if opts['logiofd']:
         # Line buffered because output is line based.
         try:
             logfh = os.fdopen(int(opts['logiofd']), r'ab', 1)
         except OSError as e:
             if e.errno != errno.ESPIPE:
                 raise
             # can't seek a pipe, so `ab` mode fails on py3
             logfh = os.fdopen(int(opts['logiofd']), r'wb', 1)
     elif opts['logiofile']:
         logfh = open(opts['logiofile'], 'ab', 1)
 
     s = wireprotoserver.sshserver(ui, repo, logfh=logfh)
     s.serve_forever()
 
 @command('debugsetparents', [], _('REV1 [REV2]'))
 def debugsetparents(ui, repo, rev1, rev2=None):
     """manually set the parents of the current working directory
 
     This is useful for writing repository conversion tools, but should
     be used with care. For example, neither the working directory nor the
     dirstate is updated, so file status may be incorrect after running this
     command.
 
     Returns 0 on success.
     """
 
     node1 = scmutil.revsingle(repo, rev1).node()
     node2 = scmutil.revsingle(repo, rev2, 'null').node()
 
     with repo.wlock():
         repo.setparents(node1, node2)
 
 @command('debugssl', [], '[SOURCE]', optionalrepo=True)
 def debugssl(ui, repo, source=None, **opts):
     '''test a secure connection to a server
 
     This builds the certificate chain for the server on Windows, installing the
     missing intermediates and trusted root via Windows Update if necessary.  It
     does nothing on other platforms.
 
     If SOURCE is omitted, the 'default' path will be used.  If a URL is given,
     that server is used. See :hg:`help urls` for more information.
 
     If the update succeeds, retry the original operation.  Otherwise, the cause
     of the SSL error is likely another issue.
     '''
     if not pycompat.iswindows:
         raise error.Abort(_('certificate chain building is only possible on '
                             'Windows'))
 
     if not source:
         if not repo:
             raise error.Abort(_("there is no Mercurial repository here, and no "
                                 "server specified"))
         source = "default"
 
     source, branches = hg.parseurl(ui.expandpath(source))
     url = util.url(source)
     addr = None
 
     defaultport = {'https': 443, 'ssh': 22}
     if url.scheme in defaultport:
         try:
             addr = (url.host, int(url.port or defaultport[url.scheme]))
         except ValueError:
             raise error.Abort(_("malformed port number in URL"))
     else:
         raise error.Abort(_("only https and ssh connections are supported"))
 
     from . import win32
 
     s = ssl.wrap_socket(socket.socket(), ssl_version=ssl.PROTOCOL_TLS,
                         cert_reqs=ssl.CERT_NONE, ca_certs=None)
 
     try:
         s.connect(addr)
         cert = s.getpeercert(True)
 
         ui.status(_('checking the certificate chain for %s\n') % url.host)
 
         complete = win32.checkcertificatechain(cert, build=False)
 
         if not complete:
             ui.status(_('certificate chain is incomplete, updating... '))
 
             if not win32.checkcertificatechain(cert):
                 ui.status(_('failed.\n'))
             else:
                 ui.status(_('done.\n'))
         else:
             ui.status(_('full certificate chain is available\n'))
     finally:
         s.close()
 
 @command('debugsub',
     [('r', 'rev', '',
      _('revision to check'), _('REV'))],
     _('[-r REV] [REV]'))
 def debugsub(ui, repo, rev=None):
     ctx = scmutil.revsingle(repo, rev, None)
     for k, v in sorted(ctx.substate.items()):
         ui.write(('path %s\n') % k)
         ui.write((' source   %s\n') % v[0])
         ui.write((' revision %s\n') % v[1])
 
 @command('debugsuccessorssets',
     [('', 'closest', False, _('return closest successors sets only'))],
     _('[REV]'))
 def debugsuccessorssets(ui, repo, *revs, **opts):
     """show set of successors for revision
 
     A successors set of changeset A is a consistent group of revisions that
     succeed A. It contains non-obsolete changesets only unless closests
     successors set is set.
 
     In most cases a changeset A has a single successors set containing a single
     successor (changeset A replaced by A').
 
     A changeset that is made obsolete with no successors are called "pruned".
     Such changesets have no successors sets at all.
 
     A changeset that has been "split" will have a successors set containing
     more than one successor.
 
     A changeset that has been rewritten in multiple different ways is called
     "divergent". Such changesets have multiple successor sets (each of which
     may also be split, i.e. have multiple successors).
 
     Results are displayed as follows::
 
         <rev1>
             <successors-1A>
         <rev2>
             <successors-2A>
             <successors-2B1> <successors-2B2> <successors-2B3>
 
     Here rev2 has two possible (i.e. divergent) successors sets. The first
     holds one element, whereas the second holds three (i.e. the changeset has
     been split).
     """
     # passed to successorssets caching computation from one call to another
     cache = {}
     ctx2str = bytes
     node2str = short
     for rev in scmutil.revrange(repo, revs):
         ctx = repo[rev]
         ui.write('%s\n'% ctx2str(ctx))
         for succsset in obsutil.successorssets(repo, ctx.node(),
                                                 closest=opts[r'closest'],
                                                 cache=cache):
             if succsset:
                 ui.write('    ')
                 ui.write(node2str(succsset[0]))
                 for node in succsset[1:]:
                     ui.write(' ')
                     ui.write(node2str(node))
             ui.write('\n')
 
 @command('debugtemplate',
     [('r', 'rev', [], _('apply template on changesets'), _('REV')),
      ('D', 'define', [], _('define template keyword'), _('KEY=VALUE'))],
     _('[-r REV]... [-D KEY=VALUE]... TEMPLATE'),
     optionalrepo=True)
 def debugtemplate(ui, repo, tmpl, **opts):
     """parse and apply a template
 
     If -r/--rev is given, the template is processed as a log template and
     applied to the given changesets. Otherwise, it is processed as a generic
     template.
 
     Use --verbose to print the parsed tree.
     """
     revs = None
     if opts[r'rev']:
         if repo is None:
             raise error.RepoError(_('there is no Mercurial repository here '
                                     '(.hg not found)'))
         revs = scmutil.revrange(repo, opts[r'rev'])
 
     props = {}
     for d in opts[r'define']:
         try:
             k, v = (e.strip() for e in d.split('=', 1))
             if not k or k == 'ui':
                 raise ValueError
             props[k] = v
         except ValueError:
             raise error.Abort(_('malformed keyword definition: %s') % d)
 
     if ui.verbose:
         aliases = ui.configitems('templatealias')
         tree = templater.parse(tmpl)
         ui.note(templater.prettyformat(tree), '\n')
         newtree = templater.expandaliases(tree, aliases)
         if newtree != tree:
             ui.note(("* expanded:\n"), templater.prettyformat(newtree), '\n')
 
     if revs is None:
         tres = formatter.templateresources(ui, repo)
         t = formatter.maketemplater(ui, tmpl, resources=tres)
         if ui.verbose:
             kwds, funcs = t.symbolsuseddefault()
             ui.write(("* keywords: %s\n") % ', '.join(sorted(kwds)))
             ui.write(("* functions: %s\n") % ', '.join(sorted(funcs)))
         ui.write(t.renderdefault(props))
     else:
         displayer = logcmdutil.maketemplater(ui, repo, tmpl)
         if ui.verbose:
             kwds, funcs = displayer.t.symbolsuseddefault()
             ui.write(("* keywords: %s\n") % ', '.join(sorted(kwds)))
             ui.write(("* functions: %s\n") % ', '.join(sorted(funcs)))
         for r in revs:
             displayer.show(repo[r], **pycompat.strkwargs(props))
         displayer.close()
 
 @command('debuguigetpass', [
     ('p', 'prompt', '', _('prompt text'), _('TEXT')),
 ], _('[-p TEXT]'), norepo=True)
 def debuguigetpass(ui, prompt=''):
     """show prompt to type password"""
     r = ui.getpass(prompt)
     ui.write(('respose: %s\n') % r)
 
 @command('debuguiprompt', [
     ('p', 'prompt', '', _('prompt text'), _('TEXT')),
 ], _('[-p TEXT]'), norepo=True)
 def debuguiprompt(ui, prompt=''):
     """show plain prompt"""
     r = ui.prompt(prompt)
     ui.write(('response: %s\n') % r)
 
 @command('debugupdatecaches', [])
 def debugupdatecaches(ui, repo, *pats, **opts):
     """warm all known caches in the repository"""
     with repo.wlock(), repo.lock():
         repo.updatecaches(full=True)
 
 @command('debugupgraderepo', [
     ('o', 'optimize', [], _('extra optimization to perform'), _('NAME')),
     ('', 'run', False, _('performs an upgrade')),
 ])
 def debugupgraderepo(ui, repo, run=False, optimize=None):
     """upgrade a repository to use different features
 
     If no arguments are specified, the repository is evaluated for upgrade
     and a list of problems and potential optimizations is printed.
 
     With ``--run``, a repository upgrade is performed. Behavior of the upgrade
     can be influenced via additional arguments. More details will be provided
     by the command output when run without ``--run``.
 
     During the upgrade, the repository will be locked and no writes will be
     allowed.
 
     At the end of the upgrade, the repository may not be readable while new
     repository data is swapped in. This window will be as long as it takes to
     rename some directories inside the ``.hg`` directory. On most machines, this
     should complete almost instantaneously and the chances of a consumer being
     unable to access the repository should be low.
     """
     return upgrade.upgraderepo(ui, repo, run=run, optimize=optimize)
 
 @command('debugwalk', cmdutil.walkopts, _('[OPTION]... [FILE]...'),
          inferrepo=True)
 def debugwalk(ui, repo, *pats, **opts):
     """show how files match on given patterns"""
     opts = pycompat.byteskwargs(opts)
     m = scmutil.match(repo[None], pats, opts)
     if ui.verbose:
         ui.write(('* matcher:\n'), stringutil.prettyrepr(m), '\n')
     items = list(repo[None].walk(m))
     if not items:
         return
     f = lambda fn: fn
     if ui.configbool('ui', 'slash') and pycompat.ossep != '/':
         f = lambda fn: util.normpath(fn)
     fmt = 'f  %%-%ds  %%-%ds  %%s' % (
         max([len(abs) for abs in items]),
         max([len(m.rel(abs)) for abs in items]))
     for abs in items:
         line = fmt % (abs, f(m.rel(abs)), m.exact(abs) and 'exact' or '')
         ui.write("%s\n" % line.rstrip())
 
 @command('debugwhyunstable', [], _('REV'))
 def debugwhyunstable(ui, repo, rev):
     """explain instabilities of a changeset"""
     for entry in obsutil.whyunstable(repo, scmutil.revsingle(repo, rev)):
         dnodes = ''
         if entry.get('divergentnodes'):
             dnodes = ' '.join('%s (%s)' % (ctx.hex(), ctx.phasestr())
                               for ctx in entry['divergentnodes']) + ' '
         ui.write('%s: %s%s %s\n' % (entry['instability'], dnodes,
                                     entry['reason'], entry['node']))
 
 @command('debugwireargs',
     [('', 'three', '', 'three'),
     ('', 'four', '', 'four'),
     ('', 'five', '', 'five'),
     ] + cmdutil.remoteopts,
     _('REPO [OPTIONS]... [ONE [TWO]]'),
     norepo=True)
 def debugwireargs(ui, repopath, *vals, **opts):
     opts = pycompat.byteskwargs(opts)
     repo = hg.peer(ui, opts, repopath)
     for opt in cmdutil.remoteopts:
         del opts[opt[1]]
     args = {}
     for k, v in opts.iteritems():
         if v:
             args[k] = v
     args = pycompat.strkwargs(args)
     # run twice to check that we don't mess up the stream for the next command
     res1 = repo.debugwireargs(*vals, **args)
     res2 = repo.debugwireargs(*vals, **args)
     ui.write("%s\n" % res1)
     if res1 != res2:
         ui.warn("%s\n" % res2)
 
 def _parsewirelangblocks(fh):
     activeaction = None
     blocklines = []
 
     for line in fh:
         line = line.rstrip()
         if not line:
             continue
 
         if line.startswith(b'#'):
             continue
 
         if not line.startswith(' '):
             # New block. Flush previous one.
             if activeaction:
                 yield activeaction, blocklines
 
             activeaction = line
             blocklines = []
             continue
 
         # Else we start with an indent.
 
         if not activeaction:
             raise error.Abort(_('indented line outside of block'))
 
         blocklines.append(line)
 
     # Flush last block.
     if activeaction:
         yield activeaction, blocklines
 
 @command('debugwireproto',
     [
         ('', 'localssh', False, _('start an SSH server for this repo')),
         ('', 'peer', '', _('construct a specific version of the peer')),
         ('', 'noreadstderr', False, _('do not read from stderr of the remote')),
         ('', 'nologhandshake', False,
          _('do not log I/O related to the peer handshake')),
     ] + cmdutil.remoteopts,
     _('[PATH]'),
     optionalrepo=True)
 def debugwireproto(ui, repo, path=None, **opts):
     """send wire protocol commands to a server
 
     This command can be used to issue wire protocol commands to remote
     peers and to debug the raw data being exchanged.
 
     ``--localssh`` will start an SSH server against the current repository
     and connect to that. By default, the connection will perform a handshake
     and establish an appropriate peer instance.
 
     ``--peer`` can be used to bypass the handshake protocol and construct a
     peer instance using the specified class type. Valid values are ``raw``,
     ``http2``, ``ssh1``, and ``ssh2``. ``raw`` instances only allow sending
     raw data payloads and don't support higher-level command actions.
 
     ``--noreadstderr`` can be used to disable automatic reading from stderr
     of the peer (for SSH connections only). Disabling automatic reading of
     stderr is useful for making output more deterministic.
 
     Commands are issued via a mini language which is specified via stdin.
     The language consists of individual actions to perform. An action is
     defined by a block. A block is defined as a line with no leading
     space followed by 0 or more lines with leading space. Blocks are
     effectively a high-level command with additional metadata.
 
     Lines beginning with ``#`` are ignored.
 
     The following sections denote available actions.
 
     raw
     ---
 
     Send raw data to the server.
 
     The block payload contains the raw data to send as one atomic send
     operation. The data may not actually be delivered in a single system
     call: it depends on the abilities of the transport being used.
 
     Each line in the block is de-indented and concatenated. Then, that
     value is evaluated as a Python b'' literal. This allows the use of
     backslash escaping, etc.
 
     raw+
     ----
 
     Behaves like ``raw`` except flushes output afterwards.
 
     command <X>
     -----------
 
     Send a request to run a named command, whose name follows the ``command``
     string.
 
     Arguments to the command are defined as lines in this block. The format of
     each line is ``<key> <value>``. e.g.::
 
        command listkeys
            namespace bookmarks
 
     If the value begins with ``eval:``, it will be interpreted as a Python
     literal expression. Otherwise values are interpreted as Python b'' literals.
     This allows sending complex types and encoding special byte sequences via
     backslash escaping.
 
     The following arguments have special meaning:
 
     ``PUSHFILE``
         When defined, the *push* mechanism of the peer will be used instead
         of the static request-response mechanism and the content of the
         file specified in the value of this argument will be sent as the
         command payload.
 
         This can be used to submit a local bundle file to the remote.
 
     batchbegin
     ----------
 
     Instruct the peer to begin a batched send.
 
     All ``command`` blocks are queued for execution until the next
     ``batchsubmit`` block.
 
     batchsubmit
     -----------
 
     Submit previously queued ``command`` blocks as a batch request.
 
     This action MUST be paired with a ``batchbegin`` action.
 
     httprequest <method> <path>
     ---------------------------
 
     (HTTP peer only)
 
     Send an HTTP request to the peer.
 
     The HTTP request line follows the ``httprequest`` action. e.g. ``GET /foo``.
 
     Arguments of the form ``<key>: <value>`` are interpreted as HTTP request
     headers to add to the request. e.g. ``Accept: foo``.
 
     The following arguments are special:
 
     ``BODYFILE``
         The content of the file defined as the value to this argument will be
         transferred verbatim as the HTTP request body.
 
     ``frame <type> <flags> <payload>``
         Send a unified protocol frame as part of the request body.
 
         All frames will be collected and sent as the body to the HTTP
         request.
 
     close
     -----
 
     Close the connection to the server.
 
     flush
     -----
 
     Flush data written to the server.
 
     readavailable
     -------------
 
     Close the write end of the connection and read all available data from
     the server.
 
     If the connection to the server encompasses multiple pipes, we poll both
     pipes and read available data.
 
     readline
     --------
 
     Read a line of output from the server. If there are multiple output
     pipes, reads only the main pipe.
 
     ereadline
     ---------
 
     Like ``readline``, but read from the stderr pipe, if available.
 
     read <X>
     --------
 
     ``read()`` N bytes from the server's main output pipe.
 
     eread <X>
     ---------
 
     ``read()`` N bytes from the server's stderr pipe, if available.
 
     Specifying Unified Frame-Based Protocol Frames
     ----------------------------------------------
 
     It is possible to emit a *Unified Frame-Based Protocol* by using special
     syntax.
 
     A frame is composed as a type, flags, and payload. These can be parsed
     from a string of the form:
 
        <request-id> <stream-id> <stream-flags> <type> <flags> <payload>
 
     ``request-id`` and ``stream-id`` are integers defining the request and
     stream identifiers.
 
     ``type`` can be an integer value for the frame type or the string name
     of the type. The strings are defined in ``wireprotoframing.py``. e.g.
     ``command-name``.
 
     ``stream-flags`` and ``flags`` are a ``|`` delimited list of flag
     components. Each component (and there can be just one) can be an integer
     or a flag name for stream flags or frame flags, respectively. Values are
     resolved to integers and then bitwise OR'd together.
 
     ``payload`` represents the raw frame payload. If it begins with
     ``cbor:``, the following string is evaluated as Python code and the
     resulting object is fed into a CBOR encoder. Otherwise it is interpreted
     as a Python byte string literal.
     """
     opts = pycompat.byteskwargs(opts)
 
     if opts['localssh'] and not repo:
         raise error.Abort(_('--localssh requires a repository'))
 
     if opts['peer'] and opts['peer'] not in ('raw', 'http2', 'ssh1', 'ssh2'):
         raise error.Abort(_('invalid value for --peer'),
                           hint=_('valid values are "raw", "ssh1", and "ssh2"'))
 
     if path and opts['localssh']:
         raise error.Abort(_('cannot specify --localssh with an explicit '
                             'path'))
 
     if ui.interactive():
         ui.write(_('(waiting for commands on stdin)\n'))
 
     blocks = list(_parsewirelangblocks(ui.fin))
 
     proc = None
     stdin = None
     stdout = None
     stderr = None
     opener = None
 
     if opts['localssh']:
         # We start the SSH server in its own process so there is process
         # separation. This prevents a whole class of potential bugs around
         # shared state from interfering with server operation.
         args = procutil.hgcmd() + [
             '-R', repo.root,
             'debugserve', '--sshstdio',
         ]
         proc = subprocess.Popen(args, stdin=subprocess.PIPE,
                                 stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                                 bufsize=0)
 
         stdin = proc.stdin
         stdout = proc.stdout
         stderr = proc.stderr
 
         # We turn the pipes into observers so we can log I/O.
         if ui.verbose or opts['peer'] == 'raw':
             stdin = util.makeloggingfileobject(ui, proc.stdin, b'i',
                                                logdata=True)
             stdout = util.makeloggingfileobject(ui, proc.stdout, b'o',
                                                 logdata=True)
             stderr = util.makeloggingfileobject(ui, proc.stderr, b'e',
                                                 logdata=True)
 
         # --localssh also implies the peer connection settings.
 
         url = 'ssh://localserver'
         autoreadstderr = not opts['noreadstderr']
 
         if opts['peer'] == 'ssh1':
             ui.write(_('creating ssh peer for wire protocol version 1\n'))
             peer = sshpeer.sshv1peer(ui, url, proc, stdin, stdout, stderr,
                                      None, autoreadstderr=autoreadstderr)
         elif opts['peer'] == 'ssh2':
             ui.write(_('creating ssh peer for wire protocol version 2\n'))
             peer = sshpeer.sshv2peer(ui, url, proc, stdin, stdout, stderr,
                                      None, autoreadstderr=autoreadstderr)
         elif opts['peer'] == 'raw':
             ui.write(_('using raw connection to peer\n'))
             peer = None
         else:
             ui.write(_('creating ssh peer from handshake results\n'))
             peer = sshpeer.makepeer(ui, url, proc, stdin, stdout, stderr,
                                     autoreadstderr=autoreadstderr)
 
     elif path:
         # We bypass hg.peer() so we can proxy the sockets.
         # TODO consider not doing this because we skip
         # ``hg.wirepeersetupfuncs`` and potentially other useful functionality.
         u = util.url(path)
         if u.scheme != 'http':
             raise error.Abort(_('only http:// paths are currently supported'))
 
         url, authinfo = u.authinfo()
         openerargs = {
             r'useragent': b'Mercurial debugwireproto',
         }
 
         # Turn pipes/sockets into observers so we can log I/O.
         if ui.verbose:
             openerargs.update({
                 r'loggingfh': ui,
                 r'loggingname': b's',
                 r'loggingopts': {
                     r'logdata': True,
                     r'logdataapis': False,
                 },
             })
 
         if ui.debugflag:
             openerargs[r'loggingopts'][r'logdataapis'] = True
 
         # Don't send default headers when in raw mode. This allows us to
         # bypass most of the behavior of our URL handling code so we can
         # have near complete control over what's sent on the wire.
         if opts['peer'] == 'raw':
             openerargs[r'sendaccept'] = False
 
         opener = urlmod.opener(ui, authinfo, **openerargs)
 
         if opts['peer'] == 'http2':
             ui.write(_('creating http peer for wire protocol version 2\n'))
             # We go through makepeer() because we need an API descriptor for
             # the peer instance to be useful.
             with ui.configoverride({
                 ('experimental', 'httppeer.advertise-v2'): True}):
                 if opts['nologhandshake']:
                     ui.pushbuffer()
 
                 peer = httppeer.makepeer(ui, path, opener=opener)
 
                 if opts['nologhandshake']:
                     ui.popbuffer()
 
             if not isinstance(peer, httppeer.httpv2peer):
                 raise error.Abort(_('could not instantiate HTTP peer for '
                                     'wire protocol version 2'),
                                   hint=_('the server may not have the feature '
                                          'enabled or is not allowing this '
                                          'client version'))
 
         elif opts['peer'] == 'raw':
             ui.write(_('using raw connection to peer\n'))
             peer = None
         elif opts['peer']:
             raise error.Abort(_('--peer %s not supported with HTTP peers') %
                               opts['peer'])
         else:
             peer = httppeer.makepeer(ui, path, opener=opener)
 
         # We /could/ populate stdin/stdout with sock.makefile()...
     else:
         raise error.Abort(_('unsupported connection configuration'))
 
     batchedcommands = None
 
     # Now perform actions based on the parsed wire language instructions.
     for action, lines in blocks:
         if action in ('raw', 'raw+'):
             if not stdin:
                 raise error.Abort(_('cannot call raw/raw+ on this peer'))
 
             # Concatenate the data together.
             data = ''.join(l.lstrip() for l in lines)
             data = stringutil.unescapestr(data)
             stdin.write(data)
 
             if action == 'raw+':
                 stdin.flush()
         elif action == 'flush':
             if not stdin:
                 raise error.Abort(_('cannot call flush on this peer'))
             stdin.flush()
         elif action.startswith('command'):
             if not peer:
                 raise error.Abort(_('cannot send commands unless peer instance '
                                     'is available'))
 
             command = action.split(' ', 1)[1]
 
             args = {}
             for line in lines:
                 # We need to allow empty values.
                 fields = line.lstrip().split(' ', 1)
                 if len(fields) == 1:
                     key = fields[0]
                     value = ''
                 else:
                     key, value = fields
 
                 if value.startswith('eval:'):
                     value = stringutil.evalpythonliteral(value[5:])
                 else:
                     value = stringutil.unescapestr(value)
 
                 args[key] = value
 
             if batchedcommands is not None:
                 batchedcommands.append((command, args))
                 continue
 
             ui.status(_('sending %s command\n') % command)
 
             if 'PUSHFILE' in args:
                 with open(args['PUSHFILE'], r'rb') as fh:
                     del args['PUSHFILE']
                     res, output = peer._callpush(command, fh,
                                                  **pycompat.strkwargs(args))
                     ui.status(_('result: %s\n') % stringutil.escapestr(res))
                     ui.status(_('remote output: %s\n') %
                               stringutil.escapestr(output))
             else:
                 with peer.commandexecutor() as e:
                     res = e.callcommand(command, args).result()
 
                 if isinstance(res, wireprotov2peer.commandresponse):
                     val = list(res.cborobjects())
                     ui.status(_('response: %s\n') %
                               stringutil.pprint(val, bprefix=True))
 
                 else:
                     ui.status(_('response: %s\n') %
                               stringutil.pprint(res, bprefix=True))
 
         elif action == 'batchbegin':
             if batchedcommands is not None:
                 raise error.Abort(_('nested batchbegin not allowed'))
 
             batchedcommands = []
         elif action == 'batchsubmit':
             # There is a batching API we could go through. But it would be
             # difficult to normalize requests into function calls. It is easier
             # to bypass this layer and normalize to commands + args.
             ui.status(_('sending batch with %d sub-commands\n') %
                       len(batchedcommands))
             for i, chunk in enumerate(peer._submitbatch(batchedcommands)):
                 ui.status(_('response #%d: %s\n') %
                           (i, stringutil.escapestr(chunk)))
 
             batchedcommands = None
 
         elif action.startswith('httprequest '):
             if not opener:
                 raise error.Abort(_('cannot use httprequest without an HTTP '
                                     'peer'))
 
             request = action.split(' ', 2)
             if len(request) != 3:
                 raise error.Abort(_('invalid httprequest: expected format is '
                                     '"httprequest <method> <path>'))
 
             method, httppath = request[1:]
             headers = {}
             body = None
             frames = []
             for line in lines:
                 line = line.lstrip()
                 m = re.match(b'^([a-zA-Z0-9_-]+): (.*)$', line)
                 if m:
                     headers[m.group(1)] = m.group(2)
                     continue
 
                 if line.startswith(b'BODYFILE '):
                     with open(line.split(b' ', 1), 'rb') as fh:
                         body = fh.read()
                 elif line.startswith(b'frame '):
                     frame = wireprotoframing.makeframefromhumanstring(
                         line[len(b'frame '):])
 
                     frames.append(frame)
                 else:
                     raise error.Abort(_('unknown argument to httprequest: %s') %
                                       line)
 
             url = path + httppath
 
             if frames:
                 body = b''.join(bytes(f) for f in frames)
 
             req = urlmod.urlreq.request(pycompat.strurl(url), body, headers)
 
             # urllib.Request insists on using has_data() as a proxy for
             # determining the request method. Override that to use our
             # explicitly requested method.
             req.get_method = lambda: method
 
             try:
                 res = opener.open(req)
                 body = res.read()
             except util.urlerr.urlerror as e:
                 e.read()
                 continue
 
             if res.headers.get('Content-Type') == 'application/mercurial-cbor':
                 ui.write(_('cbor> %s\n') %
                          stringutil.pprint(cbor.loads(body), bprefix=True))
 
         elif action == 'close':
             peer.close()
         elif action == 'readavailable':
             if not stdout or not stderr:
                 raise error.Abort(_('readavailable not available on this peer'))
 
             stdin.close()
             stdout.read()
             stderr.read()
 
         elif action == 'readline':
             if not stdout:
                 raise error.Abort(_('readline not available on this peer'))
             stdout.readline()
         elif action == 'ereadline':
             if not stderr:
                 raise error.Abort(_('ereadline not available on this peer'))
             stderr.readline()
         elif action.startswith('read '):
             count = int(action.split(' ', 1)[1])
             if not stdout:
                 raise error.Abort(_('read not available on this peer'))
             stdout.read(count)
         elif action.startswith('eread '):
             count = int(action.split(' ', 1)[1])
             if not stderr:
                 raise error.Abort(_('eread not available on this peer'))
             stderr.read(count)
         else:
             raise error.Abort(_('unknown action: %s') % action)
 
     if batchedcommands is not None:
         raise error.Abort(_('unclosed "batchbegin" request'))
 
     if peer:
         peer.close()
 
     if proc:
         proc.kill()

mercurial/fileset.py

@@ -1,665 +1,670 b''
 # fileset.py - file set queries for mercurial
 #
 # Copyright 2010 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import re
 
 from .i18n import _
 from . import (
     error,
     match as matchmod,
     merge,
     parser,
     pycompat,
     registrar,
     scmutil,
     util,
 )
 from .utils import (
     stringutil,
 )
 
 elements = {
     # token-type: binding-strength, primary, prefix, infix, suffix
     "(": (20, None, ("group", 1, ")"), ("func", 1, ")"), None),
     ":": (15, None, None, ("kindpat", 15), None),
     "-": (5, None, ("negate", 19), ("minus", 5), None),
     "not": (10, None, ("not", 10), None, None),
     "!": (10, None, ("not", 10), None, None),
     "and": (5, None, None, ("and", 5), None),
     "&": (5, None, None, ("and", 5), None),
     "or": (4, None, None, ("or", 4), None),
     "|": (4, None, None, ("or", 4), None),
     "+": (4, None, None, ("or", 4), None),
     ",": (2, None, None, ("list", 2), None),
     ")": (0, None, None, None, None),
     "symbol": (0, "symbol", None, None, None),
     "string": (0, "string", None, None, None),
     "end": (0, None, None, None, None),
 }
 
 keywords = {'and', 'or', 'not'}
 
 globchars = ".*{}[]?/\\_"
 
 def tokenize(program):
     pos, l = 0, len(program)
     program = pycompat.bytestr(program)
     while pos < l:
         c = program[pos]
         if c.isspace(): # skip inter-token whitespace
             pass
         elif c in "(),-:|&+!": # handle simple operators
             yield (c, None, pos)
         elif (c in '"\'' or c == 'r' and
               program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings
             if c == 'r':
                 pos += 1
                 c = program[pos]
                 decode = lambda x: x
             else:
                 decode = parser.unescapestr
             pos += 1
             s = pos
             while pos < l: # find closing quote
                 d = program[pos]
                 if d == '\\': # skip over escaped characters
                     pos += 2
                     continue
                 if d == c:
                     yield ('string', decode(program[s:pos]), s)
                     break
                 pos += 1
             else:
                 raise error.ParseError(_("unterminated string"), s)
         elif c.isalnum() or c in globchars or ord(c) > 127:
             # gather up a symbol/keyword
             s = pos
             pos += 1
             while pos < l: # find end of symbol
                 d = program[pos]
                 if not (d.isalnum() or d in globchars or ord(d) > 127):
                     break
                 pos += 1
             sym = program[s:pos]
             if sym in keywords: # operator keywords
                 yield (sym, None, s)
             else:
                 yield ('symbol', sym, s)
             pos -= 1
         else:
             raise error.ParseError(_("syntax error"), pos)
         pos += 1
     yield ('end', None, pos)
 
 def parse(expr):
     p = parser.parser(elements)
     tree, pos = p.parse(tokenize(expr))
     if pos != len(expr):
         raise error.ParseError(_("invalid token"), pos)
     return tree
 
 def getsymbol(x):
     if x and x[0] == 'symbol':
         return x[1]
     raise error.ParseError(_('not a symbol'))
 
 def getstring(x, err):
     if x and (x[0] == 'string' or x[0] == 'symbol'):
         return x[1]
     raise error.ParseError(err)
 
 def _getkindpat(x, y, allkinds, err):
     kind = getsymbol(x)
     pat = getstring(y, err)
     if kind not in allkinds:
         raise error.ParseError(_("invalid pattern kind: %s") % kind)
     return '%s:%s' % (kind, pat)
 
 def getpattern(x, allkinds, err):
     if x and x[0] == 'kindpat':
         return _getkindpat(x[1], x[2], allkinds, err)
     return getstring(x, err)
 
 def getlist(x):
     if not x:
         return []
     if x[0] == 'list':
         return getlist(x[1]) + [x[2]]
     return [x]
 
 def getargs(x, min, max, err):
     l = getlist(x)
     if len(l) < min or len(l) > max:
         raise error.ParseError(err)
     return l
 
 def getset(mctx, x):
     if not x:
         raise error.ParseError(_("missing argument"))
     return methods[x[0]](mctx, *x[1:])
 
 def stringset(mctx, x):
     m = mctx.matcher([x])
     return [f for f in mctx.subset if m(f)]
 
 def kindpatset(mctx, x, y):
     return stringset(mctx, _getkindpat(x, y, matchmod.allpatternkinds,
                                        _("pattern must be a string")))
 
 def andset(mctx, x, y):
     return getset(mctx.narrow(getset(mctx, x)), y)
 
 def orset(mctx, x, y):
     # needs optimizing
     xl = getset(mctx, x)
     yl = getset(mctx, y)
     return xl + [f for f in yl if f not in xl]
 
 def notset(mctx, x):
     s = set(getset(mctx, x))
     return [r for r in mctx.subset if r not in s]
 
 def minusset(mctx, x, y):
     xl = getset(mctx, x)
     yl = set(getset(mctx, y))
     return [f for f in xl if f not in yl]
 
 def negateset(mctx, x):
     raise error.ParseError(_("can't use negate operator in this context"))
 
 def listset(mctx, a, b):
     raise error.ParseError(_("can't use a list in this context"),
                            hint=_('see hg help "filesets.x or y"'))
 
 def func(mctx, a, b):
     funcname = getsymbol(a)
     if funcname in symbols:
         enabled = mctx._existingenabled
         mctx._existingenabled = funcname in _existingcallers
         try:
             return symbols[funcname](mctx, b)
         finally:
             mctx._existingenabled = enabled
 
     keep = lambda fn: getattr(fn, '__doc__', None) is not None
 
     syms = [s for (s, fn) in symbols.items() if keep(fn)]
     raise error.UnknownIdentifier(funcname, syms)
 
 # symbols are callable like:
 #  fun(mctx, x)
 # with:
 #  mctx - current matchctx instance
 #  x - argument in tree form
 symbols = {}
 
 # filesets using matchctx.status()
 _statuscallers = set()
 
 # filesets using matchctx.existing()
 _existingcallers = set()
 
 predicate = registrar.filesetpredicate()
 
 @predicate('modified()', callstatus=True)
 def modified(mctx, x):
     """File that is modified according to :hg:`status`.
     """
     # i18n: "modified" is a keyword
     getargs(x, 0, 0, _("modified takes no arguments"))
     s = set(mctx.status().modified)
     return [f for f in mctx.subset if f in s]
 
 @predicate('added()', callstatus=True)
 def added(mctx, x):
     """File that is added according to :hg:`status`.
     """
     # i18n: "added" is a keyword
     getargs(x, 0, 0, _("added takes no arguments"))
     s = set(mctx.status().added)
     return [f for f in mctx.subset if f in s]
 
 @predicate('removed()', callstatus=True)
 def removed(mctx, x):
     """File that is removed according to :hg:`status`.
     """
     # i18n: "removed" is a keyword
     getargs(x, 0, 0, _("removed takes no arguments"))
     s = set(mctx.status().removed)
     return [f for f in mctx.subset if f in s]
 
 @predicate('deleted()', callstatus=True)
 def deleted(mctx, x):
     """Alias for ``missing()``.
     """
     # i18n: "deleted" is a keyword
     getargs(x, 0, 0, _("deleted takes no arguments"))
     s = set(mctx.status().deleted)
     return [f for f in mctx.subset if f in s]
 
 @predicate('missing()', callstatus=True)
 def missing(mctx, x):
     """File that is missing according to :hg:`status`.
     """
     # i18n: "missing" is a keyword
     getargs(x, 0, 0, _("missing takes no arguments"))
     s = set(mctx.status().deleted)
     return [f for f in mctx.subset if f in s]
 
 @predicate('unknown()', callstatus=True)
 def unknown(mctx, x):
     """File that is unknown according to :hg:`status`. These files will only be
     considered if this predicate is used.
     """
     # i18n: "unknown" is a keyword
     getargs(x, 0, 0, _("unknown takes no arguments"))
     s = set(mctx.status().unknown)
     return [f for f in mctx.subset if f in s]
 
 @predicate('ignored()', callstatus=True)
 def ignored(mctx, x):
     """File that is ignored according to :hg:`status`. These files will only be
     considered if this predicate is used.
     """
     # i18n: "ignored" is a keyword
     getargs(x, 0, 0, _("ignored takes no arguments"))
     s = set(mctx.status().ignored)
     return [f for f in mctx.subset if f in s]
 
 @predicate('clean()', callstatus=True)
 def clean(mctx, x):
     """File that is clean according to :hg:`status`.
     """
     # i18n: "clean" is a keyword
     getargs(x, 0, 0, _("clean takes no arguments"))
     s = set(mctx.status().clean)
     return [f for f in mctx.subset if f in s]
 
 @predicate('binary()', callexisting=True)
 def binary(mctx, x):
     """File that appears to be binary (contains NUL bytes).
     """
     # i18n: "binary" is a keyword
     getargs(x, 0, 0, _("binary takes no arguments"))
     return [f for f in mctx.existing() if mctx.ctx[f].isbinary()]
 
 @predicate('exec()', callexisting=True)
 def exec_(mctx, x):
     """File that is marked as executable.
     """
     # i18n: "exec" is a keyword
     getargs(x, 0, 0, _("exec takes no arguments"))
     return [f for f in mctx.existing() if mctx.ctx.flags(f) == 'x']
 
 @predicate('symlink()', callexisting=True)
 def symlink(mctx, x):
     """File that is marked as a symlink.
     """
     # i18n: "symlink" is a keyword
     getargs(x, 0, 0, _("symlink takes no arguments"))
     return [f for f in mctx.existing() if mctx.ctx.flags(f) == 'l']
 
 @predicate('resolved()')
 def resolved(mctx, x):
     """File that is marked resolved according to :hg:`resolve -l`.
     """
     # i18n: "resolved" is a keyword
     getargs(x, 0, 0, _("resolved takes no arguments"))
     if mctx.ctx.rev() is not None:
         return []
     ms = merge.mergestate.read(mctx.ctx.repo())
     return [f for f in mctx.subset if f in ms and ms[f] == 'r']
 
 @predicate('unresolved()')
 def unresolved(mctx, x):
     """File that is marked unresolved according to :hg:`resolve -l`.
     """
     # i18n: "unresolved" is a keyword
     getargs(x, 0, 0, _("unresolved takes no arguments"))
     if mctx.ctx.rev() is not None:
         return []
     ms = merge.mergestate.read(mctx.ctx.repo())
     return [f for f in mctx.subset if f in ms and ms[f] == 'u']
 
 @predicate('hgignore()')
 def hgignore(mctx, x):
     """File that matches the active .hgignore pattern.
     """
     # i18n: "hgignore" is a keyword
     getargs(x, 0, 0, _("hgignore takes no arguments"))
     ignore = mctx.ctx.repo().dirstate._ignore
     return [f for f in mctx.subset if ignore(f)]
 
 @predicate('portable()')
 def portable(mctx, x):
     """File that has a portable name. (This doesn't include filenames with case
     collisions.)
     """
     # i18n: "portable" is a keyword
     getargs(x, 0, 0, _("portable takes no arguments"))
     checkwinfilename = util.checkwinfilename
     return [f for f in mctx.subset if checkwinfilename(f) is None]
 
 @predicate('grep(regex)', callexisting=True)
 def grep(mctx, x):
     """File contains the given regular expression.
     """
     try:
         # i18n: "grep" is a keyword
         r = re.compile(getstring(x, _("grep requires a pattern")))
     except re.error as e:
         raise error.ParseError(_('invalid match pattern: %s') %
                                stringutil.forcebytestr(e))
     return [f for f in mctx.existing() if r.search(mctx.ctx[f].data())]
 
 def _sizetomax(s):
     try:
         s = s.strip().lower()
         for k, v in util._sizeunits:
             if s.endswith(k):
                 # max(4k) = 5k - 1, max(4.5k) = 4.6k - 1
                 n = s[:-len(k)]
                 inc = 1.0
                 if "." in n:
                     inc /= 10 ** len(n.split(".")[1])
                 return int((float(n) + inc) * v) - 1
         # no extension, this is a precise value
         return int(s)
     except ValueError:
         raise error.ParseError(_("couldn't parse size: %s") % s)
 
 def sizematcher(x):
     """Return a function(size) -> bool from the ``size()`` expression"""
 
     # i18n: "size" is a keyword
     expr = getstring(x, _("size requires an expression")).strip()
     if '-' in expr: # do we have a range?
         a, b = expr.split('-', 1)
         a = util.sizetoint(a)
         b = util.sizetoint(b)
         return lambda x: x >= a and x <= b
     elif expr.startswith("<="):
         a = util.sizetoint(expr[2:])
         return lambda x: x <= a
     elif expr.startswith("<"):
         a = util.sizetoint(expr[1:])
         return lambda x: x < a
     elif expr.startswith(">="):
         a = util.sizetoint(expr[2:])
         return lambda x: x >= a
     elif expr.startswith(">"):
         a = util.sizetoint(expr[1:])
         return lambda x: x > a
     else:
         a = util.sizetoint(expr)
         b = _sizetomax(expr)
         return lambda x: x >= a and x <= b
 
 @predicate('size(expression)', callexisting=True)
 def size(mctx, x):
     """File size matches the given expression. Examples:
 
     - size('1k') - files from 1024 to 2047 bytes
     - size('< 20k') - files less than 20480 bytes
     - size('>= .5MB') - files at least 524288 bytes
     - size('4k - 1MB') - files from 4096 bytes to 1048576 bytes
     """
     m = sizematcher(x)
     return [f for f in mctx.existing() if m(mctx.ctx[f].size())]
 
 @predicate('encoding(name)', callexisting=True)
 def encoding(mctx, x):
     """File can be successfully decoded with the given character
     encoding. May not be useful for encodings other than ASCII and
     UTF-8.
     """
 
     # i18n: "encoding" is a keyword
     enc = getstring(x, _("encoding requires an encoding name"))
 
     s = []
     for f in mctx.existing():
         d = mctx.ctx[f].data()
         try:
             d.decode(pycompat.sysstr(enc))
         except LookupError:
             raise error.Abort(_("unknown encoding '%s'") % enc)
         except UnicodeDecodeError:
             continue
         s.append(f)
 
     return s
 
 @predicate('eol(style)', callexisting=True)
 def eol(mctx, x):
     """File contains newlines of the given style (dos, unix, mac). Binary
     files are excluded, files with mixed line endings match multiple
     styles.
     """
 
     # i18n: "eol" is a keyword
     enc = getstring(x, _("eol requires a style name"))
 
     s = []
     for f in mctx.existing():
         fctx = mctx.ctx[f]
         if fctx.isbinary():
             continue
         d = fctx.data()
         if (enc == 'dos' or enc == 'win') and '\r\n' in d:
             s.append(f)
         elif enc == 'unix' and re.search('(?<!\r)\n', d):
             s.append(f)
         elif enc == 'mac' and re.search('\r(?!\n)', d):
             s.append(f)
     return s
 
 @predicate('copied()')
 def copied(mctx, x):
     """File that is recorded as being copied.
     """
     # i18n: "copied" is a keyword
     getargs(x, 0, 0, _("copied takes no arguments"))
     s = []
     for f in mctx.subset:
         if f in mctx.ctx:
             p = mctx.ctx[f].parents()
             if p and p[0].path() != f:
                 s.append(f)
     return s
 
 @predicate('revs(revs, pattern)')
 def revs(mctx, x):
     """Evaluate set in the specified revisions. If the revset match multiple
     revs, this will return file matching pattern in any of the revision.
     """
     # i18n: "revs" is a keyword
     r, x = getargs(x, 2, 2, _("revs takes two arguments"))
     # i18n: "revs" is a keyword
     revspec = getstring(r, _("first argument to revs must be a revision"))
     repo = mctx.ctx.repo()
     revs = scmutil.revrange(repo, [revspec])
 
     found = set()
     result = []
     for r in revs:
         ctx = repo[r]
         for f in getset(mctx.switch(ctx, _buildstatus(ctx, x)), x):
             if f not in found:
                 found.add(f)
                 result.append(f)
     return result
 
 @predicate('status(base, rev, pattern)')
 def status(mctx, x):
     """Evaluate predicate using status change between ``base`` and
     ``rev``. Examples:
 
     - ``status(3, 7, added())`` - matches files added from "3" to "7"
     """
     repo = mctx.ctx.repo()
     # i18n: "status" is a keyword
     b, r, x = getargs(x, 3, 3, _("status takes three arguments"))
     # i18n: "status" is a keyword
     baseerr = _("first argument to status must be a revision")
     baserevspec = getstring(b, baseerr)
     if not baserevspec:
         raise error.ParseError(baseerr)
     reverr = _("second argument to status must be a revision")
     revspec = getstring(r, reverr)
     if not revspec:
         raise error.ParseError(reverr)
     basectx, ctx = scmutil.revpair(repo, [baserevspec, revspec])
     return getset(mctx.switch(ctx, _buildstatus(ctx, x, basectx=basectx)), x)
 
 @predicate('subrepo([pattern])')
 def subrepo(mctx, x):
     """Subrepositories whose paths match the given pattern.
     """
     # i18n: "subrepo" is a keyword
     getargs(x, 0, 1, _("subrepo takes at most one argument"))
     ctx = mctx.ctx
     sstate = sorted(ctx.substate)
     if x:
         pat = getpattern(x, matchmod.allpatternkinds,
                          # i18n: "subrepo" is a keyword
                          _("subrepo requires a pattern or no arguments"))
         fast = not matchmod.patkind(pat)
         if fast:
             def m(s):
                 return (s == pat)
         else:
             m = matchmod.match(ctx.repo().root, '', [pat], ctx=ctx)
         return [sub for sub in sstate if m(sub)]
     else:
         return [sub for sub in sstate]
 
 methods = {
     'string': stringset,
     'symbol': stringset,
     'kindpat': kindpatset,
     'and': andset,
     'or': orset,
     'minus': minusset,
     'negate': negateset,
     'list': listset,
     'group': getset,
     'not': notset,
     'func': func,
 }
 
 class matchctx(object):
     def __init__(self, ctx, subset, status=None):
         self.ctx = ctx
         self.subset = subset
         self._status = status
         self._existingenabled = False
     def status(self):
         return self._status
     def matcher(self, patterns):
         return self.ctx.match(patterns)
     def filter(self, files):
         return [f for f in files if f in self.subset]
     def existing(self):
         if not self._existingenabled:
             raise error.ProgrammingError('unexpected existing() invocation')
         if self._status is not None:
             removed = set(self._status[3])
             unknown = set(self._status[4] + self._status[5])
         else:
             removed = set()
             unknown = set()
         return (f for f in self.subset
                 if (f in self.ctx and f not in removed) or f in unknown)
     def narrow(self, files):
         return matchctx(self.ctx, self.filter(files), self._status)
     def switch(self, ctx, status=None):
         subset = self.filter(_buildsubset(ctx, status))
         return matchctx(ctx, subset, status)
 
 class fullmatchctx(matchctx):
     """A match context where any files in any revisions should be valid"""
 
     def __init__(self, ctx, status=None):
         subset = _buildsubset(ctx, status)
         super(fullmatchctx, self).__init__(ctx, subset, status)
     def switch(self, ctx, status=None):
         return fullmatchctx(ctx, status)
 
 # filesets using matchctx.switch()
 _switchcallers = [
     'revs',
     'status',
 ]
 
 def _intree(funcs, tree):
     if isinstance(tree, tuple):
         if tree[0] == 'func' and tree[1][0] == 'symbol':
             if tree[1][1] in funcs:
                 return True
             if tree[1][1] in _switchcallers:
                 # arguments won't be evaluated in the current context
                 return False
         for s in tree[1:]:
             if _intree(funcs, s):
                 return True
     return False
 
 def _buildsubset(ctx, status):
     if status:
         subset = []
         for c in status:
             subset.extend(c)
         return subset
     else:
         return list(ctx.walk(ctx.match([])))
 
-def getfileset(ctx, expr):
+def match(ctx, expr, badfn=None):
+    """Create a matcher for a single fileset expression"""
+    repo = ctx.repo()
     tree = parse(expr)
-    return getset(fullmatchctx(ctx, _buildstatus(ctx, tree)), tree)
+    fset = getset(fullmatchctx(ctx, _buildstatus(ctx, tree)), tree)
+    return matchmod.predicatematcher(repo.root, repo.getcwd(),
+                                     fset.__contains__,
+                                     predrepr='fileset', badfn=badfn)
 
 def _buildstatus(ctx, tree, basectx=None):
     # do we need status info?
 
     # temporaty boolean to simplify the next conditional
     purewdir = ctx.rev() is None and basectx is None
 
     if (_intree(_statuscallers, tree) or
         # Using matchctx.existing() on a workingctx requires us to check
         # for deleted files.
         (purewdir and _intree(_existingcallers, tree))):
         unknown = _intree(['unknown'], tree)
         ignored = _intree(['ignored'], tree)
 
         r = ctx.repo()
         if basectx is None:
             basectx = ctx.p1()
         return r.status(basectx, ctx,
                         unknown=unknown, ignored=ignored, clean=True)
     else:
         return None
 
 def prettyformat(tree):
     return parser.prettyformat(tree, ('string', 'symbol'))
 
 def loadpredicate(ui, extname, registrarobj):
     """Load fileset predicates from specified registrarobj
     """
     for name, func in registrarobj._table.iteritems():
         symbols[name] = func
         if func._callstatus:
             _statuscallers.add(name)
         if func._callexisting:
             _existingcallers.add(name)
 
 # load built-in predicates explicitly to setup _statuscallers/_existingcallers
 loadpredicate(None, None, predicate)
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = symbols.values()

mercurial/match.py

@@ -1,1133 +1,1132 b''
 # match.py - filename matching
 #
 #  Copyright 2008, 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.
 
 from __future__ import absolute_import, print_function
 
 import copy
 import os
 import re
 
 from .i18n import _
 from . import (
     encoding,
     error,
     pathutil,
     pycompat,
     util,
 )
 from .utils import (
     stringutil,
 )
 
 allpatternkinds = ('re', 'glob', 'path', 'relglob', 'relpath', 'relre',
                    'listfile', 'listfile0', 'set', 'include', 'subinclude',
                    'rootfilesin')
 cwdrelativepatternkinds = ('relpath', 'glob')
 
 propertycache = util.propertycache
 
 def _rematcher(regex):
     '''compile the regexp with the best available regexp engine and return a
     matcher function'''
     m = util.re.compile(regex)
     try:
         # slightly faster, provided by facebook's re2 bindings
         return m.test_match
     except AttributeError:
         return m.match
 
-def _expandsets(kindpats, ctx, listsubrepos):
-    '''Returns the kindpats list with the 'set' patterns expanded.'''
-    fset = set()
+def _expandsets(root, cwd, kindpats, ctx, listsubrepos, badfn):
+    '''Returns the kindpats list with the 'set' patterns expanded to matchers'''
+    matchers = []
     other = []
 
     for kind, pat, source in kindpats:
         if kind == 'set':
             if not ctx:
                 raise error.ProgrammingError("fileset expression with no "
                                              "context")
-            s = ctx.getfileset(pat)
-            fset.update(s)
+            matchers.append(ctx.matchfileset(pat, badfn=badfn))
 
             if listsubrepos:
                 for subpath in ctx.substate:
-                    s = ctx.sub(subpath).getfileset(pat)
-                    fset.update(subpath + '/' + f for f in s)
+                    sm = ctx.sub(subpath).matchfileset(pat, badfn=badfn)
+                    pm = prefixdirmatcher(root, cwd, subpath, sm, badfn=badfn)
+                    matchers.append(pm)
 
             continue
         other.append((kind, pat, source))
-    return fset, other
+    return matchers, other
 
 def _expandsubinclude(kindpats, root):
     '''Returns the list of subinclude matcher args and the kindpats without the
     subincludes in it.'''
     relmatchers = []
     other = []
 
     for kind, pat, source in kindpats:
         if kind == 'subinclude':
             sourceroot = pathutil.dirname(util.normpath(source))
             pat = util.pconvert(pat)
             path = pathutil.join(sourceroot, pat)
 
             newroot = pathutil.dirname(path)
             matcherargs = (newroot, '', [], ['include:%s' % path])
 
             prefix = pathutil.canonpath(root, root, newroot)
             if prefix:
                 prefix += '/'
             relmatchers.append((prefix, matcherargs))
         else:
             other.append((kind, pat, source))
 
     return relmatchers, other
 
 def _kindpatsalwaysmatch(kindpats):
     """"Checks whether the kindspats match everything, as e.g.
     'relpath:.' does.
     """
     for kind, pat, source in kindpats:
         if pat != '' or kind not in ['relpath', 'glob']:
             return False
     return True
 
 def _buildkindpatsmatcher(matchercls, root, cwd, kindpats, ctx=None,
                           listsubrepos=False, badfn=None):
-    fset, kindpats = _expandsets(kindpats, ctx, listsubrepos)
     matchers = []
+    fms, kindpats = _expandsets(root, cwd, kindpats, ctx=ctx,
+                                listsubrepos=listsubrepos, badfn=badfn)
     if kindpats:
         m = matchercls(root, cwd, kindpats, listsubrepos=listsubrepos,
                        badfn=badfn)
         matchers.append(m)
-    if fset:
-        m = predicatematcher(root, cwd, fset.__contains__,
-                             predrepr='fileset', badfn=badfn)
-        matchers.append(m)
+    if fms:
+        matchers.extend(fms)
     if not matchers:
         return nevermatcher(root, cwd, badfn=badfn)
     if len(matchers) == 1:
         return matchers[0]
     return unionmatcher(matchers)
 
 def match(root, cwd, patterns=None, include=None, exclude=None, default='glob',
           exact=False, auditor=None, ctx=None, listsubrepos=False, warn=None,
           badfn=None, icasefs=False):
     """build an object to match a set of file patterns
 
     arguments:
     root - the canonical root of the tree you're matching against
     cwd - the current working directory, if relevant
     patterns - patterns to find
     include - patterns to include (unless they are excluded)
     exclude - patterns to exclude (even if they are included)
     default - if a pattern in patterns has no explicit type, assume this one
     exact - patterns are actually filenames (include/exclude still apply)
     warn - optional function used for printing warnings
     badfn - optional bad() callback for this matcher instead of the default
     icasefs - make a matcher for wdir on case insensitive filesystems, which
         normalizes the given patterns to the case in the filesystem
 
     a pattern is one of:
     'glob:<glob>' - a glob relative to cwd
     're:<regexp>' - a regular expression
     'path:<path>' - a path relative to repository root, which is matched
                     recursively
     'rootfilesin:<path>' - a path relative to repository root, which is
                     matched non-recursively (will not match subdirectories)
     'relglob:<glob>' - an unrooted glob (*.c matches C files in all dirs)
     'relpath:<path>' - a path relative to cwd
     'relre:<regexp>' - a regexp that needn't match the start of a name
     'set:<fileset>' - a fileset expression
     'include:<path>' - a file of patterns to read and include
     'subinclude:<path>' - a file of patterns to match against files under
                           the same directory
     '<something>' - a pattern of the specified default type
     """
     normalize = _donormalize
     if icasefs:
         if exact:
             raise error.ProgrammingError("a case-insensitive exact matcher "
                                          "doesn't make sense")
         dirstate = ctx.repo().dirstate
         dsnormalize = dirstate.normalize
 
         def normalize(patterns, default, root, cwd, auditor, warn):
             kp = _donormalize(patterns, default, root, cwd, auditor, warn)
             kindpats = []
             for kind, pats, source in kp:
                 if kind not in ('re', 'relre'):  # regex can't be normalized
                     p = pats
                     pats = dsnormalize(pats)
 
                     # Preserve the original to handle a case only rename.
                     if p != pats and p in dirstate:
                         kindpats.append((kind, p, source))
 
                 kindpats.append((kind, pats, source))
             return kindpats
 
     if exact:
         m = exactmatcher(root, cwd, patterns, badfn)
     elif patterns:
         kindpats = normalize(patterns, default, root, cwd, auditor, warn)
         if _kindpatsalwaysmatch(kindpats):
             m = alwaysmatcher(root, cwd, badfn, relativeuipath=True)
         else:
             m = _buildkindpatsmatcher(patternmatcher, root, cwd, kindpats,
                                       ctx=ctx, listsubrepos=listsubrepos,
                                       badfn=badfn)
     else:
         # It's a little strange that no patterns means to match everything.
         # Consider changing this to match nothing (probably using nevermatcher).
         m = alwaysmatcher(root, cwd, badfn)
 
     if include:
         kindpats = normalize(include, 'glob', root, cwd, auditor, warn)
         im = _buildkindpatsmatcher(includematcher, root, cwd, kindpats, ctx=ctx,
                                    listsubrepos=listsubrepos, badfn=None)
         m = intersectmatchers(m, im)
     if exclude:
         kindpats = normalize(exclude, 'glob', root, cwd, auditor, warn)
         em = _buildkindpatsmatcher(includematcher, root, cwd, kindpats, ctx=ctx,
                                    listsubrepos=listsubrepos, badfn=None)
         m = differencematcher(m, em)
     return m
 
 def exact(root, cwd, files, badfn=None):
     return exactmatcher(root, cwd, files, badfn=badfn)
 
 def always(root, cwd):
     return alwaysmatcher(root, cwd)
 
 def never(root, cwd):
     return nevermatcher(root, cwd)
 
 def badmatch(match, badfn):
     """Make a copy of the given matcher, replacing its bad method with the given
     one.
     """
     m = copy.copy(match)
     m.bad = badfn
     return m
 
 def _donormalize(patterns, default, root, cwd, auditor, warn):
     '''Convert 'kind:pat' from the patterns list to tuples with kind and
     normalized and rooted patterns and with listfiles expanded.'''
     kindpats = []
     for kind, pat in [_patsplit(p, default) for p in patterns]:
         if kind in cwdrelativepatternkinds:
             pat = pathutil.canonpath(root, cwd, pat, auditor)
         elif kind in ('relglob', 'path', 'rootfilesin'):
             pat = util.normpath(pat)
         elif kind in ('listfile', 'listfile0'):
             try:
                 files = util.readfile(pat)
                 if kind == 'listfile0':
                     files = files.split('\0')
                 else:
                     files = files.splitlines()
                 files = [f for f in files if f]
             except EnvironmentError:
                 raise error.Abort(_("unable to read file list (%s)") % pat)
             for k, p, source in _donormalize(files, default, root, cwd,
                                              auditor, warn):
                 kindpats.append((k, p, pat))
             continue
         elif kind == 'include':
             try:
                 fullpath = os.path.join(root, util.localpath(pat))
                 includepats = readpatternfile(fullpath, warn)
                 for k, p, source in _donormalize(includepats, default,
                                                  root, cwd, auditor, warn):
                     kindpats.append((k, p, source or pat))
             except error.Abort as inst:
                 raise error.Abort('%s: %s' % (pat, inst[0]))
             except IOError as inst:
                 if warn:
                     warn(_("skipping unreadable pattern file '%s': %s\n") %
                          (pat, stringutil.forcebytestr(inst.strerror)))
             continue
         # else: re or relre - which cannot be normalized
         kindpats.append((kind, pat, ''))
     return kindpats
 
 class basematcher(object):
 
     def __init__(self, root, cwd, badfn=None, relativeuipath=True):
         self._root = root
         self._cwd = cwd
         if badfn is not None:
             self.bad = badfn
         self._relativeuipath = relativeuipath
 
     def __call__(self, fn):
         return self.matchfn(fn)
     def __iter__(self):
         for f in self._files:
             yield f
     # Callbacks related to how the matcher is used by dirstate.walk.
     # Subscribers to these events must monkeypatch the matcher object.
     def bad(self, f, msg):
         '''Callback from dirstate.walk for each explicit file that can't be
         found/accessed, with an error message.'''
 
     # If an explicitdir is set, it will be called when an explicitly listed
     # directory is visited.
     explicitdir = None
 
     # If an traversedir is set, it will be called when a directory discovered
     # by recursive traversal is visited.
     traversedir = None
 
     def abs(self, f):
         '''Convert a repo path back to path that is relative to the root of the
         matcher.'''
         return f
 
     def rel(self, f):
         '''Convert repo path back to path that is relative to cwd of matcher.'''
         return util.pathto(self._root, self._cwd, f)
 
     def uipath(self, f):
         '''Convert repo path to a display path.  If patterns or -I/-X were used
         to create this matcher, the display path will be relative to cwd.
         Otherwise it is relative to the root of the repo.'''
         return (self._relativeuipath and self.rel(f)) or self.abs(f)
 
     @propertycache
     def _files(self):
         return []
 
     def files(self):
         '''Explicitly listed files or patterns or roots:
         if no patterns or .always(): empty list,
         if exact: list exact files,
         if not .anypats(): list all files and dirs,
         else: optimal roots'''
         return self._files
 
     @propertycache
     def _fileset(self):
         return set(self._files)
 
     def exact(self, f):
         '''Returns True if f is in .files().'''
         return f in self._fileset
 
     def matchfn(self, f):
         return False
 
     def visitdir(self, dir):
         '''Decides whether a directory should be visited based on whether it
         has potential matches in it or one of its subdirectories. This is
         based on the match's primary, included, and excluded patterns.
 
         Returns the string 'all' if the given directory and all subdirectories
         should be visited. Otherwise returns True or False indicating whether
         the given directory should be visited.
         '''
         return True
 
     def always(self):
         '''Matcher will match everything and .files() will be empty --
         optimization might be possible.'''
         return False
 
     def isexact(self):
         '''Matcher will match exactly the list of files in .files() --
         optimization might be possible.'''
         return False
 
     def prefix(self):
         '''Matcher will match the paths in .files() recursively --
         optimization might be possible.'''
         return False
 
     def anypats(self):
         '''None of .always(), .isexact(), and .prefix() is true --
         optimizations will be difficult.'''
         return not self.always() and not self.isexact() and not self.prefix()
 
 class alwaysmatcher(basematcher):
     '''Matches everything.'''
 
     def __init__(self, root, cwd, badfn=None, relativeuipath=False):
         super(alwaysmatcher, self).__init__(root, cwd, badfn,
                                             relativeuipath=relativeuipath)
 
     def always(self):
         return True
 
     def matchfn(self, f):
         return True
 
     def visitdir(self, dir):
         return 'all'
 
     def __repr__(self):
         return r'<alwaysmatcher>'
 
 class nevermatcher(basematcher):
     '''Matches nothing.'''
 
     def __init__(self, root, cwd, badfn=None):
         super(nevermatcher, self).__init__(root, cwd, badfn)
 
     # It's a little weird to say that the nevermatcher is an exact matcher
     # or a prefix matcher, but it seems to make sense to let callers take
     # fast paths based on either. There will be no exact matches, nor any
     # prefixes (files() returns []), so fast paths iterating over them should
     # be efficient (and correct).
     def isexact(self):
         return True
 
     def prefix(self):
         return True
 
     def visitdir(self, dir):
         return False
 
     def __repr__(self):
         return r'<nevermatcher>'
 
 class predicatematcher(basematcher):
     """A matcher adapter for a simple boolean function"""
 
     def __init__(self, root, cwd, predfn, predrepr=None, badfn=None):
         super(predicatematcher, self).__init__(root, cwd, badfn)
         self.matchfn = predfn
         self._predrepr = predrepr
 
     @encoding.strmethod
     def __repr__(self):
         s = (stringutil.buildrepr(self._predrepr)
              or pycompat.byterepr(self.matchfn))
         return '<predicatenmatcher pred=%s>' % s
 
 class patternmatcher(basematcher):
 
     def __init__(self, root, cwd, kindpats, listsubrepos=False, badfn=None):
         super(patternmatcher, self).__init__(root, cwd, badfn)
 
         self._files = _explicitfiles(kindpats)
         self._prefix = _prefix(kindpats)
         self._pats, self.matchfn = _buildmatch(kindpats, '$', listsubrepos,
                                                root)
 
     @propertycache
     def _dirs(self):
         return set(util.dirs(self._fileset)) | {'.'}
 
     def visitdir(self, dir):
         if self._prefix and dir in self._fileset:
             return 'all'
         return ('.' in self._fileset or
                 dir in self._fileset or
                 dir in self._dirs or
                 any(parentdir in self._fileset
                     for parentdir in util.finddirs(dir)))
 
     def prefix(self):
         return self._prefix
 
     @encoding.strmethod
     def __repr__(self):
         return ('<patternmatcher patterns=%r>' % pycompat.bytestr(self._pats))
 
 class includematcher(basematcher):
 
     def __init__(self, root, cwd, kindpats, listsubrepos=False, badfn=None):
         super(includematcher, self).__init__(root, cwd, badfn)
 
         self._pats, self.matchfn = _buildmatch(kindpats, '(?:/|$)',
                                                listsubrepos, root)
         self._prefix = _prefix(kindpats)
         roots, dirs = _rootsanddirs(kindpats)
         # roots are directories which are recursively included.
         self._roots = set(roots)
         # dirs are directories which are non-recursively included.
         self._dirs = set(dirs)
 
     def visitdir(self, dir):
         if self._prefix and dir in self._roots:
             return 'all'
         return ('.' in self._roots or
                 dir in self._roots or
                 dir in self._dirs or
                 any(parentdir in self._roots
                     for parentdir in util.finddirs(dir)))
 
     @encoding.strmethod
     def __repr__(self):
         return ('<includematcher includes=%r>' % pycompat.bytestr(self._pats))
 
 class exactmatcher(basematcher):
     '''Matches the input files exactly. They are interpreted as paths, not
     patterns (so no kind-prefixes).
     '''
 
     def __init__(self, root, cwd, files, badfn=None):
         super(exactmatcher, self).__init__(root, cwd, badfn)
 
         if isinstance(files, list):
             self._files = files
         else:
             self._files = list(files)
 
     matchfn = basematcher.exact
 
     @propertycache
     def _dirs(self):
         return set(util.dirs(self._fileset)) | {'.'}
 
     def visitdir(self, dir):
         return dir in self._dirs
 
     def isexact(self):
         return True
 
     @encoding.strmethod
     def __repr__(self):
         return ('<exactmatcher files=%r>' % self._files)
 
 class differencematcher(basematcher):
     '''Composes two matchers by matching if the first matches and the second
     does not.
 
     The second matcher's non-matching-attributes (root, cwd, bad, explicitdir,
     traversedir) are ignored.
     '''
     def __init__(self, m1, m2):
         super(differencematcher, self).__init__(m1._root, m1._cwd)
         self._m1 = m1
         self._m2 = m2
         self.bad = m1.bad
         self.explicitdir = m1.explicitdir
         self.traversedir = m1.traversedir
 
     def matchfn(self, f):
         return self._m1(f) and not self._m2(f)
 
     @propertycache
     def _files(self):
         if self.isexact():
             return [f for f in self._m1.files() if self(f)]
         # If m1 is not an exact matcher, we can't easily figure out the set of
         # files, because its files() are not always files. For example, if
         # m1 is "path:dir" and m2 is "rootfileins:.", we don't
         # want to remove "dir" from the set even though it would match m2,
         # because the "dir" in m1 may not be a file.
         return self._m1.files()
 
     def visitdir(self, dir):
         if self._m2.visitdir(dir) == 'all':
             return False
         return bool(self._m1.visitdir(dir))
 
     def isexact(self):
         return self._m1.isexact()
 
     @encoding.strmethod
     def __repr__(self):
         return ('<differencematcher m1=%r, m2=%r>' % (self._m1, self._m2))
 
 def intersectmatchers(m1, m2):
     '''Composes two matchers by matching if both of them match.
 
     The second matcher's non-matching-attributes (root, cwd, bad, explicitdir,
     traversedir) are ignored.
     '''
     if m1 is None or m2 is None:
         return m1 or m2
     if m1.always():
         m = copy.copy(m2)
         # TODO: Consider encapsulating these things in a class so there's only
         # one thing to copy from m1.
         m.bad = m1.bad
         m.explicitdir = m1.explicitdir
         m.traversedir = m1.traversedir
         m.abs = m1.abs
         m.rel = m1.rel
         m._relativeuipath |= m1._relativeuipath
         return m
     if m2.always():
         m = copy.copy(m1)
         m._relativeuipath |= m2._relativeuipath
         return m
     return intersectionmatcher(m1, m2)
 
 class intersectionmatcher(basematcher):
     def __init__(self, m1, m2):
         super(intersectionmatcher, self).__init__(m1._root, m1._cwd)
         self._m1 = m1
         self._m2 = m2
         self.bad = m1.bad
         self.explicitdir = m1.explicitdir
         self.traversedir = m1.traversedir
 
     @propertycache
     def _files(self):
         if self.isexact():
             m1, m2 = self._m1, self._m2
             if not m1.isexact():
                 m1, m2 = m2, m1
             return [f for f in m1.files() if m2(f)]
         # It neither m1 nor m2 is an exact matcher, we can't easily intersect
         # the set of files, because their files() are not always files. For
         # example, if intersecting a matcher "-I glob:foo.txt" with matcher of
         # "path:dir2", we don't want to remove "dir2" from the set.
         return self._m1.files() + self._m2.files()
 
     def matchfn(self, f):
         return self._m1(f) and self._m2(f)
 
     def visitdir(self, dir):
         visit1 = self._m1.visitdir(dir)
         if visit1 == 'all':
             return self._m2.visitdir(dir)
         # bool() because visit1=True + visit2='all' should not be 'all'
         return bool(visit1 and self._m2.visitdir(dir))
 
     def always(self):
         return self._m1.always() and self._m2.always()
 
     def isexact(self):
         return self._m1.isexact() or self._m2.isexact()
 
     @encoding.strmethod
     def __repr__(self):
         return ('<intersectionmatcher m1=%r, m2=%r>' % (self._m1, self._m2))
 
 class subdirmatcher(basematcher):
     """Adapt a matcher to work on a subdirectory only.
 
     The paths are remapped to remove/insert the path as needed:
 
     >>> from . import pycompat
     >>> m1 = match(b'root', b'', [b'a.txt', b'sub/b.txt'])
     >>> m2 = subdirmatcher(b'sub', m1)
     >>> bool(m2(b'a.txt'))
     False
     >>> bool(m2(b'b.txt'))
     True
     >>> bool(m2.matchfn(b'a.txt'))
     False
     >>> bool(m2.matchfn(b'b.txt'))
     True
     >>> m2.files()
     ['b.txt']
     >>> m2.exact(b'b.txt')
     True
     >>> util.pconvert(m2.rel(b'b.txt'))
     'sub/b.txt'
     >>> def bad(f, msg):
     ...     print(pycompat.sysstr(b"%s: %s" % (f, msg)))
     >>> m1.bad = bad
     >>> m2.bad(b'x.txt', b'No such file')
     sub/x.txt: No such file
     >>> m2.abs(b'c.txt')
     'sub/c.txt'
     """
 
     def __init__(self, path, matcher):
         super(subdirmatcher, self).__init__(matcher._root, matcher._cwd)
         self._path = path
         self._matcher = matcher
         self._always = matcher.always()
 
         self._files = [f[len(path) + 1:] for f in matcher._files
                        if f.startswith(path + "/")]
 
         # If the parent repo had a path to this subrepo and the matcher is
         # a prefix matcher, this submatcher always matches.
         if matcher.prefix():
             self._always = any(f == path for f in matcher._files)
 
     def bad(self, f, msg):
         self._matcher.bad(self._path + "/" + f, msg)
 
     def abs(self, f):
         return self._matcher.abs(self._path + "/" + f)
 
     def rel(self, f):
         return self._matcher.rel(self._path + "/" + f)
 
     def uipath(self, f):
         return self._matcher.uipath(self._path + "/" + f)
 
     def matchfn(self, f):
         # Some information is lost in the superclass's constructor, so we
         # can not accurately create the matching function for the subdirectory
         # from the inputs. Instead, we override matchfn() and visitdir() to
         # call the original matcher with the subdirectory path prepended.
         return self._matcher.matchfn(self._path + "/" + f)
 
     def visitdir(self, dir):
         if dir == '.':
             dir = self._path
         else:
             dir = self._path + "/" + dir
         return self._matcher.visitdir(dir)
 
     def always(self):
         return self._always
 
     def prefix(self):
         return self._matcher.prefix() and not self._always
 
     @encoding.strmethod
     def __repr__(self):
         return ('<subdirmatcher path=%r, matcher=%r>' %
                 (self._path, self._matcher))
 
 class prefixdirmatcher(basematcher):
     """Adapt a matcher to work on a parent directory.
 
     The matcher's non-matching-attributes (root, cwd, bad, explicitdir,
     traversedir) are ignored.
 
     The prefix path should usually be the relative path from the root of
     this matcher to the root of the wrapped matcher.
 
     >>> m1 = match(b'root/d/e', b'f', [b'../a.txt', b'b.txt'])
     >>> m2 = prefixdirmatcher(b'root', b'd/e/f', b'd/e', m1)
     >>> bool(m2(b'a.txt'),)
     False
     >>> bool(m2(b'd/e/a.txt'))
     True
     >>> bool(m2(b'd/e/b.txt'))
     False
     >>> m2.files()
     ['d/e/a.txt', 'd/e/f/b.txt']
     >>> m2.exact(b'd/e/a.txt')
     True
     >>> m2.visitdir(b'd')
     True
     >>> m2.visitdir(b'd/e')
     True
     >>> m2.visitdir(b'd/e/f')
     True
     >>> m2.visitdir(b'd/e/g')
     False
     >>> m2.visitdir(b'd/ef')
     False
     """
 
     def __init__(self, root, cwd, path, matcher, badfn=None):
         super(prefixdirmatcher, self).__init__(root, cwd, badfn)
         if not path:
             raise error.ProgrammingError('prefix path must not be empty')
         self._path = path
         self._pathprefix = path + '/'
         self._matcher = matcher
 
     @propertycache
     def _files(self):
         return [self._pathprefix + f for f in self._matcher._files]
 
     def matchfn(self, f):
         if not f.startswith(self._pathprefix):
             return False
         return self._matcher.matchfn(f[len(self._pathprefix):])
 
     @propertycache
     def _pathdirs(self):
         return set(util.finddirs(self._path)) | {'.'}
 
     def visitdir(self, dir):
         if dir == self._path:
             return self._matcher.visitdir('.')
         if dir.startswith(self._pathprefix):
             return self._matcher.visitdir(dir[len(self._pathprefix):])
         return dir in self._pathdirs
 
     def isexact(self):
         return self._matcher.isexact()
 
     def prefix(self):
         return self._matcher.prefix()
 
     @encoding.strmethod
     def __repr__(self):
         return ('<prefixdirmatcher path=%r, matcher=%r>'
                 % (pycompat.bytestr(self._path), self._matcher))
 
 class unionmatcher(basematcher):
     """A matcher that is the union of several matchers.
 
     The non-matching-attributes (root, cwd, bad, explicitdir, traversedir) are
     taken from the first matcher.
     """
 
     def __init__(self, matchers):
         m1 = matchers[0]
         super(unionmatcher, self).__init__(m1._root, m1._cwd)
         self.explicitdir = m1.explicitdir
         self.traversedir = m1.traversedir
         self._matchers = matchers
 
     def matchfn(self, f):
         for match in self._matchers:
             if match(f):
                 return True
         return False
 
     def visitdir(self, dir):
         r = False
         for m in self._matchers:
             v = m.visitdir(dir)
             if v == 'all':
                 return v
             r |= v
         return r
 
     @encoding.strmethod
     def __repr__(self):
         return ('<unionmatcher matchers=%r>' % self._matchers)
 
 def patkind(pattern, default=None):
     '''If pattern is 'kind:pat' with a known kind, return kind.'''
     return _patsplit(pattern, default)[0]
 
 def _patsplit(pattern, default):
     """Split a string into the optional pattern kind prefix and the actual
     pattern."""
     if ':' in pattern:
         kind, pat = pattern.split(':', 1)
         if kind in allpatternkinds:
             return kind, pat
     return default, pattern
 
 def _globre(pat):
     r'''Convert an extended glob string to a regexp string.
 
     >>> from . import pycompat
     >>> def bprint(s):
     ...     print(pycompat.sysstr(s))
     >>> bprint(_globre(br'?'))
     .
     >>> bprint(_globre(br'*'))
     [^/]*
     >>> bprint(_globre(br'**'))
     .*
     >>> bprint(_globre(br'**/a'))
     (?:.*/)?a
     >>> bprint(_globre(br'a/**/b'))
     a/(?:.*/)?b
     >>> bprint(_globre(br'[a*?!^][^b][!c]'))
     [a*?!^][\^b][^c]
     >>> bprint(_globre(br'{a,b}'))
     (?:a|b)
     >>> bprint(_globre(br'.\*\?'))
     \.\*\?
     '''
     i, n = 0, len(pat)
     res = ''
     group = 0
     escape = util.stringutil.reescape
     def peek():
         return i < n and pat[i:i + 1]
     while i < n:
         c = pat[i:i + 1]
         i += 1
         if c not in '*?[{},\\':
             res += escape(c)
         elif c == '*':
             if peek() == '*':
                 i += 1
                 if peek() == '/':
                     i += 1
                     res += '(?:.*/)?'
                 else:
                     res += '.*'
             else:
                 res += '[^/]*'
         elif c == '?':
             res += '.'
         elif c == '[':
             j = i
             if j < n and pat[j:j + 1] in '!]':
                 j += 1
             while j < n and pat[j:j + 1] != ']':
                 j += 1
             if j >= n:
                 res += '\\['
             else:
                 stuff = pat[i:j].replace('\\','\\\\')
                 i = j + 1
                 if stuff[0:1] == '!':
                     stuff = '^' + stuff[1:]
                 elif stuff[0:1] == '^':
                     stuff = '\\' + stuff
                 res = '%s[%s]' % (res, stuff)
         elif c == '{':
             group += 1
             res += '(?:'
         elif c == '}' and group:
             res += ')'
             group -= 1
         elif c == ',' and group:
             res += '|'
         elif c == '\\':
             p = peek()
             if p:
                 i += 1
                 res += escape(p)
             else:
                 res += escape(c)
         else:
             res += escape(c)
     return res
 
 def _regex(kind, pat, globsuffix):
     '''Convert a (normalized) pattern of any kind into a regular expression.
     globsuffix is appended to the regexp of globs.'''
     if not pat:
         return ''
     if kind == 're':
         return pat
     if kind in ('path', 'relpath'):
         if pat == '.':
             return ''
         return util.stringutil.reescape(pat) + '(?:/|$)'
     if kind == 'rootfilesin':
         if pat == '.':
             escaped = ''
         else:
             # Pattern is a directory name.
             escaped = util.stringutil.reescape(pat) + '/'
         # Anything after the pattern must be a non-directory.
         return escaped + '[^/]+$'
     if kind == 'relglob':
         return '(?:|.*/)' + _globre(pat) + globsuffix
     if kind == 'relre':
         if pat.startswith('^'):
             return pat
         return '.*' + pat
     if kind == 'glob':
         return _globre(pat) + globsuffix
     raise error.ProgrammingError('not a regex pattern: %s:%s' % (kind, pat))
 
 def _buildmatch(kindpats, globsuffix, listsubrepos, root):
     '''Return regexp string and a matcher function for kindpats.
     globsuffix is appended to the regexp of globs.'''
     matchfuncs = []
 
     subincludes, kindpats = _expandsubinclude(kindpats, root)
     if subincludes:
         submatchers = {}
         def matchsubinclude(f):
             for prefix, matcherargs in subincludes:
                 if f.startswith(prefix):
                     mf = submatchers.get(prefix)
                     if mf is None:
                         mf = match(*matcherargs)
                         submatchers[prefix] = mf
 
                     if mf(f[len(prefix):]):
                         return True
             return False
         matchfuncs.append(matchsubinclude)
 
     regex = ''
     if kindpats:
         regex, mf = _buildregexmatch(kindpats, globsuffix)
         matchfuncs.append(mf)
 
     if len(matchfuncs) == 1:
         return regex, matchfuncs[0]
     else:
         return regex, lambda f: any(mf(f) for mf in matchfuncs)
 
 def _buildregexmatch(kindpats, globsuffix):
     """Build a match function from a list of kinds and kindpats,
     return regexp string and a matcher function."""
     try:
         regex = '(?:%s)' % '|'.join([_regex(k, p, globsuffix)
                                      for (k, p, s) in kindpats])
         if len(regex) > 20000:
             raise OverflowError
         return regex, _rematcher(regex)
     except OverflowError:
         # We're using a Python with a tiny regex engine and we
         # made it explode, so we'll divide the pattern list in two
         # until it works
         l = len(kindpats)
         if l < 2:
             raise
         regexa, a = _buildregexmatch(kindpats[:l//2], globsuffix)
         regexb, b = _buildregexmatch(kindpats[l//2:], globsuffix)
         return regex, lambda s: a(s) or b(s)
     except re.error:
         for k, p, s in kindpats:
             try:
                 _rematcher('(?:%s)' % _regex(k, p, globsuffix))
             except re.error:
                 if s:
                     raise error.Abort(_("%s: invalid pattern (%s): %s") %
                                      (s, k, p))
                 else:
                     raise error.Abort(_("invalid pattern (%s): %s") % (k, p))
         raise error.Abort(_("invalid pattern"))
 
 def _patternrootsanddirs(kindpats):
     '''Returns roots and directories corresponding to each pattern.
 
     This calculates the roots and directories exactly matching the patterns and
     returns a tuple of (roots, dirs) for each. It does not return other
     directories which may also need to be considered, like the parent
     directories.
     '''
     r = []
     d = []
     for kind, pat, source in kindpats:
         if kind == 'glob': # find the non-glob prefix
             root = []
             for p in pat.split('/'):
                 if '[' in p or '{' in p or '*' in p or '?' in p:
                     break
                 root.append(p)
             r.append('/'.join(root) or '.')
         elif kind in ('relpath', 'path'):
             r.append(pat or '.')
         elif kind in ('rootfilesin',):
             d.append(pat or '.')
         else: # relglob, re, relre
             r.append('.')
     return r, d
 
 def _roots(kindpats):
     '''Returns root directories to match recursively from the given patterns.'''
     roots, dirs = _patternrootsanddirs(kindpats)
     return roots
 
 def _rootsanddirs(kindpats):
     '''Returns roots and exact directories from patterns.
 
     roots are directories to match recursively, whereas exact directories should
     be matched non-recursively. The returned (roots, dirs) tuple will also
     include directories that need to be implicitly considered as either, such as
     parent directories.
 
     >>> _rootsanddirs(
     ...     [(b'glob', b'g/h/*', b''), (b'glob', b'g/h', b''),
     ...      (b'glob', b'g*', b'')])
     (['g/h', 'g/h', '.'], ['g', '.'])
     >>> _rootsanddirs(
     ...     [(b'rootfilesin', b'g/h', b''), (b'rootfilesin', b'', b'')])
     ([], ['g/h', '.', 'g', '.'])
     >>> _rootsanddirs(
     ...     [(b'relpath', b'r', b''), (b'path', b'p/p', b''),
     ...      (b'path', b'', b'')])
     (['r', 'p/p', '.'], ['p', '.'])
     >>> _rootsanddirs(
     ...     [(b'relglob', b'rg*', b''), (b're', b're/', b''),
     ...      (b'relre', b'rr', b'')])
     (['.', '.', '.'], ['.'])
     '''
     r, d = _patternrootsanddirs(kindpats)
 
     # Append the parents as non-recursive/exact directories, since they must be
     # scanned to get to either the roots or the other exact directories.
     d.extend(util.dirs(d))
     d.extend(util.dirs(r))
     # util.dirs() does not include the root directory, so add it manually
     d.append('.')
 
     return r, d
 
 def _explicitfiles(kindpats):
     '''Returns the potential explicit filenames from the patterns.
 
     >>> _explicitfiles([(b'path', b'foo/bar', b'')])
     ['foo/bar']
     >>> _explicitfiles([(b'rootfilesin', b'foo/bar', b'')])
     []
     '''
     # Keep only the pattern kinds where one can specify filenames (vs only
     # directory names).
     filable = [kp for kp in kindpats if kp[0] not in ('rootfilesin',)]
     return _roots(filable)
 
 def _prefix(kindpats):
     '''Whether all the patterns match a prefix (i.e. recursively)'''
     for kind, pat, source in kindpats:
         if kind not in ('path', 'relpath'):
             return False
     return True
 
 _commentre = None
 
 def readpatternfile(filepath, warn, sourceinfo=False):
     '''parse a pattern file, returning a list of
     patterns. These patterns should be given to compile()
     to be validated and converted into a match function.
 
     trailing white space is dropped.
     the escape character is backslash.
     comments start with #.
     empty lines are skipped.
 
     lines can be of the following formats:
 
     syntax: regexp # defaults following lines to non-rooted regexps
     syntax: glob   # defaults following lines to non-rooted globs
     re:pattern     # non-rooted regular expression
     glob:pattern   # non-rooted glob
     pattern        # pattern of the current default type
 
     if sourceinfo is set, returns a list of tuples:
     (pattern, lineno, originalline). This is useful to debug ignore patterns.
     '''
 
     syntaxes = {'re': 'relre:', 'regexp': 'relre:', 'glob': 'relglob:',
                 'include': 'include', 'subinclude': 'subinclude'}
     syntax = 'relre:'
     patterns = []
 
     fp = open(filepath, 'rb')
     for lineno, line in enumerate(util.iterfile(fp), start=1):
         if "#" in line:
             global _commentre
             if not _commentre:
                 _commentre = util.re.compile(br'((?:^|[^\\])(?:\\\\)*)#.*')
             # remove comments prefixed by an even number of escapes
             m = _commentre.search(line)
             if m:
                 line = line[:m.end(1)]
             # fixup properly escaped comments that survived the above
             line = line.replace("\\#", "#")
         line = line.rstrip()
         if not line:
             continue
 
         if line.startswith('syntax:'):
             s = line[7:].strip()
             try:
                 syntax = syntaxes[s]
             except KeyError:
                 if warn:
                     warn(_("%s: ignoring invalid syntax '%s'\n") %
                          (filepath, s))
             continue
 
         linesyntax = syntax
         for s, rels in syntaxes.iteritems():
             if line.startswith(rels):
                 linesyntax = rels
                 line = line[len(rels):]
                 break
             elif line.startswith(s+':'):
                 linesyntax = rels
                 line = line[len(s) + 1:]
                 break
         if sourceinfo:
             patterns.append((linesyntax + line, lineno, line))
         else:
             patterns.append(linesyntax + line)
     fp.close()
     return patterns

mercurial/subrepo.py

@@ -1,1816 +1,1822 b''
 # subrepo.py - sub-repository classes and factory
 #
 # Copyright 2009-2010 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import copy
 import errno
 import hashlib
 import os
 import posixpath
 import re
 import stat
 import subprocess
 import sys
 import tarfile
 import xml.dom.minidom
 
 from .i18n import _
 from . import (
     cmdutil,
     encoding,
     error,
     exchange,
     logcmdutil,
     match as matchmod,
     node,
     pathutil,
     phases,
     pycompat,
     scmutil,
     subrepoutil,
     util,
     vfs as vfsmod,
 )
 from .utils import (
     dateutil,
     procutil,
     stringutil,
 )
 
 hg = None
 reporelpath = subrepoutil.reporelpath
 subrelpath = subrepoutil.subrelpath
 _abssource = subrepoutil._abssource
 propertycache = util.propertycache
 
 def _expandedabspath(path):
     '''
     get a path or url and if it is a path expand it and return an absolute path
     '''
     expandedpath = util.urllocalpath(util.expandpath(path))
     u = util.url(expandedpath)
     if not u.scheme:
         path = util.normpath(os.path.abspath(u.path))
     return path
 
 def _getstorehashcachename(remotepath):
     '''get a unique filename for the store hash cache of a remote repository'''
     return node.hex(hashlib.sha1(_expandedabspath(remotepath)).digest())[0:12]
 
 class SubrepoAbort(error.Abort):
     """Exception class used to avoid handling a subrepo error more than once"""
     def __init__(self, *args, **kw):
         self.subrepo = kw.pop(r'subrepo', None)
         self.cause = kw.pop(r'cause', None)
         error.Abort.__init__(self, *args, **kw)
 
 def annotatesubrepoerror(func):
     def decoratedmethod(self, *args, **kargs):
         try:
             res = func(self, *args, **kargs)
         except SubrepoAbort as ex:
             # This exception has already been handled
             raise ex
         except error.Abort as ex:
             subrepo = subrelpath(self)
             errormsg = (stringutil.forcebytestr(ex) + ' '
                         + _('(in subrepository "%s")') % subrepo)
             # avoid handling this exception by raising a SubrepoAbort exception
             raise SubrepoAbort(errormsg, hint=ex.hint, subrepo=subrepo,
                                cause=sys.exc_info())
         return res
     return decoratedmethod
 
 def _updateprompt(ui, sub, dirty, local, remote):
     if dirty:
         msg = (_(' subrepository sources for %s differ\n'
                  'use (l)ocal source (%s) or (r)emote source (%s)?'
                  '$$ &Local $$ &Remote')
                % (subrelpath(sub), local, remote))
     else:
         msg = (_(' subrepository sources for %s differ (in checked out '
                  'version)\n'
                  'use (l)ocal source (%s) or (r)emote source (%s)?'
                  '$$ &Local $$ &Remote')
                % (subrelpath(sub), local, remote))
     return ui.promptchoice(msg, 0)
 
 def _sanitize(ui, vfs, ignore):
     for dirname, dirs, names in vfs.walk():
         for i, d in enumerate(dirs):
             if d.lower() == ignore:
                 del dirs[i]
                 break
         if vfs.basename(dirname).lower() != '.hg':
             continue
         for f in names:
             if f.lower() == 'hgrc':
                 ui.warn(_("warning: removing potentially hostile 'hgrc' "
                           "in '%s'\n") % vfs.join(dirname))
                 vfs.unlink(vfs.reljoin(dirname, f))
 
 def _auditsubrepopath(repo, path):
     # auditor doesn't check if the path itself is a symlink
     pathutil.pathauditor(repo.root)(path)
     if repo.wvfs.islink(path):
         raise error.Abort(_("subrepo '%s' traverses symbolic link") % path)
 
 SUBREPO_ALLOWED_DEFAULTS = {
     'hg': True,
     'git': False,
     'svn': False,
 }
 
 def _checktype(ui, kind):
     # subrepos.allowed is a master kill switch. If disabled, subrepos are
     # disabled period.
     if not ui.configbool('subrepos', 'allowed', True):
         raise error.Abort(_('subrepos not enabled'),
                           hint=_("see 'hg help config.subrepos' for details"))
 
     default = SUBREPO_ALLOWED_DEFAULTS.get(kind, False)
     if not ui.configbool('subrepos', '%s:allowed' % kind, default):
         raise error.Abort(_('%s subrepos not allowed') % kind,
                           hint=_("see 'hg help config.subrepos' for details"))
 
     if kind not in types:
         raise error.Abort(_('unknown subrepo type %s') % kind)
 
 def subrepo(ctx, path, allowwdir=False, allowcreate=True):
     """return instance of the right subrepo class for subrepo in path"""
     # subrepo inherently violates our import layering rules
     # because it wants to make repo objects from deep inside the stack
     # so we manually delay the circular imports to not break
     # scripts that don't use our demand-loading
     global hg
     from . import hg as h
     hg = h
 
     repo = ctx.repo()
     _auditsubrepopath(repo, path)
     state = ctx.substate[path]
     _checktype(repo.ui, state[2])
     if allowwdir:
         state = (state[0], ctx.subrev(path), state[2])
     return types[state[2]](ctx, path, state[:2], allowcreate)
 
 def nullsubrepo(ctx, path, pctx):
     """return an empty subrepo in pctx for the extant subrepo in ctx"""
     # subrepo inherently violates our import layering rules
     # because it wants to make repo objects from deep inside the stack
     # so we manually delay the circular imports to not break
     # scripts that don't use our demand-loading
     global hg
     from . import hg as h
     hg = h
 
     repo = ctx.repo()
     _auditsubrepopath(repo, path)
     state = ctx.substate[path]
     _checktype(repo.ui, state[2])
     subrev = ''
     if state[2] == 'hg':
         subrev = "0" * 40
     return types[state[2]](pctx, path, (state[0], subrev), True)
 
 # subrepo classes need to implement the following abstract class:
 
 class abstractsubrepo(object):
 
     def __init__(self, ctx, path):
         """Initialize abstractsubrepo part
 
         ``ctx`` is the context referring this subrepository in the
         parent repository.
 
         ``path`` is the path to this subrepository as seen from
         innermost repository.
         """
         self.ui = ctx.repo().ui
         self._ctx = ctx
         self._path = path
 
     def addwebdirpath(self, serverpath, webconf):
         """Add the hgwebdir entries for this subrepo, and any of its subrepos.
 
         ``serverpath`` is the path component of the URL for this repo.
 
         ``webconf`` is the dictionary of hgwebdir entries.
         """
         pass
 
     def storeclean(self, path):
         """
         returns true if the repository has not changed since it was last
         cloned from or pushed to a given repository.
         """
         return False
 
     def dirty(self, ignoreupdate=False, missing=False):
         """returns true if the dirstate of the subrepo is dirty or does not
         match current stored state. If ignoreupdate is true, only check
         whether the subrepo has uncommitted changes in its dirstate.  If missing
         is true, check for deleted files.
         """
         raise NotImplementedError
 
     def dirtyreason(self, ignoreupdate=False, missing=False):
         """return reason string if it is ``dirty()``
 
         Returned string should have enough information for the message
         of exception.
 
         This returns None, otherwise.
         """
         if self.dirty(ignoreupdate=ignoreupdate, missing=missing):
             return _('uncommitted changes in subrepository "%s"'
                      ) % subrelpath(self)
 
     def bailifchanged(self, ignoreupdate=False, hint=None):
         """raise Abort if subrepository is ``dirty()``
         """
         dirtyreason = self.dirtyreason(ignoreupdate=ignoreupdate,
                                        missing=True)
         if dirtyreason:
             raise error.Abort(dirtyreason, hint=hint)
 
     def basestate(self):
         """current working directory base state, disregarding .hgsubstate
         state and working directory modifications"""
         raise NotImplementedError
 
     def checknested(self, path):
         """check if path is a subrepository within this repository"""
         return False
 
     def commit(self, text, user, date):
         """commit the current changes to the subrepo with the given
         log message. Use given user and date if possible. Return the
         new state of the subrepo.
         """
         raise NotImplementedError
 
     def phase(self, state):
         """returns phase of specified state in the subrepository.
         """
         return phases.public
 
     def remove(self):
         """remove the subrepo
 
         (should verify the dirstate is not dirty first)
         """
         raise NotImplementedError
 
     def get(self, state, overwrite=False):
         """run whatever commands are needed to put the subrepo into
         this state
         """
         raise NotImplementedError
 
     def merge(self, state):
         """merge currently-saved state with the new state."""
         raise NotImplementedError
 
     def push(self, opts):
         """perform whatever action is analogous to 'hg push'
 
         This may be a no-op on some systems.
         """
         raise NotImplementedError
 
     def add(self, ui, match, prefix, explicitonly, **opts):
         return []
 
     def addremove(self, matcher, prefix, opts):
         self.ui.warn("%s: %s" % (prefix, _("addremove is not supported")))
         return 1
 
     def cat(self, match, fm, fntemplate, prefix, **opts):
         return 1
 
     def status(self, rev2, **opts):
         return scmutil.status([], [], [], [], [], [], [])
 
     def diff(self, ui, diffopts, node2, match, prefix, **opts):
         pass
 
     def outgoing(self, ui, dest, opts):
         return 1
 
     def incoming(self, ui, source, opts):
         return 1
 
     def files(self):
         """return filename iterator"""
         raise NotImplementedError
 
     def filedata(self, name, decode):
         """return file data, optionally passed through repo decoders"""
         raise NotImplementedError
 
     def fileflags(self, name):
         """return file flags"""
         return ''
 
-    def getfileset(self, expr):
+    def matchfileset(self, expr, badfn=None):
         """Resolve the fileset expression for this repo"""
-        return set()
+        return matchmod.nevermatcher(self.wvfs.base, '', badfn=badfn)
 
     def printfiles(self, ui, m, fm, fmt, subrepos):
         """handle the files command for this subrepo"""
         return 1
 
     def archive(self, archiver, prefix, match=None, decode=True):
         if match is not None:
             files = [f for f in self.files() if match(f)]
         else:
             files = self.files()
         total = len(files)
         relpath = subrelpath(self)
         progress = self.ui.makeprogress(_('archiving (%s)') % relpath,
                                         unit=_('files'), total=total)
         progress.update(0)
         for name in files:
             flags = self.fileflags(name)
             mode = 'x' in flags and 0o755 or 0o644
             symlink = 'l' in flags
             archiver.addfile(prefix + self._path + '/' + name,
                              mode, symlink, self.filedata(name, decode))
             progress.increment()
         progress.complete()
         return total
 
     def walk(self, match):
         '''
         walk recursively through the directory tree, finding all files
         matched by the match function
         '''
 
     def forget(self, match, prefix, dryrun, interactive):
         return ([], [])
 
     def removefiles(self, matcher, prefix, after, force, subrepos,
                     dryrun, warnings):
         """remove the matched files from the subrepository and the filesystem,
         possibly by force and/or after the file has been removed from the
         filesystem.  Return 0 on success, 1 on any warning.
         """
         warnings.append(_("warning: removefiles not implemented (%s)")
                         % self._path)
         return 1
 
     def revert(self, substate, *pats, **opts):
         self.ui.warn(_('%s: reverting %s subrepos is unsupported\n') \
             % (substate[0], substate[2]))
         return []
 
     def shortid(self, revid):
         return revid
 
     def unshare(self):
         '''
         convert this repository from shared to normal storage.
         '''
 
     def verify(self):
         '''verify the integrity of the repository.  Return 0 on success or
         warning, 1 on any error.
         '''
         return 0
 
     @propertycache
     def wvfs(self):
         """return vfs to access the working directory of this subrepository
         """
         return vfsmod.vfs(self._ctx.repo().wvfs.join(self._path))
 
     @propertycache
     def _relpath(self):
         """return path to this subrepository as seen from outermost repository
         """
         return self.wvfs.reljoin(reporelpath(self._ctx.repo()), self._path)
 
 class hgsubrepo(abstractsubrepo):
     def __init__(self, ctx, path, state, allowcreate):
         super(hgsubrepo, self).__init__(ctx, path)
         self._state = state
         r = ctx.repo()
         root = r.wjoin(path)
         create = allowcreate and not r.wvfs.exists('%s/.hg' % path)
         self._repo = hg.repository(r.baseui, root, create=create)
 
         # Propagate the parent's --hidden option
         if r is r.unfiltered():
             self._repo = self._repo.unfiltered()
 
         self.ui = self._repo.ui
         for s, k in [('ui', 'commitsubrepos')]:
             v = r.ui.config(s, k)
             if v:
                 self.ui.setconfig(s, k, v, 'subrepo')
         # internal config: ui._usedassubrepo
         self.ui.setconfig('ui', '_usedassubrepo', 'True', 'subrepo')
         self._initrepo(r, state[0], create)
 
     @annotatesubrepoerror
     def addwebdirpath(self, serverpath, webconf):
         cmdutil.addwebdirpath(self._repo, subrelpath(self), webconf)
 
     def storeclean(self, path):
         with self._repo.lock():
             return self._storeclean(path)
 
     def _storeclean(self, path):
         clean = True
         itercache = self._calcstorehash(path)
         for filehash in self._readstorehashcache(path):
             if filehash != next(itercache, None):
                 clean = False
                 break
         if clean:
             # if not empty:
             # the cached and current pull states have a different size
             clean = next(itercache, None) is None
         return clean
 
     def _calcstorehash(self, remotepath):
         '''calculate a unique "store hash"
 
         This method is used to to detect when there are changes that may
         require a push to a given remote path.'''
         # sort the files that will be hashed in increasing (likely) file size
         filelist = ('bookmarks', 'store/phaseroots', 'store/00changelog.i')
         yield '# %s\n' % _expandedabspath(remotepath)
         vfs = self._repo.vfs
         for relname in filelist:
             filehash = node.hex(hashlib.sha1(vfs.tryread(relname)).digest())
             yield '%s = %s\n' % (relname, filehash)
 
     @propertycache
     def _cachestorehashvfs(self):
         return vfsmod.vfs(self._repo.vfs.join('cache/storehash'))
 
     def _readstorehashcache(self, remotepath):
         '''read the store hash cache for a given remote repository'''
         cachefile = _getstorehashcachename(remotepath)
         return self._cachestorehashvfs.tryreadlines(cachefile, 'r')
 
     def _cachestorehash(self, remotepath):
         '''cache the current store hash
 
         Each remote repo requires its own store hash cache, because a subrepo
         store may be "clean" versus a given remote repo, but not versus another
         '''
         cachefile = _getstorehashcachename(remotepath)
         with self._repo.lock():
             storehash = list(self._calcstorehash(remotepath))
             vfs = self._cachestorehashvfs
             vfs.writelines(cachefile, storehash, mode='wb', notindexed=True)
 
     def _getctx(self):
         '''fetch the context for this subrepo revision, possibly a workingctx
         '''
         if self._ctx.rev() is None:
             return self._repo[None]  # workingctx if parent is workingctx
         else:
             rev = self._state[1]
             return self._repo[rev]
 
     @annotatesubrepoerror
     def _initrepo(self, parentrepo, source, create):
         self._repo._subparent = parentrepo
         self._repo._subsource = source
 
         if create:
             lines = ['[paths]\n']
 
             def addpathconfig(key, value):
                 if value:
                     lines.append('%s = %s\n' % (key, value))
                     self.ui.setconfig('paths', key, value, 'subrepo')
 
             defpath = _abssource(self._repo, abort=False)
             defpushpath = _abssource(self._repo, True, abort=False)
             addpathconfig('default', defpath)
             if defpath != defpushpath:
                 addpathconfig('default-push', defpushpath)
 
             self._repo.vfs.write('hgrc', util.tonativeeol(''.join(lines)))
 
     @annotatesubrepoerror
     def add(self, ui, match, prefix, explicitonly, **opts):
         return cmdutil.add(ui, self._repo, match,
                            self.wvfs.reljoin(prefix, self._path),
                            explicitonly, **opts)
 
     @annotatesubrepoerror
     def addremove(self, m, prefix, opts):
         # In the same way as sub directories are processed, once in a subrepo,
         # always entry any of its subrepos.  Don't corrupt the options that will
         # be used to process sibling subrepos however.
         opts = copy.copy(opts)
         opts['subrepos'] = True
         return scmutil.addremove(self._repo, m,
                                  self.wvfs.reljoin(prefix, self._path), opts)
 
     @annotatesubrepoerror
     def cat(self, match, fm, fntemplate, prefix, **opts):
         rev = self._state[1]
         ctx = self._repo[rev]
         return cmdutil.cat(self.ui, self._repo, ctx, match, fm, fntemplate,
                            prefix, **opts)
 
     @annotatesubrepoerror
     def status(self, rev2, **opts):
         try:
             rev1 = self._state[1]
             ctx1 = self._repo[rev1]
             ctx2 = self._repo[rev2]
             return self._repo.status(ctx1, ctx2, **opts)
         except error.RepoLookupError as inst:
             self.ui.warn(_('warning: error "%s" in subrepository "%s"\n')
                          % (inst, subrelpath(self)))
             return scmutil.status([], [], [], [], [], [], [])
 
     @annotatesubrepoerror
     def diff(self, ui, diffopts, node2, match, prefix, **opts):
         try:
             node1 = node.bin(self._state[1])
             # We currently expect node2 to come from substate and be
             # in hex format
             if node2 is not None:
                 node2 = node.bin(node2)
             logcmdutil.diffordiffstat(ui, self._repo, diffopts,
                                       node1, node2, match,
                                       prefix=posixpath.join(prefix, self._path),
                                       listsubrepos=True, **opts)
         except error.RepoLookupError as inst:
             self.ui.warn(_('warning: error "%s" in subrepository "%s"\n')
                           % (inst, subrelpath(self)))
 
     @annotatesubrepoerror
     def archive(self, archiver, prefix, match=None, decode=True):
         self._get(self._state + ('hg',))
         files = self.files()
         if match:
             files = [f for f in files if match(f)]
         rev = self._state[1]
         ctx = self._repo[rev]
         scmutil.prefetchfiles(self._repo, [ctx.rev()],
                               scmutil.matchfiles(self._repo, files))
         total = abstractsubrepo.archive(self, archiver, prefix, match)
         for subpath in ctx.substate:
             s = subrepo(ctx, subpath, True)
             submatch = matchmod.subdirmatcher(subpath, match)
             total += s.archive(archiver, prefix + self._path + '/', submatch,
                                decode)
         return total
 
     @annotatesubrepoerror
     def dirty(self, ignoreupdate=False, missing=False):
         r = self._state[1]
         if r == '' and not ignoreupdate: # no state recorded
             return True
         w = self._repo[None]
         if r != w.p1().hex() and not ignoreupdate:
             # different version checked out
             return True
         return w.dirty(missing=missing) # working directory changed
 
     def basestate(self):
         return self._repo['.'].hex()
 
     def checknested(self, path):
         return self._repo._checknested(self._repo.wjoin(path))
 
     @annotatesubrepoerror
     def commit(self, text, user, date):
         # don't bother committing in the subrepo if it's only been
         # updated
         if not self.dirty(True):
             return self._repo['.'].hex()
         self.ui.debug("committing subrepo %s\n" % subrelpath(self))
         n = self._repo.commit(text, user, date)
         if not n:
             return self._repo['.'].hex() # different version checked out
         return node.hex(n)
 
     @annotatesubrepoerror
     def phase(self, state):
         return self._repo[state or '.'].phase()
 
     @annotatesubrepoerror
     def remove(self):
         # we can't fully delete the repository as it may contain
         # local-only history
         self.ui.note(_('removing subrepo %s\n') % subrelpath(self))
         hg.clean(self._repo, node.nullid, False)
 
     def _get(self, state):
         source, revision, kind = state
         parentrepo = self._repo._subparent
 
         if revision in self._repo.unfiltered():
             # Allow shared subrepos tracked at null to setup the sharedpath
             if len(self._repo) != 0 or not parentrepo.shared():
                 return True
         self._repo._subsource = source
         srcurl = _abssource(self._repo)
         other = hg.peer(self._repo, {}, srcurl)
         if len(self._repo) == 0:
             # use self._repo.vfs instead of self.wvfs to remove .hg only
             self._repo.vfs.rmtree()
 
             # A remote subrepo could be shared if there is a local copy
             # relative to the parent's share source.  But clone pooling doesn't
             # assemble the repos in a tree, so that can't be consistently done.
             # A simpler option is for the user to configure clone pooling, and
             # work with that.
             if parentrepo.shared() and hg.islocal(srcurl):
                 self.ui.status(_('sharing subrepo %s from %s\n')
                                % (subrelpath(self), srcurl))
                 shared = hg.share(self._repo._subparent.baseui,
                                   other, self._repo.root,
                                   update=False, bookmarks=False)
                 self._repo = shared.local()
             else:
                 # TODO: find a common place for this and this code in the
                 # share.py wrap of the clone command.
                 if parentrepo.shared():
                     pool = self.ui.config('share', 'pool')
                     if pool:
                         pool = util.expandpath(pool)
 
                     shareopts = {
                         'pool': pool,
                         'mode': self.ui.config('share', 'poolnaming'),
                     }
                 else:
                     shareopts = {}
 
                 self.ui.status(_('cloning subrepo %s from %s\n')
                                % (subrelpath(self), srcurl))
                 other, cloned = hg.clone(self._repo._subparent.baseui, {},
                                          other, self._repo.root,
                                          update=False, shareopts=shareopts)
                 self._repo = cloned.local()
             self._initrepo(parentrepo, source, create=True)
             self._cachestorehash(srcurl)
         else:
             self.ui.status(_('pulling subrepo %s from %s\n')
                            % (subrelpath(self), srcurl))
             cleansub = self.storeclean(srcurl)
             exchange.pull(self._repo, other)
             if cleansub:
                 # keep the repo clean after pull
                 self._cachestorehash(srcurl)
         return False
 
     @annotatesubrepoerror
     def get(self, state, overwrite=False):
         inrepo = self._get(state)
         source, revision, kind = state
         repo = self._repo
         repo.ui.debug("getting subrepo %s\n" % self._path)
         if inrepo:
             urepo = repo.unfiltered()
             ctx = urepo[revision]
             if ctx.hidden():
                 urepo.ui.warn(
                     _('revision %s in subrepository "%s" is hidden\n') \
                     % (revision[0:12], self._path))
                 repo = urepo
         hg.updaterepo(repo, revision, overwrite)
 
     @annotatesubrepoerror
     def merge(self, state):
         self._get(state)
         cur = self._repo['.']
         dst = self._repo[state[1]]
         anc = dst.ancestor(cur)
 
         def mergefunc():
             if anc == cur and dst.branch() == cur.branch():
                 self.ui.debug('updating subrepository "%s"\n'
                               % subrelpath(self))
                 hg.update(self._repo, state[1])
             elif anc == dst:
                 self.ui.debug('skipping subrepository "%s"\n'
                               % subrelpath(self))
             else:
                 self.ui.debug('merging subrepository "%s"\n' % subrelpath(self))
                 hg.merge(self._repo, state[1], remind=False)
 
         wctx = self._repo[None]
         if self.dirty():
             if anc != dst:
                 if _updateprompt(self.ui, self, wctx.dirty(), cur, dst):
                     mergefunc()
             else:
                 mergefunc()
         else:
             mergefunc()
 
     @annotatesubrepoerror
     def push(self, opts):
         force = opts.get('force')
         newbranch = opts.get('new_branch')
         ssh = opts.get('ssh')
 
         # push subrepos depth-first for coherent ordering
         c = self._repo['.']
         subs = c.substate # only repos that are committed
         for s in sorted(subs):
             if c.sub(s).push(opts) == 0:
                 return False
 
         dsturl = _abssource(self._repo, True)
         if not force:
             if self.storeclean(dsturl):
                 self.ui.status(
                     _('no changes made to subrepo %s since last push to %s\n')
                     % (subrelpath(self), dsturl))
                 return None
         self.ui.status(_('pushing subrepo %s to %s\n') %
             (subrelpath(self), dsturl))
         other = hg.peer(self._repo, {'ssh': ssh}, dsturl)
         res = exchange.push(self._repo, other, force, newbranch=newbranch)
 
         # the repo is now clean
         self._cachestorehash(dsturl)
         return res.cgresult
 
     @annotatesubrepoerror
     def outgoing(self, ui, dest, opts):
         if 'rev' in opts or 'branch' in opts:
             opts = copy.copy(opts)
             opts.pop('rev', None)
             opts.pop('branch', None)
         return hg.outgoing(ui, self._repo, _abssource(self._repo, True), opts)
 
     @annotatesubrepoerror
     def incoming(self, ui, source, opts):
         if 'rev' in opts or 'branch' in opts:
             opts = copy.copy(opts)
             opts.pop('rev', None)
             opts.pop('branch', None)
         return hg.incoming(ui, self._repo, _abssource(self._repo, False), opts)
 
     @annotatesubrepoerror
     def files(self):
         rev = self._state[1]
         ctx = self._repo[rev]
         return ctx.manifest().keys()
 
     def filedata(self, name, decode):
         rev = self._state[1]
         data = self._repo[rev][name].data()
         if decode:
             data = self._repo.wwritedata(name, data)
         return data
 
     def fileflags(self, name):
         rev = self._state[1]
         ctx = self._repo[rev]
         return ctx.flags(name)
 
     @annotatesubrepoerror
     def printfiles(self, ui, m, fm, fmt, subrepos):
         # If the parent context is a workingctx, use the workingctx here for
         # consistency.
         if self._ctx.rev() is None:
             ctx = self._repo[None]
         else:
             rev = self._state[1]
             ctx = self._repo[rev]
         return cmdutil.files(ui, ctx, m, fm, fmt, subrepos)
 
     @annotatesubrepoerror
-    def getfileset(self, expr):
+    def matchfileset(self, expr, badfn=None):
+        repo = self._repo
         if self._ctx.rev() is None:
-            ctx = self._repo[None]
+            ctx = repo[None]
         else:
             rev = self._state[1]
-            ctx = self._repo[rev]
+            ctx = repo[rev]
 
-        files = ctx.getfileset(expr)
+        matchers = [ctx.matchfileset(expr, badfn=badfn)]
 
         for subpath in ctx.substate:
             sub = ctx.sub(subpath)
 
             try:
-                files.extend(subpath + '/' + f for f in sub.getfileset(expr))
+                sm = sub.matchfileset(expr, badfn=badfn)
+                pm = matchmod.prefixdirmatcher(repo.root, repo.getcwd(),
+                                               subpath, sm, badfn=badfn)
+                matchers.append(pm)
             except error.LookupError:
                 self.ui.status(_("skipping missing subrepository: %s\n")
                                % self.wvfs.reljoin(reporelpath(self), subpath))
-        return files
+        if len(matchers) == 1:
+            return matchers[0]
+        return matchmod.unionmatcher(matchers)
 
     def walk(self, match):
         ctx = self._repo[None]
         return ctx.walk(match)
 
     @annotatesubrepoerror
     def forget(self, match, prefix, dryrun, interactive):
         return cmdutil.forget(self.ui, self._repo, match,
                               self.wvfs.reljoin(prefix, self._path),
                               True, dryrun=dryrun, interactive=interactive)
 
     @annotatesubrepoerror
     def removefiles(self, matcher, prefix, after, force, subrepos,
                     dryrun, warnings):
         return cmdutil.remove(self.ui, self._repo, matcher,
                               self.wvfs.reljoin(prefix, self._path),
                               after, force, subrepos, dryrun)
 
     @annotatesubrepoerror
     def revert(self, substate, *pats, **opts):
         # reverting a subrepo is a 2 step process:
         # 1. if the no_backup is not set, revert all modified
         #    files inside the subrepo
         # 2. update the subrepo to the revision specified in
         #    the corresponding substate dictionary
         self.ui.status(_('reverting subrepo %s\n') % substate[0])
         if not opts.get(r'no_backup'):
             # Revert all files on the subrepo, creating backups
             # Note that this will not recursively revert subrepos
             # We could do it if there was a set:subrepos() predicate
             opts = opts.copy()
             opts[r'date'] = None
             opts[r'rev'] = substate[1]
 
             self.filerevert(*pats, **opts)
 
         # Update the repo to the revision specified in the given substate
         if not opts.get(r'dry_run'):
             self.get(substate, overwrite=True)
 
     def filerevert(self, *pats, **opts):
         ctx = self._repo[opts[r'rev']]
         parents = self._repo.dirstate.parents()
         if opts.get(r'all'):
             pats = ['set:modified()']
         else:
             pats = []
         cmdutil.revert(self.ui, self._repo, ctx, parents, *pats, **opts)
 
     def shortid(self, revid):
         return revid[:12]
 
     @annotatesubrepoerror
     def unshare(self):
         # subrepo inherently violates our import layering rules
         # because it wants to make repo objects from deep inside the stack
         # so we manually delay the circular imports to not break
         # scripts that don't use our demand-loading
         global hg
         from . import hg as h
         hg = h
 
         # Nothing prevents a user from sharing in a repo, and then making that a
         # subrepo.  Alternately, the previous unshare attempt may have failed
         # part way through.  So recurse whether or not this layer is shared.
         if self._repo.shared():
             self.ui.status(_("unsharing subrepo '%s'\n") % self._relpath)
 
         hg.unshare(self.ui, self._repo)
 
     def verify(self):
         try:
             rev = self._state[1]
             ctx = self._repo.unfiltered()[rev]
             if ctx.hidden():
                 # Since hidden revisions aren't pushed/pulled, it seems worth an
                 # explicit warning.
                 ui = self._repo.ui
                 ui.warn(_("subrepo '%s' is hidden in revision %s\n") %
                         (self._relpath, node.short(self._ctx.node())))
             return 0
         except error.RepoLookupError:
             # A missing subrepo revision may be a case of needing to pull it, so
             # don't treat this as an error.
             self._repo.ui.warn(_("subrepo '%s' not found in revision %s\n") %
                                (self._relpath, node.short(self._ctx.node())))
             return 0
 
     @propertycache
     def wvfs(self):
         """return own wvfs for efficiency and consistency
         """
         return self._repo.wvfs
 
     @propertycache
     def _relpath(self):
         """return path to this subrepository as seen from outermost repository
         """
         # Keep consistent dir separators by avoiding vfs.join(self._path)
         return reporelpath(self._repo)
 
 class svnsubrepo(abstractsubrepo):
     def __init__(self, ctx, path, state, allowcreate):
         super(svnsubrepo, self).__init__(ctx, path)
         self._state = state
         self._exe = procutil.findexe('svn')
         if not self._exe:
             raise error.Abort(_("'svn' executable not found for subrepo '%s'")
                              % self._path)
 
     def _svncommand(self, commands, filename='', failok=False):
         cmd = [self._exe]
         extrakw = {}
         if not self.ui.interactive():
             # Making stdin be a pipe should prevent svn from behaving
             # interactively even if we can't pass --non-interactive.
             extrakw[r'stdin'] = subprocess.PIPE
             # Starting in svn 1.5 --non-interactive is a global flag
             # instead of being per-command, but we need to support 1.4 so
             # we have to be intelligent about what commands take
             # --non-interactive.
             if commands[0] in ('update', 'checkout', 'commit'):
                 cmd.append('--non-interactive')
         cmd.extend(commands)
         if filename is not None:
             path = self.wvfs.reljoin(self._ctx.repo().origroot,
                                      self._path, filename)
             cmd.append(path)
         env = dict(encoding.environ)
         # Avoid localized output, preserve current locale for everything else.
         lc_all = env.get('LC_ALL')
         if lc_all:
             env['LANG'] = lc_all
             del env['LC_ALL']
         env['LC_MESSAGES'] = 'C'
         p = subprocess.Popen(cmd, bufsize=-1, close_fds=procutil.closefds,
                              stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                               universal_newlines=True, env=env, **extrakw)
         stdout, stderr = p.communicate()
         stderr = stderr.strip()
         if not failok:
             if p.returncode:
                 raise error.Abort(stderr or 'exited with code %d'
                                   % p.returncode)
             if stderr:
                 self.ui.warn(stderr + '\n')
         return stdout, stderr
 
     @propertycache
     def _svnversion(self):
         output, err = self._svncommand(['--version', '--quiet'], filename=None)
         m = re.search(br'^(\d+)\.(\d+)', output)
         if not m:
             raise error.Abort(_('cannot retrieve svn tool version'))
         return (int(m.group(1)), int(m.group(2)))
 
     def _svnmissing(self):
         return not self.wvfs.exists('.svn')
 
     def _wcrevs(self):
         # Get the working directory revision as well as the last
         # commit revision so we can compare the subrepo state with
         # both. We used to store the working directory one.
         output, err = self._svncommand(['info', '--xml'])
         doc = xml.dom.minidom.parseString(output)
         entries = doc.getElementsByTagName('entry')
         lastrev, rev = '0', '0'
         if entries:
             rev = str(entries[0].getAttribute('revision')) or '0'
             commits = entries[0].getElementsByTagName('commit')
             if commits:
                 lastrev = str(commits[0].getAttribute('revision')) or '0'
         return (lastrev, rev)
 
     def _wcrev(self):
         return self._wcrevs()[0]
 
     def _wcchanged(self):
         """Return (changes, extchanges, missing) where changes is True
         if the working directory was changed, extchanges is
         True if any of these changes concern an external entry and missing
         is True if any change is a missing entry.
         """
         output, err = self._svncommand(['status', '--xml'])
         externals, changes, missing = [], [], []
         doc = xml.dom.minidom.parseString(output)
         for e in doc.getElementsByTagName('entry'):
             s = e.getElementsByTagName('wc-status')
             if not s:
                 continue
             item = s[0].getAttribute('item')
             props = s[0].getAttribute('props')
             path = e.getAttribute('path')
             if item == 'external':
                 externals.append(path)
             elif item == 'missing':
                 missing.append(path)
             if (item not in ('', 'normal', 'unversioned', 'external')
                 or props not in ('', 'none', 'normal')):
                 changes.append(path)
         for path in changes:
             for ext in externals:
                 if path == ext or path.startswith(ext + pycompat.ossep):
                     return True, True, bool(missing)
         return bool(changes), False, bool(missing)
 
     @annotatesubrepoerror
     def dirty(self, ignoreupdate=False, missing=False):
         if self._svnmissing():
             return self._state[1] != ''
         wcchanged = self._wcchanged()
         changed = wcchanged[0] or (missing and wcchanged[2])
         if not changed:
             if self._state[1] in self._wcrevs() or ignoreupdate:
                 return False
         return True
 
     def basestate(self):
         lastrev, rev = self._wcrevs()
         if lastrev != rev:
             # Last committed rev is not the same than rev. We would
             # like to take lastrev but we do not know if the subrepo
             # URL exists at lastrev.  Test it and fallback to rev it
             # is not there.
             try:
                 self._svncommand(['list', '%s@%s' % (self._state[0], lastrev)])
                 return lastrev
             except error.Abort:
                 pass
         return rev
 
     @annotatesubrepoerror
     def commit(self, text, user, date):
         # user and date are out of our hands since svn is centralized
         changed, extchanged, missing = self._wcchanged()
         if not changed:
             return self.basestate()
         if extchanged:
             # Do not try to commit externals
             raise error.Abort(_('cannot commit svn externals'))
         if missing:
             # svn can commit with missing entries but aborting like hg
             # seems a better approach.
             raise error.Abort(_('cannot commit missing svn entries'))
         commitinfo, err = self._svncommand(['commit', '-m', text])
         self.ui.status(commitinfo)
         newrev = re.search('Committed revision ([0-9]+).', commitinfo)
         if not newrev:
             if not commitinfo.strip():
                 # Sometimes, our definition of "changed" differs from
                 # svn one. For instance, svn ignores missing files
                 # when committing. If there are only missing files, no
                 # commit is made, no output and no error code.
                 raise error.Abort(_('failed to commit svn changes'))
             raise error.Abort(commitinfo.splitlines()[-1])
         newrev = newrev.groups()[0]
         self.ui.status(self._svncommand(['update', '-r', newrev])[0])
         return newrev
 
     @annotatesubrepoerror
     def remove(self):
         if self.dirty():
             self.ui.warn(_('not removing repo %s because '
                            'it has changes.\n') % self._path)
             return
         self.ui.note(_('removing subrepo %s\n') % self._path)
 
         self.wvfs.rmtree(forcibly=True)
         try:
             pwvfs = self._ctx.repo().wvfs
             pwvfs.removedirs(pwvfs.dirname(self._path))
         except OSError:
             pass
 
     @annotatesubrepoerror
     def get(self, state, overwrite=False):
         if overwrite:
             self._svncommand(['revert', '--recursive'])
         args = ['checkout']
         if self._svnversion >= (1, 5):
             args.append('--force')
         # The revision must be specified at the end of the URL to properly
         # update to a directory which has since been deleted and recreated.
         args.append('%s@%s' % (state[0], state[1]))
 
         # SEC: check that the ssh url is safe
         util.checksafessh(state[0])
 
         status, err = self._svncommand(args, failok=True)
         _sanitize(self.ui, self.wvfs, '.svn')
         if not re.search('Checked out revision [0-9]+.', status):
             if ('is already a working copy for a different URL' in err
                 and (self._wcchanged()[:2] == (False, False))):
                 # obstructed but clean working copy, so just blow it away.
                 self.remove()
                 self.get(state, overwrite=False)
                 return
             raise error.Abort((status or err).splitlines()[-1])
         self.ui.status(status)
 
     @annotatesubrepoerror
     def merge(self, state):
         old = self._state[1]
         new = state[1]
         wcrev = self._wcrev()
         if new != wcrev:
             dirty = old == wcrev or self._wcchanged()[0]
             if _updateprompt(self.ui, self, dirty, wcrev, new):
                 self.get(state, False)
 
     def push(self, opts):
         # push is a no-op for SVN
         return True
 
     @annotatesubrepoerror
     def files(self):
         output = self._svncommand(['list', '--recursive', '--xml'])[0]
         doc = xml.dom.minidom.parseString(output)
         paths = []
         for e in doc.getElementsByTagName('entry'):
             kind = pycompat.bytestr(e.getAttribute('kind'))
             if kind != 'file':
                 continue
             name = ''.join(c.data for c
                            in e.getElementsByTagName('name')[0].childNodes
                            if c.nodeType == c.TEXT_NODE)
             paths.append(name.encode('utf-8'))
         return paths
 
     def filedata(self, name, decode):
         return self._svncommand(['cat'], name)[0]
 
 
 class gitsubrepo(abstractsubrepo):
     def __init__(self, ctx, path, state, allowcreate):
         super(gitsubrepo, self).__init__(ctx, path)
         self._state = state
         self._abspath = ctx.repo().wjoin(path)
         self._subparent = ctx.repo()
         self._ensuregit()
 
     def _ensuregit(self):
         try:
             self._gitexecutable = 'git'
             out, err = self._gitnodir(['--version'])
         except OSError as e:
             genericerror = _("error executing git for subrepo '%s': %s")
             notfoundhint = _("check git is installed and in your PATH")
             if e.errno != errno.ENOENT:
                 raise error.Abort(genericerror % (
                     self._path, encoding.strtolocal(e.strerror)))
             elif pycompat.iswindows:
                 try:
                     self._gitexecutable = 'git.cmd'
                     out, err = self._gitnodir(['--version'])
                 except OSError as e2:
                     if e2.errno == errno.ENOENT:
                         raise error.Abort(_("couldn't find 'git' or 'git.cmd'"
                             " for subrepo '%s'") % self._path,
                             hint=notfoundhint)
                     else:
                         raise error.Abort(genericerror % (self._path,
                             encoding.strtolocal(e2.strerror)))
             else:
                 raise error.Abort(_("couldn't find git for subrepo '%s'")
                     % self._path, hint=notfoundhint)
         versionstatus = self._checkversion(out)
         if versionstatus == 'unknown':
             self.ui.warn(_('cannot retrieve git version\n'))
         elif versionstatus == 'abort':
             raise error.Abort(_('git subrepo requires at least 1.6.0 or later'))
         elif versionstatus == 'warning':
             self.ui.warn(_('git subrepo requires at least 1.6.0 or later\n'))
 
     @staticmethod
     def _gitversion(out):
         m = re.search(br'^git version (\d+)\.(\d+)\.(\d+)', out)
         if m:
             return (int(m.group(1)), int(m.group(2)), int(m.group(3)))
 
         m = re.search(br'^git version (\d+)\.(\d+)', out)
         if m:
             return (int(m.group(1)), int(m.group(2)), 0)
 
         return -1
 
     @staticmethod
     def _checkversion(out):
         '''ensure git version is new enough
 
         >>> _checkversion = gitsubrepo._checkversion
         >>> _checkversion(b'git version 1.6.0')
         'ok'
         >>> _checkversion(b'git version 1.8.5')
         'ok'
         >>> _checkversion(b'git version 1.4.0')
         'abort'
         >>> _checkversion(b'git version 1.5.0')
         'warning'
         >>> _checkversion(b'git version 1.9-rc0')
         'ok'
         >>> _checkversion(b'git version 1.9.0.265.g81cdec2')
         'ok'
         >>> _checkversion(b'git version 1.9.0.GIT')
         'ok'
         >>> _checkversion(b'git version 12345')
         'unknown'
         >>> _checkversion(b'no')
         'unknown'
         '''
         version = gitsubrepo._gitversion(out)
         # git 1.4.0 can't work at all, but 1.5.X can in at least some cases,
         # despite the docstring comment.  For now, error on 1.4.0, warn on
         # 1.5.0 but attempt to continue.
         if version == -1:
             return 'unknown'
         if version < (1, 5, 0):
             return 'abort'
         elif version < (1, 6, 0):
             return 'warning'
         return 'ok'
 
     def _gitcommand(self, commands, env=None, stream=False):
         return self._gitdir(commands, env=env, stream=stream)[0]
 
     def _gitdir(self, commands, env=None, stream=False):
         return self._gitnodir(commands, env=env, stream=stream,
                               cwd=self._abspath)
 
     def _gitnodir(self, commands, env=None, stream=False, cwd=None):
         """Calls the git command
 
         The methods tries to call the git command. versions prior to 1.6.0
         are not supported and very probably fail.
         """
         self.ui.debug('%s: git %s\n' % (self._relpath, ' '.join(commands)))
         if env is None:
             env = encoding.environ.copy()
         # disable localization for Git output (issue5176)
         env['LC_ALL'] = 'C'
         # fix for Git CVE-2015-7545
         if 'GIT_ALLOW_PROTOCOL' not in env:
             env['GIT_ALLOW_PROTOCOL'] = 'file:git:http:https:ssh'
         # unless ui.quiet is set, print git's stderr,
         # which is mostly progress and useful info
         errpipe = None
         if self.ui.quiet:
             errpipe = open(os.devnull, 'w')
         if self.ui._colormode and len(commands) and commands[0] == "diff":
             # insert the argument in the front,
             # the end of git diff arguments is used for paths
             commands.insert(1, '--color')
         p = subprocess.Popen([self._gitexecutable] + commands, bufsize=-1,
                              cwd=cwd, env=env, close_fds=procutil.closefds,
                              stdout=subprocess.PIPE, stderr=errpipe)
         if stream:
             return p.stdout, None
 
         retdata = p.stdout.read().strip()
         # wait for the child to exit to avoid race condition.
         p.wait()
 
         if p.returncode != 0 and p.returncode != 1:
             # there are certain error codes that are ok
             command = commands[0]
             if command in ('cat-file', 'symbolic-ref'):
                 return retdata, p.returncode
             # for all others, abort
             raise error.Abort(_('git %s error %d in %s') %
                              (command, p.returncode, self._relpath))
 
         return retdata, p.returncode
 
     def _gitmissing(self):
         return not self.wvfs.exists('.git')
 
     def _gitstate(self):
         return self._gitcommand(['rev-parse', 'HEAD'])
 
     def _gitcurrentbranch(self):
         current, err = self._gitdir(['symbolic-ref', 'HEAD', '--quiet'])
         if err:
             current = None
         return current
 
     def _gitremote(self, remote):
         out = self._gitcommand(['remote', 'show', '-n', remote])
         line = out.split('\n')[1]
         i = line.index('URL: ') + len('URL: ')
         return line[i:]
 
     def _githavelocally(self, revision):
         out, code = self._gitdir(['cat-file', '-e', revision])
         return code == 0
 
     def _gitisancestor(self, r1, r2):
         base = self._gitcommand(['merge-base', r1, r2])
         return base == r1
 
     def _gitisbare(self):
         return self._gitcommand(['config', '--bool', 'core.bare']) == 'true'
 
     def _gitupdatestat(self):
         """This must be run before git diff-index.
         diff-index only looks at changes to file stat;
         this command looks at file contents and updates the stat."""
         self._gitcommand(['update-index', '-q', '--refresh'])
 
     def _gitbranchmap(self):
         '''returns 2 things:
         a map from git branch to revision
         a map from revision to branches'''
         branch2rev = {}
         rev2branch = {}
 
         out = self._gitcommand(['for-each-ref', '--format',
                                 '%(objectname) %(refname)'])
         for line in out.split('\n'):
             revision, ref = line.split(' ')
             if (not ref.startswith('refs/heads/') and
                 not ref.startswith('refs/remotes/')):
                 continue
             if ref.startswith('refs/remotes/') and ref.endswith('/HEAD'):
                 continue # ignore remote/HEAD redirects
             branch2rev[ref] = revision
             rev2branch.setdefault(revision, []).append(ref)
         return branch2rev, rev2branch
 
     def _gittracking(self, branches):
         'return map of remote branch to local tracking branch'
         # assumes no more than one local tracking branch for each remote
         tracking = {}
         for b in branches:
             if b.startswith('refs/remotes/'):
                 continue
             bname = b.split('/', 2)[2]
             remote = self._gitcommand(['config', 'branch.%s.remote' % bname])
             if remote:
                 ref = self._gitcommand(['config', 'branch.%s.merge' % bname])
                 tracking['refs/remotes/%s/%s' %
                          (remote, ref.split('/', 2)[2])] = b
         return tracking
 
     def _abssource(self, source):
         if '://' not in source:
             # recognize the scp syntax as an absolute source
             colon = source.find(':')
             if colon != -1 and '/' not in source[:colon]:
                 return source
         self._subsource = source
         return _abssource(self)
 
     def _fetch(self, source, revision):
         if self._gitmissing():
             # SEC: check for safe ssh url
             util.checksafessh(source)
 
             source = self._abssource(source)
             self.ui.status(_('cloning subrepo %s from %s\n') %
                             (self._relpath, source))
             self._gitnodir(['clone', source, self._abspath])
         if self._githavelocally(revision):
             return
         self.ui.status(_('pulling subrepo %s from %s\n') %
                         (self._relpath, self._gitremote('origin')))
         # try only origin: the originally cloned repo
         self._gitcommand(['fetch'])
         if not self._githavelocally(revision):
             raise error.Abort(_('revision %s does not exist in subrepository '
                                 '"%s"\n') % (revision, self._relpath))
 
     @annotatesubrepoerror
     def dirty(self, ignoreupdate=False, missing=False):
         if self._gitmissing():
             return self._state[1] != ''
         if self._gitisbare():
             return True
         if not ignoreupdate and self._state[1] != self._gitstate():
             # different version checked out
             return True
         # check for staged changes or modified files; ignore untracked files
         self._gitupdatestat()
         out, code = self._gitdir(['diff-index', '--quiet', 'HEAD'])
         return code == 1
 
     def basestate(self):
         return self._gitstate()
 
     @annotatesubrepoerror
     def get(self, state, overwrite=False):
         source, revision, kind = state
         if not revision:
             self.remove()
             return
         self._fetch(source, revision)
         # if the repo was set to be bare, unbare it
         if self._gitisbare():
             self._gitcommand(['config', 'core.bare', 'false'])
             if self._gitstate() == revision:
                 self._gitcommand(['reset', '--hard', 'HEAD'])
                 return
         elif self._gitstate() == revision:
             if overwrite:
                 # first reset the index to unmark new files for commit, because
                 # reset --hard will otherwise throw away files added for commit,
                 # not just unmark them.
                 self._gitcommand(['reset', 'HEAD'])
                 self._gitcommand(['reset', '--hard', 'HEAD'])
             return
         branch2rev, rev2branch = self._gitbranchmap()
 
         def checkout(args):
             cmd = ['checkout']
             if overwrite:
                 # first reset the index to unmark new files for commit, because
                 # the -f option will otherwise throw away files added for
                 # commit, not just unmark them.
                 self._gitcommand(['reset', 'HEAD'])
                 cmd.append('-f')
             self._gitcommand(cmd + args)
             _sanitize(self.ui, self.wvfs, '.git')
 
         def rawcheckout():
             # no branch to checkout, check it out with no branch
             self.ui.warn(_('checking out detached HEAD in '
                            'subrepository "%s"\n') % self._relpath)
             self.ui.warn(_('check out a git branch if you intend '
                             'to make changes\n'))
             checkout(['-q', revision])
 
         if revision not in rev2branch:
             rawcheckout()
             return
         branches = rev2branch[revision]
         firstlocalbranch = None
         for b in branches:
             if b == 'refs/heads/master':
                 # master trumps all other branches
                 checkout(['refs/heads/master'])
                 return
             if not firstlocalbranch and not b.startswith('refs/remotes/'):
                 firstlocalbranch = b
         if firstlocalbranch:
             checkout([firstlocalbranch])
             return
 
         tracking = self._gittracking(branch2rev.keys())
         # choose a remote branch already tracked if possible
         remote = branches[0]
         if remote not in tracking:
             for b in branches:
                 if b in tracking:
                     remote = b
                     break
 
         if remote not in tracking:
             # create a new local tracking branch
             local = remote.split('/', 3)[3]
             checkout(['-b', local, remote])
         elif self._gitisancestor(branch2rev[tracking[remote]], remote):
             # When updating to a tracked remote branch,
             # if the local tracking branch is downstream of it,
             # a normal `git pull` would have performed a "fast-forward merge"
             # which is equivalent to updating the local branch to the remote.
             # Since we are only looking at branching at update, we need to
             # detect this situation and perform this action lazily.
             if tracking[remote] != self._gitcurrentbranch():
                 checkout([tracking[remote]])
             self._gitcommand(['merge', '--ff', remote])
             _sanitize(self.ui, self.wvfs, '.git')
         else:
             # a real merge would be required, just checkout the revision
             rawcheckout()
 
     @annotatesubrepoerror
     def commit(self, text, user, date):
         if self._gitmissing():
             raise error.Abort(_("subrepo %s is missing") % self._relpath)
         cmd = ['commit', '-a', '-m', text]
         env = encoding.environ.copy()
         if user:
             cmd += ['--author', user]
         if date:
             # git's date parser silently ignores when seconds < 1e9
             # convert to ISO8601
             env['GIT_AUTHOR_DATE'] = dateutil.datestr(date,
                                                   '%Y-%m-%dT%H:%M:%S %1%2')
         self._gitcommand(cmd, env=env)
         # make sure commit works otherwise HEAD might not exist under certain
         # circumstances
         return self._gitstate()
 
     @annotatesubrepoerror
     def merge(self, state):
         source, revision, kind = state
         self._fetch(source, revision)
         base = self._gitcommand(['merge-base', revision, self._state[1]])
         self._gitupdatestat()
         out, code = self._gitdir(['diff-index', '--quiet', 'HEAD'])
 
         def mergefunc():
             if base == revision:
                 self.get(state) # fast forward merge
             elif base != self._state[1]:
                 self._gitcommand(['merge', '--no-commit', revision])
             _sanitize(self.ui, self.wvfs, '.git')
 
         if self.dirty():
             if self._gitstate() != revision:
                 dirty = self._gitstate() == self._state[1] or code != 0
                 if _updateprompt(self.ui, self, dirty,
                                  self._state[1][:7], revision[:7]):
                     mergefunc()
         else:
             mergefunc()
 
     @annotatesubrepoerror
     def push(self, opts):
         force = opts.get('force')
 
         if not self._state[1]:
             return True
         if self._gitmissing():
             raise error.Abort(_("subrepo %s is missing") % self._relpath)
         # if a branch in origin contains the revision, nothing to do
         branch2rev, rev2branch = self._gitbranchmap()
         if self._state[1] in rev2branch:
             for b in rev2branch[self._state[1]]:
                 if b.startswith('refs/remotes/origin/'):
                     return True
         for b, revision in branch2rev.iteritems():
             if b.startswith('refs/remotes/origin/'):
                 if self._gitisancestor(self._state[1], revision):
                     return True
         # otherwise, try to push the currently checked out branch
         cmd = ['push']
         if force:
             cmd.append('--force')
 
         current = self._gitcurrentbranch()
         if current:
             # determine if the current branch is even useful
             if not self._gitisancestor(self._state[1], current):
                 self.ui.warn(_('unrelated git branch checked out '
                                'in subrepository "%s"\n') % self._relpath)
                 return False
             self.ui.status(_('pushing branch %s of subrepository "%s"\n') %
                            (current.split('/', 2)[2], self._relpath))
             ret = self._gitdir(cmd + ['origin', current])
             return ret[1] == 0
         else:
             self.ui.warn(_('no branch checked out in subrepository "%s"\n'
                            'cannot push revision %s\n') %
                           (self._relpath, self._state[1]))
             return False
 
     @annotatesubrepoerror
     def add(self, ui, match, prefix, explicitonly, **opts):
         if self._gitmissing():
             return []
 
         (modified, added, removed,
          deleted, unknown, ignored, clean) = self.status(None, unknown=True,
                                                          clean=True)
 
         tracked = set()
         # dirstates 'amn' warn, 'r' is added again
         for l in (modified, added, deleted, clean):
             tracked.update(l)
 
         # Unknown files not of interest will be rejected by the matcher
         files = unknown
         files.extend(match.files())
 
         rejected = []
 
         files = [f for f in sorted(set(files)) if match(f)]
         for f in files:
             exact = match.exact(f)
             command = ["add"]
             if exact:
                 command.append("-f") #should be added, even if ignored
             if ui.verbose or not exact:
                 ui.status(_('adding %s\n') % match.rel(f))
 
             if f in tracked:  # hg prints 'adding' even if already tracked
                 if exact:
                     rejected.append(f)
                 continue
             if not opts.get(r'dry_run'):
                 self._gitcommand(command + [f])
 
         for f in rejected:
             ui.warn(_("%s already tracked!\n") % match.abs(f))
 
         return rejected
 
     @annotatesubrepoerror
     def remove(self):
         if self._gitmissing():
             return
         if self.dirty():
             self.ui.warn(_('not removing repo %s because '
                            'it has changes.\n') % self._relpath)
             return
         # we can't fully delete the repository as it may contain
         # local-only history
         self.ui.note(_('removing subrepo %s\n') % self._relpath)
         self._gitcommand(['config', 'core.bare', 'true'])
         for f, kind in self.wvfs.readdir():
             if f == '.git':
                 continue
             if kind == stat.S_IFDIR:
                 self.wvfs.rmtree(f)
             else:
                 self.wvfs.unlink(f)
 
     def archive(self, archiver, prefix, match=None, decode=True):
         total = 0
         source, revision = self._state
         if not revision:
             return total
         self._fetch(source, revision)
 
         # Parse git's native archive command.
         # This should be much faster than manually traversing the trees
         # and objects with many subprocess calls.
         tarstream = self._gitcommand(['archive', revision], stream=True)
         tar = tarfile.open(fileobj=tarstream, mode=r'r|')
         relpath = subrelpath(self)
         progress = self.ui.makeprogress(_('archiving (%s)') % relpath,
                                         unit=_('files'))
         progress.update(0)
         for info in tar:
             if info.isdir():
                 continue
             if match and not match(info.name):
                 continue
             if info.issym():
                 data = info.linkname
             else:
                 data = tar.extractfile(info).read()
             archiver.addfile(prefix + self._path + '/' + info.name,
                              info.mode, info.issym(), data)
             total += 1
             progress.increment()
         progress.complete()
         return total
 
 
     @annotatesubrepoerror
     def cat(self, match, fm, fntemplate, prefix, **opts):
         rev = self._state[1]
         if match.anypats():
             return 1 #No support for include/exclude yet
 
         if not match.files():
             return 1
 
         # TODO: add support for non-plain formatter (see cmdutil.cat())
         for f in match.files():
             output = self._gitcommand(["show", "%s:%s" % (rev, f)])
             fp = cmdutil.makefileobj(self._ctx, fntemplate,
                                      pathname=self.wvfs.reljoin(prefix, f))
             fp.write(output)
             fp.close()
         return 0
 
 
     @annotatesubrepoerror
     def status(self, rev2, **opts):
         rev1 = self._state[1]
         if self._gitmissing() or not rev1:
             # if the repo is missing, return no results
             return scmutil.status([], [], [], [], [], [], [])
         modified, added, removed = [], [], []
         self._gitupdatestat()
         if rev2:
             command = ['diff-tree', '--no-renames', '-r', rev1, rev2]
         else:
             command = ['diff-index', '--no-renames', rev1]
         out = self._gitcommand(command)
         for line in out.split('\n'):
             tab = line.find('\t')
             if tab == -1:
                 continue
             status, f = line[tab - 1:tab], line[tab + 1:]
             if status == 'M':
                 modified.append(f)
             elif status == 'A':
                 added.append(f)
             elif status == 'D':
                 removed.append(f)
 
         deleted, unknown, ignored, clean = [], [], [], []
 
         command = ['status', '--porcelain', '-z']
         if opts.get(r'unknown'):
             command += ['--untracked-files=all']
         if opts.get(r'ignored'):
             command += ['--ignored']
         out = self._gitcommand(command)
 
         changedfiles = set()
         changedfiles.update(modified)
         changedfiles.update(added)
         changedfiles.update(removed)
         for line in out.split('\0'):
             if not line:
                 continue
             st = line[0:2]
             #moves and copies show 2 files on one line
             if line.find('\0') >= 0:
                 filename1, filename2 = line[3:].split('\0')
             else:
                 filename1 = line[3:]
                 filename2 = None
 
             changedfiles.add(filename1)
             if filename2:
                 changedfiles.add(filename2)
 
             if st == '??':
                 unknown.append(filename1)
             elif st == '!!':
                 ignored.append(filename1)
 
         if opts.get(r'clean'):
             out = self._gitcommand(['ls-files'])
             for f in out.split('\n'):
                 if not f in changedfiles:
                     clean.append(f)
 
         return scmutil.status(modified, added, removed, deleted,
                               unknown, ignored, clean)
 
     @annotatesubrepoerror
     def diff(self, ui, diffopts, node2, match, prefix, **opts):
         node1 = self._state[1]
         cmd = ['diff', '--no-renames']
         if opts[r'stat']:
             cmd.append('--stat')
         else:
             # for Git, this also implies '-p'
             cmd.append('-U%d' % diffopts.context)
 
         gitprefix = self.wvfs.reljoin(prefix, self._path)
 
         if diffopts.noprefix:
             cmd.extend(['--src-prefix=%s/' % gitprefix,
                         '--dst-prefix=%s/' % gitprefix])
         else:
             cmd.extend(['--src-prefix=a/%s/' % gitprefix,
                         '--dst-prefix=b/%s/' % gitprefix])
 
         if diffopts.ignorews:
             cmd.append('--ignore-all-space')
         if diffopts.ignorewsamount:
             cmd.append('--ignore-space-change')
         if self._gitversion(self._gitcommand(['--version'])) >= (1, 8, 4) \
                 and diffopts.ignoreblanklines:
             cmd.append('--ignore-blank-lines')
 
         cmd.append(node1)
         if node2:
             cmd.append(node2)
 
         output = ""
         if match.always():
             output += self._gitcommand(cmd) + '\n'
         else:
             st = self.status(node2)[:3]
             files = [f for sublist in st for f in sublist]
             for f in files:
                 if match(f):
                     output += self._gitcommand(cmd + ['--', f]) + '\n'
 
         if output.strip():
             ui.write(output)
 
     @annotatesubrepoerror
     def revert(self, substate, *pats, **opts):
         self.ui.status(_('reverting subrepo %s\n') % substate[0])
         if not opts.get(r'no_backup'):
             status = self.status(None)
             names = status.modified
             for name in names:
                 bakname = scmutil.origpath(self.ui, self._subparent, name)
                 self.ui.note(_('saving current version of %s as %s\n') %
                         (name, bakname))
                 self.wvfs.rename(name, bakname)
 
         if not opts.get(r'dry_run'):
             self.get(substate, overwrite=True)
         return []
 
     def shortid(self, revid):
         return revid[:7]
 
 types = {
     'hg': hgsubrepo,
     'svn': svnsubrepo,
     'git': gitsubrepo,
     }

tests/test-glog-beautifygraph.t

@@ -1,3147 +1,3158 b''
 @  (34) head
 |
 | o  (33) head
 | |
 o |    (32) expand
 |\ \
 | o \    (31) expand
 | |\ \
 | | o \    (30) expand
 | | |\ \
 | | | o |  (29) regular commit
 | | | | |
 | | o | |    (28) merge zero known
 | | |\ \ \
 o | | | | |  (27) collapse
 |/ / / / /
 | | o---+  (26) merge one known; far right
 | | | | |
 +---o | |  (25) merge one known; far left
 | | | | |
 | | o | |  (24) merge one known; immediate right
 | | |\| |
 | | o | |  (23) merge one known; immediate left
 | |/| | |
 +---o---+  (22) merge two known; one far left, one far right
 | |  / /
 o | | |    (21) expand
 |\ \ \ \
 | o---+-+  (20) merge two known; two far right
 |  / / /
 o | | |    (19) expand
 |\ \ \ \
 +---+---o  (18) merge two known; two far left
 | | | |
 | o | |    (17) expand
 | |\ \ \
 | | o---+  (16) merge two known; one immediate right, one near right
 | | |/ /
 o | | |    (15) expand
 |\ \ \ \
 | o-----+  (14) merge two known; one immediate right, one far right
 | |/ / /
 o | | |    (13) expand
 |\ \ \ \
 +---o | |  (12) merge two known; one immediate right, one far left
 | | |/ /
 | o | |    (11) expand
 | |\ \ \
 | | o---+  (10) merge two known; one immediate left, one near right
 | |/ / /
 o | | |    (9) expand
 |\ \ \ \
 | o-----+  (8) merge two known; one immediate left, one far right
 |/ / / /
 o | | |    (7) expand
 |\ \ \ \
 +---o | |  (6) merge two known; one immediate left, one far left
 | |/ / /
 | o | |    (5) expand
 | |\ \ \
 | | o | |  (4) merge two known; one immediate left, one immediate right
 | |/|/ /
 | o / /  (3) collapse
 |/ / /
 o / /  (2) collapse
 |/ /
 o /  (1) collapse
 |/
 o  (0) root
 
   $ commit()
   > {
   >   rev=$1
   >   msg=$2
   >   shift 2
   >   if [ "$#" -gt 0 ]; then
   >       hg debugsetparents "$@"
   >   fi
   >   echo $rev > a
   >   hg commit -Aqd "$rev 0" -m "($rev) $msg"
   > }
 
   $ cat > printrevset.py <<EOF
   > from __future__ import absolute_import
   > from mercurial import (
   >   cmdutil,
   >   commands,
   >   extensions,
   >   logcmdutil,
   >   revsetlang,
   >   smartset,
   > )
   > 
   > from mercurial.utils import (
   >   stringutil,
   > )
   > 
   > def logrevset(repo, pats, opts):
   >     revs = logcmdutil._initialrevs(repo, opts)
   >     if not revs:
   >         return None
   >     match, pats, slowpath = logcmdutil._makematcher(repo, revs, pats, opts)
   >     return logcmdutil._makerevset(repo, match, pats, slowpath, opts)
   > 
   > def uisetup(ui):
   >     def printrevset(orig, repo, pats, opts):
   >         revs, filematcher = orig(repo, pats, opts)
   >         if opts.get(b'print_revset'):
   >             expr = logrevset(repo, pats, opts)
   >             if expr:
   >                 tree = revsetlang.parse(expr)
   >                 tree = revsetlang.analyze(tree)
   >             else:
   >                 tree = []
   >             ui = repo.ui
   >             ui.write(b'%r\n' % (opts.get(b'rev', []),))
   >             ui.write(revsetlang.prettyformat(tree) + b'\n')
   >             ui.write(stringutil.prettyrepr(revs) + b'\n')
   >             revs = smartset.baseset()  # display no revisions
   >         return revs, filematcher
   >     extensions.wrapfunction(logcmdutil, 'getrevs', printrevset)
   >     aliases, entry = cmdutil.findcmd(b'log', commands.table)
   >     entry[1].append((b'', b'print-revset', False,
   >                      b'print generated revset and exit (DEPRECATED)'))
   > EOF
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "printrevset=`pwd`/printrevset.py" >> $HGRCPATH
   $ echo "beautifygraph=" >> $HGRCPATH
 
 Set a default of narrow-text UTF-8.
 
   $ HGENCODING=UTF-8; export HGENCODING
   $ HGENCODINGAMBIGUOUS=narrow; export HGENCODINGAMBIGUOUS
 
 Empty repo:
 
   $ hg init repo
   $ cd repo
   $ hg log -G
 
 Building DAG:
 
   $ commit 0 "root"
   $ commit 1 "collapse" 0
   $ commit 2 "collapse" 1
   $ commit 3 "collapse" 2
   $ commit 4 "merge two known; one immediate left, one immediate right" 1 3
   $ commit 5 "expand" 3 4
   $ commit 6 "merge two known; one immediate left, one far left" 2 5
   $ commit 7 "expand" 2 5
   $ commit 8 "merge two known; one immediate left, one far right" 0 7
   $ commit 9 "expand" 7 8
   $ commit 10 "merge two known; one immediate left, one near right" 0 6
   $ commit 11 "expand" 6 10
   $ commit 12 "merge two known; one immediate right, one far left" 1 9
   $ commit 13 "expand" 9 11
   $ commit 14 "merge two known; one immediate right, one far right" 0 12
   $ commit 15 "expand" 13 14
   $ commit 16 "merge two known; one immediate right, one near right" 0 1
   $ commit 17 "expand" 12 16
   $ commit 18 "merge two known; two far left" 1 15
   $ commit 19 "expand" 15 17
   $ commit 20 "merge two known; two far right" 0 18
   $ commit 21 "expand" 19 20
   $ commit 22 "merge two known; one far left, one far right" 18 21
   $ commit 23 "merge one known; immediate left" 1 22
   $ commit 24 "merge one known; immediate right" 0 23
   $ commit 25 "merge one known; far left" 21 24
   $ commit 26 "merge one known; far right" 18 25
   $ commit 27 "collapse" 21
   $ commit 28 "merge zero known" 1 26
   $ commit 29 "regular commit" 0
   $ commit 30 "expand" 28 29
   $ commit 31 "expand" 21 30
   $ commit 32 "expand" 27 31
   $ commit 33 "head" 18
   $ commit 34 "head" 32
 
 The extension should not turn on unless we're in UTF-8.
 
   $ HGENCODING=latin1 hg log -G -q
   beautifygraph: unsupported encoding, UTF-8 required
   @  34:fea3ac5810e0
   |
   | o  33:68608f5145f9
   | |
   o |    32:d06dffa21a31
   |\ \
   | o \    31:621d83e11f67
   | |\ \
   | | o \    30:6e11cd4b648f
   | | |\ \
   | | | o |  29:cd9bb2be7593
   | | | | |
   | | o | |    28:44ecd0b9ae99
   | | |\ \ \
   o | | | | |  27:886ed638191b
   |/ / / / /
   | | o---+  26:7f25b6c2f0b9
   | | | | |
   +---o | |  25:91da8ed57247
   | | | | |
   | | o | |  24:a9c19a3d96b7
   | | |\| |
   | | o | |  23:a01cddf0766d
   | |/| | |
   +---o---+  22:e0d9cccacb5d
   | |  / /
   o | | |    21:d42a756af44d
   |\ \ \ \
   | o---+-+  20:d30ed6450e32
   |  / / /
   o | | |    19:31ddc2c1573b
   |\ \ \ \
   +---+---o  18:1aa84d96232a
   | | | |
   | o | |    17:44765d7c06e0
   | |\ \ \
   | | o---+  16:3677d192927d
   | | |/ /
   o | | |    15:1dda3f72782d
   |\ \ \ \
   | o-----+  14:8eac370358ef
   | |/ / /
   o | | |    13:22d8966a97e3
   |\ \ \ \
   +---o | |  12:86b91144a6e9
   | | |/ /
   | o | |    11:832d76e6bdf2
   | |\ \ \
   | | o---+  10:74c64d036d72
   | |/ / /
   o | | |    9:7010c0af0a35
   |\ \ \ \
   | o-----+  8:7a0b11f71937
   |/ / / /
   o | | |    7:b632bb1b1224
   |\ \ \ \
   +---o | |  6:b105a072e251
   | |/ / /
   | o | |    5:4409d547b708
   | |\ \ \
   | | o | |  4:26a8bac39d9f
   | |/|/ /
   | o / /  3:27eef8ed80b4
   |/ / /
   o / /  2:3d9a33b8d1e1
   |/ /
   o /  1:6db2ef61d156
   |/
   o  0:e6eb3150255d
   
 
 The extension should not turn on if we're using wide text.
 
   $ HGENCODINGAMBIGUOUS=wide hg log -G -q
   beautifygraph: unsupported terminal settings, monospace narrow text required
   @  34:fea3ac5810e0
   |
   | o  33:68608f5145f9
   | |
   o |    32:d06dffa21a31
   |\ \
   | o \    31:621d83e11f67
   | |\ \
   | | o \    30:6e11cd4b648f
   | | |\ \
   | | | o |  29:cd9bb2be7593
   | | | | |
   | | o | |    28:44ecd0b9ae99
   | | |\ \ \
   o | | | | |  27:886ed638191b
   |/ / / / /
   | | o---+  26:7f25b6c2f0b9
   | | | | |
   +---o | |  25:91da8ed57247
   | | | | |
   | | o | |  24:a9c19a3d96b7
   | | |\| |
   | | o | |  23:a01cddf0766d
   | |/| | |
   +---o---+  22:e0d9cccacb5d
   | |  / /
   o | | |    21:d42a756af44d
   |\ \ \ \
   | o---+-+  20:d30ed6450e32
   |  / / /
   o | | |    19:31ddc2c1573b
   |\ \ \ \
   +---+---o  18:1aa84d96232a
   | | | |
   | o | |    17:44765d7c06e0
   | |\ \ \
   | | o---+  16:3677d192927d
   | | |/ /
   o | | |    15:1dda3f72782d
   |\ \ \ \
   | o-----+  14:8eac370358ef
   | |/ / /
   o | | |    13:22d8966a97e3
   |\ \ \ \
   +---o | |  12:86b91144a6e9
   | | |/ /
   | o | |    11:832d76e6bdf2
   | |\ \ \
   | | o---+  10:74c64d036d72
   | |/ / /
   o | | |    9:7010c0af0a35
   |\ \ \ \
   | o-----+  8:7a0b11f71937
   |/ / / /
   o | | |    7:b632bb1b1224
   |\ \ \ \
   +---o | |  6:b105a072e251
   | |/ / /
   | o | |    5:4409d547b708
   | |\ \ \
   | | o | |  4:26a8bac39d9f
   | |/|/ /
   | o / /  3:27eef8ed80b4
   |/ / /
   o / /  2:3d9a33b8d1e1
   |/ /
   o /  1:6db2ef61d156
   |/
   o  0:e6eb3150255d
   
 
 The rest of our tests will use the default narrow text UTF-8.
 
   $ hg log -G -q
   \xe2\x97\x8d  34:fea3ac5810e0 (esc)
   \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  33:68608f5145f9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82  32:d06dffa21a31 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x95\xb2  31:621d83e11f67 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x95\xb2  30:6e11cd4b648f (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82  29:cd9bb2be7593 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  28:44ecd0b9ae99 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  27:886ed638191b (esc)
   \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  26:7f25b6c2f0b9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  25:91da8ed57247 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  24:a9c19a3d96b7 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2\xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  23:a01cddf0766d (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1\xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  22:e0d9cccacb5d (esc)
   \xe2\x94\x82 \xe2\x94\x82  \xe2\x95\xb1 \xe2\x95\xb1 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  21:d42a756af44d (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 (esc)
   \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xbc\xe2\x94\x80\xe2\x94\xa4  20:d30ed6450e32 (esc)
   \xe2\x94\x82  \xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  19:31ddc2c1573b (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xbc\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b  18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  17:44765d7c06e0 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  16:3677d192927d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  15:1dda3f72782d (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 (esc)
   \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  14:8eac370358ef (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  13:22d8966a97e3 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  12:86b91144a6e9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  11:832d76e6bdf2 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  10:74c64d036d72 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  9:7010c0af0a35 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 (esc)
   \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  8:7a0b11f71937 (esc)
   \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  7:b632bb1b1224 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  6:b105a072e251 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  5:4409d547b708 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  4:26a8bac39d9f (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1\xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x95\xb1 \xe2\x95\xb1  3:27eef8ed80b4 (esc)
   \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 (esc)
   \xe2\x97\x8b \xe2\x95\xb1 \xe2\x95\xb1  2:3d9a33b8d1e1 (esc)
   \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 (esc)
   \xe2\x97\x8b \xe2\x95\xb1  1:6db2ef61d156 (esc)
   \xe2\x94\x82\xe2\x95\xb1 (esc)
   \xe2\x97\x8b  0:e6eb3150255d (esc)
   
 
   $ hg log -G
   \xe2\x97\x8d  changeset:   34:fea3ac5810e0 (esc)
   \xe2\x94\x82  tag:         tip (esc)
   \xe2\x94\x82  parent:      32:d06dffa21a31 (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82  date:        Thu Jan 01 00:00:34 1970 +0000 (esc)
   \xe2\x94\x82  summary:     (34) head (esc)
   \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   33:68608f5145f9 (esc)
   \xe2\x94\x82 \xe2\x94\x82  parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:33 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82  summary:     (33) head (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82  changeset:   32:d06dffa21a31 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      27:886ed638191b (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      31:621d83e11f67 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:32 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (32) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82  changeset:   31:621d83e11f67 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      30:6e11cd4b648f (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:31 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (31) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82  changeset:   30:6e11cd4b648f (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      28:44ecd0b9ae99 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      29:cd9bb2be7593 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:30 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (30) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82  changeset:   29:cd9bb2be7593 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:29 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (29) regular commit (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   28:44ecd0b9ae99 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      26:7f25b6c2f0b9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:28 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (28) merge zero known (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   27:886ed638191b (esc)
   \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:27 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (27) collapse (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   26:7f25b6c2f0b9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      25:91da8ed57247 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:26 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (26) merge one known; far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   25:91da8ed57247 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      24:a9c19a3d96b7 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:25 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (25) merge one known; far left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   24:a9c19a3d96b7 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2\xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      23:a01cddf0766d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:24 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (24) merge one known; immediate right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   23:a01cddf0766d (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1\xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      22:e0d9cccacb5d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:23 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (23) merge one known; immediate left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   22:e0d9cccacb5d (esc)
   \xe2\x94\x82 \xe2\x94\x82   \xe2\x94\x82 \xe2\x94\x82  parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82  \xe2\x95\xb1 \xe2\x95\xb1   parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:22 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (22) merge two known; one far left, one far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   21:d42a756af44d (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      19:31ddc2c1573b (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      20:d30ed6450e32 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:21 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (21) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xbc\xe2\x94\x80\xe2\x94\xa4  changeset:   20:d30ed6450e32 (esc)
   \xe2\x94\x82   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82  \xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:20 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (20) merge two known; two far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   19:31ddc2c1573b (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      15:1dda3f72782d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      17:44765d7c06e0 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:19 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (19) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xbc\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b  changeset:   18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    parent:      15:1dda3f72782d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:18 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (18) merge two known; two far left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   17:44765d7c06e0 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      12:86b91144a6e9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      16:3677d192927d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:17 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (17) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   16:3677d192927d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1   parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:16 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (16) merge two known; one immediate right, one near right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   15:1dda3f72782d (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      13:22d8966a97e3 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      14:8eac370358ef (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:15 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (15) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   14:8eac370358ef (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      12:86b91144a6e9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:14 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (14) merge two known; one immediate right, one far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   13:22d8966a97e3 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      9:7010c0af0a35 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      11:832d76e6bdf2 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:13 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (13) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   12:86b91144a6e9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1   parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    parent:      9:7010c0af0a35 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:12 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (12) merge two known; one immediate right, one far left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   11:832d76e6bdf2 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      6:b105a072e251 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      10:74c64d036d72 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:11 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (11) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   10:74c64d036d72 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      6:b105a072e251 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:10 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (10) merge two known; one immediate left, one near right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   9:7010c0af0a35 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      7:b632bb1b1224 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      8:7a0b11f71937 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:09 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (9) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   8:7a0b11f71937 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      7:b632bb1b1224 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:08 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (8) merge two known; one immediate left, one far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   7:b632bb1b1224 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      2:3d9a33b8d1e1 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      5:4409d547b708 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:07 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (7) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   6:b105a072e251 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      2:3d9a33b8d1e1 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    parent:      5:4409d547b708 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:06 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (6) merge two known; one immediate left, one far left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   5:4409d547b708 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      3:27eef8ed80b4 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      4:26a8bac39d9f (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:05 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (5) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   4:26a8bac39d9f (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1\xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1   parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    parent:      3:27eef8ed80b4 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:04 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (4) merge two known; one immediate left, one immediate right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   3:27eef8ed80b4 (esc)
   \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:03 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (3) collapse (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   2:3d9a33b8d1e1 (esc)
   \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1   user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:02 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82    summary:     (2) collapse (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82  changeset:   1:6db2ef61d156 (esc)
   \xe2\x94\x82\xe2\x95\xb1   user:        test (esc)
   \xe2\x94\x82    date:        Thu Jan 01 00:00:01 1970 +0000 (esc)
   \xe2\x94\x82    summary:     (1) collapse (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   0:e6eb3150255d (esc)
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     (0) root
   
 File glog:
   $ hg log -G a
   \xe2\x97\x8d  changeset:   34:fea3ac5810e0 (esc)
   \xe2\x94\x82  tag:         tip (esc)
   \xe2\x94\x82  parent:      32:d06dffa21a31 (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82  date:        Thu Jan 01 00:00:34 1970 +0000 (esc)
   \xe2\x94\x82  summary:     (34) head (esc)
   \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   33:68608f5145f9 (esc)
   \xe2\x94\x82 \xe2\x94\x82  parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:33 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82  summary:     (33) head (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82  changeset:   32:d06dffa21a31 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      27:886ed638191b (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      31:621d83e11f67 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:32 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (32) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82  changeset:   31:621d83e11f67 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      30:6e11cd4b648f (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:31 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (31) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82  changeset:   30:6e11cd4b648f (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      28:44ecd0b9ae99 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      29:cd9bb2be7593 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:30 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (30) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82  changeset:   29:cd9bb2be7593 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:29 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (29) regular commit (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   28:44ecd0b9ae99 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      26:7f25b6c2f0b9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:28 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (28) merge zero known (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   27:886ed638191b (esc)
   \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:27 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (27) collapse (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   26:7f25b6c2f0b9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      25:91da8ed57247 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:26 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (26) merge one known; far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   25:91da8ed57247 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      24:a9c19a3d96b7 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:25 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (25) merge one known; far left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   24:a9c19a3d96b7 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2\xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      23:a01cddf0766d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:24 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (24) merge one known; immediate right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   23:a01cddf0766d (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1\xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      22:e0d9cccacb5d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:23 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (23) merge one known; immediate left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   22:e0d9cccacb5d (esc)
   \xe2\x94\x82 \xe2\x94\x82   \xe2\x94\x82 \xe2\x94\x82  parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82  \xe2\x95\xb1 \xe2\x95\xb1   parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:22 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (22) merge two known; one far left, one far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   21:d42a756af44d (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      19:31ddc2c1573b (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      20:d30ed6450e32 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:21 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (21) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xbc\xe2\x94\x80\xe2\x94\xa4  changeset:   20:d30ed6450e32 (esc)
   \xe2\x94\x82   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82  \xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:20 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (20) merge two known; two far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   19:31ddc2c1573b (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      15:1dda3f72782d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      17:44765d7c06e0 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:19 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (19) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xbc\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b  changeset:   18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    parent:      15:1dda3f72782d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:18 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (18) merge two known; two far left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   17:44765d7c06e0 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      12:86b91144a6e9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      16:3677d192927d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:17 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (17) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   16:3677d192927d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1   parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:16 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (16) merge two known; one immediate right, one near right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   15:1dda3f72782d (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      13:22d8966a97e3 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      14:8eac370358ef (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:15 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (15) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   14:8eac370358ef (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      12:86b91144a6e9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:14 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (14) merge two known; one immediate right, one far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   13:22d8966a97e3 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      9:7010c0af0a35 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      11:832d76e6bdf2 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:13 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (13) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   12:86b91144a6e9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1   parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    parent:      9:7010c0af0a35 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:12 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (12) merge two known; one immediate right, one far left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   11:832d76e6bdf2 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      6:b105a072e251 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      10:74c64d036d72 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:11 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (11) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   10:74c64d036d72 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      6:b105a072e251 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:10 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (10) merge two known; one immediate left, one near right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   9:7010c0af0a35 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      7:b632bb1b1224 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      8:7a0b11f71937 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:09 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (9) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   8:7a0b11f71937 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      7:b632bb1b1224 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:08 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (8) merge two known; one immediate left, one far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   7:b632bb1b1224 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      2:3d9a33b8d1e1 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      5:4409d547b708 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:07 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (7) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   6:b105a072e251 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      2:3d9a33b8d1e1 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    parent:      5:4409d547b708 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:06 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (6) merge two known; one immediate left, one far left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   5:4409d547b708 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      3:27eef8ed80b4 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      4:26a8bac39d9f (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:05 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (5) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   4:26a8bac39d9f (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1\xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1   parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    parent:      3:27eef8ed80b4 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:04 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (4) merge two known; one immediate left, one immediate right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   3:27eef8ed80b4 (esc)
   \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:03 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (3) collapse (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   2:3d9a33b8d1e1 (esc)
   \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1   user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:02 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82    summary:     (2) collapse (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82  changeset:   1:6db2ef61d156 (esc)
   \xe2\x94\x82\xe2\x95\xb1   user:        test (esc)
   \xe2\x94\x82    date:        Thu Jan 01 00:00:01 1970 +0000 (esc)
   \xe2\x94\x82    summary:     (1) collapse (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   0:e6eb3150255d (esc)
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     (0) root
   
 File glog per revset:
 
   $ hg log -G -r 'file("a")'
   \xe2\x97\x8d  changeset:   34:fea3ac5810e0 (esc)
   \xe2\x94\x82  tag:         tip (esc)
   \xe2\x94\x82  parent:      32:d06dffa21a31 (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82  date:        Thu Jan 01 00:00:34 1970 +0000 (esc)
   \xe2\x94\x82  summary:     (34) head (esc)
   \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   33:68608f5145f9 (esc)
   \xe2\x94\x82 \xe2\x94\x82  parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:33 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82  summary:     (33) head (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82  changeset:   32:d06dffa21a31 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      27:886ed638191b (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      31:621d83e11f67 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:32 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (32) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82  changeset:   31:621d83e11f67 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      30:6e11cd4b648f (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:31 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (31) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82  changeset:   30:6e11cd4b648f (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      28:44ecd0b9ae99 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      29:cd9bb2be7593 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:30 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (30) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82  changeset:   29:cd9bb2be7593 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:29 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (29) regular commit (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   28:44ecd0b9ae99 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      26:7f25b6c2f0b9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:28 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (28) merge zero known (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   27:886ed638191b (esc)
   \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:27 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (27) collapse (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   26:7f25b6c2f0b9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      25:91da8ed57247 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:26 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (26) merge one known; far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   25:91da8ed57247 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      24:a9c19a3d96b7 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:25 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (25) merge one known; far left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   24:a9c19a3d96b7 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2\xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      23:a01cddf0766d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:24 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (24) merge one known; immediate right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   23:a01cddf0766d (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1\xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      22:e0d9cccacb5d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:23 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (23) merge one known; immediate left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   22:e0d9cccacb5d (esc)
   \xe2\x94\x82 \xe2\x94\x82   \xe2\x94\x82 \xe2\x94\x82  parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82  \xe2\x95\xb1 \xe2\x95\xb1   parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:22 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (22) merge two known; one far left, one far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   21:d42a756af44d (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      19:31ddc2c1573b (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      20:d30ed6450e32 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:21 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (21) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xbc\xe2\x94\x80\xe2\x94\xa4  changeset:   20:d30ed6450e32 (esc)
   \xe2\x94\x82   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82  \xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:20 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (20) merge two known; two far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   19:31ddc2c1573b (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      15:1dda3f72782d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      17:44765d7c06e0 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:19 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (19) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xbc\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b  changeset:   18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    parent:      15:1dda3f72782d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:18 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (18) merge two known; two far left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   17:44765d7c06e0 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      12:86b91144a6e9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      16:3677d192927d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:17 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (17) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   16:3677d192927d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1   parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:16 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (16) merge two known; one immediate right, one near right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   15:1dda3f72782d (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      13:22d8966a97e3 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      14:8eac370358ef (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:15 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (15) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   14:8eac370358ef (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      12:86b91144a6e9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:14 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (14) merge two known; one immediate right, one far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   13:22d8966a97e3 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      9:7010c0af0a35 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      11:832d76e6bdf2 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:13 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (13) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   12:86b91144a6e9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1   parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    parent:      9:7010c0af0a35 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:12 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (12) merge two known; one immediate right, one far left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   11:832d76e6bdf2 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      6:b105a072e251 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      10:74c64d036d72 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:11 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (11) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   10:74c64d036d72 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      6:b105a072e251 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:10 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (10) merge two known; one immediate left, one near right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   9:7010c0af0a35 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      7:b632bb1b1224 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      8:7a0b11f71937 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:09 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (9) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x94\xa4  changeset:   8:7a0b11f71937 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      7:b632bb1b1224 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:08 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (8) merge two known; one immediate left, one far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  changeset:   7:b632bb1b1224 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      2:3d9a33b8d1e1 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      5:4409d547b708 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:07 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (7) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   6:b105a072e251 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   parent:      2:3d9a33b8d1e1 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    parent:      5:4409d547b708 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:06 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (6) merge two known; one immediate left, one far left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   5:4409d547b708 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2 \xe2\x95\xb2   parent:      3:27eef8ed80b4 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      4:26a8bac39d9f (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:05 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (5) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   4:26a8bac39d9f (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1\xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1   parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    parent:      3:27eef8ed80b4 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:04 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (4) merge two known; one immediate left, one immediate right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   3:27eef8ed80b4 (esc)
   \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1 \xe2\x95\xb1   user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:03 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82    summary:     (3) collapse (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   2:3d9a33b8d1e1 (esc)
   \xe2\x94\x82\xe2\x95\xb1 \xe2\x95\xb1   user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:02 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82    summary:     (2) collapse (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82  changeset:   1:6db2ef61d156 (esc)
   \xe2\x94\x82\xe2\x95\xb1   user:        test (esc)
   \xe2\x94\x82    date:        Thu Jan 01 00:00:01 1970 +0000 (esc)
   \xe2\x94\x82    summary:     (1) collapse (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   0:e6eb3150255d (esc)
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     (0) root
   
 
 File glog per revset (only merges):
 
   $ hg log -G -r 'file("a")' -m
   \xe2\x97\x8b  changeset:   32:d06dffa21a31 (esc)
   \xe2\x94\x82\xe2\x95\xb2   parent:      27:886ed638191b (esc)
   \xe2\x94\x82 \xe2\x94\x86  parent:      31:621d83e11f67 (esc)
   \xe2\x94\x82 \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x86  date:        Thu Jan 01 00:00:32 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x86  summary:     (32) expand (esc)
   \xe2\x94\x82 \xe2\x94\x86 (esc)
   \xe2\x97\x8b \xe2\x94\x86  changeset:   31:621d83e11f67 (esc)
   \xe2\x94\x82\xe2\x95\xb2\xe2\x94\x86  parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x86  parent:      30:6e11cd4b648f (esc)
   \xe2\x94\x82 \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x86  date:        Thu Jan 01 00:00:31 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x86  summary:     (31) expand (esc)
   \xe2\x94\x82 \xe2\x94\x86 (esc)
   \xe2\x97\x8b \xe2\x94\x86  changeset:   30:6e11cd4b648f (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      28:44ecd0b9ae99 (esc)
   \xe2\x94\x82 \xe2\x95\xa7 \xe2\x94\x86  parent:      29:cd9bb2be7593 (esc)
   \xe2\x94\x82   \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x82   \xe2\x94\x86  date:        Thu Jan 01 00:00:30 1970 +0000 (esc)
   \xe2\x94\x82   \xe2\x94\x86  summary:     (30) expand (esc)
   \xe2\x94\x82  \xe2\x95\xb1 (esc)
   \xe2\x97\x8b \xe2\x94\x86  changeset:   28:44ecd0b9ae99 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x95\xa7 \xe2\x94\x86  parent:      26:7f25b6c2f0b9 (esc)
   \xe2\x94\x82   \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x82   \xe2\x94\x86  date:        Thu Jan 01 00:00:28 1970 +0000 (esc)
   \xe2\x94\x82   \xe2\x94\x86  summary:     (28) merge zero known (esc)
   \xe2\x94\x82  \xe2\x95\xb1 (esc)
   \xe2\x97\x8b \xe2\x94\x86  changeset:   26:7f25b6c2f0b9 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86  parent:      25:91da8ed57247 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86  date:        Thu Jan 01 00:00:26 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86  summary:     (26) merge one known; far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x86  changeset:   25:91da8ed57247 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2\xe2\x94\x86  parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86  parent:      24:a9c19a3d96b7 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86  date:        Thu Jan 01 00:00:25 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86  summary:     (25) merge one known; far left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x86  changeset:   24:a9c19a3d96b7 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x95\xa7 \xe2\x94\x86  parent:      23:a01cddf0766d (esc)
   \xe2\x94\x82 \xe2\x94\x82   \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82   \xe2\x94\x86  date:        Thu Jan 01 00:00:24 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82   \xe2\x94\x86  summary:     (24) merge one known; immediate right (esc)
   \xe2\x94\x82 \xe2\x94\x82  \xe2\x95\xb1 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x86  changeset:   23:a01cddf0766d (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x95\xa7 \xe2\x94\x86  parent:      22:e0d9cccacb5d (esc)
   \xe2\x94\x82 \xe2\x94\x82   \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82   \xe2\x94\x86  date:        Thu Jan 01 00:00:23 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82   \xe2\x94\x86  summary:     (23) merge one known; immediate left (esc)
   \xe2\x94\x82 \xe2\x94\x82  \xe2\x95\xb1 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x86  changeset:   22:e0d9cccacb5d (esc)
   \xe2\x94\x82\xe2\x95\xb1\xe2\x94\x86\xe2\x95\xb1   parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x86    parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x86    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x86    date:        Thu Jan 01 00:00:22 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x86    summary:     (22) merge two known; one far left, one far right (esc)
   \xe2\x94\x82 \xe2\x94\x86 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2   parent:      19:31ddc2c1573b (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      20:d30ed6450e32 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:21 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (21) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b  changeset:   20:d30ed6450e32 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x95\xa7  parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:20 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82    summary:     (20) merge two known; two far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   19:31ddc2c1573b (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2   parent:      15:1dda3f72782d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      17:44765d7c06e0 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:19 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (19) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   18:1aa84d96232a (esc)
   \xe2\x94\x82\xe2\x95\xb2\xe2\x94\x82 \xe2\x94\x82  parent:      1:6db2ef61d156 (esc)
   \xe2\x95\xa7 \xe2\x94\x82 \xe2\x94\x82  parent:      15:1dda3f72782d (esc)
     \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
     \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:18 1970 +0000 (esc)
     \xe2\x94\x82 \xe2\x94\x82  summary:     (18) merge two known; two far left (esc)
    \xe2\x95\xb1 \xe2\x95\xb1 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   17:44765d7c06e0 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2   parent:      12:86b91144a6e9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      16:3677d192927d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:17 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (17) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b  changeset:   16:3677d192927d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2   parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x95\xa7 \xe2\x95\xa7  parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82      user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82      date:        Thu Jan 01 00:00:16 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82      summary:     (16) merge two known; one immediate right, one near right (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82  changeset:   15:1dda3f72782d (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      13:22d8966a97e3 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      14:8eac370358ef (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:15 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (15) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82  changeset:   14:8eac370358ef (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2\xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x95\xa7 \xe2\x94\x82  parent:      12:86b91144a6e9 (esc)
   \xe2\x94\x82   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82   \xe2\x94\x82  date:        Thu Jan 01 00:00:14 1970 +0000 (esc)
   \xe2\x94\x82   \xe2\x94\x82  summary:     (14) merge two known; one immediate right, one far right (esc)
   \xe2\x94\x82  \xe2\x95\xb1 (esc)
   \xe2\x97\x8b \xe2\x94\x82  changeset:   13:22d8966a97e3 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      9:7010c0af0a35 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      11:832d76e6bdf2 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:13 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (13) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b  changeset:   12:86b91144a6e9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x95\xa7  parent:      9:7010c0af0a35 (esc)
   \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:12 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82    summary:     (12) merge two known; one immediate right, one far left (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   11:832d76e6bdf2 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2   parent:      6:b105a072e251 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      10:74c64d036d72 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:11 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (11) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b  changeset:   10:74c64d036d72 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1\xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x95\xa7  parent:      6:b105a072e251 (esc)
   \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:10 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82    summary:     (10) merge two known; one immediate left, one near right (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82  changeset:   9:7010c0af0a35 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      7:b632bb1b1224 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      8:7a0b11f71937 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:09 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (9) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82  changeset:   8:7a0b11f71937 (esc)
   \xe2\x94\x82\xe2\x95\xb1\xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x95\xa7 \xe2\x94\x82  parent:      7:b632bb1b1224 (esc)
   \xe2\x94\x82   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82   \xe2\x94\x82  date:        Thu Jan 01 00:00:08 1970 +0000 (esc)
   \xe2\x94\x82   \xe2\x94\x82  summary:     (8) merge two known; one immediate left, one far right (esc)
   \xe2\x94\x82  \xe2\x95\xb1 (esc)
   \xe2\x97\x8b \xe2\x94\x82  changeset:   7:b632bb1b1224 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      2:3d9a33b8d1e1 (esc)
   \xe2\x94\x82 \xe2\x95\xa7 \xe2\x94\x82  parent:      5:4409d547b708 (esc)
   \xe2\x94\x82   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82   \xe2\x94\x82  date:        Thu Jan 01 00:00:07 1970 +0000 (esc)
   \xe2\x94\x82   \xe2\x94\x82  summary:     (7) expand (esc)
   \xe2\x94\x82  \xe2\x95\xb1 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   6:b105a072e251 (esc)
   \xe2\x94\x82\xe2\x95\xb1\xe2\x94\x82  parent:      2:3d9a33b8d1e1 (esc)
   \xe2\x94\x82 \xe2\x95\xa7  parent:      5:4409d547b708 (esc)
   \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82    date:        Thu Jan 01 00:00:06 1970 +0000 (esc)
   \xe2\x94\x82    summary:     (6) merge two known; one immediate left, one far left (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   5:4409d547b708 (esc)
   \xe2\x94\x82\xe2\x95\xb2   parent:      3:27eef8ed80b4 (esc)
   \xe2\x94\x82 \xe2\x95\xa7  parent:      4:26a8bac39d9f (esc)
   \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82    date:        Thu Jan 01 00:00:05 1970 +0000 (esc)
   \xe2\x94\x82    summary:     (5) expand (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   4:26a8bac39d9f (esc)
   \xe2\x94\x82\xe2\x95\xb2   parent:      1:6db2ef61d156 (esc)
   \xe2\x95\xa7 \xe2\x95\xa7  parent:      3:27eef8ed80b4 (esc)
        user:        test
        date:        Thu Jan 01 00:00:04 1970 +0000
        summary:     (4) merge two known; one immediate left, one immediate right
   
 
 Empty revision range - display nothing:
   $ hg log -G -r 1..0
 
   $ cd ..
 
 #if no-outer-repo
 
 From outer space:
   $ hg log -G -l1 repo
   \xe2\x97\x8d  changeset:   34:fea3ac5810e0 (esc)
   \xe2\x94\x82  tag:         tip (esc)
   \xe2\x95\xa7  parent:      32:d06dffa21a31 (esc)
      user:        test
      date:        Thu Jan 01 00:00:34 1970 +0000
      summary:     (34) head
   
   $ hg log -G -l1 repo/a
   \xe2\x97\x8d  changeset:   34:fea3ac5810e0 (esc)
   \xe2\x94\x82  tag:         tip (esc)
   \xe2\x95\xa7  parent:      32:d06dffa21a31 (esc)
      user:        test
      date:        Thu Jan 01 00:00:34 1970 +0000
      summary:     (34) head
   
   $ hg log -G -l1 repo/missing
 
 #endif
 
 File log with revs != cset revs:
   $ hg init flog
   $ cd flog
   $ echo one >one
   $ hg add one
   $ hg commit -mone
   $ echo two >two
   $ hg add two
   $ hg commit -mtwo
   $ echo more >two
   $ hg commit -mmore
   $ hg log -G two
   \xe2\x97\x8d  changeset:   2:12c28321755b (esc)
   \xe2\x94\x82  tag:         tip (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82  date:        Thu Jan 01 00:00:00 1970 +0000 (esc)
   \xe2\x94\x82  summary:     more (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   1:5ac72c0599bf (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x95\xa7  date:        Thu Jan 01 00:00:00 1970 +0000 (esc)
      summary:     two
   
 
 Issue1896: File log with explicit style
   $ hg log -G --style=default one
   \xe2\x97\x8b  changeset:   0:3d578b4a1f53 (esc)
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     one
   
 Issue2395: glog --style header and footer
   $ hg log -G --style=xml one
   <?xml version="1.0"?>
   <log>
   \xe2\x97\x8b  <logentry revision="0" node="3d578b4a1f537d5fcf7301bfa9c0b97adfaa6fb1"> (esc)
      <author email="test">test</author>
      <date>1970-01-01T00:00:00+00:00</date>
      <msg xml:space="preserve">one</msg>
      </logentry>
   </log>
 
   $ cd ..
 
 Incoming and outgoing:
 
   $ hg clone -U -r31 repo repo2
   adding changesets
   adding manifests
   adding file changes
   added 31 changesets with 31 changes to 1 files
   new changesets e6eb3150255d:621d83e11f67
   $ cd repo2
 
   $ hg incoming --graph ../repo
   comparing with ../repo
   searching for changes
   \xe2\x97\x8b  changeset:   34:fea3ac5810e0 (esc)
   \xe2\x94\x82  tag:         tip (esc)
   \xe2\x94\x82  parent:      32:d06dffa21a31 (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82  date:        Thu Jan 01 00:00:34 1970 +0000 (esc)
   \xe2\x94\x82  summary:     (34) head (esc)
   \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   33:68608f5145f9 (esc)
   \xe2\x94\x82    parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82    date:        Thu Jan 01 00:00:33 1970 +0000 (esc)
   \xe2\x94\x82    summary:     (33) head (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   32:d06dffa21a31 (esc)
   \xe2\x94\x82  parent:      27:886ed638191b (esc)
   \xe2\x94\x82  parent:      31:621d83e11f67 (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82  date:        Thu Jan 01 00:00:32 1970 +0000 (esc)
   \xe2\x94\x82  summary:     (32) expand (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   27:886ed638191b (esc)
      parent:      21:d42a756af44d
      user:        test
      date:        Thu Jan 01 00:00:27 1970 +0000
      summary:     (27) collapse
   
   $ cd ..
 
   $ hg -R repo outgoing --graph repo2
   comparing with repo2
   searching for changes
   \xe2\x97\x8d  changeset:   34:fea3ac5810e0 (esc)
   \xe2\x94\x82  tag:         tip (esc)
   \xe2\x94\x82  parent:      32:d06dffa21a31 (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82  date:        Thu Jan 01 00:00:34 1970 +0000 (esc)
   \xe2\x94\x82  summary:     (34) head (esc)
   \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   33:68608f5145f9 (esc)
   \xe2\x94\x82    parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82    date:        Thu Jan 01 00:00:33 1970 +0000 (esc)
   \xe2\x94\x82    summary:     (33) head (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   32:d06dffa21a31 (esc)
   \xe2\x94\x82  parent:      27:886ed638191b (esc)
   \xe2\x94\x82  parent:      31:621d83e11f67 (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82  date:        Thu Jan 01 00:00:32 1970 +0000 (esc)
   \xe2\x94\x82  summary:     (32) expand (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   27:886ed638191b (esc)
      parent:      21:d42a756af44d
      user:        test
      date:        Thu Jan 01 00:00:27 1970 +0000
      summary:     (27) collapse
   
 
 File + limit with revs != cset revs:
   $ cd repo
   $ touch b
   $ hg ci -Aqm0
   $ hg log -G -l2 a
   \xe2\x97\x8b  changeset:   34:fea3ac5810e0 (esc)
   \xe2\x94\x82  parent:      32:d06dffa21a31 (esc)
   \xe2\x95\xa7  user:        test (esc)
      date:        Thu Jan 01 00:00:34 1970 +0000
      summary:     (34) head
   
   \xe2\x97\x8b  changeset:   33:68608f5145f9 (esc)
   \xe2\x94\x82  parent:      18:1aa84d96232a (esc)
   \xe2\x95\xa7  user:        test (esc)
      date:        Thu Jan 01 00:00:33 1970 +0000
      summary:     (33) head
   
 
 File + limit + -ra:b, (b - a) < limit:
   $ hg log -G -l3000 -r32:tip a
   \xe2\x97\x8b  changeset:   34:fea3ac5810e0 (esc)
   \xe2\x94\x82  parent:      32:d06dffa21a31 (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82  date:        Thu Jan 01 00:00:34 1970 +0000 (esc)
   \xe2\x94\x82  summary:     (34) head (esc)
   \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   33:68608f5145f9 (esc)
   \xe2\x94\x82 \xe2\x94\x82  parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x95\xa7  user:        test (esc)
   \xe2\x94\x82    date:        Thu Jan 01 00:00:33 1970 +0000 (esc)
   \xe2\x94\x82    summary:     (33) head (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   32:d06dffa21a31 (esc)
   \xe2\x94\x82\xe2\x95\xb2   parent:      27:886ed638191b (esc)
   \xe2\x95\xa7 \xe2\x95\xa7  parent:      31:621d83e11f67 (esc)
        user:        test
        date:        Thu Jan 01 00:00:32 1970 +0000
        summary:     (32) expand
   
 
 Point out a common and an uncommon unshown parent
 
   $ hg log -G -r 'rev(8) or rev(9)'
   \xe2\x97\x8b  changeset:   9:7010c0af0a35 (esc)
   \xe2\x94\x82\xe2\x95\xb2   parent:      7:b632bb1b1224 (esc)
   \xe2\x94\x82 \xe2\x95\xa7  parent:      8:7a0b11f71937 (esc)
   \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82    date:        Thu Jan 01 00:00:09 1970 +0000 (esc)
   \xe2\x94\x82    summary:     (9) expand (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   8:7a0b11f71937 (esc)
   \xe2\x94\x82\xe2\x95\xb2   parent:      0:e6eb3150255d (esc)
   \xe2\x95\xa7 \xe2\x95\xa7  parent:      7:b632bb1b1224 (esc)
        user:        test
        date:        Thu Jan 01 00:00:08 1970 +0000
        summary:     (8) merge two known; one immediate left, one far right
   
 
 File + limit + -ra:b, b < tip:
 
   $ hg log -G -l1 -r32:34 a
   \xe2\x97\x8b  changeset:   34:fea3ac5810e0 (esc)
   \xe2\x94\x82  parent:      32:d06dffa21a31 (esc)
   \xe2\x95\xa7  user:        test (esc)
      date:        Thu Jan 01 00:00:34 1970 +0000
      summary:     (34) head
   
 
 file(File) + limit + -ra:b, b < tip:
 
   $ hg log -G -l1 -r32:34 -r 'file("a")'
   \xe2\x97\x8b  changeset:   34:fea3ac5810e0 (esc)
   \xe2\x94\x82  parent:      32:d06dffa21a31 (esc)
   \xe2\x95\xa7  user:        test (esc)
      date:        Thu Jan 01 00:00:34 1970 +0000
      summary:     (34) head
   
 
 limit(file(File) and a::b), b < tip:
 
   $ hg log -G -r 'limit(file("a") and 32::34, 1)'
   \xe2\x97\x8b  changeset:   32:d06dffa21a31 (esc)
   \xe2\x94\x82\xe2\x95\xb2   parent:      27:886ed638191b (esc)
   \xe2\x95\xa7 \xe2\x95\xa7  parent:      31:621d83e11f67 (esc)
        user:        test
        date:        Thu Jan 01 00:00:32 1970 +0000
        summary:     (32) expand
   
 
 File + limit + -ra:b, b < tip:
 
   $ hg log -G -r 'limit(file("a") and 34::32, 1)'
 
 File + limit + -ra:b, b < tip, (b - a) < limit:
 
   $ hg log -G -l10 -r33:34 a
   \xe2\x97\x8b  changeset:   34:fea3ac5810e0 (esc)
   \xe2\x94\x82  parent:      32:d06dffa21a31 (esc)
   \xe2\x95\xa7  user:        test (esc)
      date:        Thu Jan 01 00:00:34 1970 +0000
      summary:     (34) head
   
   \xe2\x97\x8b  changeset:   33:68608f5145f9 (esc)
   \xe2\x94\x82  parent:      18:1aa84d96232a (esc)
   \xe2\x95\xa7  user:        test (esc)
      date:        Thu Jan 01 00:00:33 1970 +0000
      summary:     (33) head
   
 
 Do not crash or produce strange graphs if history is buggy
 
   $ hg branch branch
   marked working directory as branch branch
   (branches are permanent and global, did you want a bookmark?)
   $ commit 36 "buggy merge: identical parents" 35 35
   $ hg log -G -l5
   \xe2\x97\x8d  changeset:   36:08a19a744424 (esc)
   \xe2\x94\x82  branch:      branch (esc)
   \xe2\x94\x82  tag:         tip (esc)
   \xe2\x94\x82  parent:      35:9159c3644c5e (esc)
   \xe2\x94\x82  parent:      35:9159c3644c5e (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82  date:        Thu Jan 01 00:00:36 1970 +0000 (esc)
   \xe2\x94\x82  summary:     (36) buggy merge: identical parents (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   35:9159c3644c5e (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82  date:        Thu Jan 01 00:00:00 1970 +0000 (esc)
   \xe2\x94\x82  summary:     0 (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   34:fea3ac5810e0 (esc)
   \xe2\x94\x82  parent:      32:d06dffa21a31 (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82  date:        Thu Jan 01 00:00:34 1970 +0000 (esc)
   \xe2\x94\x82  summary:     (34) head (esc)
   \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   33:68608f5145f9 (esc)
   \xe2\x94\x82 \xe2\x94\x82  parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x95\xa7  user:        test (esc)
   \xe2\x94\x82    date:        Thu Jan 01 00:00:33 1970 +0000 (esc)
   \xe2\x94\x82    summary:     (33) head (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   32:d06dffa21a31 (esc)
   \xe2\x94\x82\xe2\x95\xb2   parent:      27:886ed638191b (esc)
   \xe2\x95\xa7 \xe2\x95\xa7  parent:      31:621d83e11f67 (esc)
        user:        test
        date:        Thu Jan 01 00:00:32 1970 +0000
        summary:     (32) expand
   
 
 Test log -G options
 
   $ testlog() {
   >   hg log -G --print-revset "$@"
   >   hg log --template 'nodetag {rev}\n' "$@" | grep nodetag \
   >     | sed 's/.*nodetag/nodetag/' > log.nodes
   >   hg log -G --template 'nodetag {rev}\n' "$@" | grep nodetag \
   >     | sed 's/.*nodetag/nodetag/' > glog.nodes
   >   (cmp log.nodes glog.nodes || diff -u log.nodes glog.nodes) \
   >     | grep '^[-+@ ]' || :
   > }
 
 glog always reorders nodes which explains the difference with log
 
   $ testlog -r 27 -r 25 -r 21 -r 34 -r 32 -r 31
   ['27', '25', '21', '34', '32', '31']
   []
   <baseset- [21, 25, 27, 31, 32, 34]>
   --- log.nodes	* (glob)
   +++ glog.nodes	* (glob)
   @@ -1,6 +1,6 @@
   -nodetag 27
   -nodetag 25
   -nodetag 21
    nodetag 34
    nodetag 32
    nodetag 31
   +nodetag 27
   +nodetag 25
   +nodetag 21
   $ testlog -u test -u not-a-user
   []
   (or
     (list
       (func
         (symbol 'user')
         (string 'test'))
       (func
         (symbol 'user')
         (string 'not-a-user'))))
   <filteredset
     <spanset- 0:37>,
     <addset
       <filteredset
         <fullreposet+ 0:37>,
         <user 'test'>>,
       <filteredset
         <fullreposet+ 0:37>,
         <user 'not-a-user'>>>>
   $ testlog -b not-a-branch
   abort: unknown revision 'not-a-branch'!
   abort: unknown revision 'not-a-branch'!
   abort: unknown revision 'not-a-branch'!
   $ testlog -b 35 -b 36 --only-branch branch
   []
   (or
     (list
       (func
         (symbol 'branch')
         (string 'default'))
       (or
         (list
           (func
             (symbol 'branch')
             (string 'branch'))
           (func
             (symbol 'branch')
             (string 'branch'))))))
   <filteredset
     <spanset- 0:37>,
     <addset
       <filteredset
         <fullreposet+ 0:37>,
         <branch 'default'>>,
       <addset
         <filteredset
           <fullreposet+ 0:37>,
           <branch 'branch'>>,
         <filteredset
           <fullreposet+ 0:37>,
           <branch 'branch'>>>>>
   $ testlog -k expand -k merge
   []
   (or
     (list
       (func
         (symbol 'keyword')
         (string 'expand'))
       (func
         (symbol 'keyword')
         (string 'merge'))))
   <filteredset
     <spanset- 0:37>,
     <addset
       <filteredset
         <fullreposet+ 0:37>,
         <keyword 'expand'>>,
       <filteredset
         <fullreposet+ 0:37>,
         <keyword 'merge'>>>>
   $ testlog --only-merges
   []
   (func
     (symbol 'merge')
     None)
   <filteredset
     <spanset- 0:37>,
     <merge>>
   $ testlog --no-merges
   []
   (not
     (func
       (symbol 'merge')
       None))
   <filteredset
     <spanset- 0:37>,
     <not
       <filteredset
         <spanset- 0:37>,
         <merge>>>>
   $ testlog --date '2 0 to 4 0'
   []
   (func
     (symbol 'date')
     (string '2 0 to 4 0'))
   <filteredset
     <spanset- 0:37>,
     <date '2 0 to 4 0'>>
   $ hg log -G -d 'brace ) in a date'
   hg: parse error: invalid date: 'brace ) in a date'
   [255]
   $ testlog --prune 31 --prune 32
   []
   (not
     (or
       (list
         (func
           (symbol 'ancestors')
           (string '31'))
         (func
           (symbol 'ancestors')
           (string '32')))))
   <filteredset
     <spanset- 0:37>,
     <not
       <addset
         <filteredset
           <spanset- 0:37>,
           <generatorsetdesc+>>,
         <filteredset
           <spanset- 0:37>,
           <generatorsetdesc+>>>>>
 
 Dedicated repo for --follow and paths filtering. The g is crafted to
 have 2 filelog topological heads in a linear changeset graph.
 
   $ cd ..
   $ hg init follow
   $ cd follow
   $ testlog --follow
   []
   []
   <baseset []>
   $ testlog -rnull
   ['null']
   []
   <baseset [-1]>
   $ echo a > a
   $ echo aa > aa
   $ echo f > f
   $ hg ci -Am "add a" a aa f
   $ hg cp a b
   $ hg cp f g
   $ hg ci -m "copy a b"
   $ mkdir dir
   $ hg mv b dir
   $ echo g >> g
   $ echo f >> f
   $ hg ci -m "mv b dir/b"
   $ hg mv a b
   $ hg cp -f f g
   $ echo a > d
   $ hg add d
   $ hg ci -m "mv a b; add d"
   $ hg mv dir/b e
   $ hg ci -m "mv dir/b e"
   $ hg log -G --template '({rev}) {desc|firstline}\n'
   \xe2\x97\x8d  (4) mv dir/b e (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  (3) mv a b; add d (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  (2) mv b dir/b (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  (1) copy a b (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  (0) add a (esc)
   
 
   $ testlog a
   []
   (func
     (symbol 'filelog')
     (string 'a'))
   <filteredset
     <spanset- 0:5>, set([0])>
   $ testlog a b
   []
   (or
     (list
       (func
         (symbol 'filelog')
         (string 'a'))
       (func
         (symbol 'filelog')
         (string 'b'))))
   <filteredset
     <spanset- 0:5>,
     <addset
       <baseset+ [0]>,
       <baseset+ [1]>>>
 
 Test falling back to slow path for non-existing files
 
   $ testlog a c
   []
   (func
     (symbol '_matchfiles')
     (list
       (string 'r:')
       (string 'd:relpath')
       (string 'p:a')
       (string 'p:c')))
   <filteredset
     <spanset- 0:5>,
     <matchfiles patterns=['a', 'c'], include=[] exclude=[], default='relpath', rev=2147483647>>
 
 Test multiple --include/--exclude/paths
 
   $ testlog --include a --include e --exclude b --exclude e a e
   []
   (func
     (symbol '_matchfiles')
     (list
       (string 'r:')
       (string 'd:relpath')
       (string 'p:a')
       (string 'p:e')
       (string 'i:a')
       (string 'i:e')
       (string 'x:b')
       (string 'x:e')))
   <filteredset
     <spanset- 0:5>,
     <matchfiles patterns=['a', 'e'], include=['a', 'e'] exclude=['b', 'e'], default='relpath', rev=2147483647>>
 
 Test glob expansion of pats
 
   $ expandglobs=`$PYTHON -c "import mercurial.util; \
   >   print(mercurial.util.expandglobs and 'true' or 'false')"`
   $ if [ $expandglobs = "true" ]; then
   >    testlog 'a*';
   > else
   >    testlog a*;
   > fi;
   []
   (func
     (symbol 'filelog')
     (string 'aa'))
   <filteredset
     <spanset- 0:5>, set([0])>
 
 Test --follow on a non-existent directory
 
   $ testlog -f dir
   abort: cannot follow file not in parent revision: "dir"
   abort: cannot follow file not in parent revision: "dir"
   abort: cannot follow file not in parent revision: "dir"
 
 Test --follow on a directory
 
   $ hg up -q '.^'
   $ testlog -f dir
   []
   (func
     (symbol '_matchfiles')
     (list
       (string 'r:')
       (string 'd:relpath')
       (string 'p:dir')))
   <filteredset
     <generatorsetdesc->,
     <matchfiles patterns=['dir'], include=[] exclude=[], default='relpath', rev=2147483647>>
   $ hg up -q tip
 
 Test --follow on file not in parent revision
 
   $ testlog -f a
   abort: cannot follow file not in parent revision: "a"
   abort: cannot follow file not in parent revision: "a"
   abort: cannot follow file not in parent revision: "a"
 
 Test --follow and patterns
 
   $ testlog -f 'glob:*'
   []
   (func
     (symbol '_matchfiles')
     (list
       (string 'r:')
       (string 'd:relpath')
       (string 'p:glob:*')))
   <filteredset
     <generatorsetdesc->,
     <matchfiles patterns=['glob:*'], include=[] exclude=[], default='relpath', rev=2147483647>>
 
 Test --follow on a single rename
 
   $ hg up -q 2
   $ testlog -f a
   []
   []
   <generatorsetdesc->
 
 Test --follow and multiple renames
 
   $ hg up -q tip
   $ testlog -f e
   []
   []
   <generatorsetdesc->
 
 Test --follow and multiple filelog heads
 
   $ hg up -q 2
   $ testlog -f g
   []
   []
   <generatorsetdesc->
   $ cat log.nodes
   nodetag 2
   nodetag 1
   nodetag 0
   $ hg up -q tip
   $ testlog -f g
   []
   []
   <generatorsetdesc->
   $ cat log.nodes
   nodetag 3
   nodetag 2
   nodetag 0
 
 Test --follow and multiple files
 
   $ testlog -f g e
   []
   []
   <generatorsetdesc->
   $ cat log.nodes
   nodetag 4
   nodetag 3
   nodetag 2
   nodetag 1
   nodetag 0
 
 Test --follow null parent
 
   $ hg up -q null
   $ testlog -f
   []
   []
   <baseset []>
 
 Test --follow-first
 
   $ hg up -q 3
   $ echo ee > e
   $ hg ci -Am "add another e" e
   created new head
   $ hg merge --tool internal:other 4
   0 files updated, 1 files merged, 1 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ echo merge > e
   $ hg ci -m "merge 5 and 4"
   $ testlog --follow-first
   []
   []
   <generatorsetdesc->
 
 Cannot compare with log --follow-first FILE as it never worked
 
   $ hg log -G --print-revset --follow-first e
   []
   []
   <generatorsetdesc->
   $ hg log -G --follow-first e --template '{rev} {desc|firstline}\n'
   \xe2\x97\x8d  6 merge 5 and 4 (esc)
   \xe2\x94\x82\xe2\x95\xb2 (esc)
   \xe2\x94\x82 \xe2\x95\xa7 (esc)
   \xe2\x97\x8b  5 add another e (esc)
   \xe2\x94\x82 (esc)
   \xe2\x95\xa7 (esc)
 
 Test --copies
 
   $ hg log -G --copies --template "{rev} {desc|firstline} \
   >   copies: {file_copies_switch}\n"
   \xe2\x97\x8d  6 merge 5 and 4   copies: (esc)
   \xe2\x94\x82\xe2\x95\xb2 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  5 add another e   copies: (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82  4 mv dir/b e   copies: e (dir/b) (esc)
   \xe2\x94\x82\xe2\x95\xb1 (esc)
   \xe2\x97\x8b  3 mv a b; add d   copies: b (a)g (f) (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  2 mv b dir/b   copies: dir/b (b) (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  1 copy a b   copies: b (a)g (f) (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  0 add a   copies: (esc)
   
 Test "set:..." and parent revision
 
   $ hg up -q 4
   $ testlog "set:copied()"
   []
   (func
-    (symbol 'filelog')
-    (string 'set:copied()'))
+    (symbol '_matchfiles')
+    (list
+      (string 'r:')
+      (string 'd:relpath')
+      (string 'p:set:copied()')))
   <filteredset
-    <spanset- 0:7>, set([])>
+    <spanset- 0:7>,
+    <matchfiles patterns=['set:copied()'], include=[] exclude=[], default='relpath', rev=2147483647>>
   $ testlog --include "set:copied()"
   []
-  []
-  <spanset- 0:7>
+  (func
+    (symbol '_matchfiles')
+    (list
+      (string 'r:')
+      (string 'd:relpath')
+      (string 'i:set:copied()')))
+  <filteredset
+    <spanset- 0:7>,
+    <matchfiles patterns=[], include=['set:copied()'] exclude=[], default='relpath', rev=2147483647>>
   $ testlog -r "sort(file('set:copied()'), -rev)"
   ["sort(file('set:copied()'), -rev)"]
   []
   <filteredset
     <fullreposet- 0:7>,
     <matchfiles patterns=['set:copied()'], include=[] exclude=[], default='glob', rev=None>>
 
 Test --removed
 
   $ testlog --removed
   []
   []
   <spanset- 0:7>
   $ testlog --removed a
   []
   (func
     (symbol '_matchfiles')
     (list
       (string 'r:')
       (string 'd:relpath')
       (string 'p:a')))
   <filteredset
     <spanset- 0:7>,
     <matchfiles patterns=['a'], include=[] exclude=[], default='relpath', rev=2147483647>>
   $ testlog --removed --follow a
   []
   (func
     (symbol '_matchfiles')
     (list
       (string 'r:')
       (string 'd:relpath')
       (string 'p:a')))
   <filteredset
     <generatorsetdesc->,
     <matchfiles patterns=['a'], include=[] exclude=[], default='relpath', rev=2147483647>>
 
 Test --patch and --stat with --follow and --follow-first
 
   $ hg up -q 3
   $ hg log -G --git --patch b
   \xe2\x97\x8b  changeset:   1:216d4c92cf98 (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x95\xa7  date:        Thu Jan 01 00:00:00 1970 +0000 (esc)
      summary:     copy a b
   
      diff --git a/a b/b
      copy from a
      copy to b
   
 
   $ hg log -G --git --stat b
   \xe2\x97\x8b  changeset:   1:216d4c92cf98 (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x95\xa7  date:        Thu Jan 01 00:00:00 1970 +0000 (esc)
      summary:     copy a b
   
       b |  0
       1 files changed, 0 insertions(+), 0 deletions(-)
   
 
   $ hg log -G --git --patch --follow b
   \xe2\x97\x8b  changeset:   1:216d4c92cf98 (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82  date:        Thu Jan 01 00:00:00 1970 +0000 (esc)
   \xe2\x94\x82  summary:     copy a b (esc)
   \xe2\x94\x82 (esc)
   \xe2\x94\x82  diff --git a/a b/b (esc)
   \xe2\x94\x82  copy from a (esc)
   \xe2\x94\x82  copy to b (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   0:f8035bb17114 (esc)
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     add a
   
      diff --git a/a b/a
      new file mode 100644
      --- /dev/null
      +++ b/a
      @@ -0,0 +1,1 @@
      +a
   
 
   $ hg log -G --git --stat --follow b
   \xe2\x97\x8b  changeset:   1:216d4c92cf98 (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82  date:        Thu Jan 01 00:00:00 1970 +0000 (esc)
   \xe2\x94\x82  summary:     copy a b (esc)
   \xe2\x94\x82 (esc)
   \xe2\x94\x82   b |  0 (esc)
   \xe2\x94\x82   1 files changed, 0 insertions(+), 0 deletions(-) (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   0:f8035bb17114 (esc)
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     add a
   
       a |  1 +
       1 files changed, 1 insertions(+), 0 deletions(-)
   
 
   $ hg up -q 6
   $ hg log -G --git --patch --follow-first e
   \xe2\x97\x8d  changeset:   6:fc281d8ff18d (esc)
   \xe2\x94\x82\xe2\x95\xb2   tag:         tip (esc)
   \xe2\x94\x82 \xe2\x95\xa7  parent:      5:99b31f1c2782 (esc)
   \xe2\x94\x82    parent:      4:17d952250a9d (esc)
   \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82    date:        Thu Jan 01 00:00:00 1970 +0000 (esc)
   \xe2\x94\x82    summary:     merge 5 and 4 (esc)
   \xe2\x94\x82 (esc)
   \xe2\x94\x82    diff --git a/e b/e (esc)
   \xe2\x94\x82    --- a/e (esc)
   \xe2\x94\x82    +++ b/e (esc)
   \xe2\x94\x82    @@ -1,1 +1,1 @@ (esc)
   \xe2\x94\x82    -ee (esc)
   \xe2\x94\x82    +merge (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   5:99b31f1c2782 (esc)
   \xe2\x94\x82  parent:      3:5918b8d165d1 (esc)
   \xe2\x95\xa7  user:        test (esc)
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     add another e
   
      diff --git a/e b/e
      new file mode 100644
      --- /dev/null
      +++ b/e
      @@ -0,0 +1,1 @@
      +ee
   
 
 Test old-style --rev
 
   $ hg tag 'foo-bar'
   $ testlog -r 'foo-bar'
   ['foo-bar']
   []
   <baseset [6]>
 
 Test --follow and forward --rev
 
   $ hg up -q 6
   $ echo g > g
   $ hg ci -Am 'add g' g
   created new head
   $ hg up -q 2
   $ hg log -G --template "{rev} {desc|firstline}\n"
   \xe2\x97\x8b  8 add g (esc)
   \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  7 Added tag foo-bar for changeset fc281d8ff18d (esc)
   \xe2\x94\x82\xe2\x95\xb1 (esc)
   \xe2\x97\x8b  6 merge 5 and 4 (esc)
   \xe2\x94\x82\xe2\x95\xb2 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  5 add another e (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82  4 mv dir/b e (esc)
   \xe2\x94\x82\xe2\x95\xb1 (esc)
   \xe2\x97\x8b  3 mv a b; add d (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8d  2 mv b dir/b (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  1 copy a b (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  0 add a (esc)
   
   $ hg archive -r 7 archive
   $ grep changessincelatesttag archive/.hg_archival.txt
   changessincelatesttag: 1
   $ rm -r archive
 
 changessincelatesttag with no prior tag
   $ hg archive -r 4 archive
   $ grep changessincelatesttag archive/.hg_archival.txt
   changessincelatesttag: 5
 
   $ hg export 'all()'
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID f8035bb17114da16215af3436ec5222428ace8ee
   # Parent  0000000000000000000000000000000000000000
   add a
   
   diff -r 000000000000 -r f8035bb17114 a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r 000000000000 -r f8035bb17114 aa
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/aa	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +aa
   diff -r 000000000000 -r f8035bb17114 f
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/f	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +f
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID 216d4c92cf98ff2b4641d508b76b529f3d424c92
   # Parent  f8035bb17114da16215af3436ec5222428ace8ee
   copy a b
   
   diff -r f8035bb17114 -r 216d4c92cf98 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r f8035bb17114 -r 216d4c92cf98 g
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/g	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +f
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID bb573313a9e8349099b6ea2b2fb1fc7f424446f3
   # Parent  216d4c92cf98ff2b4641d508b76b529f3d424c92
   mv b dir/b
   
   diff -r 216d4c92cf98 -r bb573313a9e8 b
   --- a/b	Thu Jan 01 00:00:00 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -a
   diff -r 216d4c92cf98 -r bb573313a9e8 dir/b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/dir/b	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r 216d4c92cf98 -r bb573313a9e8 f
   --- a/f	Thu Jan 01 00:00:00 1970 +0000
   +++ b/f	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,2 @@
    f
   +f
   diff -r 216d4c92cf98 -r bb573313a9e8 g
   --- a/g	Thu Jan 01 00:00:00 1970 +0000
   +++ b/g	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,2 @@
    f
   +g
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID 5918b8d165d1364e78a66d02e66caa0133c5d1ed
   # Parent  bb573313a9e8349099b6ea2b2fb1fc7f424446f3
   mv a b; add d
   
   diff -r bb573313a9e8 -r 5918b8d165d1 a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -a
   diff -r bb573313a9e8 -r 5918b8d165d1 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r bb573313a9e8 -r 5918b8d165d1 d
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/d	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r bb573313a9e8 -r 5918b8d165d1 g
   --- a/g	Thu Jan 01 00:00:00 1970 +0000
   +++ b/g	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,2 +1,2 @@
    f
   -g
   +f
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID 17d952250a9d03cc3dc77b199ab60e959b9b0260
   # Parent  5918b8d165d1364e78a66d02e66caa0133c5d1ed
   mv dir/b e
   
   diff -r 5918b8d165d1 -r 17d952250a9d dir/b
   --- a/dir/b	Thu Jan 01 00:00:00 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -a
   diff -r 5918b8d165d1 -r 17d952250a9d e
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/e	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID 99b31f1c2782e2deb1723cef08930f70fc84b37b
   # Parent  5918b8d165d1364e78a66d02e66caa0133c5d1ed
   add another e
   
   diff -r 5918b8d165d1 -r 99b31f1c2782 e
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/e	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +ee
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID fc281d8ff18d999ad6497b3d27390bcd695dcc73
   # Parent  99b31f1c2782e2deb1723cef08930f70fc84b37b
   # Parent  17d952250a9d03cc3dc77b199ab60e959b9b0260
   merge 5 and 4
   
   diff -r 99b31f1c2782 -r fc281d8ff18d dir/b
   --- a/dir/b	Thu Jan 01 00:00:00 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -a
   diff -r 99b31f1c2782 -r fc281d8ff18d e
   --- a/e	Thu Jan 01 00:00:00 1970 +0000
   +++ b/e	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -ee
   +merge
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID 02dbb8e276b8ab7abfd07cab50c901647e75c2dd
   # Parent  fc281d8ff18d999ad6497b3d27390bcd695dcc73
   Added tag foo-bar for changeset fc281d8ff18d
   
   diff -r fc281d8ff18d -r 02dbb8e276b8 .hgtags
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hgtags	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +fc281d8ff18d999ad6497b3d27390bcd695dcc73 foo-bar
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID 24c2e826ddebf80f9dcd60b856bdb8e6715c5449
   # Parent  fc281d8ff18d999ad6497b3d27390bcd695dcc73
   add g
   
   diff -r fc281d8ff18d -r 24c2e826ddeb g
   --- a/g	Thu Jan 01 00:00:00 1970 +0000
   +++ b/g	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,2 +1,1 @@
   -f
   -f
   +g
   $ testlog --follow -r6 -r8 -r5 -r7 -r4
   ['6', '8', '5', '7', '4']
   []
   <generatorsetdesc->
 
 Test --follow-first and forward --rev
 
   $ testlog --follow-first -r6 -r8 -r5 -r7 -r4
   ['6', '8', '5', '7', '4']
   []
   <generatorsetdesc->
 
 Test --follow and backward --rev
 
   $ testlog --follow -r6 -r5 -r7 -r8 -r4
   ['6', '5', '7', '8', '4']
   []
   <generatorsetdesc->
 
 Test --follow-first and backward --rev
 
   $ testlog --follow-first -r6 -r5 -r7 -r8 -r4
   ['6', '5', '7', '8', '4']
   []
   <generatorsetdesc->
 
 Test --follow with --rev of graphlog extension
 
   $ hg --config extensions.graphlog= glog -qfr1
   \xe2\x97\x8b  1:216d4c92cf98 (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  0:f8035bb17114 (esc)
   
 
 Test subdir
 
   $ hg up -q 3
   $ cd dir
   $ testlog .
   []
   (func
     (symbol '_matchfiles')
     (list
       (string 'r:')
       (string 'd:relpath')
       (string 'p:.')))
   <filteredset
     <spanset- 0:9>,
     <matchfiles patterns=['.'], include=[] exclude=[], default='relpath', rev=2147483647>>
   $ testlog ../b
   []
   (func
     (symbol 'filelog')
     (string '../b'))
   <filteredset
     <spanset- 0:9>, set([1])>
   $ testlog -f ../b
   []
   []
   <generatorsetdesc->
   $ cd ..
 
 Test --hidden
  (enable obsolete)
 
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > evolution.createmarkers=True
   > EOF
 
   $ hg debugobsolete `hg id --debug -i -r 8`
   obsoleted 1 changesets
   $ testlog
   []
   []
   <spanset- 0:9>
   $ testlog --hidden
   []
   []
   <spanset- 0:9>
   $ hg log -G --template '{rev} {desc}\n'
   \xe2\x97\x8b  7 Added tag foo-bar for changeset fc281d8ff18d (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  6 merge 5 and 4 (esc)
   \xe2\x94\x82\xe2\x95\xb2 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  5 add another e (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82  4 mv dir/b e (esc)
   \xe2\x94\x82\xe2\x95\xb1 (esc)
   \xe2\x97\x8d  3 mv a b; add d (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  2 mv b dir/b (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  1 copy a b (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  0 add a (esc)
   
 
 A template without trailing newline should do something sane
 
   $ hg log -G -r ::2 --template '{rev} {desc}'
   \xe2\x97\x8b  2 mv b dir/b (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  1 copy a b (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  0 add a (esc)
   
 
 Extra newlines must be preserved
 
   $ hg log -G -r ::2 --template '\n{rev} {desc}\n\n'
   \xe2\x97\x8b (esc)
   \xe2\x94\x82  2 mv b dir/b (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b (esc)
   \xe2\x94\x82  1 copy a b (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b (esc)
      0 add a
   
 
 The almost-empty template should do something sane too ...
 
   $ hg log -G -r ::2 --template '\n'
   \xe2\x97\x8b (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b (esc)
   
 
 issue3772
 
   $ hg log -G -r :null
   \xe2\x97\x8b  changeset:   0:f8035bb17114 (esc)
   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82  date:        Thu Jan 01 00:00:00 1970 +0000 (esc)
   \xe2\x94\x82  summary:     add a (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   -1:000000000000 (esc)
      user:
      date:        Thu Jan 01 00:00:00 1970 +0000
   
   $ hg log -G -r null:null
   \xe2\x97\x8b  changeset:   -1:000000000000 (esc)
      user:
      date:        Thu Jan 01 00:00:00 1970 +0000
   
 
 should not draw line down to null due to the magic of fullreposet
 
   $ hg log -G -r 'all()' | tail -6
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   0:f8035bb17114 (esc)
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     add a
   
 
   $ hg log -G -r 'branch(default)' | tail -6
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   0:f8035bb17114 (esc)
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     add a
   
 
 working-directory revision
 
   $ hg log -G -qr '. + wdir()'
   \xe2\x97\x8b  2147483647:ffffffffffff (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8d  3:5918b8d165d1 (esc)
   \xe2\x94\x82 (esc)
   \xe2\x95\xa7 (esc)
 
 node template with changesetprinter:
 
   $ hg log -Gqr 5:7 --config ui.graphnodetemplate='"{rev}"'
   7  7:02dbb8e276b8
   \xe2\x94\x82 (esc)
   6    6:fc281d8ff18d
   \xe2\x94\x82\xe2\x95\xb2 (esc)
   \xe2\x94\x82 \xe2\x95\xa7 (esc)
   5  5:99b31f1c2782
   \xe2\x94\x82 (esc)
   \xe2\x95\xa7 (esc)
 
 node template with changesettemplater (shared cache variable):
 
   $ hg log -Gr 5:7 -T '{latesttag % "{rev} {tag}+{distance}"}\n' \
   > --config ui.graphnodetemplate='{ifeq(latesttagdistance, 0, "#", graphnode)}'
   \xe2\x97\x8b  7 foo-bar+1 (esc)
   \xe2\x94\x82 (esc)
   #    6 foo-bar+0
   \xe2\x94\x82\xe2\x95\xb2 (esc)
   \xe2\x94\x82 \xe2\x95\xa7 (esc)
   \xe2\x97\x8b  5 null+5 (esc)
   \xe2\x94\x82 (esc)
   \xe2\x95\xa7 (esc)
 
 label() should just work in node template:
 
   $ hg log -Gqr 7 --config extensions.color= --color=debug \
   > --config ui.graphnodetemplate='{label("branch.{branch}", rev)}'
   [branch.default\xe2\x94\x827]  [log.node|7:02dbb8e276b8] (esc)
   \xe2\x94\x82 (esc)
   \xe2\x95\xa7 (esc)
 
   $ cd ..
 
 change graph edge styling
 
   $ cd repo
 
 Setting HGPLAIN ignores graphmod styling:
 
   $ HGPLAIN=1 hg log -G -r 'file("a")' -m
   @  changeset:   36:08a19a744424
   |  branch:      branch
   |  tag:         tip
   |  parent:      35:9159c3644c5e
   |  parent:      35:9159c3644c5e
   |  user:        test
   |  date:        Thu Jan 01 00:00:36 1970 +0000
   |  summary:     (36) buggy merge: identical parents
   |
   o    changeset:   32:d06dffa21a31
   |\   parent:      27:886ed638191b
   | |  parent:      31:621d83e11f67
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:32 1970 +0000
   | |  summary:     (32) expand
   | |
   o |  changeset:   31:621d83e11f67
   |\|  parent:      21:d42a756af44d
   | |  parent:      30:6e11cd4b648f
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:31 1970 +0000
   | |  summary:     (31) expand
   | |
   o |    changeset:   30:6e11cd4b648f
   |\ \   parent:      28:44ecd0b9ae99
   | | |  parent:      29:cd9bb2be7593
   | | |  user:        test
   | | |  date:        Thu Jan 01 00:00:30 1970 +0000
   | | |  summary:     (30) expand
   | | |
   o | |    changeset:   28:44ecd0b9ae99
   |\ \ \   parent:      1:6db2ef61d156
   | | | |  parent:      26:7f25b6c2f0b9
   | | | |  user:        test
   | | | |  date:        Thu Jan 01 00:00:28 1970 +0000
   | | | |  summary:     (28) merge zero known
   | | | |
   o | | |    changeset:   26:7f25b6c2f0b9
   |\ \ \ \   parent:      18:1aa84d96232a
   | | | | |  parent:      25:91da8ed57247
   | | | | |  user:        test
   | | | | |  date:        Thu Jan 01 00:00:26 1970 +0000
   | | | | |  summary:     (26) merge one known; far right
   | | | | |
   | o-----+  changeset:   25:91da8ed57247
   | | | | |  parent:      21:d42a756af44d
   | | | | |  parent:      24:a9c19a3d96b7
   | | | | |  user:        test
   | | | | |  date:        Thu Jan 01 00:00:25 1970 +0000
   | | | | |  summary:     (25) merge one known; far left
   | | | | |
   | o | | |    changeset:   24:a9c19a3d96b7
   | |\ \ \ \   parent:      0:e6eb3150255d
   | | | | | |  parent:      23:a01cddf0766d
   | | | | | |  user:        test
   | | | | | |  date:        Thu Jan 01 00:00:24 1970 +0000
   | | | | | |  summary:     (24) merge one known; immediate right
   | | | | | |
   | o---+ | |  changeset:   23:a01cddf0766d
   | | | | | |  parent:      1:6db2ef61d156
   | | | | | |  parent:      22:e0d9cccacb5d
   | | | | | |  user:        test
   | | | | | |  date:        Thu Jan 01 00:00:23 1970 +0000
   | | | | | |  summary:     (23) merge one known; immediate left
   | | | | | |
   | o-------+  changeset:   22:e0d9cccacb5d
   | | | | | |  parent:      18:1aa84d96232a
   |/ / / / /   parent:      21:d42a756af44d
   | | | | |    user:        test
   | | | | |    date:        Thu Jan 01 00:00:22 1970 +0000
   | | | | |    summary:     (22) merge two known; one far left, one far right
   | | | | |
   | | | | o    changeset:   21:d42a756af44d
   | | | | |\   parent:      19:31ddc2c1573b
   | | | | | |  parent:      20:d30ed6450e32
   | | | | | |  user:        test
   | | | | | |  date:        Thu Jan 01 00:00:21 1970 +0000
   | | | | | |  summary:     (21) expand
   | | | | | |
   +-+-------o  changeset:   20:d30ed6450e32
   | | | | |    parent:      0:e6eb3150255d
   | | | | |    parent:      18:1aa84d96232a
   | | | | |    user:        test
   | | | | |    date:        Thu Jan 01 00:00:20 1970 +0000
   | | | | |    summary:     (20) merge two known; two far right
   | | | | |
   | | | | o    changeset:   19:31ddc2c1573b
   | | | | |\   parent:      15:1dda3f72782d
   | | | | | |  parent:      17:44765d7c06e0
   | | | | | |  user:        test
   | | | | | |  date:        Thu Jan 01 00:00:19 1970 +0000
   | | | | | |  summary:     (19) expand
   | | | | | |
   o---+---+ |  changeset:   18:1aa84d96232a
     | | | | |  parent:      1:6db2ef61d156
    / / / / /   parent:      15:1dda3f72782d
   | | | | |    user:        test
   | | | | |    date:        Thu Jan 01 00:00:18 1970 +0000
   | | | | |    summary:     (18) merge two known; two far left
   | | | | |
   | | | | o    changeset:   17:44765d7c06e0
   | | | | |\   parent:      12:86b91144a6e9
   | | | | | |  parent:      16:3677d192927d
   | | | | | |  user:        test
   | | | | | |  date:        Thu Jan 01 00:00:17 1970 +0000
   | | | | | |  summary:     (17) expand
   | | | | | |
   +-+-------o  changeset:   16:3677d192927d
   | | | | |    parent:      0:e6eb3150255d
   | | | | |    parent:      1:6db2ef61d156
   | | | | |    user:        test
   | | | | |    date:        Thu Jan 01 00:00:16 1970 +0000
   | | | | |    summary:     (16) merge two known; one immediate right, one near right
   | | | | |
   | | | o |    changeset:   15:1dda3f72782d
   | | | |\ \   parent:      13:22d8966a97e3
   | | | | | |  parent:      14:8eac370358ef
   | | | | | |  user:        test
   | | | | | |  date:        Thu Jan 01 00:00:15 1970 +0000
   | | | | | |  summary:     (15) expand
   | | | | | |
   +-------o |  changeset:   14:8eac370358ef
   | | | | |/   parent:      0:e6eb3150255d
   | | | | |    parent:      12:86b91144a6e9
   | | | | |    user:        test
   | | | | |    date:        Thu Jan 01 00:00:14 1970 +0000
   | | | | |    summary:     (14) merge two known; one immediate right, one far right
   | | | | |
   | | | o |    changeset:   13:22d8966a97e3
   | | | |\ \   parent:      9:7010c0af0a35
   | | | | | |  parent:      11:832d76e6bdf2
   | | | | | |  user:        test
   | | | | | |  date:        Thu Jan 01 00:00:13 1970 +0000
   | | | | | |  summary:     (13) expand
   | | | | | |
   | +---+---o  changeset:   12:86b91144a6e9
   | | | | |    parent:      1:6db2ef61d156
   | | | | |    parent:      9:7010c0af0a35
   | | | | |    user:        test
   | | | | |    date:        Thu Jan 01 00:00:12 1970 +0000
   | | | | |    summary:     (12) merge two known; one immediate right, one far left
   | | | | |
   | | | | o    changeset:   11:832d76e6bdf2
   | | | | |\   parent:      6:b105a072e251
   | | | | | |  parent:      10:74c64d036d72
   | | | | | |  user:        test
   | | | | | |  date:        Thu Jan 01 00:00:11 1970 +0000
   | | | | | |  summary:     (11) expand
   | | | | | |
   +---------o  changeset:   10:74c64d036d72
   | | | | |/   parent:      0:e6eb3150255d
   | | | | |    parent:      6:b105a072e251
   | | | | |    user:        test
   | | | | |    date:        Thu Jan 01 00:00:10 1970 +0000
   | | | | |    summary:     (10) merge two known; one immediate left, one near right
   | | | | |
   | | | o |    changeset:   9:7010c0af0a35
   | | | |\ \   parent:      7:b632bb1b1224
   | | | | | |  parent:      8:7a0b11f71937
   | | | | | |  user:        test
   | | | | | |  date:        Thu Jan 01 00:00:09 1970 +0000
   | | | | | |  summary:     (9) expand
   | | | | | |
   +-------o |  changeset:   8:7a0b11f71937
   | | | |/ /   parent:      0:e6eb3150255d
   | | | | |    parent:      7:b632bb1b1224
   | | | | |    user:        test
   | | | | |    date:        Thu Jan 01 00:00:08 1970 +0000
   | | | | |    summary:     (8) merge two known; one immediate left, one far right
   | | | | |
   | | | o |    changeset:   7:b632bb1b1224
   | | | |\ \   parent:      2:3d9a33b8d1e1
   | | | | | |  parent:      5:4409d547b708
   | | | | | |  user:        test
   | | | | | |  date:        Thu Jan 01 00:00:07 1970 +0000
   | | | | | |  summary:     (7) expand
   | | | | | |
   | | | +---o  changeset:   6:b105a072e251
   | | | | |/   parent:      2:3d9a33b8d1e1
   | | | | |    parent:      5:4409d547b708
   | | | | |    user:        test
   | | | | |    date:        Thu Jan 01 00:00:06 1970 +0000
   | | | | |    summary:     (6) merge two known; one immediate left, one far left
   | | | | |
   | | | o |    changeset:   5:4409d547b708
   | | | |\ \   parent:      3:27eef8ed80b4
   | | | | | |  parent:      4:26a8bac39d9f
   | | | | | |  user:        test
   | | | | | |  date:        Thu Jan 01 00:00:05 1970 +0000
   | | | | | |  summary:     (5) expand
   | | | | | |
   | +---o | |  changeset:   4:26a8bac39d9f
   | | | |/ /   parent:      1:6db2ef61d156
   | | | | |    parent:      3:27eef8ed80b4
   | | | | |    user:        test
   | | | | |    date:        Thu Jan 01 00:00:04 1970 +0000
   | | | | |    summary:     (4) merge two known; one immediate left, one immediate right
   | | | | |
 
 .. unless HGPLAINEXCEPT=graph is set:
 
   $ HGPLAIN=1 HGPLAINEXCEPT=graph hg log -G -r 'file("a")' -m
   \xe2\x97\x8d  changeset:   36:08a19a744424 (esc)
   \xe2\x94\x86  branch:      branch (esc)
   \xe2\x94\x86  tag:         tip (esc)
   \xe2\x94\x86  parent:      35:9159c3644c5e (esc)
   \xe2\x94\x86  parent:      35:9159c3644c5e (esc)
   \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x86  date:        Thu Jan 01 00:00:36 1970 +0000 (esc)
   \xe2\x94\x86  summary:     (36) buggy merge: identical parents (esc)
   \xe2\x94\x86 (esc)
   \xe2\x97\x8b  changeset:   32:d06dffa21a31 (esc)
   \xe2\x94\x82\xe2\x95\xb2   parent:      27:886ed638191b (esc)
   \xe2\x94\x82 \xe2\x94\x86  parent:      31:621d83e11f67 (esc)
   \xe2\x94\x82 \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x86  date:        Thu Jan 01 00:00:32 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x86  summary:     (32) expand (esc)
   \xe2\x94\x82 \xe2\x94\x86 (esc)
   \xe2\x97\x8b \xe2\x94\x86  changeset:   31:621d83e11f67 (esc)
   \xe2\x94\x82\xe2\x95\xb2\xe2\x94\x86  parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x86  parent:      30:6e11cd4b648f (esc)
   \xe2\x94\x82 \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x86  date:        Thu Jan 01 00:00:31 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x86  summary:     (31) expand (esc)
   \xe2\x94\x82 \xe2\x94\x86 (esc)
   \xe2\x97\x8b \xe2\x94\x86  changeset:   30:6e11cd4b648f (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      28:44ecd0b9ae99 (esc)
   \xe2\x94\x82 \xe2\x95\xa7 \xe2\x94\x86  parent:      29:cd9bb2be7593 (esc)
   \xe2\x94\x82   \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x82   \xe2\x94\x86  date:        Thu Jan 01 00:00:30 1970 +0000 (esc)
   \xe2\x94\x82   \xe2\x94\x86  summary:     (30) expand (esc)
   \xe2\x94\x82  \xe2\x95\xb1 (esc)
   \xe2\x97\x8b \xe2\x94\x86  changeset:   28:44ecd0b9ae99 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x95\xa7 \xe2\x94\x86  parent:      26:7f25b6c2f0b9 (esc)
   \xe2\x94\x82   \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x82   \xe2\x94\x86  date:        Thu Jan 01 00:00:28 1970 +0000 (esc)
   \xe2\x94\x82   \xe2\x94\x86  summary:     (28) merge zero known (esc)
   \xe2\x94\x82  \xe2\x95\xb1 (esc)
   \xe2\x97\x8b \xe2\x94\x86  changeset:   26:7f25b6c2f0b9 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86  parent:      25:91da8ed57247 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86  date:        Thu Jan 01 00:00:26 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86  summary:     (26) merge one known; far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x86  changeset:   25:91da8ed57247 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2\xe2\x94\x86  parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86  parent:      24:a9c19a3d96b7 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86  date:        Thu Jan 01 00:00:25 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86  summary:     (25) merge one known; far left (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x86 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x86  changeset:   24:a9c19a3d96b7 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x95\xa7 \xe2\x94\x86  parent:      23:a01cddf0766d (esc)
   \xe2\x94\x82 \xe2\x94\x82   \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82   \xe2\x94\x86  date:        Thu Jan 01 00:00:24 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82   \xe2\x94\x86  summary:     (24) merge one known; immediate right (esc)
   \xe2\x94\x82 \xe2\x94\x82  \xe2\x95\xb1 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x86  changeset:   23:a01cddf0766d (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x95\xa7 \xe2\x94\x86  parent:      22:e0d9cccacb5d (esc)
   \xe2\x94\x82 \xe2\x94\x82   \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82   \xe2\x94\x86  date:        Thu Jan 01 00:00:23 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82   \xe2\x94\x86  summary:     (23) merge one known; immediate left (esc)
   \xe2\x94\x82 \xe2\x94\x82  \xe2\x95\xb1 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x86  changeset:   22:e0d9cccacb5d (esc)
   \xe2\x94\x82\xe2\x95\xb1\xe2\x94\x86\xe2\x95\xb1   parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x86    parent:      21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x86    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x86    date:        Thu Jan 01 00:00:22 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x86    summary:     (22) merge two known; one far left, one far right (esc)
   \xe2\x94\x82 \xe2\x94\x86 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   21:d42a756af44d (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2   parent:      19:31ddc2c1573b (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      20:d30ed6450e32 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:21 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (21) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b  changeset:   20:d30ed6450e32 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x95\xa7  parent:      18:1aa84d96232a (esc)
   \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:20 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82    summary:     (20) merge two known; two far right (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   19:31ddc2c1573b (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2   parent:      15:1dda3f72782d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      17:44765d7c06e0 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:19 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (19) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82 \xe2\x94\x82  changeset:   18:1aa84d96232a (esc)
   \xe2\x94\x82\xe2\x95\xb2\xe2\x94\x82 \xe2\x94\x82  parent:      1:6db2ef61d156 (esc)
   \xe2\x95\xa7 \xe2\x94\x82 \xe2\x94\x82  parent:      15:1dda3f72782d (esc)
     \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
     \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:18 1970 +0000 (esc)
     \xe2\x94\x82 \xe2\x94\x82  summary:     (18) merge two known; two far left (esc)
    \xe2\x95\xb1 \xe2\x95\xb1 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   17:44765d7c06e0 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2   parent:      12:86b91144a6e9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      16:3677d192927d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:17 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (17) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b  changeset:   16:3677d192927d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2   parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x95\xa7 \xe2\x95\xa7  parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82      user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82      date:        Thu Jan 01 00:00:16 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82      summary:     (16) merge two known; one immediate right, one near right (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82  changeset:   15:1dda3f72782d (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      13:22d8966a97e3 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      14:8eac370358ef (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:15 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (15) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82  changeset:   14:8eac370358ef (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2\xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x95\xa7 \xe2\x94\x82  parent:      12:86b91144a6e9 (esc)
   \xe2\x94\x82   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82   \xe2\x94\x82  date:        Thu Jan 01 00:00:14 1970 +0000 (esc)
   \xe2\x94\x82   \xe2\x94\x82  summary:     (14) merge two known; one immediate right, one far right (esc)
   \xe2\x94\x82  \xe2\x95\xb1 (esc)
   \xe2\x97\x8b \xe2\x94\x82  changeset:   13:22d8966a97e3 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      9:7010c0af0a35 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      11:832d76e6bdf2 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:13 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (13) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x9c\xe2\x94\x80\xe2\x94\x80\xe2\x94\x80\xe2\x97\x8b  changeset:   12:86b91144a6e9 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      1:6db2ef61d156 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x95\xa7  parent:      9:7010c0af0a35 (esc)
   \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:12 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82    summary:     (12) merge two known; one immediate right, one far left (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   11:832d76e6bdf2 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb2   parent:      6:b105a072e251 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      10:74c64d036d72 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:11 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (11) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x97\x8b  changeset:   10:74c64d036d72 (esc)
   \xe2\x94\x82 \xe2\x94\x82\xe2\x95\xb1\xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x95\xa7  parent:      6:b105a072e251 (esc)
   \xe2\x94\x82 \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82    date:        Thu Jan 01 00:00:10 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82    summary:     (10) merge two known; one immediate left, one near right (esc)
   \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x97\x8b \xe2\x94\x82  changeset:   9:7010c0af0a35 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      7:b632bb1b1224 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  parent:      8:7a0b11f71937 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  date:        Thu Jan 01 00:00:09 1970 +0000 (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82  summary:     (9) expand (esc)
   \xe2\x94\x82 \xe2\x94\x82 \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b \xe2\x94\x82  changeset:   8:7a0b11f71937 (esc)
   \xe2\x94\x82\xe2\x95\xb1\xe2\x94\x82 \xe2\x94\x82  parent:      0:e6eb3150255d (esc)
   \xe2\x94\x82 \xe2\x95\xa7 \xe2\x94\x82  parent:      7:b632bb1b1224 (esc)
   \xe2\x94\x82   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82   \xe2\x94\x82  date:        Thu Jan 01 00:00:08 1970 +0000 (esc)
   \xe2\x94\x82   \xe2\x94\x82  summary:     (8) merge two known; one immediate left, one far right (esc)
   \xe2\x94\x82  \xe2\x95\xb1 (esc)
   \xe2\x97\x8b \xe2\x94\x82  changeset:   7:b632bb1b1224 (esc)
   \xe2\x94\x82\xe2\x95\xb2 \xe2\x95\xb2   parent:      2:3d9a33b8d1e1 (esc)
   \xe2\x94\x82 \xe2\x95\xa7 \xe2\x94\x82  parent:      5:4409d547b708 (esc)
   \xe2\x94\x82   \xe2\x94\x82  user:        test (esc)
   \xe2\x94\x82   \xe2\x94\x82  date:        Thu Jan 01 00:00:07 1970 +0000 (esc)
   \xe2\x94\x82   \xe2\x94\x82  summary:     (7) expand (esc)
   \xe2\x94\x82  \xe2\x95\xb1 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  changeset:   6:b105a072e251 (esc)
   \xe2\x94\x82\xe2\x95\xb1\xe2\x94\x82  parent:      2:3d9a33b8d1e1 (esc)
   \xe2\x94\x82 \xe2\x95\xa7  parent:      5:4409d547b708 (esc)
   \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82    date:        Thu Jan 01 00:00:06 1970 +0000 (esc)
   \xe2\x94\x82    summary:     (6) merge two known; one immediate left, one far left (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   5:4409d547b708 (esc)
   \xe2\x94\x82\xe2\x95\xb2   parent:      3:27eef8ed80b4 (esc)
   \xe2\x94\x82 \xe2\x95\xa7  parent:      4:26a8bac39d9f (esc)
   \xe2\x94\x82    user:        test (esc)
   \xe2\x94\x82    date:        Thu Jan 01 00:00:05 1970 +0000 (esc)
   \xe2\x94\x82    summary:     (5) expand (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  changeset:   4:26a8bac39d9f (esc)
   \xe2\x94\x82\xe2\x95\xb2   parent:      1:6db2ef61d156 (esc)
   \xe2\x95\xa7 \xe2\x95\xa7  parent:      3:27eef8ed80b4 (esc)
        user:        test
        date:        Thu Jan 01 00:00:04 1970 +0000
        summary:     (4) merge two known; one immediate left, one immediate right
   
   $ cd ..
   $ cd repo
 
 behavior with newlines
 
   $ hg log -G -r ::2 -T '{rev} {desc}'
   \xe2\x97\x8b  2 (2) collapse (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  1 (1) collapse (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  0 (0) root (esc)
   
 
   $ hg log -G -r ::2 -T '{rev} {desc}\n'
   \xe2\x97\x8b  2 (2) collapse (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  1 (1) collapse (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  0 (0) root (esc)
   
 
   $ hg log -G -r ::2 -T '{rev} {desc}\n\n'
   \xe2\x97\x8b  2 (2) collapse (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  1 (1) collapse (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  0 (0) root (esc)
   
 
   $ hg log -G -r ::2 -T '\n{rev} {desc}'
   \xe2\x97\x8b (esc)
   \xe2\x94\x82  2 (2) collapse (esc)
   \xe2\x97\x8b (esc)
   \xe2\x94\x82  1 (1) collapse (esc)
   \xe2\x97\x8b (esc)
      0 (0) root
 
   $ hg log -G -r ::2 -T '{rev} {desc}\n\n\n'
   \xe2\x97\x8b  2 (2) collapse (esc)
   \xe2\x94\x82 (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  1 (1) collapse (esc)
   \xe2\x94\x82 (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  0 (0) root (esc)
   
   
   $ cd ..
 
 When inserting extra line nodes to handle more than 2 parents, ensure that
 the right node styles are used (issue5174):
 
   $ hg init repo-issue5174
   $ cd repo-issue5174
   $ echo a > f0
   $ hg ci -Aqm 0
   $ echo a > f1
   $ hg ci -Aqm 1
   $ echo a > f2
   $ hg ci -Aqm 2
   $ hg co ".^"
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo a > f3
   $ hg ci -Aqm 3
   $ hg co ".^^"
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo a > f4
   $ hg ci -Aqm 4
   $ hg merge -r 2
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -qm 5
   $ hg merge -r 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -qm 6
   $ hg log -G -r '0 | 1 | 2 | 6'
   \xe2\x97\x8d  changeset:   6:851fe89689ad (esc)
   \xe2\x94\x86\xe2\x95\xb2   tag:         tip (esc)
   \xe2\x94\x86 \xe2\x94\x86  parent:      5:4f1e3cf15f5d (esc)
   \xe2\x94\x86 \xe2\x94\x86  parent:      3:b74ba7084d2d (esc)
   \xe2\x94\x86 \xe2\x94\x86  user:        test (esc)
   \xe2\x94\x86 \xe2\x94\x86  date:        Thu Jan 01 00:00:00 1970 +0000 (esc)
   \xe2\x94\x86 \xe2\x94\x86  summary:     6 (esc)
   \xe2\x94\x86 \xe2\x94\x86 (esc)
   \xe2\x94\x86 \xe2\x95\xb2 (esc)
   \xe2\x94\x86 \xe2\x94\x86\xe2\x95\xb2 (esc)
   \xe2\x94\x86 \xe2\x97\x8b \xe2\x94\x86  changeset:   2:3e6599df4cce (esc)
   \xe2\x94\x86 \xe2\x94\x86\xe2\x95\xb1   user:        test (esc)
   \xe2\x94\x86 \xe2\x94\x86    date:        Thu Jan 01 00:00:00 1970 +0000 (esc)
   \xe2\x94\x86 \xe2\x94\x86    summary:     2 (esc)
   \xe2\x94\x86 \xe2\x94\x86 (esc)
   \xe2\x94\x86 \xe2\x97\x8b  changeset:   1:bd9a55143933 (esc)
   \xe2\x94\x86\xe2\x95\xb1   user:        test (esc)
   \xe2\x94\x86    date:        Thu Jan 01 00:00:00 1970 +0000 (esc)
   \xe2\x94\x86    summary:     1 (esc)
   \xe2\x94\x86 (esc)
   \xe2\x97\x8b  changeset:   0:870a5edc339c (esc)
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     0
   
 
   $ cd ..
 
 Multiple roots (issue5440):
 
   $ hg init multiroots
   $ cd multiroots
   $ cat <<EOF > .hg/hgrc
   > [ui]
   > logtemplate = '{rev} {desc}\n\n'
   > EOF
 
   $ touch foo
   $ hg ci -Aqm foo
   $ hg co -q null
   $ touch bar
   $ hg ci -Aqm bar
 
   $ hg log -Gr null:
   \xe2\x97\x8d  1 bar (esc)
   \xe2\x94\x82 (esc)
   \xe2\x94\x82 \xe2\x97\x8b  0 foo (esc)
   \xe2\x94\x82\xe2\x95\xb1 (esc)
   \xe2\x97\x8b  -1 (esc)
   
   $ hg log -Gr null+0
   \xe2\x97\x8b  0 foo (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  -1 (esc)
   
   $ hg log -Gr null+1
   \xe2\x97\x8d  1 bar (esc)
   \xe2\x94\x82 (esc)
   \xe2\x97\x8b  -1 (esc)
   
 
   $ cd ..