graphlog: use '%' for other context in merge conflict

This lets the user more easily find the commit that is involved in the
conflict, such as the source of `hg update -m` or the commit being
grafted by `hg graft`.

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

hgext/beautifygraph.py

@@ -1,107 +1,109 b''
 # -*- coding: UTF-8 -*-
 # beautifygraph.py - improve graph output by using Unicode characters
 #
 # Copyright 2018 John Stiles <[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.
 
 '''beautify log -G output by using Unicode characters (EXPERIMENTAL)
 
    A terminal with UTF-8 support and monospace narrow text are required.
 '''
 
 from __future__ import absolute_import
 
 from mercurial.i18n import _
 from mercurial import (
     encoding,
     extensions,
     graphmod,
     pycompat,
     templatekw,
 )
 
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
 testedwith = b'ships-with-hg-core'
 
 
 def prettyedge(before, edge, after):
     if edge == b'~':
         return b'\xE2\x95\xA7'  # U+2567 ╧
     if edge == b'/':
         return b'\xE2\x95\xB1'  # U+2571 ╱
     if edge == b'-':
         return b'\xE2\x94\x80'  # U+2500 ─
     if edge == b'|':
         return b'\xE2\x94\x82'  # U+2502 │
     if edge == b':':
         return b'\xE2\x94\x86'  # U+2506 ┆
     if edge == b'\\':
         return b'\xE2\x95\xB2'  # U+2572 ╲
     if edge == b'+':
         if before == b' ' and not after == b' ':
             return b'\xE2\x94\x9C'  # U+251C ├
         if after == b' ' and not before == b' ':
             return b'\xE2\x94\xA4'  # U+2524 ┤
         return b'\xE2\x94\xBC'  # U+253C ┼
     return edge
 
 
 def convertedges(line):
     line = b' %s ' % line
     pretty = []
     for idx in pycompat.xrange(len(line) - 2):
         pretty.append(
             prettyedge(
                 line[idx : idx + 1],
                 line[idx + 1 : idx + 2],
                 line[idx + 2 : idx + 3],
             )
         )
     return b''.join(pretty)
 
 
 def getprettygraphnode(orig, *args, **kwargs):
     node = orig(*args, **kwargs)
     if node == b'o':
         return b'\xE2\x97\x8B'  # U+25CB ○
     if node == b'@':
         return b'\xE2\x97\x8D'  # U+25CD ◍
+    if node == b'%':
+        return b'\xE2\x97\x8D'  # U+25CE ◎
     if node == b'*':
         return b'\xE2\x88\x97'  # U+2217 ∗
     if node == b'x':
         return b'\xE2\x97\x8C'  # U+25CC ◌
     if node == b'_':
         return b'\xE2\x95\xA4'  # U+2564 ╤
     return node
 
 
 def outputprettygraph(orig, ui, graph, *args, **kwargs):
     (edges, text) = zip(*graph)
     graph = zip([convertedges(e) for e in edges], text)
     return orig(ui, graph, *args, **kwargs)
 
 
 def extsetup(ui):
     if ui.plain(b'graph'):
         return
 
     if encoding.encoding != b'UTF-8':
         ui.warn(_(b'beautifygraph: unsupported encoding, UTF-8 required\n'))
         return
 
     if 'A' in encoding._wide:
         ui.warn(
             _(
                 b'beautifygraph: unsupported terminal settings, '
                 b'monospace narrow text required\n'
             )
         )
         return
 
     extensions.wrapfunction(graphmod, b'outputgraph', outputprettygraph)
     extensions.wrapfunction(templatekw, b'getgraphnode', getprettygraphnode)

mercurial/hgweb/webutil.py

@@ -1,940 +1,940 b''
 # hgweb/webutil.py - utility library for the web interface.
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import copy
 import difflib
 import os
 import re
 
 from ..i18n import _
 from ..node import hex, nullid, short
 from ..pycompat import setattr
 
 from .common import (
     ErrorResponse,
     HTTP_BAD_REQUEST,
     HTTP_NOT_FOUND,
     paritygen,
 )
 
 from .. import (
     context,
     diffutil,
     error,
     match,
     mdiff,
     obsutil,
     patch,
     pathutil,
     pycompat,
     scmutil,
     templatefilters,
     templatekw,
     templateutil,
     ui as uimod,
     util,
 )
 
 from ..utils import stringutil
 
 archivespecs = util.sortdict(
     (
         (b'zip', (b'application/zip', b'zip', b'.zip', None)),
         (b'gz', (b'application/x-gzip', b'tgz', b'.tar.gz', None)),
         (b'bz2', (b'application/x-bzip2', b'tbz2', b'.tar.bz2', None)),
     )
 )
 
 
 def archivelist(ui, nodeid, url=None):
     allowed = ui.configlist(b'web', b'allow-archive', untrusted=True)
     archives = []
 
     for typ, spec in pycompat.iteritems(archivespecs):
         if typ in allowed or ui.configbool(
             b'web', b'allow' + typ, untrusted=True
         ):
             archives.append(
                 {
                     b'type': typ,
                     b'extension': spec[2],
                     b'node': nodeid,
                     b'url': url,
                 }
             )
 
     return templateutil.mappinglist(archives)
 
 
 def up(p):
     if p[0:1] != b"/":
         p = b"/" + p
     if p[-1:] == b"/":
         p = p[:-1]
     up = os.path.dirname(p)
     if up == b"/":
         return b"/"
     return up + b"/"
 
 
 def _navseq(step, firststep=None):
     if firststep:
         yield firststep
         if firststep >= 20 and firststep <= 40:
             firststep = 50
             yield firststep
         assert step > 0
         assert firststep > 0
         while step <= firststep:
             step *= 10
     while True:
         yield 1 * step
         yield 3 * step
         step *= 10
 
 
 class revnav(object):
     def __init__(self, repo):
         """Navigation generation object
 
         :repo: repo object we generate nav for
         """
         # used for hex generation
         self._revlog = repo.changelog
 
     def __nonzero__(self):
         """return True if any revision to navigate over"""
         return self._first() is not None
 
     __bool__ = __nonzero__
 
     def _first(self):
         """return the minimum non-filtered changeset or None"""
         try:
             return next(iter(self._revlog))
         except StopIteration:
             return None
 
     def hex(self, rev):
         return hex(self._revlog.node(rev))
 
     def gen(self, pos, pagelen, limit):
         """computes label and revision id for navigation link
 
         :pos: is the revision relative to which we generate navigation.
         :pagelen: the size of each navigation page
         :limit: how far shall we link
 
         The return is:
             - a single element mappinglist
             - containing a dictionary with a `before` and `after` key
             - values are dictionaries with `label` and `node` keys
         """
         if not self:
             # empty repo
             return templateutil.mappinglist(
                 [
                     {
                         b'before': templateutil.mappinglist([]),
                         b'after': templateutil.mappinglist([]),
                     },
                 ]
             )
 
         targets = []
         for f in _navseq(1, pagelen):
             if f > limit:
                 break
             targets.append(pos + f)
             targets.append(pos - f)
         targets.sort()
 
         first = self._first()
         navbefore = [{b'label': b'(%i)' % first, b'node': self.hex(first)}]
         navafter = []
         for rev in targets:
             if rev not in self._revlog:
                 continue
             if pos < rev < limit:
                 navafter.append(
                     {b'label': b'+%d' % abs(rev - pos), b'node': self.hex(rev)}
                 )
             if 0 < rev < pos:
                 navbefore.append(
                     {b'label': b'-%d' % abs(rev - pos), b'node': self.hex(rev)}
                 )
 
         navafter.append({b'label': b'tip', b'node': b'tip'})
 
         # TODO: maybe this can be a scalar object supporting tomap()
         return templateutil.mappinglist(
             [
                 {
                     b'before': templateutil.mappinglist(navbefore),
                     b'after': templateutil.mappinglist(navafter),
                 },
             ]
         )
 
 
 class filerevnav(revnav):
     def __init__(self, repo, path):
         """Navigation generation object
 
         :repo: repo object we generate nav for
         :path: path of the file we generate nav for
         """
         # used for iteration
         self._changelog = repo.unfiltered().changelog
         # used for hex generation
         self._revlog = repo.file(path)
 
     def hex(self, rev):
         return hex(self._changelog.node(self._revlog.linkrev(rev)))
 
 
 # TODO: maybe this can be a wrapper class for changectx/filectx list, which
 # yields {'ctx': ctx}
 def _ctxsgen(context, ctxs):
     for s in ctxs:
         d = {
             b'node': s.hex(),
             b'rev': s.rev(),
             b'user': s.user(),
             b'date': s.date(),
             b'description': s.description(),
             b'branch': s.branch(),
         }
         if util.safehasattr(s, b'path'):
             d[b'file'] = s.path()
         yield d
 
 
 def _siblings(siblings=None, hiderev=None):
     if siblings is None:
         siblings = []
     siblings = [s for s in siblings if s.node() != nullid]
     if len(siblings) == 1 and siblings[0].rev() == hiderev:
         siblings = []
     return templateutil.mappinggenerator(_ctxsgen, args=(siblings,))
 
 
 def difffeatureopts(req, ui, section):
     diffopts = diffutil.difffeatureopts(
         ui, untrusted=True, section=section, whitespace=True
     )
 
     for k in (
         b'ignorews',
         b'ignorewsamount',
         b'ignorewseol',
         b'ignoreblanklines',
     ):
         v = req.qsparams.get(k)
         if v is not None:
             v = stringutil.parsebool(v)
             setattr(diffopts, k, v if v is not None else True)
 
     return diffopts
 
 
 def annotate(req, fctx, ui):
     diffopts = difffeatureopts(req, ui, b'annotate')
     return fctx.annotate(follow=True, diffopts=diffopts)
 
 
 def parents(ctx, hide=None):
     if isinstance(ctx, context.basefilectx):
         introrev = ctx.introrev()
         if ctx.changectx().rev() != introrev:
             return _siblings([ctx.repo()[introrev]], hide)
     return _siblings(ctx.parents(), hide)
 
 
 def children(ctx, hide=None):
     return _siblings(ctx.children(), hide)
 
 
 def renamelink(fctx):
     r = fctx.renamed()
     if r:
         return templateutil.mappinglist([{b'file': r[0], b'node': hex(r[1])}])
     return templateutil.mappinglist([])
 
 
 def nodetagsdict(repo, node):
     return templateutil.hybridlist(repo.nodetags(node), name=b'name')
 
 
 def nodebookmarksdict(repo, node):
     return templateutil.hybridlist(repo.nodebookmarks(node), name=b'name')
 
 
 def nodebranchdict(repo, ctx):
     branches = []
     branch = ctx.branch()
     # If this is an empty repo, ctx.node() == nullid,
     # ctx.branch() == 'default'.
     try:
         branchnode = repo.branchtip(branch)
     except error.RepoLookupError:
         branchnode = None
     if branchnode == ctx.node():
         branches.append(branch)
     return templateutil.hybridlist(branches, name=b'name')
 
 
 def nodeinbranch(repo, ctx):
     branches = []
     branch = ctx.branch()
     try:
         branchnode = repo.branchtip(branch)
     except error.RepoLookupError:
         branchnode = None
     if branch != b'default' and branchnode != ctx.node():
         branches.append(branch)
     return templateutil.hybridlist(branches, name=b'name')
 
 
 def nodebranchnodefault(ctx):
     branches = []
     branch = ctx.branch()
     if branch != b'default':
         branches.append(branch)
     return templateutil.hybridlist(branches, name=b'name')
 
 
 def _nodenamesgen(context, f, node, name):
     for t in f(node):
         yield {name: t}
 
 
 def showtag(repo, t1, node=nullid):
     args = (repo.nodetags, node, b'tag')
     return templateutil.mappinggenerator(_nodenamesgen, args=args, name=t1)
 
 
 def showbookmark(repo, t1, node=nullid):
     args = (repo.nodebookmarks, node, b'bookmark')
     return templateutil.mappinggenerator(_nodenamesgen, args=args, name=t1)
 
 
 def branchentries(repo, stripecount, limit=0):
     tips = []
     heads = repo.heads()
     parity = paritygen(stripecount)
     sortkey = lambda item: (not item[1], item[0].rev())
 
     def entries(context):
         count = 0
         if not tips:
             for tag, hs, tip, closed in repo.branchmap().iterbranches():
                 tips.append((repo[tip], closed))
         for ctx, closed in sorted(tips, key=sortkey, reverse=True):
             if limit > 0 and count >= limit:
                 return
             count += 1
             if closed:
                 status = b'closed'
             elif ctx.node() not in heads:
                 status = b'inactive'
             else:
                 status = b'open'
             yield {
                 b'parity': next(parity),
                 b'branch': ctx.branch(),
                 b'status': status,
                 b'node': ctx.hex(),
                 b'date': ctx.date(),
             }
 
     return templateutil.mappinggenerator(entries)
 
 
 def cleanpath(repo, path):
     path = path.lstrip(b'/')
     auditor = pathutil.pathauditor(repo.root, realfs=False)
     return pathutil.canonpath(repo.root, b'', path, auditor=auditor)
 
 
 def changectx(repo, req):
     changeid = b"tip"
     if b'node' in req.qsparams:
         changeid = req.qsparams[b'node']
         ipos = changeid.find(b':')
         if ipos != -1:
             changeid = changeid[(ipos + 1) :]
 
     return scmutil.revsymbol(repo, changeid)
 
 
 def basechangectx(repo, req):
     if b'node' in req.qsparams:
         changeid = req.qsparams[b'node']
         ipos = changeid.find(b':')
         if ipos != -1:
             changeid = changeid[:ipos]
             return scmutil.revsymbol(repo, changeid)
 
     return None
 
 
 def filectx(repo, req):
     if b'file' not in req.qsparams:
         raise ErrorResponse(HTTP_NOT_FOUND, b'file not given')
     path = cleanpath(repo, req.qsparams[b'file'])
     if b'node' in req.qsparams:
         changeid = req.qsparams[b'node']
     elif b'filenode' in req.qsparams:
         changeid = req.qsparams[b'filenode']
     else:
         raise ErrorResponse(HTTP_NOT_FOUND, b'node or filenode not given')
     try:
         fctx = scmutil.revsymbol(repo, changeid)[path]
     except error.RepoError:
         fctx = repo.filectx(path, fileid=changeid)
 
     return fctx
 
 
 def linerange(req):
     linerange = req.qsparams.getall(b'linerange')
     if not linerange:
         return None
     if len(linerange) > 1:
         raise ErrorResponse(HTTP_BAD_REQUEST, b'redundant linerange parameter')
     try:
         fromline, toline = map(int, linerange[0].split(b':', 1))
     except ValueError:
         raise ErrorResponse(HTTP_BAD_REQUEST, b'invalid linerange parameter')
     try:
         return util.processlinerange(fromline, toline)
     except error.ParseError as exc:
         raise ErrorResponse(HTTP_BAD_REQUEST, pycompat.bytestr(exc))
 
 
 def formatlinerange(fromline, toline):
     return b'%d:%d' % (fromline + 1, toline)
 
 
 def _succsandmarkersgen(context, mapping):
     repo = context.resource(mapping, b'repo')
     itemmappings = templatekw.showsuccsandmarkers(context, mapping)
     for item in itemmappings.tovalue(context, mapping):
         item[b'successors'] = _siblings(
             repo[successor] for successor in item[b'successors']
         )
         yield item
 
 
 def succsandmarkers(context, mapping):
     return templateutil.mappinggenerator(_succsandmarkersgen, args=(mapping,))
 
 
 # teach templater succsandmarkers is switched to (context, mapping) API
 succsandmarkers._requires = {b'repo', b'ctx'}
 
 
 def _whyunstablegen(context, mapping):
     repo = context.resource(mapping, b'repo')
     ctx = context.resource(mapping, b'ctx')
 
     entries = obsutil.whyunstable(repo, ctx)
     for entry in entries:
         if entry.get(b'divergentnodes'):
             entry[b'divergentnodes'] = _siblings(entry[b'divergentnodes'])
         yield entry
 
 
 def whyunstable(context, mapping):
     return templateutil.mappinggenerator(_whyunstablegen, args=(mapping,))
 
 
 whyunstable._requires = {b'repo', b'ctx'}
 
 
 def commonentry(repo, ctx):
     node = scmutil.binnode(ctx)
     return {
         # TODO: perhaps ctx.changectx() should be assigned if ctx is a
         # filectx, but I'm not pretty sure if that would always work because
         # fctx.parents() != fctx.changectx.parents() for example.
         b'ctx': ctx,
         b'rev': ctx.rev(),
         b'node': hex(node),
         b'author': ctx.user(),
         b'desc': ctx.description(),
         b'date': ctx.date(),
         b'extra': ctx.extra(),
         b'phase': ctx.phasestr(),
         b'obsolete': ctx.obsolete(),
         b'succsandmarkers': succsandmarkers,
         b'instabilities': templateutil.hybridlist(
             ctx.instabilities(), name=b'instability'
         ),
         b'whyunstable': whyunstable,
         b'branch': nodebranchnodefault(ctx),
         b'inbranch': nodeinbranch(repo, ctx),
         b'branches': nodebranchdict(repo, ctx),
         b'tags': nodetagsdict(repo, node),
         b'bookmarks': nodebookmarksdict(repo, node),
         b'parent': lambda context, mapping: parents(ctx),
         b'child': lambda context, mapping: children(ctx),
     }
 
 
 def changelistentry(web, ctx):
     '''Obtain a dictionary to be used for entries in a changelist.
 
     This function is called when producing items for the "entries" list passed
     to the "shortlog" and "changelog" templates.
     '''
     repo = web.repo
     rev = ctx.rev()
     n = scmutil.binnode(ctx)
     showtags = showtag(repo, b'changelogtag', n)
     files = listfilediffs(ctx.files(), n, web.maxfiles)
 
     entry = commonentry(repo, ctx)
     entry.update(
         {
             b'allparents': lambda context, mapping: parents(ctx),
             b'parent': lambda context, mapping: parents(ctx, rev - 1),
             b'child': lambda context, mapping: children(ctx, rev + 1),
             b'changelogtag': showtags,
             b'files': files,
         }
     )
     return entry
 
 
 def changelistentries(web, revs, maxcount, parityfn):
     """Emit up to N records for an iterable of revisions."""
     repo = web.repo
 
     count = 0
     for rev in revs:
         if count >= maxcount:
             break
 
         count += 1
 
         entry = changelistentry(web, repo[rev])
         entry[b'parity'] = next(parityfn)
 
         yield entry
 
 
 def symrevorshortnode(req, ctx):
     if b'node' in req.qsparams:
         return templatefilters.revescape(req.qsparams[b'node'])
     else:
         return short(scmutil.binnode(ctx))
 
 
 def _listfilesgen(context, ctx, stripecount):
     parity = paritygen(stripecount)
     filesadded = ctx.filesadded()
     for blockno, f in enumerate(ctx.files()):
         if f not in ctx:
             status = b'removed'
         elif f in filesadded:
             status = b'added'
         else:
             status = b'modified'
         template = b'filenolink' if status == b'removed' else b'filenodelink'
         yield context.process(
             template,
             {
                 b'node': ctx.hex(),
                 b'file': f,
                 b'blockno': blockno + 1,
                 b'parity': next(parity),
                 b'status': status,
             },
         )
 
 
 def changesetentry(web, ctx):
     '''Obtain a dictionary to be used to render the "changeset" template.'''
 
     showtags = showtag(web.repo, b'changesettag', scmutil.binnode(ctx))
     showbookmarks = showbookmark(
         web.repo, b'changesetbookmark', scmutil.binnode(ctx)
     )
     showbranch = nodebranchnodefault(ctx)
 
     basectx = basechangectx(web.repo, web.req)
     if basectx is None:
         basectx = ctx.p1()
 
     style = web.config(b'web', b'style')
     if b'style' in web.req.qsparams:
         style = web.req.qsparams[b'style']
 
     diff = diffs(web, ctx, basectx, None, style)
 
     parity = paritygen(web.stripecount)
     diffstatsgen = diffstatgen(web.repo.ui, ctx, basectx)
     diffstats = diffstat(ctx, diffstatsgen, parity)
 
     return dict(
         diff=diff,
         symrev=symrevorshortnode(web.req, ctx),
         basenode=basectx.hex(),
         changesettag=showtags,
         changesetbookmark=showbookmarks,
         changesetbranch=showbranch,
         files=templateutil.mappedgenerator(
             _listfilesgen, args=(ctx, web.stripecount)
         ),
         diffsummary=lambda context, mapping: diffsummary(diffstatsgen),
         diffstat=diffstats,
         archives=web.archivelist(ctx.hex()),
         **pycompat.strkwargs(commonentry(web.repo, ctx))
     )
 
 
 def _listfilediffsgen(context, files, node, max):
     for f in files[:max]:
         yield context.process(b'filedifflink', {b'node': hex(node), b'file': f})
     if len(files) > max:
         yield context.process(b'fileellipses', {})
 
 
 def listfilediffs(files, node, max):
     return templateutil.mappedgenerator(
         _listfilediffsgen, args=(files, node, max)
     )
 
 
 def _prettyprintdifflines(context, lines, blockno, lineidprefix):
     for lineno, l in enumerate(lines, 1):
         difflineno = b"%d.%d" % (blockno, lineno)
         if l.startswith(b'+'):
             ltype = b"difflineplus"
         elif l.startswith(b'-'):
             ltype = b"difflineminus"
         elif l.startswith(b'@'):
             ltype = b"difflineat"
         else:
             ltype = b"diffline"
         yield context.process(
             ltype,
             {
                 b'line': l,
                 b'lineno': lineno,
                 b'lineid': lineidprefix + b"l%s" % difflineno,
                 b'linenumber': b"% 8s" % difflineno,
             },
         )
 
 
 def _diffsgen(
     context,
     repo,
     ctx,
     basectx,
     files,
     style,
     stripecount,
     linerange,
     lineidprefix,
 ):
     if files:
         m = match.exact(files)
     else:
         m = match.always()
 
     diffopts = patch.diffopts(repo.ui, untrusted=True)
     parity = paritygen(stripecount)
 
     diffhunks = patch.diffhunks(repo, basectx, ctx, m, opts=diffopts)
     for blockno, (fctx1, fctx2, header, hunks) in enumerate(diffhunks, 1):
         if style != b'raw':
             header = header[1:]
         lines = [h + b'\n' for h in header]
         for hunkrange, hunklines in hunks:
             if linerange is not None and hunkrange is not None:
                 s1, l1, s2, l2 = hunkrange
                 if not mdiff.hunkinrange((s2, l2), linerange):
                     continue
             lines.extend(hunklines)
         if lines:
             l = templateutil.mappedgenerator(
                 _prettyprintdifflines, args=(lines, blockno, lineidprefix)
             )
             yield {
                 b'parity': next(parity),
                 b'blockno': blockno,
                 b'lines': l,
             }
 
 
 def diffs(web, ctx, basectx, files, style, linerange=None, lineidprefix=b''):
     args = (
         web.repo,
         ctx,
         basectx,
         files,
         style,
         web.stripecount,
         linerange,
         lineidprefix,
     )
     return templateutil.mappinggenerator(
         _diffsgen, args=args, name=b'diffblock'
     )
 
 
 def _compline(type, leftlineno, leftline, rightlineno, rightline):
     lineid = leftlineno and (b"l%d" % leftlineno) or b''
     lineid += rightlineno and (b"r%d" % rightlineno) or b''
     llno = b'%d' % leftlineno if leftlineno else b''
     rlno = b'%d' % rightlineno if rightlineno else b''
     return {
         b'type': type,
         b'lineid': lineid,
         b'leftlineno': leftlineno,
         b'leftlinenumber': b"% 6s" % llno,
         b'leftline': leftline or b'',
         b'rightlineno': rightlineno,
         b'rightlinenumber': b"% 6s" % rlno,
         b'rightline': rightline or b'',
     }
 
 
 def _getcompblockgen(context, leftlines, rightlines, opcodes):
     for type, llo, lhi, rlo, rhi in opcodes:
         type = pycompat.sysbytes(type)
         len1 = lhi - llo
         len2 = rhi - rlo
         count = min(len1, len2)
         for i in pycompat.xrange(count):
             yield _compline(
                 type=type,
                 leftlineno=llo + i + 1,
                 leftline=leftlines[llo + i],
                 rightlineno=rlo + i + 1,
                 rightline=rightlines[rlo + i],
             )
         if len1 > len2:
             for i in pycompat.xrange(llo + count, lhi):
                 yield _compline(
                     type=type,
                     leftlineno=i + 1,
                     leftline=leftlines[i],
                     rightlineno=None,
                     rightline=None,
                 )
         elif len2 > len1:
             for i in pycompat.xrange(rlo + count, rhi):
                 yield _compline(
                     type=type,
                     leftlineno=None,
                     leftline=None,
                     rightlineno=i + 1,
                     rightline=rightlines[i],
                 )
 
 
 def _getcompblock(leftlines, rightlines, opcodes):
     args = (leftlines, rightlines, opcodes)
     return templateutil.mappinggenerator(
         _getcompblockgen, args=args, name=b'comparisonline'
     )
 
 
 def _comparegen(context, contextnum, leftlines, rightlines):
     '''Generator function that provides side-by-side comparison data.'''
     s = difflib.SequenceMatcher(None, leftlines, rightlines)
     if contextnum < 0:
         l = _getcompblock(leftlines, rightlines, s.get_opcodes())
         yield {b'lines': l}
     else:
         for oc in s.get_grouped_opcodes(n=contextnum):
             l = _getcompblock(leftlines, rightlines, oc)
             yield {b'lines': l}
 
 
 def compare(contextnum, leftlines, rightlines):
     args = (contextnum, leftlines, rightlines)
     return templateutil.mappinggenerator(
         _comparegen, args=args, name=b'comparisonblock'
     )
 
 
 def diffstatgen(ui, ctx, basectx):
     '''Generator function that provides the diffstat data.'''
 
     diffopts = patch.diffopts(ui, {b'noprefix': False})
     stats = patch.diffstatdata(util.iterlines(ctx.diff(basectx, opts=diffopts)))
     maxname, maxtotal, addtotal, removetotal, binary = patch.diffstatsum(stats)
     while True:
         yield stats, maxname, maxtotal, addtotal, removetotal, binary
 
 
 def diffsummary(statgen):
     '''Return a short summary of the diff.'''
 
     stats, maxname, maxtotal, addtotal, removetotal, binary = next(statgen)
     return _(b' %d files changed, %d insertions(+), %d deletions(-)\n') % (
         len(stats),
         addtotal,
         removetotal,
     )
 
 
 def _diffstattmplgen(context, ctx, statgen, parity):
     stats, maxname, maxtotal, addtotal, removetotal, binary = next(statgen)
     files = ctx.files()
 
     def pct(i):
         if maxtotal == 0:
             return 0
         return (float(i) / maxtotal) * 100
 
     fileno = 0
     for filename, adds, removes, isbinary in stats:
         template = b'diffstatlink' if filename in files else b'diffstatnolink'
         total = adds + removes
         fileno += 1
         yield context.process(
             template,
             {
                 b'node': ctx.hex(),
                 b'file': filename,
                 b'fileno': fileno,
                 b'total': total,
                 b'addpct': pct(adds),
                 b'removepct': pct(removes),
                 b'parity': next(parity),
             },
         )
 
 
 def diffstat(ctx, statgen, parity):
     '''Return a diffstat template for each file in the diff.'''
     args = (ctx, statgen, parity)
     return templateutil.mappedgenerator(_diffstattmplgen, args=args)
 
 
 class sessionvars(templateutil.wrapped):
     def __init__(self, vars, start=b'?'):
         self._start = start
         self._vars = vars
 
     def __getitem__(self, key):
         return self._vars[key]
 
     def __setitem__(self, key, value):
         self._vars[key] = value
 
     def __copy__(self):
         return sessionvars(copy.copy(self._vars), self._start)
 
     def contains(self, context, mapping, item):
         item = templateutil.unwrapvalue(context, mapping, item)
         return item in self._vars
 
     def getmember(self, context, mapping, key):
         key = templateutil.unwrapvalue(context, mapping, key)
         return self._vars.get(key)
 
     def getmin(self, context, mapping):
         raise error.ParseError(_(b'not comparable'))
 
     def getmax(self, context, mapping):
         raise error.ParseError(_(b'not comparable'))
 
     def filter(self, context, mapping, select):
         # implement if necessary
         raise error.ParseError(_(b'not filterable'))
 
     def itermaps(self, context):
         separator = self._start
         for key, value in sorted(pycompat.iteritems(self._vars)):
             yield {
                 b'name': key,
                 b'value': pycompat.bytestr(value),
                 b'separator': separator,
             }
             separator = b'&'
 
     def join(self, context, mapping, sep):
         # could be '{separator}{name}={value|urlescape}'
         raise error.ParseError(_(b'not displayable without template'))
 
     def show(self, context, mapping):
         return self.join(context, mapping, b'')
 
     def tobool(self, context, mapping):
         return bool(self._vars)
 
     def tovalue(self, context, mapping):
         return self._vars
 
 
 class wsgiui(uimod.ui):
     # default termwidth breaks under mod_wsgi
     def termwidth(self):
         return 80
 
 
 def getwebsubs(repo):
     websubtable = []
     websubdefs = repo.ui.configitems(b'websub')
     # we must maintain interhg backwards compatibility
     websubdefs += repo.ui.configitems(b'interhg')
     for key, pattern in websubdefs:
         # grab the delimiter from the character after the "s"
         unesc = pattern[1:2]
         delim = stringutil.reescape(unesc)
 
         # identify portions of the pattern, taking care to avoid escaped
         # delimiters. the replace format and flags are optional, but
         # delimiters are required.
         match = re.match(
             br'^s%s(.+)(?:(?<=\\\\)|(?<!\\))%s(.*)%s([ilmsux])*$'
             % (delim, delim, delim),
             pattern,
         )
         if not match:
             repo.ui.warn(
                 _(b"websub: invalid pattern for %s: %s\n") % (key, pattern)
             )
             continue
 
         # we need to unescape the delimiter for regexp and format
         delim_re = re.compile(br'(?<!\\)\\%s' % delim)
         regexp = delim_re.sub(unesc, match.group(1))
         format = delim_re.sub(unesc, match.group(2))
 
         # the pattern allows for 6 regexp flags, so set them if necessary
         flagin = match.group(3)
         flags = 0
         if flagin:
             for flag in pycompat.sysstr(flagin.upper()):
                 flags |= re.__dict__[flag]
 
         try:
             regexp = re.compile(regexp, flags)
             websubtable.append((regexp, format))
         except re.error:
             repo.ui.warn(
                 _(b"websub: invalid regexp for %s: %s\n") % (key, regexp)
             )
     return websubtable
 
 
 def getgraphnode(repo, ctx):
     return templatekw.getgraphnodecurrent(
-        repo, ctx
+        repo, ctx, {}
     ) + templatekw.getgraphnodesymbol(ctx)

mercurial/logcmdutil.py

@@ -1,1088 +1,1089 b''
 # logcmdutil.py - utility for log-like commands
 #
 # Copyright 2005-2007 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import itertools
 import os
 import posixpath
 
 from .i18n import _
 from .node import (
     nullid,
     wdirid,
     wdirrev,
 )
 
 from . import (
     dagop,
     error,
     formatter,
     graphmod,
     match as matchmod,
     mdiff,
     patch,
     pathutil,
     pycompat,
     revset,
     revsetlang,
     scmutil,
     smartset,
     templatekw,
     templater,
     util,
 )
 from .utils import (
     dateutil,
     stringutil,
 )
 
 
 if pycompat.TYPE_CHECKING:
     from typing import (
         Any,
         Optional,
         Tuple,
     )
 
     for t in (Any, 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.Abort(_(b'limit must be a positive integer'))
         if limit <= 0:
             raise error.Abort(_(b'limit must be positive'))
     else:
         limit = None
     return limit
 
 
 def diffordiffstat(
     ui,
     repo,
     diffopts,
     node1,
     node2,
     match,
     changes=None,
     stat=False,
     fp=None,
     graphwidth=0,
     prefix=b'',
     root=b'',
     listsubrepos=False,
     hunksfilterfn=None,
 ):
     '''show diff or diffstat.'''
     ctx1 = repo[node1]
     ctx2 = repo[node2]
     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)
 
     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):
         repo = ctx.repo()
         node = ctx.node()
         prev = ctx.p1().node()
         diffordiffstat(
             ui,
             repo,
             diffopts,
             prev,
             node,
             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 = 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 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):
     if pycompat.ispy3:
         assert not isinstance(tmpl, str), b'tmpl must not be a str'
     if mapfile:
         return formatter.templatespec(b'changeset', tmpl, mapfile)
     else:
         return formatter.templatespec(b'', tmpl, None)
 
 
 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'ui', b'logtemplate')
         if tmpl:
             return templatespec(templater.unquotestring(tmpl), None)
         else:
             style = util.expandpath(ui.config(b'ui', b'style'))
 
     if not tmpl and style:
         mapfile = style
         if not os.path.split(mapfile)[0]:
             mapname = templater.templatepath(
                 b'map-cmdline.' + mapfile
             ) or templater.templatepath(mapfile)
             if mapname:
                 mapfile = mapname
         return templatespec(None, mapfile)
 
     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 = templatespec(tmpl, None)
     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. [ui] setting 'logtemplate'
     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)
 
 
 def _makematcher(repo, revs, pats, opts):
     """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 walkchangerevs() builds 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, pats, opts)
     slowpath = match.anypats() or (not match.always() and opts.get(b'removed'))
     if not slowpath:
         follow = opts.get(b'follow') or opts.get(b'follow_first')
         startctxs = []
         if follow and opts.get(b'rev'):
             startctxs = [repo[r] for r in revs]
         for f in match.files():
             if follow and startctxs:
                 # No idea if the path was a directory at that revision, so
                 # take the slow path.
                 if any(f not in c for c in startctxs):
                     slowpath = True
                     continue
             elif follow and 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(
                         _(
                             b'cannot follow file not in parent '
                             b'revision: "%s"'
                         )
                         % f
                     )
             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.
                 if follow:
                     raise error.Abort(
                         _(b'cannot follow nonexistent file: "%s"') % f
                     )
                 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 path == b'.' 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(ctx.rev(), []))
 
     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
 
 
 _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, match, pats, slowpath, opts):
     """Return a revset string built from log options and file patterns"""
     opts = dict(opts)
     # follow or not follow?
     follow = opts.get(b'follow') or opts.get(b'follow_first')
 
     # branch and only_branch are really aliases and must be handled at
     # the same time
     opts[b'branch'] = opts.get(b'branch', []) + opts.get(b'only_branch', [])
     opts[b'branch'] = [repo.lookupbranch(b) for b in opts[b'branch']]
 
     if slowpath:
         # See walkchangerevs() slow path.
         #
         # 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 pats:
             matchargs.append(b'p:' + p)
         for p in opts.get(b'include', []):
             matchargs.append(b'i:' + p)
         for p in opts.get(b'exclude', []):
             matchargs.append(b'x:' + p)
         opts[b'_matchfiles'] = matchargs
     elif not follow:
         opts[b'_patslog'] = list(pats)
 
     expr = []
     for op, val in sorted(pycompat.iteritems(opts)):
         if not val:
             continue
         if op not in _opt2logrevset:
             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 expr:
         expr = b'(' + b' and '.join(expr) + b')'
     else:
         expr = None
     return expr
 
 
 def _initialrevs(repo, opts):
     """Return the initial set of revisions to be filtered or followed"""
     follow = opts.get(b'follow') or opts.get(b'follow_first')
     if opts.get(b'rev'):
         revs = scmutil.revrange(repo, opts[b'rev'])
     elif follow and repo.dirstate.p1() == nullid:
         revs = smartset.baseset()
     elif follow:
         revs = repo.revs(b'.')
     else:
         revs = smartset.spanset(repo)
         revs.reverse()
     return revs
 
 
 def getrevs(repo, pats, opts):
     # type: (Any, Any, Any) -> Tuple[smartset.abstractsmartset, Optional[changesetdiffer]]
     """Return (revs, differ) where revs is a smartset
 
     differ is a changesetdiffer with pre-configured file matcher.
     """
     follow = opts.get(b'follow') or opts.get(b'follow_first')
     followfirst = opts.get(b'follow_first')
     limit = getlimit(opts)
     revs = _initialrevs(repo, opts)
     if not revs:
         return smartset.baseset(), None
     match, pats, slowpath = _makematcher(repo, revs, pats, opts)
     filematcher = None
     if follow:
         if slowpath or match.always():
             revs = dagop.revancestors(repo, revs, followfirst=followfirst)
         else:
             revs, filematcher = _fileancestors(repo, revs, match, followfirst)
         revs.reverse()
     if filematcher is None:
         filematcher = _makenofollowfilematcher(repo, pats, opts)
     if filematcher is None:
 
         def filematcher(ctx):
             return match
 
     expr = _makerevset(repo, match, pats, slowpath, opts)
     if opts.get(b'graph'):
         # User-specified revs might be unsorted, but don't sort before
         # _makerevset because it might depend on the order of revs
         if repo.ui.configbool(b'experimental', b'log.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()):
             revs.sort(reverse=True)
     if expr:
         matcher = revset.match(None, expr)
         revs = matcher(repo, revs)
     if limit is not None:
         revs = revs.slice(0, limit)
 
     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.Abort(_(b'malformatted line-range pattern %s') % pat)
         try:
             fromline, toline = map(int, linerange.split(b':'))
         except ValueError:
             raise error.Abort(_(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(
                 _(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'ui', b'graphnodetemplate')
     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):
+    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)
+        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.Abort(
                 _(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)

mercurial/templatekw.py

@@ -1,992 +1,1004 b''
 # templatekw.py - common changeset template keywords
 #
 # Copyright 2005-2009 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 from .i18n import _
 from .node import (
     hex,
     nullid,
     wdirid,
     wdirrev,
 )
 
 from . import (
     diffutil,
     encoding,
     error,
     hbisect,
     i18n,
     obsutil,
     patch,
     pycompat,
     registrar,
     scmutil,
     templateutil,
     util,
 )
 from .utils import stringutil
 
 _hybrid = templateutil.hybrid
 hybriddict = templateutil.hybriddict
 hybridlist = templateutil.hybridlist
 compatdict = templateutil.compatdict
 compatlist = templateutil.compatlist
 _showcompatlist = templateutil._showcompatlist
 
 
 def getlatesttags(context, mapping, pattern=None):
     '''return date, distance and name for the latest tag of rev'''
     repo = context.resource(mapping, b'repo')
     ctx = context.resource(mapping, b'ctx')
     cache = context.resource(mapping, b'cache')
 
     cachename = b'latesttags'
     if pattern is not None:
         cachename += b'-' + pattern
         match = stringutil.stringmatcher(pattern)[2]
     else:
         match = util.always
 
     if cachename not in cache:
         # Cache mapping from rev to a tuple with tag date, tag
         # distance and tag name
         cache[cachename] = {-1: (0, 0, [b'null'])}
     latesttags = cache[cachename]
 
     rev = ctx.rev()
     todo = [rev]
     while todo:
         rev = todo.pop()
         if rev in latesttags:
             continue
         ctx = repo[rev]
         tags = [
             t
             for t in ctx.tags()
             if (repo.tagtype(t) and repo.tagtype(t) != b'local' and match(t))
         ]
         if tags:
             latesttags[rev] = ctx.date()[0], 0, [t for t in sorted(tags)]
             continue
         try:
             ptags = [latesttags[p.rev()] for p in ctx.parents()]
             if len(ptags) > 1:
                 if ptags[0][2] == ptags[1][2]:
                     # The tuples are laid out so the right one can be found by
                     # comparison in this case.
                     pdate, pdist, ptag = max(ptags)
                 else:
 
                     def key(x):
                         tag = x[2][0]
                         if ctx.rev() is None:
                             # only() doesn't support wdir
                             prevs = [c.rev() for c in ctx.parents()]
                             changes = repo.revs(b'only(%ld, %s)', prevs, tag)
                             changessincetag = len(changes) + 1
                         else:
                             changes = repo.revs(b'only(%d, %s)', ctx.rev(), tag)
                             changessincetag = len(changes)
                         # Smallest number of changes since tag wins. Date is
                         # used as tiebreaker.
                         return [-changessincetag, x[0]]
 
                     pdate, pdist, ptag = max(ptags, key=key)
             else:
                 pdate, pdist, ptag = ptags[0]
         except KeyError:
             # Cache miss - recurse
             todo.append(rev)
             todo.extend(p.rev() for p in ctx.parents())
             continue
         latesttags[rev] = pdate, pdist + 1, ptag
     return latesttags[rev]
 
 
 def getlogcolumns():
     """Return a dict of log column labels"""
     _ = pycompat.identity  # temporarily disable gettext
     # i18n: column positioning for "hg log"
     columns = _(
         b'bookmark:    %s\n'
         b'branch:      %s\n'
         b'changeset:   %s\n'
         b'copies:      %s\n'
         b'date:        %s\n'
         b'extra:       %s=%s\n'
         b'files+:      %s\n'
         b'files-:      %s\n'
         b'files:       %s\n'
         b'instability: %s\n'
         b'manifest:    %s\n'
         b'obsolete:    %s\n'
         b'parent:      %s\n'
         b'phase:       %s\n'
         b'summary:     %s\n'
         b'tag:         %s\n'
         b'user:        %s\n'
     )
     return dict(
         zip(
             [s.split(b':', 1)[0] for s in columns.splitlines()],
             i18n._(columns).splitlines(True),
         )
     )
 
 
 # basic internal templates
 _changeidtmpl = b'{rev}:{node|formatnode}'
 
 # default templates internally used for rendering of lists
 defaulttempl = {
     b'parent': _changeidtmpl + b' ',
     b'manifest': _changeidtmpl,
     b'file_copy': b'{name} ({source})',
     b'envvar': b'{key}={value}',
     b'extra': b'{key}={value|stringescape}',
 }
 # filecopy is preserved for compatibility reasons
 defaulttempl[b'filecopy'] = defaulttempl[b'file_copy']
 
 # keywords are callables (see registrar.templatekeyword for details)
 keywords = {}
 templatekeyword = registrar.templatekeyword(keywords)
 
 
 @templatekeyword(b'author', requires={b'ctx'})
 def showauthor(context, mapping):
     """Alias for ``{user}``"""
     return showuser(context, mapping)
 
 
 @templatekeyword(b'bisect', requires={b'repo', b'ctx'})
 def showbisect(context, mapping):
     """String. The changeset bisection status."""
     repo = context.resource(mapping, b'repo')
     ctx = context.resource(mapping, b'ctx')
     return hbisect.label(repo, ctx.node())
 
 
 @templatekeyword(b'branch', requires={b'ctx'})
 def showbranch(context, mapping):
     """String. The name of the branch on which the changeset was
     committed.
     """
     ctx = context.resource(mapping, b'ctx')
     return ctx.branch()
 
 
 @templatekeyword(b'branches', requires={b'ctx'})
 def showbranches(context, mapping):
     """List of strings. The name of the branch on which the
     changeset was committed. Will be empty if the branch name was
     default. (DEPRECATED)
     """
     ctx = context.resource(mapping, b'ctx')
     branch = ctx.branch()
     if branch != b'default':
         return compatlist(
             context, mapping, b'branch', [branch], plural=b'branches'
         )
     return compatlist(context, mapping, b'branch', [], plural=b'branches')
 
 
 @templatekeyword(b'bookmarks', requires={b'repo', b'ctx'})
 def showbookmarks(context, mapping):
     """List of strings. Any bookmarks associated with the
     changeset. Also sets 'active', the name of the active bookmark.
     """
     repo = context.resource(mapping, b'repo')
     ctx = context.resource(mapping, b'ctx')
     bookmarks = ctx.bookmarks()
     active = repo._activebookmark
     makemap = lambda v: {b'bookmark': v, b'active': active, b'current': active}
     f = _showcompatlist(context, mapping, b'bookmark', bookmarks)
     return _hybrid(f, bookmarks, makemap, pycompat.identity)
 
 
 @templatekeyword(b'children', requires={b'ctx'})
 def showchildren(context, mapping):
     """List of strings. The children of the changeset."""
     ctx = context.resource(mapping, b'ctx')
     childrevs = [b'%d:%s' % (cctx.rev(), cctx) for cctx in ctx.children()]
     return compatlist(
         context, mapping, b'children', childrevs, element=b'child'
     )
 
 
 # Deprecated, but kept alive for help generation a purpose.
 @templatekeyword(b'currentbookmark', requires={b'repo', b'ctx'})
 def showcurrentbookmark(context, mapping):
     """String. The active bookmark, if it is associated with the changeset.
     (DEPRECATED)"""
     return showactivebookmark(context, mapping)
 
 
 @templatekeyword(b'activebookmark', requires={b'repo', b'ctx'})
 def showactivebookmark(context, mapping):
     """String. The active bookmark, if it is associated with the changeset."""
     repo = context.resource(mapping, b'repo')
     ctx = context.resource(mapping, b'ctx')
     active = repo._activebookmark
     if active and active in ctx.bookmarks():
         return active
     return b''
 
 
 @templatekeyword(b'date', requires={b'ctx'})
 def showdate(context, mapping):
     """Date information. The date when the changeset was committed."""
     ctx = context.resource(mapping, b'ctx')
     # the default string format is '<float(unixtime)><tzoffset>' because
     # python-hglib splits date at decimal separator.
     return templateutil.date(ctx.date(), showfmt=b'%d.0%d')
 
 
 @templatekeyword(b'desc', requires={b'ctx'})
 def showdescription(context, mapping):
     """String. The text of the changeset description."""
     ctx = context.resource(mapping, b'ctx')
     s = ctx.description()
     if isinstance(s, encoding.localstr):
         # try hard to preserve utf-8 bytes
         return encoding.tolocal(encoding.fromlocal(s).strip())
     elif isinstance(s, encoding.safelocalstr):
         return encoding.safelocalstr(s.strip())
     else:
         return s.strip()
 
 
 @templatekeyword(b'diffstat', requires={b'ui', b'ctx'})
 def showdiffstat(context, mapping):
     """String. Statistics of changes with the following format:
     "modified files: +added/-removed lines"
     """
     ui = context.resource(mapping, b'ui')
     ctx = context.resource(mapping, b'ctx')
     diffopts = diffutil.diffallopts(ui, {b'noprefix': False})
     diff = ctx.diff(opts=diffopts)
     stats = patch.diffstatdata(util.iterlines(diff))
     maxname, maxtotal, adds, removes, binary = patch.diffstatsum(stats)
     return b'%d: +%d/-%d' % (len(stats), adds, removes)
 
 
 @templatekeyword(b'envvars', requires={b'ui'})
 def showenvvars(context, mapping):
     """A dictionary of environment variables. (EXPERIMENTAL)"""
     ui = context.resource(mapping, b'ui')
     env = ui.exportableenviron()
     env = util.sortdict((k, env[k]) for k in sorted(env))
     return compatdict(context, mapping, b'envvar', env, plural=b'envvars')
 
 
 @templatekeyword(b'extras', requires={b'ctx'})
 def showextras(context, mapping):
     """List of dicts with key, value entries of the 'extras'
     field of this changeset."""
     ctx = context.resource(mapping, b'ctx')
     extras = ctx.extra()
     extras = util.sortdict((k, extras[k]) for k in sorted(extras))
     makemap = lambda k: {b'key': k, b'value': extras[k]}
     c = [makemap(k) for k in extras]
     f = _showcompatlist(context, mapping, b'extra', c, plural=b'extras')
     return _hybrid(
         f,
         extras,
         makemap,
         lambda k: b'%s=%s' % (k, stringutil.escapestr(extras[k])),
     )
 
 
 def _getfilestatus(context, mapping, listall=False):
     ctx = context.resource(mapping, b'ctx')
     revcache = context.resource(mapping, b'revcache')
     if b'filestatus' not in revcache or revcache[b'filestatusall'] < listall:
         stat = ctx.p1().status(
             ctx, listignored=listall, listclean=listall, listunknown=listall
         )
         revcache[b'filestatus'] = stat
         revcache[b'filestatusall'] = listall
     return revcache[b'filestatus']
 
 
 def _getfilestatusmap(context, mapping, listall=False):
     revcache = context.resource(mapping, b'revcache')
     if b'filestatusmap' not in revcache or revcache[b'filestatusall'] < listall:
         stat = _getfilestatus(context, mapping, listall=listall)
         revcache[b'filestatusmap'] = statmap = {}
         for char, files in zip(pycompat.iterbytestr(b'MAR!?IC'), stat):
             statmap.update((f, char) for f in files)
     return revcache[b'filestatusmap']  # {path: statchar}
 
 
 @templatekeyword(
     b'file_copies', requires={b'repo', b'ctx', b'cache', b'revcache'}
 )
 def showfilecopies(context, mapping):
     """List of strings. Files copied in this changeset with
     their sources.
     """
     repo = context.resource(mapping, b'repo')
     ctx = context.resource(mapping, b'ctx')
     cache = context.resource(mapping, b'cache')
     copies = context.resource(mapping, b'revcache').get(b'copies')
     if copies is None:
         if b'getcopies' not in cache:
             cache[b'getcopies'] = scmutil.getcopiesfn(repo)
         getcopies = cache[b'getcopies']
         copies = getcopies(ctx)
     return templateutil.compatfilecopiesdict(
         context, mapping, b'file_copy', copies
     )
 
 
 # showfilecopiesswitch() displays file copies only if copy records are
 # provided before calling the templater, usually with a --copies
 # command line switch.
 @templatekeyword(b'file_copies_switch', requires={b'revcache'})
 def showfilecopiesswitch(context, mapping):
     """List of strings. Like "file_copies" but displayed
     only if the --copied switch is set.
     """
     copies = context.resource(mapping, b'revcache').get(b'copies') or []
     return templateutil.compatfilecopiesdict(
         context, mapping, b'file_copy', copies
     )
 
 
 @templatekeyword(b'file_adds', requires={b'ctx', b'revcache'})
 def showfileadds(context, mapping):
     """List of strings. Files added by this changeset."""
     ctx = context.resource(mapping, b'ctx')
     return templateutil.compatfileslist(
         context, mapping, b'file_add', ctx.filesadded()
     )
 
 
 @templatekeyword(b'file_dels', requires={b'ctx', b'revcache'})
 def showfiledels(context, mapping):
     """List of strings. Files removed by this changeset."""
     ctx = context.resource(mapping, b'ctx')
     return templateutil.compatfileslist(
         context, mapping, b'file_del', ctx.filesremoved()
     )
 
 
 @templatekeyword(b'file_mods', requires={b'ctx', b'revcache'})
 def showfilemods(context, mapping):
     """List of strings. Files modified by this changeset."""
     ctx = context.resource(mapping, b'ctx')
     return templateutil.compatfileslist(
         context, mapping, b'file_mod', ctx.filesmodified()
     )
 
 
 @templatekeyword(b'files', requires={b'ctx'})
 def showfiles(context, mapping):
     """List of strings. All files modified, added, or removed by this
     changeset.
     """
     ctx = context.resource(mapping, b'ctx')
     return templateutil.compatfileslist(context, mapping, b'file', ctx.files())
 
 
-@templatekeyword(b'graphnode', requires={b'repo', b'ctx'})
+@templatekeyword(b'graphnode', requires={b'repo', b'ctx', b'cache'})
 def showgraphnode(context, mapping):
     """String. The character representing the changeset node in an ASCII
     revision graph."""
     repo = context.resource(mapping, b'repo')
     ctx = context.resource(mapping, b'ctx')
-    return getgraphnode(repo, ctx)
+    cache = context.resource(mapping, b'cache')
+    return getgraphnode(repo, ctx, cache)
 
 
-def getgraphnode(repo, ctx):
-    return getgraphnodecurrent(repo, ctx) or getgraphnodesymbol(ctx)
+def getgraphnode(repo, ctx, cache):
+    return getgraphnodecurrent(repo, ctx, cache) or getgraphnodesymbol(ctx)
 
 
-def getgraphnodecurrent(repo, ctx):
+def getgraphnodecurrent(repo, ctx, cache):
     wpnodes = repo.dirstate.parents()
     if wpnodes[1] == nullid:
         wpnodes = wpnodes[:1]
     if ctx.node() in wpnodes:
         return b'@'
     else:
+        merge_nodes = cache.get(b'merge_nodes', ())
+        if not merge_nodes:
+            from . import merge
+
+            mergestate = merge.mergestate.read(repo)
+            if mergestate.active():
+                merge_nodes = (mergestate.local, mergestate.other)
+            cache[b'merge_nodes'] = merge_nodes
+
+        if ctx.node() in merge_nodes:
+            return b'%'
         return b''
 
 
 def getgraphnodesymbol(ctx):
     if ctx.obsolete():
         return b'x'
     elif ctx.isunstable():
         return b'*'
     elif ctx.closesbranch():
         return b'_'
     else:
         return b'o'
 
 
 @templatekeyword(b'graphwidth', requires=())
 def showgraphwidth(context, mapping):
     """Integer. The width of the graph drawn by 'log --graph' or zero."""
     # just hosts documentation; should be overridden by template mapping
     return 0
 
 
 @templatekeyword(b'index', requires=())
 def showindex(context, mapping):
     """Integer. The current iteration of the loop. (0 indexed)"""
     # just hosts documentation; should be overridden by template mapping
     raise error.Abort(_(b"can't use index in this context"))
 
 
 @templatekeyword(b'latesttag', requires={b'repo', b'ctx', b'cache'})
 def showlatesttag(context, mapping):
     """List of strings. The global tags on the most recent globally
     tagged ancestor of this changeset.  If no such tags exist, the list
     consists of the single string "null".
     """
     return showlatesttags(context, mapping, None)
 
 
 def showlatesttags(context, mapping, pattern):
     """helper method for the latesttag keyword and function"""
     latesttags = getlatesttags(context, mapping, pattern)
 
     # latesttag[0] is an implementation detail for sorting csets on different
     # branches in a stable manner- it is the date the tagged cset was created,
     # not the date the tag was created.  Therefore it isn't made visible here.
     makemap = lambda v: {
         b'changes': _showchangessincetag,
         b'distance': latesttags[1],
         b'latesttag': v,  # BC with {latesttag % '{latesttag}'}
         b'tag': v,
     }
 
     tags = latesttags[2]
     f = _showcompatlist(context, mapping, b'latesttag', tags, separator=b':')
     return _hybrid(f, tags, makemap, pycompat.identity)
 
 
 @templatekeyword(b'latesttagdistance', requires={b'repo', b'ctx', b'cache'})
 def showlatesttagdistance(context, mapping):
     """Integer. Longest path to the latest tag."""
     return getlatesttags(context, mapping)[1]
 
 
 @templatekeyword(b'changessincelatesttag', requires={b'repo', b'ctx', b'cache'})
 def showchangessincelatesttag(context, mapping):
     """Integer. All ancestors not in the latest tag."""
     tag = getlatesttags(context, mapping)[2][0]
     mapping = context.overlaymap(mapping, {b'tag': tag})
     return _showchangessincetag(context, mapping)
 
 
 def _showchangessincetag(context, mapping):
     repo = context.resource(mapping, b'repo')
     ctx = context.resource(mapping, b'ctx')
     offset = 0
     revs = [ctx.rev()]
     tag = context.symbol(mapping, b'tag')
 
     # The only() revset doesn't currently support wdir()
     if ctx.rev() is None:
         offset = 1
         revs = [p.rev() for p in ctx.parents()]
 
     return len(repo.revs(b'only(%ld, %s)', revs, tag)) + offset
 
 
 # teach templater latesttags.changes is switched to (context, mapping) API
 _showchangessincetag._requires = {b'repo', b'ctx'}
 
 
 @templatekeyword(b'manifest', requires={b'repo', b'ctx'})
 def showmanifest(context, mapping):
     repo = context.resource(mapping, b'repo')
     ctx = context.resource(mapping, b'ctx')
     mnode = ctx.manifestnode()
     if mnode is None:
         mnode = wdirid
         mrev = wdirrev
     else:
         mrev = repo.manifestlog.rev(mnode)
     mhex = hex(mnode)
     mapping = context.overlaymap(mapping, {b'rev': mrev, b'node': mhex})
     f = context.process(b'manifest', mapping)
     return templateutil.hybriditem(
         f, None, f, lambda x: {b'rev': mrev, b'node': mhex}
     )
 
 
 @templatekeyword(b'obsfate', requires={b'ui', b'repo', b'ctx'})
 def showobsfate(context, mapping):
     # this function returns a list containing pre-formatted obsfate strings.
     #
     # This function will be replaced by templates fragments when we will have
     # the verbosity templatekw available.
     succsandmarkers = showsuccsandmarkers(context, mapping)
 
     ui = context.resource(mapping, b'ui')
     repo = context.resource(mapping, b'repo')
     values = []
 
     for x in succsandmarkers.tovalue(context, mapping):
         v = obsutil.obsfateprinter(
             ui, repo, x[b'successors'], x[b'markers'], scmutil.formatchangeid
         )
         values.append(v)
 
     return compatlist(context, mapping, b"fate", values)
 
 
 def shownames(context, mapping, namespace):
     """helper method to generate a template keyword for a namespace"""
     repo = context.resource(mapping, b'repo')
     ctx = context.resource(mapping, b'ctx')
     ns = repo.names[namespace]
     names = ns.names(repo, ctx.node())
     return compatlist(
         context, mapping, ns.templatename, names, plural=namespace
     )
 
 
 @templatekeyword(b'namespaces', requires={b'repo', b'ctx'})
 def shownamespaces(context, mapping):
     """Dict of lists. Names attached to this changeset per
     namespace."""
     repo = context.resource(mapping, b'repo')
     ctx = context.resource(mapping, b'ctx')
 
     namespaces = util.sortdict()
 
     def makensmapfn(ns):
         # 'name' for iterating over namespaces, templatename for local reference
         return lambda v: {b'name': v, ns.templatename: v}
 
     for k, ns in pycompat.iteritems(repo.names):
         names = ns.names(repo, ctx.node())
         f = _showcompatlist(context, mapping, b'name', names)
         namespaces[k] = _hybrid(f, names, makensmapfn(ns), pycompat.identity)
 
     f = _showcompatlist(context, mapping, b'namespace', list(namespaces))
 
     def makemap(ns):
         return {
             b'namespace': ns,
             b'names': namespaces[ns],
             b'builtin': repo.names[ns].builtin,
             b'colorname': repo.names[ns].colorname,
         }
 
     return _hybrid(f, namespaces, makemap, pycompat.identity)
 
 
 @templatekeyword(b'negrev', requires={b'repo', b'ctx'})
 def shownegrev(context, mapping):
     """Integer. The repository-local changeset negative revision number,
     which counts in the opposite direction."""
     ctx = context.resource(mapping, b'ctx')
     rev = ctx.rev()
     if rev is None or rev < 0:  # wdir() or nullrev?
         return None
     repo = context.resource(mapping, b'repo')
     return rev - len(repo)
 
 
 @templatekeyword(b'node', requires={b'ctx'})
 def shownode(context, mapping):
     """String. The changeset identification hash, as a 40 hexadecimal
     digit string.
     """
     ctx = context.resource(mapping, b'ctx')
     return ctx.hex()
 
 
 @templatekeyword(b'obsolete', requires={b'ctx'})
 def showobsolete(context, mapping):
     """String. Whether the changeset is obsolete. (EXPERIMENTAL)"""
     ctx = context.resource(mapping, b'ctx')
     if ctx.obsolete():
         return b'obsolete'
     return b''
 
 
 @templatekeyword(b'path', requires={b'fctx'})
 def showpath(context, mapping):
     """String. Repository-absolute path of the current file. (EXPERIMENTAL)"""
     fctx = context.resource(mapping, b'fctx')
     return fctx.path()
 
 
 @templatekeyword(b'peerurls', requires={b'repo'})
 def showpeerurls(context, mapping):
     """A dictionary of repository locations defined in the [paths] section
     of your configuration file."""
     repo = context.resource(mapping, b'repo')
     # see commands.paths() for naming of dictionary keys
     paths = repo.ui.paths
     urls = util.sortdict(
         (k, p.rawloc) for k, p in sorted(pycompat.iteritems(paths))
     )
 
     def makemap(k):
         p = paths[k]
         d = {b'name': k, b'url': p.rawloc}
         d.update((o, v) for o, v in sorted(pycompat.iteritems(p.suboptions)))
         return d
 
     return _hybrid(None, urls, makemap, lambda k: b'%s=%s' % (k, urls[k]))
 
 
 @templatekeyword(b"predecessors", requires={b'repo', b'ctx'})
 def showpredecessors(context, mapping):
     """Returns the list of the closest visible predecessors. (EXPERIMENTAL)"""
     repo = context.resource(mapping, b'repo')
     ctx = context.resource(mapping, b'ctx')
     predecessors = sorted(obsutil.closestpredecessors(repo, ctx.node()))
     predecessors = pycompat.maplist(hex, predecessors)
 
     return _hybrid(
         None,
         predecessors,
         lambda x: {b'ctx': repo[x]},
         lambda x: scmutil.formatchangeid(repo[x]),
     )
 
 
 @templatekeyword(b'reporoot', requires={b'repo'})
 def showreporoot(context, mapping):
     """String. The root directory of the current repository."""
     repo = context.resource(mapping, b'repo')
     return repo.root
 
 
 @templatekeyword(b'size', requires={b'fctx'})
 def showsize(context, mapping):
     """Integer. Size of the current file in bytes. (EXPERIMENTAL)"""
     fctx = context.resource(mapping, b'fctx')
     return fctx.size()
 
 
 # requires 'fctx' to denote {status} depends on (ctx, path) pair
 @templatekeyword(b'status', requires={b'ctx', b'fctx', b'revcache'})
 def showstatus(context, mapping):
     """String. Status code of the current file. (EXPERIMENTAL)"""
     path = templateutil.runsymbol(context, mapping, b'path')
     path = templateutil.stringify(context, mapping, path)
     if not path:
         return
     statmap = _getfilestatusmap(context, mapping)
     if path not in statmap:
         statmap = _getfilestatusmap(context, mapping, listall=True)
     return statmap.get(path)
 
 
 @templatekeyword(b"successorssets", requires={b'repo', b'ctx'})
 def showsuccessorssets(context, mapping):
     """Returns a string of sets of successors for a changectx. Format used
     is: [ctx1, ctx2], [ctx3] if ctx has been split into ctx1 and ctx2
     while also diverged into ctx3. (EXPERIMENTAL)"""
     repo = context.resource(mapping, b'repo')
     ctx = context.resource(mapping, b'ctx')
     if not ctx.obsolete():
         return b''
 
     ssets = obsutil.successorssets(repo, ctx.node(), closest=True)
     ssets = [[hex(n) for n in ss] for ss in ssets]
 
     data = []
     for ss in ssets:
         h = _hybrid(
             None,
             ss,
             lambda x: {b'ctx': repo[x]},
             lambda x: scmutil.formatchangeid(repo[x]),
         )
         data.append(h)
 
     # Format the successorssets
     def render(d):
         return templateutil.stringify(context, mapping, d)
 
     def gen(data):
         yield b"; ".join(render(d) for d in data)
 
     return _hybrid(
         gen(data), data, lambda x: {b'successorset': x}, pycompat.identity
     )
 
 
 @templatekeyword(b"succsandmarkers", requires={b'repo', b'ctx'})
 def showsuccsandmarkers(context, mapping):
     """Returns a list of dict for each final successor of ctx. The dict
     contains successors node id in "successors" keys and the list of
     obs-markers from ctx to the set of successors in "markers".
     (EXPERIMENTAL)
     """
     repo = context.resource(mapping, b'repo')
     ctx = context.resource(mapping, b'ctx')
 
     values = obsutil.successorsandmarkers(repo, ctx)
 
     if values is None:
         values = []
 
     # Format successors and markers to avoid exposing binary to templates
     data = []
     for i in values:
         # Format successors
         successors = i[b'successors']
 
         successors = [hex(n) for n in successors]
         successors = _hybrid(
             None,
             successors,
             lambda x: {b'ctx': repo[x]},
             lambda x: scmutil.formatchangeid(repo[x]),
         )
 
         # Format markers
         finalmarkers = []
         for m in i[b'markers']:
             hexprec = hex(m[0])
             hexsucs = tuple(hex(n) for n in m[1])
             hexparents = None
             if m[5] is not None:
                 hexparents = tuple(hex(n) for n in m[5])
             newmarker = (hexprec, hexsucs) + m[2:5] + (hexparents,) + m[6:]
             finalmarkers.append(newmarker)
 
         data.append({b'successors': successors, b'markers': finalmarkers})
 
     return templateutil.mappinglist(data)
 
 
 @templatekeyword(b'p1', requires={b'ctx'})
 def showp1(context, mapping):
     """Changeset. The changeset's first parent. ``{p1.rev}`` for the revision
     number, and ``{p1.node}`` for the identification hash."""
     ctx = context.resource(mapping, b'ctx')
     return templateutil.mappingdict({b'ctx': ctx.p1()}, tmpl=_changeidtmpl)
 
 
 @templatekeyword(b'p2', requires={b'ctx'})
 def showp2(context, mapping):
     """Changeset. The changeset's second parent. ``{p2.rev}`` for the revision
     number, and ``{p2.node}`` for the identification hash."""
     ctx = context.resource(mapping, b'ctx')
     return templateutil.mappingdict({b'ctx': ctx.p2()}, tmpl=_changeidtmpl)
 
 
 @templatekeyword(b'p1rev', requires={b'ctx'})
 def showp1rev(context, mapping):
     """Integer. The repository-local revision number of the changeset's
     first parent, or -1 if the changeset has no parents. (DEPRECATED)"""
     ctx = context.resource(mapping, b'ctx')
     return ctx.p1().rev()
 
 
 @templatekeyword(b'p2rev', requires={b'ctx'})
 def showp2rev(context, mapping):
     """Integer. The repository-local revision number of the changeset's
     second parent, or -1 if the changeset has no second parent. (DEPRECATED)"""
     ctx = context.resource(mapping, b'ctx')
     return ctx.p2().rev()
 
 
 @templatekeyword(b'p1node', requires={b'ctx'})
 def showp1node(context, mapping):
     """String. The identification hash of the changeset's first parent,
     as a 40 digit hexadecimal string. If the changeset has no parents, all
     digits are 0. (DEPRECATED)"""
     ctx = context.resource(mapping, b'ctx')
     return ctx.p1().hex()
 
 
 @templatekeyword(b'p2node', requires={b'ctx'})
 def showp2node(context, mapping):
     """String. The identification hash of the changeset's second
     parent, as a 40 digit hexadecimal string. If the changeset has no second
     parent, all digits are 0. (DEPRECATED)"""
     ctx = context.resource(mapping, b'ctx')
     return ctx.p2().hex()
 
 
 @templatekeyword(b'parents', requires={b'repo', b'ctx'})
 def showparents(context, mapping):
     """List of strings. The parents of the changeset in "rev:node"
     format. If the changeset has only one "natural" parent (the predecessor
     revision) nothing is shown."""
     repo = context.resource(mapping, b'repo')
     ctx = context.resource(mapping, b'ctx')
     pctxs = scmutil.meaningfulparents(repo, ctx)
     prevs = [p.rev() for p in pctxs]
     parents = [
         [(b'rev', p.rev()), (b'node', p.hex()), (b'phase', p.phasestr())]
         for p in pctxs
     ]
     f = _showcompatlist(context, mapping, b'parent', parents)
     return _hybrid(
         f,
         prevs,
         lambda x: {b'ctx': repo[x]},
         lambda x: scmutil.formatchangeid(repo[x]),
         keytype=int,
     )
 
 
 @templatekeyword(b'phase', requires={b'ctx'})
 def showphase(context, mapping):
     """String. The changeset phase name."""
     ctx = context.resource(mapping, b'ctx')
     return ctx.phasestr()
 
 
 @templatekeyword(b'phaseidx', requires={b'ctx'})
 def showphaseidx(context, mapping):
     """Integer. The changeset phase index. (ADVANCED)"""
     ctx = context.resource(mapping, b'ctx')
     return ctx.phase()
 
 
 @templatekeyword(b'rev', requires={b'ctx'})
 def showrev(context, mapping):
     """Integer. The repository-local changeset revision number."""
     ctx = context.resource(mapping, b'ctx')
     return scmutil.intrev(ctx)
 
 
 def showrevslist(context, mapping, name, revs):
     """helper to generate a list of revisions in which a mapped template will
     be evaluated"""
     repo = context.resource(mapping, b'repo')
     # revs may be a smartset; don't compute it until f() has to be evaluated
     def f():
         srevs = [b'%d' % r for r in revs]
         return _showcompatlist(context, mapping, name, srevs)
 
     return _hybrid(
         f,
         revs,
         lambda x: {name: x, b'ctx': repo[x]},
         pycompat.identity,
         keytype=int,
     )
 
 
 @templatekeyword(b'subrepos', requires={b'ctx'})
 def showsubrepos(context, mapping):
     """List of strings. Updated subrepositories in the changeset."""
     ctx = context.resource(mapping, b'ctx')
     substate = ctx.substate
     if not substate:
         return compatlist(context, mapping, b'subrepo', [])
     psubstate = ctx.p1().substate or {}
     subrepos = []
     for sub in substate:
         if sub not in psubstate or substate[sub] != psubstate[sub]:
             subrepos.append(sub)  # modified or newly added in ctx
     for sub in psubstate:
         if sub not in substate:
             subrepos.append(sub)  # removed in ctx
     return compatlist(context, mapping, b'subrepo', sorted(subrepos))
 
 
 # don't remove "showtags" definition, even though namespaces will put
 # a helper function for "tags" keyword into "keywords" map automatically,
 # because online help text is built without namespaces initialization
 @templatekeyword(b'tags', requires={b'repo', b'ctx'})
 def showtags(context, mapping):
     """List of strings. Any tags associated with the changeset."""
     return shownames(context, mapping, b'tags')
 
 
 @templatekeyword(b'termwidth', requires={b'ui'})
 def showtermwidth(context, mapping):
     """Integer. The width of the current terminal."""
     ui = context.resource(mapping, b'ui')
     return ui.termwidth()
 
 
 @templatekeyword(b'user', requires={b'ctx'})
 def showuser(context, mapping):
     """String. The unmodified author of the changeset."""
     ctx = context.resource(mapping, b'ctx')
     return ctx.user()
 
 
 @templatekeyword(b'instabilities', requires={b'ctx'})
 def showinstabilities(context, mapping):
     """List of strings. Evolution instabilities affecting the changeset.
     (EXPERIMENTAL)
     """
     ctx = context.resource(mapping, b'ctx')
     return compatlist(
         context,
         mapping,
         b'instability',
         ctx.instabilities(),
         plural=b'instabilities',
     )
 
 
 @templatekeyword(b'verbosity', requires={b'ui'})
 def showverbosity(context, mapping):
     """String. The current output verbosity in 'debug', 'quiet', 'verbose',
     or ''."""
     ui = context.resource(mapping, b'ui')
     # see logcmdutil.changesettemplater for priority of these flags
     if ui.debugflag:
         return b'debug'
     elif ui.quiet:
         return b'quiet'
     elif ui.verbose:
         return b'verbose'
     return b''
 
 
 @templatekeyword(b'whyunstable', requires={b'repo', b'ctx'})
 def showwhyunstable(context, mapping):
     """List of dicts explaining all instabilities of a changeset.
     (EXPERIMENTAL)
     """
     repo = context.resource(mapping, b'repo')
     ctx = context.resource(mapping, b'ctx')
 
     def formatnode(ctx):
         return b'%s (%s)' % (scmutil.formatchangeid(ctx), ctx.phasestr())
 
     entries = obsutil.whyunstable(repo, ctx)
 
     for entry in entries:
         if entry.get(b'divergentnodes'):
             dnodes = entry[b'divergentnodes']
             dnhybrid = _hybrid(
                 None,
                 [dnode.hex() for dnode in dnodes],
                 lambda x: {b'ctx': repo[x]},
                 lambda x: formatnode(repo[x]),
             )
             entry[b'divergentnodes'] = dnhybrid
 
     tmpl = (
         b'{instability}:{if(divergentnodes, " ")}{divergentnodes} '
         b'{reason} {node|short}'
     )
     return templateutil.mappinglist(entries, tmpl=tmpl, sep=b'\n')
 
 
 def loadkeyword(ui, extname, registrarobj):
     """Load template keyword from specified registrarobj
     """
     for name, func in pycompat.iteritems(registrarobj._table):
         keywords[name] = func
 
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = keywords.values()

relnotes/next

@@ -1,29 +1,34 b''
 == New Features ==
 
  * `hg purge`/`hg clean` can now delete ignored files instead of
    untracked files, with the new -i flag.
 
- * New `conflictlocal()` and `conflictother()` revsets returns the
+ * `hg log` now defaults to using an '%' symbol for commits involved
+    in unresolved merge conflicts. That includes unresolved conflicts
+    caused by e.g. `hg update --merge` and `hg graft`. '@' still takes
+    precedence, so what used to be marked '@' still is.
+
+ * New `conflictlocal()` and `conflictother()` revsets return the
    commits that are being merged, when there are conflicts. Also works
    for conflicts caused by e.g. `hg graft`.
 
 
 == New Experimental Features ==
 
 
 == Bug Fixes  ==
 
 
 == Backwards Compatibility Changes ==
 
 
 == Internal API Changes ==
 
  * The deprecated `ui.progress()` has now been deleted. Please use
    `ui.makeprogress()` instead.
 
  * `hg.merge()` has lost its `abort` argument. Please call
    `hg.abortmerge()` directly instead.
 
  * The `*others` argument of `cmdutil.check_incompatible_arguments()`
    changed from being varargs argument to being a single collection.

tests/test-backout.t

@@ -1,807 +1,807 b''
   $ hg init basic
   $ cd basic
 
 should complain
 
   $ hg backout
   abort: please specify a revision to backout
   [255]
   $ hg backout -r 0 0
   abort: please specify just one revision
   [255]
 
 basic operation
 (this also tests that editor is invoked if the commit message is not
 specified explicitly)
 
   $ echo a > a
   $ hg commit -d '0 0' -A -m a
   adding a
   $ echo b >> a
   $ hg commit -d '1 0' -m b
 
   $ hg status --rev tip --rev "tip^1"
   M a
   $ HGEDITOR=cat hg backout -d '2 0' tip --tool=true
   reverting a
   Backed out changeset a820f4f40a57
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: changed a
   changeset 2:2929462c3dff backs out changeset 1:a820f4f40a57
   $ cat a
   a
   $ hg summary
   parent: 2:2929462c3dff tip
    Backed out changeset a820f4f40a57
   branch: default
   commit: (clean)
   update: (current)
   phases: 3 draft
 
 commit option
 
   $ cd ..
   $ hg init commit
   $ cd commit
 
   $ echo tomatoes > a
   $ hg add a
   $ hg commit -d '0 0' -m tomatoes
 
   $ echo chair > b
   $ hg add b
   $ hg commit -d '1 0' -m chair
 
   $ echo grapes >> a
   $ hg commit -d '2 0' -m grapes
 
   $ hg backout -d '4 0' 1 --tool=:fail
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   changeset 3:1c2161e97c0a backs out changeset 1:22cb4f70d813
   $ hg summary
   parent: 3:1c2161e97c0a tip
    Backed out changeset 22cb4f70d813
   branch: default
   commit: (clean)
   update: (current)
   phases: 4 draft
 
   $ echo ypples > a
   $ hg commit -d '5 0' -m ypples
 
   $ hg backout -d '6 0' 2 --tool=:fail
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ hg summary
   parent: 4:ed99997b793d tip
    ypples
   branch: default
   commit: 1 unresolved (clean)
   update: (current)
   phases: 5 draft
   $ hg log -G
   @  changeset:   4:ed99997b793d
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:05 1970 +0000
   |  summary:     ypples
   |
   o  changeset:   3:1c2161e97c0a
   |  user:        test
   |  date:        Thu Jan 01 00:00:04 1970 +0000
   |  summary:     Backed out changeset 22cb4f70d813
   |
   o  changeset:   2:a8c6e511cfee
   |  user:        test
   |  date:        Thu Jan 01 00:00:02 1970 +0000
   |  summary:     grapes
   |
-  o  changeset:   1:22cb4f70d813
+  %  changeset:   1:22cb4f70d813
   |  user:        test
   |  date:        Thu Jan 01 00:00:01 1970 +0000
   |  summary:     chair
   |
   o  changeset:   0:a5cb2dde5805
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     tomatoes
   
 
 file that was removed is recreated
 (this also tests that editor is not invoked if the commit message is
 specified explicitly)
 
   $ cd ..
   $ hg init remove
   $ cd remove
 
   $ echo content > a
   $ hg commit -d '0 0' -A -m a
   adding a
 
   $ hg rm a
   $ hg commit -d '1 0' -m b
 
   $ HGEDITOR=cat hg backout -d '2 0' tip --tool=true -m "Backed out changeset 76862dcce372"
   adding a
   changeset 2:de31bdc76c0d backs out changeset 1:76862dcce372
   $ cat a
   content
   $ hg summary
   parent: 2:de31bdc76c0d tip
    Backed out changeset 76862dcce372
   branch: default
   commit: (clean)
   update: (current)
   phases: 3 draft
 
 backout of backout is as if nothing happened
 
   $ hg backout -d '3 0' --merge tip --tool=true
   removing a
   changeset 3:7f6d0f120113 backs out changeset 2:de31bdc76c0d
   $ test -f a
   [1]
   $ hg summary
   parent: 3:7f6d0f120113 tip
    Backed out changeset de31bdc76c0d
   branch: default
   commit: (clean)
   update: (current)
   phases: 4 draft
 
 Test that 'hg rollback' restores dirstate just before opening
 transaction: in-memory dirstate changes should be written into
 '.hg/journal.dirstate' as expected.
 
   $ echo 'removed soon' > b
   $ hg commit -A -d '4 0' -m 'prepare for subsequent removing'
   adding b
   $ echo 'newly added' > c
   $ hg add c
   $ hg remove b
   $ hg commit -d '5 0' -m 'prepare for subsequent backout'
   $ touch -t 200001010000 c
   $ hg status -A
   C c
   $ hg debugstate --no-dates
   n 644         12 set                 c
   $ hg backout -d '6 0' -m 'to be rollback-ed soon' -r .
   removing c
   adding b
   changeset 6:4bfec048029d backs out changeset 5:fac0b729a654
   $ hg rollback -q
   $ hg status -A
   A b
   R c
   $ hg debugstate --no-dates
   a   0         -1 unset               b
   r   0          0 set                 c
 
 across branch
 
   $ cd ..
   $ hg init branch
   $ cd branch
   $ echo a > a
   $ hg ci -Am0
   adding a
   $ echo b > b
   $ hg ci -Am1
   adding b
   $ hg co -C 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg summary
   parent: 0:f7b1eb17ad24 
    0
   branch: default
   commit: (clean)
   update: 1 new changesets (update)
   phases: 2 draft
 
 should fail
 
   $ hg backout 1
   abort: cannot backout change that is not an ancestor
   [255]
   $ echo c > c
   $ hg ci -Am2
   adding c
   created new head
   $ hg summary
   parent: 2:db815d6d32e6 tip
    2
   branch: default
   commit: (clean)
   update: 1 new changesets, 2 branch heads (merge)
   phases: 3 draft
 
 should fail
 
   $ hg backout 1
   abort: cannot backout change that is not an ancestor
   [255]
   $ hg summary
   parent: 2:db815d6d32e6 tip
    2
   branch: default
   commit: (clean)
   update: 1 new changesets, 2 branch heads (merge)
   phases: 3 draft
 
 backout with merge
 
   $ cd ..
   $ hg init merge
   $ cd merge
 
   $ echo line 1 > a
   $ echo line 2 >> a
   $ hg commit -d '0 0' -A -m a
   adding a
   $ hg summary
   parent: 0:59395513a13a tip
    a
   branch: default
   commit: (clean)
   update: (current)
   phases: 1 draft
 
 remove line 1
 
   $ echo line 2 > a
   $ hg commit -d '1 0' -m b
 
   $ echo line 3 >> a
   $ hg commit -d '2 0' -m c
 
   $ hg backout --merge -d '3 0' 1 --tool=true
   reverting a
   created new head
   changeset 3:26b8ccb9ad91 backs out changeset 1:5a50a024c182
   merging with changeset 3:26b8ccb9ad91
   merging a
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg commit -d '4 0' -m d
   $ hg summary
   parent: 4:c7df5e0b9c09 tip
    d
   branch: default
   commit: (clean)
   update: (current)
   phases: 5 draft
 
 check line 1 is back
 
   $ cat a
   line 1
   line 2
   line 3
 
 Test visibility of in-memory dirstate changes outside transaction to
 external hook process
 
   $ cat > $TESTTMP/checkvisibility.sh <<EOF
   > echo "==== \$1:"
   > hg parents --template "{rev}:{node|short}\n"
   > echo "===="
   > EOF
 
 "hg backout --merge REV1" at REV2 below implies steps below:
 
 (1) update to REV1 (REV2 => REV1)
 (2) revert by REV1^1
 (3) commit backing out revision (REV3)
 (4) update to REV2 (REV3 => REV2)
 (5) merge with REV3 (REV2 => REV2, REV3)
 
 == test visibility to external preupdate hook
 
   $ hg update -q -C 2
   $ hg --config extensions.strip= strip 3
   saved backup bundle to * (glob)
 
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > preupdate.visibility = sh $TESTTMP/checkvisibility.sh preupdate
   > EOF
 
 ("-m" is needed to avoid writing dirstate changes out at other than
 invocation of the hook to be examined)
 
   $ hg backout --merge -d '3 0' 1 --tool=true -m 'fixed comment'
   ==== preupdate:
   2:6ea3f2a197a2
   ====
   reverting a
   created new head
   changeset 3:d92a3f57f067 backs out changeset 1:5a50a024c182
   ==== preupdate:
   3:d92a3f57f067
   ====
   merging with changeset 3:d92a3f57f067
   ==== preupdate:
   2:6ea3f2a197a2
   ====
   merging a
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > preupdate.visibility =
   > EOF
 
 == test visibility to external update hook
 
   $ hg update -q -C 2
   $ hg --config extensions.strip= strip 3
   saved backup bundle to * (glob)
 
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > update.visibility = sh $TESTTMP/checkvisibility.sh update
   > EOF
 
   $ hg backout --merge -d '3 0' 1 --tool=true -m 'fixed comment'
   ==== update:
   1:5a50a024c182
   ====
   reverting a
   created new head
   changeset 3:d92a3f57f067 backs out changeset 1:5a50a024c182
   ==== update:
   2:6ea3f2a197a2
   ====
   merging with changeset 3:d92a3f57f067
   merging a
   ==== update:
   2:6ea3f2a197a2
   3:d92a3f57f067
   ====
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > update.visibility =
   > EOF
 
   $ cd ..
 
 backout should not back out subsequent changesets
 
   $ hg init onecs
   $ cd onecs
   $ echo 1 > a
   $ hg commit -d '0 0' -A -m a
   adding a
   $ echo 2 >> a
   $ hg commit -d '1 0' -m b
   $ echo 1 > b
   $ hg commit -d '2 0' -A -m c
   adding b
   $ hg summary
   parent: 2:882396649954 tip
    c
   branch: default
   commit: (clean)
   update: (current)
   phases: 3 draft
 
 without --merge
   $ hg backout --no-commit -d '3 0' 1 --tool=true
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   changeset 22bca4c721e5 backed out, don't forget to commit.
   $ hg locate b
   b
   $ hg update -C tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg locate b
   b
   $ hg summary
   parent: 2:882396649954 tip
    c
   branch: default
   commit: (clean)
   update: (current)
   phases: 3 draft
 
 with --merge
   $ hg backout --merge -d '3 0' 1 --tool=true
   reverting a
   created new head
   changeset 3:3202beb76721 backs out changeset 1:22bca4c721e5
   merging with changeset 3:3202beb76721
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg locate b
   b
   $ hg update -C tip
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg locate b
   [1]
 
   $ cd ..
   $ hg init m
   $ cd m
   $ echo a > a
   $ hg commit -d '0 0' -A -m a
   adding a
   $ echo b > b
   $ hg commit -d '1 0' -A -m b
   adding b
   $ echo c > c
   $ hg commit -d '2 0' -A -m b
   adding c
   $ hg update 1
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo d > d
   $ hg commit -d '3 0' -A -m c
   adding d
   created new head
   $ hg merge 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg commit -d '4 0' -A -m d
   $ hg summary
   parent: 4:b2f3bb92043e tip
    d
   branch: default
   commit: (clean)
   update: (current)
   phases: 5 draft
 
 backout of merge should fail
 
   $ hg backout 4
   abort: cannot backout a merge changeset
   [255]
 
 backout of merge with bad parent should fail
 
   $ hg backout --parent 0 4
   abort: cb9a9f314b8b is not a parent of b2f3bb92043e
   [255]
 
 backout of non-merge with parent should fail
 
   $ hg backout --parent 0 3
   abort: cannot use --parent on non-merge changeset
   [255]
 
 backout with valid parent should be ok
 
   $ hg backout -d '5 0' --parent 2 4 --tool=true
   removing d
   changeset 5:10e5328c8435 backs out changeset 4:b2f3bb92043e
   $ hg summary
   parent: 5:10e5328c8435 tip
    Backed out changeset b2f3bb92043e
   branch: default
   commit: (clean)
   update: (current)
   phases: 6 draft
 
   $ hg rollback
   repository tip rolled back to revision 4 (undo commit)
   working directory now based on revision 4
   $ hg update -C
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg summary
   parent: 4:b2f3bb92043e tip
    d
   branch: default
   commit: (clean)
   update: (current)
   phases: 5 draft
 
   $ hg backout -d '6 0' --parent 3 4 --tool=true
   removing c
   changeset 5:033590168430 backs out changeset 4:b2f3bb92043e
   $ hg summary
   parent: 5:033590168430 tip
    Backed out changeset b2f3bb92043e
   branch: default
   commit: (clean)
   update: (current)
   phases: 6 draft
 
   $ cd ..
 
 named branches
 
   $ hg init named_branches
   $ cd named_branches
 
   $ echo default > default
   $ hg ci -d '0 0' -Am default
   adding default
   $ hg branch branch1
   marked working directory as branch branch1
   (branches are permanent and global, did you want a bookmark?)
   $ echo branch1 > file1
   $ hg ci -d '1 0' -Am file1
   adding file1
   $ hg branch branch2
   marked working directory as branch branch2
   $ echo branch2 > file2
   $ hg ci -d '2 0' -Am file2
   adding file2
 
 without --merge
   $ hg backout --no-commit -r 1 --tool=true
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   changeset bf1602f437f3 backed out, don't forget to commit.
   $ hg branch
   branch2
   $ hg status -A
   R file1
   C default
   C file2
   $ hg summary
   parent: 2:45bbcd363bf0 tip
    file2
   branch: branch2
   commit: 1 removed
   update: (current)
   phases: 3 draft
 
 with --merge
 (this also tests that editor is invoked if '--edit' is specified
 explicitly regardless of '--message')
 
   $ hg update -qC
   $ HGEDITOR=cat hg backout --merge -d '3 0' -r 1 -m 'backout on branch1' --tool=true --edit
   removing file1
   backout on branch1
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'branch2'
   HG: removed file1
   created new head
   changeset 3:d4e8f6db59fb backs out changeset 1:bf1602f437f3
   merging with changeset 3:d4e8f6db59fb
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg summary
   parent: 2:45bbcd363bf0 
    file2
   parent: 3:d4e8f6db59fb tip
    backout on branch1
   branch: branch2
   commit: 1 removed (merge)
   update: (current)
   phases: 4 draft
   $ hg update -q -C 2
 
 on branch2 with branch1 not merged, so file1 should still exist:
 
   $ hg id
   45bbcd363bf0 (branch2)
   $ hg st -A
   C default
   C file1
   C file2
   $ hg summary
   parent: 2:45bbcd363bf0 
    file2
   branch: branch2
   commit: (clean)
   update: 1 new changesets, 2 branch heads (merge)
   phases: 4 draft
 
 on branch2 with branch1 merged, so file1 should be gone:
 
   $ hg merge
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -d '4 0' -m 'merge backout of branch1'
   $ hg id
   d97a8500a969 (branch2) tip
   $ hg st -A
   C default
   C file2
   $ hg summary
   parent: 4:d97a8500a969 tip
    merge backout of branch1
   branch: branch2
   commit: (clean)
   update: (current)
   phases: 5 draft
 
 on branch1, so no file1 and file2:
 
   $ hg co -C branch1
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg id
   bf1602f437f3 (branch1)
   $ hg st -A
   C default
   C file1
   $ hg summary
   parent: 1:bf1602f437f3 
    file1
   branch: branch1
   commit: (clean)
   update: (current)
   phases: 5 draft
 
   $ cd ..
 
 backout of empty changeset (issue4190)
 
   $ hg init emptycommit
   $ cd emptycommit
 
   $ touch file1
   $ hg ci -Aqm file1
   $ hg branch -q branch1
   $ hg ci -qm branch1
   $ hg backout -v 1
   resolving manifests
   nothing changed
   [1]
 
   $ cd ..
 
 
 Test usage of `hg resolve` in case of conflict
 (issue4163)
 
   $ hg init issue4163
   $ cd issue4163
   $ touch foo
   $ hg add foo
   $ cat > foo << EOF
   > one
   > two
   > three
   > four
   > five
   > six
   > seven
   > height
   > nine
   > ten
   > EOF
   $ hg ci -m 'initial'
   $ cat > foo << EOF
   > one
   > two
   > THREE
   > four
   > five
   > six
   > seven
   > height
   > nine
   > ten
   > EOF
   $ hg ci -m 'capital three'
   $ cat > foo << EOF
   > one
   > two
   > THREE
   > four
   > five
   > six
   > seven
   > height
   > nine
   > TEN
   > EOF
   $ hg ci -m 'capital ten'
   $ hg backout -r 'desc("capital three")' --tool internal:fail
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ hg status
   $ hg debugmergestate
   * version 2 records
   local: b71750c4b0fdf719734971e3ef90dbeab5919a2d
   other: a30dd8addae3ce71b8667868478542bc417439e6
   file extras: foo (ancestorlinknode = 91360952243723bd5b1138d5f26bd8c8564cb553)
   file: foo (record type "F", state "u", hash 0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33)
     local path: foo (flags "")
     ancestor path: foo (node f89532f44c247a0e993d63e3a734dd781ab04708)
     other path: foo (node f50039b486d6fa1a90ae51778388cad161f425ee)
   $ mv .hg/merge/state2 .hg/merge/state2-moved
   $ hg debugmergestate
   * version 1 records
   local: b71750c4b0fdf719734971e3ef90dbeab5919a2d
   file: foo (record type "F", state "u", hash 0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33)
     local path: foo (flags "")
     ancestor path: foo (node f89532f44c247a0e993d63e3a734dd781ab04708)
     other path: foo (node not stored in v1 format)
   $ mv .hg/merge/state2-moved .hg/merge/state2
   $ hg resolve -l  # still unresolved
   U foo
   $ hg summary
   parent: 2:b71750c4b0fd tip
    capital ten
   branch: default
   commit: 1 unresolved (clean)
   update: (current)
   phases: 3 draft
   $ hg log -G
   @  changeset:   2:b71750c4b0fd
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     capital ten
   |
   o  changeset:   1:913609522437
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     capital three
   |
-  o  changeset:   0:a30dd8addae3
+  %  changeset:   0:a30dd8addae3
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     initial
   
   $ hg resolve --all --debug
   picked tool ':merge' for foo (binary False symlink False changedelete False)
   merging foo
   my foo@b71750c4b0fd+ other foo@a30dd8addae3 ancestor foo@913609522437
    premerge successful
   (no more unresolved files)
   continue: hg commit
   $ hg status
   M foo
   ? foo.orig
   $ hg resolve -l
   R foo
   $ hg summary
   parent: 2:b71750c4b0fd tip
    capital ten
   branch: default
   commit: 1 modified, 1 unknown
   update: (current)
   phases: 3 draft
   $ cat foo
   one
   two
   three
   four
   five
   six
   seven
   height
   nine
   TEN
 
 --no-commit shouldn't commit
 
   $ hg init a
   $ cd a
   $ for i in 1 2 3; do
   >   touch $i
   >   hg ci -Am $i
   > done
   adding 1
   adding 2
   adding 3
   $ hg backout --no-commit .
   removing 3
   changeset cccc23d9d68f backed out, don't forget to commit.
   $ hg revert -aq
 
 --no-commit can't be used with --merge
 
   $ hg backout --merge --no-commit 2
   abort: cannot use --merge with --no-commit
   [255]

tests/test-graft-interrupted.t

@@ -1,771 +1,771 b''
 #testcases abortcommand abortflag
 
 #if abortflag
   $ cat >> $HGRCPATH <<EOF
   > [alias]
   > abort = graft --abort
   > EOF
 #endif
 
 
 Testing the reading of old format graftstate file with newer mercurial
 
   $ hg init oldgraft
   $ cd oldgraft
   $ for ch in a b c; do echo foo > $ch; hg add $ch; hg ci -Aqm "added "$ch; done;
   $ hg log -GT "{rev}:{node|short} {desc}\n"
   @  2:8be98ac1a569 added c
   |
   o  1:80e6d2c47cfe added b
   |
   o  0:f7ad41964313 added a
   
   $ hg up 0
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo bar > b
   $ hg add b
   $ hg ci -m "bar to b"
   created new head
   $ hg graft -r 1 -r 2
   grafting 1:80e6d2c47cfe "added b"
   merging b
   warning: conflicts while merging b! (edit, then use 'hg resolve --mark')
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
 Writing the nodes in old format to graftstate
 
   $ hg log -r 1 -r 2 -T '{node}\n' > .hg/graftstate
   $ echo foo > b
   $ hg resolve -m
   (no more unresolved files)
   continue: hg graft --continue
   $ hg graft --continue
   grafting 1:80e6d2c47cfe "added b"
   grafting 2:8be98ac1a569 "added c"
 
 Testing that --user is preserved during conflicts and value is reused while
 running `hg graft --continue`
 
   $ hg log -G
   @  changeset:   5:711e9fa999f1
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     added c
   |
   o  changeset:   4:e5ad7353b408
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     added b
   |
   o  changeset:   3:9e887f7a939c
   |  parent:      0:f7ad41964313
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     bar to b
   |
   | o  changeset:   2:8be98ac1a569
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     added c
   | |
   | o  changeset:   1:80e6d2c47cfe
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     added b
   |
   o  changeset:   0:f7ad41964313
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     added a
   
 
   $ hg up '.^^'
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ hg graft -r 1 -r 2 --user batman
   grafting 1:80e6d2c47cfe "added b"
   merging b
   warning: conflicts while merging b! (edit, then use 'hg resolve --mark')
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
   $ echo wat > b
   $ hg resolve -m
   (no more unresolved files)
   continue: hg graft --continue
 
   $ hg graft --continue
   grafting 1:80e6d2c47cfe "added b"
   grafting 2:8be98ac1a569 "added c"
 
   $ hg log -Gr 3::
   @  changeset:   7:11a36ffaacf2
   |  tag:         tip
   |  user:        batman
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     added c
   |
   o  changeset:   6:76803afc6511
   |  parent:      3:9e887f7a939c
   |  user:        batman
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     added b
   |
   | o  changeset:   5:711e9fa999f1
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     added c
   | |
   | o  changeset:   4:e5ad7353b408
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     added b
   |
   o  changeset:   3:9e887f7a939c
   |  parent:      0:f7ad41964313
   ~  user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     bar to b
   
 Test that --date is preserved and reused in `hg graft --continue`
 
   $ hg up '.^^'
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg graft -r 1 -r 2 --date '1234560000 120'
   grafting 1:80e6d2c47cfe "added b"
   merging b
   warning: conflicts while merging b! (edit, then use 'hg resolve --mark')
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
   $ echo foobar > b
   $ hg resolve -m
   (no more unresolved files)
   continue: hg graft --continue
   $ hg graft --continue
   grafting 1:80e6d2c47cfe "added b"
   grafting 2:8be98ac1a569 "added c"
 
   $ hg log -Gr '.^^::.'
   @  changeset:   9:1896b76e007a
   |  tag:         tip
   |  user:        test
   |  date:        Fri Feb 13 21:18:00 2009 -0002
   |  summary:     added c
   |
   o  changeset:   8:ce2b4f1632af
   |  parent:      3:9e887f7a939c
   |  user:        test
   |  date:        Fri Feb 13 21:18:00 2009 -0002
   |  summary:     added b
   |
   o  changeset:   3:9e887f7a939c
   |  parent:      0:f7ad41964313
   ~  user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     bar to b
   
 Test that --log is preserved and reused in `hg graft --continue`
 
   $ hg up '.^^'
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg graft -r 1 -r 2 --log
   grafting 1:80e6d2c47cfe "added b"
   merging b
   warning: conflicts while merging b! (edit, then use 'hg resolve --mark')
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
   $ echo foobar > b
   $ hg resolve -m
   (no more unresolved files)
   continue: hg graft --continue
 
   $ hg graft --continue
   grafting 1:80e6d2c47cfe "added b"
   grafting 2:8be98ac1a569 "added c"
 
   $ hg log -GT "{rev}:{node|short} {desc}" -r '.^^::.'
   @  11:30c1050a58b2 added c
   |  (grafted from 8be98ac1a56990c2d9ca6861041b8390af7bd6f3)
   o  10:ec7eda2313e2 added b
   |  (grafted from 80e6d2c47cfe5b3185519568327a17a061c7efb6)
   o  3:9e887f7a939c bar to b
   |
   ~
 
   $ cd ..
 
 Testing the --stop flag of `hg graft` which stops the interrupted graft
 
   $ hg init stopgraft
   $ cd stopgraft
   $ for ch in a b c d; do echo $ch > $ch; hg add $ch; hg ci -Aqm "added "$ch; done;
 
   $ hg log -G
   @  changeset:   3:9150fe93bec6
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     added d
   |
   o  changeset:   2:155349b645be
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     added c
   |
   o  changeset:   1:5f6d8a4bf34a
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     added b
   |
   o  changeset:   0:9092f1db7931
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     added a
   
   $ hg up '.^^'
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
 
   $ echo foo > d
   $ hg ci -Aqm "added foo to d"
 
   $ hg graft --stop
   abort: no interrupted graft found
   [255]
 
   $ hg graft -r 3
   grafting 3:9150fe93bec6 "added d"
   merging d
   warning: conflicts while merging d! (edit, then use 'hg resolve --mark')
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
   $ hg graft --stop --continue
   abort: cannot use '--continue' and '--stop' together
   [255]
 
   $ hg graft --stop -U
   abort: cannot specify any other flag with '--stop'
   [255]
   $ hg graft --stop --rev 4
   abort: cannot specify any other flag with '--stop'
   [255]
   $ hg graft --stop --log
   abort: cannot specify any other flag with '--stop'
   [255]
 
   $ hg graft --stop
   stopped the interrupted graft
   working directory is now at a0deacecd59d
 
   $ hg diff
 
   $ hg log -Gr '.'
   @  changeset:   4:a0deacecd59d
   |  tag:         tip
   ~  parent:      1:5f6d8a4bf34a
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     added foo to d
   
   $ hg graft -r 2 -r 3
   grafting 2:155349b645be "added c"
   grafting 3:9150fe93bec6 "added d"
   merging d
   warning: conflicts while merging d! (edit, then use 'hg resolve --mark')
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
   $ hg graft --stop
   stopped the interrupted graft
   working directory is now at 75b447541a9e
 
   $ hg diff
 
   $ hg log -G -T "{rev}:{node|short} {desc}"
   @  5:75b447541a9e added c
   |
   o  4:a0deacecd59d added foo to d
   |
   | o  3:9150fe93bec6 added d
   | |
   | o  2:155349b645be added c
   |/
   o  1:5f6d8a4bf34a added b
   |
   o  0:9092f1db7931 added a
   
   $ cd ..
 
 Testing the --abort flag for `hg graft` which aborts and rollback to state
 before the graft
 
   $ hg init abortgraft
   $ cd abortgraft
   $ for ch in a b c d; do echo $ch > $ch; hg add $ch; hg ci -Aqm "added "$ch; done;
 
   $ hg up '.^^'
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
 
   $ echo x > x
   $ hg ci -Aqm "added x"
   $ hg up '.^'
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo foo > c
   $ hg ci -Aqm "added foo to c"
 
   $ hg log -GT "{rev}:{node|short} {desc}"
   @  5:36b793615f78 added foo to c
   |
   | o  4:863a25e1a9ea added x
   |/
   | o  3:9150fe93bec6 added d
   | |
   | o  2:155349b645be added c
   |/
   o  1:5f6d8a4bf34a added b
   |
   o  0:9092f1db7931 added a
   
   $ hg up 9150fe93bec6
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg abort
   abort: no interrupted graft to abort (abortflag !)
   abort: no operation in progress (abortcommand !)
   [255]
 
 when stripping is required
   $ hg graft -r 4 -r 5
   grafting 4:863a25e1a9ea "added x"
   grafting 5:36b793615f78 "added foo to c" (tip)
   merging c
   warning: conflicts while merging c! (edit, then use 'hg resolve --mark')
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
   $ hg graft --continue --abort
   abort: cannot use '--continue' and '--abort' together
   [255]
 
   $ hg graft --abort --stop
   abort: cannot use '--abort' and '--stop' together
   [255]
 
   $ hg graft --abort --currentuser
   abort: cannot specify any other flag with '--abort'
   [255]
 
   $ hg graft --abort --edit
   abort: cannot specify any other flag with '--abort'
   [255]
 
 #if abortcommand
 when in dry-run mode
   $ hg abort --dry-run
   graft in progress, will be aborted
 #endif
 
   $ hg abort
   graft aborted
   working directory is now at 9150fe93bec6
   $ hg log -GT "{rev}:{node|short} {desc}"
   o  5:36b793615f78 added foo to c
   |
   | o  4:863a25e1a9ea added x
   |/
   | @  3:9150fe93bec6 added d
   | |
   | o  2:155349b645be added c
   |/
   o  1:5f6d8a4bf34a added b
   |
   o  0:9092f1db7931 added a
   
 when stripping is not required
   $ hg graft -r 5
   grafting 5:36b793615f78 "added foo to c" (tip)
   merging c
   warning: conflicts while merging c! (edit, then use 'hg resolve --mark')
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
   $ hg abort
   graft aborted
   working directory is now at 9150fe93bec6
   $ hg log -GT "{rev}:{node|short} {desc}"
   o  5:36b793615f78 added foo to c
   |
   | o  4:863a25e1a9ea added x
   |/
   | @  3:9150fe93bec6 added d
   | |
   | o  2:155349b645be added c
   |/
   o  1:5f6d8a4bf34a added b
   |
   o  0:9092f1db7931 added a
   
 when some of the changesets became public
 
   $ hg graft -r 4 -r 5
   grafting 4:863a25e1a9ea "added x"
   grafting 5:36b793615f78 "added foo to c" (tip)
   merging c
   warning: conflicts while merging c! (edit, then use 'hg resolve --mark')
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
   $ hg log -GT "{rev}:{node|short} {desc}"
   @  6:6ec71c037d94 added x
   |
-  | o  5:36b793615f78 added foo to c
+  | %  5:36b793615f78 added foo to c
   | |
   | | o  4:863a25e1a9ea added x
   | |/
   o |  3:9150fe93bec6 added d
   | |
   o |  2:155349b645be added c
   |/
   o  1:5f6d8a4bf34a added b
   |
   o  0:9092f1db7931 added a
   
   $ hg phase -r 6 --public
 
   $ hg abort
   cannot clean up public changesets 6ec71c037d94
   graft aborted
   working directory is now at 6ec71c037d94
 
 when we created new changesets on top of existing one
 
   $ hg up '.^^'
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo y > y
   $ hg ci -Aqm "added y"
   $ echo z > z
   $ hg ci -Aqm "added z"
 
   $ hg up 3
   1 files updated, 0 files merged, 3 files removed, 0 files unresolved
   $ hg log -GT "{rev}:{node|short} {desc}"
   o  8:637f9e9bbfd4 added z
   |
   o  7:123221671fd4 added y
   |
   | o  6:6ec71c037d94 added x
   | |
   | | o  5:36b793615f78 added foo to c
   | | |
   | | | o  4:863a25e1a9ea added x
   | | |/
   | @ |  3:9150fe93bec6 added d
   |/ /
   o /  2:155349b645be added c
   |/
   o  1:5f6d8a4bf34a added b
   |
   o  0:9092f1db7931 added a
   
   $ hg graft -r 8 -r 7 -r 5
   grafting 8:637f9e9bbfd4 "added z" (tip)
   grafting 7:123221671fd4 "added y"
   grafting 5:36b793615f78 "added foo to c"
   merging c
   warning: conflicts while merging c! (edit, then use 'hg resolve --mark')
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
   $ cd ..
   $ hg init pullrepo
   $ cd pullrepo
   $ cat >> .hg/hgrc <<EOF
   > [phases]
   > publish=False
   > EOF
   $ hg pull ../abortgraft --config phases.publish=False
   pulling from ../abortgraft
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 11 changesets with 9 changes to 8 files (+4 heads)
   new changesets 9092f1db7931:6b98ff0062dd (6 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg up 9
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo w > w
   $ hg ci -Aqm "added w" --config phases.publish=False
 
   $ cd ../abortgraft
   $ hg pull ../pullrepo
   pulling from ../pullrepo
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   new changesets 311dfc6cf3bf (1 drafts)
   (run 'hg heads .' to see heads, 'hg merge' to merge)
 
   $ hg abort
   new changesets detected on destination branch, can't strip
   graft aborted
   working directory is now at 6b98ff0062dd
 
   $ cd ..
 
 ============================
 Testing --no-commit option:|
 ============================
 
   $ hg init nocommit
   $ cd nocommit
   $ echo a > a
   $ hg ci -qAma
   $ echo b > b
   $ hg ci -qAmb
   $ hg up -q 0
   $ echo c > c
   $ hg ci -qAmc
   $ hg log -GT "{rev}:{node|short} {desc}\n"
   @  2:d36c0562f908 c
   |
   | o  1:d2ae7f538514 b
   |/
   o  0:cb9a9f314b8b a
   
 
 Check reporting when --no-commit used with non-applicable options:
 
   $ hg graft 1 --no-commit -e
   abort: cannot specify --no-commit and --edit together
   [255]
 
   $ hg graft 1 --no-commit --log
   abort: cannot specify --no-commit and --log together
   [255]
 
   $ hg graft 1 --no-commit -D
   abort: cannot specify --no-commit and --currentdate together
   [255]
 
 Test --no-commit is working:
   $ hg graft 1 --no-commit
   grafting 1:d2ae7f538514 "b"
 
   $ hg log -GT "{rev}:{node|short} {desc}\n"
   @  2:d36c0562f908 c
   |
   | o  1:d2ae7f538514 b
   |/
   o  0:cb9a9f314b8b a
   
 
   $ hg diff
   diff -r d36c0562f908 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
 
 Prepare wrdir to check --no-commit is resepected after --continue:
 
   $ hg up -qC
   $ echo A>a
   $ hg ci -qm "A in file a"
   $ hg up -q 1
   $ echo B>a
   $ hg ci -qm "B in file a"
   $ hg log -GT "{rev}:{node|short} {desc}\n"
   @  4:2aa9ad1006ff B in file a
   |
   | o  3:09e253b87e17 A in file a
   | |
   | o  2:d36c0562f908 c
   | |
   o |  1:d2ae7f538514 b
   |/
   o  0:cb9a9f314b8b a
   
 
   $ hg graft 3 --no-commit
   grafting 3:09e253b87e17 "A in file a"
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
 Resolve conflict:
   $ echo A>a
   $ hg resolve --mark
   (no more unresolved files)
   continue: hg graft --continue
 
   $ hg graft --continue
   grafting 3:09e253b87e17 "A in file a"
   $ hg log -GT "{rev}:{node|short} {desc}\n"
   @  4:2aa9ad1006ff B in file a
   |
-  | o  3:09e253b87e17 A in file a
+  | %  3:09e253b87e17 A in file a
   | |
   | o  2:d36c0562f908 c
   | |
   o |  1:d2ae7f538514 b
   |/
   o  0:cb9a9f314b8b a
   
   $ hg diff
   diff -r 2aa9ad1006ff 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
   +A
 
   $ hg up -qC
 
 Check --no-commit is resepected when passed with --continue:
 
   $ hg graft 3
   grafting 3:09e253b87e17 "A in file a"
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
 Resolve conflict:
   $ echo A>a
   $ hg resolve --mark
   (no more unresolved files)
   continue: hg graft --continue
 
   $ hg graft --continue --no-commit
   grafting 3:09e253b87e17 "A in file a"
   $ hg diff
   diff -r 2aa9ad1006ff 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
   +A
 
   $ hg log -GT "{rev}:{node|short} {desc}\n"
   @  4:2aa9ad1006ff B in file a
   |
-  | o  3:09e253b87e17 A in file a
+  | %  3:09e253b87e17 A in file a
   | |
   | o  2:d36c0562f908 c
   | |
   o |  1:d2ae7f538514 b
   |/
   o  0:cb9a9f314b8b a
   
   $ hg up -qC
 
 Test --no-commit when graft multiple revisions:
 When there is conflict:
   $ hg graft -r "2::3" --no-commit
   grafting 2:d36c0562f908 "c"
   grafting 3:09e253b87e17 "A in file a"
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
   $ echo A>a
   $ hg resolve --mark
   (no more unresolved files)
   continue: hg graft --continue
   $ hg graft --continue
   grafting 3:09e253b87e17 "A in file a"
   $ hg diff
   diff -r 2aa9ad1006ff 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
   +A
   diff -r 2aa9ad1006ff 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
 
   $ hg log -GT "{rev}:{node|short} {desc}\n"
   @  4:2aa9ad1006ff B in file a
   |
-  | o  3:09e253b87e17 A in file a
+  | %  3:09e253b87e17 A in file a
   | |
   | o  2:d36c0562f908 c
   | |
   o |  1:d2ae7f538514 b
   |/
   o  0:cb9a9f314b8b a
   
   $ hg up -qC
 
 When there is no conflict:
   $ echo d>d
   $ hg add d -q
   $ hg ci -qmd
   $ hg up 3 -q
   $ hg log -GT "{rev}:{node|short} {desc}\n"
   o  5:baefa8927fc0 d
   |
   o  4:2aa9ad1006ff B in file a
   |
   | @  3:09e253b87e17 A in file a
   | |
   | o  2:d36c0562f908 c
   | |
   o |  1:d2ae7f538514 b
   |/
   o  0:cb9a9f314b8b a
   
 
   $ hg graft -r 1 -r 5 --no-commit
   grafting 1:d2ae7f538514 "b"
   grafting 5:baefa8927fc0 "d" (tip)
   $ hg diff
   diff -r 09e253b87e17 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 -r 09e253b87e17 d
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/d	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +d
   $ hg log -GT "{rev}:{node|short} {desc}\n"
   o  5:baefa8927fc0 d
   |
   o  4:2aa9ad1006ff B in file a
   |
   | @  3:09e253b87e17 A in file a
   | |
   | o  2:d36c0562f908 c
   | |
   o |  1:d2ae7f538514 b
   |/
   o  0:cb9a9f314b8b a
   
   $ cd ..

tests/test-rebase-collapse.t

@@ -1,776 +1,776 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > rebase=
   > mq=
   > drawdag=$TESTDIR/drawdag.py
   > 
   > [phases]
   > publish=False
   > 
   > [alias]
   > tglog = log -G --template "{rev}: {node|short} '{desc}' {branches}\n"
   > tglogp = log -G --template "{rev}: {node|short} {phase} '{desc}' {branches}\n"
   > EOF
 
 Highest phase of source commits is used:
 
   $ hg init phase
   $ cd phase
   $ hg debugdrawdag << 'EOF'
   >   D
   >   |
   > F C
   > | |
   > E B
   > |/
   > A
   > EOF
 
   $ hg phase --force --secret D
 
   $ cat > $TESTTMP/editor.sh <<EOF
   > echo "==== before editing"
   > cat \$1
   > echo "===="
   > echo "edited manually" >> \$1
   > EOF
   $ HGEDITOR="sh $TESTTMP/editor.sh" hg rebase --collapse --keepbranches -e --source B --dest F
   rebasing 1:112478962961 "B" (B)
   rebasing 3:26805aba1e60 "C" (C)
   rebasing 5:f585351a92f8 "D" (D tip)
   ==== before editing
   Collapsed revision
   * B
   * C
   * D
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: added B
   HG: added C
   HG: added D
   ====
   saved backup bundle to $TESTTMP/phase/.hg/strip-backup/112478962961-cb2a9b47-rebase.hg
 
   $ hg tglogp
   o  3: 92fa5f5fe108 secret 'Collapsed revision
   |  * B
   |  * C
   |  * D
   |
   |
   |  edited manually'
   o  2: 64a8289d2492 draft 'F'
   |
   o  1: 7fb047a69f22 draft 'E'
   |
   o  0: 426bada5c675 draft 'A'
   
   $ hg manifest --rev tip
   A
   B
   C
   D
   E
   F
 
   $ cd ..
 
 
 Merge gets linearized:
 
   $ hg init linearized-merge
   $ cd linearized-merge
 
   $ hg debugdrawdag << 'EOF'
   > F D
   > |/|
   > C B
   > |/
   > A
   > EOF
 
   $ hg phase --force --secret D
   $ hg rebase --source B --collapse --dest F
   rebasing 1:112478962961 "B" (B)
   rebasing 3:4e4f9194f9f1 "D" (D)
   saved backup bundle to $TESTTMP/linearized-merge/.hg/strip-backup/112478962961-e389075b-rebase.hg
 
   $ hg tglog
   o  3: 5bdc08b7da2b 'Collapsed revision
   |  * B
   |  * D'
   o  2: afc707c82df0 'F'
   |
   o  1: dc0947a82db8 'C'
   |
   o  0: 426bada5c675 'A'
   
   $ hg manifest --rev tip
   A
   B
   C
   F
 
   $ cd ..
 
 Custom message:
 
   $ hg init message
   $ cd message
 
   $ hg debugdrawdag << 'EOF'
   >   C
   >   |
   > D B
   > |/
   > A
   > EOF
 
 
   $ hg rebase --base B -m 'custom message'
   abort: message can only be specified with collapse
   [255]
 
   $ cat > $TESTTMP/checkeditform.sh <<EOF
   > env | grep HGEDITFORM
   > true
   > EOF
   $ HGEDITOR="sh $TESTTMP/checkeditform.sh" hg rebase --source B --collapse -m 'custom message' -e --dest D
   rebasing 1:112478962961 "B" (B)
   rebasing 3:26805aba1e60 "C" (C tip)
   HGEDITFORM=rebase.collapse
   saved backup bundle to $TESTTMP/message/.hg/strip-backup/112478962961-f4131707-rebase.hg
 
   $ hg tglog
   o  2: 2f197b9a08f3 'custom message'
   |
   o  1: b18e25de2cf5 'D'
   |
   o  0: 426bada5c675 'A'
   
   $ hg manifest --rev tip
   A
   B
   C
   D
 
   $ cd ..
 
 Rebase and collapse - more than one external (fail):
 
   $ hg init multiple-external-parents
   $ cd multiple-external-parents
 
   $ hg debugdrawdag << 'EOF'
   >   G
   >   |\
   >   | F
   >   | |
   >   D E
   >   |\|
   > H C B
   >  \|/
   >   A
   > EOF
 
   $ hg rebase -s C --dest H --collapse
   abort: unable to collapse on top of 3, there is more than one external parent: 1, 6
   [255]
 
 Rebase and collapse - E onto H:
 
   $ hg rebase -s E --dest I --collapse # root (E) is not a merge
   abort: unknown revision 'I'!
   [255]
 
   $ hg tglog
   o    7: 64e264db77f0 'G'
   |\
   | o  6: 11abe3fb10b8 'F'
   | |
   | o  5: 49cb92066bfd 'E'
   | |
   o |  4: 4e4f9194f9f1 'D'
   |\|
   | | o  3: 575c4b5ec114 'H'
   | | |
   o---+  2: dc0947a82db8 'C'
    / /
   o /  1: 112478962961 'B'
   |/
   o  0: 426bada5c675 'A'
   
   $ hg manifest --rev tip
   A
   B
   C
   E
   F
 
   $ cd ..
 
 
 
 
 Test that branchheads cache is updated correctly when doing a strip in which
 the parent of the ancestor node to be stripped does not become a head and also,
 the parent of a node that is a child of the node stripped becomes a head (node
 3). The code is now much simpler and we could just test a simpler scenario
 We keep it the test this way in case new complexity is injected.
 
 Create repo b:
 
   $ hg init branch-heads
   $ cd branch-heads
 
   $ hg debugdrawdag << 'EOF'
   >   G
   >   |\
   >   | F
   >   | |
   >   D E
   >   |\|
   > H C B
   >  \|/
   >   A
   > EOF
 
   $ hg heads --template="{rev}:{node} {branch}\n"
   7:64e264db77f061f16d9132b70c5a58e2461fb630 default
   3:575c4b5ec114d64b681d33f8792853568bfb2b2c default
 
   $ cat $TESTTMP/branch-heads/.hg/cache/branch2-served
   64e264db77f061f16d9132b70c5a58e2461fb630 7
   575c4b5ec114d64b681d33f8792853568bfb2b2c o default
   64e264db77f061f16d9132b70c5a58e2461fb630 o default
 
   $ hg strip 4
   saved backup bundle to $TESTTMP/branch-heads/.hg/strip-backup/4e4f9194f9f1-5ec4b5e6-backup.hg
 
   $ cat $TESTTMP/branch-heads/.hg/cache/branch2-served
   11abe3fb10b8689b560681094b17fe161871d043 5
   dc0947a82db884575bb76ea10ac97b08536bfa03 o default
   575c4b5ec114d64b681d33f8792853568bfb2b2c o default
   11abe3fb10b8689b560681094b17fe161871d043 o default
 
   $ hg heads --template="{rev}:{node} {branch}\n"
   5:11abe3fb10b8689b560681094b17fe161871d043 default
   3:575c4b5ec114d64b681d33f8792853568bfb2b2c default
   2:dc0947a82db884575bb76ea10ac97b08536bfa03 default
 
   $ cd ..
 
 
 
 Preserves external parent
 
   $ hg init external-parent
   $ cd external-parent
 
   $ hg debugdrawdag << 'EOF'
   >   H
   >   |\
   >   | G
   >   | |
   >   | F # F/E = F\n
   >   | |
   >   D E # D/D = D\n
   >   |\|
   > I C B
   >  \|/
   >   A
   > EOF
 
   $ hg rebase -s F --dest I --collapse # root (F) is not a merge
   rebasing 6:c82b08f646f1 "F" (F)
   file 'E' was deleted in local [dest] but was modified in other [source].
   You can use (c)hanged version, leave (d)eleted, or leave (u)nresolved.
   What do you want to do? u
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
   $ echo F > E
   $ hg resolve -m
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase -c
   rebasing 6:c82b08f646f1 "F" (F)
   rebasing 7:a6db7fa104e1 "G" (G)
   rebasing 8:e1d201b72d91 "H" (H tip)
   saved backup bundle to $TESTTMP/external-parent/.hg/strip-backup/c82b08f646f1-f2721fbf-rebase.hg
 
   $ hg tglog
   o    6: 681daa3e686d 'Collapsed revision
   |\   * F
   | |  * G
   | |  * H'
   | | o  5: 49cb92066bfd 'E'
   | | |
   | o |  4: 09143c0bf13e 'D'
   | |\|
   o | |  3: 08ebfeb61bac 'I'
   | | |
   | o |  2: dc0947a82db8 'C'
   |/ /
   | o  1: 112478962961 'B'
   |/
   o  0: 426bada5c675 'A'
   
   $ hg manifest --rev tip
   A
   C
   D
   E
   F
   G
   I
 
   $ hg up tip -q
   $ cat E
   F
 
   $ cd ..
 
 Rebasing from multiple bases:
 
   $ hg init multiple-bases
   $ cd multiple-bases
   $ hg debugdrawdag << 'EOF'
   >   C B
   > D |/
   > |/
   > A
   > EOF
   $ hg rebase --collapse -r 'B+C' -d D
   rebasing 1:fc2b737bb2e5 "B" (B)
   rebasing 2:dc0947a82db8 "C" (C)
   saved backup bundle to $TESTTMP/multiple-bases/.hg/strip-backup/dc0947a82db8-b0c1a7ea-rebase.hg
   $ hg tglog
   o  2: 2127ae44d291 'Collapsed revision
   |  * B
   |  * C'
   o  1: b18e25de2cf5 'D'
   |
   o  0: 426bada5c675 'A'
   
   $ cd ..
 
 With non-contiguous commits:
 
   $ hg init non-contiguous
   $ cd non-contiguous
   $ cat >> .hg/hgrc <<EOF
   > [experimental]
   > evolution=all
   > EOF
 
   $ hg debugdrawdag << 'EOF'
   > F
   > |
   > E
   > |
   > D
   > |
   > C
   > |
   > B G
   > |/
   > A
   > EOF
 
 BROKEN: should be allowed
   $ hg rebase --collapse -r 'B+D+F' -d G
   abort: unable to collapse on top of 2, there is more than one external parent: 3, 5
   [255]
   $ cd ..
 
 
   $ hg init multiple-external-parents-2
   $ cd multiple-external-parents-2
   $ hg debugdrawdag << 'EOF'
   > D       G
   > |\     /|
   > B C   E F
   >  \|   |/
   >   \ H /
   >    \|/
   >     A
   > EOF
 
   $ hg rebase --collapse -d H -s 'B+F'
   abort: unable to collapse on top of 5, there is more than one external parent: 1, 3
   [255]
   $ cd ..
 
 With internal merge:
 
   $ hg init internal-merge
   $ cd internal-merge
 
   $ hg debugdrawdag << 'EOF'
   >   E
   >   |\
   >   C D
   >   |/
   > F B
   > |/
   > A
   > EOF
 
 
   $ hg rebase -s B --collapse --dest F
   rebasing 1:112478962961 "B" (B)
   rebasing 3:26805aba1e60 "C" (C)
   rebasing 4:be0ef73c17ad "D" (D)
   rebasing 5:02c4367d6973 "E" (E tip)
   saved backup bundle to $TESTTMP/internal-merge/.hg/strip-backup/112478962961-1dfb057b-rebase.hg
 
   $ hg tglog
   o  2: c0512a1797b0 'Collapsed revision
   |  * B
   |  * C
   |  * D
   |  * E'
   o  1: 8908a377a434 'F'
   |
   o  0: 426bada5c675 'A'
   
   $ hg manifest --rev tip
   A
   B
   C
   D
   F
   $ cd ..
 
 Interactions between collapse and keepbranches
   $ hg init e
   $ cd e
   $ echo 'a' > a
   $ hg ci -Am 'A'
   adding a
 
   $ hg branch 'one'
   marked working directory as branch one
   (branches are permanent and global, did you want a bookmark?)
   $ echo 'b' > b
   $ hg ci -Am 'B'
   adding b
 
   $ hg branch 'two'
   marked working directory as branch two
   $ echo 'c' > c
   $ hg ci -Am 'C'
   adding c
 
   $ hg up -q 0
   $ echo 'd' > d
   $ hg ci -Am 'D'
   adding d
 
   $ hg tglog
   @  3: 41acb9dca9eb 'D'
   |
   | o  2: 8ac4a08debf1 'C' two
   | |
   | o  1: 1ba175478953 'B' one
   |/
   o  0: 1994f17a630e 'A'
   
   $ hg rebase --keepbranches --collapse -s 1 -d 3
   abort: cannot collapse multiple named branches
   [255]
 
   $ cd ..
 
 Rebase, collapse and copies
 
   $ hg init copies
   $ cd copies
   $ hg unbundle "$TESTDIR/bundles/renames.hg"
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 11 changes to 7 files (+1 heads)
   new changesets f447d5abf5ea:338e84e2e558 (4 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg up -q tip
   $ hg tglog
   @  3: 338e84e2e558 'move2'
   |
   o  2: 6e7340ee38c0 'move1'
   |
   | o  1: 1352765a01d4 'change'
   |/
   o  0: f447d5abf5ea 'add'
   
   $ hg rebase --collapse -d 1
   rebasing 2:6e7340ee38c0 "move1"
   merging a and d to d
   merging b and e to e
   merging c and f to f
   rebasing 3:338e84e2e558 "move2" (tip)
   merging f and c to c
   merging e and g to g
   saved backup bundle to $TESTTMP/copies/.hg/strip-backup/6e7340ee38c0-ef8ef003-rebase.hg
   $ hg st
   $ hg st --copies --change tip
   A d
     a
   A g
     b
   R b
   $ hg up tip -q
   $ cat c
   c
   c
   $ cat d
   a
   a
   $ cat g
   b
   b
   $ hg log -r . --template "{file_copies}\n"
   d (a)g (b)
 
 Test collapsing a middle revision in-place
 
   $ hg tglog
   @  2: 64b456429f67 'Collapsed revision
   |  * move1
   |  * move2'
   o  1: 1352765a01d4 'change'
   |
   o  0: f447d5abf5ea 'add'
   
   $ hg rebase --collapse -r 1 -d 0
   abort: cannot rebase changeset with children
   (use --keep to keep original changesets)
   [255]
 
 Test collapsing in place
 
   $ hg rebase --collapse -b . -d 0
   rebasing 1:1352765a01d4 "change"
   rebasing 2:64b456429f67 "Collapsed revision" (tip)
   saved backup bundle to $TESTTMP/copies/.hg/strip-backup/1352765a01d4-45a352ea-rebase.hg
   $ hg st --change tip --copies
   M a
   M c
   A d
     a
   A g
     b
   R b
   $ hg up tip -q
   $ cat a
   a
   a
   $ cat c
   c
   c
   $ cat d
   a
   a
   $ cat g
   b
   b
   $ cd ..
 
 
 Test stripping a revision with another child
 
   $ hg init f
   $ cd f
 
   $ hg debugdrawdag << 'EOF'
   > C B
   > |/
   > A
   > EOF
 
   $ hg heads --template="{rev}:{node} {branch}: {desc}\n"
   2:dc0947a82db884575bb76ea10ac97b08536bfa03 default: C
   1:112478962961147124edd43549aedd1a335e44bf default: B
 
   $ hg strip C
   saved backup bundle to $TESTTMP/f/.hg/strip-backup/dc0947a82db8-d21b92a4-backup.hg
 
   $ hg tglog
   o  1: 112478962961 'B'
   |
   o  0: 426bada5c675 'A'
   
 
 
   $ hg heads --template="{rev}:{node} {branch}: {desc}\n"
   1:112478962961147124edd43549aedd1a335e44bf default: B
 
   $ cd ..
 
 Test collapsing changes that add then remove a file
 
   $ hg init collapseaddremove
   $ cd collapseaddremove
 
   $ touch base
   $ hg commit -Am base
   adding base
   $ touch a
   $ hg commit -Am a
   adding a
   $ hg rm a
   $ touch b
   $ hg commit -Am b
   adding b
   $ hg book foo
   $ hg rebase -d 0 -r "1::2" --collapse -m collapsed
   rebasing 1:6d8d9f24eec3 "a"
   rebasing 2:1cc73eca5ecc "b" (foo tip)
   saved backup bundle to $TESTTMP/collapseaddremove/.hg/strip-backup/6d8d9f24eec3-77d3b6e2-rebase.hg
   $ hg log -G --template "{rev}: '{desc}' {bookmarks}"
   @  1: 'collapsed' foo
   |
   o  0: 'base'
   
   $ hg manifest --rev tip
   b
   base
 
   $ cd ..
 
 Test that rebase --collapse will remember message after
 running into merge conflict and invoking rebase --continue.
 
   $ hg init collapse_remember_message
   $ cd collapse_remember_message
   $ hg debugdrawdag << 'EOF'
   > C B # B/A = B\n
   > |/  # C/A = C\n
   > A
   > EOF
   $ hg rebase --collapse -m "new message" -b B -d C
   rebasing 1:81e5401e4d37 "B" (B)
   merging A
   warning: conflicts while merging A! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ rm A.orig
   $ hg resolve --mark A
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase --continue
   rebasing 1:81e5401e4d37 "B" (B)
   saved backup bundle to $TESTTMP/collapse_remember_message/.hg/strip-backup/81e5401e4d37-96c3dd30-rebase.hg
   $ hg log
   changeset:   2:17186933e123
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     new message
   
   changeset:   1:043039e9df84
   tag:         C
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     C
   
   changeset:   0:426bada5c675
   tag:         A
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     A
   
   $ cd ..
 
 Test aborted editor on final message
 
   $ HGMERGE=:merge3
   $ export HGMERGE
   $ hg init aborted-editor
   $ cd aborted-editor
   $ hg debugdrawdag << 'EOF'
   > C   # D/A = D\n
   > |   # C/A = C\n
   > B D # B/A = B\n
   > |/  # A/A = A\n
   > A
   > EOF
   $ hg rebase --collapse -t internal:merge3 -s B -d D
   rebasing 1:f899f3910ce7 "B" (B)
   merging A
   warning: conflicts while merging A! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg tglog
   o  3: 63668d570d21 'C'
   |
   | @  2: 82b8abf9c185 'D'
   | |
   @ |  1: f899f3910ce7 'B'
   |/
   o  0: 4a2df7238c3b 'A'
   
   $ cat A
   <<<<<<< dest:   82b8abf9c185 D - test: D
   D
   ||||||| base
   A
   =======
   B
   >>>>>>> source: f899f3910ce7 B - test: B
   $ echo BC > A
   $ hg resolve -m
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase --continue
   rebasing 1:f899f3910ce7 "B" (B)
   rebasing 3:63668d570d21 "C" (C tip)
   merging A
   warning: conflicts while merging A! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg tglog
   @  3: 63668d570d21 'C'
   |
   | @  2: 82b8abf9c185 'D'
   | |
   o |  1: f899f3910ce7 'B'
   |/
   o  0: 4a2df7238c3b 'A'
   
   $ cat A
   <<<<<<< dest:   82b8abf9c185 D - test: D
   BC
   ||||||| base
   B
   =======
   C
   >>>>>>> source: 63668d570d21 C tip - test: C
   $ echo BD > A
   $ hg resolve -m
   (no more unresolved files)
   continue: hg rebase --continue
   $ HGEDITOR=false hg rebase --continue --config ui.interactive=1
   already rebased 1:f899f3910ce7 "B" (B) as 82b8abf9c185
   rebasing 3:63668d570d21 "C" (C tip)
   abort: edit failed: false exited with status 1
   [255]
   $ hg tglog
-  o  3: 63668d570d21 'C'
+  %  3: 63668d570d21 'C'
   |
   | @  2: 82b8abf9c185 'D'
   | |
   o |  1: f899f3910ce7 'B'
   |/
   o  0: 4a2df7238c3b 'A'
   
   $ hg rebase --continue
   already rebased 1:f899f3910ce7 "B" (B) as 82b8abf9c185
   already rebased 3:63668d570d21 "C" (C tip) as 82b8abf9c185
   saved backup bundle to $TESTTMP/aborted-editor/.hg/strip-backup/f899f3910ce7-7cab5e15-rebase.hg

tests/test-strip.t

@@ -1,1407 +1,1407 b''
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "strip=" >> $HGRCPATH
   $ echo "drawdag=$TESTDIR/drawdag.py" >> $HGRCPATH
 
   $ restore() {
   >     hg unbundle -q .hg/strip-backup/*
   >     rm .hg/strip-backup/*
   > }
   $ teststrip() {
   >     hg up -C $1
   >     echo % before update $1, strip $2
   >     hg log -G -T '{rev}:{node}'
   >     hg --traceback strip $2
   >     echo % after update $1, strip $2
   >     hg log -G -T '{rev}:{node}'
   >     restore
   > }
 
   $ hg init test
   $ cd test
 
   $ echo foo > bar
   $ hg ci -Ama
   adding bar
 
   $ echo more >> bar
   $ hg ci -Amb
 
   $ echo blah >> bar
   $ hg ci -Amc
 
   $ hg up 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo blah >> bar
   $ hg ci -Amd
   created new head
 
   $ echo final >> bar
   $ hg ci -Ame
 
   $ hg log
   changeset:   4:443431ffac4f
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   changeset:   3:65bd5f99a4a3
   parent:      1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     d
   
   changeset:   2:264128213d29
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   changeset:   0:9ab35a2d17cb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
 
   $ teststrip 4 4
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   % before update 4, strip 4
   @  4:443431ffac4f5b5a19b0b6c298a21b7ba736bcce
   |
   o  3:65bd5f99a4a376cdea23a1153f07856b0d881d64
   |
   | o  2:264128213d290d868c54642d13aeaa3675551a78
   |/
   o  1:ef3a871183d7199c541cc140218298bbfcc6c28a
   |
   o  0:9ab35a2d17cb64271241ea881efcc19dd953215b
   
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update 4, strip 4
   @  3:65bd5f99a4a376cdea23a1153f07856b0d881d64
   |
   | o  2:264128213d290d868c54642d13aeaa3675551a78
   |/
   o  1:ef3a871183d7199c541cc140218298bbfcc6c28a
   |
   o  0:9ab35a2d17cb64271241ea881efcc19dd953215b
   
   $ teststrip 4 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   % before update 4, strip 3
   @  4:443431ffac4f5b5a19b0b6c298a21b7ba736bcce
   |
   o  3:65bd5f99a4a376cdea23a1153f07856b0d881d64
   |
   | o  2:264128213d290d868c54642d13aeaa3675551a78
   |/
   o  1:ef3a871183d7199c541cc140218298bbfcc6c28a
   |
   o  0:9ab35a2d17cb64271241ea881efcc19dd953215b
   
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update 4, strip 3
   o  2:264128213d290d868c54642d13aeaa3675551a78
   |
   @  1:ef3a871183d7199c541cc140218298bbfcc6c28a
   |
   o  0:9ab35a2d17cb64271241ea881efcc19dd953215b
   
   $ teststrip 1 4
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   % before update 1, strip 4
   o  4:443431ffac4f5b5a19b0b6c298a21b7ba736bcce
   |
   o  3:65bd5f99a4a376cdea23a1153f07856b0d881d64
   |
   | o  2:264128213d290d868c54642d13aeaa3675551a78
   |/
   @  1:ef3a871183d7199c541cc140218298bbfcc6c28a
   |
   o  0:9ab35a2d17cb64271241ea881efcc19dd953215b
   
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update 1, strip 4
   o  3:65bd5f99a4a376cdea23a1153f07856b0d881d64
   |
   | o  2:264128213d290d868c54642d13aeaa3675551a78
   |/
   @  1:ef3a871183d7199c541cc140218298bbfcc6c28a
   |
   o  0:9ab35a2d17cb64271241ea881efcc19dd953215b
   
   $ teststrip 4 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   % before update 4, strip 2
   @  4:443431ffac4f5b5a19b0b6c298a21b7ba736bcce
   |
   o  3:65bd5f99a4a376cdea23a1153f07856b0d881d64
   |
   | o  2:264128213d290d868c54642d13aeaa3675551a78
   |/
   o  1:ef3a871183d7199c541cc140218298bbfcc6c28a
   |
   o  0:9ab35a2d17cb64271241ea881efcc19dd953215b
   
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update 4, strip 2
   @  3:443431ffac4f5b5a19b0b6c298a21b7ba736bcce
   |
   o  2:65bd5f99a4a376cdea23a1153f07856b0d881d64
   |
   o  1:ef3a871183d7199c541cc140218298bbfcc6c28a
   |
   o  0:9ab35a2d17cb64271241ea881efcc19dd953215b
   
   $ teststrip 4 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   % before update 4, strip 1
   @  4:264128213d290d868c54642d13aeaa3675551a78
   |
   | o  3:443431ffac4f5b5a19b0b6c298a21b7ba736bcce
   | |
   | o  2:65bd5f99a4a376cdea23a1153f07856b0d881d64
   |/
   o  1:ef3a871183d7199c541cc140218298bbfcc6c28a
   |
   o  0:9ab35a2d17cb64271241ea881efcc19dd953215b
   
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update 4, strip 1
   @  0:9ab35a2d17cb64271241ea881efcc19dd953215b
   
   $ teststrip null 4
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   % before update null, strip 4
   o  4:264128213d290d868c54642d13aeaa3675551a78
   |
   | o  3:443431ffac4f5b5a19b0b6c298a21b7ba736bcce
   | |
   | o  2:65bd5f99a4a376cdea23a1153f07856b0d881d64
   |/
   o  1:ef3a871183d7199c541cc140218298bbfcc6c28a
   |
   o  0:9ab35a2d17cb64271241ea881efcc19dd953215b
   
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update null, strip 4
   o  3:443431ffac4f5b5a19b0b6c298a21b7ba736bcce
   |
   o  2:65bd5f99a4a376cdea23a1153f07856b0d881d64
   |
   o  1:ef3a871183d7199c541cc140218298bbfcc6c28a
   |
   o  0:9ab35a2d17cb64271241ea881efcc19dd953215b
   
 
   $ hg log
   changeset:   4:264128213d29
   tag:         tip
   parent:      1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
   changeset:   3:443431ffac4f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   changeset:   2:65bd5f99a4a3
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     d
   
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   changeset:   0:9ab35a2d17cb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
   $ hg up -C 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg parents
   changeset:   4:264128213d29
   tag:         tip
   parent:      1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
 
   $ hg --traceback strip 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/264128213d29-0b39d6bf-backup.hg
   $ hg parents
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   $ hg debugbundle .hg/strip-backup/*
   Stream params: {Compression: BZ}
   changegroup -- {nbchanges: 1, version: 02} (mandatory: True)
       264128213d290d868c54642d13aeaa3675551a78
   cache:rev-branch-cache -- {} (mandatory: False)
   phase-heads -- {} (mandatory: True)
       264128213d290d868c54642d13aeaa3675551a78 draft
   $ hg unbundle .hg/strip-backup/*
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 0 changes to 1 files (+1 heads)
   new changesets 264128213d29 (1 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ rm .hg/strip-backup/*
   $ hg log --graph
   o  changeset:   4:264128213d29
   |  tag:         tip
   |  parent:      1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     c
   |
   | o  changeset:   3:443431ffac4f
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     e
   | |
   | o  changeset:   2:65bd5f99a4a3
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     d
   |
   @  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ hg up -C 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 4
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 before strip of merge parent
 
   $ hg parents
   changeset:   2:65bd5f99a4a3
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     d
   
   changeset:   4:264128213d29
   tag:         tip
   parent:      1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
 ##strip not allowed with merge in progress
   $ hg strip 4
   abort: outstanding uncommitted merge
   (use 'hg commit' or 'hg merge --abort')
   [255]
 ##strip allowed --force with merge in progress
   $ hg strip 4 --force
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
 
 after strip of merge parent
 
   $ hg parents
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   $ restore
 
   $ hg up
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "264128213d29: c"
   1 other heads for branch "default"
   $ hg log -G
   @  changeset:   4:264128213d29
   |  tag:         tip
   |  parent:      1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     c
   |
   | o  changeset:   3:443431ffac4f
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     e
   | |
   | o  changeset:   2:65bd5f99a4a3
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     d
   |
   o  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
 
 2 is parent of 3, only one strip should happen
 
   $ hg strip "roots(2)" 3
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ hg log -G
   @  changeset:   2:264128213d29
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     c
   |
   o  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ restore
   $ hg log -G
   o  changeset:   4:443431ffac4f
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     e
   |
   o  changeset:   3:65bd5f99a4a3
   |  parent:      1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     d
   |
   | @  changeset:   2:264128213d29
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     c
   |
   o  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
 Failed hook while applying "saveheads" bundle.
 
   $ hg strip 2 --config hooks.pretxnchangegroup.bad=false
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   transaction abort!
   rollback completed
   strip failed, backup bundle stored in '$TESTTMP/test/.hg/strip-backup/*-backup.hg' (glob)
   strip failed, unrecovered changes stored in '$TESTTMP/test/.hg/strip-backup/*-temp.hg' (glob)
   (fix the problem, then recover the changesets with "hg unbundle '$TESTTMP/test/.hg/strip-backup/*-temp.hg'") (glob)
   abort: pretxnchangegroup.bad hook exited with status 1
   [255]
   $ restore
   $ hg log -G
   o  changeset:   4:443431ffac4f
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     e
   |
   o  changeset:   3:65bd5f99a4a3
   |  parent:      1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     d
   |
   | o  changeset:   2:264128213d29
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     c
   |
   @  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
 
 2 different branches: 2 strips
 
   $ hg strip 2 4
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ hg log -G
   o  changeset:   2:65bd5f99a4a3
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     d
   |
   @  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ restore
 
 2 different branches and a common ancestor: 1 strip
 
   $ hg strip 1 "2|4"
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ restore
 
 verify fncache is kept up-to-date
 
   $ touch a
   $ hg ci -qAm a
 #if repofncache
   $ cat .hg/store/fncache | sort
   data/a.i
   data/bar.i
 #endif
 
   $ hg strip tip
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
 #if repofncache
   $ cat .hg/store/fncache
   data/bar.i
 #endif
 
 stripping an empty revset
 
   $ hg strip "1 and not 1"
   abort: empty revision set
   [255]
 
 remove branchy history for qimport tests
 
   $ hg strip 3
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
 
 
 strip of applied mq should cleanup status file
 
   $ echo "mq=" >> $HGRCPATH
   $ hg up -C 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo fooagain >> bar
   $ hg ci -mf
   $ hg qimport -r tip:2
 
 applied patches before strip
 
   $ hg qapplied
   d
   e
   f
 
 stripping revision in queue
 
   $ hg strip 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
 
 applied patches after stripping rev in queue
 
   $ hg qapplied
   d
 
 stripping ancestor of queue
 
   $ hg strip 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
 
 applied patches after stripping ancestor of queue
 
   $ hg qapplied
 
 Verify strip protects against stripping wc parent when there are uncommitted mods
 
   $ echo b > b
   $ echo bb > bar
   $ hg add b
   $ hg ci -m 'b'
   $ hg log --graph
   @  changeset:   1:76dcf9fab855
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ hg up 0
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > bar
   $ hg up -t false
   merging bar
   merging bar failed!
   1 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ hg sum
   parent: 1:76dcf9fab855 tip
    b
   branch: default
   commit: 1 modified, 1 unknown, 1 unresolved
   update: (current)
   phases: 2 draft
   mq:     3 unapplied
 
   $ hg log --graph
   @  changeset:   1:76dcf9fab855
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
-  o  changeset:   0:9ab35a2d17cb
+  %  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ echo c > b
   $ hg strip tip
   abort: uncommitted changes
   [255]
   $ hg strip tip --keep
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ hg log --graph
   @  changeset:   0:9ab35a2d17cb
      tag:         tip
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ hg status
   M bar
   ? b
   ? bar.orig
 
   $ rm bar.orig
   $ hg sum
   parent: 0:9ab35a2d17cb tip
    a
   branch: default
   commit: 1 modified, 1 unknown
   update: (current)
   phases: 1 draft
   mq:     3 unapplied
 
 Strip adds, removes, modifies with --keep
 
   $ touch b
   $ hg add b
   $ hg commit -mb
   $ touch c
 
 ... with a clean working dir
 
   $ hg add c
   $ hg rm bar
   $ hg commit -mc
   $ hg status
   $ hg strip --keep tip
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ hg status
   ! bar
   ? c
 
 ... with a dirty working dir
 
   $ hg add c
   $ hg rm bar
   $ hg commit -mc
   $ hg status
   $ echo b > b
   $ echo d > d
   $ hg strip --keep tip
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ hg status
   M b
   ! bar
   ? c
   ? d
 
 ... after updating the dirstate
   $ hg add c
   $ hg commit -mc
   $ hg rm c
   $ hg commit -mc
   $ hg strip --keep '.^' -q
   $ cd ..
 
 stripping many nodes on a complex graph (issue3299)
 
   $ hg init issue3299
   $ cd issue3299
   $ hg debugbuilddag '@a.:a@b.:b.:x<a@a.:a<b@b.:b<a@a.:a'
   $ hg strip 'not ancestors(x)'
   saved backup bundle to $TESTTMP/issue3299/.hg/strip-backup/*-backup.hg (glob)
 
 test hg strip -B bookmark
 
   $ cd ..
   $ hg init bookmarks
   $ cd bookmarks
   $ hg debugbuilddag '..<2.*1/2:m<2+3:c<m+3:a<2.:b<m+2:d<2.:e<m+1:f'
   $ hg bookmark -r 'a' 'todelete'
   $ hg bookmark -r 'b' 'B'
   $ hg bookmark -r 'b' 'nostrip'
   $ hg bookmark -r 'c' 'delete'
   $ hg bookmark -r 'd' 'multipledelete1'
   $ hg bookmark -r 'e' 'multipledelete2'
   $ hg bookmark -r 'f' 'singlenode1'
   $ hg bookmark -r 'f' 'singlenode2'
   $ hg up -C todelete
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark todelete)
   $ hg strip -B nostrip
   bookmark 'nostrip' deleted
   abort: empty revision set
   [255]
   $ hg strip -B todelete
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/bookmarks/.hg/strip-backup/*-backup.hg (glob)
   bookmark 'todelete' deleted
   $ hg id -ir dcbb326fdec2
   abort: unknown revision 'dcbb326fdec2'!
   [255]
   $ hg id -ir d62d843c9a01
   d62d843c9a01
   $ hg bookmarks
      B                         9:ff43616e5d0f
      delete                    6:2702dd0c91e7
      multipledelete1           11:e46a4836065c
      multipledelete2           12:b4594d867745
      singlenode1               13:43227190fef8
      singlenode2               13:43227190fef8
   $ hg strip -B multipledelete1 -B multipledelete2
   saved backup bundle to $TESTTMP/bookmarks/.hg/strip-backup/e46a4836065c-89ec65c2-backup.hg
   bookmark 'multipledelete1' deleted
   bookmark 'multipledelete2' deleted
   $ hg id -ir e46a4836065c
   abort: unknown revision 'e46a4836065c'!
   [255]
   $ hg id -ir b4594d867745
   abort: unknown revision 'b4594d867745'!
   [255]
   $ hg strip -B singlenode1 -B singlenode2
   saved backup bundle to $TESTTMP/bookmarks/.hg/strip-backup/43227190fef8-8da858f2-backup.hg
   bookmark 'singlenode1' deleted
   bookmark 'singlenode2' deleted
   $ hg id -ir 43227190fef8
   abort: unknown revision '43227190fef8'!
   [255]
   $ hg strip -B unknownbookmark
   abort: bookmark 'unknownbookmark' not found
   [255]
   $ hg strip -B unknownbookmark1 -B unknownbookmark2
   abort: bookmark 'unknownbookmark1,unknownbookmark2' not found
   [255]
   $ hg strip -B delete -B unknownbookmark
   abort: bookmark 'unknownbookmark' not found
   [255]
   $ hg strip -B delete
   saved backup bundle to $TESTTMP/bookmarks/.hg/strip-backup/*-backup.hg (glob)
   bookmark 'delete' deleted
   $ hg id -ir 6:2702dd0c91e7
   abort: unknown revision '2702dd0c91e7'!
   [255]
   $ hg update B
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark B)
   $ echo a > a
   $ hg add a
   $ hg strip -B B
   abort: uncommitted changes
   [255]
   $ hg bookmarks
    * B                         6:ff43616e5d0f
 
 Make sure no one adds back a -b option:
 
   $ hg strip -b tip
   hg strip: option -b not recognized
   hg strip [-k] [-f] [-B bookmark] [-r] REV...
   
   strip changesets and all their descendants from the repository
   
   (use 'hg help -e strip' to show help for the strip extension)
   
   options ([+] can be repeated):
   
    -r --rev REV [+]           strip specified revision (optional, can specify
                               revisions without this option)
    -f --force                 force removal of changesets, discard uncommitted
                               changes (no backup)
       --no-backup             do not save backup bundle
    -k --keep                  do not modify working directory during strip
    -B --bookmark BOOKMARK [+] remove revs only reachable from given bookmark
       --mq                    operate on patch repository
   
   (use 'hg strip -h' to show more help)
   [255]
 
   $ cd ..
 
 Verify bundles don't get overwritten:
 
   $ hg init doublebundle
   $ cd doublebundle
   $ touch a
   $ hg commit -Aqm a
   $ touch b
   $ hg commit -Aqm b
   $ hg strip -r 0
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/doublebundle/.hg/strip-backup/3903775176ed-e68910bd-backup.hg
   $ ls .hg/strip-backup
   3903775176ed-e68910bd-backup.hg
 #if repobundlerepo
   $ hg pull -q -r 3903775176ed .hg/strip-backup/3903775176ed-e68910bd-backup.hg
   $ hg strip -r 0
   saved backup bundle to $TESTTMP/doublebundle/.hg/strip-backup/3903775176ed-54390173-backup.hg
   $ ls .hg/strip-backup
   3903775176ed-54390173-backup.hg
   3903775176ed-e68910bd-backup.hg
 #endif
   $ cd ..
 
 Test that we only bundle the stripped changesets (issue4736)
 ------------------------------------------------------------
 
 initialization (previous repo is empty anyway)
 
   $ hg init issue4736
   $ cd issue4736
   $ echo a > a
   $ hg add a
   $ hg commit -m commitA
   $ echo b > b
   $ hg add b
   $ hg commit -m commitB
   $ echo c > c
   $ hg add c
   $ hg commit -m commitC
   $ hg up 'desc(commitB)'
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo d > d
   $ hg add d
   $ hg commit -m commitD
   created new head
   $ hg up 'desc(commitC)'
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 'desc(commitD)'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m 'mergeCD'
   $ hg log -G
   @    changeset:   4:d8db9d137221
   |\   tag:         tip
   | |  parent:      2:5c51d8d6557d
   | |  parent:      3:6625a5168474
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     mergeCD
   | |
   | o  changeset:   3:6625a5168474
   | |  parent:      1:eca11cf91c71
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     commitD
   | |
   o |  changeset:   2:5c51d8d6557d
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     commitC
   |
   o  changeset:   1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
 
 Check bundle behavior:
 
   $ hg bundle -r 'desc(mergeCD)' --base 'desc(commitC)' ../issue4736.hg
   2 changesets found
 #if repobundlerepo
   $ hg log -r 'bundle()' -R ../issue4736.hg
   changeset:   3:6625a5168474
   parent:      1:eca11cf91c71
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commitD
   
   changeset:   4:d8db9d137221
   tag:         tip
   parent:      2:5c51d8d6557d
   parent:      3:6625a5168474
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     mergeCD
   
 #endif
 
 check strip behavior
 
   $ hg --config extensions.strip= strip 'desc(commitD)' --debug
   resolving manifests
    branchmerge: False, force: True, partial: False
    ancestor: d8db9d137221+, local: d8db9d137221+, remote: eca11cf91c71
    c: other deleted -> r
   removing c
    d: other deleted -> r
   removing d
   starting 4 threads for background file closing (?)
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   2 changesets found
   list of changesets:
   6625a516847449b6f0fa3737b9ba56e9f0f3032c
   d8db9d1372214336d2b5570f20ee468d2c72fa8b
   bundle2-output-bundle: "HG20", (1 params) 3 parts total
   bundle2-output-part: "changegroup" (params: 1 mandatory 1 advisory) streamed payload
   bundle2-output-part: "cache:rev-branch-cache" (advisory) streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   saved backup bundle to $TESTTMP/issue4736/.hg/strip-backup/6625a5168474-345bb43d-backup.hg
   updating the branch cache
   invalid branch cache (served): tip differs
   $ hg log -G
   o  changeset:   2:5c51d8d6557d
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitC
   |
   @  changeset:   1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
 
 strip backup content
 
 #if repobundlerepo
   $ hg log -r 'bundle()' -R .hg/strip-backup/6625a5168474-*-backup.hg
   changeset:   3:6625a5168474
   parent:      1:eca11cf91c71
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commitD
   
   changeset:   4:d8db9d137221
   tag:         tip
   parent:      2:5c51d8d6557d
   parent:      3:6625a5168474
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     mergeCD
   
 
 #endif
 
 Check that the phase cache is properly invalidated after a strip with bookmark.
 
   $ cat > ../stripstalephasecache.py << EOF
   > from mercurial import extensions, localrepo
   > def transactioncallback(orig, repo, desc, *args, **kwargs):
   >     def test(transaction):
   >         # observe cache inconsistency
   >         try:
   >             [repo.changelog.node(r) for r in repo.revs(b"not public()")]
   >         except IndexError:
   >             repo.ui.status(b"Index error!\n")
   >     transaction = orig(repo, desc, *args, **kwargs)
   >     # warm up the phase cache
   >     list(repo.revs(b"not public()"))
   >     if desc != b'strip':
   >          transaction.addpostclose(b"phase invalidation test", test)
   >     return transaction
   > def extsetup(ui):
   >     extensions.wrapfunction(localrepo.localrepository, b"transaction",
   >                             transactioncallback)
   > EOF
   $ hg up -C 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo k > k
   $ hg add k
   $ hg commit -m commitK
   $ echo l > l
   $ hg add l
   $ hg commit -m commitL
   $ hg book -r tip blah
   $ hg strip ".^" --config extensions.crash=$TESTTMP/stripstalephasecache.py
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/issue4736/.hg/strip-backup/8f0b4384875c-4fa10deb-backup.hg
   $ hg up -C 1
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 Error during post-close callback of the strip transaction
 (They should be gracefully handled and reported)
 
   $ cat > ../crashstrip.py << EOF
   > from mercurial import error
   > def reposetup(ui, repo):
   >     class crashstriprepo(repo.__class__):
   >         def transaction(self, desc, *args, **kwargs):
   >             tr = super(crashstriprepo, self).transaction(desc, *args, **kwargs)
   >             if desc == b'strip':
   >                 def crash(tra): raise error.Abort(b'boom')
   >                 tr.addpostclose(b'crash', crash)
   >             return tr
   >     repo.__class__ = crashstriprepo
   > EOF
   $ hg strip tip --config extensions.crash=$TESTTMP/crashstrip.py
   saved backup bundle to $TESTTMP/issue4736/.hg/strip-backup/5c51d8d6557d-70daef06-backup.hg
   strip failed, backup bundle stored in '$TESTTMP/issue4736/.hg/strip-backup/5c51d8d6557d-70daef06-backup.hg'
   abort: boom
   [255]
 
 test stripping a working directory parent doesn't switch named branches
 
   $ hg log -G
   @  changeset:   1:eca11cf91c71
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
 
   $ hg branch new-branch
   marked working directory as branch new-branch
   (branches are permanent and global, did you want a bookmark?)
   $ hg ci -m "start new branch"
   $ echo 'foo' > foo.txt
   $ hg ci -Aqm foo
   $ hg up default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo 'bar' > bar.txt
   $ hg ci -Aqm bar
   $ hg up new-branch
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg log -G
   @  changeset:   4:35358f982181
   |  tag:         tip
   |  parent:      1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     bar
   |
   | @  changeset:   3:f62c6c09b707
   | |  branch:      new-branch
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     foo
   | |
   | o  changeset:   2:b1d33a8cadd9
   |/   branch:      new-branch
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     start new branch
   |
   o  changeset:   1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
 
   $ hg strip --force -r 35358f982181
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/issue4736/.hg/strip-backup/35358f982181-50d992d4-backup.hg
   $ hg log -G
   @  changeset:   3:f62c6c09b707
   |  branch:      new-branch
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     foo
   |
   o  changeset:   2:b1d33a8cadd9
   |  branch:      new-branch
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     start new branch
   |
   o  changeset:   1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
 
   $ hg up default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo 'bar' > bar.txt
   $ hg ci -Aqm bar
   $ hg up new-branch
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m merge
   $ hg log -G
   @    changeset:   5:4cf5e92caec2
   |\   branch:      new-branch
   | |  tag:         tip
   | |  parent:      3:f62c6c09b707
   | |  parent:      4:35358f982181
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     merge
   | |
   | o  changeset:   4:35358f982181
   | |  parent:      1:eca11cf91c71
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     bar
   | |
   o |  changeset:   3:f62c6c09b707
   | |  branch:      new-branch
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     foo
   | |
   o |  changeset:   2:b1d33a8cadd9
   |/   branch:      new-branch
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     start new branch
   |
   o  changeset:   1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
 
   $ hg strip -r 35358f982181
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/issue4736/.hg/strip-backup/35358f982181-a6f020aa-backup.hg
   $ hg log -G
   @  changeset:   3:f62c6c09b707
   |  branch:      new-branch
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     foo
   |
   o  changeset:   2:b1d33a8cadd9
   |  branch:      new-branch
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     start new branch
   |
   o  changeset:   1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
 
   $ hg unbundle -u $TESTTMP/issue4736/.hg/strip-backup/35358f982181-a6f020aa-backup.hg
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 1 changes to 1 files
   new changesets 35358f982181:4cf5e92caec2 (2 drafts)
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg strip -k -r 35358f982181
   saved backup bundle to $TESTTMP/issue4736/.hg/strip-backup/35358f982181-a6f020aa-backup.hg
   $ hg log -G
   @  changeset:   3:f62c6c09b707
   |  branch:      new-branch
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     foo
   |
   o  changeset:   2:b1d33a8cadd9
   |  branch:      new-branch
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     start new branch
   |
   o  changeset:   1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
   $ hg diff
   diff -r f62c6c09b707 bar.txt
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/bar.txt	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +bar
 
 Use delayedstrip to strip inside a transaction
 
   $ cd $TESTTMP
   $ hg init delayedstrip
   $ cd delayedstrip
   $ hg debugdrawdag <<'EOS'
   >   D
   >   |
   >   C F H    # Commit on top of "I",
   >   | |/|    # Strip B+D+I+E+G+H+Z
   > I B E G
   >  \|/
   >   A   Z
   > EOS
   $ cp -R . ../scmutilcleanup
 
   $ hg up -C I
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 3 >> I
   $ cat > $TESTTMP/delayedstrip.py <<EOF
   > from __future__ import absolute_import
   > from mercurial import commands, registrar, repair
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > @command(b'testdelayedstrip')
   > def testdelayedstrip(ui, repo):
   >     def getnodes(expr):
   >         return [repo.changelog.node(r) for r in repo.revs(expr)]
   >     with repo.wlock():
   >         with repo.lock():
   >             with repo.transaction(b'delayedstrip'):
   >                 repair.delayedstrip(ui, repo, getnodes(b'B+I+Z+D+E'), b'J')
   >                 repair.delayedstrip(ui, repo, getnodes(b'G+H+Z'), b'I')
   >                 commands.commit(ui, repo, message=b'J', date=b'0 0')
   > EOF
   $ hg testdelayedstrip --config extensions.t=$TESTTMP/delayedstrip.py
   warning: orphaned descendants detected, not stripping 08ebfeb61bac, 112478962961, 7fb047a69f22
   saved backup bundle to $TESTTMP/delayedstrip/.hg/strip-backup/f585351a92f8-17475721-I.hg
 
   $ hg log -G -T '{rev}:{node|short} {desc}' -r 'sort(all(), topo)'
   @  6:2f2d51af6205 J
   |
   o  3:08ebfeb61bac I
   |
   | o  5:64a8289d2492 F
   | |
   | o  2:7fb047a69f22 E
   |/
   | o  4:26805aba1e60 C
   | |
   | o  1:112478962961 B
   |/
   o  0:426bada5c675 A
   
 Test high-level scmutil.cleanupnodes API
 
   $ cd $TESTTMP/scmutilcleanup
   $ hg debugdrawdag <<'EOS'
   >   D2  F2  G2   # D2, F2, G2 are replacements for D, F, G
   >   |   |   |
   >   C   H   G
   > EOS
   $ for i in B C D F G I Z; do
   >     hg bookmark -i -r $i b-$i
   > done
   $ hg bookmark -i -r E 'b-F@divergent1'
   $ hg bookmark -i -r H 'b-F@divergent2'
   $ hg bookmark -i -r G 'b-F@divergent3'
   $ cp -R . ../scmutilcleanup.obsstore
 
   $ cat > $TESTTMP/scmutilcleanup.py <<EOF
   > from mercurial import registrar, scmutil
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > @command(b'testnodescleanup')
   > def testnodescleanup(ui, repo):
   >     def nodes(expr):
   >         return [repo.changelog.node(r) for r in repo.revs(expr)]
   >     def node(expr):
   >         return nodes(expr)[0]
   >     with repo.wlock():
   >         with repo.lock():
   >             with repo.transaction(b'delayedstrip'):
   >                 mapping = {node(b'F'): [node(b'F2')],
   >                            node(b'D'): [node(b'D2')],
   >                            node(b'G'): [node(b'G2')]}
   >                 scmutil.cleanupnodes(repo, mapping, b'replace')
   >                 scmutil.cleanupnodes(repo, nodes(b'((B::)+I+Z)-D2-obsolete()'),
   >                                      b'replace')
   > EOF
   $ hg testnodescleanup --config extensions.t=$TESTTMP/scmutilcleanup.py
   warning: orphaned descendants detected, not stripping 112478962961, 1fc8102cda62, 26805aba1e60
   saved backup bundle to $TESTTMP/scmutilcleanup/.hg/strip-backup/f585351a92f8-73fb7c03-replace.hg
 
   $ hg log -G -T '{rev}:{node|short} {desc} {bookmarks}' -r 'sort(all(), topo)'
   o  8:1473d4b996d1 G2 b-F@divergent3 b-G
   |
   | o  7:d11b3456a873 F2 b-F
   | |
   | o  5:5cb05ba470a7 H
   |/|
   | o  3:7fb047a69f22 E b-F@divergent1
   | |
   | | o  6:7c78f703e465 D2 b-D
   | | |
   | | o  4:26805aba1e60 C
   | | |
   | | o  2:112478962961 B
   | |/
   o |  1:1fc8102cda62 G
    /
   o  0:426bada5c675 A b-B b-C b-I
   
   $ hg bookmark
      b-B                       0:426bada5c675
      b-C                       0:426bada5c675
      b-D                       6:7c78f703e465
      b-F                       7:d11b3456a873
      b-F@divergent1            3:7fb047a69f22
      b-F@divergent3            8:1473d4b996d1
      b-G                       8:1473d4b996d1
      b-I                       0:426bada5c675
      b-Z                       -1:000000000000
 
 Test the above using obsstore "by the way". Not directly related to strip, but
 we have reusable code here
 
   $ cd $TESTTMP/scmutilcleanup.obsstore
   $ cat >> .hg/hgrc <<EOF
   > [experimental]
   > evolution=true
   > evolution.track-operation=1
   > EOF
 
   $ hg testnodescleanup --config extensions.t=$TESTTMP/scmutilcleanup.py
   4 new orphan changesets
 
   $ rm .hg/localtags
   $ hg log -G -T '{rev}:{node|short} {desc} {bookmarks}' -r 'sort(all(), topo)'
   *  12:1473d4b996d1 G2 b-F@divergent3 b-G
   |
   | *  11:d11b3456a873 F2 b-F
   | |
   | *  8:5cb05ba470a7 H
   |/|
   | o  4:7fb047a69f22 E b-F@divergent1
   | |
   | | *  10:7c78f703e465 D2 b-D
   | | |
   | | x  6:26805aba1e60 C
   | | |
   | | x  3:112478962961 B
   | |/
   x |  1:1fc8102cda62 G
    /
   o  0:426bada5c675 A b-B b-C b-I
   
   $ hg debugobsolete
   1fc8102cda6204549f031015641606ccf5513ec3 1473d4b996d1d1b121de6b39fab6a04fbf9d873e 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '13', 'operation': 'replace', 'user': 'test'}
   64a8289d249234b9886244d379f15e6b650b28e3 d11b3456a873daec7c7bc53e5622e8df6d741bd2 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '13', 'operation': 'replace', 'user': 'test'}
   f585351a92f85104bff7c284233c338b10eb1df7 7c78f703e465d73102cc8780667ce269c5208a40 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '9', 'operation': 'replace', 'user': 'test'}
   48b9aae0607f43ff110d84e6883c151942add5ab 0 {0000000000000000000000000000000000000000} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'replace', 'user': 'test'}
   112478962961147124edd43549aedd1a335e44bf 0 {426bada5c67598ca65036d57d9e4b64b0c1ce7a0} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'replace', 'user': 'test'}
   08ebfeb61bac6e3f12079de774d285a0d6689eba 0 {426bada5c67598ca65036d57d9e4b64b0c1ce7a0} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'replace', 'user': 'test'}
   26805aba1e600a82e93661149f2313866a221a7b 0 {112478962961147124edd43549aedd1a335e44bf} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'replace', 'user': 'test'}
   $ cd ..
 
 Test that obsmarkers are restored even when not using generaldelta
 
   $ hg --config format.usegeneraldelta=no init issue5678
   $ cd issue5678
   $ cat >> .hg/hgrc <<EOF
   > [experimental]
   > evolution=true
   > EOF
   $ echo a > a
   $ hg ci -Aqm a
   $ hg ci --amend -m a2
   $ hg debugobsolete
   cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b 489bac576828490c0bb8d45eac9e5e172e4ec0a8 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '1', 'operation': 'amend', 'user': 'test'}
   $ hg strip .
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/issue5678/.hg/strip-backup/489bac576828-bef27e14-backup.hg
   $ hg unbundle -q .hg/strip-backup/*
   $ hg debugobsolete
   cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b 489bac576828490c0bb8d45eac9e5e172e4ec0a8 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '1', 'operation': 'amend', 'user': 'test'}
   $ cd ..

tests/test-update-branches.t

@@ -1,691 +1,691 b''
   $ cat >> $HGRCPATH <<EOF
   > [commands]
   > status.verbose=1
   > EOF
 
 # Construct the following history tree:
 #
 # @  5:e1bb631146ca  b1
 # |
 # o  4:a4fdb3b883c4 0:b608b9236435  b1
 # |
 # | o  3:4b57d2520816 1:44592833ba9f
 # | |
 # | | o  2:063f31070f65
 # | |/
 # | o  1:44592833ba9f
 # |/
 # o  0:b608b9236435
 
   $ mkdir b1
   $ cd b1
   $ hg init
   $ echo foo > foo
   $ echo zero > a
   $ hg init sub
   $ echo suba > sub/suba
   $ hg --cwd sub ci -Am addsuba
   adding suba
   $ echo 'sub = sub' > .hgsub
   $ hg ci -qAm0
   $ echo one > a ; hg ci -m1
   $ echo two > a ; hg ci -m2
   $ hg up -q 1
   $ echo three > a ; hg ci -qm3
   $ hg up -q 0
   $ hg branch -q b1
   $ echo four > a ; hg ci -qm4
   $ echo five > a ; hg ci -qm5
 
 Initial repo state:
 
   $ hg log -G --template '{rev}:{node|short} {parents} {branches}\n'
   @  5:ff252e8273df  b1
   |
   o  4:d047485b3896 0:60829823a42a  b1
   |
   | o  3:6efa171f091b 1:0786582aa4b1
   | |
   | | o  2:bd10386d478c
   | |/
   | o  1:0786582aa4b1
   |/
   o  0:60829823a42a
   
 
 Make sure update doesn't assume b1 is a repository if invoked from outside:
 
   $ cd ..
   $ hg update b1
   abort: no repository found in '$TESTTMP' (.hg not found)!
   [255]
   $ cd b1
 
 Test helper functions:
 
   $ revtest () {
   >     msg=$1
   >     dirtyflag=$2   # 'clean', 'dirty' or 'dirtysub'
   >     startrev=$3
   >     targetrev=$4
   >     opt=$5
   >     hg up -qC $startrev
   >     test $dirtyflag = dirty && echo dirty > foo
   >     test $dirtyflag = dirtysub && echo dirty > sub/suba
   >     hg up $opt $targetrev
   >     hg parent --template 'parent={rev}\n'
   >     hg stat -S
   > }
 
   $ norevtest () {
   >     msg=$1
   >     dirtyflag=$2   # 'clean', 'dirty' or 'dirtysub'
   >     startrev=$3
   >     opt=$4
   >     hg up -qC $startrev
   >     test $dirtyflag = dirty && echo dirty > foo
   >     test $dirtyflag = dirtysub && echo dirty > sub/suba
   >     hg up $opt
   >     hg parent --template 'parent={rev}\n'
   >     hg stat -S
   > }
 
 Test cases are documented in a table in the update function of merge.py.
 Cases are run as shown in that table, row by row.
 
   $ norevtest 'none clean linear' clean 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=5
 
   $ norevtest 'none clean same'   clean 2
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "bd10386d478c: 2"
   1 other heads for branch "default"
   parent=2
 
 
   $ revtest 'none clean linear' clean 1 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
 
   $ revtest 'none clean same'   clean 2 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=3
 
   $ revtest 'none clean cross'  clean 3 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=4
 
 
   $ revtest 'none dirty linear' dirty 1 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
   M foo
 
   $ revtest 'none dirtysub linear' dirtysub 1 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
   M sub/suba
 
   $ revtest 'none dirty same'   dirty 2 3
   abort: uncommitted changes
   (commit or update --clean to discard changes)
   parent=2
   M foo
 
   $ revtest 'none dirtysub same'   dirtysub 2 3
   abort: uncommitted changes
   (commit or update --clean to discard changes)
   parent=2
   M sub/suba
 
   $ revtest 'none dirty cross'  dirty 3 4
   abort: uncommitted changes
   (commit or update --clean to discard changes)
   parent=3
   M foo
 
   $ norevtest 'none dirty cross'  dirty 2
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "bd10386d478c: 2"
   1 other heads for branch "default"
   parent=2
   M foo
 
   $ revtest 'none dirtysub cross'  dirtysub 3 4
   abort: uncommitted changes
   (commit or update --clean to discard changes)
   parent=3
   M sub/suba
 
   $ revtest '-C dirty linear'   dirty 1 2 -C
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
 
   $ revtest '-c dirty linear'   dirty 1 2 -c
   abort: uncommitted changes
   parent=1
   M foo
 
   $ revtest '-m dirty linear'   dirty 1 2 -m
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
   M foo
 
   $ revtest '-m dirty cross'  dirty 3 4 -m
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=4
   M foo
 
   $ revtest '-c dirtysub linear'   dirtysub 1 2 -c
   abort: uncommitted changes in subrepository "sub"
   parent=1
   M sub/suba
 
   $ norevtest '-c clean same'   clean 2 -c
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "bd10386d478c: 2"
   1 other heads for branch "default"
   parent=2
 
   $ revtest '-cC dirty linear'  dirty 1 2 -cC
   abort: can only specify one of -C/--clean, -c/--check, or -m/--merge
   parent=1
   M foo
 
   $ revtest '-mc dirty linear'  dirty 1 2 -mc
   abort: can only specify one of -C/--clean, -c/--check, or -m/--merge
   parent=1
   M foo
 
   $ revtest '-mC dirty linear'  dirty 1 2 -mC
   abort: can only specify one of -C/--clean, -c/--check, or -m/--merge
   parent=1
   M foo
 
   $ echo '[commands]' >> .hg/hgrc
   $ echo 'update.check = abort' >> .hg/hgrc
 
   $ revtest 'none dirty linear' dirty 1 2
   abort: uncommitted changes
   parent=1
   M foo
 
   $ revtest 'none dirty linear' dirty 1 2 -c
   abort: uncommitted changes
   parent=1
   M foo
 
   $ revtest 'none dirty linear' dirty 1 2 -C
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
 
   $ echo 'update.check = none' >> .hg/hgrc
 
   $ revtest 'none dirty cross'  dirty 3 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=4
   M foo
 
   $ revtest 'none dirty linear' dirty 1 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
   M foo
 
   $ revtest 'none dirty linear' dirty 1 2 -c
   abort: uncommitted changes
   parent=1
   M foo
 
   $ revtest 'none dirty linear' dirty 1 2 -C
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
 
   $ hg co -qC 3
   $ echo dirty >> a
   $ hg co --tool :merge3 4
   merging a
   warning: conflicts while merging a! (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
   [1]
   $ hg log -G --template '{rev}:{node|short} {parents} {branches}\n'
   o  5:ff252e8273df  b1
   |
   @  4:d047485b3896 0:60829823a42a  b1
   |
-  | o  3:6efa171f091b 1:0786582aa4b1
+  | %  3:6efa171f091b 1:0786582aa4b1
   | |
   | | o  2:bd10386d478c
   | |/
   | o  1:0786582aa4b1
   |/
   o  0:60829823a42a
   
   $ hg st
   M a
   ? a.orig
   # Unresolved merge conflicts:
   # 
   #     a
   # 
   # To mark files as resolved:  hg resolve --mark FILE
   
   $ cat a
   <<<<<<< working copy: 6efa171f091b - test: 3
   three
   dirty
   ||||||| base
   three
   =======
   four
   >>>>>>> destination:  d047485b3896 b1 - test: 4
   $ rm a.orig
 
   $ echo 'update.check = noconflict' >> .hg/hgrc
 
   $ revtest 'none dirty cross'  dirty 3 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=4
   M foo
 
   $ revtest 'none dirty linear' dirty 1 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
   M foo
 
   $ revtest 'none dirty linear' dirty 1 2 -c
   abort: uncommitted changes
   parent=1
   M foo
 
   $ revtest 'none dirty linear' dirty 1 2 -C
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
 
 Locally added file is allowed
   $ hg up -qC 3
   $ echo a > bar
   $ hg add bar
   $ hg up -q 4
   $ hg st
   A bar
   $ hg forget bar
   $ rm bar
 
 Locally removed file is allowed
   $ hg up -qC 3
   $ hg rm foo
   $ hg up -q 4
 
 File conflict is not allowed
   $ hg up -qC 3
   $ echo dirty >> a
   $ hg up -q 4
   abort: conflicting changes
   (commit or update --clean to discard changes)
   [255]
   $ hg up -m 4
   merging a
   warning: conflicts while merging a! (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
   [1]
   $ rm a.orig
   $ hg status
   M a
   # Unresolved merge conflicts:
   # 
   #     a
   # 
   # To mark files as resolved:  hg resolve --mark FILE
   
   $ hg resolve -l
   U a
 
 Change/delete conflict is not allowed
   $ hg up -qC 3
   $ hg rm foo
   $ hg up -q 4
 
 Uses default value of "linear" when value is misspelled
   $ echo 'update.check = linyar' >> .hg/hgrc
 
   $ revtest 'dirty cross'  dirty 3 4
   abort: uncommitted changes
   (commit or update --clean to discard changes)
   parent=3
   M foo
 
 Setup for later tests
   $ revtest 'none dirty linear' dirty 1 2 -c
   abort: uncommitted changes
   parent=1
   M foo
 
   $ cd ..
 
 Test updating to null revision
 
   $ hg init null-repo
   $ cd null-repo
   $ echo a > a
   $ hg add a
   $ hg ci -m a
   $ hg up -qC 0
   $ echo b > b
   $ hg add b
   $ hg up null
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg st
   A b
   $ hg up -q 0
   $ hg st
   A b
   $ hg up -qC null
   $ hg st
   ? b
   $ cd ..
 
 Test updating with closed head
 ---------------------------------------------------------------------
 
   $ hg clone -U -q b1 closed-heads
   $ cd closed-heads
 
 Test updating if at least one non-closed branch head exists
 
 if on the closed branch head:
 - update to "."
 - "updated to a closed branch head ...." message is displayed
 - "N other heads for ...." message is displayed
 
   $ hg update -q -C 3
   $ hg commit --close-branch -m 6
   $ norevtest "on closed branch head" clean 6
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   no open descendant heads on branch "default", updating to a closed head
   (committing will reopen the head, use 'hg heads .' to see 1 other heads)
   parent=6
 
 if descendant non-closed branch head exists, and it is only one branch head:
 - update to it, even if its revision is less than closed one
 - "N other heads for ...." message isn't displayed
 
   $ norevtest "non-closed 2 should be chosen" clean 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=2
 
 if all descendant branch heads are closed, but there is another branch head:
 - update to the tipmost descendant head
 - "updated to a closed branch head ...." message is displayed
 - "N other heads for ...." message is displayed
 
   $ norevtest "all descendant branch heads are closed" clean 3
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   no open descendant heads on branch "default", updating to a closed head
   (committing will reopen the head, use 'hg heads .' to see 1 other heads)
   parent=6
 
 Test updating if all branch heads are closed
 
 if on the closed branch head:
 - update to "."
 - "updated to a closed branch head ...." message is displayed
 - "all heads of branch ...." message is displayed
 
   $ hg update -q -C 2
   $ hg commit --close-branch -m 7
   $ norevtest "all heads of branch default are closed" clean 6
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   no open descendant heads on branch "default", updating to a closed head
   (committing will reopen branch "default")
   parent=6
 
 if not on the closed branch head:
 - update to the tipmost descendant (closed) head
 - "updated to a closed branch head ...." message is displayed
 - "all heads of branch ...." message is displayed
 
   $ norevtest "all heads of branch default are closed" clean 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   no open descendant heads on branch "default", updating to a closed head
   (committing will reopen branch "default")
   parent=7
 
   $ cd ..
 
 Test updating if "default" branch doesn't exist and no revision is
 checked out (= "default" is used as current branch)
 
   $ hg init no-default-branch
   $ cd no-default-branch
 
   $ hg branch foobar
   marked working directory as branch foobar
   (branches are permanent and global, did you want a bookmark?)
   $ echo a > a
   $ hg commit -m "#0" -A
   adding a
   $ echo 1 >> a
   $ hg commit -m "#1"
   $ hg update -q 0
   $ echo 3 >> a
   $ hg commit -m "#2"
   created new head
   $ hg commit --close-branch -m "#3"
 
 if there is at least one non-closed branch head:
 - update to the tipmost branch head
 
   $ norevtest "non-closed 1 should be chosen" clean null
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   parent=1
 
 if all branch heads are closed
 - update to "tip"
 - "updated to a closed branch head ...." message is displayed
 - "all heads for branch "XXXX" are closed" message is displayed
 
   $ hg update -q -C 1
   $ hg commit --close-branch -m "#4"
 
   $ norevtest "all branches are closed" clean null
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   no open descendant heads on branch "foobar", updating to a closed head
   (committing will reopen branch "foobar")
   parent=4
 
   $ cd ../b1
 
 Test obsolescence behavior
 ---------------------------------------------------------------------
 
 successors should be taken in account when checking head destination
 
   $ cat << EOF >> $HGRCPATH
   > [ui]
   > logtemplate={rev}:{node|short} {desc|firstline}
   > [experimental]
   > evolution.createmarkers=True
   > EOF
 
 Test no-argument update to a successor of an obsoleted changeset
 
   $ hg log -G
   o  5:ff252e8273df 5
   |
   o  4:d047485b3896 4
   |
   | o  3:6efa171f091b 3
   | |
   | | o  2:bd10386d478c 2
   | |/
   | @  1:0786582aa4b1 1
   |/
   o  0:60829823a42a 0
   
   $ hg book bm -r 3
   $ hg status
   M foo
 
 We add simple obsolescence marker between 3 and 4 (indirect successors)
 
   $ hg id --debug -i -r 3
   6efa171f091b00a3c35edc15d48c52a498929953
   $ hg id --debug -i -r 4
   d047485b3896813b2a624e86201983520f003206
   $ hg debugobsolete 6efa171f091b00a3c35edc15d48c52a498929953 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
   1 new obsolescence markers
   obsoleted 1 changesets
   $ hg debugobsolete aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa d047485b3896813b2a624e86201983520f003206
   1 new obsolescence markers
 
 Test that 5 is detected as a valid destination from 3 and also accepts moving
 the bookmark (issue4015)
 
   $ hg up --quiet --hidden 3
   $ hg up 5
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg book bm
   moving bookmark 'bm' forward from 6efa171f091b
   $ hg bookmarks
    * bm                        5:ff252e8273df
 
 Test that we abort before we warn about the hidden commit if the working
 directory is dirty
   $ echo conflict > a
   $ hg up --hidden 3
   abort: uncommitted changes
   (commit or update --clean to discard changes)
   [255]
 
 Test that we still warn also when there are conflicts
   $ hg up -m --hidden 3
   merging a
   warning: conflicts while merging a! (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
   (leaving bookmark bm)
   updated to hidden changeset 6efa171f091b
   (hidden revision '6efa171f091b' was rewritten as: d047485b3896)
   [1]
 
 Test that statuses are reported properly before and after merge resolution.
   $ rm a.orig
   $ hg resolve -l
   U a
   $ hg status
   M a
   M foo
   # Unresolved merge conflicts:
   # 
   #     a
   # 
   # To mark files as resolved:  hg resolve --mark FILE
   
 
   $ hg revert -r . a
 
   $ rm a.orig
   $ hg resolve -l
   U a
   $ hg status
   M foo
   # Unresolved merge conflicts:
   # 
   #     a
   # 
   # To mark files as resolved:  hg resolve --mark FILE
   
   $ hg status -Tjson
   [
    {
     "itemtype": "file",
     "path": "foo",
     "status": "M"
    },
    {
     "itemtype": "file",
     "path": "a",
     "unresolved": true
    }
   ]
 
   $ hg resolve -m
   (no more unresolved files)
 
   $ hg resolve -l
   R a
   $ hg status
   M foo
   # No unresolved merge conflicts.
   
   $ hg status -Tjson
   [
    {
     "itemtype": "file",
     "path": "foo",
     "status": "M"
    }
   ]
 
 Test that 4 is detected as the no-argument destination from 3 and also moves
 the bookmark with it
   $ hg up --quiet 0          # we should be able to update to 3 directly
   $ hg status
   M foo
   $ hg up --quiet --hidden 3 # but not implemented yet.
   updated to hidden changeset 6efa171f091b
   (hidden revision '6efa171f091b' was rewritten as: d047485b3896)
   $ hg book -f bm
   $ hg up
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updating bookmark bm
   $ hg book
    * bm                        4:d047485b3896
 
 Test that 5 is detected as a valid destination from 1
   $ hg up --quiet 0          # we should be able to update to 3 directly
   $ hg up --quiet --hidden 3 # but not implemented yet.
   updated to hidden changeset 6efa171f091b
   (hidden revision '6efa171f091b' was rewritten as: d047485b3896)
   $ hg up 5
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Test that 5 is not detected as a valid destination from 2
   $ hg up --quiet 0
   $ hg up --quiet 2
   $ hg up 5
   abort: uncommitted changes
   (commit or update --clean to discard changes)
   [255]
 
 Test that we don't crash when updating from a pruned changeset (i.e. has no
 successors). Behavior should probably be that we update to the first
 non-obsolete parent but that will be decided later.
   $ hg id --debug -r 2
   bd10386d478cd5a9faf2e604114c8e6da62d3889
   $ hg up --quiet 0
   $ hg up --quiet 2
   $ hg debugobsolete bd10386d478cd5a9faf2e604114c8e6da62d3889
   1 new obsolescence markers
   obsoleted 1 changesets
   $ hg up
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Test experimental revset support
 
   $ hg log -r '_destupdate()'
   2:bd10386d478c 2 (no-eol)
 
 Test that boolean flags allow --no-flag specification to override [defaults]
   $ cat >> $HGRCPATH <<EOF
   > [defaults]
   > update = --check
   > EOF
   $ hg co 2
   abort: uncommitted changes
   [255]
   $ hg co --no-check 2
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved