phabricator: clarify the multiple heads/roots error message for phabsend

As pointed out in followup feedback for c1c922391314, it's confusing to say
there are multiple items and then only list one.

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

hgext/phabricator.py

@@ -1,2303 +1,2303 b''
 # phabricator.py - simple Phabricator integration
 #
 # Copyright 2017 Facebook, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 """simple Phabricator integration (EXPERIMENTAL)
 
 This extension provides a ``phabsend`` command which sends a stack of
 changesets to Phabricator, and a ``phabread`` command which prints a stack of
 revisions in a format suitable for :hg:`import`, and a ``phabupdate`` command
 to update statuses in batch.
 
 A "phabstatus" view for :hg:`show` is also provided; it displays status
 information of Phabricator differentials associated with unfinished
 changesets.
 
 By default, Phabricator requires ``Test Plan`` which might prevent some
 changeset from being sent. The requirement could be disabled by changing
 ``differential.require-test-plan-field`` config server side.
 
 Config::
 
     [phabricator]
     # Phabricator URL
     url = https://phab.example.com/
 
     # Repo callsign. If a repo has a URL https://$HOST/diffusion/FOO, then its
     # callsign is "FOO".
     callsign = FOO
 
     # curl command to use. If not set (default), use builtin HTTP library to
     # communicate. If set, use the specified curl command. This could be useful
     # if you need to specify advanced options that is not easily supported by
     # the internal library.
     curlcmd = curl --connect-timeout 2 --retry 3 --silent
 
     [auth]
     example.schemes = https
     example.prefix = phab.example.com
 
     # API token. Get it from https://$HOST/conduit/login/
     example.phabtoken = cli-xxxxxxxxxxxxxxxxxxxxxxxxxxxx
 """
 
 from __future__ import absolute_import
 
 import base64
 import contextlib
 import hashlib
 import itertools
 import json
 import mimetypes
 import operator
 import re
 
 from mercurial.node import bin, nullid, short
 from mercurial.i18n import _
 from mercurial.pycompat import getattr
 from mercurial.thirdparty import attr
 from mercurial import (
     cmdutil,
     context,
     copies,
     encoding,
     error,
     exthelper,
     graphmod,
     httpconnection as httpconnectionmod,
     localrepo,
     logcmdutil,
     match,
     mdiff,
     obsutil,
     parser,
     patch,
     phases,
     pycompat,
     scmutil,
     smartset,
     tags,
     templatefilters,
     templateutil,
     url as urlmod,
     util,
 )
 from mercurial.utils import (
     procutil,
     stringutil,
 )
 from . import show
 
 
 # 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'
 
 eh = exthelper.exthelper()
 
 cmdtable = eh.cmdtable
 command = eh.command
 configtable = eh.configtable
 templatekeyword = eh.templatekeyword
 uisetup = eh.finaluisetup
 
 # developer config: phabricator.batchsize
 eh.configitem(
     b'phabricator', b'batchsize', default=12,
 )
 eh.configitem(
     b'phabricator', b'callsign', default=None,
 )
 eh.configitem(
     b'phabricator', b'curlcmd', default=None,
 )
 # developer config: phabricator.debug
 eh.configitem(
     b'phabricator', b'debug', default=False,
 )
 # developer config: phabricator.repophid
 eh.configitem(
     b'phabricator', b'repophid', default=None,
 )
 eh.configitem(
     b'phabricator', b'url', default=None,
 )
 eh.configitem(
     b'phabsend', b'confirm', default=False,
 )
 eh.configitem(
     b'phabimport', b'secret', default=False,
 )
 eh.configitem(
     b'phabimport', b'obsolete', default=False,
 )
 
 colortable = {
     b'phabricator.action.created': b'green',
     b'phabricator.action.skipped': b'magenta',
     b'phabricator.action.updated': b'magenta',
     b'phabricator.desc': b'',
     b'phabricator.drev': b'bold',
     b'phabricator.node': b'',
     b'phabricator.status.abandoned': b'magenta dim',
     b'phabricator.status.accepted': b'green bold',
     b'phabricator.status.closed': b'green',
     b'phabricator.status.needsreview': b'yellow',
     b'phabricator.status.needsrevision': b'red',
     b'phabricator.status.changesplanned': b'red',
 }
 
 _VCR_FLAGS = [
     (
         b'',
         b'test-vcr',
         b'',
         _(
             b'Path to a vcr file. If nonexistent, will record a new vcr transcript'
             b', otherwise will mock all http requests using the specified vcr file.'
             b' (ADVANCED)'
         ),
     ),
 ]
 
 
 @eh.wrapfunction(localrepo, "loadhgrc")
 def _loadhgrc(orig, ui, wdirvfs, hgvfs, requirements):
     """Load ``.arcconfig`` content into a ui instance on repository open.
     """
     result = False
     arcconfig = {}
 
     try:
         # json.loads only accepts bytes from 3.6+
         rawparams = encoding.unifromlocal(wdirvfs.read(b".arcconfig"))
         # json.loads only returns unicode strings
         arcconfig = pycompat.rapply(
             lambda x: encoding.unitolocal(x)
             if isinstance(x, pycompat.unicode)
             else x,
             pycompat.json_loads(rawparams),
         )
 
         result = True
     except ValueError:
         ui.warn(_(b"invalid JSON in %s\n") % wdirvfs.join(b".arcconfig"))
     except IOError:
         pass
 
     cfg = util.sortdict()
 
     if b"repository.callsign" in arcconfig:
         cfg[(b"phabricator", b"callsign")] = arcconfig[b"repository.callsign"]
 
     if b"phabricator.uri" in arcconfig:
         cfg[(b"phabricator", b"url")] = arcconfig[b"phabricator.uri"]
 
     if cfg:
         ui.applyconfig(cfg, source=wdirvfs.join(b".arcconfig"))
 
     return orig(ui, wdirvfs, hgvfs, requirements) or result  # Load .hg/hgrc
 
 
 def vcrcommand(name, flags, spec, helpcategory=None, optionalrepo=False):
     fullflags = flags + _VCR_FLAGS
 
     def hgmatcher(r1, r2):
         if r1.uri != r2.uri or r1.method != r2.method:
             return False
         r1params = util.urlreq.parseqs(r1.body)
         r2params = util.urlreq.parseqs(r2.body)
         for key in r1params:
             if key not in r2params:
                 return False
             value = r1params[key][0]
             # we want to compare json payloads without worrying about ordering
             if value.startswith(b'{') and value.endswith(b'}'):
                 r1json = pycompat.json_loads(value)
                 r2json = pycompat.json_loads(r2params[key][0])
                 if r1json != r2json:
                     return False
             elif r2params[key][0] != value:
                 return False
         return True
 
     def sanitiserequest(request):
         request.body = re.sub(
             br'cli-[a-z0-9]+', br'cli-hahayouwish', request.body
         )
         return request
 
     def sanitiseresponse(response):
         if 'set-cookie' in response['headers']:
             del response['headers']['set-cookie']
         return response
 
     def decorate(fn):
         def inner(*args, **kwargs):
             if kwargs.get('test_vcr'):
                 cassette = pycompat.fsdecode(kwargs.pop('test_vcr'))
                 import hgdemandimport
 
                 with hgdemandimport.deactivated():
                     import vcr as vcrmod
                     import vcr.stubs as stubs
 
                     vcr = vcrmod.VCR(
                         serializer='json',
                         before_record_request=sanitiserequest,
                         before_record_response=sanitiseresponse,
                         custom_patches=[
                             (
                                 urlmod,
                                 'httpconnection',
                                 stubs.VCRHTTPConnection,
                             ),
                             (
                                 urlmod,
                                 'httpsconnection',
                                 stubs.VCRHTTPSConnection,
                             ),
                         ],
                     )
                     vcr.register_matcher('hgmatcher', hgmatcher)
                     with vcr.use_cassette(cassette, match_on=['hgmatcher']):
                         return fn(*args, **kwargs)
             return fn(*args, **kwargs)
 
         cmd = util.checksignature(inner, depth=2)
         cmd.__name__ = fn.__name__
         cmd.__doc__ = fn.__doc__
 
         return command(
             name,
             fullflags,
             spec,
             helpcategory=helpcategory,
             optionalrepo=optionalrepo,
         )(cmd)
 
     return decorate
 
 
 def _debug(ui, *msg, **opts):
     """write debug output for Phabricator if ``phabricator.debug`` is set
 
     Specifically, this avoids dumping Conduit and HTTP auth chatter that is
     printed with the --debug argument.
     """
     if ui.configbool(b"phabricator", b"debug"):
         flag = ui.debugflag
         try:
             ui.debugflag = True
             ui.write(*msg, **opts)
         finally:
             ui.debugflag = flag
 
 
 def urlencodenested(params):
     """like urlencode, but works with nested parameters.
 
     For example, if params is {'a': ['b', 'c'], 'd': {'e': 'f'}}, it will be
     flattened to {'a[0]': 'b', 'a[1]': 'c', 'd[e]': 'f'} and then passed to
     urlencode. Note: the encoding is consistent with PHP's http_build_query.
     """
     flatparams = util.sortdict()
 
     def process(prefix, obj):
         if isinstance(obj, bool):
             obj = {True: b'true', False: b'false'}[obj]  # Python -> PHP form
         lister = lambda l: [(b'%d' % k, v) for k, v in enumerate(l)]
         items = {list: lister, dict: lambda x: x.items()}.get(type(obj))
         if items is None:
             flatparams[prefix] = obj
         else:
             for k, v in items(obj):
                 if prefix:
                     process(b'%s[%s]' % (prefix, k), v)
                 else:
                     process(k, v)
 
     process(b'', params)
     return util.urlreq.urlencode(flatparams)
 
 
 def readurltoken(ui):
     """return conduit url, token and make sure they exist
 
     Currently read from [auth] config section. In the future, it might
     make sense to read from .arcconfig and .arcrc as well.
     """
     url = ui.config(b'phabricator', b'url')
     if not url:
         raise error.Abort(
             _(b'config %s.%s is required') % (b'phabricator', b'url')
         )
 
     res = httpconnectionmod.readauthforuri(ui, url, util.url(url).user)
     token = None
 
     if res:
         group, auth = res
 
         ui.debug(b"using auth.%s.* for authentication\n" % group)
 
         token = auth.get(b'phabtoken')
 
     if not token:
         raise error.Abort(
             _(b'Can\'t find conduit token associated to %s') % (url,)
         )
 
     return url, token
 
 
 def callconduit(ui, name, params):
     """call Conduit API, params is a dict. return json.loads result, or None"""
     host, token = readurltoken(ui)
     url, authinfo = util.url(b'/'.join([host, b'api', name])).authinfo()
     ui.debug(b'Conduit Call: %s %s\n' % (url, pycompat.byterepr(params)))
     params = params.copy()
     params[b'__conduit__'] = {
         b'token': token,
     }
     rawdata = {
         b'params': templatefilters.json(params),
         b'output': b'json',
         b'__conduit__': 1,
     }
     data = urlencodenested(rawdata)
     curlcmd = ui.config(b'phabricator', b'curlcmd')
     if curlcmd:
         sin, sout = procutil.popen2(
             b'%s -d @- %s' % (curlcmd, procutil.shellquote(url))
         )
         sin.write(data)
         sin.close()
         body = sout.read()
     else:
         urlopener = urlmod.opener(ui, authinfo)
         request = util.urlreq.request(pycompat.strurl(url), data=data)
         with contextlib.closing(urlopener.open(request)) as rsp:
             body = rsp.read()
     ui.debug(b'Conduit Response: %s\n' % body)
     parsed = pycompat.rapply(
         lambda x: encoding.unitolocal(x)
         if isinstance(x, pycompat.unicode)
         else x,
         # json.loads only accepts bytes from py3.6+
         pycompat.json_loads(encoding.unifromlocal(body)),
     )
     if parsed.get(b'error_code'):
         msg = _(b'Conduit Error (%s): %s') % (
             parsed[b'error_code'],
             parsed[b'error_info'],
         )
         raise error.Abort(msg)
     return parsed[b'result']
 
 
 @vcrcommand(b'debugcallconduit', [], _(b'METHOD'), optionalrepo=True)
 def debugcallconduit(ui, repo, name):
     """call Conduit API
 
     Call parameters are read from stdin as a JSON blob. Result will be written
     to stdout as a JSON blob.
     """
     # json.loads only accepts bytes from 3.6+
     rawparams = encoding.unifromlocal(ui.fin.read())
     # json.loads only returns unicode strings
     params = pycompat.rapply(
         lambda x: encoding.unitolocal(x)
         if isinstance(x, pycompat.unicode)
         else x,
         pycompat.json_loads(rawparams),
     )
     # json.dumps only accepts unicode strings
     result = pycompat.rapply(
         lambda x: encoding.unifromlocal(x) if isinstance(x, bytes) else x,
         callconduit(ui, name, params),
     )
     s = json.dumps(result, sort_keys=True, indent=2, separators=(u',', u': '))
     ui.write(b'%s\n' % encoding.unitolocal(s))
 
 
 def getrepophid(repo):
     """given callsign, return repository PHID or None"""
     # developer config: phabricator.repophid
     repophid = repo.ui.config(b'phabricator', b'repophid')
     if repophid:
         return repophid
     callsign = repo.ui.config(b'phabricator', b'callsign')
     if not callsign:
         return None
     query = callconduit(
         repo.ui,
         b'diffusion.repository.search',
         {b'constraints': {b'callsigns': [callsign]}},
     )
     if len(query[b'data']) == 0:
         return None
     repophid = query[b'data'][0][b'phid']
     repo.ui.setconfig(b'phabricator', b'repophid', repophid)
     return repophid
 
 
 _differentialrevisiontagre = re.compile(br'\AD([1-9][0-9]*)\Z')
 _differentialrevisiondescre = re.compile(
     br'^Differential Revision:\s*(?P<url>(?:.*)D(?P<id>[1-9][0-9]*))$', re.M
 )
 
 
 def getoldnodedrevmap(repo, nodelist):
     """find previous nodes that has been sent to Phabricator
 
     return {node: (oldnode, Differential diff, Differential Revision ID)}
     for node in nodelist with known previous sent versions, or associated
     Differential Revision IDs. ``oldnode`` and ``Differential diff`` could
     be ``None``.
 
     Examines commit messages like "Differential Revision:" to get the
     association information.
 
     If such commit message line is not found, examines all precursors and their
     tags. Tags with format like "D1234" are considered a match and the node
     with that tag, and the number after "D" (ex. 1234) will be returned.
 
     The ``old node``, if not None, is guaranteed to be the last diff of
     corresponding Differential Revision, and exist in the repo.
     """
     unfi = repo.unfiltered()
     has_node = unfi.changelog.index.has_node
 
     result = {}  # {node: (oldnode?, lastdiff?, drev)}
     # ordered for test stability when printing new -> old mapping below
     toconfirm = util.sortdict()  # {node: (force, {precnode}, drev)}
     for node in nodelist:
         ctx = unfi[node]
         # For tags like "D123", put them into "toconfirm" to verify later
         precnodes = list(obsutil.allpredecessors(unfi.obsstore, [node]))
         for n in precnodes:
             if has_node(n):
                 for tag in unfi.nodetags(n):
                     m = _differentialrevisiontagre.match(tag)
                     if m:
                         toconfirm[node] = (0, set(precnodes), int(m.group(1)))
                         break
                 else:
                     continue  # move to next predecessor
                 break  # found a tag, stop
         else:
             # Check commit message
             m = _differentialrevisiondescre.search(ctx.description())
             if m:
                 toconfirm[node] = (1, set(precnodes), int(m.group('id')))
 
     # Double check if tags are genuine by collecting all old nodes from
     # Phabricator, and expect precursors overlap with it.
     if toconfirm:
         drevs = [drev for force, precs, drev in toconfirm.values()]
         alldiffs = callconduit(
             unfi.ui, b'differential.querydiffs', {b'revisionIDs': drevs}
         )
 
         def getnodes(d, precset):
             # Ignore other nodes that were combined into the Differential
             # that aren't predecessors of the current local node.
             return [n for n in getlocalcommits(d) if n in precset]
 
         for newnode, (force, precset, drev) in toconfirm.items():
             diffs = [
                 d for d in alldiffs.values() if int(d[b'revisionID']) == drev
             ]
 
             # local predecessors known by Phabricator
             phprecset = {n for d in diffs for n in getnodes(d, precset)}
 
             # Ignore if precursors (Phabricator and local repo) do not overlap,
             # and force is not set (when commit message says nothing)
             if not force and not phprecset:
                 tagname = b'D%d' % drev
                 tags.tag(
                     repo,
                     tagname,
                     nullid,
                     message=None,
                     user=None,
                     date=None,
                     local=True,
                 )
                 unfi.ui.warn(
                     _(
                         b'D%d: local tag removed - does not match '
                         b'Differential history\n'
                     )
                     % drev
                 )
                 continue
 
             # Find the last node using Phabricator metadata, and make sure it
             # exists in the repo
             oldnode = lastdiff = None
             if diffs:
                 lastdiff = max(diffs, key=lambda d: int(d[b'id']))
                 oldnodes = getnodes(lastdiff, precset)
 
                 _debug(
                     unfi.ui,
                     b"%s mapped to old nodes %s\n"
                     % (
                         short(newnode),
                         stringutil.pprint([short(n) for n in sorted(oldnodes)]),
                     ),
                 )
 
                 # If this commit was the result of `hg fold` after submission,
                 # and now resubmitted with --fold, the easiest thing to do is
                 # to leave the node clear.  This only results in creating a new
                 # diff for the _same_ Differential Revision if this commit is
                 # the first or last in the selected range.  If we picked a node
                 # from the list instead, it would have to be the lowest if at
                 # the beginning of the --fold range, or the highest at the end.
                 # Otherwise, one or more of the nodes wouldn't be considered in
                 # the diff, and the Differential wouldn't be properly updated.
                 # If this commit is the result of `hg split` in the same
                 # scenario, there is a single oldnode here (and multiple
                 # newnodes mapped to it).  That makes it the same as the normal
                 # case, as the edges of the newnode range cleanly maps to one
                 # oldnode each.
                 if len(oldnodes) == 1:
                     oldnode = oldnodes[0]
                 if oldnode and not has_node(oldnode):
                     oldnode = None
 
             result[newnode] = (oldnode, lastdiff, drev)
 
     return result
 
 
 def getdrevmap(repo, revs):
     """Return a dict mapping each rev in `revs` to their Differential Revision
     ID or None.
     """
     result = {}
     for rev in revs:
         result[rev] = None
         ctx = repo[rev]
         # Check commit message
         m = _differentialrevisiondescre.search(ctx.description())
         if m:
             result[rev] = int(m.group('id'))
             continue
         # Check tags
         for tag in repo.nodetags(ctx.node()):
             m = _differentialrevisiontagre.match(tag)
             if m:
                 result[rev] = int(m.group(1))
                 break
 
     return result
 
 
 def getdiff(basectx, ctx, diffopts):
     """plain-text diff without header (user, commit message, etc)"""
     output = util.stringio()
     for chunk, _label in patch.diffui(
         ctx.repo(), basectx.p1().node(), ctx.node(), None, opts=diffopts
     ):
         output.write(chunk)
     return output.getvalue()
 
 
 class DiffChangeType(object):
     ADD = 1
     CHANGE = 2
     DELETE = 3
     MOVE_AWAY = 4
     COPY_AWAY = 5
     MOVE_HERE = 6
     COPY_HERE = 7
     MULTICOPY = 8
 
 
 class DiffFileType(object):
     TEXT = 1
     IMAGE = 2
     BINARY = 3
 
 
 @attr.s
 class phabhunk(dict):
     """Represents a Differential hunk, which is owned by a Differential change
     """
 
     oldOffset = attr.ib(default=0)  # camelcase-required
     oldLength = attr.ib(default=0)  # camelcase-required
     newOffset = attr.ib(default=0)  # camelcase-required
     newLength = attr.ib(default=0)  # camelcase-required
     corpus = attr.ib(default='')
     # These get added to the phabchange's equivalents
     addLines = attr.ib(default=0)  # camelcase-required
     delLines = attr.ib(default=0)  # camelcase-required
 
 
 @attr.s
 class phabchange(object):
     """Represents a Differential change, owns Differential hunks and owned by a
     Differential diff.  Each one represents one file in a diff.
     """
 
     currentPath = attr.ib(default=None)  # camelcase-required
     oldPath = attr.ib(default=None)  # camelcase-required
     awayPaths = attr.ib(default=attr.Factory(list))  # camelcase-required
     metadata = attr.ib(default=attr.Factory(dict))
     oldProperties = attr.ib(default=attr.Factory(dict))  # camelcase-required
     newProperties = attr.ib(default=attr.Factory(dict))  # camelcase-required
     type = attr.ib(default=DiffChangeType.CHANGE)
     fileType = attr.ib(default=DiffFileType.TEXT)  # camelcase-required
     commitHash = attr.ib(default=None)  # camelcase-required
     addLines = attr.ib(default=0)  # camelcase-required
     delLines = attr.ib(default=0)  # camelcase-required
     hunks = attr.ib(default=attr.Factory(list))
 
     def copynewmetadatatoold(self):
         for key in list(self.metadata.keys()):
             newkey = key.replace(b'new:', b'old:')
             self.metadata[newkey] = self.metadata[key]
 
     def addoldmode(self, value):
         self.oldProperties[b'unix:filemode'] = value
 
     def addnewmode(self, value):
         self.newProperties[b'unix:filemode'] = value
 
     def addhunk(self, hunk):
         if not isinstance(hunk, phabhunk):
             raise error.Abort(b'phabchange.addhunk only takes phabhunks')
         self.hunks.append(pycompat.byteskwargs(attr.asdict(hunk)))
         # It's useful to include these stats since the Phab web UI shows them,
         # and uses them to estimate how large a change a Revision is. Also used
         # in email subjects for the [+++--] bit.
         self.addLines += hunk.addLines
         self.delLines += hunk.delLines
 
 
 @attr.s
 class phabdiff(object):
     """Represents a Differential diff, owns Differential changes.  Corresponds
     to a commit.
     """
 
     # Doesn't seem to be any reason to send this (output of uname -n)
     sourceMachine = attr.ib(default=b'')  # camelcase-required
     sourcePath = attr.ib(default=b'/')  # camelcase-required
     sourceControlBaseRevision = attr.ib(default=b'0' * 40)  # camelcase-required
     sourceControlPath = attr.ib(default=b'/')  # camelcase-required
     sourceControlSystem = attr.ib(default=b'hg')  # camelcase-required
     branch = attr.ib(default=b'default')
     bookmark = attr.ib(default=None)
     creationMethod = attr.ib(default=b'phabsend')  # camelcase-required
     lintStatus = attr.ib(default=b'none')  # camelcase-required
     unitStatus = attr.ib(default=b'none')  # camelcase-required
     changes = attr.ib(default=attr.Factory(dict))
     repositoryPHID = attr.ib(default=None)  # camelcase-required
 
     def addchange(self, change):
         if not isinstance(change, phabchange):
             raise error.Abort(b'phabdiff.addchange only takes phabchanges')
         self.changes[change.currentPath] = pycompat.byteskwargs(
             attr.asdict(change)
         )
 
 
 def maketext(pchange, basectx, ctx, fname):
     """populate the phabchange for a text file"""
     repo = ctx.repo()
     fmatcher = match.exact([fname])
     diffopts = mdiff.diffopts(git=True, context=32767)
     _pfctx, _fctx, header, fhunks = next(
         patch.diffhunks(repo, basectx.p1(), ctx, fmatcher, opts=diffopts)
     )
 
     for fhunk in fhunks:
         (oldOffset, oldLength, newOffset, newLength), lines = fhunk
         corpus = b''.join(lines[1:])
         shunk = list(header)
         shunk.extend(lines)
         _mf, _mt, addLines, delLines, _hb = patch.diffstatsum(
             patch.diffstatdata(util.iterlines(shunk))
         )
         pchange.addhunk(
             phabhunk(
                 oldOffset,
                 oldLength,
                 newOffset,
                 newLength,
                 corpus,
                 addLines,
                 delLines,
             )
         )
 
 
 def uploadchunks(fctx, fphid):
     """upload large binary files as separate chunks.
     Phab requests chunking over 8MiB, and splits into 4MiB chunks
     """
     ui = fctx.repo().ui
     chunks = callconduit(ui, b'file.querychunks', {b'filePHID': fphid})
     with ui.makeprogress(
         _(b'uploading file chunks'), unit=_(b'chunks'), total=len(chunks)
     ) as progress:
         for chunk in chunks:
             progress.increment()
             if chunk[b'complete']:
                 continue
             bstart = int(chunk[b'byteStart'])
             bend = int(chunk[b'byteEnd'])
             callconduit(
                 ui,
                 b'file.uploadchunk',
                 {
                     b'filePHID': fphid,
                     b'byteStart': bstart,
                     b'data': base64.b64encode(fctx.data()[bstart:bend]),
                     b'dataEncoding': b'base64',
                 },
             )
 
 
 def uploadfile(fctx):
     """upload binary files to Phabricator"""
     repo = fctx.repo()
     ui = repo.ui
     fname = fctx.path()
     size = fctx.size()
     fhash = pycompat.bytestr(hashlib.sha256(fctx.data()).hexdigest())
 
     # an allocate call is required first to see if an upload is even required
     # (Phab might already have it) and to determine if chunking is needed
     allocateparams = {
         b'name': fname,
         b'contentLength': size,
         b'contentHash': fhash,
     }
     filealloc = callconduit(ui, b'file.allocate', allocateparams)
     fphid = filealloc[b'filePHID']
 
     if filealloc[b'upload']:
         ui.write(_(b'uploading %s\n') % bytes(fctx))
         if not fphid:
             uploadparams = {
                 b'name': fname,
                 b'data_base64': base64.b64encode(fctx.data()),
             }
             fphid = callconduit(ui, b'file.upload', uploadparams)
         else:
             uploadchunks(fctx, fphid)
     else:
         ui.debug(b'server already has %s\n' % bytes(fctx))
 
     if not fphid:
         raise error.Abort(b'Upload of %s failed.' % bytes(fctx))
 
     return fphid
 
 
 def addoldbinary(pchange, oldfctx, fctx):
     """add the metadata for the previous version of a binary file to the
     phabchange for the new version
 
     ``oldfctx`` is the previous version of the file; ``fctx`` is the new
     version of the file, or None if the file is being removed.
     """
     if not fctx or fctx.cmp(oldfctx):
         # Files differ, add the old one
         pchange.metadata[b'old:file:size'] = oldfctx.size()
         mimeguess, _enc = mimetypes.guess_type(
             encoding.unifromlocal(oldfctx.path())
         )
         if mimeguess:
             pchange.metadata[b'old:file:mime-type'] = pycompat.bytestr(
                 mimeguess
             )
         fphid = uploadfile(oldfctx)
         pchange.metadata[b'old:binary-phid'] = fphid
     else:
         # If it's left as IMAGE/BINARY web UI might try to display it
         pchange.fileType = DiffFileType.TEXT
         pchange.copynewmetadatatoold()
 
 
 def makebinary(pchange, fctx):
     """populate the phabchange for a binary file"""
     pchange.fileType = DiffFileType.BINARY
     fphid = uploadfile(fctx)
     pchange.metadata[b'new:binary-phid'] = fphid
     pchange.metadata[b'new:file:size'] = fctx.size()
     mimeguess, _enc = mimetypes.guess_type(encoding.unifromlocal(fctx.path()))
     if mimeguess:
         mimeguess = pycompat.bytestr(mimeguess)
         pchange.metadata[b'new:file:mime-type'] = mimeguess
         if mimeguess.startswith(b'image/'):
             pchange.fileType = DiffFileType.IMAGE
 
 
 # Copied from mercurial/patch.py
 gitmode = {b'l': b'120000', b'x': b'100755', b'': b'100644'}
 
 
 def notutf8(fctx):
     """detect non-UTF-8 text files since Phabricator requires them to be marked
     as binary
     """
     try:
         fctx.data().decode('utf-8')
         return False
     except UnicodeDecodeError:
         fctx.repo().ui.write(
             _(b'file %s detected as non-UTF-8, marked as binary\n')
             % fctx.path()
         )
         return True
 
 
 def addremoved(pdiff, basectx, ctx, removed):
     """add removed files to the phabdiff. Shouldn't include moves"""
     for fname in removed:
         pchange = phabchange(
             currentPath=fname, oldPath=fname, type=DiffChangeType.DELETE
         )
         oldfctx = basectx.p1()[fname]
         pchange.addoldmode(gitmode[oldfctx.flags()])
         if not (oldfctx.isbinary() or notutf8(oldfctx)):
             maketext(pchange, basectx, ctx, fname)
 
         pdiff.addchange(pchange)
 
 
 def addmodified(pdiff, basectx, ctx, modified):
     """add modified files to the phabdiff"""
     for fname in modified:
         fctx = ctx[fname]
         oldfctx = basectx.p1()[fname]
         pchange = phabchange(currentPath=fname, oldPath=fname)
         filemode = gitmode[fctx.flags()]
         originalmode = gitmode[oldfctx.flags()]
         if filemode != originalmode:
             pchange.addoldmode(originalmode)
             pchange.addnewmode(filemode)
 
         if (
             fctx.isbinary()
             or notutf8(fctx)
             or oldfctx.isbinary()
             or notutf8(oldfctx)
         ):
             makebinary(pchange, fctx)
             addoldbinary(pchange, oldfctx, fctx)
         else:
             maketext(pchange, basectx, ctx, fname)
 
         pdiff.addchange(pchange)
 
 
 def addadded(pdiff, basectx, ctx, added, removed):
     """add file adds to the phabdiff, both new files and copies/moves"""
     # Keep track of files that've been recorded as moved/copied, so if there are
     # additional copies we can mark them (moves get removed from removed)
     copiedchanges = {}
     movedchanges = {}
 
     copy = {}
     if basectx != ctx:
         copy = copies.pathcopies(basectx.p1(), ctx)
 
     for fname in added:
         fctx = ctx[fname]
         oldfctx = None
         pchange = phabchange(currentPath=fname)
 
         filemode = gitmode[fctx.flags()]
 
         if copy:
             originalfname = copy.get(fname, fname)
         else:
             originalfname = fname
             if fctx.renamed():
                 originalfname = fctx.renamed()[0]
 
         renamed = fname != originalfname
 
         if renamed:
             oldfctx = basectx.p1()[originalfname]
             originalmode = gitmode[oldfctx.flags()]
             pchange.oldPath = originalfname
 
             if originalfname in removed:
                 origpchange = phabchange(
                     currentPath=originalfname,
                     oldPath=originalfname,
                     type=DiffChangeType.MOVE_AWAY,
                     awayPaths=[fname],
                 )
                 movedchanges[originalfname] = origpchange
                 removed.remove(originalfname)
                 pchange.type = DiffChangeType.MOVE_HERE
             elif originalfname in movedchanges:
                 movedchanges[originalfname].type = DiffChangeType.MULTICOPY
                 movedchanges[originalfname].awayPaths.append(fname)
                 pchange.type = DiffChangeType.COPY_HERE
             else:  # pure copy
                 if originalfname not in copiedchanges:
                     origpchange = phabchange(
                         currentPath=originalfname, type=DiffChangeType.COPY_AWAY
                     )
                     copiedchanges[originalfname] = origpchange
                 else:
                     origpchange = copiedchanges[originalfname]
                 origpchange.awayPaths.append(fname)
                 pchange.type = DiffChangeType.COPY_HERE
 
             if filemode != originalmode:
                 pchange.addoldmode(originalmode)
                 pchange.addnewmode(filemode)
         else:  # Brand-new file
             pchange.addnewmode(gitmode[fctx.flags()])
             pchange.type = DiffChangeType.ADD
 
         if (
             fctx.isbinary()
             or notutf8(fctx)
             or (oldfctx and (oldfctx.isbinary() or notutf8(oldfctx)))
         ):
             makebinary(pchange, fctx)
             if renamed:
                 addoldbinary(pchange, oldfctx, fctx)
         else:
             maketext(pchange, basectx, ctx, fname)
 
         pdiff.addchange(pchange)
 
     for _path, copiedchange in copiedchanges.items():
         pdiff.addchange(copiedchange)
     for _path, movedchange in movedchanges.items():
         pdiff.addchange(movedchange)
 
 
 def creatediff(basectx, ctx):
     """create a Differential Diff"""
     repo = ctx.repo()
     repophid = getrepophid(repo)
     # Create a "Differential Diff" via "differential.creatediff" API
     pdiff = phabdiff(
         sourceControlBaseRevision=b'%s' % basectx.p1().hex(),
         branch=b'%s' % ctx.branch(),
     )
     modified, added, removed, _d, _u, _i, _c = basectx.p1().status(ctx)
     # addadded will remove moved files from removed, so addremoved won't get
     # them
     addadded(pdiff, basectx, ctx, added, removed)
     addmodified(pdiff, basectx, ctx, modified)
     addremoved(pdiff, basectx, ctx, removed)
     if repophid:
         pdiff.repositoryPHID = repophid
     diff = callconduit(
         repo.ui,
         b'differential.creatediff',
         pycompat.byteskwargs(attr.asdict(pdiff)),
     )
     if not diff:
         if basectx != ctx:
             msg = _(b'cannot create diff for %s::%s') % (basectx, ctx)
         else:
             msg = _(b'cannot create diff for %s') % ctx
         raise error.Abort(msg)
     return diff
 
 
 def writediffproperties(ctxs, diff):
     """write metadata to diff so patches could be applied losslessly
 
     ``ctxs`` is the list of commits that created the diff, in ascending order.
     The list is generally a single commit, but may be several when using
     ``phabsend --fold``.
     """
     # creatediff returns with a diffid but query returns with an id
     diffid = diff.get(b'diffid', diff.get(b'id'))
     basectx = ctxs[0]
     tipctx = ctxs[-1]
 
     params = {
         b'diff_id': diffid,
         b'name': b'hg:meta',
         b'data': templatefilters.json(
             {
                 b'user': tipctx.user(),
                 b'date': b'%d %d' % tipctx.date(),
                 b'branch': tipctx.branch(),
                 b'node': tipctx.hex(),
                 b'parent': basectx.p1().hex(),
             }
         ),
     }
     callconduit(basectx.repo().ui, b'differential.setdiffproperty', params)
 
     commits = {}
     for ctx in ctxs:
         commits[ctx.hex()] = {
             b'author': stringutil.person(ctx.user()),
             b'authorEmail': stringutil.email(ctx.user()),
             b'time': int(ctx.date()[0]),
             b'commit': ctx.hex(),
             b'parents': [ctx.p1().hex()],
             b'branch': ctx.branch(),
         }
     params = {
         b'diff_id': diffid,
         b'name': b'local:commits',
         b'data': templatefilters.json(commits),
     }
     callconduit(basectx.repo().ui, b'differential.setdiffproperty', params)
 
 
 def createdifferentialrevision(
     ctxs,
     revid=None,
     parentrevphid=None,
     oldbasenode=None,
     oldnode=None,
     olddiff=None,
     actions=None,
     comment=None,
 ):
     """create or update a Differential Revision
 
     If revid is None, create a new Differential Revision, otherwise update
     revid. If parentrevphid is not None, set it as a dependency.
 
     If there is a single commit for the new Differential Revision, ``ctxs`` will
     be a list of that single context.  Otherwise, it is a list that covers the
     range of changes for the differential, where ``ctxs[0]`` is the first change
     to include and ``ctxs[-1]`` is the last.
 
     If oldnode is not None, check if the patch content (without commit message
     and metadata) has changed before creating another diff.  For a Revision with
     a single commit, ``oldbasenode`` and ``oldnode`` have the same value.  For a
     Revision covering multiple commits, ``oldbasenode`` corresponds to
     ``ctxs[0]`` the previous time this Revision was posted, and ``oldnode``
     corresponds to ``ctxs[-1]``.
 
     If actions is not None, they will be appended to the transaction.
     """
     ctx = ctxs[-1]
     basectx = ctxs[0]
 
     repo = ctx.repo()
     if oldnode:
         diffopts = mdiff.diffopts(git=True, context=32767)
         unfi = repo.unfiltered()
         oldctx = unfi[oldnode]
         oldbasectx = unfi[oldbasenode]
         neednewdiff = getdiff(basectx, ctx, diffopts) != getdiff(
             oldbasectx, oldctx, diffopts
         )
     else:
         neednewdiff = True
 
     transactions = []
     if neednewdiff:
         diff = creatediff(basectx, ctx)
         transactions.append({b'type': b'update', b'value': diff[b'phid']})
         if comment:
             transactions.append({b'type': b'comment', b'value': comment})
     else:
         # Even if we don't need to upload a new diff because the patch content
         # does not change. We might still need to update its metadata so
         # pushers could know the correct node metadata.
         assert olddiff
         diff = olddiff
     writediffproperties(ctxs, diff)
 
     # Set the parent Revision every time, so commit re-ordering is picked-up
     if parentrevphid:
         transactions.append(
             {b'type': b'parents.set', b'value': [parentrevphid]}
         )
 
     if actions:
         transactions += actions
 
     # When folding multiple local commits into a single review, arcanist will
     # take the summary line of the first commit as the title, and then
     # concatenate the rest of the remaining messages (including each of their
     # first lines) to the rest of the first commit message (each separated by
     # an empty line), and use that as the summary field.  Do the same here.
     # For commits with only a one line message, there is no summary field, as
     # this gets assigned to the title.
     fields = util.sortdict()  # sorted for stable wire protocol in tests
 
     for i, _ctx in enumerate(ctxs):
         # Parse commit message and update related fields.
         desc = _ctx.description()
         info = callconduit(
             repo.ui, b'differential.parsecommitmessage', {b'corpus': desc}
         )
 
         for k in [b'title', b'summary', b'testPlan']:
             v = info[b'fields'].get(k)
             if not v:
                 continue
 
             if i == 0:
                 # Title, summary and test plan (if present) are taken verbatim
                 # for the first commit.
                 fields[k] = v.rstrip()
                 continue
             elif k == b'title':
                 # Add subsequent titles (i.e. the first line of the commit
                 # message) back to the summary.
                 k = b'summary'
 
             # Append any current field to the existing composite field
             fields[k] = b'\n\n'.join(filter(None, [fields.get(k), v.rstrip()]))
 
     for k, v in fields.items():
         transactions.append({b'type': k, b'value': v})
 
     params = {b'transactions': transactions}
     if revid is not None:
         # Update an existing Differential Revision
         params[b'objectIdentifier'] = revid
 
     revision = callconduit(repo.ui, b'differential.revision.edit', params)
     if not revision:
         if len(ctxs) == 1:
             msg = _(b'cannot create revision for %s') % ctx
         else:
             msg = _(b'cannot create revision for %s::%s') % (basectx, ctx)
         raise error.Abort(msg)
 
     return revision, diff
 
 
 def userphids(ui, names):
     """convert user names to PHIDs"""
     names = [name.lower() for name in names]
     query = {b'constraints': {b'usernames': names}}
     result = callconduit(ui, b'user.search', query)
     # username not found is not an error of the API. So check if we have missed
     # some names here.
     data = result[b'data']
     resolved = {entry[b'fields'][b'username'].lower() for entry in data}
     unresolved = set(names) - resolved
     if unresolved:
         raise error.Abort(
             _(b'unknown username: %s') % b' '.join(sorted(unresolved))
         )
     return [entry[b'phid'] for entry in data]
 
 
 def _print_phabsend_action(ui, ctx, newrevid, action):
     """print the ``action`` that occurred when posting ``ctx`` for review
 
     This is a utility function for the sending phase of ``phabsend``, which
     makes it easier to show a status for all local commits with `--fold``.
     """
     actiondesc = ui.label(
         {
             b'created': _(b'created'),
             b'skipped': _(b'skipped'),
             b'updated': _(b'updated'),
         }[action],
         b'phabricator.action.%s' % action,
     )
     drevdesc = ui.label(b'D%d' % newrevid, b'phabricator.drev')
     nodedesc = ui.label(bytes(ctx), b'phabricator.node')
     desc = ui.label(ctx.description().split(b'\n')[0], b'phabricator.desc')
     ui.write(_(b'%s - %s - %s: %s\n') % (drevdesc, actiondesc, nodedesc, desc))
 
 
 def _amend_diff_properties(unfi, drevid, newnodes, diff):
     """update the local commit list for the ``diff`` associated with ``drevid``
 
     This is a utility function for the amend phase of ``phabsend``, which
     converts failures to warning messages.
     """
     _debug(
         unfi.ui,
         b"new commits: %s\n" % stringutil.pprint([short(n) for n in newnodes]),
     )
 
     try:
         writediffproperties([unfi[newnode] for newnode in newnodes], diff)
     except util.urlerr.urlerror:
         # If it fails just warn and keep going, otherwise the DREV
         # associations will be lost
         unfi.ui.warnnoi18n(b'Failed to update metadata for D%d\n' % drevid)
 
 
 @vcrcommand(
     b'phabsend',
     [
         (b'r', b'rev', [], _(b'revisions to send'), _(b'REV')),
         (b'', b'amend', True, _(b'update commit messages')),
         (b'', b'reviewer', [], _(b'specify reviewers')),
         (b'', b'blocker', [], _(b'specify blocking reviewers')),
         (
             b'm',
             b'comment',
             b'',
             _(b'add a comment to Revisions with new/updated Diffs'),
         ),
         (b'', b'confirm', None, _(b'ask for confirmation before sending')),
         (b'', b'fold', False, _(b'combine the revisions into one review')),
     ],
     _(b'REV [OPTIONS]'),
     helpcategory=command.CATEGORY_IMPORT_EXPORT,
 )
 def phabsend(ui, repo, *revs, **opts):
     """upload changesets to Phabricator
 
     If there are multiple revisions specified, they will be send as a stack
     with a linear dependencies relationship using the order specified by the
     revset.
 
     For the first time uploading changesets, local tags will be created to
     maintain the association. After the first time, phabsend will check
     obsstore and tags information so it can figure out whether to update an
     existing Differential Revision, or create a new one.
 
     If --amend is set, update commit messages so they have the
     ``Differential Revision`` URL, remove related tags. This is similar to what
     arcanist will do, and is more desired in author-push workflows. Otherwise,
     use local tags to record the ``Differential Revision`` association.
 
     The --confirm option lets you confirm changesets before sending them. You
     can also add following to your configuration file to make it default
     behaviour::
 
         [phabsend]
         confirm = true
 
     By default, a separate review will be created for each commit that is
     selected, and will have the same parent/child relationship in Phabricator.
     If ``--fold`` is set, multiple commits are rolled up into a single review
     as if diffed from the parent of the first revision to the last.  The commit
     messages are concatenated in the summary field on Phabricator.
 
     phabsend will check obsstore and the above association to decide whether to
     update an existing Differential Revision, or create a new one.
     """
     opts = pycompat.byteskwargs(opts)
     revs = list(revs) + opts.get(b'rev', [])
     revs = scmutil.revrange(repo, revs)
     revs.sort()  # ascending order to preserve topological parent/child in phab
 
     if not revs:
         raise error.Abort(_(b'phabsend requires at least one changeset'))
     if opts.get(b'amend'):
         cmdutil.checkunfinished(repo)
 
     ctxs = [repo[rev] for rev in revs]
 
     if any(c for c in ctxs if c.obsolete()):
         raise error.Abort(_(b"obsolete commits cannot be posted for review"))
 
     # Ensure the local commits are an unbroken range.  The semantics of the
     # --fold option implies this, and the auto restacking of orphans requires
     # it.  Otherwise A+C in A->B->C will cause B to be orphaned, and C' to
     # get A' as a parent.
-    def _fail_nonlinear_revs(revs, skiprev, revtype):
-        badnodes = [repo[r].node() for r in revs if r != skiprev]
+    def _fail_nonlinear_revs(revs, revtype):
+        badnodes = [repo[r].node() for r in revs]
         raise error.Abort(
             _(b"cannot phabsend multiple %s revisions: %s")
             % (revtype, scmutil.nodesummaries(repo, badnodes)),
             hint=_(b"the revisions must form a linear chain"),
         )
 
     heads = repo.revs(b'heads(%ld)', revs)
     if len(heads) > 1:
-        _fail_nonlinear_revs(heads, heads.max(), b"head")
+        _fail_nonlinear_revs(heads, b"head")
 
     roots = repo.revs(b'roots(%ld)', revs)
     if len(roots) > 1:
-        _fail_nonlinear_revs(roots, roots.min(), b"root")
+        _fail_nonlinear_revs(roots, b"root")
 
     fold = opts.get(b'fold')
     if fold:
         if len(revs) == 1:
             # TODO: just switch to --no-fold instead?
             raise error.Abort(_(b"cannot fold a single revision"))
 
         # There's no clear way to manage multiple commits with a Dxxx tag, so
         # require the amend option.  (We could append "_nnn", but then it
         # becomes jumbled if earlier commits are added to an update.)  It should
         # lock the repo and ensure that the range is editable, but that would
         # make the code pretty convoluted.  The default behavior of `arc` is to
         # create a new review anyway.
         if not opts.get(b"amend"):
             raise error.Abort(_(b"cannot fold with --no-amend"))
 
         # It might be possible to bucketize the revisions by the DREV value, and
         # iterate over those groups when posting, and then again when amending.
         # But for simplicity, require all selected revisions to be for the same
         # DREV (if present).  Adding local revisions to an existing DREV is
         # acceptable.
         drevmatchers = [
             _differentialrevisiondescre.search(ctx.description())
             for ctx in ctxs
         ]
         if len({m.group('url') for m in drevmatchers if m}) > 1:
             raise error.Abort(
                 _(b"cannot fold revisions with different DREV values")
             )
 
     # {newnode: (oldnode, olddiff, olddrev}
     oldmap = getoldnodedrevmap(repo, [repo[r].node() for r in revs])
 
     confirm = ui.configbool(b'phabsend', b'confirm')
     confirm |= bool(opts.get(b'confirm'))
     if confirm:
         confirmed = _confirmbeforesend(repo, revs, oldmap)
         if not confirmed:
             raise error.Abort(_(b'phabsend cancelled'))
 
     actions = []
     reviewers = opts.get(b'reviewer', [])
     blockers = opts.get(b'blocker', [])
     phids = []
     if reviewers:
         phids.extend(userphids(repo.ui, reviewers))
     if blockers:
         phids.extend(
             map(
                 lambda phid: b'blocking(%s)' % phid,
                 userphids(repo.ui, blockers),
             )
         )
     if phids:
         actions.append({b'type': b'reviewers.add', b'value': phids})
 
     drevids = []  # [int]
     diffmap = {}  # {newnode: diff}
 
     # Send patches one by one so we know their Differential Revision PHIDs and
     # can provide dependency relationship
     lastrevphid = None
     for ctx in ctxs:
         if fold:
             ui.debug(b'sending rev %d::%d\n' % (ctx.rev(), ctxs[-1].rev()))
         else:
             ui.debug(b'sending rev %d\n' % ctx.rev())
 
         # Get Differential Revision ID
         oldnode, olddiff, revid = oldmap.get(ctx.node(), (None, None, None))
         oldbasenode, oldbasediff, oldbaserevid = oldnode, olddiff, revid
 
         if fold:
             oldbasenode, oldbasediff, oldbaserevid = oldmap.get(
                 ctxs[-1].node(), (None, None, None)
             )
 
         if oldnode != ctx.node() or opts.get(b'amend'):
             # Create or update Differential Revision
             revision, diff = createdifferentialrevision(
                 ctxs if fold else [ctx],
                 revid,
                 lastrevphid,
                 oldbasenode,
                 oldnode,
                 olddiff,
                 actions,
                 opts.get(b'comment'),
             )
 
             if fold:
                 for ctx in ctxs:
                     diffmap[ctx.node()] = diff
             else:
                 diffmap[ctx.node()] = diff
 
             newrevid = int(revision[b'object'][b'id'])
             newrevphid = revision[b'object'][b'phid']
             if revid:
                 action = b'updated'
             else:
                 action = b'created'
 
             # Create a local tag to note the association, if commit message
             # does not have it already
             if not fold:
                 m = _differentialrevisiondescre.search(ctx.description())
                 if not m or int(m.group('id')) != newrevid:
                     tagname = b'D%d' % newrevid
                     tags.tag(
                         repo,
                         tagname,
                         ctx.node(),
                         message=None,
                         user=None,
                         date=None,
                         local=True,
                     )
         else:
             # Nothing changed. But still set "newrevphid" so the next revision
             # could depend on this one and "newrevid" for the summary line.
             newrevphid = querydrev(repo.ui, b'%d' % revid)[0][b'phid']
             newrevid = revid
             action = b'skipped'
 
         drevids.append(newrevid)
         lastrevphid = newrevphid
 
         if fold:
             for c in ctxs:
                 if oldmap.get(c.node(), (None, None, None))[2]:
                     action = b'updated'
                 else:
                     action = b'created'
                 _print_phabsend_action(ui, c, newrevid, action)
             break
 
         _print_phabsend_action(ui, ctx, newrevid, action)
 
     # Update commit messages and remove tags
     if opts.get(b'amend'):
         unfi = repo.unfiltered()
         drevs = callconduit(ui, b'differential.query', {b'ids': drevids})
         with repo.wlock(), repo.lock(), repo.transaction(b'phabsend'):
             # Eagerly evaluate commits to restabilize before creating new
             # commits.  The selected revisions are excluded because they are
             # automatically restacked as part of the submission process.
             restack = [
                 c
                 for c in repo.set(
                     b"(%ld::) - (%ld) - unstable() - obsolete() - public()",
                     revs,
                     revs,
                 )
             ]
             wnode = unfi[b'.'].node()
             mapping = {}  # {oldnode: [newnode]}
             newnodes = []
 
             drevid = drevids[0]
 
             for i, rev in enumerate(revs):
                 old = unfi[rev]
                 if not fold:
                     drevid = drevids[i]
                 drev = [d for d in drevs if int(d[b'id']) == drevid][0]
 
                 newdesc = get_amended_desc(drev, old, fold)
                 # Make sure commit message contain "Differential Revision"
                 if (
                     old.description() != newdesc
                     or old.p1().node() in mapping
                     or old.p2().node() in mapping
                 ):
                     if old.phase() == phases.public:
                         ui.warn(
                             _(b"warning: not updating public commit %s\n")
                             % scmutil.formatchangeid(old)
                         )
                         continue
                     parents = [
                         mapping.get(old.p1().node(), (old.p1(),))[0],
                         mapping.get(old.p2().node(), (old.p2(),))[0],
                     ]
                     new = context.metadataonlyctx(
                         repo,
                         old,
                         parents=parents,
                         text=newdesc,
                         user=old.user(),
                         date=old.date(),
                         extra=old.extra(),
                     )
 
                     newnode = new.commit()
 
                     mapping[old.node()] = [newnode]
 
                     if fold:
                         # Defer updating the (single) Diff until all nodes are
                         # collected.  No tags were created, so none need to be
                         # removed.
                         newnodes.append(newnode)
                         continue
 
                     _amend_diff_properties(
                         unfi, drevid, [newnode], diffmap[old.node()]
                     )
 
                     # Remove local tags since it's no longer necessary
                     tagname = b'D%d' % drevid
                     if tagname in repo.tags():
                         tags.tag(
                             repo,
                             tagname,
                             nullid,
                             message=None,
                             user=None,
                             date=None,
                             local=True,
                         )
                 elif fold:
                     # When folding multiple commits into one review with
                     # --fold, track even the commits that weren't amended, so
                     # that their association isn't lost if the properties are
                     # rewritten below.
                     newnodes.append(old.node())
 
             # If the submitted commits are public, no amend takes place so
             # there are no newnodes and therefore no diff update to do.
             if fold and newnodes:
                 diff = diffmap[old.node()]
 
                 # The diff object in diffmap doesn't have the local commits
                 # because that could be returned from differential.creatediff,
                 # not differential.querydiffs.  So use the queried diff (if
                 # present), or force the amend (a new revision is being posted.)
                 if not olddiff or set(newnodes) != getlocalcommits(olddiff):
                     _debug(ui, b"updating local commit list for D%d\n" % drevid)
                     _amend_diff_properties(unfi, drevid, newnodes, diff)
                 else:
                     _debug(
                         ui,
                         b"local commit list for D%d is already up-to-date\n"
                         % drevid,
                     )
             elif fold:
                 _debug(ui, b"no newnodes to update\n")
 
             # Restack any children of first-time submissions that were orphaned
             # in the process.  The ctx won't report that it is an orphan until
             # the cleanup takes place below.
             for old in restack:
                 parents = [
                     mapping.get(old.p1().node(), (old.p1(),))[0],
                     mapping.get(old.p2().node(), (old.p2(),))[0],
                 ]
                 new = context.metadataonlyctx(
                     repo,
                     old,
                     parents=parents,
                     text=old.description(),
                     user=old.user(),
                     date=old.date(),
                     extra=old.extra(),
                 )
 
                 newnode = new.commit()
 
                 # Don't obsolete unselected descendants of nodes that have not
                 # been changed in this transaction- that results in an error.
                 if newnode != old.node():
                     mapping[old.node()] = [newnode]
                     _debug(
                         ui,
                         b"restabilizing %s as %s\n"
                         % (short(old.node()), short(newnode)),
                     )
                 else:
                     _debug(
                         ui,
                         b"not restabilizing unchanged %s\n" % short(old.node()),
                     )
 
             scmutil.cleanupnodes(repo, mapping, b'phabsend', fixphase=True)
             if wnode in mapping:
                 unfi.setparents(mapping[wnode][0])
 
 
 # Map from "hg:meta" keys to header understood by "hg import". The order is
 # consistent with "hg export" output.
 _metanamemap = util.sortdict(
     [
         (b'user', b'User'),
         (b'date', b'Date'),
         (b'branch', b'Branch'),
         (b'node', b'Node ID'),
         (b'parent', b'Parent '),
     ]
 )
 
 
 def _confirmbeforesend(repo, revs, oldmap):
     url, token = readurltoken(repo.ui)
     ui = repo.ui
     for rev in revs:
         ctx = repo[rev]
         desc = ctx.description().splitlines()[0]
         oldnode, olddiff, drevid = oldmap.get(ctx.node(), (None, None, None))
         if drevid:
             drevdesc = ui.label(b'D%d' % drevid, b'phabricator.drev')
         else:
             drevdesc = ui.label(_(b'NEW'), b'phabricator.drev')
 
         ui.write(
             _(b'%s - %s: %s\n')
             % (
                 drevdesc,
                 ui.label(bytes(ctx), b'phabricator.node'),
                 ui.label(desc, b'phabricator.desc'),
             )
         )
 
     if ui.promptchoice(
         _(b'Send the above changes to %s (Y/n)?$$ &Yes $$ &No') % url
     ):
         return False
 
     return True
 
 
 _knownstatusnames = {
     b'accepted',
     b'needsreview',
     b'needsrevision',
     b'closed',
     b'abandoned',
     b'changesplanned',
 }
 
 
 def _getstatusname(drev):
     """get normalized status name from a Differential Revision"""
     return drev[b'statusName'].replace(b' ', b'').lower()
 
 
 # Small language to specify differential revisions. Support symbols: (), :X,
 # +, and -.
 
 _elements = {
     # token-type: binding-strength, primary, prefix, infix, suffix
     b'(': (12, None, (b'group', 1, b')'), None, None),
     b':': (8, None, (b'ancestors', 8), None, None),
     b'&': (5, None, None, (b'and_', 5), None),
     b'+': (4, None, None, (b'add', 4), None),
     b'-': (4, None, None, (b'sub', 4), None),
     b')': (0, None, None, None, None),
     b'symbol': (0, b'symbol', None, None, None),
     b'end': (0, None, None, None, None),
 }
 
 
 def _tokenize(text):
     view = memoryview(text)  # zero-copy slice
     special = b'():+-& '
     pos = 0
     length = len(text)
     while pos < length:
         symbol = b''.join(
             itertools.takewhile(
                 lambda ch: ch not in special, pycompat.iterbytestr(view[pos:])
             )
         )
         if symbol:
             yield (b'symbol', symbol, pos)
             pos += len(symbol)
         else:  # special char, ignore space
             if text[pos : pos + 1] != b' ':
                 yield (text[pos : pos + 1], None, pos)
             pos += 1
     yield (b'end', None, pos)
 
 
 def _parse(text):
     tree, pos = parser.parser(_elements).parse(_tokenize(text))
     if pos != len(text):
         raise error.ParseError(b'invalid token', pos)
     return tree
 
 
 def _parsedrev(symbol):
     """str -> int or None, ex. 'D45' -> 45; '12' -> 12; 'x' -> None"""
     if symbol.startswith(b'D') and symbol[1:].isdigit():
         return int(symbol[1:])
     if symbol.isdigit():
         return int(symbol)
 
 
 def _prefetchdrevs(tree):
     """return ({single-drev-id}, {ancestor-drev-id}) to prefetch"""
     drevs = set()
     ancestordrevs = set()
     op = tree[0]
     if op == b'symbol':
         r = _parsedrev(tree[1])
         if r:
             drevs.add(r)
     elif op == b'ancestors':
         r, a = _prefetchdrevs(tree[1])
         drevs.update(r)
         ancestordrevs.update(r)
         ancestordrevs.update(a)
     else:
         for t in tree[1:]:
             r, a = _prefetchdrevs(t)
             drevs.update(r)
             ancestordrevs.update(a)
     return drevs, ancestordrevs
 
 
 def querydrev(ui, spec):
     """return a list of "Differential Revision" dicts
 
     spec is a string using a simple query language, see docstring in phabread
     for details.
 
     A "Differential Revision dict" looks like:
 
         {
             "activeDiffPHID": "PHID-DIFF-xoqnjkobbm6k4dk6hi72",
             "authorPHID": "PHID-USER-tv3ohwc4v4jeu34otlye",
             "auxiliary": {
               "phabricator:depends-on": [
                 "PHID-DREV-gbapp366kutjebt7agcd"
               ]
               "phabricator:projects": [],
             },
             "branch": "default",
             "ccs": [],
             "commits": [],
             "dateCreated": "1499181406",
             "dateModified": "1499182103",
             "diffs": [
               "3",
               "4",
             ],
             "hashes": [],
             "id": "2",
             "lineCount": "2",
             "phid": "PHID-DREV-672qvysjcczopag46qty",
             "properties": {},
             "repositoryPHID": "PHID-REPO-hub2hx62ieuqeheznasv",
             "reviewers": [],
             "sourcePath": null
             "status": "0",
             "statusName": "Needs Review",
             "summary": "",
             "testPlan": "",
             "title": "example",
             "uri": "https://phab.example.com/D2",
         }
     """
     # TODO: replace differential.query and differential.querydiffs with
     # differential.diff.search because the former (and their output) are
     # frozen, and planned to be deprecated and removed.
 
     def fetch(params):
         """params -> single drev or None"""
         key = (params.get(b'ids') or params.get(b'phids') or [None])[0]
         if key in prefetched:
             return prefetched[key]
         drevs = callconduit(ui, b'differential.query', params)
         # Fill prefetched with the result
         for drev in drevs:
             prefetched[drev[b'phid']] = drev
             prefetched[int(drev[b'id'])] = drev
         if key not in prefetched:
             raise error.Abort(
                 _(b'cannot get Differential Revision %r') % params
             )
         return prefetched[key]
 
     def getstack(topdrevids):
         """given a top, get a stack from the bottom, [id] -> [id]"""
         visited = set()
         result = []
         queue = [{b'ids': [i]} for i in topdrevids]
         while queue:
             params = queue.pop()
             drev = fetch(params)
             if drev[b'id'] in visited:
                 continue
             visited.add(drev[b'id'])
             result.append(int(drev[b'id']))
             auxiliary = drev.get(b'auxiliary', {})
             depends = auxiliary.get(b'phabricator:depends-on', [])
             for phid in depends:
                 queue.append({b'phids': [phid]})
         result.reverse()
         return smartset.baseset(result)
 
     # Initialize prefetch cache
     prefetched = {}  # {id or phid: drev}
 
     tree = _parse(spec)
     drevs, ancestordrevs = _prefetchdrevs(tree)
 
     # developer config: phabricator.batchsize
     batchsize = ui.configint(b'phabricator', b'batchsize')
 
     # Prefetch Differential Revisions in batch
     tofetch = set(drevs)
     for r in ancestordrevs:
         tofetch.update(range(max(1, r - batchsize), r + 1))
     if drevs:
         fetch({b'ids': list(tofetch)})
     validids = sorted(set(getstack(list(ancestordrevs))) | set(drevs))
 
     # Walk through the tree, return smartsets
     def walk(tree):
         op = tree[0]
         if op == b'symbol':
             drev = _parsedrev(tree[1])
             if drev:
                 return smartset.baseset([drev])
             elif tree[1] in _knownstatusnames:
                 drevs = [
                     r
                     for r in validids
                     if _getstatusname(prefetched[r]) == tree[1]
                 ]
                 return smartset.baseset(drevs)
             else:
                 raise error.Abort(_(b'unknown symbol: %s') % tree[1])
         elif op in {b'and_', b'add', b'sub'}:
             assert len(tree) == 3
             return getattr(operator, op)(walk(tree[1]), walk(tree[2]))
         elif op == b'group':
             return walk(tree[1])
         elif op == b'ancestors':
             return getstack(walk(tree[1]))
         else:
             raise error.ProgrammingError(b'illegal tree: %r' % tree)
 
     return [prefetched[r] for r in walk(tree)]
 
 
 def getdescfromdrev(drev):
     """get description (commit message) from "Differential Revision"
 
     This is similar to differential.getcommitmessage API. But we only care
     about limited fields: title, summary, test plan, and URL.
     """
     title = drev[b'title']
     summary = drev[b'summary'].rstrip()
     testplan = drev[b'testPlan'].rstrip()
     if testplan:
         testplan = b'Test Plan:\n%s' % testplan
     uri = b'Differential Revision: %s' % drev[b'uri']
     return b'\n\n'.join(filter(None, [title, summary, testplan, uri]))
 
 
 def get_amended_desc(drev, ctx, folded):
     """similar to ``getdescfromdrev``, but supports a folded series of commits
 
     This is used when determining if an individual commit needs to have its
     message amended after posting it for review.  The determination is made for
     each individual commit, even when they were folded into one review.
     """
     if not folded:
         return getdescfromdrev(drev)
 
     uri = b'Differential Revision: %s' % drev[b'uri']
 
     # Since the commit messages were combined when posting multiple commits
     # with --fold, the fields can't be read from Phabricator here, or *all*
     # affected local revisions will end up with the same commit message after
     # the URI is amended in.  Append in the DREV line, or update it if it
     # exists.  At worst, this means commit message or test plan updates on
     # Phabricator aren't propagated back to the repository, but that seems
     # reasonable for the case where local commits are effectively combined
     # in Phabricator.
     m = _differentialrevisiondescre.search(ctx.description())
     if not m:
         return b'\n\n'.join([ctx.description(), uri])
 
     return _differentialrevisiondescre.sub(uri, ctx.description())
 
 
 def getlocalcommits(diff):
     """get the set of local commits from a diff object
 
     See ``getdiffmeta()`` for an example diff object.
     """
     props = diff.get(b'properties') or {}
     commits = props.get(b'local:commits') or {}
     if len(commits) > 1:
         return {bin(c) for c in commits.keys()}
 
     # Storing the diff metadata predates storing `local:commits`, so continue
     # to use that in the --no-fold case.
     return {bin(getdiffmeta(diff).get(b'node', b'')) or None}
 
 
 def getdiffmeta(diff):
     """get commit metadata (date, node, user, p1) from a diff object
 
     The metadata could be "hg:meta", sent by phabsend, like:
 
         "properties": {
           "hg:meta": {
             "branch": "default",
             "date": "1499571514 25200",
             "node": "98c08acae292b2faf60a279b4189beb6cff1414d",
             "user": "Foo Bar <[e-mail]>",
             "parent": "6d0abad76b30e4724a37ab8721d630394070fe16"
           }
         }
 
     Or converted from "local:commits", sent by "arc", like:
 
         "properties": {
           "local:commits": {
             "98c08acae292b2faf60a279b4189beb6cff1414d": {
               "author": "Foo Bar",
               "authorEmail": "[e-mail]"
               "branch": "default",
               "commit": "98c08acae292b2faf60a279b4189beb6cff1414d",
               "local": "1000",
               "message": "...",
               "parents": ["6d0abad76b30e4724a37ab8721d630394070fe16"],
               "rev": "98c08acae292b2faf60a279b4189beb6cff1414d",
               "summary": "...",
               "tag": "",
               "time": 1499546314,
             }
           }
         }
 
     Note: metadata extracted from "local:commits" will lose time zone
     information.
     """
     props = diff.get(b'properties') or {}
     meta = props.get(b'hg:meta')
     if not meta:
         if props.get(b'local:commits'):
             commit = sorted(props[b'local:commits'].values())[0]
             meta = {}
             if b'author' in commit and b'authorEmail' in commit:
                 meta[b'user'] = b'%s <%s>' % (
                     commit[b'author'],
                     commit[b'authorEmail'],
                 )
             if b'time' in commit:
                 meta[b'date'] = b'%d 0' % int(commit[b'time'])
             if b'branch' in commit:
                 meta[b'branch'] = commit[b'branch']
             node = commit.get(b'commit', commit.get(b'rev'))
             if node:
                 meta[b'node'] = node
             if len(commit.get(b'parents', ())) >= 1:
                 meta[b'parent'] = commit[b'parents'][0]
         else:
             meta = {}
     if b'date' not in meta and b'dateCreated' in diff:
         meta[b'date'] = b'%s 0' % diff[b'dateCreated']
     if b'branch' not in meta and diff.get(b'branch'):
         meta[b'branch'] = diff[b'branch']
     if b'parent' not in meta and diff.get(b'sourceControlBaseRevision'):
         meta[b'parent'] = diff[b'sourceControlBaseRevision']
     return meta
 
 
 def _getdrevs(ui, stack, specs):
     """convert user supplied DREVSPECs into "Differential Revision" dicts
 
     See ``hg help phabread`` for how to specify each DREVSPEC.
     """
     if len(specs) > 0:
 
         def _formatspec(s):
             if stack:
                 s = b':(%s)' % s
             return b'(%s)' % s
 
         spec = b'+'.join(pycompat.maplist(_formatspec, specs))
 
         drevs = querydrev(ui, spec)
         if drevs:
             return drevs
 
     raise error.Abort(_(b"empty DREVSPEC set"))
 
 
 def readpatch(ui, drevs, write):
     """generate plain-text patch readable by 'hg import'
 
     write takes a list of (DREV, bytes), where DREV is the differential number
     (as bytes, without the "D" prefix) and the bytes are the text of a patch
     to be imported. drevs is what "querydrev" returns, results of
     "differential.query".
     """
     # Prefetch hg:meta property for all diffs
     diffids = sorted({max(int(v) for v in drev[b'diffs']) for drev in drevs})
     diffs = callconduit(ui, b'differential.querydiffs', {b'ids': diffids})
 
     patches = []
 
     # Generate patch for each drev
     for drev in drevs:
         ui.note(_(b'reading D%s\n') % drev[b'id'])
 
         diffid = max(int(v) for v in drev[b'diffs'])
         body = callconduit(ui, b'differential.getrawdiff', {b'diffID': diffid})
         desc = getdescfromdrev(drev)
         header = b'# HG changeset patch\n'
 
         # Try to preserve metadata from hg:meta property. Write hg patch
         # headers that can be read by the "import" command. See patchheadermap
         # and extract in mercurial/patch.py for supported headers.
         meta = getdiffmeta(diffs[b'%d' % diffid])
         for k in _metanamemap.keys():
             if k in meta:
                 header += b'# %s %s\n' % (_metanamemap[k], meta[k])
 
         content = b'%s%s\n%s' % (header, desc, body)
         patches.append((drev[b'id'], content))
 
     # Write patches to the supplied callback
     write(patches)
 
 
 @vcrcommand(
     b'phabread',
     [(b'', b'stack', False, _(b'read dependencies'))],
     _(b'DREVSPEC... [OPTIONS]'),
     helpcategory=command.CATEGORY_IMPORT_EXPORT,
     optionalrepo=True,
 )
 def phabread(ui, repo, *specs, **opts):
     """print patches from Phabricator suitable for importing
 
     DREVSPEC could be a Differential Revision identity, like ``D123``, or just
     the number ``123``. It could also have common operators like ``+``, ``-``,
     ``&``, ``(``, ``)`` for complex queries. Prefix ``:`` could be used to
     select a stack.  If multiple DREVSPEC values are given, the result is the
     union of each individually evaluated value.  No attempt is currently made
     to reorder the values to run from parent to child.
 
     ``abandoned``, ``accepted``, ``closed``, ``needsreview``, ``needsrevision``
     could be used to filter patches by status. For performance reason, they
     only represent a subset of non-status selections and cannot be used alone.
 
     For example, ``:D6+8-(2+D4)`` selects a stack up to D6, plus D8 and exclude
     D2 and D4. ``:D9 & needsreview`` selects "Needs Review" revisions in a
     stack up to D9.
 
     If --stack is given, follow dependencies information and read all patches.
     It is equivalent to the ``:`` operator.
     """
     opts = pycompat.byteskwargs(opts)
     drevs = _getdrevs(ui, opts.get(b'stack'), specs)
 
     def _write(patches):
         for drev, content in patches:
             ui.write(content)
 
     readpatch(ui, drevs, _write)
 
 
 @vcrcommand(
     b'phabimport',
     [(b'', b'stack', False, _(b'import dependencies as well'))],
     _(b'DREVSPEC... [OPTIONS]'),
     helpcategory=command.CATEGORY_IMPORT_EXPORT,
 )
 def phabimport(ui, repo, *specs, **opts):
     """import patches from Phabricator for the specified Differential Revisions
 
     The patches are read and applied starting at the parent of the working
     directory.
 
     See ``hg help phabread`` for how to specify DREVSPEC.
     """
     opts = pycompat.byteskwargs(opts)
 
     # --bypass avoids losing exec and symlink bits when importing on Windows,
     # and allows importing with a dirty wdir.  It also aborts instead of leaving
     # rejects.
     opts[b'bypass'] = True
 
     # Mandatory default values, synced with commands.import
     opts[b'strip'] = 1
     opts[b'prefix'] = b''
     # Evolve 9.3.0 assumes this key is present in cmdutil.tryimportone()
     opts[b'obsolete'] = False
 
     if ui.configbool(b'phabimport', b'secret'):
         opts[b'secret'] = True
     if ui.configbool(b'phabimport', b'obsolete'):
         opts[b'obsolete'] = True  # Handled by evolve wrapping tryimportone()
 
     def _write(patches):
         parents = repo[None].parents()
 
         with repo.wlock(), repo.lock(), repo.transaction(b'phabimport'):
             for drev, contents in patches:
                 ui.status(_(b'applying patch from D%s\n') % drev)
 
                 with patch.extract(ui, pycompat.bytesio(contents)) as patchdata:
                     msg, node, rej = cmdutil.tryimportone(
                         ui,
                         repo,
                         patchdata,
                         parents,
                         opts,
                         [],
                         None,  # Never update wdir to another revision
                     )
 
                     if not node:
                         raise error.Abort(_(b'D%s: no diffs found') % drev)
 
                     ui.note(msg + b'\n')
                     parents = [repo[node]]
 
     drevs = _getdrevs(ui, opts.get(b'stack'), specs)
 
     readpatch(repo.ui, drevs, _write)
 
 
 @vcrcommand(
     b'phabupdate',
     [
         (b'', b'accept', False, _(b'accept revisions')),
         (b'', b'reject', False, _(b'reject revisions')),
         (b'', b'request-review', False, _(b'request review on revisions')),
         (b'', b'abandon', False, _(b'abandon revisions')),
         (b'', b'reclaim', False, _(b'reclaim revisions')),
         (b'', b'close', False, _(b'close revisions')),
         (b'', b'reopen', False, _(b'reopen revisions')),
         (b'', b'plan-changes', False, _(b'plan changes for revisions')),
         (b'', b'resign', False, _(b'resign as a reviewer from revisions')),
         (b'', b'commandeer', False, _(b'commandeer revisions')),
         (b'm', b'comment', b'', _(b'comment on the last revision')),
     ],
     _(b'DREVSPEC... [OPTIONS]'),
     helpcategory=command.CATEGORY_IMPORT_EXPORT,
     optionalrepo=True,
 )
 def phabupdate(ui, repo, *specs, **opts):
     """update Differential Revision in batch
 
     DREVSPEC selects revisions. See :hg:`help phabread` for its usage.
     """
     opts = pycompat.byteskwargs(opts)
     transactions = [
         b'abandon',
         b'accept',
         b'close',
         b'commandeer',
         b'plan-changes',
         b'reclaim',
         b'reject',
         b'reopen',
         b'request-review',
         b'resign',
     ]
     flags = [n for n in transactions if opts.get(n.replace(b'-', b'_'))]
     if len(flags) > 1:
         raise error.Abort(_(b'%s cannot be used together') % b', '.join(flags))
 
     actions = []
     for f in flags:
         actions.append({b'type': f, b'value': True})
 
     drevs = _getdrevs(ui, opts.get(b'stack'), specs)
     for i, drev in enumerate(drevs):
         if i + 1 == len(drevs) and opts.get(b'comment'):
             actions.append({b'type': b'comment', b'value': opts[b'comment']})
         if actions:
             params = {
                 b'objectIdentifier': drev[b'phid'],
                 b'transactions': actions,
             }
             callconduit(ui, b'differential.revision.edit', params)
 
 
 @eh.templatekeyword(b'phabreview', requires={b'ctx'})
 def template_review(context, mapping):
     """:phabreview: Object describing the review for this changeset.
     Has attributes `url` and `id`.
     """
     ctx = context.resource(mapping, b'ctx')
     m = _differentialrevisiondescre.search(ctx.description())
     if m:
         return templateutil.hybriddict(
             {b'url': m.group('url'), b'id': b"D%s" % m.group('id'),}
         )
     else:
         tags = ctx.repo().nodetags(ctx.node())
         for t in tags:
             if _differentialrevisiontagre.match(t):
                 url = ctx.repo().ui.config(b'phabricator', b'url')
                 if not url.endswith(b'/'):
                     url += b'/'
                 url += t
 
                 return templateutil.hybriddict({b'url': url, b'id': t,})
     return None
 
 
 @eh.templatekeyword(b'phabstatus', requires={b'ctx', b'repo', b'ui'})
 def template_status(context, mapping):
     """:phabstatus: String. Status of Phabricator differential.
     """
     ctx = context.resource(mapping, b'ctx')
     repo = context.resource(mapping, b'repo')
     ui = context.resource(mapping, b'ui')
 
     rev = ctx.rev()
     try:
         drevid = getdrevmap(repo, [rev])[rev]
     except KeyError:
         return None
     drevs = callconduit(ui, b'differential.query', {b'ids': [drevid]})
     for drev in drevs:
         if int(drev[b'id']) == drevid:
             return templateutil.hybriddict(
                 {b'url': drev[b'uri'], b'status': drev[b'statusName'],}
             )
     return None
 
 
 @show.showview(b'phabstatus', csettopic=b'work')
 def phabstatusshowview(ui, repo, displayer):
     """Phabricator differiential status"""
     revs = repo.revs('sort(_underway(), topo)')
     drevmap = getdrevmap(repo, revs)
     unknownrevs, drevids, revsbydrevid = [], set(), {}
     for rev, drevid in pycompat.iteritems(drevmap):
         if drevid is not None:
             drevids.add(drevid)
             revsbydrevid.setdefault(drevid, set()).add(rev)
         else:
             unknownrevs.append(rev)
 
     drevs = callconduit(ui, b'differential.query', {b'ids': list(drevids)})
     drevsbyrev = {}
     for drev in drevs:
         for rev in revsbydrevid[int(drev[b'id'])]:
             drevsbyrev[rev] = drev
 
     def phabstatus(ctx):
         drev = drevsbyrev[ctx.rev()]
         status = ui.label(
             b'%(statusName)s' % drev,
             b'phabricator.status.%s' % _getstatusname(drev),
         )
         ui.write(b"\n%s %s\n" % (drev[b'uri'], status))
 
     revs -= smartset.baseset(unknownrevs)
     revdag = graphmod.dagwalker(repo, revs)
 
     ui.setconfig(b'experimental', b'graphshorten', True)
     displayer._exthook = phabstatus
     nodelen = show.longestshortest(repo, revs)
     logcmdutil.displaygraph(
         ui,
         repo,
         revdag,
         displayer,
         graphmod.asciiedges,
         props={b'nodelen': nodelen},
     )

tests/test-phabricator.t

@@ -1,969 +1,969 b''
 #require vcr
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > phabricator = 
   > 
   > [auth]
   > hgphab.schemes = https
   > hgphab.prefix = phab.mercurial-scm.org
   > # When working on the extension and making phabricator interaction
   > # changes, edit this to be a real phabricator token. When done, edit
   > # it back. The VCR transcripts will be auto-sanitised to replace your real
   > # token with this value.
   > hgphab.phabtoken = cli-hahayouwish
   > 
   > [phabricator]
   > debug = True
   > EOF
   $ hg init repo
   $ cd repo
   $ cat >> .hg/hgrc <<EOF
   > [phabricator]
   > url = https://phab.mercurial-scm.org/
   > callsign = HG
   > EOF
   $ VCR="$TESTDIR/phabricator"
 
 Error is handled reasonably. We override the phabtoken here so that
 when you're developing changes to phabricator.py you can edit the
 above config and have a real token in the test but not have to edit
 this test.
   $ hg phabread --config auth.hgphab.phabtoken=cli-notavalidtoken \
   >  --test-vcr "$VCR/phabread-conduit-error.json" D4480 | head
   abort: Conduit Error (ERR-INVALID-AUTH): API token "cli-notavalidtoken" has the wrong length. API tokens should be 32 characters long.
 
 Missing arguments don't crash, and may print the command help
 
   $ hg debugcallconduit
   hg debugcallconduit: invalid arguments
   hg debugcallconduit METHOD
   
   call Conduit API
   
   options:
   
   (use 'hg debugcallconduit -h' to show more help)
   [255]
   $ hg phabread
   abort: empty DREVSPEC set
   [255]
 
 Basic phabread:
   $ hg phabread --test-vcr "$VCR/phabread-4480.json" D4480 | head
   # HG changeset patch
   # Date 1536771503 0
   # Parent  a5de21c9e3703f8e8eb064bd7d893ff2f703c66a
   exchangev2: start to implement pull with wire protocol v2
   
   Wire protocol version 2 will take a substantially different
   approach to exchange than version 1 (at least as far as pulling
   is concerned).
   
   This commit establishes a new exchangev2 module for holding
 
 Phabread with multiple DREVSPEC
 
 TODO: attempt to order related revisions like --stack?
   $ hg phabread --test-vcr "$VCR/phabread-multi-drev.json" D8205 8206 D8207 \
   >             | grep '^Differential Revision'
   Differential Revision: https://phab.mercurial-scm.org/D8205
   Differential Revision: https://phab.mercurial-scm.org/D8206
   Differential Revision: https://phab.mercurial-scm.org/D8207
 
 Empty DREVSPECs don't crash
 
   $ hg phabread --test-vcr "$VCR/phabread-empty-drev.json" D7917-D7917
   abort: empty DREVSPEC set
   [255]
 
 
 phabupdate with an accept:
   $ hg phabupdate --accept D4564 \
   > -m 'I think I like where this is headed. Will read rest of series later.'\
   >  --test-vcr "$VCR/accept-4564.json"
   abort: Conduit Error (ERR-CONDUIT-CORE): Validation errors:
     - You can not accept this revision because it has already been closed. Only open revisions can be accepted.
   [255]
   $ hg phabupdate --accept D7913 -m 'LGTM' --test-vcr "$VCR/accept-7913.json"
 
 phabupdate with --plan-changes:
 
   $ hg phabupdate --plan-changes D6876 --test-vcr "$VCR/phabupdate-change-6876.json"
 
 Create a differential diff:
   $ HGENCODING=utf-8; export HGENCODING
   $ echo alpha > alpha
   $ hg ci --addremove -m 'create alpha for phabricator test €'
   adding alpha
   $ hg phabsend -r . --test-vcr "$VCR/phabsend-create-alpha.json"
   D7915 - created - d386117f30e6: create alpha for phabricator test \xe2\x82\xac (esc)
   new commits: ['347bf67801e5']
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/d386117f30e6-24ffe649-phabsend.hg
   $ echo more >> alpha
   $ HGEDITOR=true hg ci --amend
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/347bf67801e5-3bf313e4-amend.hg
   $ echo beta > beta
   $ hg ci --addremove -m 'create beta for phabricator test'
   adding beta
   $ hg phabsend -r ".^::" --test-vcr "$VCR/phabsend-update-alpha-create-beta.json"
   c44b38f24a45 mapped to old nodes []
   D7915 - updated - c44b38f24a45: create alpha for phabricator test \xe2\x82\xac (esc)
   D7916 - created - 9e6901f21d5b: create beta for phabricator test
   new commits: ['a692622e6937']
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/9e6901f21d5b-1fcd4f0e-phabsend.hg
   $ unset HGENCODING
 
 The amend won't explode after posting a public commit.  The local tag is left
 behind to identify it.
 
   $ echo 'public change' > beta
   $ hg ci -m 'create public change for phabricator testing'
   $ hg phase --public .
   $ echo 'draft change' > alpha
   $ hg ci -m 'create draft change for phabricator testing'
   $ hg phabsend --amend -r '.^::' --test-vcr "$VCR/phabsend-create-public.json"
   D7917 - created - 7b4185ab5d16: create public change for phabricator testing
   D7918 - created - 251c1c333fc6: create draft change for phabricator testing
   warning: not updating public commit 2:7b4185ab5d16
   new commits: ['3244dc4a3334']
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/251c1c333fc6-41cb7c3b-phabsend.hg
   $ hg tags -v
   tip                                3:3244dc4a3334
   D7917                              2:7b4185ab5d16 local
 
   $ hg debugcallconduit user.search --test-vcr "$VCR/phab-conduit.json" <<EOF
   > {
   >     "constraints": {
   >         "isBot": true
   >     }
   > }
   > EOF
   {
     "cursor": {
       "after": null,
       "before": null,
       "limit": 100,
       "order": null
     },
     "data": [],
     "maps": {},
     "query": {
       "queryKey": null
     }
   }
 
 Template keywords
   $ hg log -T'{rev} {phabreview|json}\n'
   3 {"id": "D7918", "url": "https://phab.mercurial-scm.org/D7918"}
   2 {"id": "D7917", "url": "https://phab.mercurial-scm.org/D7917"}
   1 {"id": "D7916", "url": "https://phab.mercurial-scm.org/D7916"}
   0 {"id": "D7915", "url": "https://phab.mercurial-scm.org/D7915"}
 
   $ hg log -T'{rev} {if(phabreview, "{phabreview.url} {phabreview.id}")}\n'
   3 https://phab.mercurial-scm.org/D7918 D7918
   2 https://phab.mercurial-scm.org/D7917 D7917
   1 https://phab.mercurial-scm.org/D7916 D7916
   0 https://phab.mercurial-scm.org/D7915 D7915
 
 Commenting when phabsending:
   $ echo comment > comment
   $ hg ci --addremove -m "create comment for phabricator test"
   adding comment
   $ hg phabsend -r . -m "For default branch" --test-vcr "$VCR/phabsend-comment-created.json"
   D7919 - created - d5dddca9023d: create comment for phabricator test
   new commits: ['f7db812bbe1d']
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/d5dddca9023d-adf673ba-phabsend.hg
   $ echo comment2 >> comment
   $ hg ci --amend
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/f7db812bbe1d-8fcded77-amend.hg
   $ hg phabsend -r . -m "Address review comments" --test-vcr "$VCR/phabsend-comment-updated.json"
   1849d7828727 mapped to old nodes []
   D7919 - updated - 1849d7828727: create comment for phabricator test
 
 Phabsending a skipped commit:
   $ hg phabsend --no-amend -r . --test-vcr "$VCR/phabsend-skipped.json"
   1849d7828727 mapped to old nodes ['1849d7828727']
   D7919 - skipped - 1849d7828727: create comment for phabricator test
 
 Phabsend doesn't create an instability when restacking existing revisions on top
 of new revisions.
 
   $ hg init reorder
   $ cd reorder
   $ cat >> .hg/hgrc <<EOF
   > [phabricator]
   > url = https://phab.mercurial-scm.org/
   > callsign = HG
   > [experimental]
   > evolution = all
   > EOF
 
   $ echo "add" > file1.txt
   $ hg ci -Aqm 'added'
   $ echo "mod1" > file1.txt
   $ hg ci -m 'modified 1'
   $ echo "mod2" > file1.txt
   $ hg ci -m 'modified 2'
   $ hg phabsend -r . --test-vcr "$VCR/phabsend-add-parent-setup.json"
   D8433 - created - 5d3959e20d1d: modified 2
   new commits: ['2b4aa8a88d61']
   $ hg log -G -T compact
   @  3[tip]:1   2b4aa8a88d61   1970-01-01 00:00 +0000   test
   |    modified 2
   |
   o  1   d549263bcb2d   1970-01-01 00:00 +0000   test
   |    modified 1
   |
   o  0   5cbade24e0fa   1970-01-01 00:00 +0000   test
        added
   
 Also check that it doesn't create more orphans outside of the stack
 
   $ hg up -q 1
   $ echo "mod3" > file1.txt
   $ hg ci -m 'modified 3'
   created new head
   $ hg up -q 3
   $ hg phabsend -r ".^ + ." --test-vcr "$VCR/phabsend-add-parent.json"
   2b4aa8a88d61 mapped to old nodes ['2b4aa8a88d61']
   D8434 - created - d549263bcb2d: modified 1
   D8433 - updated - 2b4aa8a88d61: modified 2
   new commits: ['876a60d024de']
   new commits: ['0c6523cb1d0f']
   restabilizing 1eda4bf55021 as d2c78c3a3e01
   $ hg log -G -T compact
   o  7[tip]:5   d2c78c3a3e01   1970-01-01 00:00 +0000   test
   |    modified 3
   |
   | @  6   0c6523cb1d0f   1970-01-01 00:00 +0000   test
   |/     modified 2
   |
   o  5:0   876a60d024de   1970-01-01 00:00 +0000   test
   |    modified 1
   |
   o  0   5cbade24e0fa   1970-01-01 00:00 +0000   test
        added
   
 Posting obsolete commits is disallowed
 
   $ echo "mod3" > file1.txt
   $ hg ci -m 'modified A'
   $ echo "mod4" > file1.txt
   $ hg ci -m 'modified B'
 
   $ hg up '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 'obsolete' > file1.txt
   $ hg amend --config extensions.amend=
   1 new orphan changesets
   $ hg log -G
   @  changeset:   10:082be6c94150
   |  tag:         tip
   |  parent:      6:0c6523cb1d0f
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     modified A
   |
   | *  changeset:   9:a67643f48146
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  instability: orphan
   | |  summary:     modified B
   | |
   | x  changeset:   8:db79727cb2f7
   |/   parent:      6:0c6523cb1d0f
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    obsolete:    rewritten using amend as 10:082be6c94150
   |    summary:     modified A
   |
   | o  changeset:   7:d2c78c3a3e01
   | |  parent:      5:876a60d024de
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     modified 3
   | |
   o |  changeset:   6:0c6523cb1d0f
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     modified 2
   |
   o  changeset:   5:876a60d024de
   |  parent:      0:5cbade24e0fa
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     modified 1
   |
   o  changeset:   0:5cbade24e0fa
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     added
   
   $ hg phabsend -r 5::
   abort: obsolete commits cannot be posted for review
   [255]
 
 Don't restack existing orphans
 
   $ hg phabsend -r 5::tip --test-vcr "$VCR/phabsend-no-restack-orphan.json"
   876a60d024de mapped to old nodes ['876a60d024de']
   0c6523cb1d0f mapped to old nodes ['0c6523cb1d0f']
   D8434 - updated - 876a60d024de: modified 1
   D8433 - updated - 0c6523cb1d0f: modified 2
   D8435 - created - 082be6c94150: modified A
   new commits: ['b5913193c805']
   not restabilizing unchanged d2c78c3a3e01
   $ hg log -G
   @  changeset:   11:b5913193c805
   |  tag:         tip
   |  parent:      6:0c6523cb1d0f
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     modified A
   |
   | *  changeset:   9:a67643f48146
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  instability: orphan
   | |  summary:     modified B
   | |
   | x  changeset:   8:db79727cb2f7
   |/   parent:      6:0c6523cb1d0f
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    obsolete:    rewritten using amend, phabsend as 11:b5913193c805
   |    summary:     modified A
   |
   | o  changeset:   7:d2c78c3a3e01
   | |  parent:      5:876a60d024de
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     modified 3
   | |
   o |  changeset:   6:0c6523cb1d0f
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     modified 2
   |
   o  changeset:   5:876a60d024de
   |  parent:      0:5cbade24e0fa
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     modified 1
   |
   o  changeset:   0:5cbade24e0fa
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     added
   
   $ cd ..
 
 Phabesending a new binary, a modified binary, and a removed binary
 
   >>> open('bin', 'wb').write(b'\0a') and None
   $ hg ci -Am 'add binary'
   adding bin
   >>> open('bin', 'wb').write(b'\0b') and None
   $ hg ci -m 'modify binary'
   $ hg rm bin
   $ hg ci -m 'remove binary'
   $ hg phabsend -r .~2:: --test-vcr "$VCR/phabsend-binary.json"
   uploading bin@aa24a81f55de
   D8007 - created - aa24a81f55de: add binary
   uploading bin@d8d62a881b54
   D8008 - created - d8d62a881b54: modify binary
   D8009 - created - af55645b2e29: remove binary
   new commits: ['b8139fbb4a57']
   new commits: ['c88ce4c2d2ad']
   new commits: ['75dbbc901145']
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/aa24a81f55de-a3a0cf24-phabsend.hg
 
 Phabsend a renamed binary and a copied binary, with and without content changes
 to src and dest
 
   >>> open('bin2', 'wb').write(b'\0c') and None
   $ hg ci -Am 'add another binary'
   adding bin2
 
 TODO: "bin2" can't be viewed in this commit (left or right side), and the URL
 looks much different than when viewing "bin2_moved".  No idea if this is a phab
 bug, or phabsend bug.  The patch (as printed by phabread) look reasonable
 though.
 
   $ hg mv bin2 bin2_moved
   $ hg ci -m "moved binary"
 
 Note: "bin2_moved" is also not viewable in phabricator with this review
 
   $ hg cp bin2_moved bin2_copied
   $ hg ci -m "copied binary"
 
 Note: "bin2_moved_again" is marked binary in phabricator, and both sides of it
 are viewable in their proper state.  "bin2_copied" is not viewable, and not
 listed as binary in phabricator.
 
   >>> open('bin2_copied', 'wb').write(b'\0move+mod') and None
   $ hg mv bin2_copied bin2_moved_again
   $ hg ci -m "move+mod copied binary"
 
 Note: "bin2_moved" and "bin2_moved_copy" are both marked binary, and both
 viewable on each side.
 
   >>> open('bin2_moved', 'wb').write(b'\0precopy mod') and None
   $ hg cp bin2_moved bin2_moved_copied
   >>> open('bin2_moved', 'wb').write(b'\0copy src+mod') and None
   $ hg ci -m "copy+mod moved binary"
 
   $ hg phabsend -r .~4:: --test-vcr "$VCR/phabsend-binary-renames.json"
   uploading bin2@f42f9195e00c
   D8128 - created - f42f9195e00c: add another binary
   D8129 - created - 834ab31d80ae: moved binary
   D8130 - created - 494b750e5194: copied binary
   uploading bin2_moved_again@25f766b50cc2
   D8131 - created - 25f766b50cc2: move+mod copied binary
   uploading bin2_moved_copied@1b87b363a5e4
   uploading bin2_moved@1b87b363a5e4
   D8132 - created - 1b87b363a5e4: copy+mod moved binary
   new commits: ['90437c20312a']
   new commits: ['f391f4da4c61']
   new commits: ['da86a9f3268c']
   new commits: ['003ffc16ba66']
   new commits: ['13bd750c36fa']
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/f42f9195e00c-e82a0769-phabsend.hg
 
 Phabreading a DREV with a local:commits time as a string:
   $ hg phabread --test-vcr "$VCR/phabread-str-time.json" D1285
   # HG changeset patch
   # User Pulkit Goyal <[e-mail]>
   # Date 1509404054 -19800
   # Node ID 44fc1c1f1774a76423b9c732af6938435099bcc5
   # Parent  8feef8ef8389a3b544e0a74624f1efc3a8d85d35
   repoview: add a new attribute _visibilityexceptions and related API
   
   Currently we don't have a defined way in core to make some hidden revisions
   visible in filtered repo. Extensions to achieve the purpose of unhiding some
   hidden commits, wrap repoview.pinnedrevs() function.
   
   To make the above task simple and have well defined API, this patch adds a new
   attribute '_visibilityexceptions' to repoview class which will contains
   the hidden revs which should be exception.
   This will allow to set different exceptions for different repoview objects
   backed by the same unfiltered repo.
   
   This patch also adds API to add revs to the attribute set and get them.
   
   Thanks to Jun for suggesting the use of repoview class instead of localrepo.
   
   Differential Revision: https://phab.mercurial-scm.org/D1285
   diff --git a/mercurial/repoview.py b/mercurial/repoview.py
   --- a/mercurial/repoview.py
   +++ b/mercurial/repoview.py
   @@ * @@ (glob)
        subclasses of `localrepo`. Eg: `bundlerepo` or `statichttprepo`.
        """
    
   +    # hidden revs which should be visible
   +    _visibilityexceptions = set()
   +
        def __init__(self, repo, filtername):
            object.__setattr__(self, r'_unfilteredrepo', repo)
            object.__setattr__(self, r'filtername', filtername)
   @@ -231,6 +234,14 @@
                return self
            return self.unfiltered().filtered(name)
    
   +    def addvisibilityexceptions(self, revs):
   +        """adds hidden revs which should be visible to set of exceptions"""
   +        self._visibilityexceptions.update(revs)
   +
   +    def getvisibilityexceptions(self):
   +        """returns the set of hidden revs which should be visible"""
   +        return self._visibilityexceptions
   +
        # everything access are forwarded to the proxied repo
        def __getattr__(self, attr):
            return getattr(self._unfilteredrepo, attr)
   diff --git a/mercurial/localrepo.py b/mercurial/localrepo.py
   --- a/mercurial/localrepo.py
   +++ b/mercurial/localrepo.py
   @@ -570,6 +570,14 @@
        def close(self):
            self._writecaches()
    
   +    def addvisibilityexceptions(self, exceptions):
   +        # should be called on a filtered repository
   +        pass
   +
   +    def getvisibilityexceptions(self):
   +        # should be called on a filtered repository
   +        return set()
   +
        def _loadextensions(self):
            extensions.loadall(self.ui)
    
   
 A bad .arcconfig doesn't error out
   $ echo 'garbage' > .arcconfig
   $ hg config phabricator --debug
   invalid JSON in $TESTTMP/repo/.arcconfig
   read config from: */.hgrc (glob)
   */.hgrc:*: phabricator.debug=True (glob)
   $TESTTMP/repo/.hg/hgrc:*: phabricator.url=https://phab.mercurial-scm.org/ (glob)
   $TESTTMP/repo/.hg/hgrc:*: phabricator.callsign=HG (glob)
 
 The .arcconfig content overrides global config
   $ cat >> $HGRCPATH << EOF
   > [phabricator]
   > url = global
   > callsign = global
   > EOF
   $ cp $TESTDIR/../.arcconfig .
   $ mv .hg/hgrc .hg/hgrc.bak
   $ hg config phabricator --debug
   read config from: */.hgrc (glob)
   */.hgrc:*: phabricator.debug=True (glob)
   $TESTTMP/repo/.arcconfig: phabricator.callsign=HG
   $TESTTMP/repo/.arcconfig: phabricator.url=https://phab.mercurial-scm.org/
 
 But it doesn't override local config
   $ cat >> .hg/hgrc << EOF
   > [phabricator]
   > url = local
   > callsign = local
   > EOF
   $ hg config phabricator --debug
   read config from: */.hgrc (glob)
   */.hgrc:*: phabricator.debug=True (glob)
   $TESTTMP/repo/.hg/hgrc:*: phabricator.url=local (glob)
   $TESTTMP/repo/.hg/hgrc:*: phabricator.callsign=local (glob)
   $ mv .hg/hgrc.bak .hg/hgrc
 
 Phabimport works with a stack
 
   $ cd ..
   $ hg clone repo repo2 -qr 1
   $ cp repo/.hg/hgrc repo2/.hg/
   $ cd repo2
   $ hg phabimport --stack 'D7918' --test-vcr "$VCR/phabimport-stack.json"
   applying patch from D7917
   applying patch from D7918
   $ hg log -r .: -G -Tcompact
   o  3[tip]   aaef04066140   1970-01-01 00:00 +0000   test
   |    create draft change for phabricator testing
   |
   o  2   8de3712202d1   1970-01-01 00:00 +0000   test
   |    create public change for phabricator testing
   |
   @  1   a692622e6937   1970-01-01 00:00 +0000   test
   |    create beta for phabricator test
   ~
 Phabimport can create secret commits
 
   $ hg rollback --config ui.rollback=True
   repository tip rolled back to revision 1 (undo phabimport)
   $ hg phabimport --stack 'D7918' --test-vcr "$VCR/phabimport-stack.json" \
   >    --config phabimport.secret=True
   applying patch from D7917
   applying patch from D7918
   $ hg log -r 'reverse(.:)' -T phases
   changeset:   3:aaef04066140
   tag:         tip
   phase:       secret
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     create draft change for phabricator testing
   
   changeset:   2:8de3712202d1
   phase:       secret
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     create public change for phabricator testing
   
   changeset:   1:a692622e6937
   phase:       public
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     create beta for phabricator test
   
 Phabimport accepts multiple DREVSPECs
 
   $ hg rollback --config ui.rollback=True
   repository tip rolled back to revision 1 (undo phabimport)
   $ hg phabimport --no-stack D7917 D7918 --test-vcr "$VCR/phabimport-multi-drev.json"
   applying patch from D7917
   applying patch from D7918
 
 Phabsend requires a linear range of commits
 
   $ hg phabsend -r 0+2+3
-  abort: cannot phabsend multiple head revisions: c44b38f24a45
+  abort: cannot phabsend multiple head revisions: c44b38f24a45 aaef04066140
   (the revisions must form a linear chain)
   [255]
 
 Validate arguments with --fold
 
   $ hg phabsend --fold -r 1
   abort: cannot fold a single revision
   [255]
   $ hg phabsend --fold --no-amend -r 1::
   abort: cannot fold with --no-amend
   [255]
   $ hg phabsend --fold -r 1::
   abort: cannot fold revisions with different DREV values
   [255]
 
 Setup a series of commits to be folded, and include the Test Plan field multiple
 times to test the concatenation logic.  No Test Plan field in the last one to
 ensure missing fields are skipped.
 
   $ hg init ../folded
   $ cd ../folded
   $ cat >> .hg/hgrc <<EOF
   > [phabricator]
   > url = https://phab.mercurial-scm.org/
   > callsign = HG
   > EOF
 
   $ echo 'added' > file.txt
   $ hg ci -Aqm 'added file'
 
   $ cat > log.txt <<EOF
   > one: first commit to review
   > 
   > This file was modified with 'mod1' as its contents.
   > 
   > Test Plan:
   > LOL!  What testing?!
   > EOF
   $ echo mod1 > file.txt
   $ hg ci -l log.txt
 
   $ cat > log.txt <<EOF
   > two: second commit to review
   > 
   > This file was modified with 'mod2' as its contents.
   > 
   > Test Plan:
   > Haha! yeah, right.
   > 
   > EOF
   $ echo mod2 > file.txt
   $ hg ci -l log.txt
 
   $ echo mod3 > file.txt
   $ hg ci -m '3: a commit with no detailed message'
 
 The folding of immutable commits works...
 
   $ hg phase -r tip --public
   $ hg phabsend --fold -r 1:: --test-vcr "$VCR/phabsend-fold-immutable.json"
   D8386 - created - a959a3f69d8d: one: first commit to review
   D8386 - created - 24a4438154ba: two: second commit to review
   D8386 - created - d235829e802c: 3: a commit with no detailed message
   warning: not updating public commit 1:a959a3f69d8d
   warning: not updating public commit 2:24a4438154ba
   warning: not updating public commit 3:d235829e802c
   no newnodes to update
 
   $ hg phase -r 0 --draft --force
 
 ... as does the initial mutable fold...
 
   $ echo y | hg phabsend --fold --confirm -r 1:: \
   >          --test-vcr "$VCR/phabsend-fold-initial.json"
   NEW - a959a3f69d8d: one: first commit to review
   NEW - 24a4438154ba: two: second commit to review
   NEW - d235829e802c: 3: a commit with no detailed message
   Send the above changes to https://phab.mercurial-scm.org/ (Y/n)? y
   D8387 - created - a959a3f69d8d: one: first commit to review
   D8387 - created - 24a4438154ba: two: second commit to review
   D8387 - created - d235829e802c: 3: a commit with no detailed message
   updating local commit list for D8387
   new commits: ['602c4e738243', '832553266fe8', '921f8265efbd']
   saved backup bundle to $TESTTMP/folded/.hg/strip-backup/a959a3f69d8d-a4a24136-phabsend.hg
 
 ... and doesn't mangle the local commits.
 
   $ hg log -T '{rev}:{node|short}\n{indent(desc, "  ")}\n'
   3:921f8265efbd
     3: a commit with no detailed message
   
     Differential Revision: https://phab.mercurial-scm.org/D8387
   2:832553266fe8
     two: second commit to review
   
     This file was modified with 'mod2' as its contents.
   
     Test Plan:
     Haha! yeah, right.
   
     Differential Revision: https://phab.mercurial-scm.org/D8387
   1:602c4e738243
     one: first commit to review
   
     This file was modified with 'mod1' as its contents.
   
     Test Plan:
     LOL!  What testing?!
   
     Differential Revision: https://phab.mercurial-scm.org/D8387
   0:98d480e0d494
     added file
 
 Setup some obsmarkers by adding a file to the middle commit.  This stress tests
 getoldnodedrevmap() in later phabsends.
 
   $ hg up '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 'modified' > file2.txt
   $ hg add file2.txt
   $ hg amend --config experimental.evolution=all --config extensions.amend=
   1 new orphan changesets
   $ hg up 3
   obsolete feature not enabled but 1 markers found!
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg rebase --config experimental.evolution=all --config extensions.rebase=
   note: not rebasing 2:832553266fe8 "two: second commit to review", already in destination as 4:0124e5474c88 "two: second commit to review" (tip)
   rebasing 3:921f8265efbd "3: a commit with no detailed message"
 
 When commits have changed locally, the local commit list on Phabricator is
 updated.
 
   $ echo y | hg phabsend --fold --confirm -r 1:: \
   >          --test-vcr "$VCR/phabsend-fold-updated.json"
   obsolete feature not enabled but 2 markers found!
   602c4e738243 mapped to old nodes ['602c4e738243']
   0124e5474c88 mapped to old nodes ['832553266fe8']
   e4edb1fe3565 mapped to old nodes ['921f8265efbd']
   D8387 - 602c4e738243: one: first commit to review
   D8387 - 0124e5474c88: two: second commit to review
   D8387 - e4edb1fe3565: 3: a commit with no detailed message
   Send the above changes to https://phab.mercurial-scm.org/ (Y/n)? y
   D8387 - updated - 602c4e738243: one: first commit to review
   D8387 - updated - 0124e5474c88: two: second commit to review
   D8387 - updated - e4edb1fe3565: 3: a commit with no detailed message
   obsolete feature not enabled but 2 markers found! (?)
   updating local commit list for D8387
   new commits: ['602c4e738243', '0124e5474c88', 'e4edb1fe3565']
   $ hg log -Tcompact
   obsolete feature not enabled but 2 markers found!
   5[tip]   e4edb1fe3565   1970-01-01 00:00 +0000   test
     3: a commit with no detailed message
   
   4:1   0124e5474c88   1970-01-01 00:00 +0000   test
     two: second commit to review
   
   1   602c4e738243   1970-01-01 00:00 +0000   test
     one: first commit to review
   
   0   98d480e0d494   1970-01-01 00:00 +0000   test
     added file
   
 When nothing has changed locally since the last phabsend, the commit list isn't
 updated, and nothing is changed locally afterward.
 
   $ hg phabsend --fold -r 1:: --test-vcr "$VCR/phabsend-fold-no-changes.json"
   obsolete feature not enabled but 2 markers found!
   602c4e738243 mapped to old nodes ['602c4e738243']
   0124e5474c88 mapped to old nodes ['0124e5474c88']
   e4edb1fe3565 mapped to old nodes ['e4edb1fe3565']
   D8387 - updated - 602c4e738243: one: first commit to review
   D8387 - updated - 0124e5474c88: two: second commit to review
   D8387 - updated - e4edb1fe3565: 3: a commit with no detailed message
   obsolete feature not enabled but 2 markers found! (?)
   local commit list for D8387 is already up-to-date
   $ hg log -Tcompact
   obsolete feature not enabled but 2 markers found!
   5[tip]   e4edb1fe3565   1970-01-01 00:00 +0000   test
     3: a commit with no detailed message
   
   4:1   0124e5474c88   1970-01-01 00:00 +0000   test
     two: second commit to review
   
   1   602c4e738243   1970-01-01 00:00 +0000   test
     one: first commit to review
   
   0   98d480e0d494   1970-01-01 00:00 +0000   test
     added file
   
 Fold will accept new revisions at the end...
 
   $ echo 'another mod' > file2.txt
   $ hg ci -m 'four: extend the fold range'
   obsolete feature not enabled but 2 markers found!
   $ hg phabsend --fold -r 1:: --test-vcr "$VCR/phabsend-fold-extend-end.json" \
   >             --config experimental.evolution=all
   602c4e738243 mapped to old nodes ['602c4e738243']
   0124e5474c88 mapped to old nodes ['0124e5474c88']
   e4edb1fe3565 mapped to old nodes ['e4edb1fe3565']
   D8387 - updated - 602c4e738243: one: first commit to review
   D8387 - updated - 0124e5474c88: two: second commit to review
   D8387 - updated - e4edb1fe3565: 3: a commit with no detailed message
   D8387 - created - 94aaae213b23: four: extend the fold range
   updating local commit list for D8387
   new commits: ['602c4e738243', '0124e5474c88', 'e4edb1fe3565', '51a04fea8707']
   $ hg log -r . -T '{desc}\n'
   four: extend the fold range
   
   Differential Revision: https://phab.mercurial-scm.org/D8387
   $ hg log -T'{rev} {if(phabreview, "{phabreview.url} {phabreview.id}")}\n' -r 1::
   obsolete feature not enabled but 3 markers found!
   1 https://phab.mercurial-scm.org/D8387 D8387
   4 https://phab.mercurial-scm.org/D8387 D8387
   5 https://phab.mercurial-scm.org/D8387 D8387
   7 https://phab.mercurial-scm.org/D8387 D8387
 
 ... and also accepts new revisions at the beginning of the range
 
 It's a bit unfortunate that not having a Differential URL on the first commit
 causes a new Differential Revision to be created, though it isn't *entirely*
 unreasonable.  At least this updates the subsequent commits.
 
 TODO: See if it can reuse the existing Differential.
 
   $ hg phabsend --fold -r 0:: --test-vcr "$VCR/phabsend-fold-extend-front.json" \
   >             --config experimental.evolution=all
   602c4e738243 mapped to old nodes ['602c4e738243']
   0124e5474c88 mapped to old nodes ['0124e5474c88']
   e4edb1fe3565 mapped to old nodes ['e4edb1fe3565']
   51a04fea8707 mapped to old nodes ['51a04fea8707']
   D8388 - created - 98d480e0d494: added file
   D8388 - updated - 602c4e738243: one: first commit to review
   D8388 - updated - 0124e5474c88: two: second commit to review
   D8388 - updated - e4edb1fe3565: 3: a commit with no detailed message
   D8388 - updated - 51a04fea8707: four: extend the fold range
   updating local commit list for D8388
   new commits: ['15e9b14b4b4c', '6320b7d714cf', '3ee132d41dbc', '30682b960804', 'ac7db67f0991']
 
   $ hg log -T '{rev}:{node|short}\n{indent(desc, "  ")}\n'
   obsolete feature not enabled but 8 markers found!
   12:ac7db67f0991
     four: extend the fold range
   
     Differential Revision: https://phab.mercurial-scm.org/D8388
   11:30682b960804
     3: a commit with no detailed message
   
     Differential Revision: https://phab.mercurial-scm.org/D8388
   10:3ee132d41dbc
     two: second commit to review
   
     This file was modified with 'mod2' as its contents.
   
     Test Plan:
     Haha! yeah, right.
   
     Differential Revision: https://phab.mercurial-scm.org/D8388
   9:6320b7d714cf
     one: first commit to review
   
     This file was modified with 'mod1' as its contents.
   
     Test Plan:
     LOL!  What testing?!
   
     Differential Revision: https://phab.mercurial-scm.org/D8388
   8:15e9b14b4b4c
     added file
   
     Differential Revision: https://phab.mercurial-scm.org/D8388
 
 Test phabsend --fold with an `hg split` at the end of the range
 
   $ echo foo > file3.txt
   $ hg add file3.txt
 
   $ hg log -r . -T '{desc}' > log.txt
   $ echo 'amended mod' > file2.txt
   $ hg ci --amend -l log.txt --config experimental.evolution=all
 
   $ cat <<EOF | hg --config extensions.split= --config ui.interactive=True \
   >                --config experimental.evolution=all split -r .
   > n
   > y
   > y
   > y
   > y
   > EOF
   diff --git a/file2.txt b/file2.txt
   1 hunks, 1 lines changed
   examine changes to 'file2.txt'?
   (enter ? for help) [Ynesfdaq?] n
   
   diff --git a/file3.txt b/file3.txt
   new file mode 100644
   examine changes to 'file3.txt'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -0,0 +1,1 @@
   +foo
   record change 2/2 to 'file3.txt'?
   (enter ? for help) [Ynesfdaq?] y
   
   created new head
   diff --git a/file2.txt b/file2.txt
   1 hunks, 1 lines changed
   examine changes to 'file2.txt'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -1,1 +1,1 @@
   -modified
   +amended mod
   record this change to 'file2.txt'?
   (enter ? for help) [Ynesfdaq?] y
   
   $ hg phabsend --fold -r 8:: --test-vcr "$VCR/phabsend-fold-split-end.json" \
   >             --config experimental.evolution=all
   15e9b14b4b4c mapped to old nodes ['15e9b14b4b4c']
   6320b7d714cf mapped to old nodes ['6320b7d714cf']
   3ee132d41dbc mapped to old nodes ['3ee132d41dbc']
   30682b960804 mapped to old nodes ['30682b960804']
   6bc15dc99efd mapped to old nodes ['ac7db67f0991']
   b50946d5e490 mapped to old nodes ['ac7db67f0991']
   D8388 - updated - 15e9b14b4b4c: added file
   D8388 - updated - 6320b7d714cf: one: first commit to review
   D8388 - updated - 3ee132d41dbc: two: second commit to review
   D8388 - updated - 30682b960804: 3: a commit with no detailed message
   D8388 - updated - 6bc15dc99efd: four: extend the fold range
   D8388 - updated - b50946d5e490: four: extend the fold range
   updating local commit list for D8388
   new commits: ['15e9b14b4b4c', '6320b7d714cf', '3ee132d41dbc', '30682b960804', '6bc15dc99efd', 'b50946d5e490']
 
 Test phabsend --fold with an `hg fold` at the end of the range
 
   $ hg --config experimental.evolution=all --config extensions.rebase= \
   >    rebase -r '.^' -r . -d '.^^' --collapse -l log.txt
   rebasing 14:6bc15dc99efd "four: extend the fold range"
   rebasing 15:b50946d5e490 "four: extend the fold range" (tip)
 
   $ hg phabsend --fold -r 8:: --test-vcr "$VCR/phabsend-fold-fold-end.json" \
   >             --config experimental.evolution=all
   15e9b14b4b4c mapped to old nodes ['15e9b14b4b4c']
   6320b7d714cf mapped to old nodes ['6320b7d714cf']
   3ee132d41dbc mapped to old nodes ['3ee132d41dbc']
   30682b960804 mapped to old nodes ['30682b960804']
   e919cdf3d4fe mapped to old nodes ['6bc15dc99efd', 'b50946d5e490']
   D8388 - updated - 15e9b14b4b4c: added file
   D8388 - updated - 6320b7d714cf: one: first commit to review
   D8388 - updated - 3ee132d41dbc: two: second commit to review
   D8388 - updated - 30682b960804: 3: a commit with no detailed message
   D8388 - updated - e919cdf3d4fe: four: extend the fold range
   updating local commit list for D8388
   new commits: ['15e9b14b4b4c', '6320b7d714cf', '3ee132d41dbc', '30682b960804', 'e919cdf3d4fe']
 
   $ hg log -r tip -v
   obsolete feature not enabled but 12 markers found!
   changeset:   16:e919cdf3d4fe
   tag:         tip
   parent:      11:30682b960804
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       file2.txt file3.txt
   description:
   four: extend the fold range
   
   Differential Revision: https://phab.mercurial-scm.org/D8388
   
   
 
   $ cd ..