logcmdutil: raise `StateError` when file to follow doesn't exist

Differential Revision: https://phab.mercurial-scm.org/D11969

mercurial/logcmdutil.py

@@ -1,1287 +1,1287 b''
 # logcmdutil.py - utility for log-like commands
 #
 # Copyright 2005-2007 Olivia 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 itertools
 import os
 import posixpath
 
 from .i18n import _
 from .node import nullrev, wdirrev
 
 from .thirdparty import attr
 
 from . import (
     dagop,
     error,
     formatter,
     graphmod,
     match as matchmod,
     mdiff,
     merge,
     patch,
     pathutil,
     pycompat,
     revset,
     revsetlang,
     scmutil,
     smartset,
     templatekw,
     templater,
     util,
 )
 from .utils import (
     dateutil,
     stringutil,
 )
 
 
 if pycompat.TYPE_CHECKING:
     from typing import (
         Any,
         Callable,
         Dict,
         Optional,
         Sequence,
         Tuple,
     )
 
     for t in (Any, Callable, Dict, Optional, Tuple):
         assert t
 
 
 def getlimit(opts):
     """get the log limit according to option -l/--limit"""
     limit = opts.get(b'limit')
     if limit:
         try:
             limit = int(limit)
         except ValueError:
             raise error.InputError(_(b'limit must be a positive integer'))
         if limit <= 0:
             raise error.InputError(_(b'limit must be positive'))
     else:
         limit = None
     return limit
 
 
 def diff_parent(ctx):
     """get the context object to use as parent when diffing
 
 
     If diff.merge is enabled, an overlayworkingctx of the auto-merged parents will be returned.
     """
     repo = ctx.repo()
     if repo.ui.configbool(b"diff", b"merge") and ctx.p2().rev() != nullrev:
         # avoid cycle context -> subrepo -> cmdutil -> logcmdutil
         from . import context
 
         wctx = context.overlayworkingctx(repo)
         wctx.setbase(ctx.p1())
         with repo.ui.configoverride(
             {
                 (
                     b"ui",
                     b"forcemerge",
                 ): b"internal:merge3-lie-about-conflicts",
             },
             b"merge-diff",
         ):
             with repo.ui.silent():
                 merge.merge(ctx.p2(), wc=wctx)
         return wctx
     else:
         return ctx.p1()
 
 
 def diffordiffstat(
     ui,
     repo,
     diffopts,
     ctx1,
     ctx2,
     match,
     changes=None,
     stat=False,
     fp=None,
     graphwidth=0,
     prefix=b'',
     root=b'',
     listsubrepos=False,
     hunksfilterfn=None,
 ):
     '''show diff or diffstat.'''
     if root:
         relroot = pathutil.canonpath(repo.root, repo.getcwd(), root)
     else:
         relroot = b''
     copysourcematch = None
 
     def compose(f, g):
         return lambda x: f(g(x))
 
     def pathfn(f):
         return posixpath.join(prefix, f)
 
     if relroot != b'':
         # XXX relative roots currently don't work if the root is within a
         # subrepo
         uipathfn = scmutil.getuipathfn(repo, legacyrelativevalue=True)
         uirelroot = uipathfn(pathfn(relroot))
         relroot += b'/'
         for matchroot in match.files():
             if not matchroot.startswith(relroot):
                 ui.warn(
                     _(b'warning: %s not inside relative root %s\n')
                     % (uipathfn(pathfn(matchroot)), uirelroot)
                 )
 
         relrootmatch = scmutil.match(ctx2, pats=[relroot], default=b'path')
         match = matchmod.intersectmatchers(match, relrootmatch)
         copysourcematch = relrootmatch
 
         checkroot = repo.ui.configbool(
             b'devel', b'all-warnings'
         ) or repo.ui.configbool(b'devel', b'check-relroot')
 
         def relrootpathfn(f):
             if checkroot and not f.startswith(relroot):
                 raise AssertionError(
                     b"file %s doesn't start with relroot %s" % (f, relroot)
                 )
             return f[len(relroot) :]
 
         pathfn = compose(relrootpathfn, pathfn)
 
     if stat:
         diffopts = diffopts.copy(context=0, noprefix=False)
         width = 80
         if not ui.plain():
             width = ui.termwidth() - graphwidth
         # If an explicit --root was given, don't respect ui.relative-paths
         if not relroot:
             pathfn = compose(scmutil.getuipathfn(repo), pathfn)
 
     chunks = ctx2.diff(
         ctx1,
         match,
         changes,
         opts=diffopts,
         pathfn=pathfn,
         copysourcematch=copysourcematch,
         hunksfilterfn=hunksfilterfn,
     )
 
     if fp is not None or ui.canwritewithoutlabels():
         out = fp or ui
         if stat:
             chunks = [patch.diffstat(util.iterlines(chunks), width=width)]
         for chunk in util.filechunkiter(util.chunkbuffer(chunks)):
             out.write(chunk)
     else:
         if stat:
             chunks = patch.diffstatui(util.iterlines(chunks), width=width)
         else:
             chunks = patch.difflabel(
                 lambda chunks, **kwargs: chunks, chunks, opts=diffopts
             )
         if ui.canbatchlabeledwrites():
 
             def gen():
                 for chunk, label in chunks:
                     yield ui.label(chunk, label=label)
 
             for chunk in util.filechunkiter(util.chunkbuffer(gen())):
                 ui.write(chunk)
         else:
             for chunk, label in chunks:
                 ui.write(chunk, label=label)
 
     node2 = ctx2.node()
     for subpath, sub in scmutil.itersubrepos(ctx1, ctx2):
         tempnode2 = node2
         try:
             if node2 is not None:
                 tempnode2 = ctx2.substate[subpath][1]
         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 is to ignore it.
             tempnode2 = None
         submatch = matchmod.subdirmatcher(subpath, match)
         subprefix = repo.wvfs.reljoin(prefix, subpath)
         if listsubrepos or match.exact(subpath) or any(submatch.files()):
             sub.diff(
                 ui,
                 diffopts,
                 tempnode2,
                 submatch,
                 changes=changes,
                 stat=stat,
                 fp=fp,
                 prefix=subprefix,
             )
 
 
 class changesetdiffer(object):
     """Generate diff of changeset with pre-configured filtering functions"""
 
     def _makefilematcher(self, ctx):
         return scmutil.matchall(ctx.repo())
 
     def _makehunksfilter(self, ctx):
         return None
 
     def showdiff(self, ui, ctx, diffopts, graphwidth=0, stat=False):
         diffordiffstat(
             ui,
             ctx.repo(),
             diffopts,
             diff_parent(ctx),
             ctx,
             match=self._makefilematcher(ctx),
             stat=stat,
             graphwidth=graphwidth,
             hunksfilterfn=self._makehunksfilter(ctx),
         )
 
 
 def changesetlabels(ctx):
     labels = [b'log.changeset', b'changeset.%s' % ctx.phasestr()]
     if ctx.obsolete():
         labels.append(b'changeset.obsolete')
     if ctx.isunstable():
         labels.append(b'changeset.unstable')
         for instability in ctx.instabilities():
             labels.append(b'instability.%s' % instability)
     return b' '.join(labels)
 
 
 class changesetprinter(object):
     '''show changeset information when templating not requested.'''
 
     def __init__(self, ui, repo, differ=None, diffopts=None, buffered=False):
         self.ui = ui
         self.repo = repo
         self.buffered = buffered
         self._differ = differ or changesetdiffer()
         self._diffopts = patch.diffallopts(ui, diffopts)
         self._includestat = diffopts and diffopts.get(b'stat')
         self._includediff = diffopts and diffopts.get(b'patch')
         self.header = {}
         self.hunk = {}
         self.lastheader = None
         self.footer = None
         self._columns = templatekw.getlogcolumns()
 
     def flush(self, ctx):
         rev = ctx.rev()
         if rev in self.header:
             h = self.header[rev]
             if h != self.lastheader:
                 self.lastheader = h
                 self.ui.write(h)
             del self.header[rev]
         if rev in self.hunk:
             self.ui.write(self.hunk[rev])
             del self.hunk[rev]
 
     def close(self):
         if self.footer:
             self.ui.write(self.footer)
 
     def show(self, ctx, copies=None, **props):
         props = pycompat.byteskwargs(props)
         if self.buffered:
             self.ui.pushbuffer(labeled=True)
             self._show(ctx, copies, props)
             self.hunk[ctx.rev()] = self.ui.popbuffer()
         else:
             self._show(ctx, copies, props)
 
     def _show(self, ctx, copies, props):
         '''show a single changeset or file revision'''
         changenode = ctx.node()
         graphwidth = props.get(b'graphwidth', 0)
 
         if self.ui.quiet:
             self.ui.write(
                 b"%s\n" % scmutil.formatchangeid(ctx), label=b'log.node'
             )
             return
 
         columns = self._columns
         self.ui.write(
             columns[b'changeset'] % scmutil.formatchangeid(ctx),
             label=changesetlabels(ctx),
         )
 
         # branches are shown first before any other names due to backwards
         # compatibility
         branch = ctx.branch()
         # don't show the default branch name
         if branch != b'default':
             self.ui.write(columns[b'branch'] % branch, label=b'log.branch')
 
         for nsname, ns in pycompat.iteritems(self.repo.names):
             # branches has special logic already handled above, so here we just
             # skip it
             if nsname == b'branches':
                 continue
             # we will use the templatename as the color name since those two
             # should be the same
             for name in ns.names(self.repo, changenode):
                 self.ui.write(ns.logfmt % name, label=b'log.%s' % ns.colorname)
         if self.ui.debugflag:
             self.ui.write(
                 columns[b'phase'] % ctx.phasestr(), label=b'log.phase'
             )
         for pctx in scmutil.meaningfulparents(self.repo, ctx):
             label = b'log.parent changeset.%s' % pctx.phasestr()
             self.ui.write(
                 columns[b'parent'] % scmutil.formatchangeid(pctx), label=label
             )
 
         if self.ui.debugflag:
             mnode = ctx.manifestnode()
             if mnode is None:
                 mnode = self.repo.nodeconstants.wdirid
                 mrev = wdirrev
             else:
                 mrev = self.repo.manifestlog.rev(mnode)
             self.ui.write(
                 columns[b'manifest']
                 % scmutil.formatrevnode(self.ui, mrev, mnode),
                 label=b'ui.debug log.manifest',
             )
         self.ui.write(columns[b'user'] % ctx.user(), label=b'log.user')
         self.ui.write(
             columns[b'date'] % dateutil.datestr(ctx.date()), label=b'log.date'
         )
 
         if ctx.isunstable():
             instabilities = ctx.instabilities()
             self.ui.write(
                 columns[b'instability'] % b', '.join(instabilities),
                 label=b'log.instability',
             )
 
         elif ctx.obsolete():
             self._showobsfate(ctx)
 
         self._exthook(ctx)
 
         if self.ui.debugflag:
             files = ctx.p1().status(ctx)
             for key, value in zip(
                 [b'files', b'files+', b'files-'],
                 [files.modified, files.added, files.removed],
             ):
                 if value:
                     self.ui.write(
                         columns[key] % b" ".join(value),
                         label=b'ui.debug log.files',
                     )
         elif ctx.files() and self.ui.verbose:
             self.ui.write(
                 columns[b'files'] % b" ".join(ctx.files()),
                 label=b'ui.note log.files',
             )
         if copies and self.ui.verbose:
             copies = [b'%s (%s)' % c for c in copies]
             self.ui.write(
                 columns[b'copies'] % b' '.join(copies),
                 label=b'ui.note log.copies',
             )
 
         extra = ctx.extra()
         if extra and self.ui.debugflag:
             for key, value in sorted(extra.items()):
                 self.ui.write(
                     columns[b'extra'] % (key, stringutil.escapestr(value)),
                     label=b'ui.debug log.extra',
                 )
 
         description = ctx.description().strip()
         if description:
             if self.ui.verbose:
                 self.ui.write(
                     _(b"description:\n"), label=b'ui.note log.description'
                 )
                 self.ui.write(description, label=b'ui.note log.description')
                 self.ui.write(b"\n\n")
             else:
                 self.ui.write(
                     columns[b'summary'] % description.splitlines()[0],
                     label=b'log.summary',
                 )
         self.ui.write(b"\n")
 
         self._showpatch(ctx, graphwidth)
 
     def _showobsfate(self, ctx):
         # TODO: do not depend on templater
         tres = formatter.templateresources(self.repo.ui, self.repo)
         t = formatter.maketemplater(
             self.repo.ui,
             b'{join(obsfate, "\n")}',
             defaults=templatekw.keywords,
             resources=tres,
         )
         obsfate = t.renderdefault({b'ctx': ctx}).splitlines()
 
         if obsfate:
             for obsfateline in obsfate:
                 self.ui.write(
                     self._columns[b'obsolete'] % obsfateline,
                     label=b'log.obsfate',
                 )
 
     def _exthook(self, ctx):
         """empty method used by extension as a hook point"""
 
     def _showpatch(self, ctx, graphwidth=0):
         if self._includestat:
             self._differ.showdiff(
                 self.ui, ctx, self._diffopts, graphwidth, stat=True
             )
         if self._includestat and self._includediff:
             self.ui.write(b"\n")
         if self._includediff:
             self._differ.showdiff(
                 self.ui, ctx, self._diffopts, graphwidth, stat=False
             )
         if self._includestat or self._includediff:
             self.ui.write(b"\n")
 
 
 class changesetformatter(changesetprinter):
     """Format changeset information by generic formatter"""
 
     def __init__(
         self, ui, repo, fm, differ=None, diffopts=None, buffered=False
     ):
         changesetprinter.__init__(self, ui, repo, differ, diffopts, buffered)
         self._diffopts = patch.difffeatureopts(ui, diffopts, git=True)
         self._fm = fm
 
     def close(self):
         self._fm.end()
 
     def _show(self, ctx, copies, props):
         '''show a single changeset or file revision'''
         fm = self._fm
         fm.startitem()
         fm.context(ctx=ctx)
         fm.data(rev=scmutil.intrev(ctx), node=fm.hexfunc(scmutil.binnode(ctx)))
 
         datahint = fm.datahint()
         if self.ui.quiet and not datahint:
             return
 
         fm.data(
             branch=ctx.branch(),
             phase=ctx.phasestr(),
             user=ctx.user(),
             date=fm.formatdate(ctx.date()),
             desc=ctx.description(),
             bookmarks=fm.formatlist(ctx.bookmarks(), name=b'bookmark'),
             tags=fm.formatlist(ctx.tags(), name=b'tag'),
             parents=fm.formatlist(
                 [fm.hexfunc(c.node()) for c in ctx.parents()], name=b'node'
             ),
         )
 
         if self.ui.debugflag or b'manifest' in datahint:
             fm.data(
                 manifest=fm.hexfunc(
                     ctx.manifestnode() or self.repo.nodeconstants.wdirid
                 )
             )
         if self.ui.debugflag or b'extra' in datahint:
             fm.data(extra=fm.formatdict(ctx.extra()))
 
         if (
             self.ui.debugflag
             or b'modified' in datahint
             or b'added' in datahint
             or b'removed' in datahint
         ):
             files = ctx.p1().status(ctx)
             fm.data(
                 modified=fm.formatlist(files.modified, name=b'file'),
                 added=fm.formatlist(files.added, name=b'file'),
                 removed=fm.formatlist(files.removed, name=b'file'),
             )
 
         verbose = not self.ui.debugflag and self.ui.verbose
         if verbose or b'files' in datahint:
             fm.data(files=fm.formatlist(ctx.files(), name=b'file'))
         if verbose and copies or b'copies' in datahint:
             fm.data(
                 copies=fm.formatdict(copies or {}, key=b'name', value=b'source')
             )
 
         if self._includestat or b'diffstat' in datahint:
             self.ui.pushbuffer()
             self._differ.showdiff(self.ui, ctx, self._diffopts, stat=True)
             fm.data(diffstat=self.ui.popbuffer())
         if self._includediff or b'diff' in datahint:
             self.ui.pushbuffer()
             self._differ.showdiff(self.ui, ctx, self._diffopts, stat=False)
             fm.data(diff=self.ui.popbuffer())
 
 
 class changesettemplater(changesetprinter):
     """format changeset information.
 
     Note: there are a variety of convenience functions to build a
     changesettemplater for common cases. See functions such as:
     maketemplater, changesetdisplayer, buildcommittemplate, or other
     functions that use changesest_templater.
     """
 
     # Arguments before "buffered" used to be positional. Consider not
     # adding/removing arguments before "buffered" to not break callers.
     def __init__(
         self, ui, repo, tmplspec, differ=None, diffopts=None, buffered=False
     ):
         changesetprinter.__init__(self, ui, repo, differ, diffopts, buffered)
         # tres is shared with _graphnodeformatter()
         self._tresources = tres = formatter.templateresources(ui, repo)
         self.t = formatter.loadtemplater(
             ui,
             tmplspec,
             defaults=templatekw.keywords,
             resources=tres,
             cache=templatekw.defaulttempl,
         )
         self._counter = itertools.count()
 
         self._tref = tmplspec.ref
         self._parts = {
             b'header': b'',
             b'footer': b'',
             tmplspec.ref: tmplspec.ref,
             b'docheader': b'',
             b'docfooter': b'',
             b'separator': b'',
         }
         if tmplspec.mapfile:
             # find correct templates for current mode, for backward
             # compatibility with 'log -v/-q/--debug' using a mapfile
             tmplmodes = [
                 (True, b''),
                 (self.ui.verbose, b'_verbose'),
                 (self.ui.quiet, b'_quiet'),
                 (self.ui.debugflag, b'_debug'),
             ]
             for mode, postfix in tmplmodes:
                 for t in self._parts:
                     cur = t + postfix
                     if mode and cur in self.t:
                         self._parts[t] = cur
         else:
             partnames = [p for p in self._parts.keys() if p != tmplspec.ref]
             m = formatter.templatepartsmap(tmplspec, self.t, partnames)
             self._parts.update(m)
 
         if self._parts[b'docheader']:
             self.ui.write(self.t.render(self._parts[b'docheader'], {}))
 
     def close(self):
         if self._parts[b'docfooter']:
             if not self.footer:
                 self.footer = b""
             self.footer += self.t.render(self._parts[b'docfooter'], {})
         return super(changesettemplater, self).close()
 
     def _show(self, ctx, copies, props):
         '''show a single changeset or file revision'''
         props = props.copy()
         props[b'ctx'] = ctx
         props[b'index'] = index = next(self._counter)
         props[b'revcache'] = {b'copies': copies}
         graphwidth = props.get(b'graphwidth', 0)
 
         # write separator, which wouldn't work well with the header part below
         # since there's inherently a conflict between header (across items) and
         # separator (per item)
         if self._parts[b'separator'] and index > 0:
             self.ui.write(self.t.render(self._parts[b'separator'], {}))
 
         # write header
         if self._parts[b'header']:
             h = self.t.render(self._parts[b'header'], props)
             if self.buffered:
                 self.header[ctx.rev()] = h
             else:
                 if self.lastheader != h:
                     self.lastheader = h
                     self.ui.write(h)
 
         # write changeset metadata, then patch if requested
         key = self._parts[self._tref]
         self.ui.write(self.t.render(key, props))
         self._exthook(ctx)
         self._showpatch(ctx, graphwidth)
 
         if self._parts[b'footer']:
             if not self.footer:
                 self.footer = self.t.render(self._parts[b'footer'], props)
 
 
 def templatespec(tmpl, mapfile):
     assert not (tmpl and mapfile)
     if mapfile:
         return formatter.mapfile_templatespec(b'changeset', mapfile)
     else:
         return formatter.literal_templatespec(tmpl)
 
 
 def _lookuptemplate(ui, tmpl, style):
     """Find the template matching the given template spec or style
 
     See formatter.lookuptemplate() for details.
     """
 
     # ui settings
     if not tmpl and not style:  # template are stronger than style
         tmpl = ui.config(b'command-templates', b'log')
         if tmpl:
             return formatter.literal_templatespec(templater.unquotestring(tmpl))
         else:
             style = util.expandpath(ui.config(b'ui', b'style'))
 
     if not tmpl and style:
         mapfile = style
         fp = None
         if not os.path.split(mapfile)[0]:
             (mapname, fp) = templater.try_open_template(
                 b'map-cmdline.' + mapfile
             ) or templater.try_open_template(mapfile)
             if mapname:
                 mapfile = mapname
         return formatter.mapfile_templatespec(b'changeset', mapfile, fp)
 
     return formatter.lookuptemplate(ui, b'changeset', tmpl)
 
 
 def maketemplater(ui, repo, tmpl, buffered=False):
     """Create a changesettemplater from a literal template 'tmpl'
     byte-string."""
     spec = formatter.literal_templatespec(tmpl)
     return changesettemplater(ui, repo, spec, buffered=buffered)
 
 
 def changesetdisplayer(ui, repo, opts, differ=None, buffered=False):
     """show one changeset using template or regular display.
 
     Display format will be the first non-empty hit of:
     1. option 'template'
     2. option 'style'
     3. [command-templates] setting 'log'
     4. [ui] setting 'style'
     If all of these values are either the unset or the empty string,
     regular display via changesetprinter() is done.
     """
     postargs = (differ, opts, buffered)
     spec = _lookuptemplate(ui, opts.get(b'template'), opts.get(b'style'))
 
     # machine-readable formats have slightly different keyword set than
     # plain templates, which are handled by changesetformatter.
     # note that {b'pickle', b'debug'} can also be added to the list if needed.
     if spec.ref in {b'cbor', b'json'}:
         fm = ui.formatter(b'log', opts)
         return changesetformatter(ui, repo, fm, *postargs)
 
     if not spec.ref and not spec.tmpl and not spec.mapfile:
         return changesetprinter(ui, repo, *postargs)
 
     return changesettemplater(ui, repo, spec, *postargs)
 
 
 @attr.s
 class walkopts(object):
     """Options to configure a set of revisions and file matcher factory
     to scan revision/file history
     """
 
     # raw command-line parameters, which a matcher will be built from
     pats = attr.ib()
     opts = attr.ib()
 
     # a list of revset expressions to be traversed; if follow, it specifies
     # the start revisions
     revspec = attr.ib()
 
     # miscellaneous queries to filter revisions (see "hg help log" for details)
     bookmarks = attr.ib(default=attr.Factory(list))
     branches = attr.ib(default=attr.Factory(list))
     date = attr.ib(default=None)
     keywords = attr.ib(default=attr.Factory(list))
     no_merges = attr.ib(default=False)
     only_merges = attr.ib(default=False)
     prune_ancestors = attr.ib(default=attr.Factory(list))
     users = attr.ib(default=attr.Factory(list))
 
     # miscellaneous matcher arguments
     include_pats = attr.ib(default=attr.Factory(list))
     exclude_pats = attr.ib(default=attr.Factory(list))
 
     # 0: no follow, 1: follow first, 2: follow both parents
     follow = attr.ib(default=0)
 
     # do not attempt filelog-based traversal, which may be fast but cannot
     # include revisions where files were removed
     force_changelog_traversal = attr.ib(default=False)
 
     # filter revisions by file patterns, which should be disabled only if
     # you want to include revisions where files were unmodified
     filter_revisions_by_pats = attr.ib(default=True)
 
     # sort revisions prior to traversal: 'desc', 'topo', or None
     sort_revisions = attr.ib(default=None)
 
     # limit number of changes displayed; None means unlimited
     limit = attr.ib(default=None)
 
 
 def parseopts(ui, pats, opts):
     # type: (Any, Sequence[bytes], Dict[bytes, Any]) -> walkopts
     """Parse log command options into walkopts
 
     The returned walkopts will be passed in to getrevs() or makewalker().
     """
     if opts.get(b'follow_first'):
         follow = 1
     elif opts.get(b'follow'):
         follow = 2
     else:
         follow = 0
 
     if opts.get(b'graph'):
         if ui.configbool(b'experimental', b'log.topo'):
             sort_revisions = b'topo'
         else:
             sort_revisions = b'desc'
     else:
         sort_revisions = None
 
     return walkopts(
         pats=pats,
         opts=opts,
         revspec=opts.get(b'rev', []),
         bookmarks=opts.get(b'bookmark', []),
         # branch and only_branch are really aliases and must be handled at
         # the same time
         branches=opts.get(b'branch', []) + opts.get(b'only_branch', []),
         date=opts.get(b'date'),
         keywords=opts.get(b'keyword', []),
         no_merges=bool(opts.get(b'no_merges')),
         only_merges=bool(opts.get(b'only_merges')),
         prune_ancestors=opts.get(b'prune', []),
         users=opts.get(b'user', []),
         include_pats=opts.get(b'include', []),
         exclude_pats=opts.get(b'exclude', []),
         follow=follow,
         force_changelog_traversal=bool(opts.get(b'removed')),
         sort_revisions=sort_revisions,
         limit=getlimit(opts),
     )
 
 
 def _makematcher(repo, revs, wopts):
     """Build matcher and expanded patterns from log options
 
     If --follow, revs are the revisions to follow from.
 
     Returns (match, pats, slowpath) where
     - match: a matcher built from the given pats and -I/-X opts
     - pats: patterns used (globs are expanded on Windows)
     - slowpath: True if patterns aren't as simple as scanning filelogs
     """
     # pats/include/exclude are passed to match.match() directly in
     # _matchfiles() revset, but a log-like command should build its matcher
     # with scmutil.match(). The difference is input pats are globbed on
     # platforms without shell expansion (windows).
     wctx = repo[None]
     match, pats = scmutil.matchandpats(wctx, wopts.pats, wopts.opts)
     slowpath = match.anypats() or (
         not match.always() and wopts.force_changelog_traversal
     )
     if not slowpath:
         if wopts.follow and wopts.revspec:
             # There may be the case that a path doesn't exist in some (but
             # not all) of the specified start revisions, but let's consider
             # the path is valid. Missing files will be warned by the matcher.
             startctxs = [repo[r] for r in revs]
             for f in match.files():
                 found = False
                 for c in startctxs:
                     if f in c:
                         found = True
                     elif c.hasdir(f):
                         # If a directory exists in any of the start revisions,
                         # take the slow path.
                         found = slowpath = True
                 if not found:
-                    raise error.Abort(
+                    raise error.StateError(
                         _(
                             b'cannot follow file not in any of the specified '
                             b'revisions: "%s"'
                         )
                         % f
                     )
         elif wopts.follow:
             for f in match.files():
                 if f not in wctx:
                     # If the file exists, it may be a directory, so let it
                     # take the slow path.
                     if os.path.exists(repo.wjoin(f)):
                         slowpath = True
                         continue
                     else:
-                        raise error.Abort(
+                        raise error.StateError(
                             _(
                                 b'cannot follow file not in parent '
                                 b'revision: "%s"'
                             )
                             % f
                         )
                 filelog = repo.file(f)
                 if not filelog:
                     # A file exists in wdir but not in history, which means
                     # the file isn't committed yet.
-                    raise error.Abort(
+                    raise error.StateError(
                         _(b'cannot follow nonexistent file: "%s"') % f
                     )
         else:
             for f in match.files():
                 filelog = repo.file(f)
                 if not filelog:
                     # A zero count may be a directory or deleted file, so
                     # try to find matching entries on the slow path.
                     slowpath = True
 
         # We decided to fall back to the slowpath because at least one
         # of the paths was not a file. Check to see if at least one of them
         # existed in history - in that case, we'll continue down the
         # slowpath; otherwise, we can turn off the slowpath
         if slowpath:
             for path in match.files():
                 if not path or path in repo.store:
                     break
             else:
                 slowpath = False
 
     return match, pats, slowpath
 
 
 def _fileancestors(repo, revs, match, followfirst):
     fctxs = []
     for r in revs:
         ctx = repo[r]
         fctxs.extend(ctx[f].introfilectx() for f in ctx.walk(match))
 
     # When displaying a revision with --patch --follow FILE, we have
     # to know which file of the revision must be diffed. With
     # --follow, we want the names of the ancestors of FILE in the
     # revision, stored in "fcache". "fcache" is populated as a side effect
     # of the graph traversal.
     fcache = {}
 
     def filematcher(ctx):
         return scmutil.matchfiles(repo, fcache.get(scmutil.intrev(ctx), []))
 
     def revgen():
         for rev, cs in dagop.filectxancestors(fctxs, followfirst=followfirst):
             fcache[rev] = [c.path() for c in cs]
             yield rev
 
     return smartset.generatorset(revgen(), iterasc=False), filematcher
 
 
 def _makenofollowfilematcher(repo, pats, opts):
     '''hook for extensions to override the filematcher for non-follow cases'''
     return None
 
 
 def revsingle(repo, revspec, default=b'.', localalias=None):
     """Resolves user-provided revset(s) into a single revision.
 
     This just wraps the lower-level scmutil.revsingle() in order to raise an
     exception indicating user error.
     """
     try:
         return scmutil.revsingle(repo, revspec, default, localalias)
     except error.RepoLookupError as e:
         raise error.InputError(e.args[0], hint=e.hint)
 
 
 def revpair(repo, revs):
     """Resolves user-provided revset(s) into two revisions.
 
     This just wraps the lower-level scmutil.revpair() in order to raise an
     exception indicating user error.
     """
     try:
         return scmutil.revpair(repo, revs)
     except error.RepoLookupError as e:
         raise error.InputError(e.args[0], hint=e.hint)
 
 
 def revrange(repo, specs, localalias=None):
     """Resolves user-provided revset(s).
 
     This just wraps the lower-level scmutil.revrange() in order to raise an
     exception indicating user error.
     """
     try:
         return scmutil.revrange(repo, specs, localalias)
     except error.RepoLookupError as e:
         raise error.InputError(e.args[0], hint=e.hint)
 
 
 _opt2logrevset = {
     b'no_merges': (b'not merge()', None),
     b'only_merges': (b'merge()', None),
     b'_matchfiles': (None, b'_matchfiles(%ps)'),
     b'date': (b'date(%s)', None),
     b'branch': (b'branch(%s)', b'%lr'),
     b'_patslog': (b'filelog(%s)', b'%lr'),
     b'keyword': (b'keyword(%s)', b'%lr'),
     b'prune': (b'ancestors(%s)', b'not %lr'),
     b'user': (b'user(%s)', b'%lr'),
 }
 
 
 def _makerevset(repo, wopts, slowpath):
     """Return a revset string built from log options and file patterns"""
     opts = {
         b'branch': [b'literal:' + repo.lookupbranch(b) for b in wopts.branches],
         b'date': wopts.date,
         b'keyword': wopts.keywords,
         b'no_merges': wopts.no_merges,
         b'only_merges': wopts.only_merges,
         b'prune': wopts.prune_ancestors,
         b'user': [b'literal:' + v for v in wopts.users],
     }
 
     if wopts.filter_revisions_by_pats and slowpath:
         # pats/include/exclude cannot be represented as separate
         # revset expressions as their filtering logic applies at file
         # level. For instance "-I a -X b" matches a revision touching
         # "a" and "b" while "file(a) and not file(b)" does
         # not. Besides, filesets are evaluated against the working
         # directory.
         matchargs = [b'r:', b'd:relpath']
         for p in wopts.pats:
             matchargs.append(b'p:' + p)
         for p in wopts.include_pats:
             matchargs.append(b'i:' + p)
         for p in wopts.exclude_pats:
             matchargs.append(b'x:' + p)
         opts[b'_matchfiles'] = matchargs
     elif wopts.filter_revisions_by_pats and not wopts.follow:
         opts[b'_patslog'] = list(wopts.pats)
 
     expr = []
     for op, val in sorted(pycompat.iteritems(opts)):
         if not val:
             continue
         revop, listop = _opt2logrevset[op]
         if revop and b'%' not in revop:
             expr.append(revop)
         elif not listop:
             expr.append(revsetlang.formatspec(revop, val))
         else:
             if revop:
                 val = [revsetlang.formatspec(revop, v) for v in val]
             expr.append(revsetlang.formatspec(listop, val))
 
     if wopts.bookmarks:
         expr.append(
             revsetlang.formatspec(
                 b'%lr',
                 [scmutil.format_bookmark_revspec(v) for v in wopts.bookmarks],
             )
         )
 
     if expr:
         expr = b'(' + b' and '.join(expr) + b')'
     else:
         expr = None
     return expr
 
 
 def _initialrevs(repo, wopts):
     """Return the initial set of revisions to be filtered or followed"""
     if wopts.revspec:
         revs = revrange(repo, wopts.revspec)
     elif wopts.follow and repo.dirstate.p1() == repo.nullid:
         revs = smartset.baseset()
     elif wopts.follow:
         revs = repo.revs(b'.')
     else:
         revs = smartset.spanset(repo)
         revs.reverse()
     return revs
 
 
 def makewalker(repo, wopts):
     # type: (Any, walkopts) -> Tuple[smartset.abstractsmartset, Optional[Callable[[Any], matchmod.basematcher]]]
     """Build (revs, makefilematcher) to scan revision/file history
 
     - revs is the smartset to be traversed.
     - makefilematcher is a function to map ctx to a matcher for that revision
     """
     revs = _initialrevs(repo, wopts)
     if not revs:
         return smartset.baseset(), None
     # TODO: might want to merge slowpath with wopts.force_changelog_traversal
     match, pats, slowpath = _makematcher(repo, revs, wopts)
     wopts = attr.evolve(wopts, pats=pats)
 
     filematcher = None
     if wopts.follow:
         if slowpath or match.always():
             revs = dagop.revancestors(repo, revs, followfirst=wopts.follow == 1)
         else:
             assert not wopts.force_changelog_traversal
             revs, filematcher = _fileancestors(
                 repo, revs, match, followfirst=wopts.follow == 1
             )
         revs.reverse()
     if filematcher is None:
         filematcher = _makenofollowfilematcher(repo, wopts.pats, wopts.opts)
     if filematcher is None:
 
         def filematcher(ctx):
             return match
 
     expr = _makerevset(repo, wopts, slowpath)
     if wopts.sort_revisions:
         assert wopts.sort_revisions in {b'topo', b'desc'}
         if wopts.sort_revisions == b'topo':
             if not revs.istopo():
                 revs = dagop.toposort(revs, repo.changelog.parentrevs)
                 # TODO: try to iterate the set lazily
                 revs = revset.baseset(list(revs), istopo=True)
         elif not (revs.isdescending() or revs.istopo()):
             # User-specified revs might be unsorted
             revs.sort(reverse=True)
     if expr:
         matcher = revset.match(None, expr)
         revs = matcher(repo, revs)
     if wopts.limit is not None:
         revs = revs.slice(0, wopts.limit)
 
     return revs, filematcher
 
 
 def getrevs(repo, wopts):
     # type: (Any, walkopts) -> Tuple[smartset.abstractsmartset, Optional[changesetdiffer]]
     """Return (revs, differ) where revs is a smartset
 
     differ is a changesetdiffer with pre-configured file matcher.
     """
     revs, filematcher = makewalker(repo, wopts)
     if not revs:
         return revs, None
     differ = changesetdiffer()
     differ._makefilematcher = filematcher
     return revs, differ
 
 
 def _parselinerangeopt(repo, opts):
     """Parse --line-range log option and return a list of tuples (filename,
     (fromline, toline)).
     """
     linerangebyfname = []
     for pat in opts.get(b'line_range', []):
         try:
             pat, linerange = pat.rsplit(b',', 1)
         except ValueError:
             raise error.InputError(
                 _(b'malformatted line-range pattern %s') % pat
             )
         try:
             fromline, toline = map(int, linerange.split(b':'))
         except ValueError:
             raise error.InputError(_(b"invalid line range for %s") % pat)
         msg = _(b"line range pattern '%s' must match exactly one file") % pat
         fname = scmutil.parsefollowlinespattern(repo, None, pat, msg)
         linerangebyfname.append(
             (fname, util.processlinerange(fromline, toline))
         )
     return linerangebyfname
 
 
 def getlinerangerevs(repo, userrevs, opts):
     """Return (revs, differ).
 
     "revs" are revisions obtained by processing "line-range" log options and
     walking block ancestors of each specified file/line-range.
 
     "differ" is a changesetdiffer with pre-configured file matcher and hunks
     filter.
     """
     wctx = repo[None]
 
     # Two-levels map of "rev -> file ctx -> [line range]".
     linerangesbyrev = {}
     for fname, (fromline, toline) in _parselinerangeopt(repo, opts):
         if fname not in wctx:
-            raise error.Abort(
+            raise error.StateError(
                 _(b'cannot follow file not in parent revision: "%s"') % fname
             )
         fctx = wctx.filectx(fname)
         for fctx, linerange in dagop.blockancestors(fctx, fromline, toline):
             rev = fctx.introrev()
             if rev is None:
                 rev = wdirrev
             if rev not in userrevs:
                 continue
             linerangesbyrev.setdefault(rev, {}).setdefault(
                 fctx.path(), []
             ).append(linerange)
 
     def nofilterhunksfn(fctx, hunks):
         return hunks
 
     def hunksfilter(ctx):
         fctxlineranges = linerangesbyrev.get(scmutil.intrev(ctx))
         if fctxlineranges is None:
             return nofilterhunksfn
 
         def filterfn(fctx, hunks):
             lineranges = fctxlineranges.get(fctx.path())
             if lineranges is not None:
                 for hr, lines in hunks:
                     if hr is None:  # binary
                         yield hr, lines
                         continue
                     if any(mdiff.hunkinrange(hr[2:], lr) for lr in lineranges):
                         yield hr, lines
             else:
                 for hunk in hunks:
                     yield hunk
 
         return filterfn
 
     def filematcher(ctx):
         files = list(linerangesbyrev.get(scmutil.intrev(ctx), []))
         return scmutil.matchfiles(repo, files)
 
     revs = sorted(linerangesbyrev, reverse=True)
 
     differ = changesetdiffer()
     differ._makefilematcher = filematcher
     differ._makehunksfilter = hunksfilter
     return smartset.baseset(revs), differ
 
 
 def _graphnodeformatter(ui, displayer):
     spec = ui.config(b'command-templates', b'graphnode')
     if not spec:
         return templatekw.getgraphnode  # fast path for "{graphnode}"
 
     spec = templater.unquotestring(spec)
     if isinstance(displayer, changesettemplater):
         # reuse cache of slow templates
         tres = displayer._tresources
     else:
         tres = formatter.templateresources(ui)
     templ = formatter.maketemplater(
         ui, spec, defaults=templatekw.keywords, resources=tres
     )
 
     def formatnode(repo, ctx, cache):
         props = {b'ctx': ctx, b'repo': repo}
         return templ.renderdefault(props)
 
     return formatnode
 
 
 def displaygraph(ui, repo, dag, displayer, edgefn, getcopies=None, props=None):
     props = props or {}
     formatnode = _graphnodeformatter(ui, displayer)
     state = graphmod.asciistate()
     styles = state.styles
 
     # only set graph styling if HGPLAIN is not set.
     if ui.plain(b'graph'):
         # set all edge styles to |, the default pre-3.8 behaviour
         styles.update(dict.fromkeys(styles, b'|'))
     else:
         edgetypes = {
             b'parent': graphmod.PARENT,
             b'grandparent': graphmod.GRANDPARENT,
             b'missing': graphmod.MISSINGPARENT,
         }
         for name, key in edgetypes.items():
             # experimental config: experimental.graphstyle.*
             styles[key] = ui.config(
                 b'experimental', b'graphstyle.%s' % name, styles[key]
             )
             if not styles[key]:
                 styles[key] = None
 
         # experimental config: experimental.graphshorten
         state.graphshorten = ui.configbool(b'experimental', b'graphshorten')
 
     formatnode_cache = {}
     for rev, type, ctx, parents in dag:
         char = formatnode(repo, ctx, formatnode_cache)
         copies = getcopies(ctx) if getcopies else None
         edges = edgefn(type, char, state, rev, parents)
         firstedge = next(edges)
         width = firstedge[2]
         displayer.show(
             ctx, copies=copies, graphwidth=width, **pycompat.strkwargs(props)
         )
         lines = displayer.hunk.pop(rev).split(b'\n')
         if not lines[-1]:
             del lines[-1]
         displayer.flush(ctx)
         for type, char, width, coldata in itertools.chain([firstedge], edges):
             graphmod.ascii(ui, state, type, char, lines, coldata)
             lines = []
     displayer.close()
 
 
 def displaygraphrevs(ui, repo, revs, displayer, getrenamed):
     revdag = graphmod.dagwalker(repo, revs)
     displaygraph(ui, repo, revdag, displayer, graphmod.asciiedges, getrenamed)
 
 
 def displayrevs(ui, repo, revs, displayer, getcopies):
     for rev in revs:
         ctx = repo[rev]
         copies = getcopies(ctx) if getcopies else None
         displayer.show(ctx, copies=copies)
         displayer.flush(ctx)
     displayer.close()
 
 
 def checkunsupportedgraphflags(pats, opts):
     for op in [b"newest_first"]:
         if op in opts and opts[op]:
             raise error.InputError(
                 _(b"-G/--graph option is incompatible with --%s")
                 % op.replace(b"_", b"-")
             )
 
 
 def graphrevs(repo, nodes, opts):
     limit = getlimit(opts)
     nodes.reverse()
     if limit is not None:
         nodes = nodes[:limit]
     return graphmod.nodes(repo, nodes)

tests/test-grep.t

@@ -1,1464 +1,1464 b''
   $ hg init t
   $ cd t
   $ echo import > port
   $ hg add port
   $ hg commit -m 0 -u spam -d '0 0'
   $ echo export >> port
   $ hg commit -m 1 -u eggs -d '1 0'
   $ echo export > port
   $ echo vaportight >> port
   $ echo 'import/export' >> port
   $ hg commit -m 2 -u spam -d '2 0'
   $ echo 'import/export' >> port
   $ hg commit -m 3 -u eggs -d '3 0'
   $ head -n 3 port > port1
   $ mv port1 port
   $ hg commit -m 4 -u spam -d '4 0'
 
 pattern error
 
   $ hg grep '**test**'
   grep: invalid match pattern: nothing to repeat* (glob)
   [1]
 
 invalid revset syntax
 
   $ hg log -r 'diffcontains()'
   hg: parse error: diffcontains takes at least 1 argument
   [10]
   $ hg log -r 'diffcontains(:)'
   hg: parse error: diffcontains requires a string pattern
   [10]
   $ hg log -r 'diffcontains("re:**test**")'
   hg: parse error: invalid regular expression: nothing to repeat* (glob)
   [10]
 
 simple
 
   $ hg grep -r tip:0 '.*'
   port:4:export
   port:4:vaportight
   port:4:import/export
   port:3:export
   port:3:vaportight
   port:3:import/export
   port:3:import/export
   port:2:export
   port:2:vaportight
   port:2:import/export
   port:1:import
   port:1:export
   port:0:import
   $ hg grep -r tip:0 port port
   port:4:export
   port:4:vaportight
   port:4:import/export
   port:3:export
   port:3:vaportight
   port:3:import/export
   port:3:import/export
   port:2:export
   port:2:vaportight
   port:2:import/export
   port:1:import
   port:1:export
   port:0:import
 
 simple from subdirectory
 
   $ mkdir dir
   $ cd dir
   $ hg grep -r tip:0 port
   port:4:export
   port:4:vaportight
   port:4:import/export
   port:3:export
   port:3:vaportight
   port:3:import/export
   port:3:import/export
   port:2:export
   port:2:vaportight
   port:2:import/export
   port:1:import
   port:1:export
   port:0:import
   $ hg grep -r tip:0 port --config ui.relative-paths=yes
   ../port:4:export
   ../port:4:vaportight
   ../port:4:import/export
   ../port:3:export
   ../port:3:vaportight
   ../port:3:import/export
   ../port:3:import/export
   ../port:2:export
   ../port:2:vaportight
   ../port:2:import/export
   ../port:1:import
   ../port:1:export
   ../port:0:import
   $ cd ..
 
 simple with color
 
   $ hg --config extensions.color= grep --config color.mode=ansi \
   >     --color=always port port -r tip:0
   \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m4\x1b[0m\x1b[0;36m:\x1b[0mex\x1b[0;31;1mport\x1b[0m (esc)
   \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m4\x1b[0m\x1b[0;36m:\x1b[0mva\x1b[0;31;1mport\x1b[0might (esc)
   \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m4\x1b[0m\x1b[0;36m:\x1b[0mim\x1b[0;31;1mport\x1b[0m/ex\x1b[0;31;1mport\x1b[0m (esc)
   \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m3\x1b[0m\x1b[0;36m:\x1b[0mex\x1b[0;31;1mport\x1b[0m (esc)
   \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m3\x1b[0m\x1b[0;36m:\x1b[0mva\x1b[0;31;1mport\x1b[0might (esc)
   \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m3\x1b[0m\x1b[0;36m:\x1b[0mim\x1b[0;31;1mport\x1b[0m/ex\x1b[0;31;1mport\x1b[0m (esc)
   \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m3\x1b[0m\x1b[0;36m:\x1b[0mim\x1b[0;31;1mport\x1b[0m/ex\x1b[0;31;1mport\x1b[0m (esc)
   \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m2\x1b[0m\x1b[0;36m:\x1b[0mex\x1b[0;31;1mport\x1b[0m (esc)
   \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m2\x1b[0m\x1b[0;36m:\x1b[0mva\x1b[0;31;1mport\x1b[0might (esc)
   \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m2\x1b[0m\x1b[0;36m:\x1b[0mim\x1b[0;31;1mport\x1b[0m/ex\x1b[0;31;1mport\x1b[0m (esc)
   \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m1\x1b[0m\x1b[0;36m:\x1b[0mim\x1b[0;31;1mport\x1b[0m (esc)
   \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m1\x1b[0m\x1b[0;36m:\x1b[0mex\x1b[0;31;1mport\x1b[0m (esc)
   \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m0\x1b[0m\x1b[0;36m:\x1b[0mim\x1b[0;31;1mport\x1b[0m (esc)
 
 simple templated
 
   $ hg grep port -r tip:0 \
   > -T '{path}:{rev}:{node|short}:{texts % "{if(matched, text|upper, text)}"}\n'
   port:4:914fa752cdea:exPORT
   port:4:914fa752cdea:vaPORTight
   port:4:914fa752cdea:imPORT/exPORT
   port:3:95040cfd017d:exPORT
   port:3:95040cfd017d:vaPORTight
   port:3:95040cfd017d:imPORT/exPORT
   port:3:95040cfd017d:imPORT/exPORT
   port:2:3b325e3481a1:exPORT
   port:2:3b325e3481a1:vaPORTight
   port:2:3b325e3481a1:imPORT/exPORT
   port:1:8b20f75c1585:imPORT
   port:1:8b20f75c1585:exPORT
   port:0:f31323c92170:imPORT
 
   $ hg grep port -r tip:0 -T '{path}:{rev}:{texts}\n'
   port:4:export
   port:4:vaportight
   port:4:import/export
   port:3:export
   port:3:vaportight
   port:3:import/export
   port:3:import/export
   port:2:export
   port:2:vaportight
   port:2:import/export
   port:1:import
   port:1:export
   port:0:import
 
   $ hg grep port -r tip:0 -T '{path}:{tags}:{texts}\n'
   port:tip:export
   port:tip:vaportight
   port:tip:import/export
   port::export
   port::vaportight
   port::import/export
   port::import/export
   port::export
   port::vaportight
   port::import/export
   port::import
   port::export
   port::import
 
 simple JSON (no "change" field)
 
   $ hg grep -r tip:0 -Tjson port
   [
    {
     "date": [4, 0],
     "lineno": 1,
     "node": "914fa752cdea87777ac1a8d5c858b0c736218f6c",
     "path": "port",
     "rev": 4,
     "texts": [{"matched": false, "text": "ex"}, {"matched": true, "text": "port"}],
     "user": "spam"
    },
    {
     "date": [4, 0],
     "lineno": 2,
     "node": "914fa752cdea87777ac1a8d5c858b0c736218f6c",
     "path": "port",
     "rev": 4,
     "texts": [{"matched": false, "text": "va"}, {"matched": true, "text": "port"}, {"matched": false, "text": "ight"}],
     "user": "spam"
    },
    {
     "date": [4, 0],
     "lineno": 3,
     "node": "914fa752cdea87777ac1a8d5c858b0c736218f6c",
     "path": "port",
     "rev": 4,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}, {"matched": false, "text": "/ex"}, {"matched": true, "text": "port"}],
     "user": "spam"
    },
    {
     "date": [3, 0],
     "lineno": 1,
     "node": "95040cfd017d658c536071c6290230a613c4c2a6",
     "path": "port",
     "rev": 3,
     "texts": [{"matched": false, "text": "ex"}, {"matched": true, "text": "port"}],
     "user": "eggs"
    },
    {
     "date": [3, 0],
     "lineno": 2,
     "node": "95040cfd017d658c536071c6290230a613c4c2a6",
     "path": "port",
     "rev": 3,
     "texts": [{"matched": false, "text": "va"}, {"matched": true, "text": "port"}, {"matched": false, "text": "ight"}],
     "user": "eggs"
    },
    {
     "date": [3, 0],
     "lineno": 3,
     "node": "95040cfd017d658c536071c6290230a613c4c2a6",
     "path": "port",
     "rev": 3,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}, {"matched": false, "text": "/ex"}, {"matched": true, "text": "port"}],
     "user": "eggs"
    },
    {
     "date": [3, 0],
     "lineno": 4,
     "node": "95040cfd017d658c536071c6290230a613c4c2a6",
     "path": "port",
     "rev": 3,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}, {"matched": false, "text": "/ex"}, {"matched": true, "text": "port"}],
     "user": "eggs"
    },
    {
     "date": [2, 0],
     "lineno": 1,
     "node": "3b325e3481a1f07435d81dfdbfa434d9a0245b47",
     "path": "port",
     "rev": 2,
     "texts": [{"matched": false, "text": "ex"}, {"matched": true, "text": "port"}],
     "user": "spam"
    },
    {
     "date": [2, 0],
     "lineno": 2,
     "node": "3b325e3481a1f07435d81dfdbfa434d9a0245b47",
     "path": "port",
     "rev": 2,
     "texts": [{"matched": false, "text": "va"}, {"matched": true, "text": "port"}, {"matched": false, "text": "ight"}],
     "user": "spam"
    },
    {
     "date": [2, 0],
     "lineno": 3,
     "node": "3b325e3481a1f07435d81dfdbfa434d9a0245b47",
     "path": "port",
     "rev": 2,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}, {"matched": false, "text": "/ex"}, {"matched": true, "text": "port"}],
     "user": "spam"
    },
    {
     "date": [1, 0],
     "lineno": 1,
     "node": "8b20f75c158513ff5ac80bd0e5219bfb6f0eb587",
     "path": "port",
     "rev": 1,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}],
     "user": "eggs"
    },
    {
     "date": [1, 0],
     "lineno": 2,
     "node": "8b20f75c158513ff5ac80bd0e5219bfb6f0eb587",
     "path": "port",
     "rev": 1,
     "texts": [{"matched": false, "text": "ex"}, {"matched": true, "text": "port"}],
     "user": "eggs"
    },
    {
     "date": [0, 0],
     "lineno": 1,
     "node": "f31323c9217050ba245ee8b537c713ec2e8ab226",
     "path": "port",
     "rev": 0,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}],
     "user": "spam"
    }
   ]
 
 simple JSON without matching lines
 
   $ hg grep -r tip:0 -Tjson -l port
   [
    {
     "date": [4, 0],
     "lineno": 1,
     "node": "914fa752cdea87777ac1a8d5c858b0c736218f6c",
     "path": "port",
     "rev": 4,
     "user": "spam"
    },
    {
     "date": [3, 0],
     "lineno": 1,
     "node": "95040cfd017d658c536071c6290230a613c4c2a6",
     "path": "port",
     "rev": 3,
     "user": "eggs"
    },
    {
     "date": [2, 0],
     "lineno": 1,
     "node": "3b325e3481a1f07435d81dfdbfa434d9a0245b47",
     "path": "port",
     "rev": 2,
     "user": "spam"
    },
    {
     "date": [1, 0],
     "lineno": 1,
     "node": "8b20f75c158513ff5ac80bd0e5219bfb6f0eb587",
     "path": "port",
     "rev": 1,
     "user": "eggs"
    },
    {
     "date": [0, 0],
     "lineno": 1,
     "node": "f31323c9217050ba245ee8b537c713ec2e8ab226",
     "path": "port",
     "rev": 0,
     "user": "spam"
    }
   ]
 
 diff of each revision for reference
 
   $ hg log -p -T'== rev: {rev} ==\n'
   == rev: 4 ==
   diff -r 95040cfd017d -r 914fa752cdea port
   --- a/port	Thu Jan 01 00:00:03 1970 +0000
   +++ b/port	Thu Jan 01 00:00:04 1970 +0000
   @@ -1,4 +1,3 @@
    export
    vaportight
    import/export
   -import/export
   
   == rev: 3 ==
   diff -r 3b325e3481a1 -r 95040cfd017d port
   --- a/port	Thu Jan 01 00:00:02 1970 +0000
   +++ b/port	Thu Jan 01 00:00:03 1970 +0000
   @@ -1,3 +1,4 @@
    export
    vaportight
    import/export
   +import/export
   
   == rev: 2 ==
   diff -r 8b20f75c1585 -r 3b325e3481a1 port
   --- a/port	Thu Jan 01 00:00:01 1970 +0000
   +++ b/port	Thu Jan 01 00:00:02 1970 +0000
   @@ -1,2 +1,3 @@
   -import
    export
   +vaportight
   +import/export
   
   == rev: 1 ==
   diff -r f31323c92170 -r 8b20f75c1585 port
   --- a/port	Thu Jan 01 00:00:00 1970 +0000
   +++ b/port	Thu Jan 01 00:00:01 1970 +0000
   @@ -1,1 +1,2 @@
    import
   +export
   
   == rev: 0 ==
   diff -r 000000000000 -r f31323c92170 port
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/port	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +import
   
 
 all
 
   $ hg grep --traceback --all -nu port port
   port:4:4:-:spam:import/export
   port:3:4:+:eggs:import/export
   port:2:1:-:spam:import
   port:2:2:+:spam:vaportight
   port:2:3:+:spam:import/export
   port:1:2:+:eggs:export
   port:0:1:+:spam:import
 
 all JSON
 
   $ hg grep --all -Tjson port port
   [
    {
     "change": "-",
     "date": [4, 0],
     "lineno": 4,
     "node": "914fa752cdea87777ac1a8d5c858b0c736218f6c",
     "path": "port",
     "rev": 4,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}, {"matched": false, "text": "/ex"}, {"matched": true, "text": "port"}],
     "user": "spam"
    },
    {
     "change": "+",
     "date": [3, 0],
     "lineno": 4,
     "node": "95040cfd017d658c536071c6290230a613c4c2a6",
     "path": "port",
     "rev": 3,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}, {"matched": false, "text": "/ex"}, {"matched": true, "text": "port"}],
     "user": "eggs"
    },
    {
     "change": "-",
     "date": [2, 0],
     "lineno": 1,
     "node": "3b325e3481a1f07435d81dfdbfa434d9a0245b47",
     "path": "port",
     "rev": 2,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}],
     "user": "spam"
    },
    {
     "change": "+",
     "date": [2, 0],
     "lineno": 2,
     "node": "3b325e3481a1f07435d81dfdbfa434d9a0245b47",
     "path": "port",
     "rev": 2,
     "texts": [{"matched": false, "text": "va"}, {"matched": true, "text": "port"}, {"matched": false, "text": "ight"}],
     "user": "spam"
    },
    {
     "change": "+",
     "date": [2, 0],
     "lineno": 3,
     "node": "3b325e3481a1f07435d81dfdbfa434d9a0245b47",
     "path": "port",
     "rev": 2,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}, {"matched": false, "text": "/ex"}, {"matched": true, "text": "port"}],
     "user": "spam"
    },
    {
     "change": "+",
     "date": [1, 0],
     "lineno": 2,
     "node": "8b20f75c158513ff5ac80bd0e5219bfb6f0eb587",
     "path": "port",
     "rev": 1,
     "texts": [{"matched": false, "text": "ex"}, {"matched": true, "text": "port"}],
     "user": "eggs"
    },
    {
     "change": "+",
     "date": [0, 0],
     "lineno": 1,
     "node": "f31323c9217050ba245ee8b537c713ec2e8ab226",
     "path": "port",
     "rev": 0,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}],
     "user": "spam"
    }
   ]
 
 other
 
   $ hg grep -r tip:0 -l port port
   port:4
   port:3
   port:2
   port:1
   port:0
   $ hg grep -r tip:0 import port
   port:4:import/export
   port:3:import/export
   port:3:import/export
   port:2:import/export
   port:1:import
   port:0:import
 
   $ hg cp port port2
   $ hg commit -m 4 -u spam -d '5 0'
 
 follow
 
   $ hg grep -r tip:0 --traceback -f 'import\n\Z' port2
   [1]
   $ echo deport >> port2
   $ hg commit -m 5 -u eggs -d '6 0'
   $ hg grep -f --all -nu port port2
   port2:6:4:+:eggs:deport
   port:4:4:-:spam:import/export
   port:3:4:+:eggs:import/export
   port:2:1:-:spam:import
   port:2:2:+:spam:vaportight
   port:2:3:+:spam:import/export
   port:1:2:+:eggs:export
   port:0:1:+:spam:import
 
   $ hg up -q null
   $ hg grep -r 'reverse(:.)' -f port
   port:0:import
 
 Test wdir
 (at least, this shouldn't crash)
 
   $ hg up -q
   $ echo wport >> port2
   $ hg stat
   M port2
   $ hg grep -r 'wdir()' port
   port:2147483647:export
   port:2147483647:vaportight
   port:2147483647:import/export
   port2:2147483647:export
   port2:2147483647:vaportight
   port2:2147483647:import/export
   port2:2147483647:deport
   port2:2147483647:wport
 
   $ cd ..
   $ hg init t2
   $ cd t2
   $ hg grep -r tip:0 foobar foo
   [1]
   $ hg grep -r tip:0 foobar
   [1]
   $ echo blue >> color
   $ echo black >> color
   $ hg add color
   $ hg ci -m 0
   $ echo orange >> color
   $ hg ci -m 1
   $ echo black > color
   $ hg ci -m 2
   $ echo orange >> color
   $ echo blue >> color
   $ hg ci -m 3
   $ hg grep -r tip:0 orange
   color:3:orange
   color:1:orange
   $ hg grep --all orange
   color:3:+:orange
   color:2:-:orange
   color:1:+:orange
   $ hg grep --diff orange --color=debug
   [grep.filename|color][grep.sep|:][grep.rev|3][grep.sep|:][grep.inserted grep.change|+][grep.sep|:][grep.match|orange]
   [grep.filename|color][grep.sep|:][grep.rev|2][grep.sep|:][grep.deleted grep.change|-][grep.sep|:][grep.match|orange]
   [grep.filename|color][grep.sep|:][grep.rev|1][grep.sep|:][grep.inserted grep.change|+][grep.sep|:][grep.match|orange]
 
   $ hg grep --diff orange --color=yes
   \x1b[0;35mcolor\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m3\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;32;1m+\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;31;1morange\x1b[0m (esc)
   \x1b[0;35mcolor\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m2\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;31;1m-\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;31;1morange\x1b[0m (esc)
   \x1b[0;35mcolor\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m1\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;32;1m+\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;31;1morange\x1b[0m (esc)
 
   $ hg grep --diff orange
   color:3:+:orange
   color:2:-:orange
   color:1:+:orange
 
 revset predicate for "grep --diff"
 
   $ hg log -qr 'diffcontains("re:^bl...$")'
   0:203191eb5e21
   $ hg log -qr 'diffcontains("orange")'
   1:7c585a21e0d1
   2:11bd8bc8d653
   3:e0116d3829f8
   $ hg log -qr '2:0 & diffcontains("orange")'
   2:11bd8bc8d653
   1:7c585a21e0d1
 
 test substring match: '^' should only match at the beginning
 
   $ hg grep -r tip:0 '^.' --config extensions.color= --color debug
   [grep.filename|color][grep.sep|:][grep.rev|3][grep.sep|:][grep.match|b]lack
   [grep.filename|color][grep.sep|:][grep.rev|3][grep.sep|:][grep.match|o]range
   [grep.filename|color][grep.sep|:][grep.rev|3][grep.sep|:][grep.match|b]lue
   [grep.filename|color][grep.sep|:][grep.rev|2][grep.sep|:][grep.match|b]lack
   [grep.filename|color][grep.sep|:][grep.rev|1][grep.sep|:][grep.match|b]lue
   [grep.filename|color][grep.sep|:][grep.rev|1][grep.sep|:][grep.match|b]lack
   [grep.filename|color][grep.sep|:][grep.rev|1][grep.sep|:][grep.match|o]range
   [grep.filename|color][grep.sep|:][grep.rev|0][grep.sep|:][grep.match|b]lue
   [grep.filename|color][grep.sep|:][grep.rev|0][grep.sep|:][grep.match|b]lack
 
 match in last "line" without newline
 
   $ "$PYTHON" -c 'fp = open("noeol", "wb"); fp.write(b"no infinite loop"); fp.close();'
   $ hg ci -Amnoeol
   adding noeol
   $ hg grep -r tip:0 loop
   noeol:4:no infinite loop
 
   $ cd ..
 
 Issue685: traceback in grep -r after rename
 
 Got a traceback when using grep on a single
 revision with renamed files.
 
   $ hg init issue685
   $ cd issue685
   $ echo octarine > color
   $ hg ci -Amcolor
   adding color
   $ hg rename color colour
   $ hg ci -Am rename
   $ hg grep -r tip:0 octarine
   colour:1:octarine
   color:0:octarine
 
 Used to crash here
 
   $ hg grep -r 1 octarine
   colour:1:octarine
   $ cd ..
 
 
 Issue337: test that grep follows parent-child relationships instead
 of just using revision numbers.
 
   $ hg init issue337
   $ cd issue337
 
   $ echo white > color
   $ hg commit -A -m "0 white"
   adding color
 
   $ echo red > color
   $ hg commit -A -m "1 red"
 
   $ hg update 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo black > color
   $ hg commit -A -m "2 black"
   created new head
 
   $ hg update --clean 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo blue > color
   $ hg commit -A -m "3 blue"
 
   $ hg grep --all red
   color:3:-:red
   color:1:+:red
 
   $ hg grep --diff red
   color:3:-:red
   color:1:+:red
 
 Issue3885: test that changing revision order does not alter the
 revisions printed, just their order.
 
   $ hg grep --all red -r "all()"
   color:1:+:red
   color:3:-:red
 
   $ hg grep --all red -r "reverse(all())"
   color:3:-:red
   color:1:+:red
 
   $ hg grep --diff red -r "all()"
   color:1:+:red
   color:3:-:red
 
   $ hg grep --diff red -r "reverse(all())"
   color:3:-:red
   color:1:+:red
 
   $ cd ..
 
   $ hg init a
   $ cd a
   $ cp "$TESTDIR/binfile.bin" .
   $ hg add binfile.bin
   $ hg ci -m 'add binfile.bin'
   $ hg grep "MaCam" --all
   binfile.bin:0:+: Binary file matches
 
   $ hg grep "MaCam" --diff
   binfile.bin:0:+: Binary file matches
 
   $ cd ..
 
 Moved line may not be collected by "grep --diff" since it first filters
 the contents to be diffed by the pattern. (i.e.
 "diff <(grep pat a) <(grep pat b)", not "diff a b | grep pat".)
 This is much faster than generating full diff per revision.
 
   $ hg init moved-line
   $ cd moved-line
   $ cat <<'EOF' > a
   > foo
   > bar
   > baz
   > EOF
   $ hg ci -Am initial
   adding a
   $ cat <<'EOF' > a
   > bar
   > baz
   > foo
   > EOF
   $ hg ci -m reorder
 
   $ hg diff -c 1
   diff -r a593cc55e81b -r 69789a3b6e80 a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,3 +1,3 @@
   -foo
    bar
    baz
   +foo
 
  can't find the move of "foo" at the revision 1:
 
   $ hg grep --diff foo -r1
   [1]
 
  "bar" isn't moved at the revisoin 1:
 
   $ hg grep --diff bar -r1
   [1]
 
   $ cd ..
 
 Test for showing working of allfiles flag
 
   $ hg init sng
   $ cd sng
   $ echo "unmod" >> um
   $ echo old > old
   $ hg ci -q -A -m "adds unmod to um"
   $ echo "something else" >> new
   $ hg ci -A -m "second commit"
   adding new
   $ hg grep -r "." "unmod"
   um:1:unmod
 
 Existing tracked files in the working directory are searched by default
 
   $ echo modified >> new
   $ echo 'added' > added; hg add added
   $ echo 'added, missing' > added-missing; hg add added-missing; rm added-missing
   $ echo 'untracked' > untracked
   $ hg rm old
   $ hg grep ''
   added:added
   new:something else
   new:modified
   um:unmod
 
 #if symlink
 Grepping a symlink greps its destination
 
   $ rm -f added; ln -s symlink-added added
   $ hg grep '' | grep added
   added:symlink-added
 
 But we reject symlinks as directories components of a tracked file as
 usual:
 
   $ mkdir dir; touch dir/f; hg add dir/f
   $ rm -rf dir; ln -s / dir
   $ hg grep ''
   abort: path 'dir/f' traverses symbolic link 'dir'
   [255]
 #endif
 
 But we can search files from some other revision with -rREV
 
   $ hg grep -r. mod
   um:1:unmod
 
   $ hg grep --diff mod
   um:0:+:unmod
 
   $ cd ..
 
 Change Default of grep by ui.tweakdefaults, that is, the files not in current
 working directory should not be grepp-ed on
 
   $ hg init ab
   $ cd ab
   $ cat <<'EOF' >> .hg/hgrc
   > [ui]
   > tweakdefaults = True
   > EOF
   $ echo "some text">>file1
   $ hg add file1
   $ hg commit -m "adds file1"
   $ hg mv file1 file2
 
 wdir revision is hidden by default:
 
   $ hg grep "some"
   file2:some text
 
 but it should be available in template dict:
 
   $ hg grep "some" -Tjson
   [
    {
     "date": [0, 0],
     "lineno": 1,
     "node": "ffffffffffffffffffffffffffffffffffffffff",
     "path": "file2",
     "rev": 2147483647,
     "texts": [{"matched": true, "text": "some"}, {"matched": false, "text": " text"}],
     "user": "test"
    }
   ]
 
   $ cd ..
 
 test -rMULTIREV
 
   $ cd sng
   $ hg rm um
   $ hg commit -m "deletes um"
   $ hg grep -r "0:2" "unmod"
   um:0:unmod
   um:1:unmod
   $ hg grep -r "0:2" "unmod" um
   um:0:unmod
   um:1:unmod
   $ hg grep -r "0:2" "unmod" "glob:**/um" # Check that patterns also work
   um:0:unmod
   um:1:unmod
   $ cd ..
 
 --follow with/without --diff and/or paths
 -----------------------------------------
 
 For each test case, we compare the history traversal of "hg log",
 "hg grep --diff", and "hg grep" (--all-files).
 
 "hg grep --diff" should traverse the log in the same way as "hg log".
 "hg grep" (--all-files) is slightly different in that it includes
 unmodified changes.
 
   $ hg init follow
   $ cd follow
 
   $ cat <<'EOF' >> .hg/hgrc
   > [command-templates]
   > log = '{rev}: {join(files % "{status} {path}", ", ")}\n'
   > EOF
 
   $ for f in add0 add0-mod1 add0-rm1 add0-mod2 add0-rm2 add0-mod3 add0-mod4 add0-rm4; do
   > echo data0 >> $f
   > done
   $ hg ci -qAm0
 
   $ hg cp add0 add0-cp1
   $ hg cp add0 add0-cp1-mod1
   $ hg cp add0 add0-cp1-mod1-rm3
   $ hg rm add0-rm1
   $ for f in *mod1*; do
   > echo data1 >> $f
   > done
   $ hg ci -qAm1
 
   $ hg update -q 0
   $ hg cp add0 add0-cp2
   $ hg cp add0 add0-cp2-mod2
   $ hg rm add0-rm2
   $ for f in *mod2*; do
   > echo data2 >> $f
   > done
   $ hg ci -qAm2
 
   $ hg update -q 1
   $ hg cp add0-cp1 add0-cp1-cp3
   $ hg cp add0-cp1-mod1 add0-cp1-mod1-cp3-mod3
   $ hg rm add0-cp1-mod1-rm3
   $ for f in *mod3*; do
   > echo data3 >> $f
   > done
   $ hg ci -qAm3
 
   $ hg cp add0 add0-cp4
   $ hg cp add0 add0-cp4-mod4
   $ hg rm add0-rm4
   $ for f in *mod4*; do
   > echo data4 >> $f
   > done
 
   $ hg log -Gr':wdir()'
   o  2147483647: A add0-cp4, A add0-cp4-mod4, M add0-mod4, R add0-rm4
   |
   @  3: A add0-cp1-cp3, A add0-cp1-mod1-cp3-mod3, R add0-cp1-mod1-rm3, M add0-mod3
   |
   | o  2: A add0-cp2, A add0-cp2-mod2, M add0-mod2, R add0-rm2
   | |
   o |  1: A add0-cp1, A add0-cp1-mod1, A add0-cp1-mod1-rm3, M add0-mod1, R add0-rm1
   |/
   o  0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
   
 
 follow revision history from wdir parent:
 
   $ hg log -f
   3: A add0-cp1-cp3, A add0-cp1-mod1-cp3-mod3, R add0-cp1-mod1-rm3, M add0-mod3
   1: A add0-cp1, A add0-cp1-mod1, A add0-cp1-mod1-rm3, M add0-mod1, R add0-rm1
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -f data
   add0-cp1-mod1-cp3-mod3:3:+:data3
   add0-mod3:3:+:data3
   add0-cp1-mod1:1:+:data1
   add0-cp1-mod1-rm3:1:+:data1
   add0-mod1:1:+:data1
   add0:0:+:data0
   add0-mod1:0:+:data0
   add0-mod2:0:+:data0
   add0-mod3:0:+:data0
   add0-mod4:0:+:data0
   add0-rm1:0:+:data0
   add0-rm2:0:+:data0
   add0-rm4:0:+:data0
 
   $ hg grep -f data
   add0:3:data0
   add0-cp1:3:data0
   add0-cp1-cp3:3:data0
   add0-cp1-mod1:3:data0
   add0-cp1-mod1:3:data1
   add0-cp1-mod1-cp3-mod3:3:data0
   add0-cp1-mod1-cp3-mod3:3:data1
   add0-cp1-mod1-cp3-mod3:3:data3
   add0-mod1:3:data0
   add0-mod1:3:data1
   add0-mod2:3:data0
   add0-mod3:3:data0
   add0-mod3:3:data3
   add0-mod4:3:data0
   add0-rm2:3:data0
   add0-rm4:3:data0
   add0:1:data0
   add0-cp1:1:data0
   add0-cp1-mod1:1:data0
   add0-cp1-mod1:1:data1
   add0-cp1-mod1-rm3:1:data0
   add0-cp1-mod1-rm3:1:data1
   add0-mod1:1:data0
   add0-mod1:1:data1
   add0-mod2:1:data0
   add0-mod3:1:data0
   add0-mod4:1:data0
   add0-rm2:1:data0
   add0-rm4:1:data0
   add0:0:data0
   add0-mod1:0:data0
   add0-mod2:0:data0
   add0-mod3:0:data0
   add0-mod4:0:data0
   add0-rm1:0:data0
   add0-rm2:0:data0
   add0-rm4:0:data0
 
 follow revision history from specified revision:
 
   $ hg log -fr2
   2: A add0-cp2, A add0-cp2-mod2, M add0-mod2, R add0-rm2
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -fr2 data
   add0-cp2-mod2:2:+:data2
   add0-mod2:2:+:data2
   add0:0:+:data0
   add0-mod1:0:+:data0
   add0-mod2:0:+:data0
   add0-mod3:0:+:data0
   add0-mod4:0:+:data0
   add0-rm1:0:+:data0
   add0-rm2:0:+:data0
   add0-rm4:0:+:data0
 
   $ hg grep -fr2 data
   add0:2:data0
   add0-cp2:2:data0
   add0-cp2-mod2:2:data0
   add0-cp2-mod2:2:data2
   add0-mod1:2:data0
   add0-mod2:2:data0
   add0-mod2:2:data2
   add0-mod3:2:data0
   add0-mod4:2:data0
   add0-rm1:2:data0
   add0-rm4:2:data0
   add0:0:data0
   add0-mod1:0:data0
   add0-mod2:0:data0
   add0-mod3:0:data0
   add0-mod4:0:data0
   add0-rm1:0:data0
   add0-rm2:0:data0
   add0-rm4:0:data0
 
 follow revision history from wdir:
 
   $ hg log -fr'wdir()'
   2147483647: A add0-cp4, A add0-cp4-mod4, M add0-mod4, R add0-rm4
   3: A add0-cp1-cp3, A add0-cp1-mod1-cp3-mod3, R add0-cp1-mod1-rm3, M add0-mod3
   1: A add0-cp1, A add0-cp1-mod1, A add0-cp1-mod1-rm3, M add0-mod1, R add0-rm1
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
  BROKEN: should not abort because of removed file
   $ hg grep --diff -fr'wdir()' data
   add0-cp4-mod4:2147483647:+:data4
   add0-mod4:2147483647:+:data4
   add0-rm4:2147483647:-:abort: add0-rm4@None: not found in manifest
   [50]
 
   $ hg grep -fr'wdir()' data
   add0:2147483647:data0
   add0-cp1:2147483647:data0
   add0-cp1-cp3:2147483647:data0
   add0-cp1-mod1:2147483647:data0
   add0-cp1-mod1:2147483647:data1
   add0-cp1-mod1-cp3-mod3:2147483647:data0
   add0-cp1-mod1-cp3-mod3:2147483647:data1
   add0-cp1-mod1-cp3-mod3:2147483647:data3
   add0-cp4:2147483647:data0
   add0-cp4-mod4:2147483647:data0
   add0-cp4-mod4:2147483647:data4
   add0-mod1:2147483647:data0
   add0-mod1:2147483647:data1
   add0-mod2:2147483647:data0
   add0-mod3:2147483647:data0
   add0-mod3:2147483647:data3
   add0-mod4:2147483647:data0
   add0-mod4:2147483647:data4
   add0-rm2:2147483647:data0
   add0:3:data0
   add0-cp1:3:data0
   add0-cp1-cp3:3:data0
   add0-cp1-mod1:3:data0
   add0-cp1-mod1:3:data1
   add0-cp1-mod1-cp3-mod3:3:data0
   add0-cp1-mod1-cp3-mod3:3:data1
   add0-cp1-mod1-cp3-mod3:3:data3
   add0-mod1:3:data0
   add0-mod1:3:data1
   add0-mod2:3:data0
   add0-mod3:3:data0
   add0-mod3:3:data3
   add0-mod4:3:data0
   add0-rm2:3:data0
   add0-rm4:3:data0
   add0:1:data0
   add0-cp1:1:data0
   add0-cp1-mod1:1:data0
   add0-cp1-mod1:1:data1
   add0-cp1-mod1-rm3:1:data0
   add0-cp1-mod1-rm3:1:data1
   add0-mod1:1:data0
   add0-mod1:1:data1
   add0-mod2:1:data0
   add0-mod3:1:data0
   add0-mod4:1:data0
   add0-rm2:1:data0
   add0-rm4:1:data0
   add0:0:data0
   add0-mod1:0:data0
   add0-mod2:0:data0
   add0-mod3:0:data0
   add0-mod4:0:data0
   add0-rm1:0:data0
   add0-rm2:0:data0
   add0-rm4:0:data0
 
 follow revision history from multiple revisions:
 
   $ hg log -fr'1+2'
   2: A add0-cp2, A add0-cp2-mod2, M add0-mod2, R add0-rm2
   1: A add0-cp1, A add0-cp1-mod1, A add0-cp1-mod1-rm3, M add0-mod1, R add0-rm1
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -fr'1+2' data
   add0-cp2-mod2:2:+:data2
   add0-mod2:2:+:data2
   add0-cp1-mod1:1:+:data1
   add0-cp1-mod1-rm3:1:+:data1
   add0-mod1:1:+:data1
   add0:0:+:data0
   add0-mod1:0:+:data0
   add0-mod2:0:+:data0
   add0-mod3:0:+:data0
   add0-mod4:0:+:data0
   add0-rm1:0:+:data0
   add0-rm2:0:+:data0
   add0-rm4:0:+:data0
 
   $ hg grep -fr'1+2' data
   add0:2:data0
   add0-cp2:2:data0
   add0-cp2-mod2:2:data0
   add0-cp2-mod2:2:data2
   add0-mod1:2:data0
   add0-mod2:2:data0
   add0-mod2:2:data2
   add0-mod3:2:data0
   add0-mod4:2:data0
   add0-rm1:2:data0
   add0-rm4:2:data0
   add0:1:data0
   add0-cp1:1:data0
   add0-cp1-mod1:1:data0
   add0-cp1-mod1:1:data1
   add0-cp1-mod1-rm3:1:data0
   add0-cp1-mod1-rm3:1:data1
   add0-mod1:1:data0
   add0-mod1:1:data1
   add0-mod2:1:data0
   add0-mod3:1:data0
   add0-mod4:1:data0
   add0-rm2:1:data0
   add0-rm4:1:data0
   add0:0:data0
   add0-mod1:0:data0
   add0-mod2:0:data0
   add0-mod3:0:data0
   add0-mod4:0:data0
   add0-rm1:0:data0
   add0-rm2:0:data0
   add0-rm4:0:data0
 
 follow file history from wdir parent, unmodified in wdir:
 
   $ hg log -f add0-mod3
   3: A add0-cp1-cp3, A add0-cp1-mod1-cp3-mod3, R add0-cp1-mod1-rm3, M add0-mod3
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -f data add0-mod3
   add0-mod3:3:+:data3
   add0-mod3:0:+:data0
 
   $ hg grep -f data add0-mod3
   add0-mod3:3:data0
   add0-mod3:3:data3
   add0-mod3:1:data0
   add0-mod3:0:data0
 
 follow file history from wdir parent, modified in wdir:
 
   $ hg log -f add0-mod4
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -f data add0-mod4
   add0-mod4:0:+:data0
 
   $ hg grep -f data add0-mod4
   add0-mod4:3:data0
   add0-mod4:1:data0
   add0-mod4:0:data0
 
 follow file history from wdir parent, copied but unmodified:
 
   $ hg log -f add0-cp1-cp3
   3: A add0-cp1-cp3, A add0-cp1-mod1-cp3-mod3, R add0-cp1-mod1-rm3, M add0-mod3
   1: A add0-cp1, A add0-cp1-mod1, A add0-cp1-mod1-rm3, M add0-mod1, R add0-rm1
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -f data add0-cp1-cp3
   add0:0:+:data0
 
  BROKEN: should follow history across renames
   $ hg grep -f data add0-cp1-cp3
   add0-cp1-cp3:3:data0
 
 follow file history from wdir parent, copied and modified:
 
   $ hg log -f add0-cp1-mod1-cp3-mod3
   3: A add0-cp1-cp3, A add0-cp1-mod1-cp3-mod3, R add0-cp1-mod1-rm3, M add0-mod3
   1: A add0-cp1, A add0-cp1-mod1, A add0-cp1-mod1-rm3, M add0-mod1, R add0-rm1
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -f data add0-cp1-mod1-cp3-mod3
   add0-cp1-mod1-cp3-mod3:3:+:data3
   add0-cp1-mod1:1:+:data1
   add0:0:+:data0
 
  BROKEN: should follow history across renames
   $ hg grep -f data add0-cp1-mod1-cp3-mod3
   add0-cp1-mod1-cp3-mod3:3:data0
   add0-cp1-mod1-cp3-mod3:3:data1
   add0-cp1-mod1-cp3-mod3:3:data3
 
 follow file history from wdir parent, copied in wdir:
 
   $ hg log -f add0-cp4
   abort: cannot follow nonexistent file: "add0-cp4"
-  [255]
+  [20]
 
   $ hg grep --diff -f data add0-cp4
   abort: cannot follow nonexistent file: "add0-cp4"
-  [255]
+  [20]
 
  BROKEN: maybe better to abort
   $ hg grep -f data add0-cp4
   [1]
 
 follow file history from wdir parent, removed:
 
   $ hg log -f add0-cp1-mod1-rm3
   abort: cannot follow file not in parent revision: "add0-cp1-mod1-rm3"
-  [255]
+  [20]
 
   $ hg grep --diff -f data add0-cp1-mod1-rm3
   abort: cannot follow file not in parent revision: "add0-cp1-mod1-rm3"
-  [255]
+  [20]
 
  BROKEN: maybe better to abort
   $ hg grep -f data add0-cp1-mod1-rm3
   add0-cp1-mod1-rm3:1:data0
   add0-cp1-mod1-rm3:1:data1
 
 follow file history from wdir parent (explicit), removed:
 
   $ hg log -fr. add0-cp1-mod1-rm3
   abort: cannot follow file not in any of the specified revisions: "add0-cp1-mod1-rm3"
-  [255]
+  [20]
 
   $ hg grep --diff -fr. data add0-cp1-mod1-rm3
   abort: cannot follow file not in any of the specified revisions: "add0-cp1-mod1-rm3"
-  [255]
+  [20]
 
  BROKEN: should abort
   $ hg grep -fr. data add0-cp1-mod1-rm3
   add0-cp1-mod1-rm3:1:data0
   add0-cp1-mod1-rm3:1:data1
 
 follow file history from wdir parent, removed in wdir:
 
   $ hg log -f add0-rm4
   abort: cannot follow file not in parent revision: "add0-rm4"
-  [255]
+  [20]
 
   $ hg grep --diff -f data add0-rm4
   abort: cannot follow file not in parent revision: "add0-rm4"
-  [255]
+  [20]
 
  BROKEN: should abort
   $ hg grep -f data add0-rm4
   add0-rm4:3:data0
   add0-rm4:1:data0
   add0-rm4:0:data0
 
 follow file history from wdir parent (explicit), removed in wdir:
 
   $ hg log -fr. add0-rm4
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -fr. data add0-rm4
   add0-rm4:0:+:data0
 
   $ hg grep -fr. data add0-rm4
   add0-rm4:3:data0
   add0-rm4:1:data0
   add0-rm4:0:data0
 
 follow file history from wdir parent, multiple files:
 
   $ hg log -f add0-mod3 add0-cp1-mod1
   3: A add0-cp1-cp3, A add0-cp1-mod1-cp3-mod3, R add0-cp1-mod1-rm3, M add0-mod3
   1: A add0-cp1, A add0-cp1-mod1, A add0-cp1-mod1-rm3, M add0-mod1, R add0-rm1
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -f data add0-mod3 add0-cp1-mod1
   add0-mod3:3:+:data3
   add0-cp1-mod1:1:+:data1
   add0:0:+:data0
   add0-mod3:0:+:data0
 
  BROKEN: should follow history across renames
   $ hg grep -f data add0-mod3 add0-cp1-mod1
   add0-cp1-mod1:3:data0
   add0-cp1-mod1:3:data1
   add0-mod3:3:data0
   add0-mod3:3:data3
   add0-cp1-mod1:1:data0
   add0-cp1-mod1:1:data1
   add0-mod3:1:data0
   add0-mod3:0:data0
 
 follow file history from specified revision, modified:
 
   $ hg log -fr2 add0-mod2
   2: A add0-cp2, A add0-cp2-mod2, M add0-mod2, R add0-rm2
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -fr2 data add0-mod2
   add0-mod2:2:+:data2
   add0-mod2:0:+:data0
 
   $ hg grep -fr2 data add0-mod2
   add0-mod2:2:data0
   add0-mod2:2:data2
   add0-mod2:0:data0
 
 follow file history from specified revision, copied but unmodified:
 
   $ hg log -fr2 add0-cp2
   2: A add0-cp2, A add0-cp2-mod2, M add0-mod2, R add0-rm2
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -fr2 data add0-cp2
   add0:0:+:data0
 
  BROKEN: should follow history across renames
   $ hg grep -fr2 data add0-cp2
   add0-cp2:2:data0
 
 follow file history from specified revision, copied and modified:
 
   $ hg log -fr2 add0-cp2-mod2
   2: A add0-cp2, A add0-cp2-mod2, M add0-mod2, R add0-rm2
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -fr2 data add0-cp2-mod2
   add0-cp2-mod2:2:+:data2
   add0:0:+:data0
 
  BROKEN: should follow history across renames
   $ hg grep -fr2 data add0-cp2-mod2
   add0-cp2-mod2:2:data0
   add0-cp2-mod2:2:data2
 
 follow file history from specified revision, removed:
 
   $ hg log -fr2 add0-rm2
   abort: cannot follow file not in any of the specified revisions: "add0-rm2"
-  [255]
+  [20]
 
   $ hg grep --diff -fr2 data add0-rm2
   abort: cannot follow file not in any of the specified revisions: "add0-rm2"
-  [255]
+  [20]
 
  BROKEN: should abort
   $ hg grep -fr2 data add0-rm2
   add0-rm2:0:data0
 
 follow file history from specified revision, multiple files:
 
   $ hg log -fr2 add0-cp2 add0-mod2
   2: A add0-cp2, A add0-cp2-mod2, M add0-mod2, R add0-rm2
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -fr2 data add0-cp2 add0-mod2
   add0-mod2:2:+:data2
   add0:0:+:data0
   add0-mod2:0:+:data0
 
  BROKEN: should follow history across renames
   $ hg grep -fr2 data add0-cp2 add0-mod2
   add0-cp2:2:data0
   add0-mod2:2:data0
   add0-mod2:2:data2
   add0-mod2:0:data0
 
 follow file history from wdir, unmodified:
 
   $ hg log -fr'wdir()' add0-mod3
   2147483647: A add0-cp4, A add0-cp4-mod4, M add0-mod4, R add0-rm4
   3: A add0-cp1-cp3, A add0-cp1-mod1-cp3-mod3, R add0-cp1-mod1-rm3, M add0-mod3
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -fr'wdir()' data add0-mod3
   add0-mod3:3:+:data3
   add0-mod3:0:+:data0
 
   $ hg grep -fr'wdir()' data add0-mod3
   add0-mod3:2147483647:data0
   add0-mod3:2147483647:data3
   add0-mod3:3:data0
   add0-mod3:3:data3
   add0-mod3:1:data0
   add0-mod3:0:data0
 
 follow file history from wdir, modified:
 
   $ hg log -fr'wdir()' add0-mod4
   2147483647: A add0-cp4, A add0-cp4-mod4, M add0-mod4, R add0-rm4
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -fr'wdir()' data add0-mod4
   add0-mod4:2147483647:+:data4
   add0-mod4:0:+:data0
 
   $ hg grep -fr'wdir()' data add0-mod4
   add0-mod4:2147483647:data0
   add0-mod4:2147483647:data4
   add0-mod4:3:data0
   add0-mod4:1:data0
   add0-mod4:0:data0
 
 follow file history from wdir, copied but unmodified:
 
   $ hg log -fr'wdir()' add0-cp4
   2147483647: A add0-cp4, A add0-cp4-mod4, M add0-mod4, R add0-rm4
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -fr'wdir()' data add0-cp4
   add0:0:+:data0
 
  BROKEN: should follow history across renames
   $ hg grep -fr'wdir()' data add0-cp4
   add0-cp4:2147483647:data0
 
 follow file history from wdir, copied and modified:
 
   $ hg log -fr'wdir()' add0-cp4-mod4
   2147483647: A add0-cp4, A add0-cp4-mod4, M add0-mod4, R add0-rm4
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -fr'wdir()' data add0-cp4-mod4
   add0-cp4-mod4:2147483647:+:data4
   add0:0:+:data0
 
  BROKEN: should follow history across renames
   $ hg grep -fr'wdir()' data add0-cp4-mod4
   add0-cp4-mod4:2147483647:data0
   add0-cp4-mod4:2147483647:data4
 
 follow file history from wdir, multiple files:
 
   $ hg log -fr'wdir()' add0-cp4 add0-mod4 add0-mod3
   2147483647: A add0-cp4, A add0-cp4-mod4, M add0-mod4, R add0-rm4
   3: A add0-cp1-cp3, A add0-cp1-mod1-cp3-mod3, R add0-cp1-mod1-rm3, M add0-mod3
   0: A add0, A add0-mod1, A add0-mod2, A add0-mod3, A add0-mod4, A add0-rm1, A add0-rm2, A add0-rm4
 
   $ hg grep --diff -fr'wdir()' data add0-cp4 add0-mod4 add0-mod3
   add0-mod4:2147483647:+:data4
   add0-mod3:3:+:data3
   add0:0:+:data0
   add0-mod3:0:+:data0
   add0-mod4:0:+:data0
 
  BROKEN: should follow history across renames
   $ hg grep -fr'wdir()' data add0-cp4 add0-mod4 add0-mod3
   add0-cp4:2147483647:data0
   add0-mod3:2147483647:data0
   add0-mod3:2147483647:data3
   add0-mod4:2147483647:data0
   add0-mod4:2147483647:data4
   add0-mod3:3:data0
   add0-mod3:3:data3
   add0-mod4:3:data0
   add0-mod3:1:data0
   add0-mod4:1:data0
   add0-mod3:0:data0
   add0-mod4:0:data0
 
   $ cd ..

tests/test-log-linerange.t

@@ -1,1153 +1,1153 b''
   $ cat >> $HGRCPATH << EOF
   > [diff]
   > git = true
   > EOF
 
   $ hg init
   $ cat > foo << EOF
   > 0
   > 1
   > 2
   > 3
   > 4
   > EOF
   $ hg ci -Am init
   adding foo
   $ cat > foo << EOF
   > 0
   > 0
   > 0
   > 0
   > 1
   > 2
   > 3
   > 4
   > EOF
   $ hg ci -m 'more 0'
   $ sed 's/2/2+/' foo > foo.new
   $ mv foo.new foo
   $ cat > bar << EOF
   > a
   > b
   > c
   > d
   > e
   > EOF
   $ hg add bar
   $ hg ci -Am "2 -> 2+; added bar"
   $ cat >> foo << EOF
   > 5
   > 6
   > 7
   > 8
   > 9
   > 10
   > 11
   > EOF
   $ hg ci -m "to 11"
 
 Add some changes with two diff hunks
 
   $ sed 's/^1$/ 1/' foo > foo.new
   $ mv foo.new foo
   $ sed 's/^11$/11+/' foo > foo.new
   $ mv foo.new foo
   $ hg ci -m '11 -> 11+; leading space before "1"'
 (make sure there are two hunks in "foo")
   $ hg diff -c .
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -2,7 +2,7 @@
    0
    0
    0
   -1
   + 1
    2+
    3
    4
   @@ -12,4 +12,4 @@
    8
    9
    10
   -11
   +11+
   $ sed 's/3/3+/' foo > foo.new
   $ mv foo.new foo
   $ sed 's/^11+$/11-/' foo > foo.new
   $ mv foo.new foo
   $ sed 's/a/a+/' bar > bar.new
   $ mv bar.new bar
   $ hg ci -m 'foo: 3 -> 3+ and 11+ -> 11-; bar: a -> a+'
 (make sure there are two hunks in "foo")
   $ hg diff -c . foo
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -4,7 +4,7 @@
    0
     1
    2+
   -3
   +3+
    4
    5
    6
   @@ -12,4 +12,4 @@
    8
    9
    10
   -11+
   +11-
 
   $ hg log -f -L foo,5:7 -p
   changeset:   5:cfdf972b3971
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     foo: 3 -> 3+ and 11+ -> 11-; bar: a -> a+
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -4,7 +4,7 @@
    0
     1
    2+
   -3
   +3+
    4
    5
    6
   
   changeset:   4:eaec41c1a0c9
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     11 -> 11+; leading space before "1"
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -2,7 +2,7 @@
    0
    0
    0
   -1
   + 1
    2+
    3
    4
   
   changeset:   2:63a884426fd0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2 -> 2+; added bar
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -3,6 +3,6 @@
    0
    0
    1
   -2
   +2+
    3
    4
   
   changeset:   0:5ae1f82b9a00
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     init
   
   diff --git a/foo b/foo
   new file mode 100644
   --- /dev/null
   +++ b/foo
   @@ -0,0 +1,5 @@
   +0
   +1
   +2
   +3
   +4
   
   $ hg log -f --graph -L foo,5:7 -p
   @  changeset:   5:cfdf972b3971
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     foo: 3 -> 3+ and 11+ -> 11-; bar: a -> a+
   |
   |  diff --git a/foo b/foo
   |  --- a/foo
   |  +++ b/foo
   |  @@ -4,7 +4,7 @@
   |   0
   |    1
   |   2+
   |  -3
   |  +3+
   |   4
   |   5
   |   6
   |
   o  changeset:   4:eaec41c1a0c9
   :  user:        test
   :  date:        Thu Jan 01 00:00:00 1970 +0000
   :  summary:     11 -> 11+; leading space before "1"
   :
   :  diff --git a/foo b/foo
   :  --- a/foo
   :  +++ b/foo
   :  @@ -2,7 +2,7 @@
   :   0
   :   0
   :   0
   :  -1
   :  + 1
   :   2+
   :   3
   :   4
   :
   o  changeset:   2:63a884426fd0
   :  user:        test
   :  date:        Thu Jan 01 00:00:00 1970 +0000
   :  summary:     2 -> 2+; added bar
   :
   :  diff --git a/foo b/foo
   :  --- a/foo
   :  +++ b/foo
   :  @@ -3,6 +3,6 @@
   :   0
   :   0
   :   1
   :  -2
   :  +2+
   :   3
   :   4
   :
   o  changeset:   0:5ae1f82b9a00
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     init
   
      diff --git a/foo b/foo
      new file mode 100644
      --- /dev/null
      +++ b/foo
      @@ -0,0 +1,5 @@
      +0
      +1
      +2
      +3
      +4
   
 
 With --template.
 
   $ hg log -f -L foo,5:7 -T '{rev}:{node|short} {desc|firstline}\n'
   5:cfdf972b3971 foo: 3 -> 3+ and 11+ -> 11-; bar: a -> a+
   4:eaec41c1a0c9 11 -> 11+; leading space before "1"
   2:63a884426fd0 2 -> 2+; added bar
   0:5ae1f82b9a00 init
   $ hg log -f -L foo,5:7 -T json
   [
    {
     "bookmarks": [],
     "branch": "default",
     "date": [0, 0],
     "desc": "foo: 3 -> 3+ and 11+ -> 11-; bar: a -> a+",
     "node": "cfdf972b3971a2a59638bf9583c0debbffee5404",
     "parents": ["eaec41c1a0c9ad0a5e999611d0149d171beffb8c"],
     "phase": "draft",
     "rev": 5,
     "tags": ["tip"],
     "user": "test"
    },
    {
     "bookmarks": [],
     "branch": "default",
     "date": [0, 0],
     "desc": "11 -> 11+; leading space before \"1\"",
     "node": "eaec41c1a0c9ad0a5e999611d0149d171beffb8c",
     "parents": ["730a61fbaecf426c17c2c66bc42d195b5d5b0ba8"],
     "phase": "draft",
     "rev": 4,
     "tags": [],
     "user": "test"
    },
    {
     "bookmarks": [],
     "branch": "default",
     "date": [0, 0],
     "desc": "2 -> 2+; added bar",
     "node": "63a884426fd0b277fcd55895bbb2f230434576eb",
     "parents": ["29a1e7c6b80024f63f310a2d71de979e9d2996d7"],
     "phase": "draft",
     "rev": 2,
     "tags": [],
     "user": "test"
    },
    {
     "bookmarks": [],
     "branch": "default",
     "date": [0, 0],
     "desc": "init",
     "node": "5ae1f82b9a000ff1e0967d0dac1c58b9d796e1b4",
     "parents": ["0000000000000000000000000000000000000000"],
     "phase": "draft",
     "rev": 0,
     "tags": [],
     "user": "test"
    }
   ]
 
 With some white-space diff option, respective revisions are skipped.
 
   $ hg log -f -L foo,5:7 -p --config diff.ignorews=true
   changeset:   5:cfdf972b3971
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     foo: 3 -> 3+ and 11+ -> 11-; bar: a -> a+
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -4,7 +4,7 @@
    0
     1
    2+
   -3
   +3+
    4
    5
    6
   
   changeset:   2:63a884426fd0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2 -> 2+; added bar
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -3,6 +3,6 @@
    0
    0
    1
   -2
   +2+
    3
    4
   
   changeset:   0:5ae1f82b9a00
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     init
   
   diff --git a/foo b/foo
   new file mode 100644
   --- /dev/null
   +++ b/foo
   @@ -0,0 +1,5 @@
   +0
   +1
   +2
   +3
   +4
   
 
 Regular file patterns are not allowed.
 
   $ hg log -f -L foo,5:7 -p bar
   abort: FILE arguments are not compatible with --line-range option
   [10]
 
 Option --rev acts as a restriction.
 
   $ hg log -f -L foo,5:7 -p -r 'desc(2)'
   changeset:   2:63a884426fd0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2 -> 2+; added bar
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -3,6 +3,6 @@
    0
    0
    1
   -2
   +2+
    3
    4
   
   changeset:   0:5ae1f82b9a00
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     init
   
   diff --git a/foo b/foo
   new file mode 100644
   --- /dev/null
   +++ b/foo
   @@ -0,0 +1,5 @@
   +0
   +1
   +2
   +3
   +4
   
 
 With several -L patterns, changes touching any files in their respective line
 range are show.
 
   $ hg log -f -L foo,5:7 -L bar,1:2 -p
   changeset:   5:cfdf972b3971
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     foo: 3 -> 3+ and 11+ -> 11-; bar: a -> a+
   
   diff --git a/bar b/bar
   --- a/bar
   +++ b/bar
   @@ -1,4 +1,4 @@
   -a
   +a+
    b
    c
    d
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -4,7 +4,7 @@
    0
     1
    2+
   -3
   +3+
    4
    5
    6
   
   changeset:   4:eaec41c1a0c9
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     11 -> 11+; leading space before "1"
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -2,7 +2,7 @@
    0
    0
    0
   -1
   + 1
    2+
    3
    4
   
   changeset:   2:63a884426fd0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2 -> 2+; added bar
   
   diff --git a/bar b/bar
   new file mode 100644
   --- /dev/null
   +++ b/bar
   @@ -0,0 +1,5 @@
   +a
   +b
   +c
   +d
   +e
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -3,6 +3,6 @@
    0
    0
    1
   -2
   +2+
    3
    4
   
   changeset:   0:5ae1f82b9a00
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     init
   
   diff --git a/foo b/foo
   new file mode 100644
   --- /dev/null
   +++ b/foo
   @@ -0,0 +1,5 @@
   +0
   +1
   +2
   +3
   +4
   
 
 Multiple -L options with the same file yields changes touching any of
 specified line ranges.
 
   $ hg log -f -L foo,5:7 -L foo,14:15 -p
   changeset:   5:cfdf972b3971
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     foo: 3 -> 3+ and 11+ -> 11-; bar: a -> a+
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -4,7 +4,7 @@
    0
     1
    2+
   -3
   +3+
    4
    5
    6
   @@ -12,4 +12,4 @@
    8
    9
    10
   -11+
   +11-
   
   changeset:   4:eaec41c1a0c9
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     11 -> 11+; leading space before "1"
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -2,7 +2,7 @@
    0
    0
    0
   -1
   + 1
    2+
    3
    4
   @@ -12,4 +12,4 @@
    8
    9
    10
   -11
   +11+
   
   changeset:   3:730a61fbaecf
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     to 11
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -6,3 +6,10 @@
    2+
    3
    4
   +5
   +6
   +7
   +8
   +9
   +10
   +11
   
   changeset:   2:63a884426fd0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2 -> 2+; added bar
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -3,6 +3,6 @@
    0
    0
    1
   -2
   +2+
    3
    4
   
   changeset:   0:5ae1f82b9a00
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     init
   
   diff --git a/foo b/foo
   new file mode 100644
   --- /dev/null
   +++ b/foo
   @@ -0,0 +1,5 @@
   +0
   +1
   +2
   +3
   +4
   
 
 A file with a comma in its name.
 
   $ cat > ba,z << EOF
   > q
   > w
   > e
   > r
   > t
   > y
   > EOF
   $ hg ci -Am 'querty'
   adding ba,z
   $ cat >> ba,z << EOF
   > u
   > i
   > o
   > p
   > EOF
   $ hg ci -m 'more keys'
   $ cat > ba,z << EOF
   > a
   > z
   > e
   > r
   > t
   > y
   > u
   > i
   > o
   > p
   > EOF
   $ hg ci -m 'azerty'
   $ hg log -f -L ba,z,1:2 -p
   changeset:   8:52373265138b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     azerty
   
   diff --git a/ba,z b/ba,z
   --- a/ba,z
   +++ b/ba,z
   @@ -1,5 +1,5 @@
   -q
   -w
   +a
   +z
    e
    r
    t
   
   changeset:   6:96ba8850f316
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     querty
   
   diff --git a/ba,z b/ba,z
   new file mode 100644
   --- /dev/null
   +++ b/ba,z
   @@ -0,0 +1,6 @@
   +q
   +w
   +e
   +r
   +t
   +y
   
 
 Exact prefix kinds work in -L options.
 
   $ mkdir dir
   $ cd dir
   $ hg log -f -L path:foo,5:7 -p
   changeset:   5:cfdf972b3971
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     foo: 3 -> 3+ and 11+ -> 11-; bar: a -> a+
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -4,7 +4,7 @@
    0
     1
    2+
   -3
   +3+
    4
    5
    6
   
   changeset:   4:eaec41c1a0c9
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     11 -> 11+; leading space before "1"
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -2,7 +2,7 @@
    0
    0
    0
   -1
   + 1
    2+
    3
    4
   
   changeset:   2:63a884426fd0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2 -> 2+; added bar
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -3,6 +3,6 @@
    0
    0
    1
   -2
   +2+
    3
    4
   
   changeset:   0:5ae1f82b9a00
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     init
   
   diff --git a/foo b/foo
   new file mode 100644
   --- /dev/null
   +++ b/foo
   @@ -0,0 +1,5 @@
   +0
   +1
   +2
   +3
   +4
   
 
 Renames are followed.
 
   $ hg mv ../foo baz
   $ sed 's/1/1+/' baz > baz.new
   $ mv baz.new baz
   $ hg ci -m 'foo -> dir/baz; 1-1+'
   $ hg diff -c .
   diff --git a/foo b/dir/baz
   rename from foo
   rename to dir/baz
   --- a/foo
   +++ b/dir/baz
   @@ -2,7 +2,7 @@
    0
    0
    0
   - 1
   + 1+
    2+
    3+
    4
   @@ -11,5 +11,5 @@
    7
    8
    9
   -10
   -11-
   +1+0
   +1+1-
   $ hg log -f -L relpath:baz,5:7 -p
   changeset:   9:6af29c3a778f
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     foo -> dir/baz; 1-1+
   
   diff --git a/foo b/dir/baz
   copy from foo
   copy to dir/baz
   --- a/foo
   +++ b/dir/baz
   @@ -2,7 +2,7 @@
    0
    0
    0
   - 1
   + 1+
    2+
    3+
    4
   
   changeset:   5:cfdf972b3971
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     foo: 3 -> 3+ and 11+ -> 11-; bar: a -> a+
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -4,7 +4,7 @@
    0
     1
    2+
   -3
   +3+
    4
    5
    6
   
   changeset:   4:eaec41c1a0c9
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     11 -> 11+; leading space before "1"
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -2,7 +2,7 @@
    0
    0
    0
   -1
   + 1
    2+
    3
    4
   
   changeset:   2:63a884426fd0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2 -> 2+; added bar
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -3,6 +3,6 @@
    0
    0
    1
   -2
   +2+
    3
    4
   
   changeset:   0:5ae1f82b9a00
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     init
   
   diff --git a/foo b/foo
   new file mode 100644
   --- /dev/null
   +++ b/foo
   @@ -0,0 +1,5 @@
   +0
   +1
   +2
   +3
   +4
   
 
 Uncommitted changes with a rename
 
   $ hg mv baz bazn
   $ hg log -f -L bazn,5:7
   changeset:   9:6af29c3a778f
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     foo -> dir/baz; 1-1+
   
   changeset:   5:cfdf972b3971
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     foo: 3 -> 3+ and 11+ -> 11-; bar: a -> a+
   
   changeset:   4:eaec41c1a0c9
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     11 -> 11+; leading space before "1"
   
   changeset:   2:63a884426fd0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2 -> 2+; added bar
   
   changeset:   0:5ae1f82b9a00
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     init
   
 
 Uncommitted changes in requested line range
 
   $ sed 's/2/  /' bazn > bazn.new
   $ mv bazn.new bazn
   $ hg diff
   diff --git a/dir/baz b/dir/bazn
   rename from dir/baz
   rename to dir/bazn
   --- a/dir/baz
   +++ b/dir/bazn
   @@ -3,7 +3,7 @@
    0
    0
     1+
   -2+
   +  +
    3+
    4
    5
   $ hg log -f -L bazn,5:7
   changeset:   9:6af29c3a778f
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     foo -> dir/baz; 1-1+
   
   changeset:   5:cfdf972b3971
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     foo: 3 -> 3+ and 11+ -> 11-; bar: a -> a+
   
   changeset:   4:eaec41c1a0c9
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     11 -> 11+; leading space before "1"
   
   changeset:   2:63a884426fd0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2 -> 2+; added bar
   
   changeset:   0:5ae1f82b9a00
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     init
   
 
 Uncommitted changes in line-range + wdir()
 
   $ hg log -r 'wdir()' -f -L bazn,5:7 --limit 2 -p
   changeset:   2147483647:ffffffffffff
   parent:      9:6af29c3a778f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   
   diff --git a/dir/baz b/dir/bazn
   copy from dir/baz
   copy to dir/bazn
   --- a/dir/baz
   +++ b/dir/bazn
   @@ -3,7 +3,7 @@
    0
    0
     1+
   -2+
   +  +
    3+
    4
    5
   
   changeset:   9:6af29c3a778f
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     foo -> dir/baz; 1-1+
   
   diff --git a/foo b/dir/baz
   copy from foo
   copy to dir/baz
   --- a/foo
   +++ b/dir/baz
   @@ -2,7 +2,7 @@
    0
    0
    0
   - 1
   + 1+
    2+
    3+
    4
   
 
   $ hg revert -a -C -q
 
 Copies.
 
   $ hg copy baz bbaz
   $ sed 's/6/6+/' bbaz > bbaz.new
   $ mv bbaz.new bbaz
   $ hg commit -m 'cp baz bbaz; 6-6+'
   $ hg diff -c .
   diff --git a/dir/baz b/dir/bbaz
   copy from dir/baz
   copy to dir/bbaz
   --- a/dir/baz
   +++ b/dir/bbaz
   @@ -7,7 +7,7 @@
    3+
    4
    5
   -6
   +6+
    7
    8
    9
   $ hg log --copies -f -L bbaz,10:11 -p
   changeset:   10:91a3d3b6c546
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     cp baz bbaz; 6-6+
   
   diff --git a/dir/baz b/dir/bbaz
   copy from dir/baz
   copy to dir/bbaz
   --- a/dir/baz
   +++ b/dir/bbaz
   @@ -7,7 +7,7 @@
    3+
    4
    5
   -6
   +6+
    7
    8
    9
   
   changeset:   3:730a61fbaecf
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     to 11
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -6,3 +6,10 @@
    2+
    3
    4
   +5
   +6
   +7
   +8
   +9
   +10
   +11
   
   $ hg log -f -L bbaz,10:11 -p
   changeset:   10:91a3d3b6c546
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     cp baz bbaz; 6-6+
   
   diff --git a/dir/baz b/dir/bbaz
   copy from dir/baz
   copy to dir/bbaz
   --- a/dir/baz
   +++ b/dir/bbaz
   @@ -7,7 +7,7 @@
    3+
    4
    5
   -6
   +6+
    7
    8
    9
   
   changeset:   3:730a61fbaecf
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     to 11
   
   diff --git a/foo b/foo
   --- a/foo
   +++ b/foo
   @@ -6,3 +6,10 @@
    2+
    3
    4
   +5
   +6
   +7
   +8
   +9
   +10
   +11
   
 
 Binary files work but without diff hunks filtering.
 (Checking w/ and w/o diff.git option.)
 
   >>> open('binary', 'wb').write(b'this\nis\na\nbinary\0') and None
   $ hg add binary
   $ hg ci -m 'add a binary file' --quiet
   $ hg log -f -L binary,1:2 -p
   changeset:   11:dc865b608edf
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add a binary file
   
   diff --git a/dir/binary b/dir/binary
   new file mode 100644
   index 0000000000000000000000000000000000000000..c2e1fbed209fe919b3f189a6a31950e9adf61e45
   GIT binary patch
   literal 17
   Wc$_QA$SmdpqC~Ew%)G>+N(KNlNClYy
   
   
   $ hg log -f -L binary,1:2 -p --config diff.git=false
   changeset:   11:dc865b608edf
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add a binary file
   
   diff -r 91a3d3b6c546 -r dc865b608edf dir/binary
   Binary file dir/binary has changed
   
 
 Option --follow is required.
 
   $ hg log -L foo,5:7
   abort: --line-range requires --follow
   [10]
 
 Non-exact pattern kinds are not allowed.
 
   $ cd ..
   $ hg log -f -L glob:*a*,1:2
   hg: parse error: line range pattern 'glob:*a*' must match exactly one file
   [10]
 
 We get an error for removed files.
 
   $ hg rm dir/baz
   $ hg ci -m 'remove baz' --quiet
   $ hg log -f -L dir/baz,5:7 -p
   abort: cannot follow file not in parent revision: "dir/baz"
-  [255]
+  [20]

tests/test-log.t

@@ -1,2971 +1,2971 b''
 Log on empty repository: checking consistency
 
   $ hg init empty
   $ cd empty
   $ hg log
   $ hg log -r 1
   abort: unknown revision '1'
   [10]
   $ hg log -r -1:0
   abort: unknown revision '-1'
   [10]
   $ hg log -r 'branch(name)'
   abort: unknown revision 'name'
   [10]
   $ hg log -r null -q
   -1:000000000000
 
   $ cd ..
 
 The g is crafted to have 2 filelog topological heads in a linear
 changeset graph
 
   $ hg init a
   $ cd a
   $ echo a > a
   $ echo f > f
   $ hg ci -Ama -d '1 0'
   adding a
   adding f
 
   $ hg cp a b
   $ hg cp f g
   $ hg ci -mb -d '2 0'
 
   $ mkdir dir
   $ hg mv b dir
   $ echo g >> g
   $ echo f >> f
   $ hg ci -mc -d '3 0'
 
   $ hg mv a b
   $ hg cp -f f g
   $ echo a > d
   $ hg add d
   $ hg ci -md -d '4 0'
 
   $ hg mv dir/b e
   $ hg ci -me -d '5 0'
 
 Make sure largefiles doesn't interfere with logging a regular file
   $ hg --debug log a -T '{rev}: {desc}\n' --config extensions.largefiles=
   The fsmonitor extension is incompatible with the largefiles extension and has been disabled. (fsmonitor !)
   updated patterns: .hglf/a, a
   0: a
   $ hg log a
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
   $ hg log glob:a*
   changeset:   3:2ca5ba701980
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   summary:     d
   
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
   $ hg --debug log glob:a* -T '{rev}: {desc}\n' --config extensions.largefiles=
   The fsmonitor extension is incompatible with the largefiles extension and has been disabled. (fsmonitor !)
   updated patterns: glob:.hglf/a*, glob:a*
   3: d
   0: a
 
 log on directory
 
   $ hg log dir
   changeset:   4:7e4639b4691b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   summary:     e
   
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
   $ hg log somethingthatdoesntexist dir
   changeset:   4:7e4639b4691b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   summary:     e
   
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
 
 log empty path (or repo root) of slow path shouldn't crash (issue6478)
 
   $ hg log -ql1 '' inexistent
   4:7e4639b4691b
   $ hg log -ql1 . inexistent
   4:7e4639b4691b
   $ hg log -ql1 "`pwd`" inexistent
   4:7e4639b4691b
 
   $ hg log -ql1 '' e
   4:7e4639b4691b
   $ hg log -ql1 . e
   4:7e4639b4691b
   $ hg log -ql1 "`pwd`" e
   4:7e4639b4691b
 
 log -f empty path (or repo root) shouldn't crash
 
   $ hg log -qfl1 '' inexistent
   abort: cannot follow file not in parent revision: "inexistent"
-  [255]
+  [20]
   $ hg log -qfl1 . inexistent
   abort: cannot follow file not in parent revision: "inexistent"
-  [255]
+  [20]
   $ hg log -qfl1 "`pwd`" inexistent
   abort: cannot follow file not in parent revision: "inexistent"
-  [255]
+  [20]
 
   $ hg log -qfl1 '' e
   4:7e4639b4691b
   $ hg log -qfl1 . e
   4:7e4639b4691b
   $ hg log -qfl1 "`pwd`" e
   4:7e4639b4691b
 
 -X, with explicit path
 
   $ hg log a -X a
 
 -f, non-existent directory
 
   $ hg log -f dir
   abort: cannot follow file not in parent revision: "dir"
-  [255]
+  [20]
 
 -f, directory
 
   $ hg up -q 3
   $ hg log -f dir
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
 -f, directory with --patch
 
   $ hg log -f dir -p
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
   diff -r d89b0a12d229 -r f8954cd4dc1f dir/b
   --- /dev/null* (glob)
   +++ b/dir/b* (glob)
   @@ -0,0 +1,1 @@
   +a
   
 
 -f, pattern
 
   $ hg log -f -I 'dir**' -p
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
   diff -r d89b0a12d229 -r f8954cd4dc1f dir/b
   --- /dev/null* (glob)
   +++ b/dir/b* (glob)
   @@ -0,0 +1,1 @@
   +a
   
   $ hg up -q 4
 
 -f, a wrong style
 
   $ hg log -f -l1 --style something
   abort: style 'something' not found
   (available styles: bisect, changelog, compact, default, phases, show, status, xml)
   [255]
 
 -f, phases style
 
 
   $ hg log -f -l1 --style phases
   changeset:   4:7e4639b4691b
   tag:         tip
   phase:       draft
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   summary:     e
   
 
   $ hg log -f -l1 --style phases -q
   4:7e4639b4691b
 
 -f, but no args
 
   $ hg log -f
   changeset:   4:7e4639b4691b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   summary:     e
   
   changeset:   3:2ca5ba701980
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   summary:     d
   
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
   changeset:   1:d89b0a12d229
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   summary:     b
   
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
 
 one rename
 
   $ hg up -q 2
   $ hg log -vf a
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   files:       a f
   description:
   a
   
   
 
 many renames
 
   $ hg up -q tip
   $ hg log -vf e
   changeset:   4:7e4639b4691b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   files:       dir/b e
   description:
   e
   
   
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   files:       b dir/b f g
   description:
   c
   
   
   changeset:   1:d89b0a12d229
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   files:       b g
   description:
   b
   
   
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   files:       a f
   description:
   a
   
   
 
 
 log -pf dir/b
 
   $ hg up -q 3
   $ hg log -pf dir/b
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
   diff -r d89b0a12d229 -r f8954cd4dc1f dir/b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/dir/b	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   changeset:   1:d89b0a12d229
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   summary:     b
   
   diff -r 9161b9aeaf16 -r d89b0a12d229 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
   diff -r 000000000000 -r 9161b9aeaf16 a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
 
 log -pf b inside dir
 
   $ hg --cwd=dir log -pf b
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
   diff -r d89b0a12d229 -r f8954cd4dc1f dir/b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/dir/b	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   changeset:   1:d89b0a12d229
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   summary:     b
   
   diff -r 9161b9aeaf16 -r d89b0a12d229 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
   diff -r 000000000000 -r 9161b9aeaf16 a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
 
 log -pf, but no args
 
   $ hg log -pf
   changeset:   3:2ca5ba701980
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   summary:     d
   
   diff -r f8954cd4dc1f -r 2ca5ba701980 a
   --- a/a	Thu Jan 01 00:00:03 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -a
   diff -r f8954cd4dc1f -r 2ca5ba701980 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r f8954cd4dc1f -r 2ca5ba701980 d
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/d	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r f8954cd4dc1f -r 2ca5ba701980 g
   --- a/g	Thu Jan 01 00:00:03 1970 +0000
   +++ b/g	Thu Jan 01 00:00:04 1970 +0000
   @@ -1,2 +1,2 @@
    f
   -g
   +f
   
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     c
   
   diff -r d89b0a12d229 -r f8954cd4dc1f b
   --- a/b	Thu Jan 01 00:00:02 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -a
   diff -r d89b0a12d229 -r f8954cd4dc1f dir/b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/dir/b	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r d89b0a12d229 -r f8954cd4dc1f f
   --- a/f	Thu Jan 01 00:00:02 1970 +0000
   +++ b/f	Thu Jan 01 00:00:03 1970 +0000
   @@ -1,1 +1,2 @@
    f
   +f
   diff -r d89b0a12d229 -r f8954cd4dc1f g
   --- a/g	Thu Jan 01 00:00:02 1970 +0000
   +++ b/g	Thu Jan 01 00:00:03 1970 +0000
   @@ -1,1 +1,2 @@
    f
   +g
   
   changeset:   1:d89b0a12d229
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   summary:     b
   
   diff -r 9161b9aeaf16 -r d89b0a12d229 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r 9161b9aeaf16 -r d89b0a12d229 g
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/g	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +f
   
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     a
   
   diff -r 000000000000 -r 9161b9aeaf16 a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r 000000000000 -r 9161b9aeaf16 f
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/f	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +f
   
 
 log -vf dir/b
 
   $ hg log -vf dir/b
   changeset:   2:f8954cd4dc1f
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   files:       b dir/b f g
   description:
   c
   
   
   changeset:   1:d89b0a12d229
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   files:       b g
   description:
   b
   
   
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   files:       a f
   description:
   a
   
   
 Respects ui.logtemplate and command-templates.log configs (the latter takes
 precedence)
 
   $ hg log -r 0 --config ui.logtemplate="foo {rev}\n"
   foo 0
   $ hg log -r 0 --config command-templates.log="bar {rev}\n"
   bar 0
   $ hg log -r 0 --config ui.logtemplate="foo {rev}\n" \
   > --config command-templates.log="bar {rev}\n"
   bar 0
 
 
 -f and multiple filelog heads
 
   $ hg up -q 2
   $ hg log -f g --template '{rev}\n'
   2
   1
   0
   $ hg up -q tip
   $ hg log -f g --template '{rev}\n'
   3
   2
   0
 
 follow files from the specified revisions (issue4959)
 
   $ hg log -G -T '{rev} {files},{file_copies % " {source}->{name}"}\n'
   @  4 dir/b e, dir/b->e
   |
   o  3 a b d g, a->b f->g
   |
   o  2 b dir/b f g, b->dir/b
   |
   o  1 b g, a->b f->g
   |
   o  0 a f,
   
 
   $ hg log -T '{rev}\n' -fr 4 e
   4
   2
   1
   0
   $ hg log -T '{rev}\n' -fr 2 g
   2
   1
   0
   $ hg log -T '{rev}\n' -fr '2+3' g
   3
   2
   1
   0
 
 follow files from the specified revisions with glob patterns (issue5053)
 (BROKEN: should follow copies from e@4)
 
   $ hg log -T '{rev}\n' -fr4 e -X '[abcdfg]'
   4
   2 (false !)
   1 (false !)
   0 (false !)
 
 follow files from the specified revisions with missing patterns
 
   $ hg log -T '{rev}\n' -fr4 e x
   abort: cannot follow file not in any of the specified revisions: "x"
-  [255]
+  [20]
 
 follow files from the specified revisions with directory patterns
 (BROKEN: should follow copies from dir/b@2)
 
   $ hg log -T '{rev}\n' -fr2 dir/b dir
   2
   1 (false !)
   0 (false !)
 
 follow files from multiple revisions, but the pattern is missing in
 one of the specified revisions
 
   $ hg log -T '{rev}\n' -fr'2+4' dir/b e
   e: no such file in rev f8954cd4dc1f
   dir/b: no such file in rev 7e4639b4691b
   4
   2
   1
   0
 
 follow files from multiple revisions, and the pattern matches a file in
 one revision but matches a directory in another:
 (BROKEN: should follow copies from dir/b@2 and dir/b/g@5)
 (BROKEN: the revision 4 should not be included since dir/b/g@5 is unchanged)
 
   $ mkdir -p dir/b
   $ hg mv g dir/b
   $ hg ci -m 'make dir/b a directory'
 
   $ hg log -T '{rev}\n' -fr'2+5' dir/b
   5
   4
   3 (false !)
   2
   1 (false !)
   0 (false !)
 
   $ hg --config extensions.strip= strip -r. --no-backup
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 follow files from the specified revisions across copies with -p/--patch
 
   $ hg log -T '== rev: {rev},{file_copies % " {source}->{name}"} ==\n' -fpr 4 e g
   == rev: 4, dir/b->e ==
   diff -r 2ca5ba701980 -r 7e4639b4691b e
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/e	Thu Jan 01 00:00:05 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   == rev: 3, a->b f->g ==
   diff -r f8954cd4dc1f -r 2ca5ba701980 g
   --- a/g	Thu Jan 01 00:00:03 1970 +0000
   +++ b/g	Thu Jan 01 00:00:04 1970 +0000
   @@ -1,2 +1,2 @@
    f
   -g
   +f
   
   == rev: 2, b->dir/b ==
   diff -r d89b0a12d229 -r f8954cd4dc1f dir/b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/dir/b	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r d89b0a12d229 -r f8954cd4dc1f f
   --- a/f	Thu Jan 01 00:00:02 1970 +0000
   +++ b/f	Thu Jan 01 00:00:03 1970 +0000
   @@ -1,1 +1,2 @@
    f
   +f
   
   == rev: 1, a->b f->g ==
   diff -r 9161b9aeaf16 -r d89b0a12d229 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   == rev: 0, ==
   diff -r 000000000000 -r 9161b9aeaf16 a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   diff -r 000000000000 -r 9161b9aeaf16 f
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/f	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +f
   
 
 log copies with --copies
 
   $ hg log -vC --template '{rev} {file_copies}\n'
   4 e (dir/b)
   3 b (a)g (f)
   2 dir/b (b)
   1 b (a)g (f)
   0 
 
 log copies switch without --copies, with old filecopy template
 
   $ hg log -v --template '{rev} {file_copies_switch%filecopy}\n'
   4 
   3 
   2 
   1 
   0 
 
 log copies switch with --copies
 
   $ hg log -vC --template '{rev} {file_copies_switch}\n'
   4 e (dir/b)
   3 b (a)g (f)
   2 dir/b (b)
   1 b (a)g (f)
   0 
 
 
 log copies with hardcoded style and with --style=default
 
   $ hg log -vC -r4
   changeset:   4:7e4639b4691b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   files:       dir/b e
   copies:      e (dir/b)
   description:
   e
   
   
   $ hg log -vC -r4 --style=default
   changeset:   4:7e4639b4691b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   files:       dir/b e
   copies:      e (dir/b)
   description:
   e
   
   
   $ hg log -vC -r4 -Tjson
   [
    {
     "bookmarks": [],
     "branch": "default",
     "copies": {"e": "dir/b"},
     "date": [5, 0],
     "desc": "e",
     "files": ["dir/b", "e"],
     "node": "7e4639b4691b9f84b81036a8d4fb218ce3c5e3a3",
     "parents": ["2ca5ba7019804f1f597249caddf22a64d34df0ba"],
     "phase": "draft",
     "rev": 4,
     "tags": ["tip"],
     "user": "test"
    }
   ]
 
 log copies, non-linear manifest
 
   $ hg up -C 3
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg mv dir/b e
   $ echo foo > foo
   $ hg ci -Ame2 -d '6 0'
   adding foo
   created new head
   $ hg log -v --template '{rev} {file_copies}\n' -r 5
   5 e (dir/b)
 
 
 log copies, execute bit set
 
 #if execbit
   $ chmod +x e
   $ hg ci -me3 -d '7 0'
   $ hg log -v --template '{rev} {file_copies}\n' -r 6
   6 
 #endif
 
 log copies, empty set
 
   $ hg log --copies -r '0 and not 0'
 
 log -p d
 
   $ hg log -pv d
   changeset:   3:2ca5ba701980
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   files:       a b d g
   description:
   d
   
   
   diff -r f8954cd4dc1f -r 2ca5ba701980 d
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/d	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
 
 
 log --removed file
 
   $ hg log --removed -v a
   changeset:   3:2ca5ba701980
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   files:       a b d g
   description:
   d
   
   
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   files:       a f
   description:
   a
   
   
 
 log --removed revrange file
 
   $ hg log --removed -v -r0:2 a
   changeset:   0:9161b9aeaf16
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   files:       a f
   description:
   a
   
   
   $ cd ..
 
 log --follow tests
 
   $ hg init follow
   $ cd follow
 
   $ echo base > base
   $ hg ci -Ambase -d '1 0'
   adding base
 
   $ echo r1 >> base
   $ hg ci -Amr1 -d '1 0'
   $ echo r2 >> base
   $ hg ci -Amr2 -d '1 0'
 
   $ hg up -C 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo b1 > b1
 
 log -r "follow('set:clean()')"
 
   $ hg log -r "follow('set:clean()')"
   changeset:   0:67e992f2c4f3
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     base
   
   changeset:   1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     r1
   
 
   $ hg ci -Amb1 -d '1 0'
   adding b1
   created new head
 
 
 log -f
 
   $ hg log -f
   changeset:   3:e62f78d544b4
   tag:         tip
   parent:      1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1
   
   changeset:   1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     r1
   
   changeset:   0:67e992f2c4f3
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     base
   
 
 log -r follow('glob:b*')
 
   $ hg log -r "follow('glob:b*')"
   changeset:   0:67e992f2c4f3
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     base
   
   changeset:   1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     r1
   
   changeset:   3:e62f78d544b4
   tag:         tip
   parent:      1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1
   
 log -f -r '1 + 4'
 
   $ hg up -C 0
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo b2 > b2
   $ hg ci -Amb2 -d '1 0'
   adding b2
   created new head
   $ hg log -f -r '1 + 4'
   changeset:   4:ddb82e70d1a1
   tag:         tip
   parent:      0:67e992f2c4f3
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b2
   
   changeset:   1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     r1
   
   changeset:   0:67e992f2c4f3
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     base
   
 
 log -fr with aliases: 'A' should be expanded, but 'reverse()' should have no
 effect
 
   $ hg log --config 'revsetalias.reverse(x)=x' --config 'revsetalias.A=1+4' -qfrA
   4:ddb82e70d1a1
   1:3d5bf5654eda
   0:67e992f2c4f3
 
 log -r "follow('set:grep(b2)')"
 
   $ hg log -r "follow('set:grep(b2)')"
   changeset:   4:ddb82e70d1a1
   tag:         tip
   parent:      0:67e992f2c4f3
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b2
   
 log -r "follow('set:grep(b2)', 4)"
 
   $ hg up -qC 0
   $ hg log -r "follow('set:grep(b2)', 4)"
   changeset:   4:ddb82e70d1a1
   tag:         tip
   parent:      0:67e992f2c4f3
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b2
   
 
 follow files starting from multiple revisions:
 
   $ hg log -T '{rev}: {files}\n' -r "follow('glob:b?', startrev=2+3+4)"
   3: b1
   4: b2
 
 follow files starting from empty revision:
 
   $ hg log -T '{rev}: {files}\n' -r "follow('glob:*', startrev=.-.)"
 
 follow starting from revisions:
 
   $ hg log -Gq -r "follow(startrev=2+4)"
   o  4:ddb82e70d1a1
   |
   | o  2:60c670bf5b30
   | |
   | o  1:3d5bf5654eda
   |/
   @  0:67e992f2c4f3
   
 
 follow the current revision:
 
   $ hg log -Gq -r "follow()"
   @  0:67e992f2c4f3
   
 
   $ hg up -qC 4
 
 log -f -r null
 
   $ hg log -f -r null
   changeset:   -1:000000000000
   user:        
   date:        Thu Jan 01 00:00:00 1970 +0000
   
   $ hg log -f -r null -G
   o  changeset:   -1:000000000000
      user:
      date:        Thu Jan 01 00:00:00 1970 +0000
   
 
 
 log -f with null parent
 
   $ hg up -C null
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg log -f
 
 
 log -r .  with two parents
 
   $ hg up -C 3
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg log -r .
   changeset:   3:e62f78d544b4
   parent:      1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1
   
 
 
 log -r .  with one parent
 
   $ hg ci -mm12 -d '1 0'
   $ hg log -r .
   changeset:   5:302e9dd6890d
   tag:         tip
   parent:      3:e62f78d544b4
   parent:      4:ddb82e70d1a1
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     m12
   
 
   $ echo postm >> b1
   $ hg ci -Amb1.1 -d'1 0'
 
 
 log --follow-first
 
   $ hg log --follow-first
   changeset:   6:2404bbcab562
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1.1
   
   changeset:   5:302e9dd6890d
   parent:      3:e62f78d544b4
   parent:      4:ddb82e70d1a1
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     m12
   
   changeset:   3:e62f78d544b4
   parent:      1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1
   
   changeset:   1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     r1
   
   changeset:   0:67e992f2c4f3
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     base
   
 
 
 log -P 2
 
   $ hg log -P 2
   changeset:   6:2404bbcab562
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1.1
   
   changeset:   5:302e9dd6890d
   parent:      3:e62f78d544b4
   parent:      4:ddb82e70d1a1
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     m12
   
   changeset:   4:ddb82e70d1a1
   parent:      0:67e992f2c4f3
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b2
   
   changeset:   3:e62f78d544b4
   parent:      1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1
   
 
 
 log -r tip -p --git
 
   $ hg log -r tip -p --git
   changeset:   6:2404bbcab562
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1.1
   
   diff --git a/b1 b/b1
   --- a/b1
   +++ b/b1
   @@ -1,1 +1,2 @@
    b1
   +postm
   
 
 
 log -r ""
 
   $ hg log -r ''
   hg: parse error: empty query
   [10]
 
 log -r <some unknown node id>
 
   $ hg log -r 1000000000000000000000000000000000000000
   abort: unknown revision '1000000000000000000000000000000000000000'
   [10]
 
 log -k r1
 
   $ hg log -k r1
   changeset:   1:3d5bf5654eda
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     r1
   
 log -p -l2 --color=always
 
   $ hg --config extensions.color= --config color.mode=ansi \
   >  log -p -l2 --color=always
   \x1b[0;33mchangeset:   6:2404bbcab562\x1b[0m (esc)
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1.1
   
   \x1b[0;1mdiff -r 302e9dd6890d -r 2404bbcab562 b1\x1b[0m (esc)
   \x1b[0;31;1m--- a/b1	Thu Jan 01 00:00:01 1970 +0000\x1b[0m (esc)
   \x1b[0;32;1m+++ b/b1	Thu Jan 01 00:00:01 1970 +0000\x1b[0m (esc)
   \x1b[0;35m@@ -1,1 +1,2 @@\x1b[0m (esc)
    b1
   \x1b[0;32m+postm\x1b[0m (esc)
   
   \x1b[0;33mchangeset:   5:302e9dd6890d\x1b[0m (esc)
   parent:      3:e62f78d544b4
   parent:      4:ddb82e70d1a1
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     m12
   
   \x1b[0;1mdiff -r e62f78d544b4 -r 302e9dd6890d b2\x1b[0m (esc)
   \x1b[0;31;1m--- /dev/null	Thu Jan 01 00:00:00 1970 +0000\x1b[0m (esc)
   \x1b[0;32;1m+++ b/b2	Thu Jan 01 00:00:01 1970 +0000\x1b[0m (esc)
   \x1b[0;35m@@ -0,0 +1,1 @@\x1b[0m (esc)
   \x1b[0;32m+b2\x1b[0m (esc)
   
 
 
 log -r tip --stat
 
   $ hg log -r tip --stat
   changeset:   6:2404bbcab562
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b1.1
   
    b1 |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
 
   $ cd ..
 
 log --follow --patch FILE in repository where linkrev isn't trustworthy
 (issue5376, issue6124)
 
   $ hg init follow-dup
   $ cd follow-dup
   $ cat <<EOF >> .hg/hgrc
   > [command-templates]
   > log = '=== {rev}: {desc}\n'
   > [diff]
   > nodates = True
   > EOF
   $ echo 0 >> a
   $ hg ci -qAm 'a0'
   $ echo 1 >> a
   $ hg ci -m 'a1'
   $ hg up -q 0
   $ echo 1 >> a
   $ touch b
   $ hg ci -qAm 'a1 with b'
   $ echo 3 >> a
   $ hg ci -m 'a3'
 
  fctx.rev() == 2, but fctx.linkrev() == 1
 
   $ hg log -pf a
   === 3: a3
   diff -r 4ea02ba94d66 -r e7a6331a34f0 a
   --- a/a
   +++ b/a
   @@ -1,2 +1,3 @@
    0
    1
   +3
   
   === 2: a1 with b
   diff -r 49b5e81287e2 -r 4ea02ba94d66 a
   --- a/a
   +++ b/a
   @@ -1,1 +1,2 @@
    0
   +1
   
   === 0: a0
   diff -r 000000000000 -r 49b5e81287e2 a
   --- /dev/null
   +++ b/a
   @@ -0,0 +1,1 @@
   +0
   
   $ hg log -pr . a
   === 3: a3
   diff -r 4ea02ba94d66 -r e7a6331a34f0 a
   --- a/a
   +++ b/a
   @@ -1,2 +1,3 @@
    0
    1
   +3
   
 
  fctx.introrev() == 2, but fctx.linkrev() == 1
 
   $ hg up -q 2
   $ hg log -pf a
   === 2: a1 with b
   diff -r 49b5e81287e2 -r 4ea02ba94d66 a
   --- a/a
   +++ b/a
   @@ -1,1 +1,2 @@
    0
   +1
   
   === 0: a0
   diff -r 000000000000 -r 49b5e81287e2 a
   --- /dev/null
   +++ b/a
   @@ -0,0 +1,1 @@
   +0
   
 
 BROKEN: should show the same diff as for rev 2 above
   $ hg log -pr . a
 
   $ cd ..
 
 Multiple copy sources of a file:
 
   $ hg init follow-multi
   $ cd follow-multi
   $ echo 0 >> a
   $ hg ci -qAm 'a'
   $ hg cp a b
   $ hg ci -m 'a->b'
   $ echo 2 >> a
   $ hg ci -m 'a'
   $ echo 3 >> b
   $ hg ci -m 'b'
   $ echo 4 >> a
   $ echo 4 >> b
   $ hg ci -m 'a,b'
   $ echo 5 >> a
   $ hg ci -m 'a0'
   $ echo 6 >> b
   $ hg ci -m 'b0'
   $ hg up -q 4
   $ echo 7 >> b
   $ hg ci -m 'b1'
   created new head
   $ echo 8 >> a
   $ hg ci -m 'a1'
   $ hg rm a
   $ hg mv b a
   $ hg ci -m 'b1->a1'
   $ hg merge -qt :local
   $ hg ci -m '(a0,b1->a1)->a'
 
   $ hg log -GT '{rev}: {desc}\n'
   @    10: (a0,b1->a1)->a
   |\
   | o  9: b1->a1
   | |
   | o  8: a1
   | |
   | o  7: b1
   | |
   o |  6: b0
   | |
   o |  5: a0
   |/
   o  4: a,b
   |
   o  3: b
   |
   o  2: a
   |
   o  1: a->b
   |
   o  0: a
   
 
  since file 'a' has multiple copy sources at the revision 4, ancestors can't
  be indexed solely by fctx.linkrev().
 
   $ hg log -T '{rev}: {desc}\n' -f a
   10: (a0,b1->a1)->a
   9: b1->a1
   7: b1
   5: a0
   4: a,b
   3: b
   2: a
   1: a->b
   0: a
 
   $ cd ..
 
 Test that log should respect the order of -rREV even if multiple OR conditions
 are specified (issue5100):
 
   $ hg init revorder
   $ cd revorder
 
   $ hg branch -q b0
   $ echo 0 >> f0
   $ hg ci -qAm k0 -u u0
   $ hg branch -q b1
   $ echo 1 >> f1
   $ hg ci -qAm k1 -u u1
   $ hg branch -q b2
   $ echo 2 >> f2
   $ hg ci -qAm k2 -u u2
 
   $ hg update -q b2
   $ echo 3 >> f2
   $ hg ci -qAm k2 -u u2
   $ hg update -q b1
   $ echo 4 >> f1
   $ hg ci -qAm k1 -u u1
   $ hg update -q b0
   $ echo 5 >> f0
   $ hg ci -qAm k0 -u u0
 
  summary of revisions:
 
   $ hg log -G -T '{rev} {branch} {author} {desc} {files}\n'
   @  5 b0 u0 k0 f0
   |
   | o  4 b1 u1 k1 f1
   | |
   | | o  3 b2 u2 k2 f2
   | | |
   | | o  2 b2 u2 k2 f2
   | |/
   | o  1 b1 u1 k1 f1
   |/
   o  0 b0 u0 k0 f0
   
 
  log -b BRANCH in ascending order:
 
   $ hg log -r0:tip -T '{rev} {branch}\n' -b b0 -b b1
   0 b0
   1 b1
   4 b1
   5 b0
   $ hg log -r0:tip -T '{rev} {branch}\n' -b b1 -b b0
   0 b0
   1 b1
   4 b1
   5 b0
 
  log --only-branch BRANCH in descending order:
 
   $ hg log -rtip:0 -T '{rev} {branch}\n' --only-branch b1 --only-branch b2
   4 b1
   3 b2
   2 b2
   1 b1
   $ hg log -rtip:0 -T '{rev} {branch}\n' --only-branch b2 --only-branch b1
   4 b1
   3 b2
   2 b2
   1 b1
 
  log -u USER in ascending order, against compound set:
 
   $ hg log -r'::head()' -T '{rev} {author}\n' -u u0 -u u2
   0 u0
   2 u2
   3 u2
   5 u0
   $ hg log -r'::head()' -T '{rev} {author}\n' -u u2 -u u0
   0 u0
   2 u2
   3 u2
   5 u0
 
  log -k TEXT in descending order, against compound set:
 
   $ hg log -r'5 + reverse(::3)' -T '{rev} {desc}\n' -k k0 -k k1 -k k2
   5 k0
   3 k2
   2 k2
   1 k1
   0 k0
   $ hg log -r'5 + reverse(::3)' -T '{rev} {desc}\n' -k k2 -k k1 -k k0
   5 k0
   3 k2
   2 k2
   1 k1
   0 k0
 
  log -b/-u/-k shouldn't accept string-matcher syntax:
 
   $ hg log -b 're:.*'
   abort: unknown revision 're:.*'
   [10]
   $ hg log -k 're:.*'
   $ hg log -u 're:.*'
 
  log FILE in ascending order, against dagrange:
 
   $ hg log -r1:: -T '{rev} {files}\n' f1 f2
   1 f1
   2 f2
   3 f2
   4 f1
   $ hg log -r1:: -T '{rev} {files}\n' f2 f1
   1 f1
   2 f2
   3 f2
   4 f1
 
   $ cd ..
 
 User
 
   $ hg init usertest
   $ cd usertest
 
   $ echo a > a
   $ hg ci -A -m "a" -u "User One <[e-mail]>"
   adding a
   $ echo b > b
   $ hg ci -A -m "b" -u "User Two <[e-mail]>"
   adding b
 
   $ hg log -u "User One <[e-mail]>"
   changeset:   0:29a4c94f1924
   user:        User One <[e-mail]>
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
   $ hg log -u "user1" -u "user2"
   changeset:   1:e834b5e69c0e
   tag:         tip
   user:        User Two <[e-mail]>
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   changeset:   0:29a4c94f1924
   user:        User One <[e-mail]>
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
   $ hg log -u "user3"
 
 "-u USER" shouldn't be overridden by "user(USER)" alias
 
   $ hg log --config 'revsetalias.user(x)=branch(x)' -u default
   $ hg log --config 'revsetalias.user(x)=branch(x)' -u user1
   changeset:   0:29a4c94f1924
   user:        User One <[e-mail]>
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
 
   $ cd ..
 
   $ hg init branches
   $ cd branches
 
   $ echo a > a
   $ hg ci -A -m "commit on default"
   adding a
   $ hg branch test
   marked working directory as branch test
   (branches are permanent and global, did you want a bookmark?)
   $ echo b > b
   $ hg ci -A -m "commit on test"
   adding b
 
   $ hg up default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -A -m "commit on default"
   adding c
   $ hg up test
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -A -m "commit on test"
   adding c
 
 
 log -b default
 
   $ hg log -b default
   changeset:   2:c3a4f03cc9a7
   parent:      0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
   changeset:   0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
 
 
 log -b test
 
   $ hg log -b test
   changeset:   3:f5d8de11c2e2
   branch:      test
   tag:         tip
   parent:      1:d32277701ccb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   changeset:   1:d32277701ccb
   branch:      test
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
 
 
 log -b dummy
 
   $ hg log -b dummy
   abort: unknown revision 'dummy'
   [10]
 
 
 log -b .
 
   $ hg log -b .
   changeset:   3:f5d8de11c2e2
   branch:      test
   tag:         tip
   parent:      1:d32277701ccb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   changeset:   1:d32277701ccb
   branch:      test
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
 
 
 log -b default -b test
 
   $ hg log -b default -b test
   changeset:   3:f5d8de11c2e2
   branch:      test
   tag:         tip
   parent:      1:d32277701ccb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   changeset:   2:c3a4f03cc9a7
   parent:      0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
   changeset:   1:d32277701ccb
   branch:      test
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   changeset:   0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
 
 
 log -b default -b .
 
   $ hg log -b default -b .
   changeset:   3:f5d8de11c2e2
   branch:      test
   tag:         tip
   parent:      1:d32277701ccb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   changeset:   2:c3a4f03cc9a7
   parent:      0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
   changeset:   1:d32277701ccb
   branch:      test
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   changeset:   0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
 
 
 log -b . -b test
 
   $ hg log -b . -b test
   changeset:   3:f5d8de11c2e2
   branch:      test
   tag:         tip
   parent:      1:d32277701ccb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   changeset:   1:d32277701ccb
   branch:      test
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
 
 
 log -b 2
 
   $ hg log -b 2
   changeset:   2:c3a4f03cc9a7
   parent:      0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
   changeset:   0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
 #if gettext
 
 Test that all log names are translated (e.g. branches, bookmarks, tags):
 
   $ hg bookmark babar -r tip
 
   $ HGENCODING=UTF-8 LANGUAGE=de hg log -r tip
   \xc3\x84nderung:        3:f5d8de11c2e2 (esc)
   Zweig:           test
   Lesezeichen:     babar
   Marke:           tip
   Vorg\xc3\xa4nger:       1:d32277701ccb (esc)
   Nutzer:          test
   Datum:           Thu Jan 01 00:00:00 1970 +0000
   Zusammenfassung: commit on test
   
   $ hg bookmark -d babar
 
 #endif
 
 log -p --cwd dir (in subdir)
 
   $ mkdir dir
   $ hg log -p --cwd dir
   changeset:   3:f5d8de11c2e2
   branch:      test
   tag:         tip
   parent:      1:d32277701ccb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   diff -r d32277701ccb -r f5d8de11c2e2 c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
   changeset:   2:c3a4f03cc9a7
   parent:      0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
   diff -r 24427303d56f -r c3a4f03cc9a7 c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
   changeset:   1:d32277701ccb
   branch:      test
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on test
   
   diff -r 24427303d56f -r d32277701ccb 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 @@
   +b
   
   changeset:   0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
   diff -r 000000000000 -r 24427303d56f 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
   
 
 
 log -p -R repo
 
   $ cd dir
   $ hg log -p -R .. ../a
   changeset:   0:24427303d56f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit on default
   
   diff -r 000000000000 -r 24427303d56f 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
   
 
   $ cd ../..
 
   $ hg init follow2
   $ cd follow2
 
 # Build the following history:
 # tip - o - x - o - x - x
 #    \                 /
 #     o - o - o - x
 #      \     /
 #         o
 #
 # Where "o" is a revision containing "foo" and
 # "x" is a revision without "foo"
 
   $ touch init
   $ hg ci -A -m "init, unrelated"
   adding init
   $ echo 'foo' > init
   $ hg ci -m "change, unrelated"
   $ echo 'foo' > foo
   $ hg ci -A -m "add unrelated old foo"
   adding foo
   $ hg rm foo
   $ hg ci -m "delete foo, unrelated"
   $ echo 'related' > foo
   $ hg ci -A -m "add foo, related"
   adding foo
 
   $ hg up 0
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ touch branch
   $ hg ci -A -m "first branch, unrelated"
   adding branch
   created new head
   $ touch foo
   $ hg ci -A -m "create foo, related"
   adding foo
   $ echo 'change' > foo
   $ hg ci -m "change foo, related"
 
   $ hg up 6
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 'change foo in branch' > foo
   $ hg ci -m "change foo in branch, related"
   created new head
   $ hg merge 7
   merging foo
   warning: conflicts while merging foo! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ echo 'merge 1' > foo
   $ hg resolve -m foo
   (no more unresolved files)
   $ hg ci -m "First merge, related"
 
   $ hg merge 4
   merging foo
   warning: conflicts while merging foo! (edit, then use 'hg resolve --mark')
   1 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ echo 'merge 2' > foo
   $ hg resolve -m foo
   (no more unresolved files)
   $ hg ci -m "Last merge, related"
 
   $ hg log --graph
   @    changeset:   10:4dae8563d2c5
   |\   tag:         tip
   | |  parent:      9:7b35701b003e
   | |  parent:      4:88176d361b69
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     Last merge, related
   | |
   | o    changeset:   9:7b35701b003e
   | |\   parent:      8:e5416ad8a855
   | | |  parent:      7:87fe3144dcfa
   | | |  user:        test
   | | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | | |  summary:     First merge, related
   | | |
   | | o  changeset:   8:e5416ad8a855
   | | |  parent:      6:dc6c325fe5ee
   | | |  user:        test
   | | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | | |  summary:     change foo in branch, related
   | | |
   | o |  changeset:   7:87fe3144dcfa
   | |/   user:        test
   | |    date:        Thu Jan 01 00:00:00 1970 +0000
   | |    summary:     change foo, related
   | |
   | o  changeset:   6:dc6c325fe5ee
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     create foo, related
   | |
   | o  changeset:   5:73db34516eb9
   | |  parent:      0:e87515fd044a
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     first branch, unrelated
   | |
   o |  changeset:   4:88176d361b69
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     add foo, related
   | |
   o |  changeset:   3:dd78ae4afb56
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     delete foo, unrelated
   | |
   o |  changeset:   2:c4c64aedf0f7
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     add unrelated old foo
   | |
   o |  changeset:   1:e5faa7440653
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     change, unrelated
   |
   o  changeset:   0:e87515fd044a
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     init, unrelated
   
 
   $ hg --traceback log -f foo
   changeset:   10:4dae8563d2c5
   tag:         tip
   parent:      9:7b35701b003e
   parent:      4:88176d361b69
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Last merge, related
   
   changeset:   9:7b35701b003e
   parent:      8:e5416ad8a855
   parent:      7:87fe3144dcfa
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     First merge, related
   
   changeset:   8:e5416ad8a855
   parent:      6:dc6c325fe5ee
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change foo in branch, related
   
   changeset:   7:87fe3144dcfa
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change foo, related
   
   changeset:   6:dc6c325fe5ee
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     create foo, related
   
   changeset:   4:88176d361b69
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add foo, related
   
 
 Also check when maxrev < lastrevfilelog
 
   $ hg --traceback log -f -r4 foo
   changeset:   4:88176d361b69
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add foo, related
   
   $ cd ..
 
 Issue2383: hg log showing _less_ differences than hg diff
 
   $ hg init issue2383
   $ cd issue2383
 
 Create a test repo:
 
   $ echo a > a
   $ hg ci -Am0
   adding a
   $ echo b > b
   $ hg ci -Am1
   adding b
   $ hg co 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo b > a
   $ hg ci -m2
   created new head
 
 Merge:
 
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 Make sure there's a file listed in the merge to trigger the bug:
 
   $ echo c > a
   $ hg ci -m3
 
 Two files shown here in diff:
 
   $ hg diff --rev 2:3
   diff -r b09be438c43a -r 8e07aafe1edc a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -b
   +c
   diff -r b09be438c43a -r 8e07aafe1edc 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 @@
   +b
 
 Diff here should be the same:
 
   $ hg log -vpr 3
   changeset:   3:8e07aafe1edc
   tag:         tip
   parent:      2:b09be438c43a
   parent:      1:925d80f479bb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       a
   description:
   3
   
   
   diff -r b09be438c43a -r 8e07aafe1edc a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -b
   +c
   diff -r b09be438c43a -r 8e07aafe1edc 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 @@
   +b
   
 
 Test that diff.merge is respected (file b was added on one side and
 and therefore merged cleanly)
 
   $ hg log -pr 3 --config diff.merge=yes
   changeset:   3:8e07aafe1edc
   tag:         tip
   parent:      2:b09be438c43a
   parent:      1:925d80f479bb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3
   
   diff -r 8e07aafe1edc a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -b
   +c
   
   $ cd ..
 
 'hg log -r rev fn' when last(filelog(fn)) != rev
 
   $ hg init simplelog
   $ cd simplelog
   $ echo f > a
   $ hg ci -Am'a' -d '0 0'
   adding a
   $ echo f >> a
   $ hg ci -Am'a bis' -d '1 0'
 
   $ hg log -r0 a
   changeset:   0:9f758d63dcde
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
 enable obsolete to test hidden feature
 
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > evolution.createmarkers=True
   > EOF
 
   $ hg log --template='{rev}:{node}\n'
   1:a765632148dc55d38c35c4f247c618701886cb2f
   0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05
   $ hg debugobsolete a765632148dc55d38c35c4f247c618701886cb2f
   1 new obsolescence markers
   obsoleted 1 changesets
   $ hg up null -q
   $ hg log --template='{rev}:{node}\n'
   0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05
   $ hg log --template='{rev}:{node}\n' --hidden
   1:a765632148dc55d38c35c4f247c618701886cb2f
   0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05
   $ hg log -r a
   abort: hidden revision 'a' is pruned
   (use --hidden to access hidden revisions)
   [10]
 
 test that parent prevent a changeset to be hidden
 
   $ hg up 1 -q --hidden
   updated to hidden changeset a765632148dc
   (hidden revision 'a765632148dc' is pruned)
   $ hg log --template='{rev}:{node}\n'
   1:a765632148dc55d38c35c4f247c618701886cb2f
   0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05
 
 test that second parent prevent a changeset to be hidden too
 
   $ hg debugsetparents 0 1 # nothing suitable to merge here
   $ hg log --template='{rev}:{node}\n'
   1:a765632148dc55d38c35c4f247c618701886cb2f
   0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05
   $ hg debugsetparents 1
   $ hg up -q null
 
 bookmarks prevent a changeset being hidden
 
   $ hg bookmark --hidden -r 1 X
   bookmarking hidden changeset a765632148dc
   (hidden revision 'a765632148dc' is pruned)
   $ hg log --template '{rev}:{node}\n'
   1:a765632148dc55d38c35c4f247c618701886cb2f
   0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05
   $ hg bookmark -d X
 
 divergent bookmarks are not hidden
 
   $ hg bookmark --hidden -r 1 X@foo
   bookmarking hidden changeset a765632148dc
   (hidden revision 'a765632148dc' is pruned)
   $ hg log --template '{rev}:{node}\n'
   1:a765632148dc55d38c35c4f247c618701886cb2f
   0:9f758d63dcde62d547ebfb08e1e7ee96535f2b05
 
 test hidden revision 0 (issue5385)
 
   $ hg bookmark -d X@foo
   $ hg up null -q
   $ hg debugobsolete 9f758d63dcde62d547ebfb08e1e7ee96535f2b05
   1 new obsolescence markers
   obsoleted 1 changesets
   $ echo f > b
   $ hg ci -Am'b' -d '2 0'
   adding b
   $ echo f >> b
   $ hg ci -m'b bis' -d '3 0'
   $ hg log -T'{rev}:{node}\n'
   3:d7d28b288a6b83d5d2cf49f10c5974deed3a1d2e
   2:94375ec45bddd2a824535fc04855bd058c926ec0
 
   $ hg log -T'{rev}:{node}\n' -r:
   2:94375ec45bddd2a824535fc04855bd058c926ec0
   3:d7d28b288a6b83d5d2cf49f10c5974deed3a1d2e
   $ hg log -T'{rev}:{node}\n' -r:tip
   2:94375ec45bddd2a824535fc04855bd058c926ec0
   3:d7d28b288a6b83d5d2cf49f10c5974deed3a1d2e
   $ hg log -T'{rev}:{node}\n' -r:0
   abort: hidden revision '0' is pruned
   (use --hidden to access hidden revisions)
   [10]
   $ hg log -T'{rev}:{node}\n' -f
   3:d7d28b288a6b83d5d2cf49f10c5974deed3a1d2e
   2:94375ec45bddd2a824535fc04855bd058c926ec0
 
 clear extensions configuration
   $ echo '[extensions]' >> $HGRCPATH
   $ echo "obs=!" >> $HGRCPATH
   $ cd ..
 
 test -u/-k for problematic encoding
 # unicode: cp932:
 # u30A2    0x83 0x41(= 'A')
 # u30C2    0x83 0x61(= 'a')
 
   $ hg init problematicencoding
   $ cd problematicencoding
 
   >>> with open('setup.sh', 'wb') as f:
   ...     f.write(u'''
   ... echo a > text
   ... hg add text
   ... hg --encoding utf-8 commit -u '\u30A2' -m none
   ... echo b > text
   ... hg --encoding utf-8 commit -u '\u30C2' -m none
   ... echo c > text
   ... hg --encoding utf-8 commit -u none -m '\u30A2'
   ... echo d > text
   ... hg --encoding utf-8 commit -u none -m '\u30C2'
   ... '''.encode('utf-8')) and None
   $ sh < setup.sh
 
 test in problematic encoding
   >>> with open('test.sh', 'wb') as f:
   ...     f.write(u'''
   ... hg --encoding cp932 log --template '{rev}\\n' -u '\u30A2'
   ... echo ====
   ... hg --encoding cp932 log --template '{rev}\\n' -u '\u30C2'
   ... echo ====
   ... hg --encoding cp932 log --template '{rev}\\n' -k '\u30A2'
   ... echo ====
   ... hg --encoding cp932 log --template '{rev}\\n' -k '\u30C2'
   ... '''.encode('cp932')) and None
   $ sh < test.sh
   0
   ====
   1
   ====
   2
   0
   ====
   3
   1
 
   $ cd ..
 
 test hg log on non-existent files and on directories
   $ hg init issue1340
   $ cd issue1340
   $ mkdir d1; mkdir D2; mkdir D3.i; mkdir d4.hg; mkdir d5.d; mkdir .d6
   $ echo 1 > d1/f1
   $ echo 1 > D2/f1
   $ echo 1 > D3.i/f1
   $ echo 1 > d4.hg/f1
   $ echo 1 > d5.d/f1
   $ echo 1 > .d6/f1
   $ hg -q add .
   $ hg commit -m "a bunch of weird directories"
   $ hg log -l1 d1/f1 | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 f1
   $ hg log -l1 . | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 ./ | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 d1 | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 D2 | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 D2/f1 | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 D3.i | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 D3.i/f1 | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 d4.hg | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 d4.hg/f1 | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 d5.d | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 d5.d/f1 | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 .d6 | grep changeset
   changeset:   0:65624cd9070a
   $ hg log -l1 .d6/f1 | grep changeset
   changeset:   0:65624cd9070a
 
 issue3772: hg log -r :null showing revision 0 as well
 
   $ hg log -r :null
   changeset:   0:65624cd9070a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a bunch of weird directories
   
   changeset:   -1:000000000000
   user:        
   date:        Thu Jan 01 00:00:00 1970 +0000
   
   $ hg log -r null:null
   changeset:   -1:000000000000
   user:        
   date:        Thu Jan 01 00:00:00 1970 +0000
   
 working-directory revision requires special treatment
 
 clean:
 
   $ hg log -r 'wdir()' --debug
   changeset:   2147483647:ffffffffffffffffffffffffffffffffffffffff
   phase:       draft
   parent:      0:65624cd9070a035fa7191a54f2b8af39f16b0c08
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    2147483647:ffffffffffffffffffffffffffffffffffffffff
   user:        test
   date:        [A-Za-z0-9:+ ]+ (re)
   extra:       branch=default
   
   $ hg log -r 'wdir()' -p --stat
   changeset:   2147483647:ffffffffffff
   parent:      0:65624cd9070a
   user:        test
   date:        [A-Za-z0-9:+ ]+ (re)
   
   
   
 
 dirty:
 
   $ echo 2 >> d1/f1
   $ echo 2 > d1/f2
   $ hg add d1/f2
   $ hg remove .d6/f1
   $ hg status
   M d1/f1
   A d1/f2
   R .d6/f1
 
   $ hg log -r 'wdir()'
   changeset:   2147483647:ffffffffffff
   parent:      0:65624cd9070a
   user:        test
   date:        [A-Za-z0-9:+ ]+ (re)
   
   $ hg log -r 'wdir()' -q
   2147483647:ffffffffffff
 
   $ hg log -r 'wdir()' --debug
   changeset:   2147483647:ffffffffffffffffffffffffffffffffffffffff
   phase:       draft
   parent:      0:65624cd9070a035fa7191a54f2b8af39f16b0c08
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    2147483647:ffffffffffffffffffffffffffffffffffffffff
   user:        test
   date:        [A-Za-z0-9:+ ]+ (re)
   files:       d1/f1
   files+:      d1/f2
   files-:      .d6/f1
   extra:       branch=default
   
   $ hg log -r 'wdir()' -p --stat --git
   changeset:   2147483647:ffffffffffff
   parent:      0:65624cd9070a
   user:        test
   date:        [A-Za-z0-9:+ ]+ (re)
   
    .d6/f1 |  1 -
    d1/f1  |  1 +
    d1/f2  |  1 +
    3 files changed, 2 insertions(+), 1 deletions(-)
   
   diff --git a/.d6/f1 b/.d6/f1
   deleted file mode 100644
   --- a/.d6/f1
   +++ /dev/null
   @@ -1,1 +0,0 @@
   -1
   diff --git a/d1/f1 b/d1/f1
   --- a/d1/f1
   +++ b/d1/f1
   @@ -1,1 +1,2 @@
    1
   +2
   diff --git a/d1/f2 b/d1/f2
   new file mode 100644
   --- /dev/null
   +++ b/d1/f2
   @@ -0,0 +1,1 @@
   +2
   
   $ hg log -r 'wdir()' -Tjson
   [
    {
     "bookmarks": [],
     "branch": "default",
     "date": [*, 0], (glob)
     "desc": "",
     "node": "ffffffffffffffffffffffffffffffffffffffff",
     "parents": ["65624cd9070a035fa7191a54f2b8af39f16b0c08"],
     "phase": "draft",
     "rev": 2147483647,
     "tags": [],
     "user": "test"
    }
   ]
 
   $ hg log -r 'wdir()' -Tjson -q
   [
    {
     "node": "ffffffffffffffffffffffffffffffffffffffff",
     "rev": 2147483647
    }
   ]
 
   $ hg log -r 'wdir()' -Tjson --debug
   [
    {
     "added": ["d1/f2"],
     "bookmarks": [],
     "branch": "default",
     "date": [*, 0], (glob)
     "desc": "",
     "extra": {"branch": "default"},
     "manifest": "ffffffffffffffffffffffffffffffffffffffff",
     "modified": ["d1/f1"],
     "node": "ffffffffffffffffffffffffffffffffffffffff",
     "parents": ["65624cd9070a035fa7191a54f2b8af39f16b0c08"],
     "phase": "draft",
     "removed": [".d6/f1"],
     "rev": 2147483647,
     "tags": [],
     "user": "test"
    }
   ]
 
 follow files from wdir
 
   $ hg cp d1/f1 f1-copy
   $ hg stat --all
   M d1/f1
   A d1/f2
   A f1-copy
     d1/f1
   R .d6/f1
   C D2/f1
   C D3.i/f1
   C d4.hg/f1
   C d5.d/f1
 
   $ hg log -T '== {rev} ==\n' -fr'wdir()' --git --stat d5.d/f1
   == 2147483647 ==
   
   == 0 ==
    d5.d/f1 |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
 
   $ hg log -T '== {rev} ==\n' -fr'wdir()' --git --stat d1/f1
   == 2147483647 ==
    d1/f1 |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
   == 0 ==
    d1/f1 |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
 
   $ hg log -T '== {rev} ==\n' -fr'wdir()' --git --stat d1/f2
   == 2147483647 ==
    d1/f2 |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
 
   $ hg log -T '== {rev} ==\n' -fr'wdir()' --git --stat f1-copy
   == 2147483647 ==
    f1-copy |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
   == 0 ==
    d1/f1 |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
 
   $ hg log -T '== {rev} ==\n' -fr'wdir()' --git --stat notfound
   abort: cannot follow file not in any of the specified revisions: "notfound"
-  [255]
+  [20]
 
 follow files from wdir and non-wdir revision:
 
   $ hg log -T '{rev}\n' -fr'wdir()+.' f1-copy
   f1-copy: no such file in rev 65624cd9070a
   2147483647
   0
 
 follow added/removed files from wdir parent
 
   $ hg log -T '{rev}\n' -f d1/f2
   abort: cannot follow nonexistent file: "d1/f2"
-  [255]
+  [20]
 
   $ hg log -T '{rev}\n' -f f1-copy
   abort: cannot follow nonexistent file: "f1-copy"
-  [255]
+  [20]
 
   $ hg log -T '{rev}\n' -f .d6/f1
   abort: cannot follow file not in parent revision: ".d6/f1"
-  [255]
+  [20]
 
   $ hg revert -aqC
 
 Check that adding an arbitrary name shows up in log automatically
 
   $ cat > ../names.py <<EOF
   > """A small extension to test adding arbitrary names to a repo"""
   > from __future__ import absolute_import
   > from mercurial import namespaces
   > 
   > def reposetup(ui, repo):
   >     if not repo.local():
   >         return
   >     foo = {b'foo': repo[0].node()}
   >     names = lambda r: foo.keys()
   >     namemap = lambda r, name: foo.get(name)
   >     nodemap = lambda r, node: [name for name, n in foo.items()
   >                                if n == node]
   >     ns = namespaces.namespace(
   >         b"bars", templatename=b"bar", logname=b"barlog",
   >         colorname=b"barcolor", listnames=names, namemap=namemap,
   >         nodemap=nodemap)
   > 
   >     repo.names.addnamespace(ns)
   > EOF
 
   $ hg --config extensions.names=../names.py log -r 0
   changeset:   0:65624cd9070a
   tag:         tip
   barlog:      foo
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a bunch of weird directories
   
   $ hg --config extensions.names=../names.py \
   >  --config extensions.color= --config color.log.barcolor=red \
   >  --color=always log -r 0
   \x1b[0;33mchangeset:   0:65624cd9070a\x1b[0m (esc)
   tag:         tip
   \x1b[0;31mbarlog:      foo\x1b[0m (esc)
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a bunch of weird directories
   
   $ hg --config extensions.names=../names.py log -r 0 --template '{bars}\n'
   foo
 
 Templater parse errors:
 
 simple error
   $ hg log -r . -T '{shortest(node}'
   hg: parse error at 14: unexpected token: end
   ({shortest(node}
                  ^ here)
   [10]
 
 multi-line template with error
   $ hg log -r . -T 'line 1
   > line2
   > {shortest(node}
   > line4\nline5'
   hg: parse error at 27: unexpected token: end
   (line 1\nline2\n{shortest(node}\nline4\nline5
                                 ^ here)
   [10]
 
   $ cd ..
 
 New namespace is registered per repo instance, but the template keyword
 is global. So we shouldn't expect the namespace always exists. Using
 ssh:// makes sure a bundle repository is created from scratch. (issue6301)
 
   $ hg clone -qr0 "ssh://user@dummy/`pwd`/a" a-clone
   $ hg incoming --config extensions.names=names.py -R a-clone \
   > -T '{bars}\n' -l1
   comparing with ssh://user@dummy/$TESTTMP/a
   searching for changes
   
 
 hg log -f dir across branches
 
   $ hg init acrossbranches
   $ cd acrossbranches
   $ mkdir d
   $ echo a > d/a && hg ci -Aqm a
   $ echo b > d/a && hg ci -Aqm b
   $ hg up -q 0
   $ echo b > d/a && hg ci -Aqm c
   $ hg log -f d -T '{desc}' -G
   @  c
   |
   o  a
   
 Ensure that largefiles doesn't interfere with following a normal file
   $ hg  --config extensions.largefiles= log -f d -T '{desc}' -G
   The fsmonitor extension is incompatible with the largefiles extension and has been disabled. (fsmonitor !)
   @  c
   |
   o  a
   
   $ hg log -f d/a -T '{desc}' -G
   @  c
   |
   o  a
   
   $ cd ..
 
 hg log -f with linkrev pointing to another branch
 -------------------------------------------------
 
 create history with a filerev whose linkrev points to another branch
 
   $ hg init branchedlinkrev
   $ cd branchedlinkrev
   $ echo 1 > a
   $ hg commit -Am 'content1'
   adding a
   $ echo 2 > a
   $ hg commit -m 'content2'
   $ hg up --rev 'desc(content1)'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo unrelated > unrelated
   $ hg commit -Am 'unrelated'
   adding unrelated
   created new head
   $ hg graft -r 'desc(content2)'
   grafting 1:2294ae80ad84 "content2"
   $ echo 3 > a
   $ hg commit -m 'content3'
   $ hg log -G
   @  changeset:   4:50b9b36e9c5d
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content3
   |
   o  changeset:   3:15b2327059e5
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content2
   |
   o  changeset:   2:2029acd1168c
   |  parent:      0:ae0a3c9f9e95
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     unrelated
   |
   | o  changeset:   1:2294ae80ad84
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     content2
   |
   o  changeset:   0:ae0a3c9f9e95
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     content1
   
 
 log -f on the file should list the graft result.
 
   $ hg log -Gf a
   @  changeset:   4:50b9b36e9c5d
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content3
   |
   o  changeset:   3:15b2327059e5
   :  user:        test
   :  date:        Thu Jan 01 00:00:00 1970 +0000
   :  summary:     content2
   :
   o  changeset:   0:ae0a3c9f9e95
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     content1
   
 
 plain log lists the original version
 (XXX we should probably list both)
 
   $ hg log -G a
   @  changeset:   4:50b9b36e9c5d
   :  tag:         tip
   :  user:        test
   :  date:        Thu Jan 01 00:00:00 1970 +0000
   :  summary:     content3
   :
   : o  changeset:   1:2294ae80ad84
   :/   user:        test
   :    date:        Thu Jan 01 00:00:00 1970 +0000
   :    summary:     content2
   :
   o  changeset:   0:ae0a3c9f9e95
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     content1
   
 
 hg log -f from the grafted changeset
 (The bootstrap should properly take the topology in account)
 
   $ hg up 'desc(content3)^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg log -Gf a
   @  changeset:   3:15b2327059e5
   :  user:        test
   :  date:        Thu Jan 01 00:00:00 1970 +0000
   :  summary:     content2
   :
   o  changeset:   0:ae0a3c9f9e95
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     content1
   
 
 Test that we use the first non-hidden changeset in that case.
 
 (hide the changeset)
 
   $ hg log -T '{node}\n' -r 1
   2294ae80ad8447bc78383182eeac50cb049df623
   $ hg debugobsolete 2294ae80ad8447bc78383182eeac50cb049df623
   1 new obsolescence markers
   obsoleted 1 changesets
   $ hg log -G
   o  changeset:   4:50b9b36e9c5d
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content3
   |
   @  changeset:   3:15b2327059e5
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content2
   |
   o  changeset:   2:2029acd1168c
   |  parent:      0:ae0a3c9f9e95
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     unrelated
   |
   o  changeset:   0:ae0a3c9f9e95
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     content1
   
 
 Check that log on the file does not drop the file revision.
 
   $ hg log -G a
   o  changeset:   4:50b9b36e9c5d
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     content3
   |
   @  changeset:   3:15b2327059e5
   :  user:        test
   :  date:        Thu Jan 01 00:00:00 1970 +0000
   :  summary:     content2
   :
   o  changeset:   0:ae0a3c9f9e95
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     content1
   
 
 Even when a head revision is linkrev-shadowed.
 
   $ hg log -T '{node}\n' -r 4
   50b9b36e9c5df2c6fc6dcefa8ad0da929e84aed2
   $ hg debugobsolete 50b9b36e9c5df2c6fc6dcefa8ad0da929e84aed2
   1 new obsolescence markers
   obsoleted 1 changesets
   $ hg log -G a
   @  changeset:   3:15b2327059e5
   :  tag:         tip
   :  user:        test
   :  date:        Thu Jan 01 00:00:00 1970 +0000
   :  summary:     content2
   :
   o  changeset:   0:ae0a3c9f9e95
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     content1
   
 
   $ cd ..
 
 Even when the file revision is missing from some head:
 
   $ hg init issue4490
   $ cd issue4490
   $ echo '[experimental]' >> .hg/hgrc
   $ echo 'evolution.createmarkers=True' >> .hg/hgrc
   $ echo a > a
   $ hg ci -Am0
   adding a
   $ echo b > b
   $ hg ci -Am1
   adding b
   $ echo B > b
   $ hg ci --amend -m 1
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > c
   $ hg ci -Am2
   adding c
   created new head
   $ hg up 'head() and not .'
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg log -G
   o  changeset:   3:db815d6d32e6
   |  tag:         tip
   |  parent:      0:f7b1eb17ad24
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     2
   |
   | @  changeset:   2:9bc8ce7f9356
   |/   parent:      0:f7b1eb17ad24
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     1
   |
   o  changeset:   0:f7b1eb17ad24
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     0
   
   $ hg log -f -G b
   @  changeset:   2:9bc8ce7f9356
   |  parent:      0:f7b1eb17ad24
   ~  user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     1
   
   $ hg log -G b
   @  changeset:   2:9bc8ce7f9356
   |  parent:      0:f7b1eb17ad24
   ~  user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     1
   
   $ cd ..
 
 Check proper report when the manifest changes but not the file issue4499
 ------------------------------------------------------------------------
 
   $ hg init issue4499
   $ cd issue4499
   $ for f in A B C D F E G H I J K L M N O P Q R S T U; do
   >     echo 1 > $f;
   >     hg add $f;
   > done
   $ hg commit -m 'A1B1C1'
   $ echo 2 > A
   $ echo 2 > B
   $ echo 2 > C
   $ hg commit -m 'A2B2C2'
   $ hg up 0
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 3 > A
   $ echo 2 > B
   $ echo 2 > C
   $ hg commit -m 'A3B2C2'
   created new head
 
   $ hg log -G
   @  changeset:   2:fe5fc3d0eb17
   |  tag:         tip
   |  parent:      0:abf4f0e38563
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     A3B2C2
   |
   | o  changeset:   1:07dcc6b312c0
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     A2B2C2
   |
   o  changeset:   0:abf4f0e38563
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     A1B1C1
   
 
 Log -f on B should reports current changesets
 
   $ hg log -fG B
   @  changeset:   2:fe5fc3d0eb17
   |  tag:         tip
   |  parent:      0:abf4f0e38563
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     A3B2C2
   |
   o  changeset:   0:abf4f0e38563
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     A1B1C1
   
   $ cd ..
 
 --- going to test line wrap fix on using both --stat and -G (issue5800)
   $ hg init issue5800
   $ cd issue5800
   $ touch a
   $ hg ci -Am 'add a'
   adding a
 ---- now we are going to add 300 lines to a
   $ for i in `$TESTDIR/seq.py 1 300`; do echo $i >> a; done
   $ hg ci -m 'modify a'
   $ hg log
   changeset:   1:a98683e6a834
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     modify a
   
   changeset:   0:ac82d8b1f7c4
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add a
   
 ---- now visualise the changes we made without template
   $ hg log -l1 -r a98683e6a834 --stat -G
   @  changeset:   1:a98683e6a834
   |  tag:         tip
   ~  user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     modify a
   
       a |  300 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       1 files changed, 300 insertions(+), 0 deletions(-)
   
 ---- with template
   $ hg log -l1 -r a98683e6a834 --stat -G -T bisect
   @  changeset:   1:a98683e6a834
   |  bisect:
   ~  tag:         tip
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     modify a
   
       a |  300 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       1 files changed, 300 insertions(+), 0 deletions(-)
   
   $ hg log -l1 -r a98683e6a834 --stat -G -T changelog
   1970-01-01  test  <test>
   
   @  	* a:
   |  	modify a
   ~  	[a98683e6a834] [tip]
   
       a |  300 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       1 files changed, 300 insertions(+), 0 deletions(-)
   
   $ hg log -l1 -r a98683e6a834 --stat -G -T compact
   @  1[tip]   a98683e6a834   1970-01-01 00:00 +0000   test
   |    modify a
   ~
       a |  300 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       1 files changed, 300 insertions(+), 0 deletions(-)
   
   $ hg log -l1 -r a98683e6a834 --stat -G -T default
   @  changeset:   1:a98683e6a834
   |  tag:         tip
   ~  user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     modify a
   
       a |  300 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       1 files changed, 300 insertions(+), 0 deletions(-)
   
   $ hg log -l1 -r a98683e6a834 --stat -G -T phases
   @  changeset:   1:a98683e6a834
   |  tag:         tip
   ~  phase:       draft
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     modify a
   
       a |  300 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       1 files changed, 300 insertions(+), 0 deletions(-)
   
   $ hg log -l1 -r a98683e6a834 --stat -G -T show
   @  changeset:   1:a98683e6a834
   |  tag:         tip
   ~  user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     modify a
   
       a |  300 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       1 files changed, 300 insertions(+), 0 deletions(-)
   
   $ hg log -l1 -r a98683e6a834 --stat -G -T status
   @  changeset:   1:a98683e6a834
   |  tag:         tip
   ~  user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     modify a
      files:
      M a
   
       a |  300 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       1 files changed, 300 insertions(+), 0 deletions(-)
   
   $ hg log -l1 -r a98683e6a834 --stat -G -T xml
   <?xml version="1.0"?>
   <log>
   @  <logentry revision="1" node="a98683e6a8340830a7683909768b62871e84bc9d">
   |  <tag>tip</tag>
   ~  <author email="test">test</author>
      <date>1970-01-01T00:00:00+00:00</date>
      <msg xml:space="preserve">modify a</msg>
      </logentry>
       a |  300 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       1 files changed, 300 insertions(+), 0 deletions(-)
   
   </log>
 
   $ cd ..