brancing: merge stable into default

hgext/highlight/__init__.py

@@ -1,108 +1,108
 # highlight - syntax highlighting in hgweb, based on Pygments
 #
 #  Copyright 2008, 2009 Patrick Mezard <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 #
 # The original module was split in an interface and an implementation
 # file to defer pygments loading and speedup extension setup.
 
 """syntax highlighting for hgweb (requires Pygments)
 
 It depends on the Pygments syntax highlighting library:
 http://pygments.org/
 
 There are the following configuration options::
 
   [web]
   pygments_style = <style> (default: colorful)
   highlightfiles = <fileset> (default: size('<5M'))
   highlightonlymatchfilename = <bool> (default False)
 
 ``highlightonlymatchfilename`` will only highlight files if their type could
 be identified by their filename. When this is not enabled (the default),
 Pygments will try very hard to identify the file type from content and any
 match (even matches with a low confidence score) will be used.
 """
 
 
 from . import highlight
 from mercurial.hgweb import (
     webcommands,
     webutil,
 )
 
 from mercurial import (
     extensions,
     pycompat,
 )
 
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
 testedwith = b'ships-with-hg-core'
 
 
 def pygmentize(web, field, fctx, tmpl):
     style = web.config(b'web', b'pygments_style', b'colorful')
     expr = web.config(b'web', b'highlightfiles', b"size('<5M')")
     filenameonly = web.configbool(b'web', b'highlightonlymatchfilename', False)
 
     ctx = fctx.changectx()
     m = ctx.matchfileset(fctx.repo().root, expr)
     if m(fctx.path()):
         highlight.pygmentize(
             field, fctx, style, tmpl, guessfilenameonly=filenameonly
         )
 
 
 def filerevision_highlight(orig, web, fctx):
     mt = web.res.headers[b'Content-Type']
     # only pygmentize for mimetype containing 'html' so we both match
     # 'text/html' and possibly 'application/xhtml+xml' in the future
     # so that we don't have to touch the extension when the mimetype
     # for a template changes; also hgweb optimizes the case that a
     # raw file is sent using rawfile() and doesn't call us, so we
     # can't clash with the file's content-type here in case we
     # pygmentize a html file
     if b'html' in mt:
         pygmentize(web, b'fileline', fctx, web.tmpl)
 
     return orig(web, fctx)
 
 
 def annotate_highlight(orig, web):
     mt = web.res.headers[b'Content-Type']
     if b'html' in mt:
         fctx = webutil.filectx(web.repo, web.req)
         pygmentize(web, b'annotateline', fctx, web.tmpl)
 
     return orig(web)
 
 
 def generate_css(web):
     pg_style = web.config(b'web', b'pygments_style', b'colorful')
     fmter = highlight.HtmlFormatter(style=pycompat.sysstr(pg_style))
     web.res.headers[b'Content-Type'] = b'text/css'
     style_defs = fmter.get_style_defs(pycompat.sysstr(b''))
     web.res.setbodybytes(
         b''.join(
             [
                 b'/* pygments_style = %s */\n\n' % pg_style,
                 pycompat.bytestr(style_defs),
             ]
         )
     )
     return web.res.sendresponse()
 
 
 def extsetup(ui):
     # monkeypatch in the new version
     extensions.wrapfunction(
         webcommands, '_filerevision', filerevision_highlight
     )
     extensions.wrapfunction(webcommands, 'annotate', annotate_highlight)
     webcommands.highlightcss = generate_css
-    webcommands.__all__.append(b'highlightcss')
+    webcommands.__all__.append('highlightcss')

hgext/histedit.py

@@ -1,2685 +1,2685
 # histedit.py - interactive history editing for mercurial
 #
 # Copyright 2009 Augie Fackler <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 """interactive history editing
 
 With this extension installed, Mercurial gains one new command: histedit. Usage
 is as follows, assuming the following history::
 
  @  3[tip]   7c2fd3b9020c   2009-04-27 18:04 -0500   durin42
  |    Add delta
  |
  o  2   030b686bedc4   2009-04-27 18:04 -0500   durin42
  |    Add gamma
  |
  o  1   c561b4e977df   2009-04-27 18:04 -0500   durin42
  |    Add beta
  |
  o  0   d8d2fcd0e319   2009-04-27 18:04 -0500   durin42
       Add alpha
 
 If you were to run ``hg histedit c561b4e977df``, you would see the following
 file open in your editor::
 
  pick c561b4e977df Add beta
  pick 030b686bedc4 Add gamma
  pick 7c2fd3b9020c Add delta
 
  # Edit history between c561b4e977df and 7c2fd3b9020c
  #
  # Commits are listed from least to most recent
  #
  # Commands:
  #  p, pick = use commit
  #  e, edit = use commit, but allow edits before making new commit
  #  f, fold = use commit, but combine it with the one above
  #  r, roll = like fold, but discard this commit's description and date
  #  d, drop = remove commit from history
  #  m, mess = edit commit message without changing commit content
  #  b, base = checkout changeset and apply further changesets from there
  #
 
 In this file, lines beginning with ``#`` are ignored. You must specify a rule
 for each revision in your history. For example, if you had meant to add gamma
 before beta, and then wanted to add delta in the same revision as beta, you
 would reorganize the file to look like this::
 
  pick 030b686bedc4 Add gamma
  pick c561b4e977df Add beta
  fold 7c2fd3b9020c Add delta
 
  # Edit history between c561b4e977df and 7c2fd3b9020c
  #
  # Commits are listed from least to most recent
  #
  # Commands:
  #  p, pick = use commit
  #  e, edit = use commit, but allow edits before making new commit
  #  f, fold = use commit, but combine it with the one above
  #  r, roll = like fold, but discard this commit's description and date
  #  d, drop = remove commit from history
  #  m, mess = edit commit message without changing commit content
  #  b, base = checkout changeset and apply further changesets from there
  #
 
 At which point you close the editor and ``histedit`` starts working. When you
 specify a ``fold`` operation, ``histedit`` will open an editor when it folds
 those revisions together, offering you a chance to clean up the commit message::
 
  Add beta
  ***
  Add delta
 
 Edit the commit message to your liking, then close the editor. The date used
 for the commit will be the later of the two commits' dates. For this example,
 let's assume that the commit message was changed to ``Add beta and delta.``
 After histedit has run and had a chance to remove any old or temporary
 revisions it needed, the history looks like this::
 
  @  2[tip]   989b4d060121   2009-04-27 18:04 -0500   durin42
  |    Add beta and delta.
  |
  o  1   081603921c3f   2009-04-27 18:04 -0500   durin42
  |    Add gamma
  |
  o  0   d8d2fcd0e319   2009-04-27 18:04 -0500   durin42
       Add alpha
 
 Note that ``histedit`` does *not* remove any revisions (even its own temporary
 ones) until after it has completed all the editing operations, so it will
 probably perform several strip operations when it's done. For the above example,
 it had to run strip twice. Strip can be slow depending on a variety of factors,
 so you might need to be a little patient. You can choose to keep the original
 revisions by passing the ``--keep`` flag.
 
 The ``edit`` operation will drop you back to a command prompt,
 allowing you to edit files freely, or even use ``hg record`` to commit
 some changes as a separate commit. When you're done, any remaining
 uncommitted changes will be committed as well. When done, run ``hg
 histedit --continue`` to finish this step. If there are uncommitted
 changes, you'll be prompted for a new commit message, but the default
 commit message will be the original message for the ``edit`` ed
 revision, and the date of the original commit will be preserved.
 
 The ``message`` operation will give you a chance to revise a commit
 message without changing the contents. It's a shortcut for doing
 ``edit`` immediately followed by `hg histedit --continue``.
 
 If ``histedit`` encounters a conflict when moving a revision (while
 handling ``pick`` or ``fold``), it'll stop in a similar manner to
 ``edit`` with the difference that it won't prompt you for a commit
 message when done. If you decide at this point that you don't like how
 much work it will be to rearrange history, or that you made a mistake,
 you can use ``hg histedit --abort`` to abandon the new changes you
 have made and return to the state before you attempted to edit your
 history.
 
 If we clone the histedit-ed example repository above and add four more
 changes, such that we have the following history::
 
    @  6[tip]   038383181893   2009-04-27 18:04 -0500   stefan
    |    Add theta
    |
    o  5   140988835471   2009-04-27 18:04 -0500   stefan
    |    Add eta
    |
    o  4   122930637314   2009-04-27 18:04 -0500   stefan
    |    Add zeta
    |
    o  3   836302820282   2009-04-27 18:04 -0500   stefan
    |    Add epsilon
    |
    o  2   989b4d060121   2009-04-27 18:04 -0500   durin42
    |    Add beta and delta.
    |
    o  1   081603921c3f   2009-04-27 18:04 -0500   durin42
    |    Add gamma
    |
    o  0   d8d2fcd0e319   2009-04-27 18:04 -0500   durin42
         Add alpha
 
 If you run ``hg histedit --outgoing`` on the clone then it is the same
 as running ``hg histedit 836302820282``. If you need plan to push to a
 repository that Mercurial does not detect to be related to the source
 repo, you can add a ``--force`` option.
 
 Config
 ------
 
 Histedit rule lines are truncated to 80 characters by default. You
 can customize this behavior by setting a different length in your
 configuration file::
 
   [histedit]
   linelen = 120      # truncate rule lines at 120 characters
 
 The summary of a change can be customized as well::
 
   [histedit]
   summary-template = '{rev} {bookmarks} {desc|firstline}'
 
 The customized summary should be kept short enough that rule lines
 will fit in the configured line length. See above if that requires
 customization.
 
 ``hg histedit`` attempts to automatically choose an appropriate base
 revision to use. To change which base revision is used, define a
 revset in your configuration file::
 
   [histedit]
   defaultrev = only(.) & draft()
 
 By default each edited revision needs to be present in histedit commands.
 To remove revision you need to use ``drop`` operation. You can configure
 the drop to be implicit for missing commits by adding::
 
   [histedit]
   dropmissing = True
 
 By default, histedit will close the transaction after each action. For
 performance purposes, you can configure histedit to use a single transaction
 across the entire histedit. WARNING: This setting introduces a significant risk
 of losing the work you've done in a histedit if the histedit aborts
 unexpectedly::
 
   [histedit]
   singletransaction = True
 
 """
 
 
 # chistedit dependencies that are not available everywhere
 try:
     import fcntl
     import termios
 except ImportError:
     fcntl = None
     termios = None
 
 import binascii
 import functools
 import os
 import pickle
 import struct
 
 from mercurial.i18n import _
 from mercurial.pycompat import (
     open,
 )
 from mercurial.node import (
     bin,
     hex,
     short,
 )
 from mercurial import (
     bundle2,
     cmdutil,
     context,
     copies,
     destutil,
     discovery,
     encoding,
     error,
     exchange,
     extensions,
     hg,
     logcmdutil,
     merge as mergemod,
     mergestate as mergestatemod,
     mergeutil,
     obsolete,
     pycompat,
     registrar,
     repair,
     rewriteutil,
     scmutil,
     state as statemod,
     util,
 )
 from mercurial.utils import (
     dateutil,
     stringutil,
     urlutil,
 )
 
 cmdtable = {}
 command = registrar.command(cmdtable)
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 configitem(
     b'experimental',
     b'histedit.autoverb',
     default=False,
 )
 configitem(
     b'histedit',
     b'defaultrev',
     default=None,
 )
 configitem(
     b'histedit',
     b'dropmissing',
     default=False,
 )
 configitem(
     b'histedit',
     b'linelen',
     default=80,
 )
 configitem(
     b'histedit',
     b'singletransaction',
     default=False,
 )
 configitem(
     b'ui',
     b'interface.histedit',
     default=None,
 )
 configitem(b'histedit', b'summary-template', default=b'{rev} {desc|firstline}')
 # TODO: Teach the text-based histedit interface to respect this config option
 # before we make it non-experimental.
 configitem(
     b'histedit', b'later-commits-first', default=False, experimental=True
 )
 
 # 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'
 
 actiontable = {}
 primaryactions = set()
 secondaryactions = set()
 tertiaryactions = set()
 internalactions = set()
 
 
 def geteditcomment(ui, first, last):
     """construct the editor comment
     The comment includes::
      - an intro
      - sorted primary commands
      - sorted short commands
      - sorted long commands
      - additional hints
 
     Commands are only included once.
     """
     intro = _(
         b"""Edit history between %s and %s
 
 Commits are listed from least to most recent
 
 You can reorder changesets by reordering the lines
 
 Commands:
 """
     )
     actions = []
 
     def addverb(v):
         a = actiontable[v]
         lines = a.message.split(b"\n")
         if len(a.verbs):
             v = b', '.join(sorted(a.verbs, key=lambda v: len(v)))
         actions.append(b" %s = %s" % (v, lines[0]))
         actions.extend([b'  %s'] * (len(lines) - 1))
 
     for v in (
         sorted(primaryactions)
         + sorted(secondaryactions)
         + sorted(tertiaryactions)
     ):
         addverb(v)
     actions.append(b'')
 
     hints = []
     if ui.configbool(b'histedit', b'dropmissing'):
         hints.append(
             b"Deleting a changeset from the list "
             b"will DISCARD it from the edited history!"
         )
 
     lines = (intro % (first, last)).split(b'\n') + actions + hints
 
     return b''.join([b'# %s\n' % l if l else b'#\n' for l in lines])
 
 
 class histeditstate:
     def __init__(self, repo):
         self.repo = repo
         self.actions = None
         self.keep = None
         self.topmost = None
         self.parentctxnode = None
         self.lock = None
         self.wlock = None
         self.backupfile = None
         self.stateobj = statemod.cmdstate(repo, b'histedit-state')
         self.replacements = []
 
     def read(self):
         """Load histedit state from disk and set fields appropriately."""
         if not self.stateobj.exists():
             cmdutil.wrongtooltocontinue(self.repo, _(b'histedit'))
 
         data = self._read()
 
         self.parentctxnode = data[b'parentctxnode']
         actions = parserules(data[b'rules'], self)
         self.actions = actions
         self.keep = data[b'keep']
         self.topmost = data[b'topmost']
         self.replacements = data[b'replacements']
         self.backupfile = data[b'backupfile']
 
     def _read(self):
         fp = self.repo.vfs.read(b'histedit-state')
         if fp.startswith(b'v1\n'):
             data = self._load()
             parentctxnode, rules, keep, topmost, replacements, backupfile = data
         else:
             data = pickle.loads(fp)
             parentctxnode, rules, keep, topmost, replacements = data
             backupfile = None
         rules = b"\n".join([b"%s %s" % (verb, rest) for [verb, rest] in rules])
 
         return {
             b'parentctxnode': parentctxnode,
             b"rules": rules,
             b"keep": keep,
             b"topmost": topmost,
             b"replacements": replacements,
             b"backupfile": backupfile,
         }
 
     def write(self, tr=None):
         if tr:
             tr.addfilegenerator(
                 b'histedit-state',
                 (b'histedit-state',),
                 self._write,
                 location=b'plain',
             )
         else:
             with self.repo.vfs(b"histedit-state", b"w") as f:
                 self._write(f)
 
     def _write(self, fp):
         fp.write(b'v1\n')
         fp.write(b'%s\n' % hex(self.parentctxnode))
         fp.write(b'%s\n' % hex(self.topmost))
         fp.write(b'%s\n' % (b'True' if self.keep else b'False'))
         fp.write(b'%d\n' % len(self.actions))
         for action in self.actions:
             fp.write(b'%s\n' % action.tostate())
         fp.write(b'%d\n' % len(self.replacements))
         for replacement in self.replacements:
             fp.write(
                 b'%s%s\n'
                 % (
                     hex(replacement[0]),
                     b''.join(hex(r) for r in replacement[1]),
                 )
             )
         backupfile = self.backupfile
         if not backupfile:
             backupfile = b''
         fp.write(b'%s\n' % backupfile)
 
     def _load(self):
         fp = self.repo.vfs(b'histedit-state', b'r')
         lines = [l[:-1] for l in fp.readlines()]
 
         index = 0
         lines[index]  # version number
         index += 1
 
         parentctxnode = bin(lines[index])
         index += 1
 
         topmost = bin(lines[index])
         index += 1
 
         keep = lines[index] == b'True'
         index += 1
 
         # Rules
         rules = []
         rulelen = int(lines[index])
         index += 1
         for i in range(rulelen):
             ruleaction = lines[index]
             index += 1
             rule = lines[index]
             index += 1
             rules.append((ruleaction, rule))
 
         # Replacements
         replacements = []
         replacementlen = int(lines[index])
         index += 1
         for i in range(replacementlen):
             replacement = lines[index]
             original = bin(replacement[:40])
             succ = [
                 bin(replacement[i : i + 40])
                 for i in range(40, len(replacement), 40)
             ]
             replacements.append((original, succ))
             index += 1
 
         backupfile = lines[index]
         index += 1
 
         fp.close()
 
         return parentctxnode, rules, keep, topmost, replacements, backupfile
 
     def clear(self):
         if self.inprogress():
             self.repo.vfs.unlink(b'histedit-state')
 
     def inprogress(self):
         return self.repo.vfs.exists(b'histedit-state')
 
 
 class histeditaction:
     def __init__(self, state, node):
         self.state = state
         self.repo = state.repo
         self.node = node
 
     @classmethod
     def fromrule(cls, state, rule):
         """Parses the given rule, returning an instance of the histeditaction."""
         ruleid = rule.strip().split(b' ', 1)[0]
         # ruleid can be anything from rev numbers, hashes, "bookmarks" etc
         # Check for validation of rule ids and get the rulehash
         try:
             rev = bin(ruleid)
         except binascii.Error:
             try:
                 _ctx = scmutil.revsingle(state.repo, ruleid)
                 rulehash = _ctx.hex()
                 rev = bin(rulehash)
             except error.RepoLookupError:
                 raise error.ParseError(_(b"invalid changeset %s") % ruleid)
         return cls(state, rev)
 
     def verify(self, prev, expected, seen):
         """Verifies semantic correctness of the rule"""
         repo = self.repo
         ha = hex(self.node)
         self.node = scmutil.resolvehexnodeidprefix(repo, ha)
         if self.node is None:
             raise error.ParseError(_(b'unknown changeset %s listed') % ha[:12])
         self._verifynodeconstraints(prev, expected, seen)
 
     def _verifynodeconstraints(self, prev, expected, seen):
         # by default command need a node in the edited list
         if self.node not in expected:
             raise error.ParseError(
                 _(b'%s "%s" changeset was not a candidate')
                 % (self.verb, short(self.node)),
                 hint=_(b'only use listed changesets'),
             )
         # and only one command per node
         if self.node in seen:
             raise error.ParseError(
                 _(b'duplicated command for changeset %s') % short(self.node)
             )
 
     def torule(self):
         """build a histedit rule line for an action
 
         by default lines are in the form:
         <hash> <rev> <summary>
         """
         ctx = self.repo[self.node]
         ui = self.repo.ui
         # We don't want color codes in the commit message template, so
         # disable the label() template function while we render it.
         with ui.configoverride(
             {(b'templatealias', b'label(l,x)'): b"x"}, b'histedit'
         ):
             summary = cmdutil.rendertemplate(
                 ctx, ui.config(b'histedit', b'summary-template')
             )
         line = b'%s %s %s' % (self.verb, ctx, stringutil.firstline(summary))
         # trim to 75 columns by default so it's not stupidly wide in my editor
         # (the 5 more are left for verb)
         maxlen = self.repo.ui.configint(b'histedit', b'linelen')
         maxlen = max(maxlen, 22)  # avoid truncating hash
         return stringutil.ellipsis(line, maxlen)
 
     def tostate(self):
         """Print an action in format used by histedit state files
         (the first line is a verb, the remainder is the second)
         """
         return b"%s\n%s" % (self.verb, hex(self.node))
 
     def run(self):
         """Runs the action. The default behavior is simply apply the action's
         rulectx onto the current parentctx."""
         self.applychange()
         self.continuedirty()
         return self.continueclean()
 
     def applychange(self):
         """Applies the changes from this action's rulectx onto the current
         parentctx, but does not commit them."""
         repo = self.repo
         rulectx = repo[self.node]
         with repo.ui.silent():
             hg.update(repo, self.state.parentctxnode, quietempty=True)
         stats = applychanges(repo.ui, repo, rulectx, {})
         repo.dirstate.setbranch(rulectx.branch(), repo.currenttransaction())
         if stats.unresolvedcount:
             raise error.InterventionRequired(
                 _(b'Fix up the change (%s %s)') % (self.verb, short(self.node)),
                 hint=_(b'hg histedit --continue to resume'),
             )
 
     def continuedirty(self):
         """Continues the action when changes have been applied to the working
         copy. The default behavior is to commit the dirty changes."""
         repo = self.repo
         rulectx = repo[self.node]
 
         editor = self.commiteditor()
         commit = commitfuncfor(repo, rulectx)
         if repo.ui.configbool(b'rewrite', b'update-timestamp'):
             date = dateutil.makedate()
         else:
             date = rulectx.date()
         commit(
             text=rulectx.description(),
             user=rulectx.user(),
             date=date,
             extra=rulectx.extra(),
             editor=editor,
         )
 
     def commiteditor(self):
         """The editor to be used to edit the commit message."""
         return False
 
     def continueclean(self):
         """Continues the action when the working copy is clean. The default
         behavior is to accept the current commit as the new version of the
         rulectx."""
         ctx = self.repo[b'.']
         if ctx.node() == self.state.parentctxnode:
             self.repo.ui.warn(
                 _(b'%s: skipping changeset (no changes)\n') % short(self.node)
             )
             return ctx, [(self.node, tuple())]
         if ctx.node() == self.node:
             # Nothing changed
             return ctx, []
         return ctx, [(self.node, (ctx.node(),))]
 
 
 def commitfuncfor(repo, src):
     """Build a commit function for the replacement of <src>
 
     This function ensure we apply the same treatment to all changesets.
 
     - Add a 'histedit_source' entry in extra.
 
     Note that fold has its own separated logic because its handling is a bit
     different and not easily factored out of the fold method.
     """
     phasemin = src.phase()
 
     def commitfunc(**kwargs):
         overrides = {(b'phases', b'new-commit'): phasemin}
         with repo.ui.configoverride(overrides, b'histedit'):
             extra = kwargs.get('extra', {}).copy()
             extra[b'histedit_source'] = src.hex()
             kwargs['extra'] = extra
             return repo.commit(**kwargs)
 
     return commitfunc
 
 
 def applychanges(ui, repo, ctx, opts):
     """Merge changeset from ctx (only) in the current working directory"""
     if ctx.p1().node() == repo.dirstate.p1():
         # edits are "in place" we do not need to make any merge,
         # just applies changes on parent for editing
         with ui.silent():
             cmdutil.revert(ui, repo, ctx, all=True)
             stats = mergemod.updateresult(0, 0, 0, 0)
     else:
         try:
             # ui.forcemerge is an internal variable, do not document
             repo.ui.setconfig(
                 b'ui', b'forcemerge', opts.get(b'tool', b''), b'histedit'
             )
             stats = mergemod.graft(
                 repo,
                 ctx,
                 labels=[
                     b'already edited',
                     b'current change',
                     b'parent of current change',
                 ],
             )
         finally:
             repo.ui.setconfig(b'ui', b'forcemerge', b'', b'histedit')
     return stats
 
 
 def collapse(repo, firstctx, lastctx, commitopts, skipprompt=False):
     """collapse the set of revisions from first to last as new one.
 
     Expected commit options are:
         - message
         - date
         - username
     Commit message is edited in all cases.
 
     This function works in memory."""
     ctxs = list(repo.set(b'%d::%d', firstctx.rev(), lastctx.rev()))
     if not ctxs:
         return None
     for c in ctxs:
         if not c.mutable():
             raise error.ParseError(
                 _(b"cannot fold into public change %s") % short(c.node())
             )
     base = firstctx.p1()
 
     # commit a new version of the old changeset, including the update
     # collect all files which might be affected
     files = set()
     for ctx in ctxs:
         files.update(ctx.files())
 
     # Recompute copies (avoid recording a -> b -> a)
     copied = copies.pathcopies(base, lastctx)
 
     # prune files which were reverted by the updates
     files = [f for f in files if not cmdutil.samefile(f, lastctx, base)]
     # commit version of these files as defined by head
     headmf = lastctx.manifest()
 
     def filectxfn(repo, ctx, path):
         if path in headmf:
             fctx = lastctx[path]
             flags = fctx.flags()
             mctx = context.memfilectx(
                 repo,
                 ctx,
                 fctx.path(),
                 fctx.data(),
                 islink=b'l' in flags,
                 isexec=b'x' in flags,
                 copysource=copied.get(path),
             )
             return mctx
         return None
 
     if commitopts.get(b'message'):
         message = commitopts[b'message']
     else:
         message = firstctx.description()
     user = commitopts.get(b'user')
     date = commitopts.get(b'date')
     extra = commitopts.get(b'extra')
 
     parents = (firstctx.p1().node(), firstctx.p2().node())
     editor = None
     if not skipprompt:
         editor = cmdutil.getcommiteditor(edit=True, editform=b'histedit.fold')
     new = context.memctx(
         repo,
         parents=parents,
         text=message,
         files=files,
         filectxfn=filectxfn,
         user=user,
         date=date,
         extra=extra,
         editor=editor,
     )
     return repo.commitctx(new)
 
 
 def _isdirtywc(repo):
     return repo[None].dirty(missing=True)
 
 
 def abortdirty():
     raise error.StateError(
         _(b'working copy has pending changes'),
         hint=_(
             b'amend, commit, or revert them and run histedit '
             b'--continue, or abort with histedit --abort'
         ),
     )
 
 
 def action(verbs, message, priority=False, internal=False):
     def wrap(cls):
         assert not priority or not internal
         verb = verbs[0]
         if priority:
             primaryactions.add(verb)
         elif internal:
             internalactions.add(verb)
         elif len(verbs) > 1:
             secondaryactions.add(verb)
         else:
             tertiaryactions.add(verb)
 
         cls.verb = verb
         cls.verbs = verbs
         cls.message = message
         for verb in verbs:
             actiontable[verb] = cls
         return cls
 
     return wrap
 
 
 @action([b'pick', b'p'], _(b'use commit'), priority=True)
 class pick(histeditaction):
     def run(self):
         rulectx = self.repo[self.node]
         if rulectx.p1().node() == self.state.parentctxnode:
             self.repo.ui.debug(b'node %s unchanged\n' % short(self.node))
             return rulectx, []
 
         return super(pick, self).run()
 
 
 @action(
     [b'edit', b'e'],
     _(b'use commit, but allow edits before making new commit'),
     priority=True,
 )
 class edit(histeditaction):
     def run(self):
         repo = self.repo
         rulectx = repo[self.node]
         hg.update(repo, self.state.parentctxnode, quietempty=True)
         applychanges(repo.ui, repo, rulectx, {})
         hint = _(b'to edit %s, `hg histedit --continue` after making changes')
         raise error.InterventionRequired(
             _(b'Editing (%s), commit as needed now to split the change')
             % short(self.node),
             hint=hint % short(self.node),
         )
 
     def commiteditor(self):
         return cmdutil.getcommiteditor(edit=True, editform=b'histedit.edit')
 
 
 @action([b'fold', b'f'], _(b'use commit, but combine it with the one above'))
 class fold(histeditaction):
     def verify(self, prev, expected, seen):
         """Verifies semantic correctness of the fold rule"""
         super(fold, self).verify(prev, expected, seen)
         repo = self.repo
         if not prev:
             c = repo[self.node].p1()
         elif not prev.verb in (b'pick', b'base'):
             return
         else:
             c = repo[prev.node]
         if not c.mutable():
             raise error.ParseError(
                 _(b"cannot fold into public change %s") % short(c.node())
             )
 
     def continuedirty(self):
         repo = self.repo
         rulectx = repo[self.node]
 
         commit = commitfuncfor(repo, rulectx)
         commit(
             text=b'fold-temp-revision %s' % short(self.node),
             user=rulectx.user(),
             date=rulectx.date(),
             extra=rulectx.extra(),
         )
 
     def continueclean(self):
         repo = self.repo
         ctx = repo[b'.']
         rulectx = repo[self.node]
         parentctxnode = self.state.parentctxnode
         if ctx.node() == parentctxnode:
             repo.ui.warn(_(b'%s: empty changeset\n') % short(self.node))
             return ctx, [(self.node, (parentctxnode,))]
 
         parentctx = repo[parentctxnode]
         newcommits = {
             c.node()
             for c in repo.set(b'(%d::. - %d)', parentctx.rev(), parentctx.rev())
         }
         if not newcommits:
             repo.ui.warn(
                 _(
                     b'%s: cannot fold - working copy is not a '
                     b'descendant of previous commit %s\n'
                 )
                 % (short(self.node), short(parentctxnode))
             )
             return ctx, [(self.node, (ctx.node(),))]
 
         middlecommits = newcommits.copy()
         middlecommits.discard(ctx.node())
 
         return self.finishfold(
             repo.ui, repo, parentctx, rulectx, ctx.node(), middlecommits
         )
 
     def skipprompt(self):
         """Returns true if the rule should skip the message editor.
 
         For example, 'fold' wants to show an editor, but 'rollup'
         doesn't want to.
         """
         return False
 
     def mergedescs(self):
         """Returns true if the rule should merge messages of multiple changes.
 
         This exists mainly so that 'rollup' rules can be a subclass of
         'fold'.
         """
         return True
 
     def firstdate(self):
         """Returns true if the rule should preserve the date of the first
         change.
 
         This exists mainly so that 'rollup' rules can be a subclass of
         'fold'.
         """
         return False
 
     def finishfold(self, ui, repo, ctx, oldctx, newnode, internalchanges):
         mergemod.update(ctx.p1())
         ### prepare new commit data
         commitopts = {}
         commitopts[b'user'] = ctx.user()
         # commit message
         if not self.mergedescs():
             newmessage = ctx.description()
         else:
             newmessage = (
                 b'\n***\n'.join(
                     [ctx.description()]
                     + [repo[r].description() for r in internalchanges]
                     + [oldctx.description()]
                 )
                 + b'\n'
             )
         commitopts[b'message'] = newmessage
         # date
         if self.firstdate():
             commitopts[b'date'] = ctx.date()
         else:
             commitopts[b'date'] = max(ctx.date(), oldctx.date())
         # if date is to be updated to current
         if ui.configbool(b'rewrite', b'update-timestamp'):
             commitopts[b'date'] = dateutil.makedate()
 
         extra = ctx.extra().copy()
         # histedit_source
         # note: ctx is likely a temporary commit but that the best we can do
         #       here. This is sufficient to solve issue3681 anyway.
         extra[b'histedit_source'] = b'%s,%s' % (ctx.hex(), oldctx.hex())
         commitopts[b'extra'] = extra
         phasemin = max(ctx.phase(), oldctx.phase())
         overrides = {(b'phases', b'new-commit'): phasemin}
         with repo.ui.configoverride(overrides, b'histedit'):
             n = collapse(
                 repo,
                 ctx,
                 repo[newnode],
                 commitopts,
                 skipprompt=self.skipprompt(),
             )
         if n is None:
             return ctx, []
         mergemod.update(repo[n])
         replacements = [
             (oldctx.node(), (newnode,)),
             (ctx.node(), (n,)),
             (newnode, (n,)),
         ]
         for ich in internalchanges:
             replacements.append((ich, (n,)))
         return repo[n], replacements
 
 
 @action(
     [b'base', b'b'],
     _(b'checkout changeset and apply further changesets from there'),
 )
 class base(histeditaction):
     def run(self):
         if self.repo[b'.'].node() != self.node:
             mergemod.clean_update(self.repo[self.node])
         return self.continueclean()
 
     def continuedirty(self):
         abortdirty()
 
     def continueclean(self):
         basectx = self.repo[b'.']
         return basectx, []
 
     def _verifynodeconstraints(self, prev, expected, seen):
         # base can only be use with a node not in the edited set
         if self.node in expected:
             msg = _(b'%s "%s" changeset was an edited list candidate')
             raise error.ParseError(
                 msg % (self.verb, short(self.node)),
                 hint=_(b'base must only use unlisted changesets'),
             )
 
 
 @action(
     [b'_multifold'],
     _(
         b"""fold subclass used for when multiple folds happen in a row
 
     We only want to fire the editor for the folded message once when
     (say) four changes are folded down into a single change. This is
     similar to rollup, but we should preserve both messages so that
     when the last fold operation runs we can show the user all the
     commit messages in their editor.
     """
     ),
     internal=True,
 )
 class _multifold(fold):
     def skipprompt(self):
         return True
 
 
 @action(
     [b"roll", b"r"],
     _(b"like fold, but discard this commit's description and date"),
 )
 class rollup(fold):
     def mergedescs(self):
         return False
 
     def skipprompt(self):
         return True
 
     def firstdate(self):
         return True
 
 
 @action([b"drop", b"d"], _(b'remove commit from history'))
 class drop(histeditaction):
     def run(self):
         parentctx = self.repo[self.state.parentctxnode]
         return parentctx, [(self.node, tuple())]
 
 
 @action(
     [b"mess", b"m"],
     _(b'edit commit message without changing commit content'),
     priority=True,
 )
 class message(histeditaction):
     def commiteditor(self):
         return cmdutil.getcommiteditor(edit=True, editform=b'histedit.mess')
 
 
 def findoutgoing(ui, repo, remote=None, force=False, opts=None):
     """utility function to find the first outgoing changeset
 
     Used by initialization code"""
     if opts is None:
         opts = {}
     path = urlutil.get_unique_push_path(b'histedit', repo, ui, remote)
 
     ui.status(_(b'comparing with %s\n') % urlutil.hidepassword(path.loc))
 
     revs, checkout = hg.addbranchrevs(repo, repo, (path.branch, []), None)
     other = hg.peer(repo, opts, path)
 
     if revs:
         revs = [repo.lookup(rev) for rev in revs]
 
     outgoing = discovery.findcommonoutgoing(repo, other, revs, force=force)
     if not outgoing.missing:
         raise error.StateError(_(b'no outgoing ancestors'))
     roots = list(repo.revs(b"roots(%ln)", outgoing.missing))
     if len(roots) > 1:
         msg = _(b'there are ambiguous outgoing revisions')
         hint = _(b"see 'hg help histedit' for more detail")
         raise error.StateError(msg, hint=hint)
     return repo[roots[0]].node()
 
 
 # Curses Support
 try:
     import curses
 except ImportError:
     curses = None
 
 KEY_LIST = [b'pick', b'edit', b'fold', b'drop', b'mess', b'roll']
 ACTION_LABELS = {
     b'fold': b'^fold',
     b'roll': b'^roll',
 }
 
 COLOR_HELP, COLOR_SELECTED, COLOR_OK, COLOR_WARN, COLOR_CURRENT = 1, 2, 3, 4, 5
 COLOR_DIFF_ADD_LINE, COLOR_DIFF_DEL_LINE, COLOR_DIFF_OFFSET = 6, 7, 8
 COLOR_ROLL, COLOR_ROLL_CURRENT, COLOR_ROLL_SELECTED = 9, 10, 11
 
 E_QUIT, E_HISTEDIT = 1, 2
 E_PAGEDOWN, E_PAGEUP, E_LINEUP, E_LINEDOWN, E_RESIZE = 3, 4, 5, 6, 7
 MODE_INIT, MODE_PATCH, MODE_RULES, MODE_HELP = 0, 1, 2, 3
 
 KEYTABLE = {
     b'global': {
         b'h': b'next-action',
         b'KEY_RIGHT': b'next-action',
         b'l': b'prev-action',
         b'KEY_LEFT': b'prev-action',
         b'q': b'quit',
         b'c': b'histedit',
         b'C': b'histedit',
         b'v': b'showpatch',
         b'?': b'help',
     },
     MODE_RULES: {
         b'd': b'action-drop',
         b'e': b'action-edit',
         b'f': b'action-fold',
         b'm': b'action-mess',
         b'p': b'action-pick',
         b'r': b'action-roll',
         b' ': b'select',
         b'j': b'down',
         b'k': b'up',
         b'KEY_DOWN': b'down',
         b'KEY_UP': b'up',
         b'J': b'move-down',
         b'K': b'move-up',
         b'KEY_NPAGE': b'move-down',
         b'KEY_PPAGE': b'move-up',
         b'0': b'goto',  # Used for 0..9
     },
     MODE_PATCH: {
         b' ': b'page-down',
         b'KEY_NPAGE': b'page-down',
         b'KEY_PPAGE': b'page-up',
         b'j': b'line-down',
         b'k': b'line-up',
         b'KEY_DOWN': b'line-down',
         b'KEY_UP': b'line-up',
         b'J': b'down',
         b'K': b'up',
     },
     MODE_HELP: {},
 }
 
 
 def screen_size():
     return struct.unpack(b'hh', fcntl.ioctl(1, termios.TIOCGWINSZ, b'    '))
 
 
 class histeditrule:
     def __init__(self, ui, ctx, pos, action=b'pick'):
         self.ui = ui
         self.ctx = ctx
         self.action = action
         self.origpos = pos
         self.pos = pos
         self.conflicts = []
 
     def __bytes__(self):
         # Example display of several histeditrules:
         #
         #  #10 pick   316392:06a16c25c053   add option to skip tests
         #  #11 ^roll  316393:71313c964cc5   <RED>oops a fixup commit</RED>
         #  #12 pick   316394:ab31f3973b0d   include mfbt for mozilla-config.h
         #  #13 ^fold  316395:14ce5803f4c3   fix warnings
         #
         # The carets point to the changeset being folded into ("roll this
         # changeset into the changeset above").
         return b'%s%s' % (self.prefix, self.desc)
 
     __str__ = encoding.strmethod(__bytes__)
 
     @property
     def prefix(self):
         # Some actions ('fold' and 'roll') combine a patch with a
         # previous one. Add a marker showing which patch they apply
         # to.
         action = ACTION_LABELS.get(self.action, self.action)
 
         h = self.ctx.hex()[0:12]
         r = self.ctx.rev()
 
         return b"#%s %s %d:%s   " % (
             (b'%d' % self.origpos).ljust(2),
             action.ljust(6),
             r,
             h,
         )
 
     @util.propertycache
     def desc(self):
         summary = cmdutil.rendertemplate(
             self.ctx, self.ui.config(b'histedit', b'summary-template')
         )
         if summary:
             return summary
         # This is split off from the prefix property so that we can
         # separately make the description for 'roll' red (since it
         # will get discarded).
         return stringutil.firstline(self.ctx.description())
 
     def checkconflicts(self, other):
         if other.pos > self.pos and other.origpos <= self.origpos:
             if set(other.ctx.files()) & set(self.ctx.files()) != set():
                 self.conflicts.append(other)
                 return self.conflicts
 
         if other in self.conflicts:
             self.conflicts.remove(other)
         return self.conflicts
 
 
 def makecommands(rules):
     """Returns a list of commands consumable by histedit --commands based on
     our list of rules"""
     commands = []
     for rules in rules:
         commands.append(b'%s %s\n' % (rules.action, rules.ctx))
     return commands
 
 
 def addln(win, y, x, line, color=None):
     """Add a line to the given window left padding but 100% filled with
     whitespace characters, so that the color appears on the whole line"""
     maxy, maxx = win.getmaxyx()
     length = maxx - 1 - x
     line = bytes(line).ljust(length)[:length]
     if y < 0:
         y = maxy + y
     if x < 0:
         x = maxx + x
     if color:
         win.addstr(y, x, line, color)
     else:
         win.addstr(y, x, line)
 
 
 def _trunc_head(line, n):
     if len(line) <= n:
         return line
     return b'> ' + line[-(n - 2) :]
 
 
 def _trunc_tail(line, n):
     if len(line) <= n:
         return line
     return line[: n - 2] + b' >'
 
 
 class _chistedit_state:
     def __init__(
         self,
         repo,
         rules,
         stdscr,
     ):
         self.repo = repo
         self.rules = rules
         self.stdscr = stdscr
         self.later_on_top = repo.ui.configbool(
             b'histedit', b'later-commits-first'
         )
         # The current item in display order, initialized to point to the top
         # of the screen.
         self.pos = 0
         self.selected = None
         self.mode = (MODE_INIT, MODE_INIT)
         self.page_height = None
         self.modes = {
             MODE_RULES: {
                 b'line_offset': 0,
             },
             MODE_PATCH: {
                 b'line_offset': 0,
             },
         }
 
     def render_commit(self, win):
         """Renders the commit window that shows the log of the current selected
         commit"""
         rule = self.rules[self.display_pos_to_rule_pos(self.pos)]
 
         ctx = rule.ctx
         win.box()
 
         maxy, maxx = win.getmaxyx()
         length = maxx - 3
 
         line = b"changeset: %d:%s" % (ctx.rev(), ctx.hex()[:12])
         win.addstr(1, 1, line[:length])
 
         line = b"user:      %s" % ctx.user()
         win.addstr(2, 1, line[:length])
 
         bms = self.repo.nodebookmarks(ctx.node())
         line = b"bookmark:  %s" % b' '.join(bms)
         win.addstr(3, 1, line[:length])
 
         line = b"summary:   %s" % stringutil.firstline(ctx.description())
         win.addstr(4, 1, line[:length])
 
         line = b"files:     "
         win.addstr(5, 1, line)
         fnx = 1 + len(line)
         fnmaxx = length - fnx + 1
         y = 5
         fnmaxn = maxy - (1 + y) - 1
         files = ctx.files()
         for i, line1 in enumerate(files):
             if len(files) > fnmaxn and i == fnmaxn - 1:
                 win.addstr(y, fnx, _trunc_tail(b','.join(files[i:]), fnmaxx))
                 y = y + 1
                 break
             win.addstr(y, fnx, _trunc_head(line1, fnmaxx))
             y = y + 1
 
         conflicts = rule.conflicts
         if len(conflicts) > 0:
             conflictstr = b','.join(map(lambda r: r.ctx.hex()[:12], conflicts))
             conflictstr = b"changed files overlap with %s" % conflictstr
         else:
             conflictstr = b'no overlap'
 
         win.addstr(y, 1, conflictstr[:length])
         win.noutrefresh()
 
     def helplines(self):
         if self.mode[0] == MODE_PATCH:
             help = b"""\
 ?: help, k/up: line up, j/down: line down, v: stop viewing patch
 pgup: prev page, space/pgdn: next page, c: commit, q: abort
 """
         else:
             help = b"""\
 ?: help, k/up: move up, j/down: move down, space: select, v: view patch
 d: drop, e: edit, f: fold, m: mess, p: pick, r: roll
 pgup/K: move patch up, pgdn/J: move patch down, c: commit, q: abort
 """
             if self.later_on_top:
                 help += b"Newer commits are shown above older commits.\n"
             else:
                 help += b"Older commits are shown above newer commits.\n"
         return help.splitlines()
 
     def render_help(self, win):
         maxy, maxx = win.getmaxyx()
         for y, line in enumerate(self.helplines()):
             if y >= maxy:
                 break
             addln(win, y, 0, line, curses.color_pair(COLOR_HELP))
         win.noutrefresh()
 
     def layout(self):
         maxy, maxx = self.stdscr.getmaxyx()
         helplen = len(self.helplines())
         mainlen = maxy - helplen - 12
         if mainlen < 1:
             raise error.Abort(
                 _(b"terminal dimensions %d by %d too small for curses histedit")
                 % (maxy, maxx),
                 hint=_(
                     b"enlarge your terminal or use --config ui.interface=text"
                 ),
             )
         return {
             b'commit': (12, maxx),
             b'help': (helplen, maxx),
             b'main': (mainlen, maxx),
         }
 
     def display_pos_to_rule_pos(self, display_pos):
         """Converts a position in display order to rule order.
 
         The `display_pos` is the order from the top in display order, not
         considering which items are currently visible on the screen. Thus,
         `display_pos=0` is the item at the top (possibly after scrolling to
         the top)
         """
         if self.later_on_top:
             return len(self.rules) - 1 - display_pos
         else:
             return display_pos
 
     def render_rules(self, rulesscr):
         start = self.modes[MODE_RULES][b'line_offset']
 
         conflicts = [r.ctx for r in self.rules if r.conflicts]
         if len(conflicts) > 0:
             line = b"potential conflict in %s" % b','.join(
                 map(pycompat.bytestr, conflicts)
             )
             addln(rulesscr, -1, 0, line, curses.color_pair(COLOR_WARN))
 
         for display_pos in range(start, len(self.rules)):
             y = display_pos - start
             if y < 0 or y >= self.page_height:
                 continue
             rule_pos = self.display_pos_to_rule_pos(display_pos)
             rule = self.rules[rule_pos]
             if len(rule.conflicts) > 0:
                 rulesscr.addstr(y, 0, b" ", curses.color_pair(COLOR_WARN))
             else:
                 rulesscr.addstr(y, 0, b" ", curses.COLOR_BLACK)
 
             if display_pos == self.selected:
                 rollcolor = COLOR_ROLL_SELECTED
                 addln(rulesscr, y, 2, rule, curses.color_pair(COLOR_SELECTED))
             elif display_pos == self.pos:
                 rollcolor = COLOR_ROLL_CURRENT
                 addln(
                     rulesscr,
                     y,
                     2,
                     rule,
                     curses.color_pair(COLOR_CURRENT) | curses.A_BOLD,
                 )
             else:
                 rollcolor = COLOR_ROLL
                 addln(rulesscr, y, 2, rule)
 
             if rule.action == b'roll':
                 rulesscr.addstr(
                     y,
                     2 + len(rule.prefix),
                     rule.desc,
                     curses.color_pair(rollcolor),
                 )
 
         rulesscr.noutrefresh()
 
     def render_string(self, win, output, diffcolors=False):
         maxy, maxx = win.getmaxyx()
         length = min(maxy - 1, len(output))
         for y in range(0, length):
             line = output[y]
             if diffcolors:
                 if line.startswith(b'+'):
                     win.addstr(
                         y, 0, line, curses.color_pair(COLOR_DIFF_ADD_LINE)
                     )
                 elif line.startswith(b'-'):
                     win.addstr(
                         y, 0, line, curses.color_pair(COLOR_DIFF_DEL_LINE)
                     )
                 elif line.startswith(b'@@ '):
                     win.addstr(y, 0, line, curses.color_pair(COLOR_DIFF_OFFSET))
                 else:
                     win.addstr(y, 0, line)
             else:
                 win.addstr(y, 0, line)
         win.noutrefresh()
 
     def render_patch(self, win):
         start = self.modes[MODE_PATCH][b'line_offset']
         content = self.modes[MODE_PATCH][b'patchcontents']
         self.render_string(win, content[start:], diffcolors=True)
 
     def event(self, ch):
         """Change state based on the current character input
 
         This takes the current state and based on the current character input from
         the user we change the state.
         """
         oldpos = self.pos
 
         if ch in (curses.KEY_RESIZE, b"KEY_RESIZE"):
             return E_RESIZE
 
         lookup_ch = ch
         if ch is not None and b'0' <= ch <= b'9':
             lookup_ch = b'0'
 
         curmode, prevmode = self.mode
         action = KEYTABLE[curmode].get(
             lookup_ch, KEYTABLE[b'global'].get(lookup_ch)
         )
         if action is None:
             return
         if action in (b'down', b'move-down'):
             newpos = min(oldpos + 1, len(self.rules) - 1)
             self.move_cursor(oldpos, newpos)
             if self.selected is not None or action == b'move-down':
                 self.swap(oldpos, newpos)
         elif action in (b'up', b'move-up'):
             newpos = max(0, oldpos - 1)
             self.move_cursor(oldpos, newpos)
             if self.selected is not None or action == b'move-up':
                 self.swap(oldpos, newpos)
         elif action == b'next-action':
             self.cycle_action(oldpos, next=True)
         elif action == b'prev-action':
             self.cycle_action(oldpos, next=False)
         elif action == b'select':
             self.selected = oldpos if self.selected is None else None
             self.make_selection(self.selected)
         elif action == b'goto' and int(ch) < len(self.rules) <= 10:
             newrule = next((r for r in self.rules if r.origpos == int(ch)))
             self.move_cursor(oldpos, newrule.pos)
             if self.selected is not None:
                 self.swap(oldpos, newrule.pos)
         elif action.startswith(b'action-'):
             self.change_action(oldpos, action[7:])
         elif action == b'showpatch':
             self.change_mode(MODE_PATCH if curmode != MODE_PATCH else prevmode)
         elif action == b'help':
             self.change_mode(MODE_HELP if curmode != MODE_HELP else prevmode)
         elif action == b'quit':
             return E_QUIT
         elif action == b'histedit':
             return E_HISTEDIT
         elif action == b'page-down':
             return E_PAGEDOWN
         elif action == b'page-up':
             return E_PAGEUP
         elif action == b'line-down':
             return E_LINEDOWN
         elif action == b'line-up':
             return E_LINEUP
 
     def patch_contents(self):
         repo = self.repo
         rule = self.rules[self.display_pos_to_rule_pos(self.pos)]
         displayer = logcmdutil.changesetdisplayer(
             repo.ui,
             repo,
             {b"patch": True, b"template": b"status"},
             buffered=True,
         )
         overrides = {(b'ui', b'verbose'): True}
         with repo.ui.configoverride(overrides, source=b'histedit'):
             displayer.show(rule.ctx)
             displayer.close()
         return displayer.hunk[rule.ctx.rev()].splitlines()
 
     def move_cursor(self, oldpos, newpos):
         """Change the rule/changeset that the cursor is pointing to, regardless of
         current mode (you can switch between patches from the view patch window).
         """
         self.pos = newpos
 
         mode, _ = self.mode
         if mode == MODE_RULES:
             # Scroll through the list by updating the view for MODE_RULES, so that
             # even if we are not currently viewing the rules, switching back will
             # result in the cursor's rule being visible.
             modestate = self.modes[MODE_RULES]
             if newpos < modestate[b'line_offset']:
                 modestate[b'line_offset'] = newpos
             elif newpos > modestate[b'line_offset'] + self.page_height - 1:
                 modestate[b'line_offset'] = newpos - self.page_height + 1
 
         # Reset the patch view region to the top of the new patch.
         self.modes[MODE_PATCH][b'line_offset'] = 0
 
     def change_mode(self, mode):
         curmode, _ = self.mode
         self.mode = (mode, curmode)
         if mode == MODE_PATCH:
             self.modes[MODE_PATCH][b'patchcontents'] = self.patch_contents()
 
     def make_selection(self, pos):
         self.selected = pos
 
     def swap(self, oldpos, newpos):
         """Swap two positions and calculate necessary conflicts in
         O(|newpos-oldpos|) time"""
         old_rule_pos = self.display_pos_to_rule_pos(oldpos)
         new_rule_pos = self.display_pos_to_rule_pos(newpos)
 
         rules = self.rules
         assert 0 <= old_rule_pos < len(rules) and 0 <= new_rule_pos < len(rules)
 
         rules[old_rule_pos], rules[new_rule_pos] = (
             rules[new_rule_pos],
             rules[old_rule_pos],
         )
 
         # TODO: swap should not know about histeditrule's internals
         rules[new_rule_pos].pos = new_rule_pos
         rules[old_rule_pos].pos = old_rule_pos
 
         start = min(old_rule_pos, new_rule_pos)
         end = max(old_rule_pos, new_rule_pos)
         for r in range(start, end + 1):
             rules[new_rule_pos].checkconflicts(rules[r])
             rules[old_rule_pos].checkconflicts(rules[r])
 
         if self.selected:
             self.make_selection(newpos)
 
     def change_action(self, pos, action):
         """Change the action state on the given position to the new action"""
         rule_pos = self.display_pos_to_rule_pos(pos)
         assert 0 <= rule_pos < len(self.rules)
         self.rules[rule_pos].action = action
 
     def cycle_action(self, pos, next=False):
         """Changes the action state the next or the previous action from
         the action list"""
         rule_pos = self.display_pos_to_rule_pos(pos)
         assert 0 <= rule_pos < len(self.rules)
         current = self.rules[rule_pos].action
 
         assert current in KEY_LIST
 
         index = KEY_LIST.index(current)
         if next:
             index += 1
         else:
             index -= 1
         # using pos instead of rule_pos because change_action() also calls
         # display_pos_to_rule_pos()
         self.change_action(pos, KEY_LIST[index % len(KEY_LIST)])
 
     def change_view(self, delta, unit):
         """Change the region of whatever is being viewed (a patch or the list of
         changesets). 'delta' is an amount (+/- 1) and 'unit' is 'page' or 'line'.
         """
         mode, _ = self.mode
         if mode != MODE_PATCH:
             return
         mode_state = self.modes[mode]
         num_lines = len(mode_state[b'patchcontents'])
         page_height = self.page_height
         unit = page_height if unit == b'page' else 1
         num_pages = 1 + (num_lines - 1) // page_height
         max_offset = (num_pages - 1) * page_height
         newline = mode_state[b'line_offset'] + delta * unit
         mode_state[b'line_offset'] = max(0, min(max_offset, newline))
 
 
 def _chisteditmain(repo, rules, stdscr):
     try:
         curses.use_default_colors()
     except curses.error:
         pass
 
     # initialize color pattern
     curses.init_pair(COLOR_HELP, curses.COLOR_WHITE, curses.COLOR_BLUE)
     curses.init_pair(COLOR_SELECTED, curses.COLOR_BLACK, curses.COLOR_WHITE)
     curses.init_pair(COLOR_WARN, curses.COLOR_BLACK, curses.COLOR_YELLOW)
     curses.init_pair(COLOR_OK, curses.COLOR_BLACK, curses.COLOR_GREEN)
     curses.init_pair(COLOR_CURRENT, curses.COLOR_WHITE, curses.COLOR_MAGENTA)
     curses.init_pair(COLOR_DIFF_ADD_LINE, curses.COLOR_GREEN, -1)
     curses.init_pair(COLOR_DIFF_DEL_LINE, curses.COLOR_RED, -1)
     curses.init_pair(COLOR_DIFF_OFFSET, curses.COLOR_MAGENTA, -1)
     curses.init_pair(COLOR_ROLL, curses.COLOR_RED, -1)
     curses.init_pair(
         COLOR_ROLL_CURRENT, curses.COLOR_BLACK, curses.COLOR_MAGENTA
     )
     curses.init_pair(COLOR_ROLL_SELECTED, curses.COLOR_RED, curses.COLOR_WHITE)
 
     # don't display the cursor
     try:
         curses.curs_set(0)
     except curses.error:
         pass
 
     def drawvertwin(size, y, x):
         win = curses.newwin(size[0], size[1], y, x)
         y += size[0]
         return win, y, x
 
     state = _chistedit_state(repo, rules, stdscr)
 
     # eventloop
     ch = None
     stdscr.clear()
     stdscr.refresh()
     while True:
         oldmode, unused = state.mode
         if oldmode == MODE_INIT:
             state.change_mode(MODE_RULES)
         e = state.event(ch)
 
         if e == E_QUIT:
             return False
         if e == E_HISTEDIT:
             return state.rules
         else:
             if e == E_RESIZE:
                 size = screen_size()
                 if size != stdscr.getmaxyx():
                     curses.resizeterm(*size)
 
             sizes = state.layout()
             curmode, unused = state.mode
             if curmode != oldmode:
                 state.page_height = sizes[b'main'][0]
                 # Adjust the view to fit the current screen size.
                 state.move_cursor(state.pos, state.pos)
 
             # Pack the windows against the top, each pane spread across the
             # full width of the screen.
             y, x = (0, 0)
             helpwin, y, x = drawvertwin(sizes[b'help'], y, x)
             mainwin, y, x = drawvertwin(sizes[b'main'], y, x)
             commitwin, y, x = drawvertwin(sizes[b'commit'], y, x)
 
             if e in (E_PAGEDOWN, E_PAGEUP, E_LINEDOWN, E_LINEUP):
                 if e == E_PAGEDOWN:
                     state.change_view(+1, b'page')
                 elif e == E_PAGEUP:
                     state.change_view(-1, b'page')
                 elif e == E_LINEDOWN:
                     state.change_view(+1, b'line')
                 elif e == E_LINEUP:
                     state.change_view(-1, b'line')
 
             # start rendering
             commitwin.erase()
             helpwin.erase()
             mainwin.erase()
             if curmode == MODE_PATCH:
                 state.render_patch(mainwin)
             elif curmode == MODE_HELP:
                 state.render_string(mainwin, __doc__.strip().splitlines())
             else:
                 state.render_rules(mainwin)
                 state.render_commit(commitwin)
             state.render_help(helpwin)
             curses.doupdate()
             # done rendering
             ch = encoding.strtolocal(stdscr.getkey())
 
 
-def _chistedit(ui, repo, freeargs, opts):
+def _chistedit(ui, repo, state, freeargs, opts):
     """interactively edit changeset history via a curses interface
 
     Provides a ncurses interface to histedit. Press ? in chistedit mode
     to see an extensive help. Requires python-curses to be installed."""
 
     if curses is None:
         raise error.Abort(_(b"Python curses library required"))
 
     # disable color
     ui._colormode = None
 
     try:
         keep = opts.get(b'keep')
         revs = opts.get(b'rev', [])[:]
         cmdutil.checkunfinished(repo)
         cmdutil.bailifchanged(repo)
 
         revs.extend(freeargs)
         if not revs:
             defaultrev = destutil.desthistedit(ui, repo)
             if defaultrev is not None:
                 revs.append(defaultrev)
         if len(revs) != 1:
             raise error.InputError(
                 _(b'histedit requires exactly one ancestor revision')
             )
 
         rr = list(repo.set(b'roots(%ld)', logcmdutil.revrange(repo, revs)))
         if len(rr) != 1:
             raise error.InputError(
                 _(
                     b'The specified revisions must have '
                     b'exactly one common root'
                 )
             )
         root = rr[0].node()
 
         topmost = repo.dirstate.p1()
         revs = between(repo, root, topmost, keep)
         if not revs:
             raise error.InputError(
                 _(b'%s is not an ancestor of working directory') % short(root)
             )
 
         rules = []
         for i, r in enumerate(revs):
             rules.append(histeditrule(ui, repo[r], i))
         with util.with_lc_ctype():
             rc = curses.wrapper(functools.partial(_chisteditmain, repo, rules))
         if rc is False:
             ui.write(_(b"histedit aborted\n"))
             return 0
         if type(rc) is list:
             ui.status(_(b"performing changes\n"))
             rules = makecommands(rc)
             with repo.vfs(b'chistedit', b'w+') as fp:
                 for r in rules:
                     fp.write(r)
                 opts[b'commands'] = fp.name
-            return _texthistedit(ui, repo, freeargs, opts)
+            return _texthistedit(ui, repo, state, freeargs, opts)
     except KeyboardInterrupt:
         pass
     return -1
 
 
 @command(
     b'histedit',
     [
         (
             b'',
             b'commands',
             b'',
             _(b'read history edits from the specified file'),
             _(b'FILE'),
         ),
         (b'c', b'continue', False, _(b'continue an edit already in progress')),
         (b'', b'edit-plan', False, _(b'edit remaining actions list')),
         (
             b'k',
             b'keep',
             False,
             _(b"don't strip old nodes after edit is complete"),
         ),
         (b'', b'abort', False, _(b'abort an edit in progress')),
         (b'o', b'outgoing', False, _(b'changesets not found in destination')),
         (
             b'f',
             b'force',
             False,
             _(b'force outgoing even for unrelated repositories'),
         ),
         (b'r', b'rev', [], _(b'first revision to be edited'), _(b'REV')),
     ]
     + cmdutil.formatteropts,
     _(b"[OPTIONS] ([ANCESTOR] | --outgoing [URL])"),
     helpcategory=command.CATEGORY_CHANGE_MANAGEMENT,
 )
 def histedit(ui, repo, *freeargs, **opts):
     """interactively edit changeset history
 
     This command lets you edit a linear series of changesets (up to
     and including the working directory, which should be clean).
     You can:
 
     - `pick` to [re]order a changeset
 
     - `drop` to omit changeset
 
     - `mess` to reword the changeset commit message
 
     - `fold` to combine it with the preceding changeset (using the later date)
 
     - `roll` like fold, but discarding this commit's description and date
 
     - `edit` to edit this changeset (preserving date)
 
     - `base` to checkout changeset and apply further changesets from there
 
     There are a number of ways to select the root changeset:
 
     - Specify ANCESTOR directly
 
     - Use --outgoing -- it will be the first linear changeset not
       included in destination. (See :hg:`help config.paths.default-push`)
 
     - Otherwise, the value from the "histedit.defaultrev" config option
       is used as a revset to select the base revision when ANCESTOR is not
       specified. The first revision returned by the revset is used. By
       default, this selects the editable history that is unique to the
       ancestry of the working directory.
 
     .. container:: verbose
 
        If you use --outgoing, this command will abort if there are ambiguous
        outgoing revisions. For example, if there are multiple branches
        containing outgoing revisions.
 
        Use "min(outgoing() and ::.)" or similar revset specification
        instead of --outgoing to specify edit target revision exactly in
        such ambiguous situation. See :hg:`help revsets` for detail about
        selecting revisions.
 
     .. container:: verbose
 
        Examples:
 
          - A number of changes have been made.
            Revision 3 is no longer needed.
 
            Start history editing from revision 3::
 
              hg histedit -r 3
 
            An editor opens, containing the list of revisions,
            with specific actions specified::
 
              pick 5339bf82f0ca 3 Zworgle the foobar
              pick 8ef592ce7cc4 4 Bedazzle the zerlog
              pick 0a9639fcda9d 5 Morgify the cromulancy
 
            Additional information about the possible actions
            to take appears below the list of revisions.
 
            To remove revision 3 from the history,
            its action (at the beginning of the relevant line)
            is changed to 'drop'::
 
              drop 5339bf82f0ca 3 Zworgle the foobar
              pick 8ef592ce7cc4 4 Bedazzle the zerlog
              pick 0a9639fcda9d 5 Morgify the cromulancy
 
          - A number of changes have been made.
            Revision 2 and 4 need to be swapped.
 
            Start history editing from revision 2::
 
              hg histedit -r 2
 
            An editor opens, containing the list of revisions,
            with specific actions specified::
 
              pick 252a1af424ad 2 Blorb a morgwazzle
              pick 5339bf82f0ca 3 Zworgle the foobar
              pick 8ef592ce7cc4 4 Bedazzle the zerlog
 
            To swap revision 2 and 4, its lines are swapped
            in the editor::
 
              pick 8ef592ce7cc4 4 Bedazzle the zerlog
              pick 5339bf82f0ca 3 Zworgle the foobar
              pick 252a1af424ad 2 Blorb a morgwazzle
 
     Returns 0 on success, 1 if user intervention is required (not only
     for intentional "edit" command, but also for resolving unexpected
     conflicts).
     """
     opts = pycompat.byteskwargs(opts)
 
-    # kludge: _chistedit only works for starting an edit, not aborting
-    # or continuing, so fall back to regular _texthistedit for those
-    # operations.
-    if ui.interface(b'histedit') == b'curses' and _getgoal(opts) == goalnew:
-        return _chistedit(ui, repo, freeargs, opts)
-    return _texthistedit(ui, repo, freeargs, opts)
-
-
-def _texthistedit(ui, repo, freeargs, opts):
     state = histeditstate(repo)
     with repo.wlock() as wlock, repo.lock() as lock:
         state.wlock = wlock
         state.lock = lock
-        _histedit(ui, repo, state, freeargs, opts)
+        # kludge: _chistedit only works for starting an edit, not aborting
+        # or continuing, so fall back to regular _texthistedit for those
+        # operations.
+        if ui.interface(b'histedit') == b'curses' and _getgoal(opts) == goalnew:
+            return _chistedit(ui, repo, state, freeargs, opts)
+        return _texthistedit(ui, repo, state, freeargs, opts)
+
+
+def _texthistedit(ui, repo, state, freeargs, opts):
+    _histedit(ui, repo, state, freeargs, opts)
 
 
 goalcontinue = b'continue'
 goalabort = b'abort'
 goaleditplan = b'edit-plan'
 goalnew = b'new'
 
 
 def _getgoal(opts):
     if opts.get(b'continue'):
         return goalcontinue
     if opts.get(b'abort'):
         return goalabort
     if opts.get(b'edit_plan'):
         return goaleditplan
     return goalnew
 
 
 def _readfile(ui, path):
     if path == b'-':
         with ui.timeblockedsection(b'histedit'):
             return ui.fin.read()
     else:
         with open(path, b'rb') as f:
             return f.read()
 
 
 def _validateargs(ui, repo, freeargs, opts, goal, rules, revs):
     # TODO only abort if we try to histedit mq patches, not just
     # blanket if mq patches are applied somewhere
     mq = getattr(repo, 'mq', None)
     if mq and mq.applied:
         raise error.StateError(_(b'source has mq patches applied'))
 
     # basic argument incompatibility processing
     outg = opts.get(b'outgoing')
     editplan = opts.get(b'edit_plan')
     abort = opts.get(b'abort')
     force = opts.get(b'force')
     if force and not outg:
         raise error.InputError(_(b'--force only allowed with --outgoing'))
     if goal == b'continue':
         if any((outg, abort, revs, freeargs, rules, editplan)):
             raise error.InputError(_(b'no arguments allowed with --continue'))
     elif goal == b'abort':
         if any((outg, revs, freeargs, rules, editplan)):
             raise error.InputError(_(b'no arguments allowed with --abort'))
     elif goal == b'edit-plan':
         if any((outg, revs, freeargs)):
             raise error.InputError(
                 _(b'only --commands argument allowed with --edit-plan')
             )
     else:
         if outg:
             if revs:
                 raise error.InputError(
                     _(b'no revisions allowed with --outgoing')
                 )
             if len(freeargs) > 1:
                 raise error.InputError(
                     _(b'only one repo argument allowed with --outgoing')
                 )
         else:
             revs.extend(freeargs)
             if len(revs) == 0:
                 defaultrev = destutil.desthistedit(ui, repo)
                 if defaultrev is not None:
                     revs.append(defaultrev)
 
             if len(revs) != 1:
                 raise error.InputError(
                     _(b'histedit requires exactly one ancestor revision')
                 )
 
 
 def _histedit(ui, repo, state, freeargs, opts):
     fm = ui.formatter(b'histedit', opts)
     fm.startitem()
     goal = _getgoal(opts)
     revs = opts.get(b'rev', [])
     nobackup = not ui.configbool(b'rewrite', b'backup-bundle')
     rules = opts.get(b'commands', b'')
     state.keep = opts.get(b'keep', False)
 
     _validateargs(ui, repo, freeargs, opts, goal, rules, revs)
 
     hastags = False
     if revs:
         revs = logcmdutil.revrange(repo, revs)
         ctxs = [repo[rev] for rev in revs]
         for ctx in ctxs:
             tags = [tag for tag in ctx.tags() if tag != b'tip']
             if not hastags:
                 hastags = len(tags)
     if hastags:
         if ui.promptchoice(
             _(
                 b'warning: tags associated with the given'
                 b' changeset will be lost after histedit.\n'
                 b'do you want to continue (yN)? $$ &Yes $$ &No'
             ),
             default=1,
         ):
             raise error.CanceledError(_(b'histedit cancelled\n'))
     # rebuild state
     if goal == goalcontinue:
         state.read()
         state = bootstrapcontinue(ui, state, opts)
     elif goal == goaleditplan:
         _edithisteditplan(ui, repo, state, rules)
         return
     elif goal == goalabort:
         _aborthistedit(ui, repo, state, nobackup=nobackup)
         return
     else:
         # goal == goalnew
         _newhistedit(ui, repo, state, revs, freeargs, opts)
 
     _continuehistedit(ui, repo, state)
     _finishhistedit(ui, repo, state, fm)
     fm.end()
 
 
 def _continuehistedit(ui, repo, state):
     """This function runs after either:
     - bootstrapcontinue (if the goal is 'continue')
     - _newhistedit (if the goal is 'new')
     """
     # preprocess rules so that we can hide inner folds from the user
     # and only show one editor
     actions = state.actions[:]
     for idx, (action, nextact) in enumerate(zip(actions, actions[1:] + [None])):
         if action.verb == b'fold' and nextact and nextact.verb == b'fold':
             state.actions[idx].__class__ = _multifold
 
     # Force an initial state file write, so the user can run --abort/continue
     # even if there's an exception before the first transaction serialize.
     state.write()
 
     tr = None
     # Don't use singletransaction by default since it rolls the entire
     # transaction back if an unexpected exception happens (like a
     # pretxncommit hook throws, or the user aborts the commit msg editor).
     if ui.configbool(b"histedit", b"singletransaction"):
         # Don't use a 'with' for the transaction, since actions may close
         # and reopen a transaction. For example, if the action executes an
         # external process it may choose to commit the transaction first.
         tr = repo.transaction(b'histedit')
     progress = ui.makeprogress(
         _(b"editing"), unit=_(b'changes'), total=len(state.actions)
     )
     with progress, util.acceptintervention(tr):
         while state.actions:
             state.write(tr=tr)
             actobj = state.actions[0]
             progress.increment(item=actobj.torule())
             ui.debug(
                 b'histedit: processing %s %s\n' % (actobj.verb, actobj.torule())
             )
             parentctx, replacement_ = actobj.run()
             state.parentctxnode = parentctx.node()
             state.replacements.extend(replacement_)
             state.actions.pop(0)
 
     state.write()
 
 
 def _finishhistedit(ui, repo, state, fm):
     """This action runs when histedit is finishing its session"""
     mergemod.update(repo[state.parentctxnode])
 
     mapping, tmpnodes, created, ntm = processreplacement(state)
     if mapping:
         for prec, succs in mapping.items():
             if not succs:
                 ui.debug(b'histedit: %s is dropped\n' % short(prec))
             else:
                 ui.debug(
                     b'histedit: %s is replaced by %s\n'
                     % (short(prec), short(succs[0]))
                 )
                 if len(succs) > 1:
                     m = b'histedit:                            %s'
                     for n in succs[1:]:
                         ui.debug(m % short(n))
 
     if not state.keep:
         if mapping:
             movetopmostbookmarks(repo, state.topmost, ntm)
             # TODO update mq state
     else:
         mapping = {}
 
     for n in tmpnodes:
         if n in repo:
             mapping[n] = ()
 
     # remove entries about unknown nodes
     has_node = repo.unfiltered().changelog.index.has_node
     mapping = {
         k: v
         for k, v in mapping.items()
         if has_node(k) and all(has_node(n) for n in v)
     }
     scmutil.cleanupnodes(repo, mapping, b'histedit')
     hf = fm.hexfunc
     fl = fm.formatlist
     fd = fm.formatdict
     nodechanges = fd(
         {
             hf(oldn): fl([hf(n) for n in newn], name=b'node')
             for oldn, newn in mapping.items()
         },
         key=b"oldnode",
         value=b"newnodes",
     )
     fm.data(nodechanges=nodechanges)
 
     state.clear()
     if os.path.exists(repo.sjoin(b'undo')):
         os.unlink(repo.sjoin(b'undo'))
     if repo.vfs.exists(b'histedit-last-edit.txt'):
         repo.vfs.unlink(b'histedit-last-edit.txt')
 
 
 def _aborthistedit(ui, repo, state, nobackup=False):
     try:
         state.read()
         __, leafs, tmpnodes, __ = processreplacement(state)
         ui.debug(b'restore wc to old parent %s\n' % short(state.topmost))
 
         # Recover our old commits if necessary
         if not state.topmost in repo and state.backupfile:
             backupfile = repo.vfs.join(state.backupfile)
             f = hg.openpath(ui, backupfile)
             gen = exchange.readbundle(ui, f, backupfile)
             with repo.transaction(b'histedit.abort') as tr:
                 bundle2.applybundle(
                     repo,
                     gen,
                     tr,
                     source=b'histedit',
                     url=b'bundle:' + backupfile,
                 )
 
             os.remove(backupfile)
 
         # check whether we should update away
         if repo.unfiltered().revs(
             b'parents() and (%n  or %ln::)',
             state.parentctxnode,
             leafs | tmpnodes,
         ):
             hg.clean(repo, state.topmost, show_stats=True, quietempty=True)
         cleanupnode(ui, repo, tmpnodes, nobackup=nobackup)
         cleanupnode(ui, repo, leafs, nobackup=nobackup)
     except Exception:
         if state.inprogress():
             ui.warn(
                 _(
                     b'warning: encountered an exception during histedit '
                     b'--abort; the repository may not have been completely '
                     b'cleaned up\n'
                 )
             )
         raise
     finally:
         state.clear()
 
 
 def hgaborthistedit(ui, repo):
     state = histeditstate(repo)
     nobackup = not ui.configbool(b'rewrite', b'backup-bundle')
     with repo.wlock() as wlock, repo.lock() as lock:
         state.wlock = wlock
         state.lock = lock
         _aborthistedit(ui, repo, state, nobackup=nobackup)
 
 
 def _edithisteditplan(ui, repo, state, rules):
     state.read()
     if not rules:
         comment = geteditcomment(
             ui, short(state.parentctxnode), short(state.topmost)
         )
         rules = ruleeditor(repo, ui, state.actions, comment)
     else:
         rules = _readfile(ui, rules)
     actions = parserules(rules, state)
     ctxs = [repo[act.node] for act in state.actions if act.node]
     warnverifyactions(ui, repo, actions, state, ctxs)
     state.actions = actions
     state.write()
 
 
 def _newhistedit(ui, repo, state, revs, freeargs, opts):
     outg = opts.get(b'outgoing')
     rules = opts.get(b'commands', b'')
     force = opts.get(b'force')
 
     cmdutil.checkunfinished(repo)
     cmdutil.bailifchanged(repo)
 
     topmost = repo.dirstate.p1()
     if outg:
         if freeargs:
             remote = freeargs[0]
         else:
             remote = None
         root = findoutgoing(ui, repo, remote, force, opts)
     else:
         rr = list(repo.set(b'roots(%ld)', logcmdutil.revrange(repo, revs)))
         if len(rr) != 1:
             raise error.InputError(
                 _(
                     b'The specified revisions must have '
                     b'exactly one common root'
                 )
             )
         root = rr[0].node()
 
     revs = between(repo, root, topmost, state.keep)
     if not revs:
         raise error.InputError(
             _(b'%s is not an ancestor of working directory') % short(root)
         )
 
     ctxs = [repo[r] for r in revs]
 
     wctx = repo[None]
     # Please don't ask me why `ancestors` is this value. I figured it
     # out with print-debugging, not by actually understanding what the
     # merge code is doing. :(
     ancs = [repo[b'.']]
     # Sniff-test to make sure we won't collide with untracked files in
     # the working directory. If we don't do this, we can get a
     # collision after we've started histedit and backing out gets ugly
     # for everyone, especially the user.
     for c in [ctxs[0].p1()] + ctxs:
         try:
             mergemod.calculateupdates(
                 repo,
                 wctx,
                 c,
                 ancs,
                 # These parameters were determined by print-debugging
                 # what happens later on inside histedit.
                 branchmerge=False,
                 force=False,
                 acceptremote=False,
                 followcopies=False,
             )
         except error.Abort:
             raise error.StateError(
                 _(
                     b"untracked files in working directory conflict with files in %s"
                 )
                 % c
             )
 
     if not rules:
         comment = geteditcomment(ui, short(root), short(topmost))
         actions = [pick(state, r) for r in revs]
         rules = ruleeditor(repo, ui, actions, comment)
     else:
         rules = _readfile(ui, rules)
     actions = parserules(rules, state)
     warnverifyactions(ui, repo, actions, state, ctxs)
 
     parentctxnode = repo[root].p1().node()
 
     state.parentctxnode = parentctxnode
     state.actions = actions
     state.topmost = topmost
     state.replacements = []
 
     ui.log(
         b"histedit",
         b"%d actions to histedit\n",
         len(actions),
         histedit_num_actions=len(actions),
     )
 
     # Create a backup so we can always abort completely.
     backupfile = None
     if not obsolete.isenabled(repo, obsolete.createmarkersopt):
         backupfile = repair.backupbundle(
             repo, [parentctxnode], [topmost], root, b'histedit'
         )
     state.backupfile = backupfile
 
 
 def _getsummary(ctx):
     return stringutil.firstline(ctx.description())
 
 
 def bootstrapcontinue(ui, state, opts):
     repo = state.repo
 
     ms = mergestatemod.mergestate.read(repo)
     mergeutil.checkunresolved(ms)
 
     if state.actions:
         actobj = state.actions.pop(0)
 
         if _isdirtywc(repo):
             actobj.continuedirty()
             if _isdirtywc(repo):
                 abortdirty()
 
         parentctx, replacements = actobj.continueclean()
 
         state.parentctxnode = parentctx.node()
         state.replacements.extend(replacements)
 
     return state
 
 
 def between(repo, old, new, keep):
     """select and validate the set of revision to edit
 
     When keep is false, the specified set can't have children."""
     revs = repo.revs(b'%n::%n', old, new)
     if revs and not keep:
         rewriteutil.precheck(repo, revs, b'edit')
         if repo.revs(b'(%ld) and merge()', revs):
             raise error.StateError(
                 _(b'cannot edit history that contains merges')
             )
     return pycompat.maplist(repo.changelog.node, revs)
 
 
 def ruleeditor(repo, ui, actions, editcomment=b""):
     """open an editor to edit rules
 
     rules are in the format [ [act, ctx], ...] like in state.rules
     """
     if repo.ui.configbool(b"experimental", b"histedit.autoverb"):
         newact = util.sortdict()
         for act in actions:
             ctx = repo[act.node]
             summary = _getsummary(ctx)
             fword = summary.split(b' ', 1)[0].lower()
             added = False
 
             # if it doesn't end with the special character '!' just skip this
             if fword.endswith(b'!'):
                 fword = fword[:-1]
                 if fword in primaryactions | secondaryactions | tertiaryactions:
                     act.verb = fword
                     # get the target summary
                     tsum = summary[len(fword) + 1 :].lstrip()
                     # safe but slow: reverse iterate over the actions so we
                     # don't clash on two commits having the same summary
                     for na, l in reversed(list(newact.items())):
                         actx = repo[na.node]
                         asum = _getsummary(actx)
                         if asum == tsum:
                             added = True
                             l.append(act)
                             break
 
             if not added:
                 newact[act] = []
 
         # copy over and flatten the new list
         actions = []
         for na, l in newact.items():
             actions.append(na)
             actions += l
 
     rules = b'\n'.join([act.torule() for act in actions])
     rules += b'\n\n'
     rules += editcomment
     rules = ui.edit(
         rules,
         ui.username(),
         {b'prefix': b'histedit'},
         repopath=repo.path,
         action=b'histedit',
     )
 
     # Save edit rules in .hg/histedit-last-edit.txt in case
     # the user needs to ask for help after something
     # surprising happens.
     with repo.vfs(b'histedit-last-edit.txt', b'wb') as f:
         f.write(rules)
 
     return rules
 
 
 def parserules(rules, state):
     """Read the histedit rules string and return list of action objects"""
     rules = [
         l
         for l in (r.strip() for r in rules.splitlines())
         if l and not l.startswith(b'#')
     ]
     actions = []
     for r in rules:
         if b' ' not in r:
             raise error.ParseError(_(b'malformed line "%s"') % r)
         verb, rest = r.split(b' ', 1)
 
         if verb not in actiontable:
             raise error.ParseError(_(b'unknown action "%s"') % verb)
 
         action = actiontable[verb].fromrule(state, rest)
         actions.append(action)
     return actions
 
 
 def warnverifyactions(ui, repo, actions, state, ctxs):
     try:
         verifyactions(actions, state, ctxs)
     except error.ParseError:
         if repo.vfs.exists(b'histedit-last-edit.txt'):
             ui.warn(
                 _(
                     b'warning: histedit rules saved '
                     b'to: .hg/histedit-last-edit.txt\n'
                 )
             )
         raise
 
 
 def verifyactions(actions, state, ctxs):
     """Verify that there exists exactly one action per given changeset and
     other constraints.
 
     Will abort if there are to many or too few rules, a malformed rule,
     or a rule on a changeset outside of the user-given range.
     """
     expected = {c.node() for c in ctxs}
     seen = set()
     prev = None
 
     if actions and actions[0].verb in [b'roll', b'fold']:
         raise error.ParseError(
             _(b'first changeset cannot use verb "%s"') % actions[0].verb
         )
 
     for action in actions:
         action.verify(prev, expected, seen)
         prev = action
         if action.node is not None:
             seen.add(action.node)
     missing = sorted(expected - seen)  # sort to stabilize output
 
     if state.repo.ui.configbool(b'histedit', b'dropmissing'):
         if len(actions) == 0:
             raise error.ParseError(
                 _(b'no rules provided'),
                 hint=_(b'use strip extension to remove commits'),
             )
 
         drops = [drop(state, n) for n in missing]
         # put the in the beginning so they execute immediately and
         # don't show in the edit-plan in the future
         actions[:0] = drops
     elif missing:
         raise error.ParseError(
             _(b'missing rules for changeset %s') % short(missing[0]),
             hint=_(
                 b'use "drop %s" to discard, see also: '
                 b"'hg help -e histedit.config'"
             )
             % short(missing[0]),
         )
 
 
 def adjustreplacementsfrommarkers(repo, oldreplacements):
     """Adjust replacements from obsolescence markers
 
     Replacements structure is originally generated based on
     histedit's state and does not account for changes that are
     not recorded there. This function fixes that by adding
     data read from obsolescence markers"""
     if not obsolete.isenabled(repo, obsolete.createmarkersopt):
         return oldreplacements
 
     unfi = repo.unfiltered()
     get_rev = unfi.changelog.index.get_rev
     obsstore = repo.obsstore
     newreplacements = list(oldreplacements)
     oldsuccs = [r[1] for r in oldreplacements]
     # successors that have already been added to succstocheck once
     seensuccs = set().union(
         *oldsuccs
     )  # create a set from an iterable of tuples
     succstocheck = list(seensuccs)
     while succstocheck:
         n = succstocheck.pop()
         missing = get_rev(n) is None
         markers = obsstore.successors.get(n, ())
         if missing and not markers:
             # dead end, mark it as such
             newreplacements.append((n, ()))
         for marker in markers:
             nsuccs = marker[1]
             newreplacements.append((n, nsuccs))
             for nsucc in nsuccs:
                 if nsucc not in seensuccs:
                     seensuccs.add(nsucc)
                     succstocheck.append(nsucc)
 
     return newreplacements
 
 
 def processreplacement(state):
     """process the list of replacements to return
 
     1) the final mapping between original and created nodes
     2) the list of temporary node created by histedit
     3) the list of new commit created by histedit"""
     replacements = adjustreplacementsfrommarkers(state.repo, state.replacements)
     allsuccs = set()
     replaced = set()
     fullmapping = {}
     # initialize basic set
     # fullmapping records all operations recorded in replacement
     for rep in replacements:
         allsuccs.update(rep[1])
         replaced.add(rep[0])
         fullmapping.setdefault(rep[0], set()).update(rep[1])
     new = allsuccs - replaced
     tmpnodes = allsuccs & replaced
     # Reduce content fullmapping into direct relation between original nodes
     # and final node created during history edition
     # Dropped changeset are replaced by an empty list
     toproceed = set(fullmapping)
     final = {}
     while toproceed:
         for x in list(toproceed):
             succs = fullmapping[x]
             for s in list(succs):
                 if s in toproceed:
                     # non final node with unknown closure
                     # We can't process this now
                     break
                 elif s in final:
                     # non final node, replace with closure
                     succs.remove(s)
                     succs.update(final[s])
             else:
                 final[x] = succs
                 toproceed.remove(x)
     # remove tmpnodes from final mapping
     for n in tmpnodes:
         del final[n]
     # we expect all changes involved in final to exist in the repo
     # turn `final` into list (topologically sorted)
     get_rev = state.repo.changelog.index.get_rev
     for prec, succs in final.items():
         final[prec] = sorted(succs, key=get_rev)
 
     # computed topmost element (necessary for bookmark)
     if new:
         newtopmost = sorted(new, key=state.repo.changelog.rev)[-1]
     elif not final:
         # Nothing rewritten at all. we won't need `newtopmost`
         # It is the same as `oldtopmost` and `processreplacement` know it
         newtopmost = None
     else:
         # every body died. The newtopmost is the parent of the root.
         r = state.repo.changelog.rev
         newtopmost = state.repo[sorted(final, key=r)[0]].p1().node()
 
     return final, tmpnodes, new, newtopmost
 
 
 def movetopmostbookmarks(repo, oldtopmost, newtopmost):
     """Move bookmark from oldtopmost to newly created topmost
 
     This is arguably a feature and we may only want that for the active
     bookmark. But the behavior is kept compatible with the old version for now.
     """
     if not oldtopmost or not newtopmost:
         return
     oldbmarks = repo.nodebookmarks(oldtopmost)
     if oldbmarks:
         with repo.lock(), repo.transaction(b'histedit') as tr:
             marks = repo._bookmarks
             changes = []
             for name in oldbmarks:
                 changes.append((name, newtopmost))
             marks.applychanges(repo, tr, changes)
 
 
 def cleanupnode(ui, repo, nodes, nobackup=False):
     """strip a group of nodes from the repository
 
     The set of node to strip may contains unknown nodes."""
     with repo.lock():
         # do not let filtering get in the way of the cleanse
         # we should probably get rid of obsolescence marker created during the
         # histedit, but we currently do not have such information.
         repo = repo.unfiltered()
         # Find all nodes that need to be stripped
         # (we use %lr instead of %ln to silently ignore unknown items)
         has_node = repo.changelog.index.has_node
         nodes = sorted(n for n in nodes if has_node(n))
         roots = [c.node() for c in repo.set(b"roots(%ln)", nodes)]
         if roots:
             backup = not nobackup
             repair.strip(ui, repo, roots, backup=backup)
 
 
 def stripwrapper(orig, ui, repo, nodelist, *args, **kwargs):
     if isinstance(nodelist, bytes):
         nodelist = [nodelist]
     state = histeditstate(repo)
     if state.inprogress():
         state.read()
         histedit_nodes = {
             action.node for action in state.actions if action.node
         }
         common_nodes = histedit_nodes & set(nodelist)
         if common_nodes:
             raise error.Abort(
                 _(b"histedit in progress, can't strip %s")
                 % b', '.join(short(x) for x in common_nodes)
             )
     return orig(ui, repo, nodelist, *args, **kwargs)
 
 
 extensions.wrapfunction(repair, 'strip', stripwrapper)
 
 
 def summaryhook(ui, repo):
     state = histeditstate(repo)
     if not state.inprogress():
         return
     state.read()
     if state.actions:
         # i18n: column positioning for "hg summary"
         ui.write(
             _(b'hist:   %s (histedit --continue)\n')
             % (
                 ui.label(_(b'%d remaining'), b'histedit.remaining')
                 % len(state.actions)
             )
         )
 
 
 def extsetup(ui):
     cmdutil.summaryhooks.add(b'histedit', summaryhook)
     statemod.addunfinished(
         b'histedit',
         fname=b'histedit-state',
         allowcommit=True,
         continueflag=True,
         abortfunc=hgaborthistedit,
     )

hgext/largefiles/overrides.py

@@ -1,1940 +1,1945
 # Copyright 2009-2010 Gregory P. Ward
 # Copyright 2009-2010 Intelerad Medical Systems Incorporated
 # Copyright 2010-2011 Fog Creek Software
 # Copyright 2010-2011 Unity Technologies
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 '''Overridden Mercurial commands and functions for the largefiles extension'''
 
 import contextlib
 import copy
 import os
 from typing import (
     Optional,
 )
 
 from mercurial.i18n import _
 
 from mercurial.pycompat import open
 
 from mercurial.hgweb import webcommands
 
 from mercurial import (
     archival,
     cmdutil,
     copies as copiesmod,
     dirstate,
     error,
     exchange,
     extensions,
     exthelper,
     filemerge,
     hg,
     logcmdutil,
     match as matchmod,
     merge,
     mergestate as mergestatemod,
     pathutil,
     pycompat,
     scmutil,
     smartset,
     subrepo,
     url as urlmod,
     util,
 )
 
 from mercurial.upgrade_utils import (
     actions as upgrade_actions,
 )
 
+from mercurial.utils import urlutil
+
 from . import (
     lfcommands,
     lfutil,
     storefactory,
 )
 
 ACTION_ADD = mergestatemod.ACTION_ADD
 ACTION_DELETED_CHANGED = mergestatemod.ACTION_DELETED_CHANGED
 ACTION_GET = mergestatemod.ACTION_GET
 ACTION_KEEP = mergestatemod.ACTION_KEEP
 ACTION_REMOVE = mergestatemod.ACTION_REMOVE
 
 eh = exthelper.exthelper()
 
 lfstatus = lfutil.lfstatus
 
 MERGE_ACTION_LARGEFILE_MARK_REMOVED = mergestatemod.MergeAction('lfmr')
 
 # -- Utility functions: commonly/repeatedly needed functionality ---------------
 
 
 def composelargefilematcher(match, manifest):
     """create a matcher that matches only the largefiles in the original
     matcher"""
     m = copy.copy(match)
     m._was_tampered_with = True
     lfile = lambda f: lfutil.standin(f) in manifest
     m._files = [lf for lf in m._files if lfile(lf)]
     m._fileset = set(m._files)
     m.always = lambda: False
     origmatchfn = m.matchfn
     m.matchfn = lambda f: lfile(f) and origmatchfn(f)
     return m
 
 
 def composenormalfilematcher(match, manifest, exclude=None):
     excluded = set()
     if exclude is not None:
         excluded.update(exclude)
 
     m = copy.copy(match)
     m._was_tampered_with = True
     notlfile = lambda f: not (
         lfutil.isstandin(f) or lfutil.standin(f) in manifest or f in excluded
     )
     m._files = [lf for lf in m._files if notlfile(lf)]
     m._fileset = set(m._files)
     m.always = lambda: False
     origmatchfn = m.matchfn
     m.matchfn = lambda f: notlfile(f) and origmatchfn(f)
     return m
 
 
 def addlargefiles(ui, repo, isaddremove, matcher, uipathfn, **opts):
     large = opts.get('large')
     lfsize = lfutil.getminsize(
         ui, lfutil.islfilesrepo(repo), opts.get('lfsize')
     )
 
     lfmatcher = None
     if lfutil.islfilesrepo(repo):
         lfpats = ui.configlist(lfutil.longname, b'patterns')
         if lfpats:
             lfmatcher = matchmod.match(repo.root, b'', list(lfpats))
 
     lfnames = []
     m = matcher
 
     wctx = repo[None]
     for f in wctx.walk(matchmod.badmatch(m, lambda x, y: None)):
         exact = m.exact(f)
         lfile = lfutil.standin(f) in wctx
         nfile = f in wctx
         exists = lfile or nfile
 
         # Don't warn the user when they attempt to add a normal tracked file.
         # The normal add code will do that for us.
         if exact and exists:
             if lfile:
                 ui.warn(_(b'%s already a largefile\n') % uipathfn(f))
             continue
 
         if (exact or not exists) and not lfutil.isstandin(f):
             # In case the file was removed previously, but not committed
             # (issue3507)
             if not repo.wvfs.exists(f):
                 continue
 
             abovemin = (
                 lfsize and repo.wvfs.lstat(f).st_size >= lfsize * 1024 * 1024
             )
             if large or abovemin or (lfmatcher and lfmatcher(f)):
                 lfnames.append(f)
                 if ui.verbose or not exact:
                     ui.status(_(b'adding %s as a largefile\n') % uipathfn(f))
 
     bad = []
 
     # Need to lock, otherwise there could be a race condition between
     # when standins are created and added to the repo.
     with repo.wlock():
         if not opts.get('dry_run'):
             standins = []
             lfdirstate = lfutil.openlfdirstate(ui, repo)
             for f in lfnames:
                 standinname = lfutil.standin(f)
                 lfutil.writestandin(
                     repo,
                     standinname,
                     hash=b'',
                     executable=lfutil.getexecutable(repo.wjoin(f)),
                 )
                 standins.append(standinname)
                 lfdirstate.set_tracked(f)
             lfdirstate.write(repo.currenttransaction())
             bad += [
                 lfutil.splitstandin(f)
                 for f in repo[None].add(standins)
                 if f in m.files()
             ]
 
         added = [f for f in lfnames if f not in bad]
     return added, bad
 
 
 def removelargefiles(ui, repo, isaddremove, matcher, uipathfn, dryrun, **opts):
     after = opts.get('after')
     m = composelargefilematcher(matcher, repo[None].manifest())
     with lfstatus(repo):
         s = repo.status(match=m, clean=not isaddremove)
     manifest = repo[None].manifest()
     modified, added, deleted, clean = [
         [f for f in list if lfutil.standin(f) in manifest]
         for list in (s.modified, s.added, s.deleted, s.clean)
     ]
 
     def warn(files, msg):
         for f in files:
             ui.warn(msg % uipathfn(f))
         return int(len(files) > 0)
 
     if after:
         remove = deleted
         result = warn(
             modified + added + clean, _(b'not removing %s: file still exists\n')
         )
     else:
         remove = deleted + clean
         result = warn(
             modified,
             _(
                 b'not removing %s: file is modified (use -f'
                 b' to force removal)\n'
             ),
         )
         result = (
             warn(
                 added,
                 _(
                     b'not removing %s: file has been marked for add'
                     b' (use forget to undo)\n'
                 ),
             )
             or result
         )
 
     # Need to lock because standin files are deleted then removed from the
     # repository and we could race in-between.
     with repo.wlock():
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         for f in sorted(remove):
             if ui.verbose or not m.exact(f):
                 ui.status(_(b'removing %s\n') % uipathfn(f))
 
             if not dryrun:
                 if not after:
                     repo.wvfs.unlinkpath(f, ignoremissing=True)
 
         if dryrun:
             return result
 
         remove = [lfutil.standin(f) for f in remove]
         # If this is being called by addremove, let the original addremove
         # function handle this.
         if not isaddremove:
             for f in remove:
                 repo.wvfs.unlinkpath(f, ignoremissing=True)
         repo[None].forget(remove)
 
         for f in remove:
             lfdirstate.set_untracked(lfutil.splitstandin(f))
 
         lfdirstate.write(repo.currenttransaction())
 
     return result
 
 
 # For overriding mercurial.hgweb.webcommands so that largefiles will
 # appear at their right place in the manifests.
 @eh.wrapfunction(webcommands, 'decodepath')
 def decodepath(orig, path):
     return lfutil.splitstandin(path) or path
 
 
 # -- Wrappers: modify existing commands --------------------------------
 
 
 @eh.wrapcommand(
     b'add',
     opts=[
         (b'', b'large', None, _(b'add as largefile')),
         (b'', b'normal', None, _(b'add as normal file')),
         (
             b'',
             b'lfsize',
             b'',
             _(
                 b'add all files above this size (in megabytes) '
                 b'as largefiles (default: 10)'
             ),
         ),
     ],
 )
 def overrideadd(orig, ui, repo, *pats, **opts):
     if opts.get('normal') and opts.get('large'):
         raise error.Abort(_(b'--normal cannot be used with --large'))
     return orig(ui, repo, *pats, **opts)
 
 
 @eh.wrapfunction(cmdutil, 'add')
 def cmdutiladd(orig, ui, repo, matcher, prefix, uipathfn, explicitonly, **opts):
     # The --normal flag short circuits this override
     if opts.get('normal'):
         return orig(ui, repo, matcher, prefix, uipathfn, explicitonly, **opts)
 
     ladded, lbad = addlargefiles(ui, repo, False, matcher, uipathfn, **opts)
     normalmatcher = composenormalfilematcher(
         matcher, repo[None].manifest(), ladded
     )
     bad = orig(ui, repo, normalmatcher, prefix, uipathfn, explicitonly, **opts)
 
     bad.extend(f for f in lbad)
     return bad
 
 
 @eh.wrapfunction(cmdutil, 'remove')
 def cmdutilremove(
     orig, ui, repo, matcher, prefix, uipathfn, after, force, subrepos, dryrun
 ):
     normalmatcher = composenormalfilematcher(matcher, repo[None].manifest())
     result = orig(
         ui,
         repo,
         normalmatcher,
         prefix,
         uipathfn,
         after,
         force,
         subrepos,
         dryrun,
     )
     return (
         removelargefiles(
             ui, repo, False, matcher, uipathfn, dryrun, after=after, force=force
         )
         or result
     )
 
 
 @eh.wrapfunction(dirstate.dirstate, '_changing')
 @contextlib.contextmanager
 def _changing(orig, self, repo, change_type):
     pre = sub_dirstate = getattr(self, '_sub_dirstate', None)
     try:
         lfd = getattr(self, '_large_file_dirstate', False)
         if sub_dirstate is None and not lfd:
             sub_dirstate = lfutil.openlfdirstate(repo.ui, repo)
             self._sub_dirstate = sub_dirstate
         if not lfd:
             assert self._sub_dirstate is not None
         with orig(self, repo, change_type):
             if sub_dirstate is None:
                 yield
             else:
                 with sub_dirstate._changing(repo, change_type):
                     yield
     finally:
         self._sub_dirstate = pre
 
 
 @eh.wrapfunction(dirstate.dirstate, 'running_status')
 @contextlib.contextmanager
 def running_status(orig, self, repo):
     pre = sub_dirstate = getattr(self, '_sub_dirstate', None)
     try:
         lfd = getattr(self, '_large_file_dirstate', False)
         if sub_dirstate is None and not lfd:
             sub_dirstate = lfutil.openlfdirstate(repo.ui, repo)
             self._sub_dirstate = sub_dirstate
         if not lfd:
             assert self._sub_dirstate is not None
         with orig(self, repo):
             if sub_dirstate is None:
                 yield
             else:
                 with sub_dirstate.running_status(repo):
                     yield
     finally:
         self._sub_dirstate = pre
 
 
 @eh.wrapfunction(subrepo.hgsubrepo, 'status')
 def overridestatusfn(orig, repo, rev2, **opts):
     with lfstatus(repo._repo):
         return orig(repo, rev2, **opts)
 
 
 @eh.wrapcommand(b'status')
 def overridestatus(orig, ui, repo, *pats, **opts):
     with lfstatus(repo):
         return orig(ui, repo, *pats, **opts)
 
 
 @eh.wrapfunction(subrepo.hgsubrepo, 'dirty')
 def overridedirty(orig, repo, ignoreupdate=False, missing=False):
     with lfstatus(repo._repo):
         return orig(repo, ignoreupdate=ignoreupdate, missing=missing)
 
 
 @eh.wrapcommand(b'log')
 def overridelog(orig, ui, repo, *pats, **opts):
     def overridematchandpats(
         orig,
         ctx,
         pats=(),
         opts=None,
         globbed=False,
         default=b'relpath',
         badfn=None,
     ):
         """Matcher that merges root directory with .hglf, suitable for log.
         It is still possible to match .hglf directly.
         For any listed files run log on the standin too.
         matchfn tries both the given filename and with .hglf stripped.
         """
         if opts is None:
             opts = {}
         matchandpats = orig(ctx, pats, opts, globbed, default, badfn=badfn)
         m, p = copy.copy(matchandpats)
 
         if m.always():
             # We want to match everything anyway, so there's no benefit trying
             # to add standins.
             return matchandpats
 
         pats = set(p)
 
         def fixpats(pat, tostandin=lfutil.standin):
             if pat.startswith(b'set:'):
                 return pat
 
             kindpat = matchmod._patsplit(pat, None)
 
             if kindpat[0] is not None:
                 return kindpat[0] + b':' + tostandin(kindpat[1])
             return tostandin(kindpat[1])
 
         cwd = repo.getcwd()
         if cwd:
             hglf = lfutil.shortname
             back = util.pconvert(repo.pathto(hglf)[: -len(hglf)])
 
             def tostandin(f):
                 # The file may already be a standin, so truncate the back
                 # prefix and test before mangling it.  This avoids turning
                 # 'glob:../.hglf/foo*' into 'glob:../.hglf/../.hglf/foo*'.
                 if f.startswith(back) and lfutil.splitstandin(f[len(back) :]):
                     return f
 
                 # An absolute path is from outside the repo, so truncate the
                 # path to the root before building the standin.  Otherwise cwd
                 # is somewhere in the repo, relative to root, and needs to be
                 # prepended before building the standin.
                 if os.path.isabs(cwd):
                     f = f[len(back) :]
                 else:
                     f = cwd + b'/' + f
                 return back + lfutil.standin(f)
 
         else:
 
             def tostandin(f):
                 if lfutil.isstandin(f):
                     return f
                 return lfutil.standin(f)
 
         pats.update(fixpats(f, tostandin) for f in p)
 
         m._was_tampered_with = True
 
         for i in range(0, len(m._files)):
             # Don't add '.hglf' to m.files, since that is already covered by '.'
             if m._files[i] == b'.':
                 continue
             standin = lfutil.standin(m._files[i])
             # If the "standin" is a directory, append instead of replace to
             # support naming a directory on the command line with only
             # largefiles.  The original directory is kept to support normal
             # files.
             if standin in ctx:
                 m._files[i] = standin
             elif m._files[i] not in ctx and repo.wvfs.isdir(standin):
                 m._files.append(standin)
 
         m._fileset = set(m._files)
         m.always = lambda: False
         origmatchfn = m.matchfn
 
         def lfmatchfn(f):
             lf = lfutil.splitstandin(f)
             if lf is not None and origmatchfn(lf):
                 return True
             r = origmatchfn(f)
             return r
 
         m.matchfn = lfmatchfn
 
         ui.debug(b'updated patterns: %s\n' % b', '.join(sorted(pats)))
         return m, pats
 
     # For hg log --patch, the match object is used in two different senses:
     # (1) to determine what revisions should be printed out, and
     # (2) to determine what files to print out diffs for.
     # The magic matchandpats override should be used for case (1) but not for
     # case (2).
     oldmatchandpats = scmutil.matchandpats
 
     def overridemakefilematcher(orig, repo, pats, opts, badfn=None):
         wctx = repo[None]
         match, pats = oldmatchandpats(wctx, pats, opts, badfn=badfn)
         return lambda ctx: match
 
     wrappedmatchandpats = extensions.wrappedfunction(
         scmutil, 'matchandpats', overridematchandpats
     )
     wrappedmakefilematcher = extensions.wrappedfunction(
         logcmdutil, '_makenofollowfilematcher', overridemakefilematcher
     )
     with wrappedmatchandpats, wrappedmakefilematcher:
         return orig(ui, repo, *pats, **opts)
 
 
 @eh.wrapcommand(
     b'verify',
     opts=[
         (
             b'',
             b'large',
             None,
             _(b'verify that all largefiles in current revision exists'),
         ),
         (
             b'',
             b'lfa',
             None,
             _(b'verify largefiles in all revisions, not just current'),
         ),
         (
             b'',
             b'lfc',
             None,
             _(b'verify local largefile contents, not just existence'),
         ),
     ],
 )
 def overrideverify(orig, ui, repo, *pats, **opts):
     large = opts.pop('large', False)
     all = opts.pop('lfa', False)
     contents = opts.pop('lfc', False)
 
     result = orig(ui, repo, *pats, **opts)
     if large or all or contents:
         result = result or lfcommands.verifylfiles(ui, repo, all, contents)
     return result
 
 
 @eh.wrapcommand(
     b'debugstate',
     opts=[(b'', b'large', None, _(b'display largefiles dirstate'))],
 )
 def overridedebugstate(orig, ui, repo, *pats, **opts):
     large = opts.pop('large', False)
     if large:
 
         class fakerepo:
             dirstate = lfutil.openlfdirstate(ui, repo)
 
         orig(ui, fakerepo, *pats, **opts)
     else:
         orig(ui, repo, *pats, **opts)
 
 
 # Before starting the manifest merge, merge.updates will call
 # _checkunknownfile to check if there are any files in the merged-in
 # changeset that collide with unknown files in the working copy.
 #
 # The largefiles are seen as unknown, so this prevents us from merging
 # in a file 'foo' if we already have a largefile with the same name.
 #
 # The overridden function filters the unknown files by removing any
 # largefiles. This makes the merge proceed and we can then handle this
 # case further in the overridden calculateupdates function below.
 @eh.wrapfunction(merge, '_checkunknownfile')
 def overridecheckunknownfile(
     origfn, dirstate, wvfs, dircache, wctx, mctx, f, f2=None
 ):
     if lfutil.standin(dirstate.normalize(f)) in wctx:
         return False
     return origfn(dirstate, wvfs, dircache, wctx, mctx, f, f2)
 
 
 # The manifest merge handles conflicts on the manifest level. We want
 # to handle changes in largefile-ness of files at this level too.
 #
 # The strategy is to run the original calculateupdates and then process
 # the action list it outputs. There are two cases we need to deal with:
 #
 # 1. Normal file in p1, largefile in p2. Here the largefile is
 #    detected via its standin file, which will enter the working copy
 #    with a "get" action. It is not "merge" since the standin is all
 #    Mercurial is concerned with at this level -- the link to the
 #    existing normal file is not relevant here.
 #
 # 2. Largefile in p1, normal file in p2. Here we get a "merge" action
 #    since the largefile will be present in the working copy and
 #    different from the normal file in p2. Mercurial therefore
 #    triggers a merge action.
 #
 # In both cases, we prompt the user and emit new actions to either
 # remove the standin (if the normal file was kept) or to remove the
 # normal file and get the standin (if the largefile was kept). The
 # default prompt answer is to use the largefile version since it was
 # presumably changed on purpose.
 #
 # Finally, the merge.applyupdates function will then take care of
 # writing the files into the working copy and lfcommands.updatelfiles
 # will update the largefiles.
 @eh.wrapfunction(merge, 'calculateupdates')
 def overridecalculateupdates(
     origfn, repo, p1, p2, pas, branchmerge, force, acceptremote, *args, **kwargs
 ):
     overwrite = force and not branchmerge
     mresult = origfn(
         repo, p1, p2, pas, branchmerge, force, acceptremote, *args, **kwargs
     )
 
     if overwrite:
         return mresult
 
     # Convert to dictionary with filename as key and action as value.
     lfiles = set()
     for f in mresult.files():
         splitstandin = lfutil.splitstandin(f)
         if splitstandin is not None and splitstandin in p1:
             lfiles.add(splitstandin)
         elif lfutil.standin(f) in p1:
             lfiles.add(f)
 
     for lfile in sorted(lfiles):
         standin = lfutil.standin(lfile)
         (lm, largs, lmsg) = mresult.getfile(lfile, (None, None, None))
         (sm, sargs, smsg) = mresult.getfile(standin, (None, None, None))
 
         if sm in (ACTION_GET, ACTION_DELETED_CHANGED) and lm != ACTION_REMOVE:
             if sm == ACTION_DELETED_CHANGED:
                 f1, f2, fa, move, anc = sargs
                 sargs = (p2[f2].flags(), False)
             # Case 1: normal file in the working copy, largefile in
             # the second parent
             usermsg = (
                 _(
                     b'remote turned local normal file %s into a largefile\n'
                     b'use (l)argefile or keep (n)ormal file?'
                     b'$$ &Largefile $$ &Normal file'
                 )
                 % lfile
             )
             if repo.ui.promptchoice(usermsg, 0) == 0:  # pick remote largefile
                 mresult.addfile(
                     lfile, ACTION_REMOVE, None, b'replaced by standin'
                 )
                 mresult.addfile(standin, ACTION_GET, sargs, b'replaces standin')
             else:  # keep local normal file
                 mresult.addfile(lfile, ACTION_KEEP, None, b'replaces standin')
                 if branchmerge:
                     mresult.addfile(
                         standin,
                         ACTION_KEEP,
                         None,
                         b'replaced by non-standin',
                     )
                 else:
                     mresult.addfile(
                         standin,
                         ACTION_REMOVE,
                         None,
                         b'replaced by non-standin',
                     )
         if lm in (ACTION_GET, ACTION_DELETED_CHANGED) and sm != ACTION_REMOVE:
             if lm == ACTION_DELETED_CHANGED:
                 f1, f2, fa, move, anc = largs
                 largs = (p2[f2].flags(), False)
             # Case 2: largefile in the working copy, normal file in
             # the second parent
             usermsg = (
                 _(
                     b'remote turned local largefile %s into a normal file\n'
                     b'keep (l)argefile or use (n)ormal file?'
                     b'$$ &Largefile $$ &Normal file'
                 )
                 % lfile
             )
             if repo.ui.promptchoice(usermsg, 0) == 0:  # keep local largefile
                 if branchmerge:
                     # largefile can be restored from standin safely
                     mresult.addfile(
                         lfile,
                         ACTION_KEEP,
                         None,
                         b'replaced by standin',
                     )
                     mresult.addfile(
                         standin, ACTION_KEEP, None, b'replaces standin'
                     )
                 else:
                     # "lfile" should be marked as "removed" without
                     # removal of itself
                     mresult.addfile(
                         lfile,
                         MERGE_ACTION_LARGEFILE_MARK_REMOVED,
                         None,
                         b'forget non-standin largefile',
                     )
 
                     # linear-merge should treat this largefile as 're-added'
                     mresult.addfile(standin, ACTION_ADD, None, b'keep standin')
             else:  # pick remote normal file
                 mresult.addfile(lfile, ACTION_GET, largs, b'replaces standin')
                 mresult.addfile(
                     standin,
                     ACTION_REMOVE,
                     None,
                     b'replaced by non-standin',
                 )
 
     return mresult
 
 
 @eh.wrapfunction(mergestatemod, 'recordupdates')
 def mergerecordupdates(orig, repo, actions, branchmerge, getfiledata):
     if MERGE_ACTION_LARGEFILE_MARK_REMOVED in actions:
         lfdirstate = lfutil.openlfdirstate(repo.ui, repo)
         for lfile, args, msg in actions[MERGE_ACTION_LARGEFILE_MARK_REMOVED]:
             # this should be executed before 'orig', to execute 'remove'
             # before all other actions
             repo.dirstate.update_file(lfile, p1_tracked=True, wc_tracked=False)
             # make sure lfile doesn't get synclfdirstate'd as normal
             lfdirstate.update_file(lfile, p1_tracked=False, wc_tracked=True)
 
     return orig(repo, actions, branchmerge, getfiledata)
 
 
 # Override filemerge to prompt the user about how they wish to merge
 # largefiles. This will handle identical edits without prompting the user.
 @eh.wrapfunction(filemerge, 'filemerge')
 def overridefilemerge(
     origfn, repo, wctx, mynode, orig, fcd, fco, fca, labels=None
 ):
     if not lfutil.isstandin(orig) or fcd.isabsent() or fco.isabsent():
         return origfn(repo, wctx, mynode, orig, fcd, fco, fca, labels=labels)
 
     ahash = lfutil.readasstandin(fca).lower()
     dhash = lfutil.readasstandin(fcd).lower()
     ohash = lfutil.readasstandin(fco).lower()
     if (
         ohash != ahash
         and ohash != dhash
         and (
             dhash == ahash
             or repo.ui.promptchoice(
                 _(
                     b'largefile %s has a merge conflict\nancestor was %s\n'
                     b'you can keep (l)ocal %s or take (o)ther %s.\n'
                     b'what do you want to do?'
                     b'$$ &Local $$ &Other'
                 )
                 % (lfutil.splitstandin(orig), ahash, dhash, ohash),
                 0,
             )
             == 1
         )
     ):
         repo.wwrite(fcd.path(), fco.data(), fco.flags())
     return 0, False
 
 
 @eh.wrapfunction(copiesmod, 'pathcopies')
 def copiespathcopies(orig, ctx1, ctx2, match=None):
     copies = orig(ctx1, ctx2, match=match)
     updated = {}
 
     for k, v in copies.items():
         updated[lfutil.splitstandin(k) or k] = lfutil.splitstandin(v) or v
 
     return updated
 
 
 # Copy first changes the matchers to match standins instead of
 # largefiles.  Then it overrides util.copyfile in that function it
 # checks if the destination largefile already exists. It also keeps a
 # list of copied files so that the largefiles can be copied and the
 # dirstate updated.
 @eh.wrapfunction(cmdutil, 'copy')
 def overridecopy(orig, ui, repo, pats, opts, rename=False):
     # doesn't remove largefile on rename
     if len(pats) < 2:
         # this isn't legal, let the original function deal with it
         return orig(ui, repo, pats, opts, rename)
 
     # This could copy both lfiles and normal files in one command,
     # but we don't want to do that. First replace their matcher to
     # only match normal files and run it, then replace it to just
     # match largefiles and run it again.
     nonormalfiles = False
     nolfiles = False
     manifest = repo[None].manifest()
 
     def normalfilesmatchfn(
         orig,
         ctx,
         pats=(),
         opts=None,
         globbed=False,
         default=b'relpath',
         badfn=None,
     ):
         if opts is None:
             opts = {}
         match = orig(ctx, pats, opts, globbed, default, badfn=badfn)
         return composenormalfilematcher(match, manifest)
 
     with extensions.wrappedfunction(scmutil, 'match', normalfilesmatchfn):
         try:
             result = orig(ui, repo, pats, opts, rename)
         except error.Abort as e:
             if e.message != _(b'no files to copy'):
                 raise e
             else:
                 nonormalfiles = True
             result = 0
 
     # The first rename can cause our current working directory to be removed.
     # In that case there is nothing left to copy/rename so just quit.
     try:
         repo.getcwd()
     except OSError:
         return result
 
     def makestandin(relpath):
         path = pathutil.canonpath(repo.root, repo.getcwd(), relpath)
         return repo.wvfs.join(lfutil.standin(path))
 
     fullpats = scmutil.expandpats(pats)
     dest = fullpats[-1]
 
     if os.path.isdir(dest):
         if not os.path.isdir(makestandin(dest)):
             os.makedirs(makestandin(dest))
 
     # When we call orig below it creates the standins but we don't add
     # them to the dir state until later so lock during that time.
     wlock = repo.wlock()
 
     try:
         manifest = repo[None].manifest()
 
         def overridematch(
             orig,
             ctx,
             pats=(),
             opts=None,
             globbed=False,
             default=b'relpath',
             badfn=None,
         ):
             if opts is None:
                 opts = {}
             newpats = []
             # The patterns were previously mangled to add the standin
             # directory; we need to remove that now
             for pat in pats:
                 if matchmod.patkind(pat) is None and lfutil.shortname in pat:
                     newpats.append(pat.replace(lfutil.shortname, b''))
                 else:
                     newpats.append(pat)
             match = orig(ctx, newpats, opts, globbed, default, badfn=badfn)
             m = copy.copy(match)
             m._was_tampered_with = True
             lfile = lambda f: lfutil.standin(f) in manifest
             m._files = [lfutil.standin(f) for f in m._files if lfile(f)]
             m._fileset = set(m._files)
             origmatchfn = m.matchfn
 
             def matchfn(f):
                 lfile = lfutil.splitstandin(f)
                 return (
                     lfile is not None
                     and (f in manifest)
                     and origmatchfn(lfile)
                     or None
                 )
 
             m.matchfn = matchfn
             return m
 
         listpats = []
         for pat in pats:
             if matchmod.patkind(pat) is not None:
                 listpats.append(pat)
             else:
                 listpats.append(makestandin(pat))
 
         copiedfiles = []
 
         def overridecopyfile(orig, src, dest, *args, **kwargs):
             if lfutil.shortname in src and dest.startswith(
                 repo.wjoin(lfutil.shortname)
             ):
                 destlfile = dest.replace(lfutil.shortname, b'')
                 if not opts[b'force'] and os.path.exists(destlfile):
                     raise IOError(
                         b'', _(b'destination largefile already exists')
                     )
             copiedfiles.append((src, dest))
             orig(src, dest, *args, **kwargs)
 
         with extensions.wrappedfunction(util, 'copyfile', overridecopyfile):
             with extensions.wrappedfunction(scmutil, 'match', overridematch):
                 result += orig(ui, repo, listpats, opts, rename)
 
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         for src, dest in copiedfiles:
             if lfutil.shortname in src and dest.startswith(
                 repo.wjoin(lfutil.shortname)
             ):
                 srclfile = src.replace(repo.wjoin(lfutil.standin(b'')), b'')
                 destlfile = dest.replace(repo.wjoin(lfutil.standin(b'')), b'')
                 destlfiledir = repo.wvfs.dirname(repo.wjoin(destlfile)) or b'.'
                 if not os.path.isdir(destlfiledir):
                     os.makedirs(destlfiledir)
                 if rename:
                     os.rename(repo.wjoin(srclfile), repo.wjoin(destlfile))
 
                     # The file is gone, but this deletes any empty parent
                     # directories as a side-effect.
                     repo.wvfs.unlinkpath(srclfile, ignoremissing=True)
                     lfdirstate.set_untracked(srclfile)
                 else:
                     util.copyfile(repo.wjoin(srclfile), repo.wjoin(destlfile))
 
                 lfdirstate.set_tracked(destlfile)
         lfdirstate.write(repo.currenttransaction())
     except error.Abort as e:
         if e.message != _(b'no files to copy'):
             raise e
         else:
             nolfiles = True
     finally:
         wlock.release()
 
     if nolfiles and nonormalfiles:
         raise error.Abort(_(b'no files to copy'))
 
     return result
 
 
 # When the user calls revert, we have to be careful to not revert any
 # changes to other largefiles accidentally. This means we have to keep
 # track of the largefiles that are being reverted so we only pull down
 # the necessary largefiles.
 #
 # Standins are only updated (to match the hash of largefiles) before
 # commits. Update the standins then run the original revert, changing
 # the matcher to hit standins instead of largefiles. Based on the
 # resulting standins update the largefiles.
 @eh.wrapfunction(cmdutil, 'revert')
 def overriderevert(orig, ui, repo, ctx, *pats, **opts):
     # Because we put the standins in a bad state (by updating them)
     # and then return them to a correct state we need to lock to
     # prevent others from changing them in their incorrect state.
     with repo.wlock(), repo.dirstate.running_status(repo):
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         s = lfutil.lfdirstatestatus(lfdirstate, repo)
         lfdirstate.write(repo.currenttransaction())
         for lfile in s.modified:
             lfutil.updatestandin(repo, lfile, lfutil.standin(lfile))
         for lfile in s.deleted:
             fstandin = lfutil.standin(lfile)
             if repo.wvfs.exists(fstandin):
                 repo.wvfs.unlink(fstandin)
 
         oldstandins = lfutil.getstandinsstate(repo)
 
         def overridematch(
             orig,
             mctx,
             pats=(),
             opts=None,
             globbed=False,
             default=b'relpath',
             badfn=None,
         ):
             if opts is None:
                 opts = {}
             match = orig(mctx, pats, opts, globbed, default, badfn=badfn)
             m = copy.copy(match)
             m._was_tampered_with = True
 
             # revert supports recursing into subrepos, and though largefiles
             # currently doesn't work correctly in that case, this match is
             # called, so the lfdirstate above may not be the correct one for
             # this invocation of match.
             lfdirstate = lfutil.openlfdirstate(
                 mctx.repo().ui, mctx.repo(), False
             )
 
             wctx = repo[None]
             matchfiles = []
             for f in m._files:
                 standin = lfutil.standin(f)
                 if standin in ctx or standin in mctx:
                     matchfiles.append(standin)
                 elif standin in wctx or lfdirstate.get_entry(f).removed:
                     continue
                 else:
                     matchfiles.append(f)
             m._files = matchfiles
             m._fileset = set(m._files)
             origmatchfn = m.matchfn
 
             def matchfn(f):
                 lfile = lfutil.splitstandin(f)
                 if lfile is not None:
                     return origmatchfn(lfile) and (f in ctx or f in mctx)
                 return origmatchfn(f)
 
             m.matchfn = matchfn
             return m
 
         with extensions.wrappedfunction(scmutil, 'match', overridematch):
             orig(ui, repo, ctx, *pats, **opts)
 
         newstandins = lfutil.getstandinsstate(repo)
         filelist = lfutil.getlfilestoupdate(oldstandins, newstandins)
         # lfdirstate should be 'normallookup'-ed for updated files,
         # because reverting doesn't touch dirstate for 'normal' files
         # when target revision is explicitly specified: in such case,
         # 'n' and valid timestamp in dirstate doesn't ensure 'clean'
         # of target (standin) file.
         lfcommands.updatelfiles(
             ui, repo, filelist, printmessage=False, normallookup=True
         )
 
 
 # after pulling changesets, we need to take some extra care to get
 # largefiles updated remotely
 @eh.wrapcommand(
     b'pull',
     opts=[
         (
             b'',
             b'all-largefiles',
             None,
             _(b'download all pulled versions of largefiles (DEPRECATED)'),
         ),
         (
             b'',
             b'lfrev',
             [],
             _(b'download largefiles for these revisions'),
             _(b'REV'),
         ),
     ],
 )
 def overridepull(orig, ui, repo, source=None, **opts):
     revsprepull = len(repo)
     if not source:
         source = b'default'
     repo.lfpullsource = source
     result = orig(ui, repo, source, **opts)
     revspostpull = len(repo)
     lfrevs = opts.get('lfrev', [])
     if opts.get('all_largefiles'):
         lfrevs.append(b'pulled()')
     if lfrevs and revspostpull > revsprepull:
         numcached = 0
         repo.firstpulled = revsprepull  # for pulled() revset expression
         try:
             for rev in logcmdutil.revrange(repo, lfrevs):
                 ui.note(_(b'pulling largefiles for revision %d\n') % rev)
                 (cached, missing) = lfcommands.cachelfiles(ui, repo, rev)
                 numcached += len(cached)
         finally:
             del repo.firstpulled
         ui.status(_(b"%d largefiles cached\n") % numcached)
     return result
 
 
 @eh.wrapcommand(
     b'push',
     opts=[
         (
             b'',
             b'lfrev',
             [],
             _(b'upload largefiles for these revisions'),
             _(b'REV'),
         )
     ],
 )
 def overridepush(orig, ui, repo, *args, **kwargs):
     """Override push command and store --lfrev parameters in opargs"""
     lfrevs = kwargs.pop('lfrev', None)
     if lfrevs:
         opargs = kwargs.setdefault('opargs', {})
         opargs[b'lfrevs'] = logcmdutil.revrange(repo, lfrevs)
     return orig(ui, repo, *args, **kwargs)
 
 
 @eh.wrapfunction(exchange, 'pushoperation')
 def exchangepushoperation(orig, *args, **kwargs):
     """Override pushoperation constructor and store lfrevs parameter"""
     lfrevs = kwargs.pop('lfrevs', None)
     pushop = orig(*args, **kwargs)
     pushop.lfrevs = lfrevs
     return pushop
 
 
 @eh.revsetpredicate(b'pulled()')
 def pulledrevsetsymbol(repo, subset, x):
     """Changesets that just has been pulled.
 
     Only available with largefiles from pull --lfrev expressions.
 
     .. container:: verbose
 
       Some examples:
 
       - pull largefiles for all new changesets::
 
           hg pull -lfrev "pulled()"
 
       - pull largefiles for all new branch heads::
 
           hg pull -lfrev "head(pulled()) and not closed()"
 
     """
 
     try:
         firstpulled = repo.firstpulled
     except AttributeError:
         raise error.Abort(_(b"pulled() only available in --lfrev"))
     return smartset.baseset([r for r in subset if r >= firstpulled])
 
 
 @eh.wrapcommand(
     b'clone',
     opts=[
         (
             b'',
             b'all-largefiles',
             None,
             _(b'download all versions of all largefiles'),
         )
     ],
 )
 def overrideclone(orig, ui, source, dest=None, **opts):
     d = dest
     if d is None:
         d = hg.defaultdest(source)
-    if opts.get('all_largefiles') and not hg.islocal(d):
+    if opts.get('all_largefiles') and urlutil.url(d).scheme not in (
+        b'file',
+        None,
+    ):
         raise error.Abort(
             _(b'--all-largefiles is incompatible with non-local destination %s')
             % d
         )
 
     return orig(ui, source, dest, **opts)
 
 
 @eh.wrapfunction(hg, 'clone')
 def hgclone(orig, ui, opts, *args, **kwargs):
     result = orig(ui, opts, *args, **kwargs)
 
     if result is not None:
         sourcerepo, destrepo = result
         repo = destrepo.local()
 
         # When cloning to a remote repo (like through SSH), no repo is available
         # from the peer.   Therefore the largefiles can't be downloaded and the
         # hgrc can't be updated.
         if not repo:
             return result
 
         # Caching is implicitly limited to 'rev' option, since the dest repo was
         # truncated at that point.  The user may expect a download count with
         # this option, so attempt whether or not this is a largefile repo.
         if opts.get(b'all_largefiles'):
             success, missing = lfcommands.downloadlfiles(ui, repo)
 
             if missing != 0:
                 return None
 
     return result
 
 
 @eh.wrapcommand(b'rebase', extension=b'rebase')
 def overriderebasecmd(orig, ui, repo, **opts):
     if not hasattr(repo, '_largefilesenabled'):
         return orig(ui, repo, **opts)
 
     resuming = opts.get('continue')
     repo._lfcommithooks.append(lfutil.automatedcommithook(resuming))
     repo._lfstatuswriters.append(lambda *msg, **opts: None)
     try:
         with ui.configoverride(
             {(b'rebase', b'experimental.inmemory'): False}, b"largefiles"
         ):
             return orig(ui, repo, **opts)
     finally:
         repo._lfstatuswriters.pop()
         repo._lfcommithooks.pop()
 
 
 @eh.extsetup
 def overriderebase(ui):
     try:
         rebase = extensions.find(b'rebase')
     except KeyError:
         pass
     else:
 
         def _dorebase(orig, *args, **kwargs):
             kwargs['inmemory'] = False
             return orig(*args, **kwargs)
 
         extensions.wrapfunction(rebase, '_dorebase', _dorebase)
 
 
 @eh.wrapcommand(b'archive')
 def overridearchivecmd(orig, ui, repo, dest, **opts):
     with lfstatus(repo.unfiltered()):
         return orig(ui, repo.unfiltered(), dest, **opts)
 
 
 @eh.wrapfunction(webcommands, 'archive')
 def hgwebarchive(orig, web):
     with lfstatus(web.repo):
         return orig(web)
 
 
 @eh.wrapfunction(archival, 'archive')
 def overridearchive(
     orig,
     repo,
     dest,
     node,
     kind,
     decode=True,
     match: Optional[matchmod.basematcher] = None,
     prefix=b'',
     mtime=None,
     subrepos=None,
 ):
     # For some reason setting repo.lfstatus in hgwebarchive only changes the
     # unfiltered repo's attr, so check that as well.
     if not repo.lfstatus and not repo.unfiltered().lfstatus:
         return orig(
             repo, dest, node, kind, decode, match, prefix, mtime, subrepos
         )
 
     # No need to lock because we are only reading history and
     # largefile caches, neither of which are modified.
     if node is not None:
         lfcommands.cachelfiles(repo.ui, repo, node)
 
     if kind not in archival.archivers:
         raise error.Abort(_(b"unknown archive type '%s'") % kind)
 
     ctx = repo[node]
 
     if kind == b'files':
         if prefix:
             raise error.Abort(_(b'cannot give prefix when archiving to files'))
     else:
         prefix = archival.tidyprefix(dest, kind, prefix)
 
     if not match:
         match = scmutil.matchall(repo)
 
     def write(name, mode, islink, getdata):
         if not match(name):
             return
         data = getdata()
         if decode:
             data = repo.wwritedata(name, data)
         archiver.addfile(prefix + name, mode, islink, data)
 
     archiver = archival.archivers[kind](dest, mtime or ctx.date()[0])
 
     if repo.ui.configbool(b"ui", b"archivemeta"):
         write(
             b'.hg_archival.txt',
             0o644,
             False,
             lambda: archival.buildmetadata(ctx),
         )
 
     for f in ctx:
         ff = ctx.flags(f)
         getdata = ctx[f].data
         lfile = lfutil.splitstandin(f)
         if lfile is not None:
             if node is not None:
                 path = lfutil.findfile(repo, getdata().strip())
 
                 if path is None:
                     raise error.Abort(
                         _(
                             b'largefile %s not found in repo store or system cache'
                         )
                         % lfile
                     )
             else:
                 path = lfile
 
             f = lfile
 
             getdata = lambda: util.readfile(path)
         write(f, b'x' in ff and 0o755 or 0o644, b'l' in ff, getdata)
 
     if subrepos:
         for subpath in sorted(ctx.substate):
             sub = ctx.workingsub(subpath)
             submatch = matchmod.subdirmatcher(subpath, match)
             subprefix = prefix + subpath + b'/'
 
             # TODO: Only hgsubrepo instances have `_repo`, so figure out how to
             # infer and possibly set lfstatus in hgsubrepoarchive.  That would
             # allow only hgsubrepos to set this, instead of the current scheme
             # where the parent sets this for the child.
             with (
                 hasattr(sub, '_repo')
                 and lfstatus(sub._repo)
                 or util.nullcontextmanager()
             ):
                 sub.archive(archiver, subprefix, submatch)
 
     archiver.done()
 
 
 @eh.wrapfunction(subrepo.hgsubrepo, 'archive')
 def hgsubrepoarchive(
     orig, repo, archiver, prefix, match: matchmod.basematcher, decode=True
 ):
     lfenabled = hasattr(repo._repo, '_largefilesenabled')
     if not lfenabled or not repo._repo.lfstatus:
         return orig(repo, archiver, prefix, match, decode)
 
     repo._get(repo._state + (b'hg',))
     rev = repo._state[1]
     ctx = repo._repo[rev]
 
     if ctx.node() is not None:
         lfcommands.cachelfiles(repo.ui, repo._repo, ctx.node())
 
     def write(name, mode, islink, getdata):
         # At this point, the standin has been replaced with the largefile name,
         # so the normal matcher works here without the lfutil variants.
         if not match(f):
             return
         data = getdata()
         if decode:
             data = repo._repo.wwritedata(name, data)
 
         archiver.addfile(prefix + name, mode, islink, data)
 
     for f in ctx:
         ff = ctx.flags(f)
         getdata = ctx[f].data
         lfile = lfutil.splitstandin(f)
         if lfile is not None:
             if ctx.node() is not None:
                 path = lfutil.findfile(repo._repo, getdata().strip())
 
                 if path is None:
                     raise error.Abort(
                         _(
                             b'largefile %s not found in repo store or system cache'
                         )
                         % lfile
                     )
             else:
                 path = lfile
 
             f = lfile
 
             getdata = lambda: util.readfile(os.path.join(prefix, path))
 
         write(f, b'x' in ff and 0o755 or 0o644, b'l' in ff, getdata)
 
     for subpath in sorted(ctx.substate):
         sub = ctx.workingsub(subpath)
         submatch = matchmod.subdirmatcher(subpath, match)
         subprefix = prefix + subpath + b'/'
         # TODO: Only hgsubrepo instances have `_repo`, so figure out how to
         # infer and possibly set lfstatus at the top of this function.  That
         # would allow only hgsubrepos to set this, instead of the current scheme
         # where the parent sets this for the child.
         with (
             hasattr(sub, '_repo')
             and lfstatus(sub._repo)
             or util.nullcontextmanager()
         ):
             sub.archive(archiver, subprefix, submatch, decode)
 
 
 # If a largefile is modified, the change is not reflected in its
 # standin until a commit. cmdutil.bailifchanged() raises an exception
 # if the repo has uncommitted changes. Wrap it to also check if
 # largefiles were changed. This is used by bisect, backout and fetch.
 @eh.wrapfunction(cmdutil, 'bailifchanged')
 def overridebailifchanged(orig, repo, *args, **kwargs):
     orig(repo, *args, **kwargs)
     with lfstatus(repo):
         s = repo.status()
     if s.modified or s.added or s.removed or s.deleted:
         raise error.Abort(_(b'uncommitted changes'))
 
 
 @eh.wrapfunction(cmdutil, 'postcommitstatus')
 def postcommitstatus(orig, repo, *args, **kwargs):
     with lfstatus(repo):
         return orig(repo, *args, **kwargs)
 
 
 @eh.wrapfunction(cmdutil, 'forget')
 def cmdutilforget(
     orig, ui, repo, match, prefix, uipathfn, explicitonly, dryrun, interactive
 ):
     normalmatcher = composenormalfilematcher(match, repo[None].manifest())
     bad, forgot = orig(
         ui,
         repo,
         normalmatcher,
         prefix,
         uipathfn,
         explicitonly,
         dryrun,
         interactive,
     )
     m = composelargefilematcher(match, repo[None].manifest())
 
     with lfstatus(repo):
         s = repo.status(match=m, clean=True)
     manifest = repo[None].manifest()
     forget = sorted(s.modified + s.added + s.deleted + s.clean)
     forget = [f for f in forget if lfutil.standin(f) in manifest]
 
     for f in forget:
         fstandin = lfutil.standin(f)
         if fstandin not in repo.dirstate and not repo.wvfs.isdir(fstandin):
             ui.warn(
                 _(b'not removing %s: file is already untracked\n') % uipathfn(f)
             )
             bad.append(f)
 
     for f in forget:
         if ui.verbose or not m.exact(f):
             ui.status(_(b'removing %s\n') % uipathfn(f))
 
     # Need to lock because standin files are deleted then removed from the
     # repository and we could race in-between.
     with repo.wlock():
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         for f in forget:
             lfdirstate.set_untracked(f)
         lfdirstate.write(repo.currenttransaction())
         standins = [lfutil.standin(f) for f in forget]
         for f in standins:
             repo.wvfs.unlinkpath(f, ignoremissing=True)
         rejected = repo[None].forget(standins)
 
     bad.extend(f for f in rejected if f in m.files())
     forgot.extend(f for f in forget if f not in rejected)
     return bad, forgot
 
 
 def _getoutgoings(repo, other, missing, addfunc):
     """get pairs of filename and largefile hash in outgoing revisions
     in 'missing'.
 
     largefiles already existing on 'other' repository are ignored.
 
     'addfunc' is invoked with each unique pairs of filename and
     largefile hash value.
     """
     knowns = set()
     lfhashes = set()
 
     def dedup(fn, lfhash):
         k = (fn, lfhash)
         if k not in knowns:
             knowns.add(k)
             lfhashes.add(lfhash)
 
     lfutil.getlfilestoupload(repo, missing, dedup)
     if lfhashes:
         lfexists = storefactory.openstore(repo, other).exists(lfhashes)
         for fn, lfhash in knowns:
             if not lfexists[lfhash]:  # lfhash doesn't exist on "other"
                 addfunc(fn, lfhash)
 
 
 def outgoinghook(ui, repo, other, opts, missing):
     if opts.pop(b'large', None):
         lfhashes = set()
         if ui.debugflag:
             toupload = {}
 
             def addfunc(fn, lfhash):
                 if fn not in toupload:
                     toupload[fn] = []  # pytype: disable=unsupported-operands
                 toupload[fn].append(lfhash)
                 lfhashes.add(lfhash)
 
             def showhashes(fn):
                 for lfhash in sorted(toupload[fn]):
                     ui.debug(b'    %s\n' % lfhash)
 
         else:
             toupload = set()
 
             def addfunc(fn, lfhash):
                 toupload.add(fn)
                 lfhashes.add(lfhash)
 
             def showhashes(fn):
                 pass
 
         _getoutgoings(repo, other, missing, addfunc)
 
         if not toupload:
             ui.status(_(b'largefiles: no files to upload\n'))
         else:
             ui.status(
                 _(b'largefiles to upload (%d entities):\n') % (len(lfhashes))
             )
             for file in sorted(toupload):
                 ui.status(lfutil.splitstandin(file) + b'\n')
                 showhashes(file)
             ui.status(b'\n')
 
 
 @eh.wrapcommand(
     b'outgoing', opts=[(b'', b'large', None, _(b'display outgoing largefiles'))]
 )
 def _outgoingcmd(orig, *args, **kwargs):
     # Nothing to do here other than add the extra help option- the hook above
     # processes it.
     return orig(*args, **kwargs)
 
 
 def summaryremotehook(ui, repo, opts, changes):
     largeopt = opts.get(b'large', False)
     if changes is None:
         if largeopt:
             return (False, True)  # only outgoing check is needed
         else:
             return (False, False)
     elif largeopt:
         url, branch, peer, outgoing = changes[1]
         if peer is None:
             # i18n: column positioning for "hg summary"
             ui.status(_(b'largefiles: (no remote repo)\n'))
             return
 
         toupload = set()
         lfhashes = set()
 
         def addfunc(fn, lfhash):
             toupload.add(fn)
             lfhashes.add(lfhash)
 
         _getoutgoings(repo, peer, outgoing.missing, addfunc)
 
         if not toupload:
             # i18n: column positioning for "hg summary"
             ui.status(_(b'largefiles: (no files to upload)\n'))
         else:
             # i18n: column positioning for "hg summary"
             ui.status(
                 _(b'largefiles: %d entities for %d files to upload\n')
                 % (len(lfhashes), len(toupload))
             )
 
 
 @eh.wrapcommand(
     b'summary', opts=[(b'', b'large', None, _(b'display outgoing largefiles'))]
 )
 def overridesummary(orig, ui, repo, *pats, **opts):
     with lfstatus(repo):
         orig(ui, repo, *pats, **opts)
 
 
 @eh.wrapfunction(scmutil, 'addremove')
 def scmutiladdremove(
     orig,
     repo,
     matcher,
     prefix,
     uipathfn,
     opts=None,
     open_tr=None,
 ):
     if opts is None:
         opts = {}
     if not lfutil.islfilesrepo(repo):
         return orig(repo, matcher, prefix, uipathfn, opts, open_tr=open_tr)
 
     # open the transaction and changing_files context
     if open_tr is not None:
         open_tr()
 
     # Get the list of missing largefiles so we can remove them
     with repo.dirstate.running_status(repo):
         lfdirstate = lfutil.openlfdirstate(repo.ui, repo)
         unsure, s, mtime_boundary = lfdirstate.status(
             matchmod.always(),
             subrepos=[],
             ignored=False,
             clean=False,
             unknown=False,
         )
 
     # Call into the normal remove code, but the removing of the standin, we want
     # to have handled by original addremove.  Monkey patching here makes sure
     # we don't remove the standin in the largefiles code, preventing a very
     # confused state later.
     if s.deleted:
         m = copy.copy(matcher)
         m._was_tampered_with = True
 
         # The m._files and m._map attributes are not changed to the deleted list
         # because that affects the m.exact() test, which in turn governs whether
         # or not the file name is printed, and how.  Simply limit the original
         # matches to those in the deleted status list.
         matchfn = m.matchfn
         m.matchfn = lambda f: f in s.deleted and matchfn(f)
 
         removelargefiles(
             repo.ui,
             repo,
             True,
             m,
             uipathfn,
             opts.get(b'dry_run'),
             **pycompat.strkwargs(opts)
         )
     # Call into the normal add code, and any files that *should* be added as
     # largefiles will be
     added, bad = addlargefiles(
         repo.ui, repo, True, matcher, uipathfn, **pycompat.strkwargs(opts)
     )
     # Now that we've handled largefiles, hand off to the original addremove
     # function to take care of the rest.  Make sure it doesn't do anything with
     # largefiles by passing a matcher that will ignore them.
     matcher = composenormalfilematcher(matcher, repo[None].manifest(), added)
 
     return orig(repo, matcher, prefix, uipathfn, opts, open_tr=open_tr)
 
 
 # Calling purge with --all will cause the largefiles to be deleted.
 # Override repo.status to prevent this from happening.
 @eh.wrapcommand(b'purge')
 def overridepurge(orig, ui, repo, *dirs, **opts):
     # XXX Monkey patching a repoview will not work. The assigned attribute will
     # be set on the unfiltered repo, but we will only lookup attributes in the
     # unfiltered repo if the lookup in the repoview object itself fails. As the
     # monkey patched method exists on the repoview class the lookup will not
     # fail. As a result, the original version will shadow the monkey patched
     # one, defeating the monkey patch.
     #
     # As a work around we use an unfiltered repo here. We should do something
     # cleaner instead.
     repo = repo.unfiltered()
     oldstatus = repo.status
 
     def overridestatus(
         node1=b'.',
         node2=None,
         match=None,
         ignored=False,
         clean=False,
         unknown=False,
         listsubrepos=False,
     ):
         r = oldstatus(
             node1, node2, match, ignored, clean, unknown, listsubrepos
         )
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         unknown = [
             f for f in r.unknown if not lfdirstate.get_entry(f).any_tracked
         ]
         ignored = [
             f for f in r.ignored if not lfdirstate.get_entry(f).any_tracked
         ]
         return scmutil.status(
             r.modified, r.added, r.removed, r.deleted, unknown, ignored, r.clean
         )
 
     repo.status = overridestatus
     orig(ui, repo, *dirs, **opts)
     repo.status = oldstatus
 
 
 @eh.wrapcommand(b'rollback')
 def overriderollback(orig, ui, repo, **opts):
     with repo.wlock():
         before = repo.dirstate.parents()
         orphans = {
             f
             for f in repo.dirstate
             if lfutil.isstandin(f) and not repo.dirstate.get_entry(f).removed
         }
         result = orig(ui, repo, **opts)
         after = repo.dirstate.parents()
         if before == after:
             return result  # no need to restore standins
 
         pctx = repo[b'.']
         for f in repo.dirstate:
             if lfutil.isstandin(f):
                 orphans.discard(f)
                 if repo.dirstate.get_entry(f).removed:
                     repo.wvfs.unlinkpath(f, ignoremissing=True)
                 elif f in pctx:
                     fctx = pctx[f]
                     repo.wwrite(f, fctx.data(), fctx.flags())
                 else:
                     # content of standin is not so important in 'a',
                     # 'm' or 'n' (coming from the 2nd parent) cases
                     lfutil.writestandin(repo, f, b'', False)
         for standin in orphans:
             repo.wvfs.unlinkpath(standin, ignoremissing=True)
 
     return result
 
 
 @eh.wrapcommand(b'transplant', extension=b'transplant')
 def overridetransplant(orig, ui, repo, *revs, **opts):
     resuming = opts.get('continue')
     repo._lfcommithooks.append(lfutil.automatedcommithook(resuming))
     repo._lfstatuswriters.append(lambda *msg, **opts: None)
     try:
         result = orig(ui, repo, *revs, **opts)
     finally:
         repo._lfstatuswriters.pop()
         repo._lfcommithooks.pop()
     return result
 
 
 @eh.wrapcommand(b'cat')
 def overridecat(orig, ui, repo, file1, *pats, **opts):
     ctx = logcmdutil.revsingle(repo, opts.get('rev'))
     err = 1
     notbad = set()
     m = scmutil.match(ctx, (file1,) + pats, pycompat.byteskwargs(opts))
     m._was_tampered_with = True
     origmatchfn = m.matchfn
 
     def lfmatchfn(f):
         if origmatchfn(f):
             return True
         lf = lfutil.splitstandin(f)
         if lf is None:
             return False
         notbad.add(lf)
         return origmatchfn(lf)
 
     m.matchfn = lfmatchfn
     origbadfn = m.bad
 
     def lfbadfn(f, msg):
         if not f in notbad:
             origbadfn(f, msg)
 
     m.bad = lfbadfn
 
     origvisitdirfn = m.visitdir
 
     def lfvisitdirfn(dir):
         if dir == lfutil.shortname:
             return True
         ret = origvisitdirfn(dir)
         if ret:
             return ret
         lf = lfutil.splitstandin(dir)
         if lf is None:
             return False
         return origvisitdirfn(lf)
 
     m.visitdir = lfvisitdirfn
 
     for f in ctx.walk(m):
         with cmdutil.makefileobj(ctx, opts.get('output'), pathname=f) as fp:
             lf = lfutil.splitstandin(f)
             if lf is None or origmatchfn(f):
                 # duplicating unreachable code from commands.cat
                 data = ctx[f].data()
                 if opts.get('decode'):
                     data = repo.wwritedata(f, data)
                 fp.write(data)
             else:
                 hash = lfutil.readasstandin(ctx[f])
                 if not lfutil.inusercache(repo.ui, hash):
                     store = storefactory.openstore(repo)
                     success, missing = store.get([(lf, hash)])
                     if len(success) != 1:
                         raise error.Abort(
                             _(
                                 b'largefile %s is not in cache and could not be '
                                 b'downloaded'
                             )
                             % lf
                         )
                 path = lfutil.usercachepath(repo.ui, hash)
                 with open(path, b"rb") as fpin:
                     for chunk in util.filechunkiter(fpin):
                         fp.write(chunk)
         err = 0
     return err
 
 
 @eh.wrapfunction(merge, '_update')
 def mergeupdate(orig, repo, node, branchmerge, force, *args, **kwargs):
     matcher = kwargs.get('matcher', None)
     # note if this is a partial update
     partial = matcher and not matcher.always()
     with repo.wlock(), repo.dirstate.changing_parents(repo):
         # branch |       |         |
         #  merge | force | partial | action
         # -------+-------+---------+--------------
         #    x   |   x   |    x    | linear-merge
         #    o   |   x   |    x    | branch-merge
         #    x   |   o   |    x    | overwrite (as clean update)
         #    o   |   o   |    x    | force-branch-merge (*1)
         #    x   |   x   |    o    |   (*)
         #    o   |   x   |    o    |   (*)
         #    x   |   o   |    o    | overwrite (as revert)
         #    o   |   o   |    o    |   (*)
         #
         # (*) don't care
         # (*1) deprecated, but used internally (e.g: "rebase --collapse")
         with repo.dirstate.running_status(repo):
             lfdirstate = lfutil.openlfdirstate(repo.ui, repo)
             unsure, s, mtime_boundary = lfdirstate.status(
                 matchmod.always(),
                 subrepos=[],
                 ignored=False,
                 clean=True,
                 unknown=False,
             )
         oldclean = set(s.clean)
         pctx = repo[b'.']
         dctx = repo[node]
         for lfile in unsure + s.modified:
             lfileabs = repo.wvfs.join(lfile)
             if not repo.wvfs.exists(lfileabs):
                 continue
             lfhash = lfutil.hashfile(lfileabs)
             standin = lfutil.standin(lfile)
             lfutil.writestandin(
                 repo, standin, lfhash, lfutil.getexecutable(lfileabs)
             )
             if standin in pctx and lfhash == lfutil.readasstandin(
                 pctx[standin]
             ):
                 oldclean.add(lfile)
         for lfile in s.added:
             fstandin = lfutil.standin(lfile)
             if fstandin not in dctx:
                 # in this case, content of standin file is meaningless
                 # (in dctx, lfile is unknown, or normal file)
                 continue
             lfutil.updatestandin(repo, lfile, fstandin)
         # mark all clean largefiles as dirty, just in case the update gets
         # interrupted before largefiles and lfdirstate are synchronized
         for lfile in oldclean:
             entry = lfdirstate.get_entry(lfile)
             lfdirstate.hacky_extension_update_file(
                 lfile,
                 wc_tracked=entry.tracked,
                 p1_tracked=entry.p1_tracked,
                 p2_info=entry.p2_info,
                 possibly_dirty=True,
             )
         lfdirstate.write(repo.currenttransaction())
 
         oldstandins = lfutil.getstandinsstate(repo)
         wc = kwargs.get('wc')
         if wc and wc.isinmemory():
             # largefiles is not a good candidate for in-memory merge (large
             # files, custom dirstate, matcher usage).
             raise error.ProgrammingError(
                 b'largefiles is not compatible with in-memory merge'
             )
         result = orig(repo, node, branchmerge, force, *args, **kwargs)
 
         newstandins = lfutil.getstandinsstate(repo)
         filelist = lfutil.getlfilestoupdate(oldstandins, newstandins)
 
         # to avoid leaving all largefiles as dirty and thus rehash them, mark
         # all the ones that didn't change as clean
         for lfile in oldclean.difference(filelist):
             lfdirstate.update_file(lfile, p1_tracked=True, wc_tracked=True)
 
         if branchmerge or force or partial:
             filelist.extend(s.deleted + s.removed)
 
         lfcommands.updatelfiles(
             repo.ui, repo, filelist=filelist, normallookup=partial
         )
 
         return result
 
 
 @eh.wrapfunction(scmutil, 'marktouched')
 def scmutilmarktouched(orig, repo, files, *args, **kwargs):
     result = orig(repo, files, *args, **kwargs)
 
     filelist = []
     for f in files:
         lf = lfutil.splitstandin(f)
         if lf is not None:
             filelist.append(lf)
     if filelist:
         lfcommands.updatelfiles(
             repo.ui,
             repo,
             filelist=filelist,
             printmessage=False,
             normallookup=True,
         )
 
     return result
 
 
 @eh.wrapfunction(upgrade_actions, 'preservedrequirements')
 @eh.wrapfunction(upgrade_actions, 'supporteddestrequirements')
 def upgraderequirements(orig, repo):
     reqs = orig(repo)
     if b'largefiles' in repo.requirements:
         reqs.add(b'largefiles')
     return reqs
 
 
 _lfscheme = b'largefile://'
 
 
 @eh.wrapfunction(urlmod, 'open')
 def openlargefile(orig, ui, url_, data=None, **kwargs):
     if url_.startswith(_lfscheme):
         if data:
             msg = b"cannot use data on a 'largefile://' url"
             raise error.ProgrammingError(msg)
         lfid = url_[len(_lfscheme) :]
         return storefactory.getlfile(ui, lfid)
     else:
         return orig(ui, url_, data=data, **kwargs)

hgext/zeroconf/Zeroconf.py

@@ -1,1891 +1,1891
 """ Multicast DNS Service Discovery for Python, v0.12
     Copyright (C) 2003, Paul Scott-Murphy
 
     This module provides a framework for the use of DNS Service Discovery
     using IP multicast.  It has been tested against the JRendezvous
     implementation from <a href="http://strangeberry.com">StrangeBerry</a>,
     and against the mDNSResponder from Mac OS X 10.3.8.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library; if not, see
     <http://www.gnu.org/licenses/>.
 
 """
 
 """0.12 update - allow selection of binding interface
          typo fix - Thanks A. M. Kuchlingi
          removed all use of word 'Rendezvous' - this is an API change"""
 
 """0.11 update - correction to comments for addListener method
                  support for new record types seen from OS X
                   - IPv6 address
                   - hostinfo
                  ignore unknown DNS record types
                  fixes to name decoding
                  works alongside other processes using port 5353 (e.g. Mac OS X)
                  tested against Mac OS X 10.3.2's mDNSResponder
                  corrections to removal of list entries for service browser"""
 
 """0.10 update - Jonathon Paisley contributed these corrections:
                  always multicast replies, even when query is unicast
                  correct a pointer encoding problem
                  can now write records in any order
                  traceback shown on failure
                  better TXT record parsing
                  server is now separate from name
                  can cancel a service browser
 
                  modified some unit tests to accommodate these changes"""
 
 """0.09 update - remove all records on service unregistration
                  fix DOS security problem with readName"""
 
 """0.08 update - changed licensing to LGPL"""
 
 """0.07 update - faster shutdown on engine
                  pointer encoding of outgoing names
                  ServiceBrowser now works
                  new unit tests"""
 
 """0.06 update - small improvements with unit tests
                  added defined exception types
                  new style objects
                  fixed hostname/interface problem
                  fixed socket timeout problem
                  fixed addServiceListener() typo bug
                  using select() for socket reads
                  tested on Debian unstable with Python 2.2.2"""
 
 """0.05 update - ensure case insensitivity on domain names
                  support for unicast DNS queries"""
 
 """0.04 update - added some unit tests
                  added __ne__ adjuncts where required
                  ensure names end in '.local.'
                  timeout on receiving socket for clean shutdown"""
 
 __author__ = b"Paul Scott-Murphy"
 __email__ = b"paul at scott dash murphy dot com"
 __version__ = b"0.12"
 
 import errno
 import itertools
 import select
 import socket
 import struct
 import threading
 import time
 import traceback
 
 from mercurial import pycompat
 
-__all__ = [b"Zeroconf", b"ServiceInfo", b"ServiceBrowser"]
+__all__ = ["Zeroconf", "ServiceInfo", "ServiceBrowser"]
 
 # hook for threads
 
 globals()[b'_GLOBAL_DONE'] = 0
 
 # Some timing constants
 
 _UNREGISTER_TIME = 125
 _CHECK_TIME = 175
 _REGISTER_TIME = 225
 _LISTENER_TIME = 200
 _BROWSER_TIME = 500
 
 # Some DNS constants
 
 _MDNS_ADDR = r'224.0.0.251'
 _MDNS_PORT = 5353
 _DNS_PORT = 53
 _DNS_TTL = 60 * 60  # one hour default TTL
 
 _MAX_MSG_TYPICAL = 1460  # unused
 _MAX_MSG_ABSOLUTE = 8972
 
 _FLAGS_QR_MASK = 0x8000  # query response mask
 _FLAGS_QR_QUERY = 0x0000  # query
 _FLAGS_QR_RESPONSE = 0x8000  # response
 
 _FLAGS_AA = 0x0400  # Authoritative answer
 _FLAGS_TC = 0x0200  # Truncated
 _FLAGS_RD = 0x0100  # Recursion desired
 _FLAGS_RA = 0x8000  # Recursion available
 
 _FLAGS_Z = 0x0040  # Zero
 _FLAGS_AD = 0x0020  # Authentic data
 _FLAGS_CD = 0x0010  # Checking disabled
 
 _CLASS_IN = 1
 _CLASS_CS = 2
 _CLASS_CH = 3
 _CLASS_HS = 4
 _CLASS_NONE = 254
 _CLASS_ANY = 255
 _CLASS_MASK = 0x7FFF
 _CLASS_UNIQUE = 0x8000
 
 _TYPE_A = 1
 _TYPE_NS = 2
 _TYPE_MD = 3
 _TYPE_MF = 4
 _TYPE_CNAME = 5
 _TYPE_SOA = 6
 _TYPE_MB = 7
 _TYPE_MG = 8
 _TYPE_MR = 9
 _TYPE_NULL = 10
 _TYPE_WKS = 11
 _TYPE_PTR = 12
 _TYPE_HINFO = 13
 _TYPE_MINFO = 14
 _TYPE_MX = 15
 _TYPE_TXT = 16
 _TYPE_AAAA = 28
 _TYPE_SRV = 33
 _TYPE_ANY = 255
 
 # Mapping constants to names
 
 _CLASSES = {
     _CLASS_IN: b"in",
     _CLASS_CS: b"cs",
     _CLASS_CH: b"ch",
     _CLASS_HS: b"hs",
     _CLASS_NONE: b"none",
     _CLASS_ANY: b"any",
 }
 
 _TYPES = {
     _TYPE_A: b"a",
     _TYPE_NS: b"ns",
     _TYPE_MD: b"md",
     _TYPE_MF: b"mf",
     _TYPE_CNAME: b"cname",
     _TYPE_SOA: b"soa",
     _TYPE_MB: b"mb",
     _TYPE_MG: b"mg",
     _TYPE_MR: b"mr",
     _TYPE_NULL: b"null",
     _TYPE_WKS: b"wks",
     _TYPE_PTR: b"ptr",
     _TYPE_HINFO: b"hinfo",
     _TYPE_MINFO: b"minfo",
     _TYPE_MX: b"mx",
     _TYPE_TXT: b"txt",
     _TYPE_AAAA: b"quada",
     _TYPE_SRV: b"srv",
     _TYPE_ANY: b"any",
 }
 
 # utility functions
 
 
 def currentTimeMillis():
     """Current system time in milliseconds"""
     return time.time() * 1000
 
 
 # Exceptions
 
 
 class NonLocalNameException(Exception):
     pass
 
 
 class NonUniqueNameException(Exception):
     pass
 
 
 class NamePartTooLongException(Exception):
     pass
 
 
 class AbstractMethodException(Exception):
     pass
 
 
 class BadTypeInNameException(Exception):
     pass
 
 
 class BadDomainName(Exception):
     def __init__(self, pos):
         Exception.__init__(self, b"at position %s" % pos)
 
 
 class BadDomainNameCircular(BadDomainName):
     pass
 
 
 # implementation classes
 
 
 class DNSEntry:
     """A DNS entry"""
 
     def __init__(self, name, type, clazz):
         self.key = name.lower()
         self.name = name
         self.type = type
         self.clazz = clazz & _CLASS_MASK
         self.unique = (clazz & _CLASS_UNIQUE) != 0
 
     def __eq__(self, other):
         """Equality test on name, type, and class"""
         if isinstance(other, DNSEntry):
             return (
                 self.name == other.name
                 and self.type == other.type
                 and self.clazz == other.clazz
             )
         return 0
 
     def __ne__(self, other):
         """Non-equality test"""
         return not self.__eq__(other)
 
     def getClazz(self, clazz):
         """Class accessor"""
         try:
             return _CLASSES[clazz]
         except KeyError:
             return b"?(%s)" % clazz
 
     def getType(self, type):
         """Type accessor"""
         try:
             return _TYPES[type]
         except KeyError:
             return b"?(%s)" % type
 
     def toString(self, hdr, other):
         """String representation with additional information"""
         result = b"%s[%s,%s" % (
             hdr,
             self.getType(self.type),
             self.getClazz(self.clazz),
         )
         if self.unique:
             result += b"-unique,"
         else:
             result += b","
         result += self.name
         if other is not None:
             result += b",%s]" % other
         else:
             result += b"]"
         return result
 
 
 class DNSQuestion(DNSEntry):
     """A DNS question entry"""
 
     def __init__(self, name, type, clazz):
         if isinstance(name, str):
             name = name.encode('ascii')
         if not name.endswith(b".local."):
             raise NonLocalNameException(name)
         DNSEntry.__init__(self, name, type, clazz)
 
     def answeredBy(self, rec):
         """Returns true if the question is answered by the record"""
         return (
             self.clazz == rec.clazz
             and (self.type == rec.type or self.type == _TYPE_ANY)
             and self.name == rec.name
         )
 
     def __repr__(self):
         """String representation"""
         return DNSEntry.toString(self, b"question", None)
 
 
 class DNSRecord(DNSEntry):
     """A DNS record - like a DNS entry, but has a TTL"""
 
     def __init__(self, name, type, clazz, ttl):
         DNSEntry.__init__(self, name, type, clazz)
         self.ttl = ttl
         self.created = currentTimeMillis()
 
     def __eq__(self, other):
         """Tests equality as per DNSRecord"""
         if isinstance(other, DNSRecord):
             return DNSEntry.__eq__(self, other)
         return 0
 
     def suppressedBy(self, msg):
         """Returns true if any answer in a message can suffice for the
         information held in this record."""
         for record in msg.answers:
             if self.suppressedByAnswer(record):
                 return 1
         return 0
 
     def suppressedByAnswer(self, other):
         """Returns true if another record has same name, type and class,
         and if its TTL is at least half of this record's."""
         if self == other and other.ttl > (self.ttl / 2):
             return 1
         return 0
 
     def getExpirationTime(self, percent):
         """Returns the time at which this record will have expired
         by a certain percentage."""
         return self.created + (percent * self.ttl * 10)
 
     def getRemainingTTL(self, now):
         """Returns the remaining TTL in seconds."""
         return max(0, (self.getExpirationTime(100) - now) / 1000)
 
     def isExpired(self, now):
         """Returns true if this record has expired."""
         return self.getExpirationTime(100) <= now
 
     def isStale(self, now):
         """Returns true if this record is at least half way expired."""
         return self.getExpirationTime(50) <= now
 
     def resetTTL(self, other):
         """Sets this record's TTL and created time to that of
         another record."""
         self.created = other.created
         self.ttl = other.ttl
 
     def write(self, out):
         """Abstract method"""
         raise AbstractMethodException
 
     def toString(self, other):
         """String representation with additional information"""
         arg = b"%s/%s,%s" % (
             self.ttl,
             self.getRemainingTTL(currentTimeMillis()),
             other,
         )
         return DNSEntry.toString(self, b"record", arg)
 
 
 class DNSAddress(DNSRecord):
     """A DNS address record"""
 
     def __init__(self, name, type, clazz, ttl, address):
         DNSRecord.__init__(self, name, type, clazz, ttl)
         self.address = address
 
     def write(self, out):
         """Used in constructing an outgoing packet"""
         out.writeString(self.address, len(self.address))
 
     def __eq__(self, other):
         """Tests equality on address"""
         if isinstance(other, DNSAddress):
             return self.address == other.address
         return 0
 
     def __repr__(self):
         """String representation"""
         try:
             return socket.inet_ntoa(self.address)
         except Exception:
             return self.address
 
 
 class DNSHinfo(DNSRecord):
     """A DNS host information record"""
 
     def __init__(self, name, type, clazz, ttl, cpu, os):
         DNSRecord.__init__(self, name, type, clazz, ttl)
         self.cpu = cpu
         self.os = os
 
     def write(self, out):
         """Used in constructing an outgoing packet"""
         out.writeString(self.cpu, len(self.cpu))
         out.writeString(self.os, len(self.os))
 
     def __eq__(self, other):
         """Tests equality on cpu and os"""
         if isinstance(other, DNSHinfo):
             return self.cpu == other.cpu and self.os == other.os
         return 0
 
     def __repr__(self):
         """String representation"""
         return self.cpu + b" " + self.os
 
 
 class DNSPointer(DNSRecord):
     """A DNS pointer record"""
 
     def __init__(self, name, type, clazz, ttl, alias):
         DNSRecord.__init__(self, name, type, clazz, ttl)
         self.alias = alias
 
     def write(self, out):
         """Used in constructing an outgoing packet"""
         out.writeName(self.alias)
 
     def __eq__(self, other):
         """Tests equality on alias"""
         if isinstance(other, DNSPointer):
             return self.alias == other.alias
         return 0
 
     def __repr__(self):
         """String representation"""
         return self.toString(self.alias)
 
 
 class DNSText(DNSRecord):
     """A DNS text record"""
 
     def __init__(self, name, type, clazz, ttl, text):
         DNSRecord.__init__(self, name, type, clazz, ttl)
         self.text = text
 
     def write(self, out):
         """Used in constructing an outgoing packet"""
         out.writeString(self.text, len(self.text))
 
     def __eq__(self, other):
         """Tests equality on text"""
         if isinstance(other, DNSText):
             return self.text == other.text
         return 0
 
     def __repr__(self):
         """String representation"""
         if len(self.text) > 10:
             return self.toString(self.text[:7] + b"...")
         else:
             return self.toString(self.text)
 
 
 class DNSService(DNSRecord):
     """A DNS service record"""
 
     def __init__(self, name, type, clazz, ttl, priority, weight, port, server):
         DNSRecord.__init__(self, name, type, clazz, ttl)
         self.priority = priority
         self.weight = weight
         self.port = port
         self.server = server
 
     def write(self, out):
         """Used in constructing an outgoing packet"""
         out.writeShort(self.priority)
         out.writeShort(self.weight)
         out.writeShort(self.port)
         out.writeName(self.server)
 
     def __eq__(self, other):
         """Tests equality on priority, weight, port and server"""
         if isinstance(other, DNSService):
             return (
                 self.priority == other.priority
                 and self.weight == other.weight
                 and self.port == other.port
                 and self.server == other.server
             )
         return 0
 
     def __repr__(self):
         """String representation"""
         return self.toString(b"%s:%s" % (self.server, self.port))
 
 
 class DNSIncoming:
     """Object representation of an incoming DNS packet"""
 
     def __init__(self, data):
         """Constructor from string holding bytes of packet"""
         self.offset = 0
         self.data = data
         self.questions = []
         self.answers = []
         self.numquestions = 0
         self.numanswers = 0
         self.numauthorities = 0
         self.numadditionals = 0
 
         self.readHeader()
         self.readQuestions()
         self.readOthers()
 
     def readHeader(self):
         """Reads header portion of packet"""
         format = b'!HHHHHH'
         length = struct.calcsize(format)
         info = struct.unpack(
             format, self.data[self.offset : self.offset + length]
         )
         self.offset += length
 
         self.id = info[0]
         self.flags = info[1]
         self.numquestions = info[2]
         self.numanswers = info[3]
         self.numauthorities = info[4]
         self.numadditionals = info[5]
 
     def readQuestions(self):
         """Reads questions section of packet"""
         format = b'!HH'
         length = struct.calcsize(format)
         for i in range(0, self.numquestions):
             name = self.readName()
             info = struct.unpack(
                 format, self.data[self.offset : self.offset + length]
             )
             self.offset += length
 
             try:
                 question = DNSQuestion(name, info[0], info[1])
                 self.questions.append(question)
             except NonLocalNameException:
                 pass
 
     def readInt(self):
         """Reads an integer from the packet"""
         format = b'!I'
         length = struct.calcsize(format)
         info = struct.unpack(
             format, self.data[self.offset : self.offset + length]
         )
         self.offset += length
         return info[0]
 
     def readCharacterString(self):
         """Reads a character string from the packet"""
         length = ord(self.data[self.offset])
         self.offset += 1
         return self.readString(length)
 
     def readString(self, len):
         """Reads a string of a given length from the packet"""
         format = b'!%ds' % len
         length = struct.calcsize(format)
         info = struct.unpack(
             format, self.data[self.offset : self.offset + length]
         )
         self.offset += length
         return info[0]
 
     def readUnsignedShort(self):
         """Reads an unsigned short from the packet"""
         format = b'!H'
         length = struct.calcsize(format)
         info = struct.unpack(
             format, self.data[self.offset : self.offset + length]
         )
         self.offset += length
         return info[0]
 
     def readOthers(self):
         """Reads answers, authorities and additionals section of the packet"""
         format = b'!HHiH'
         length = struct.calcsize(format)
         n = self.numanswers + self.numauthorities + self.numadditionals
         for i in range(0, n):
             domain = self.readName()
             info = struct.unpack(
                 format, self.data[self.offset : self.offset + length]
             )
             self.offset += length
 
             rec = None
             if info[0] == _TYPE_A:
                 rec = DNSAddress(
                     domain, info[0], info[1], info[2], self.readString(4)
                 )
             elif info[0] == _TYPE_CNAME or info[0] == _TYPE_PTR:
                 rec = DNSPointer(
                     domain, info[0], info[1], info[2], self.readName()
                 )
             elif info[0] == _TYPE_TXT:
                 rec = DNSText(
                     domain, info[0], info[1], info[2], self.readString(info[3])
                 )
             elif info[0] == _TYPE_SRV:
                 rec = DNSService(
                     domain,
                     info[0],
                     info[1],
                     info[2],
                     self.readUnsignedShort(),
                     self.readUnsignedShort(),
                     self.readUnsignedShort(),
                     self.readName(),
                 )
             elif info[0] == _TYPE_HINFO:
                 rec = DNSHinfo(
                     domain,
                     info[0],
                     info[1],
                     info[2],
                     self.readCharacterString(),
                     self.readCharacterString(),
                 )
             elif info[0] == _TYPE_AAAA:
                 rec = DNSAddress(
                     domain, info[0], info[1], info[2], self.readString(16)
                 )
             else:
                 # Try to ignore types we don't know about
                 # this may mean the rest of the name is
                 # unable to be parsed, and may show errors
                 # so this is left for debugging.  New types
                 # encountered need to be parsed properly.
                 #
                 # print "UNKNOWN TYPE = " + str(info[0])
                 # raise BadTypeInNameException
                 self.offset += info[3]
 
             if rec is not None:
                 self.answers.append(rec)
 
     def isQuery(self):
         """Returns true if this is a query"""
         return (self.flags & _FLAGS_QR_MASK) == _FLAGS_QR_QUERY
 
     def isResponse(self):
         """Returns true if this is a response"""
         return (self.flags & _FLAGS_QR_MASK) == _FLAGS_QR_RESPONSE
 
     def readUTF(self, offset, len):
         """Reads a UTF-8 string of a given length from the packet"""
         return self.data[offset : offset + len].decode('utf-8')
 
     def readName(self):
         """Reads a domain name from the packet"""
         result = r''
         off = self.offset
         next = -1
         first = off
 
         while True:
             len = ord(self.data[off : off + 1])
             off += 1
             if len == 0:
                 break
             t = len & 0xC0
             if t == 0x00:
                 result = ''.join((result, self.readUTF(off, len) + '.'))
                 off += len
             elif t == 0xC0:
                 if next < 0:
                     next = off + 1
                 off = ((len & 0x3F) << 8) | ord(self.data[off : off + 1])
                 if off >= first:
                     raise BadDomainNameCircular(off)
                 first = off
             else:
                 raise BadDomainName(off)
 
         if next >= 0:
             self.offset = next
         else:
             self.offset = off
 
         return result
 
 
 class DNSOutgoing:
     """Object representation of an outgoing packet"""
 
     def __init__(self, flags, multicast=1):
         self.finished = 0
         self.id = 0
         self.multicast = multicast
         self.flags = flags
         self.names = {}
         self.data = []
         self.size = 12
 
         self.questions = []
         self.answers = []
         self.authorities = []
         self.additionals = []
 
     def addQuestion(self, record):
         """Adds a question"""
         self.questions.append(record)
 
     def addAnswer(self, inp, record):
         """Adds an answer"""
         if not record.suppressedBy(inp):
             self.addAnswerAtTime(record, 0)
 
     def addAnswerAtTime(self, record, now):
         """Adds an answer if if does not expire by a certain time"""
         if record is not None:
             if now == 0 or not record.isExpired(now):
                 self.answers.append((record, now))
 
     def addAuthoritativeAnswer(self, record):
         """Adds an authoritative answer"""
         self.authorities.append(record)
 
     def addAdditionalAnswer(self, record):
         """Adds an additional answer"""
         self.additionals.append(record)
 
     def writeByte(self, value):
         """Writes a single byte to the packet"""
         format = b'!c'
         self.data.append(struct.pack(format, chr(value)))
         self.size += 1
 
     def insertShort(self, index, value):
         """Inserts an unsigned short in a certain position in the packet"""
         format = b'!H'
         self.data.insert(index, struct.pack(format, value))
         self.size += 2
 
     def writeShort(self, value):
         """Writes an unsigned short to the packet"""
         format = b'!H'
         self.data.append(struct.pack(format, value))
         self.size += 2
 
     def writeInt(self, value):
         """Writes an unsigned integer to the packet"""
         format = b'!I'
         self.data.append(struct.pack(format, int(value)))
         self.size += 4
 
     def writeString(self, value, length):
         """Writes a string to the packet"""
         format = '!' + str(length) + 's'
         self.data.append(struct.pack(format, value))
         self.size += length
 
     def writeUTF(self, s):
         """Writes a UTF-8 string of a given length to the packet"""
         utfstr = s.encode('utf-8')
         length = len(utfstr)
         if length > 64:
             raise NamePartTooLongException
         self.writeByte(length)
         self.writeString(utfstr, length)
 
     def writeName(self, name):
         """Writes a domain name to the packet"""
 
         try:
             # Find existing instance of this name in packet
             #
             index = self.names[name]
         except KeyError:
             # No record of this name already, so write it
             # out as normal, recording the location of the name
             # for future pointers to it.
             #
             self.names[name] = self.size
             parts = name.split(b'.')
             if parts[-1] == b'':
                 parts = parts[:-1]
             for part in parts:
                 self.writeUTF(part)
             self.writeByte(0)
             return
 
         # An index was found, so write a pointer to it
         #
         self.writeByte((index >> 8) | 0xC0)
         self.writeByte(index)
 
     def writeQuestion(self, question):
         """Writes a question to the packet"""
         self.writeName(question.name)
         self.writeShort(question.type)
         self.writeShort(question.clazz)
 
     def writeRecord(self, record, now):
         """Writes a record (answer, authoritative answer, additional) to
         the packet"""
         self.writeName(record.name)
         self.writeShort(record.type)
         if record.unique and self.multicast:
             self.writeShort(record.clazz | _CLASS_UNIQUE)
         else:
             self.writeShort(record.clazz)
         if now == 0:
             self.writeInt(record.ttl)
         else:
             self.writeInt(record.getRemainingTTL(now))
         index = len(self.data)
         # Adjust size for the short we will write before this record
         #
         self.size += 2
         record.write(self)
         self.size -= 2
 
         length = len(b''.join(self.data[index:]))
         self.insertShort(index, length)  # Here is the short we adjusted for
 
     def packet(self):
         """Returns a string containing the packet's bytes
 
         No further parts should be added to the packet once this
         is done."""
         if not self.finished:
             self.finished = 1
             for question in self.questions:
                 self.writeQuestion(question)
             for answer, time_ in self.answers:
                 self.writeRecord(answer, time_)
             for authority in self.authorities:
                 self.writeRecord(authority, 0)
             for additional in self.additionals:
                 self.writeRecord(additional, 0)
 
             self.insertShort(0, len(self.additionals))
             self.insertShort(0, len(self.authorities))
             self.insertShort(0, len(self.answers))
             self.insertShort(0, len(self.questions))
             self.insertShort(0, self.flags)
             if self.multicast:
                 self.insertShort(0, 0)
             else:
                 self.insertShort(0, self.id)
         return b''.join(self.data)
 
 
 class DNSCache:
     """A cache of DNS entries"""
 
     def __init__(self):
         self.cache = {}
 
     def add(self, entry):
         """Adds an entry"""
         try:
             list = self.cache[entry.key]
         except KeyError:
             list = self.cache[entry.key] = []
         list.append(entry)
 
     def remove(self, entry):
         """Removes an entry"""
         try:
             list = self.cache[entry.key]
             list.remove(entry)
         except KeyError:
             pass
 
     def get(self, entry):
         """Gets an entry by key.  Will return None if there is no
         matching entry."""
         try:
             list = self.cache[entry.key]
             return list[list.index(entry)]
         except (KeyError, ValueError):
             return None
 
     def getByDetails(self, name, type, clazz):
         """Gets an entry by details.  Will return None if there is
         no matching entry."""
         entry = DNSEntry(name, type, clazz)
         return self.get(entry)
 
     def entriesWithName(self, name):
         """Returns a list of entries whose key matches the name."""
         try:
             return self.cache[name]
         except KeyError:
             return []
 
     def entries(self):
         """Returns a list of all entries"""
         try:
             return list(itertools.chain.from_iterable(self.cache.values()))
         except Exception:
             return []
 
 
 class Engine(threading.Thread):
     """An engine wraps read access to sockets, allowing objects that
     need to receive data from sockets to be called back when the
     sockets are ready.
 
     A reader needs a handle_read() method, which is called when the socket
     it is interested in is ready for reading.
 
     Writers are not implemented here, because we only send short
     packets.
     """
 
     def __init__(self, zeroconf):
         threading.Thread.__init__(self)
         self.zeroconf = zeroconf
         self.readers = {}  # maps socket to reader
         self.timeout = 5
         self.condition = threading.Condition()
         self.start()
 
     def run(self):
         while not globals()[b'_GLOBAL_DONE']:
             rs = self.getReaders()
             if len(rs) == 0:
                 # No sockets to manage, but we wait for the timeout
                 # or addition of a socket
                 #
                 self.condition.acquire()
                 self.condition.wait(self.timeout)
                 self.condition.release()
             else:
                 try:
                     rr, wr, er = select.select(rs, [], [], self.timeout)
                     for sock in rr:
                         try:
                             self.readers[sock].handle_read()
                         except Exception:
                             if not globals()[b'_GLOBAL_DONE']:
                                 traceback.print_exc()
                 except Exception:
                     pass
 
     def getReaders(self):
         self.condition.acquire()
         result = self.readers.keys()
         self.condition.release()
         return result
 
     def addReader(self, reader, socket):
         self.condition.acquire()
         self.readers[socket] = reader
         self.condition.notify()
         self.condition.release()
 
     def delReader(self, socket):
         self.condition.acquire()
         del self.readers[socket]
         self.condition.notify()
         self.condition.release()
 
     def notify(self):
         self.condition.acquire()
         self.condition.notify()
         self.condition.release()
 
 
 class Listener:
     """A Listener is used by this module to listen on the multicast
     group to which DNS messages are sent, allowing the implementation
     to cache information as it arrives.
 
     It requires registration with an Engine object in order to have
     the read() method called when a socket is available for reading."""
 
     def __init__(self, zeroconf):
         self.zeroconf = zeroconf
         self.zeroconf.engine.addReader(self, self.zeroconf.socket)
 
     def handle_read(self):
         sock = self.zeroconf.socket
         try:
             data, (addr, port) = sock.recvfrom(_MAX_MSG_ABSOLUTE)
         except socket.error as e:
             if e.errno == errno.EBADF:
                 # some other thread may close the socket
                 return
             else:
                 raise
         self.data = data
         msg = DNSIncoming(data)
         if msg.isQuery():
             # Always multicast responses
             #
             if port == _MDNS_PORT:
                 self.zeroconf.handleQuery(msg, _MDNS_ADDR, _MDNS_PORT)
             # If it's not a multicast query, reply via unicast
             # and multicast
             #
             elif port == _DNS_PORT:
                 self.zeroconf.handleQuery(msg, addr, port)
                 self.zeroconf.handleQuery(msg, _MDNS_ADDR, _MDNS_PORT)
         else:
             self.zeroconf.handleResponse(msg)
 
 
 class Reaper(threading.Thread):
     """A Reaper is used by this module to remove cache entries that
     have expired."""
 
     def __init__(self, zeroconf):
         threading.Thread.__init__(self)
         self.zeroconf = zeroconf
         self.start()
 
     def run(self):
         while True:
             self.zeroconf.wait(10 * 1000)
             if globals()[b'_GLOBAL_DONE']:
                 return
             now = currentTimeMillis()
             for record in self.zeroconf.cache.entries():
                 if record.isExpired(now):
                     self.zeroconf.updateRecord(now, record)
                     self.zeroconf.cache.remove(record)
 
 
 class ServiceBrowser(threading.Thread):
     """Used to browse for a service of a specific type.
 
     The listener object will have its addService() and
     removeService() methods called when this browser
     discovers changes in the services availability."""
 
     def __init__(self, zeroconf, type, listener):
         """Creates a browser for a specific type"""
         threading.Thread.__init__(self)
         self.zeroconf = zeroconf
         self.type = type
         self.listener = listener
         self.services = {}
         self.nexttime = currentTimeMillis()
         self.delay = _BROWSER_TIME
         self.list = []
 
         self.done = 0
 
         self.zeroconf.addListener(
             self, DNSQuestion(self.type, _TYPE_PTR, _CLASS_IN)
         )
         self.start()
 
     def updateRecord(self, zeroconf, now, record):
         """Callback invoked by Zeroconf when new information arrives.
 
         Updates information required by browser in the Zeroconf cache."""
         if record.type == _TYPE_PTR and record.name == self.type:
             expired = record.isExpired(now)
             try:
                 oldrecord = self.services[record.alias.lower()]
                 if not expired:
                     oldrecord.resetTTL(record)
                 else:
                     del self.services[record.alias.lower()]
                     callback = lambda x: self.listener.removeService(
                         x, self.type, record.alias
                     )
                     self.list.append(callback)
                     return
             except Exception:
                 if not expired:
                     self.services[record.alias.lower()] = record
                     callback = lambda x: self.listener.addService(
                         x, self.type, record.alias
                     )
                     self.list.append(callback)
 
             expires = record.getExpirationTime(75)
             if expires < self.nexttime:
                 self.nexttime = expires
 
     def cancel(self):
         self.done = 1
         self.zeroconf.notifyAll()
 
     def run(self):
         while True:
             event = None
             now = currentTimeMillis()
             if len(self.list) == 0 and self.nexttime > now:
                 self.zeroconf.wait(self.nexttime - now)
             if globals()[b'_GLOBAL_DONE'] or self.done:
                 return
             now = currentTimeMillis()
 
             if self.nexttime <= now:
                 out = DNSOutgoing(_FLAGS_QR_QUERY)
                 out.addQuestion(DNSQuestion(self.type, _TYPE_PTR, _CLASS_IN))
                 for record in self.services.values():
                     if not record.isExpired(now):
                         out.addAnswerAtTime(record, now)
                 self.zeroconf.send(out)
                 self.nexttime = now + self.delay
                 self.delay = min(20 * 1000, self.delay * 2)
 
             if len(self.list) > 0:
                 event = self.list.pop(0)
 
             if event is not None:
                 event(self.zeroconf)
 
 
 class ServiceInfo:
     """Service information"""
 
     def __init__(
         self,
         type,
         name,
         address=None,
         port=None,
         weight=0,
         priority=0,
         properties=None,
         server=None,
     ):
         """Create a service description.
 
         type: fully qualified service type name
         name: fully qualified service name
         address: IP address as unsigned short, network byte order
         port: port that the service runs on
         weight: weight of the service
         priority: priority of the service
         properties: dictionary of properties (or a string holding the bytes for
                     the text field)
         server: fully qualified name for service host (defaults to name)"""
 
         if not name.endswith(type):
             raise BadTypeInNameException
         self.type = type
         self.name = name
         self.address = address
         self.port = port
         self.weight = weight
         self.priority = priority
         if server:
             self.server = server
         else:
             self.server = name
         self.setProperties(properties)
 
     def setProperties(self, properties):
         """Sets properties and text of this info from a dictionary"""
         if isinstance(properties, dict):
             self.properties = properties
             list = []
             result = b''
             for key in properties:
                 value = properties[key]
                 if value is None:
                     suffix = b''
                 elif isinstance(value, str):
                     suffix = value
                 elif isinstance(value, int):
                     if value:
                         suffix = b'true'
                     else:
                         suffix = b'false'
                 else:
                     suffix = b''
                 list.append(b'='.join((key, suffix)))
             for item in list:
                 result = b''.join(
                     (
                         result,
                         struct.pack(b'!c', pycompat.bytechr(len(item))),
                         item,
                     )
                 )
             self.text = result
         else:
             self.text = properties
 
     def setText(self, text):
         """Sets properties and text given a text field"""
         self.text = text
         try:
             result = {}
             end = len(text)
             index = 0
             strs = []
             while index < end:
                 length = ord(text[index])
                 index += 1
                 strs.append(text[index : index + length])
                 index += length
 
             for s in strs:
                 eindex = s.find(b'=')
                 if eindex == -1:
                     # No equals sign at all
                     key = s
                     value = 0
                 else:
                     key = s[:eindex]
                     value = s[eindex + 1 :]
                     if value == b'true':
                         value = 1
                     elif value == b'false' or not value:
                         value = 0
 
                 # Only update non-existent properties
                 if key and result.get(key) is None:
                     result[key] = value
 
             self.properties = result
         except Exception:
             traceback.print_exc()
             self.properties = None
 
     def getType(self):
         """Type accessor"""
         return self.type
 
     def getName(self):
         """Name accessor"""
         if self.type is not None and self.name.endswith(b"." + self.type):
             return self.name[: len(self.name) - len(self.type) - 1]
         return self.name
 
     def getAddress(self):
         """Address accessor"""
         return self.address
 
     def getPort(self):
         """Port accessor"""
         return self.port
 
     def getPriority(self):
         """Priority accessor"""
         return self.priority
 
     def getWeight(self):
         """Weight accessor"""
         return self.weight
 
     def getProperties(self):
         """Properties accessor"""
         return self.properties
 
     def getText(self):
         """Text accessor"""
         return self.text
 
     def getServer(self):
         """Server accessor"""
         return self.server
 
     def updateRecord(self, zeroconf, now, record):
         """Updates service information from a DNS record"""
         if record is not None and not record.isExpired(now):
             if record.type == _TYPE_A:
                 # if record.name == self.name:
                 if record.name == self.server:
                     self.address = record.address
             elif record.type == _TYPE_SRV:
                 if record.name == self.name:
                     self.server = record.server
                     self.port = record.port
                     self.weight = record.weight
                     self.priority = record.priority
                     # self.address = None
                     self.updateRecord(
                         zeroconf,
                         now,
                         zeroconf.cache.getByDetails(
                             self.server, _TYPE_A, _CLASS_IN
                         ),
                     )
             elif record.type == _TYPE_TXT:
                 if record.name == self.name:
                     self.setText(record.text)
 
     def request(self, zeroconf, timeout):
         """Returns true if the service could be discovered on the
         network, and updates this object with details discovered.
         """
         now = currentTimeMillis()
         delay = _LISTENER_TIME
         next = now + delay
         last = now + timeout
         result = False
         try:
             zeroconf.addListener(
                 self, DNSQuestion(self.name, _TYPE_ANY, _CLASS_IN)
             )
             while (
                 self.server is None or self.address is None or self.text is None
             ):
                 if last <= now:
                     return 0
                 if next <= now:
                     out = DNSOutgoing(_FLAGS_QR_QUERY)
                     out.addQuestion(
                         DNSQuestion(self.name, _TYPE_SRV, _CLASS_IN)
                     )
                     out.addAnswerAtTime(
                         zeroconf.cache.getByDetails(
                             self.name, _TYPE_SRV, _CLASS_IN
                         ),
                         now,
                     )
                     out.addQuestion(
                         DNSQuestion(self.name, _TYPE_TXT, _CLASS_IN)
                     )
                     out.addAnswerAtTime(
                         zeroconf.cache.getByDetails(
                             self.name, _TYPE_TXT, _CLASS_IN
                         ),
                         now,
                     )
                     if self.server is not None:
                         out.addQuestion(
                             DNSQuestion(self.server, _TYPE_A, _CLASS_IN)
                         )
                         out.addAnswerAtTime(
                             zeroconf.cache.getByDetails(
                                 self.server, _TYPE_A, _CLASS_IN
                             ),
                             now,
                         )
                     zeroconf.send(out)
                     next = now + delay
                     delay = delay * 2
 
                 zeroconf.wait(min(next, last) - now)
                 now = currentTimeMillis()
             result = True
         finally:
             zeroconf.removeListener(self)
 
         return result
 
     def __eq__(self, other):
         """Tests equality of service name"""
         if isinstance(other, ServiceInfo):
             return other.name == self.name
         return 0
 
     def __ne__(self, other):
         """Non-equality test"""
         return not self.__eq__(other)
 
     def __repr__(self):
         """String representation"""
         result = b"service[%s,%s:%s," % (
             self.name,
             socket.inet_ntoa(self.getAddress()),
             self.port,
         )
         if self.text is None:
             result += b"None"
         else:
             if len(self.text) < 20:
                 result += self.text
             else:
                 result += self.text[:17] + b"..."
         result += b"]"
         return result
 
 
 class Zeroconf:
     """Implementation of Zeroconf Multicast DNS Service Discovery
 
     Supports registration, unregistration, queries and browsing.
     """
 
     def __init__(self, bindaddress=None):
         """Creates an instance of the Zeroconf class, establishing
         multicast communications, listening and reaping threads."""
         globals()[b'_GLOBAL_DONE'] = 0
         if bindaddress is None:
             self.intf = socket.gethostbyname(socket.gethostname())
         else:
             self.intf = bindaddress
         self.group = (b'', _MDNS_PORT)
         self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         try:
             self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
             self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
         except Exception:
             # SO_REUSEADDR should be equivalent to SO_REUSEPORT for
             # multicast UDP sockets (p 731, "TCP/IP Illustrated,
             # Volume 2"), but some BSD-derived systems require
             # SO_REUSEPORT to be specified explicitly.  Also, not all
             # versions of Python have SO_REUSEPORT available.  So
             # if you're on a BSD-based system, and haven't upgraded
             # to Python 2.3 yet, you may find this library doesn't
             # work as expected.
             #
             pass
         self.socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_TTL, b"\xff")
         self.socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_LOOP, b"\x01")
         try:
             self.socket.bind(self.group)
         except Exception:
             # Some versions of linux raise an exception even though
             # SO_REUSEADDR and SO_REUSEPORT have been set, so ignore it
             pass
         self.socket.setsockopt(
             socket.SOL_IP,
             socket.IP_ADD_MEMBERSHIP,
             socket.inet_aton(_MDNS_ADDR) + socket.inet_aton('0.0.0.0'),
         )
 
         self.listeners = []
         self.browsers = []
         self.services = {}
         self.servicetypes = {}
 
         self.cache = DNSCache()
 
         self.condition = threading.Condition()
 
         self.engine = Engine(self)
         self.listener = Listener(self)
         self.reaper = Reaper(self)
 
     def isLoopback(self):
         return self.intf.startswith(b"127.0.0.1")
 
     def isLinklocal(self):
         return self.intf.startswith(b"169.254.")
 
     def wait(self, timeout):
         """Calling thread waits for a given number of milliseconds or
         until notified."""
         self.condition.acquire()
         self.condition.wait(timeout / 1000)
         self.condition.release()
 
     def notifyAll(self):
         """Notifies all waiting threads"""
         self.condition.acquire()
         self.condition.notify_all()
         self.condition.release()
 
     def getServiceInfo(self, type, name, timeout=3000):
         """Returns network's service information for a particular
         name and type, or None if no service matches by the timeout,
         which defaults to 3 seconds."""
         info = ServiceInfo(type, name)
         if info.request(self, timeout):
             return info
         return None
 
     def addServiceListener(self, type, listener):
         """Adds a listener for a particular service type.  This object
         will then have its updateRecord method called when information
         arrives for that type."""
         self.removeServiceListener(listener)
         self.browsers.append(ServiceBrowser(self, type, listener))
 
     def removeServiceListener(self, listener):
         """Removes a listener from the set that is currently listening."""
         for browser in self.browsers:
             if browser.listener == listener:
                 browser.cancel()
                 del browser
 
     def registerService(self, info, ttl=_DNS_TTL):
         """Registers service information to the network with a default TTL
         of 60 seconds.  Zeroconf will then respond to requests for
         information for that service.  The name of the service may be
         changed if needed to make it unique on the network."""
         self.checkService(info)
         self.services[info.name.lower()] = info
         if info.type in self.servicetypes:
             self.servicetypes[info.type] += 1
         else:
             self.servicetypes[info.type] = 1
         now = currentTimeMillis()
         nexttime = now
         i = 0
         while i < 3:
             if now < nexttime:
                 self.wait(nexttime - now)
                 now = currentTimeMillis()
                 continue
             out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
             out.addAnswerAtTime(
                 DNSPointer(info.type, _TYPE_PTR, _CLASS_IN, ttl, info.name), 0
             )
             out.addAnswerAtTime(
                 DNSService(
                     info.name,
                     _TYPE_SRV,
                     _CLASS_IN,
                     ttl,
                     info.priority,
                     info.weight,
                     info.port,
                     info.server,
                 ),
                 0,
             )
             out.addAnswerAtTime(
                 DNSText(info.name, _TYPE_TXT, _CLASS_IN, ttl, info.text), 0
             )
             if info.address:
                 out.addAnswerAtTime(
                     DNSAddress(
                         info.server, _TYPE_A, _CLASS_IN, ttl, info.address
                     ),
                     0,
                 )
             self.send(out)
             i += 1
             nexttime += _REGISTER_TIME
 
     def unregisterService(self, info):
         """Unregister a service."""
         try:
             del self.services[info.name.lower()]
             if self.servicetypes[info.type] > 1:
                 self.servicetypes[info.type] -= 1
             else:
                 del self.servicetypes[info.type]
         except KeyError:
             pass
         now = currentTimeMillis()
         nexttime = now
         i = 0
         while i < 3:
             if now < nexttime:
                 self.wait(nexttime - now)
                 now = currentTimeMillis()
                 continue
             out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
             out.addAnswerAtTime(
                 DNSPointer(info.type, _TYPE_PTR, _CLASS_IN, 0, info.name), 0
             )
             out.addAnswerAtTime(
                 DNSService(
                     info.name,
                     _TYPE_SRV,
                     _CLASS_IN,
                     0,
                     info.priority,
                     info.weight,
                     info.port,
                     info.name,
                 ),
                 0,
             )
             out.addAnswerAtTime(
                 DNSText(info.name, _TYPE_TXT, _CLASS_IN, 0, info.text), 0
             )
             if info.address:
                 out.addAnswerAtTime(
                     DNSAddress(
                         info.server, _TYPE_A, _CLASS_IN, 0, info.address
                     ),
                     0,
                 )
             self.send(out)
             i += 1
             nexttime += _UNREGISTER_TIME
 
     def unregisterAllServices(self):
         """Unregister all registered services."""
         if len(self.services) > 0:
             now = currentTimeMillis()
             nexttime = now
             i = 0
             while i < 3:
                 if now < nexttime:
                     self.wait(nexttime - now)
                     now = currentTimeMillis()
                     continue
                 out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
                 for info in self.services.values():
                     out.addAnswerAtTime(
                         DNSPointer(
                             info.type, _TYPE_PTR, _CLASS_IN, 0, info.name
                         ),
                         0,
                     )
                     out.addAnswerAtTime(
                         DNSService(
                             info.name,
                             _TYPE_SRV,
                             _CLASS_IN,
                             0,
                             info.priority,
                             info.weight,
                             info.port,
                             info.server,
                         ),
                         0,
                     )
                     out.addAnswerAtTime(
                         DNSText(info.name, _TYPE_TXT, _CLASS_IN, 0, info.text),
                         0,
                     )
                     if info.address:
                         out.addAnswerAtTime(
                             DNSAddress(
                                 info.server, _TYPE_A, _CLASS_IN, 0, info.address
                             ),
                             0,
                         )
                 self.send(out)
                 i += 1
                 nexttime += _UNREGISTER_TIME
 
     def checkService(self, info):
         """Checks the network for a unique service name, modifying the
         ServiceInfo passed in if it is not unique."""
         now = currentTimeMillis()
         nexttime = now
         i = 0
         while i < 3:
             for record in self.cache.entriesWithName(info.type):
                 if (
                     record.type == _TYPE_PTR
                     and not record.isExpired(now)
                     and record.alias == info.name
                 ):
                     if info.name.find(b'.') < 0:
                         info.name = b"%s.[%s:%d].%s" % (
                             info.name,
                             info.address,
                             info.port,
                             info.type,
                         )
                         self.checkService(info)
                         return
                     raise NonUniqueNameException
             if now < nexttime:
                 self.wait(nexttime - now)
                 now = currentTimeMillis()
                 continue
             out = DNSOutgoing(_FLAGS_QR_QUERY | _FLAGS_AA)
             self.debug = out
             out.addQuestion(DNSQuestion(info.type, _TYPE_PTR, _CLASS_IN))
             out.addAuthoritativeAnswer(
                 DNSPointer(info.type, _TYPE_PTR, _CLASS_IN, _DNS_TTL, info.name)
             )
             self.send(out)
             i += 1
             nexttime += _CHECK_TIME
 
     def addListener(self, listener, question):
         """Adds a listener for a given question.  The listener will have
         its updateRecord method called when information is available to
         answer the question."""
         now = currentTimeMillis()
         self.listeners.append(listener)
         if question is not None:
             for record in self.cache.entriesWithName(question.name):
                 if question.answeredBy(record) and not record.isExpired(now):
                     listener.updateRecord(self, now, record)
         self.notifyAll()
 
     def removeListener(self, listener):
         """Removes a listener."""
         try:
             self.listeners.remove(listener)
             self.notifyAll()
         except Exception:
             pass
 
     def updateRecord(self, now, rec):
         """Used to notify listeners of new information that has updated
         a record."""
         for listener in self.listeners:
             listener.updateRecord(self, now, rec)
         self.notifyAll()
 
     def handleResponse(self, msg):
         """Deal with incoming response packets.  All answers
         are held in the cache, and listeners are notified."""
         now = currentTimeMillis()
         for record in msg.answers:
             expired = record.isExpired(now)
             if record in self.cache.entries():
                 if expired:
                     self.cache.remove(record)
                 else:
                     entry = self.cache.get(record)
                     if entry is not None:
                         entry.resetTTL(record)
                         record = entry
             else:
                 self.cache.add(record)
 
             self.updateRecord(now, record)
 
     def handleQuery(self, msg, addr, port):
         """Deal with incoming query packets.  Provides a response if
         possible."""
         out = None
 
         # Support unicast client responses
         #
         if port != _MDNS_PORT:
             out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA, 0)
             for question in msg.questions:
                 out.addQuestion(question)
 
         for question in msg.questions:
             if question.type == _TYPE_PTR:
                 if question.name == b"_services._dns-sd._udp.local.":
                     for stype in self.servicetypes.keys():
                         if out is None:
                             out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
                         out.addAnswer(
                             msg,
                             DNSPointer(
                                 b"_services._dns-sd._udp.local.",
                                 _TYPE_PTR,
                                 _CLASS_IN,
                                 _DNS_TTL,
                                 stype,
                             ),
                         )
                 for service in self.services.values():
                     if question.name == service.type:
                         if out is None:
                             out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
                         out.addAnswer(
                             msg,
                             DNSPointer(
                                 service.type,
                                 _TYPE_PTR,
                                 _CLASS_IN,
                                 _DNS_TTL,
                                 service.name,
                             ),
                         )
             else:
                 try:
                     if out is None:
                         out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
 
                     # Answer A record queries for any service addresses we know
                     if question.type == _TYPE_A or question.type == _TYPE_ANY:
                         for service in self.services.values():
                             if service.server == question.name.lower():
                                 out.addAnswer(
                                     msg,
                                     DNSAddress(
                                         question.name,
                                         _TYPE_A,
                                         _CLASS_IN | _CLASS_UNIQUE,
                                         _DNS_TTL,
                                         service.address,
                                     ),
                                 )
 
                     service = self.services.get(question.name.lower(), None)
                     if not service:
                         continue
 
                     if question.type == _TYPE_SRV or question.type == _TYPE_ANY:
                         out.addAnswer(
                             msg,
                             DNSService(
                                 question.name,
                                 _TYPE_SRV,
                                 _CLASS_IN | _CLASS_UNIQUE,
                                 _DNS_TTL,
                                 service.priority,
                                 service.weight,
                                 service.port,
                                 service.server,
                             ),
                         )
                     if question.type == _TYPE_TXT or question.type == _TYPE_ANY:
                         out.addAnswer(
                             msg,
                             DNSText(
                                 question.name,
                                 _TYPE_TXT,
                                 _CLASS_IN | _CLASS_UNIQUE,
                                 _DNS_TTL,
                                 service.text,
                             ),
                         )
                     if question.type == _TYPE_SRV:
                         out.addAdditionalAnswer(
                             DNSAddress(
                                 service.server,
                                 _TYPE_A,
                                 _CLASS_IN | _CLASS_UNIQUE,
                                 _DNS_TTL,
                                 service.address,
                             )
                         )
                 except Exception:
                     traceback.print_exc()
 
         if out is not None and out.answers:
             out.id = msg.id
             self.send(out, addr, port)
 
     def send(self, out, addr=_MDNS_ADDR, port=_MDNS_PORT):
         """Sends an outgoing packet."""
         # This is a quick test to see if we can parse the packets we generate
         # temp = DNSIncoming(out.packet())
         try:
             self.socket.sendto(out.packet(), 0, (addr, port))
         except Exception:
             # Ignore this, it may be a temporary loss of network connection
             pass
 
     def close(self):
         """Ends the background threads, and prevent this instance from
         servicing further queries."""
         if globals()[b'_GLOBAL_DONE'] == 0:
             globals()[b'_GLOBAL_DONE'] = 1
             self.notifyAll()
             self.engine.notify()
             self.unregisterAllServices()
             self.socket.setsockopt(
                 socket.SOL_IP,
                 socket.IP_DROP_MEMBERSHIP,
                 socket.inet_aton(_MDNS_ADDR) + socket.inet_aton('0.0.0.0'),
             )
             self.socket.close()
 
 
 # Test a few module features, including service registration, service
 # query (for Zoe), and service unregistration.
 
 if __name__ == '__main__':
     print(b"Multicast DNS Service Discovery for Python, version", __version__)
     r = Zeroconf()
     print(b"1. Testing registration of a service...")
     desc = {b'version': b'0.10', b'a': b'test value', b'b': b'another value'}
     info = ServiceInfo(
         b"_http._tcp.local.",
         b"My Service Name._http._tcp.local.",
         socket.inet_aton("127.0.0.1"),
         1234,
         0,
         0,
         desc,
     )
     print(b"   Registering service...")
     r.registerService(info)
     print(b"   Registration done.")
     print(b"2. Testing query of service information...")
     print(
         b"   Getting ZOE service:",
         str(r.getServiceInfo(b"_http._tcp.local.", b"ZOE._http._tcp.local.")),
     )
     print(b"   Query done.")
     print(b"3. Testing query of own service...")
     print(
         b"   Getting self:",
         str(
             r.getServiceInfo(
                 b"_http._tcp.local.", b"My Service Name._http._tcp.local."
             )
         ),
     )
     print(b"   Query done.")
     print(b"4. Testing unregister of service information...")
     r.unregisterService(info)
     print(b"   Unregister done.")
     r.close()

mercurial/cffi/bdiff.py

@@ -1,88 +1,88
 # bdiff.py - CFFI implementation of bdiff.c
 #
 # Copyright 2016 Maciej Fijalkowski <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import struct
 
 from typing import (
     List,
     Tuple,
 )
 
 from ..pure.bdiff import *
 from . import _bdiff  # pytype: disable=import-error
 
 ffi = _bdiff.ffi
 lib = _bdiff.lib
 
 
 def blocks(sa: bytes, sb: bytes) -> List[Tuple[int, int, int, int]]:
-    a = ffi.new(b"struct bdiff_line**")
-    b = ffi.new(b"struct bdiff_line**")
-    ac = ffi.new(b"char[]", str(sa))
-    bc = ffi.new(b"char[]", str(sb))
-    l = ffi.new(b"struct bdiff_hunk*")
+    a = ffi.new("struct bdiff_line**")
+    b = ffi.new("struct bdiff_line**")
+    ac = ffi.new("char[]", bytes(sa))
+    bc = ffi.new("char[]", bytes(sb))
+    l = ffi.new("struct bdiff_hunk*")
     try:
         an = lib.bdiff_splitlines(ac, len(sa), a)
         bn = lib.bdiff_splitlines(bc, len(sb), b)
         if not a[0] or not b[0]:
             raise MemoryError
         count = lib.bdiff_diff(a[0], an, b[0], bn, l)
         if count < 0:
             raise MemoryError
         rl = [(0, 0, 0, 0)] * count
         h = l.next
         i = 0
         while h:
             rl[i] = (h.a1, h.a2, h.b1, h.b2)
             h = h.next
             i += 1
     finally:
         lib.free(a[0])
         lib.free(b[0])
         lib.bdiff_freehunks(l.next)
     return rl
 
 
 def bdiff(sa: bytes, sb: bytes) -> bytes:
-    a = ffi.new(b"struct bdiff_line**")
-    b = ffi.new(b"struct bdiff_line**")
-    ac = ffi.new(b"char[]", str(sa))
-    bc = ffi.new(b"char[]", str(sb))
-    l = ffi.new(b"struct bdiff_hunk*")
+    a = ffi.new("struct bdiff_line**")
+    b = ffi.new("struct bdiff_line**")
+    ac = ffi.new("char[]", bytes(sa))
+    bc = ffi.new("char[]", bytes(sb))
+    l = ffi.new("struct bdiff_hunk*")
     try:
         an = lib.bdiff_splitlines(ac, len(sa), a)
         bn = lib.bdiff_splitlines(bc, len(sb), b)
         if not a[0] or not b[0]:
             raise MemoryError
         count = lib.bdiff_diff(a[0], an, b[0], bn, l)
         if count < 0:
             raise MemoryError
         rl = []
         h = l.next
         la = lb = 0
         while h:
             if h.a1 != la or h.b1 != lb:
                 lgt = (b[0] + h.b1).l - (b[0] + lb).l
                 rl.append(
                     struct.pack(
                         b">lll",
                         (a[0] + la).l - a[0].l,
                         (a[0] + h.a1).l - a[0].l,
                         lgt,
                     )
                 )
-                rl.append(str(ffi.buffer((b[0] + lb).l, lgt)))
+                rl.append(bytes(ffi.buffer((b[0] + lb).l, lgt)))
             la = h.a2
             lb = h.b2
             h = h.next
 
     finally:
         lib.free(a[0])
         lib.free(b[0])
         lib.bdiff_freehunks(l.next)
     return b"".join(rl)

mercurial/cffi/mpatch.py

@@ -1,50 +1,50
 # mpatch.py - CFFI implementation of mpatch.c
 #
 # Copyright 2016 Maciej Fijalkowski <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 from typing import List
 
 from ..pure.mpatch import *
 from ..pure.mpatch import mpatchError  # silence pyflakes
 from . import _mpatch  # pytype: disable=import-error
 
 ffi = _mpatch.ffi
 lib = _mpatch.lib
 
 
 @ffi.def_extern()
 def cffi_get_next_item(arg, pos):
     all, bins = ffi.from_handle(arg)
-    container = ffi.new(b"struct mpatch_flist*[1]")
-    to_pass = ffi.new(b"char[]", str(bins[pos]))
+    container = ffi.new("struct mpatch_flist*[1]")
+    to_pass = ffi.new("char[]", bytes(bins[pos]))
     all.append(to_pass)
     r = lib.mpatch_decode(to_pass, len(to_pass) - 1, container)
     if r < 0:
         return ffi.NULL
     return container[0]
 
 
 def patches(text: bytes, bins: List[bytes]) -> bytes:
     lgt = len(bins)
     all = []
     if not lgt:
         return text
     arg = (all, bins)
     patch = lib.mpatch_fold(ffi.new_handle(arg), lib.cffi_get_next_item, 0, lgt)
     if not patch:
         raise mpatchError(b"cannot decode chunk")
     outlen = lib.mpatch_calcsize(len(text), patch)
     if outlen < 0:
         lib.mpatch_lfree(patch)
         raise mpatchError(b"inconsistency detected")
-    buf = ffi.new(b"char[]", outlen)
+    buf = ffi.new("char[]", outlen)
     if lib.mpatch_apply(buf, text, len(text), patch) < 0:
         lib.mpatch_lfree(patch)
         raise mpatchError(b"error applying patches")
     res = ffi.buffer(buf, outlen)[:]
     lib.mpatch_lfree(patch)
     return res

mercurial/cffi/osutil.py

@@ -1,114 +1,114
 # osutil.py - CFFI version of osutil.c
 #
 # Copyright 2016 Maciej Fijalkowski <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import os
 import stat as statmod
 
 from ..pure.osutil import *
 
 from .. import pycompat
 
 if pycompat.isdarwin:
     from . import _osutil  # pytype: disable=import-error
 
     ffi = _osutil.ffi
     lib = _osutil.lib
 
     listdir_batch_size = 4096
     # tweakable number, only affects performance, which chunks
     # of bytes do we get back from getattrlistbulk
 
     attrkinds = [None] * 20  # we need the max no for enum VXXX, 20 is plenty
 
     attrkinds[lib.VREG] = statmod.S_IFREG
     attrkinds[lib.VDIR] = statmod.S_IFDIR
     attrkinds[lib.VLNK] = statmod.S_IFLNK
     attrkinds[lib.VBLK] = statmod.S_IFBLK
     attrkinds[lib.VCHR] = statmod.S_IFCHR
     attrkinds[lib.VFIFO] = statmod.S_IFIFO
     attrkinds[lib.VSOCK] = statmod.S_IFSOCK
 
     class stat_res:
         def __init__(self, st_mode, st_mtime, st_size):
             self.st_mode = st_mode
             self.st_mtime = st_mtime
             self.st_size = st_size
 
-    tv_sec_ofs = ffi.offsetof(b"struct timespec", b"tv_sec")
-    buf = ffi.new(b"char[]", listdir_batch_size)
+    tv_sec_ofs = ffi.offsetof("struct timespec", "tv_sec")
+    buf = ffi.new("char[]", listdir_batch_size)
 
     def listdirinternal(dfd, req, stat, skip):
         ret = []
         while True:
             r = lib.getattrlistbulk(dfd, req, buf, listdir_batch_size, 0)
             if r == 0:
                 break
             if r == -1:
                 raise OSError(ffi.errno, os.strerror(ffi.errno))
-            cur = ffi.cast(b"val_attrs_t*", buf)
+            cur = ffi.cast("val_attrs_t*", buf)
             for i in range(r):
                 lgt = cur.length
-                assert lgt == ffi.cast(b'uint32_t*', cur)[0]
+                assert lgt == ffi.cast('uint32_t*', cur)[0]
                 ofs = cur.name_info.attr_dataoffset
                 str_lgt = cur.name_info.attr_length
-                base_ofs = ffi.offsetof(b'val_attrs_t', b'name_info')
+                base_ofs = ffi.offsetof('val_attrs_t', 'name_info')
                 name = bytes(
                     ffi.buffer(
-                        ffi.cast(b"char*", cur) + base_ofs + ofs, str_lgt - 1
+                        ffi.cast("char*", cur) + base_ofs + ofs, str_lgt - 1
                     )
                 )
                 tp = attrkinds[cur.obj_type]
                 if name == b"." or name == b"..":
                     continue
                 if skip == name and tp == statmod.S_ISDIR:
                     return []
                 if stat:
                     mtime = cur.mtime.tv_sec
                     mode = (cur.accessmask & ~lib.S_IFMT) | tp
                     ret.append(
                         (
                             name,
                             tp,
                             stat_res(
                                 st_mode=mode,
                                 st_mtime=mtime,
                                 st_size=cur.datalength,
                             ),
                         )
                     )
                 else:
                     ret.append((name, tp))
                 cur = ffi.cast(
-                    b"val_attrs_t*", int(ffi.cast(b"intptr_t", cur)) + lgt
+                    "val_attrs_t*", int(ffi.cast("intptr_t", cur)) + lgt
                 )
         return ret
 
     def listdir(path, stat=False, skip=None):
-        req = ffi.new(b"struct attrlist*")
+        req = ffi.new("struct attrlist*")
         req.bitmapcount = lib.ATTR_BIT_MAP_COUNT
         req.commonattr = (
             lib.ATTR_CMN_RETURNED_ATTRS
             | lib.ATTR_CMN_NAME
             | lib.ATTR_CMN_OBJTYPE
             | lib.ATTR_CMN_ACCESSMASK
             | lib.ATTR_CMN_MODTIME
         )
         req.fileattr = lib.ATTR_FILE_DATALENGTH
         dfd = lib.open(path, lib.O_RDONLY, 0)
         if dfd == -1:
             raise OSError(ffi.errno, os.strerror(ffi.errno))
 
         try:
             ret = listdirinternal(dfd, req, stat, skip)
         finally:
             try:
                 lib.close(dfd)
             except BaseException:
                 pass  # we ignore all the errors from closing, not
                 # much we can do about that
         return ret

mercurial/hgweb/hgweb_mod.py

@@ -1,525 +1,525
 # hgweb/hgweb_mod.py - Web interface for a repository.
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005-2007 Olivia Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import contextlib
 import os
 
 from .common import (
     ErrorResponse,
     HTTP_BAD_REQUEST,
     cspvalues,
     permhooks,
     statusmessage,
 )
 
 from .. import (
     encoding,
     error,
     extensions,
     formatter,
     hg,
     hook,
     profiling,
     pycompat,
     registrar,
     repoview,
     templatefilters,
     templater,
     templateutil,
     ui as uimod,
     wireprotoserver,
 )
 
 from . import (
     common,
     request as requestmod,
     webcommands,
     webutil,
     wsgicgi,
 )
 
 
 def getstyle(req, configfn, templatepath):
     styles = (
         req.qsparams.get(b'style', None),
         configfn(b'web', b'style'),
         b'paper',
     )
     return styles, _stylemap(styles, templatepath)
 
 
 def _stylemap(styles, path=None):
     """Return path to mapfile for a given style.
 
     Searches mapfile in the following locations:
     1. templatepath/style/map
     2. templatepath/map-style
     3. templatepath/map
     """
 
     for style in styles:
         # only plain name is allowed to honor template paths
         if (
             not style
             or style in (pycompat.oscurdir, pycompat.ospardir)
             or pycompat.ossep in style
             or pycompat.osaltsep
             and pycompat.osaltsep in style
         ):
             continue
         locations = (os.path.join(style, b'map'), b'map-' + style, b'map')
 
         for location in locations:
             mapfile, fp = templater.try_open_template(location, path)
             if mapfile:
                 return style, mapfile, fp
 
     raise RuntimeError(b"No hgweb templates found in %r" % path)
 
 
 def makebreadcrumb(url, prefix=b''):
     """Return a 'URL breadcrumb' list
 
     A 'URL breadcrumb' is a list of URL-name pairs,
     corresponding to each of the path items on a URL.
     This can be used to create path navigation entries.
     """
     if url.endswith(b'/'):
         url = url[:-1]
     if prefix:
         url = b'/' + prefix + url
     relpath = url
     if relpath.startswith(b'/'):
         relpath = relpath[1:]
 
     breadcrumb = []
     urlel = url
     pathitems = [b''] + relpath.split(b'/')
     for pathel in reversed(pathitems):
         if not pathel or not urlel:
             break
         breadcrumb.append({b'url': urlel, b'name': pathel})
         urlel = os.path.dirname(urlel)
     return templateutil.mappinglist(reversed(breadcrumb))
 
 
 class requestcontext:
     """Holds state/context for an individual request.
 
     Servers can be multi-threaded. Holding state on the WSGI application
     is prone to race conditions. Instances of this class exist to hold
     mutable and race-free state for requests.
     """
 
     def __init__(self, app, repo, req, res):
         self.repo = repo
         self.reponame = app.reponame
         self.req = req
         self.res = res
 
         # Only works if the filter actually support being upgraded to show
         # visible changesets
         current_filter = repo.filtername
         if (
             common.hashiddenaccess(repo, req)
             and current_filter is not None
             and current_filter + b'.hidden' in repoview.filtertable
         ):
             self.repo = self.repo.filtered(repo.filtername + b'.hidden')
 
         self.maxchanges = self.configint(b'web', b'maxchanges')
         self.stripecount = self.configint(b'web', b'stripes')
         self.maxshortchanges = self.configint(b'web', b'maxshortchanges')
         self.maxfiles = self.configint(b'web', b'maxfiles')
         self.allowpull = self.configbool(b'web', b'allow-pull')
 
         # we use untrusted=False to prevent a repo owner from using
         # web.templates in .hg/hgrc to get access to any file readable
         # by the user running the CGI script
         self.templatepath = self.config(b'web', b'templates', untrusted=False)
 
         # This object is more expensive to build than simple config values.
         # It is shared across requests. The app will replace the object
         # if it is updated. Since this is a reference and nothing should
         # modify the underlying object, it should be constant for the lifetime
         # of the request.
         self.websubtable = app.websubtable
 
         self.csp, self.nonce = cspvalues(self.repo.ui)
 
     # Trust the settings from the .hg/hgrc files by default.
     def config(self, *args, **kwargs):
         kwargs.setdefault('untrusted', True)
         return self.repo.ui.config(*args, **kwargs)
 
     def configbool(self, *args, **kwargs):
         kwargs.setdefault('untrusted', True)
         return self.repo.ui.configbool(*args, **kwargs)
 
     def configint(self, *args, **kwargs):
         kwargs.setdefault('untrusted', True)
         return self.repo.ui.configint(*args, **kwargs)
 
     def configlist(self, *args, **kwargs):
         kwargs.setdefault('untrusted', True)
         return self.repo.ui.configlist(*args, **kwargs)
 
     def archivelist(self, nodeid):
         return webutil.archivelist(self.repo.ui, nodeid)
 
     def templater(self, req):
         # determine scheme, port and server name
         # this is needed to create absolute urls
         logourl = self.config(b'web', b'logourl')
         logoimg = self.config(b'web', b'logoimg')
         staticurl = (
             self.config(b'web', b'staticurl')
             or req.apppath.rstrip(b'/') + b'/static/'
         )
         if not staticurl.endswith(b'/'):
             staticurl += b'/'
 
         # figure out which style to use
 
         vars = {}
         styles, (style, mapfile, fp) = getstyle(
             req, self.config, self.templatepath
         )
         if style == styles[0]:
             vars[b'style'] = style
 
         sessionvars = webutil.sessionvars(vars, b'?')
 
         if not self.reponame:
             self.reponame = (
                 self.config(b'web', b'name', b'')
                 or req.reponame
                 or req.apppath
                 or self.repo.root
             )
 
         filters = {}
         templatefilter = registrar.templatefilter(filters)
 
         @templatefilter(b'websub', intype=bytes)
         def websubfilter(text):
             return templatefilters.websub(text, self.websubtable)
 
         # create the templater
         # TODO: export all keywords: defaults = templatekw.keywords.copy()
         defaults = {
             b'url': req.apppath + b'/',
             b'logourl': logourl,
             b'logoimg': logoimg,
             b'staticurl': staticurl,
             b'urlbase': req.advertisedbaseurl,
             b'repo': self.reponame,
             b'encoding': encoding.encoding,
             b'sessionvars': sessionvars,
             b'pathdef': makebreadcrumb(req.apppath),
             b'style': style,
             b'nonce': self.nonce,
         }
         templatekeyword = registrar.templatekeyword(defaults)
 
         @templatekeyword(b'motd', requires=())
         def motd(context, mapping):
             yield self.config(b'web', b'motd')
 
         tres = formatter.templateresources(self.repo.ui, self.repo)
         return templater.templater.frommapfile(
             mapfile, fp=fp, filters=filters, defaults=defaults, resources=tres
         )
 
     def sendtemplate(self, name, **kwargs):
         """Helper function to send a response generated from a template."""
         if self.req.method != b'HEAD':
             kwargs = pycompat.byteskwargs(kwargs)
             self.res.setbodygen(self.tmpl.generate(name, kwargs))
         return self.res.sendresponse()
 
 
 class hgweb:
     """HTTP server for individual repositories.
 
     Instances of this class serve HTTP responses for a particular
     repository.
 
     Instances are typically used as WSGI applications.
 
     Some servers are multi-threaded. On these servers, there may
     be multiple active threads inside __call__.
     """
 
     def __init__(self, repo, name=None, baseui=None):
         if isinstance(repo, bytes):
             if baseui:
                 u = baseui.copy()
             else:
                 u = uimod.ui.load()
                 extensions.loadall(u)
                 extensions.populateui(u)
             r = hg.repository(u, repo)
         else:
             # we trust caller to give us a private copy
             r = repo
 
         r.ui.setconfig(b'ui', b'report_untrusted', b'off', b'hgweb')
         r.baseui.setconfig(b'ui', b'report_untrusted', b'off', b'hgweb')
         r.ui.setconfig(b'ui', b'nontty', b'true', b'hgweb')
         r.baseui.setconfig(b'ui', b'nontty', b'true', b'hgweb')
         # resolve file patterns relative to repo root
         r.ui.setconfig(b'ui', b'forcecwd', r.root, b'hgweb')
         r.baseui.setconfig(b'ui', b'forcecwd', r.root, b'hgweb')
         # it's unlikely that we can replace signal handlers in WSGI server,
         # and mod_wsgi issues a big warning. a plain hgweb process (with no
         # threading) could replace signal handlers, but we don't bother
         # conditionally enabling it.
         r.ui.setconfig(b'ui', b'signal-safe-lock', b'false', b'hgweb')
         r.baseui.setconfig(b'ui', b'signal-safe-lock', b'false', b'hgweb')
         # displaying bundling progress bar while serving feel wrong and may
         # break some wsgi implementation.
         r.ui.setconfig(b'progress', b'disable', b'true', b'hgweb')
         r.baseui.setconfig(b'progress', b'disable', b'true', b'hgweb')
         self._repos = [hg.cachedlocalrepo(self._webifyrepo(r))]
         self._lastrepo = self._repos[0]
         hook.redirect(True)
         self.reponame = name
 
     def _webifyrepo(self, repo):
         repo = getwebview(repo)
         self.websubtable = webutil.getwebsubs(repo)
         return repo
 
     @contextlib.contextmanager
     def _obtainrepo(self):
         """Obtain a repo unique to the caller.
 
         Internally we maintain a stack of cachedlocalrepo instances
         to be handed out. If one is available, we pop it and return it,
         ensuring it is up to date in the process. If one is not available,
         we clone the most recently used repo instance and return it.
 
         It is currently possible for the stack to grow without bounds
         if the server allows infinite threads. However, servers should
         have a thread limit, thus establishing our limit.
         """
         if self._repos:
             cached = self._repos.pop()
             r, created = cached.fetch()
         else:
             cached = self._lastrepo.copy()
             r, created = cached.fetch()
         if created:
             r = self._webifyrepo(r)
 
         self._lastrepo = cached
         self.mtime = cached.mtime
         try:
             yield r
         finally:
             self._repos.append(cached)
 
     def run(self):
         """Start a server from CGI environment.
 
         Modern servers should be using WSGI and should avoid this
         method, if possible.
         """
         if not encoding.environ.get(b'GATEWAY_INTERFACE', b'').startswith(
             b"CGI/1."
         ):
             raise RuntimeError(
                 b"This function is only intended to be "
                 b"called while running as a CGI script."
             )
         wsgicgi.launch(self)
 
     def __call__(self, env, respond):
         """Run the WSGI application.
 
         This may be called by multiple threads.
         """
         req = requestmod.parserequestfromenv(env)
         res = requestmod.wsgiresponse(req, respond)
 
         return self.run_wsgi(req, res)
 
     def run_wsgi(self, req, res):
         """Internal method to run the WSGI application.
 
         This is typically only called by Mercurial. External consumers
         should be using instances of this class as the WSGI application.
         """
         with self._obtainrepo() as repo:
             profile = repo.ui.configbool(b'profiling', b'enabled')
             with profiling.profile(repo.ui, enabled=profile):
                 for r in self._runwsgi(req, res, repo):
                     yield r
 
     def _runwsgi(self, req, res, repo):
         rctx = requestcontext(self, repo, req, res)
 
         # This state is global across all threads.
         encoding.encoding = rctx.config(b'web', b'encoding')
         rctx.repo.ui.environ = req.rawenv
 
         if rctx.csp:
             # hgwebdir may have added CSP header. Since we generate our own,
             # replace it.
             res.headers[b'Content-Security-Policy'] = rctx.csp
 
         handled = wireprotoserver.handlewsgirequest(
             rctx, req, res, self.check_perm
         )
         if handled:
             return res.sendresponse()
 
         # Old implementations of hgweb supported dispatching the request via
         # the initial query string parameter instead of using PATH_INFO.
         # If PATH_INFO is present (signaled by ``req.dispatchpath`` having
         # a value), we use it. Otherwise fall back to the query string.
         if req.dispatchpath is not None:
             query = req.dispatchpath
         else:
             query = req.querystring.partition(b'&')[0].partition(b';')[0]
 
         # translate user-visible url structure to internal structure
 
         args = query.split(b'/', 2)
         if b'cmd' not in req.qsparams and args and args[0]:
             cmd = args.pop(0)
             style = cmd.rfind(b'-')
             if style != -1:
                 req.qsparams[b'style'] = cmd[:style]
                 cmd = cmd[style + 1 :]
 
             # avoid accepting e.g. style parameter as command
             if hasattr(webcommands, pycompat.sysstr(cmd)):
                 req.qsparams[b'cmd'] = cmd
 
             if cmd == b'static':
                 req.qsparams[b'file'] = b'/'.join(args)
             else:
                 if args and args[0]:
                     node = args.pop(0).replace(b'%2F', b'/')
                     req.qsparams[b'node'] = node
                 if args:
                     if b'file' in req.qsparams:
                         del req.qsparams[b'file']
                     for a in args:
                         req.qsparams.add(b'file', a)
 
             ua = req.headers.get(b'User-Agent', b'')
             if cmd == b'rev' and b'mercurial' in ua:
                 req.qsparams[b'style'] = b'raw'
 
             if cmd == b'archive':
                 fn = req.qsparams[b'node']
                 for type_, spec in webutil.archivespecs.items():
                     ext = spec[2]
                     if fn.endswith(ext):
                         req.qsparams[b'node'] = fn[: -len(ext)]
                         req.qsparams[b'type'] = type_
         else:
             cmd = req.qsparams.get(b'cmd', b'')
 
         # process the web interface request
 
         try:
             rctx.tmpl = rctx.templater(req)
             ctype = rctx.tmpl.render(
                 b'mimetype', {b'encoding': encoding.encoding}
             )
 
             # check read permissions non-static content
             if cmd != b'static':
                 self.check_perm(rctx, req, None)
 
             if cmd == b'':
                 req.qsparams[b'cmd'] = rctx.tmpl.render(b'default', {})
                 cmd = req.qsparams[b'cmd']
 
             # Don't enable caching if using a CSP nonce because then it wouldn't
             # be a nonce.
             if rctx.configbool(b'web', b'cache') and not rctx.nonce:
                 tag = b'W/"%d"' % self.mtime
                 if req.headers.get(b'If-None-Match') == tag:
                     res.status = b'304 Not Modified'
                     # Content-Type may be defined globally. It isn't valid on a
                     # 304, so discard it.
                     try:
                         del res.headers[b'Content-Type']
                     except KeyError:
                         pass
                     # Response body not allowed on 304.
                     res.setbodybytes(b'')
                     return res.sendresponse()
 
                 res.headers[b'ETag'] = tag
 
-            if cmd not in webcommands.__all__:
+            if pycompat.sysstr(cmd) not in webcommands.__all__:
                 msg = b'no such method: %s' % cmd
                 raise ErrorResponse(HTTP_BAD_REQUEST, msg)
             else:
                 # Set some globals appropriate for web handlers. Commands can
                 # override easily enough.
                 res.status = b'200 Script output follows'
                 res.headers[b'Content-Type'] = ctype
                 return getattr(webcommands, pycompat.sysstr(cmd))(rctx)
 
         except (error.LookupError, error.RepoLookupError) as err:
             msg = pycompat.bytestr(err)
             if hasattr(err, 'name') and not isinstance(
                 err, error.ManifestLookupError
             ):
                 msg = b'revision not found: %s' % err.name
 
             res.status = b'404 Not Found'
             res.headers[b'Content-Type'] = ctype
             return rctx.sendtemplate(b'error', error=msg)
         except (error.RepoError, error.StorageError) as e:
             res.status = b'500 Internal Server Error'
             res.headers[b'Content-Type'] = ctype
             return rctx.sendtemplate(b'error', error=pycompat.bytestr(e))
         except error.Abort as e:
             res.status = b'403 Forbidden'
             res.headers[b'Content-Type'] = ctype
             return rctx.sendtemplate(b'error', error=e.message)
         except ErrorResponse as e:
             for k, v in e.headers:
                 res.headers[k] = v
             res.status = statusmessage(e.code, pycompat.bytestr(e))
             res.headers[b'Content-Type'] = ctype
             return rctx.sendtemplate(b'error', error=pycompat.bytestr(e))
 
     def check_perm(self, rctx, req, op):
         for permhook in permhooks:
             permhook(rctx, req, op)
 
 
 def getwebview(repo):
     """The 'web.view' config controls changeset filter to hgweb. Possible
     values are ``served``, ``visible`` and ``all``. Default is ``served``.
     The ``served`` filter only shows changesets that can be pulled from the
     hgweb instance.  The``visible`` filter includes secret changesets but
     still excludes "hidden" one.
 
     See the repoview module for details.
 
     The option has been around undocumented since Mercurial 2.5, but no
     user ever asked about it. So we better keep it undocumented for now."""
     # experimental config: web.view
     viewconfig = repo.ui.config(b'web', b'view', untrusted=True)
     if viewconfig == b'all':
         return repo.unfiltered()
     elif viewconfig in repoview.filtertable:
         return repo.filtered(viewconfig)
     else:
         return repo.filtered(b'served')

mercurial/hgweb/webcommands.py

@@ -1,1596 +1,1596
 #
 # Copyright 21 May 2005 - (c) 2005 Jake Edge <[e-mail]>
 # Copyright 2005-2007 Olivia Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import copy
 import mimetypes
 import os
 import re
 
 from ..i18n import _
 from ..node import hex, short
 
 from .common import (
     ErrorResponse,
     HTTP_FORBIDDEN,
     HTTP_NOT_FOUND,
     get_contact,
     paritygen,
     staticfile,
 )
 
 from .. import (
     archival,
     dagop,
     encoding,
     error,
     graphmod,
     pycompat,
     revset,
     revsetlang,
     scmutil,
     smartset,
     templateutil,
 )
 
 from ..utils import stringutil
 
 from . import webutil
 
 __all__ = []
 commands = {}
 
 
 class webcommand:
     """Decorator used to register a web command handler.
 
     The decorator takes as its positional arguments the name/path the
     command should be accessible under.
 
     When called, functions receive as arguments a ``requestcontext``,
     ``wsgirequest``, and a templater instance for generatoring output.
     The functions should populate the ``rctx.res`` object with details
     about the HTTP response.
 
     The function returns a generator to be consumed by the WSGI application.
     For most commands, this should be the result from
     ``web.res.sendresponse()``. Many commands will call ``web.sendtemplate()``
     to render a template.
 
     Usage:
 
     @webcommand('mycommand')
     def mycommand(web):
         pass
     """
 
     def __init__(self, name):
         self.name = name
 
     def __call__(self, func):
-        __all__.append(self.name)
+        __all__.append(pycompat.sysstr(self.name))
         commands[self.name] = func
         return func
 
 
 @webcommand(b'log')
 def log(web):
     """
     /log[/{revision}[/{path}]]
     --------------------------
 
     Show repository or file history.
 
     For URLs of the form ``/log/{revision}``, a list of changesets starting at
     the specified changeset identifier is shown. If ``{revision}`` is not
     defined, the default is ``tip``. This form is equivalent to the
     ``changelog`` handler.
 
     For URLs of the form ``/log/{revision}/{file}``, the history for a specific
     file will be shown. This form is equivalent to the ``filelog`` handler.
     """
 
     if web.req.qsparams.get(b'file'):
         return filelog(web)
     else:
         return changelog(web)
 
 
 @webcommand(b'rawfile')
 def rawfile(web):
     guessmime = web.configbool(b'web', b'guessmime')
 
     path = webutil.cleanpath(web.repo, web.req.qsparams.get(b'file', b''))
     if not path:
         return manifest(web)
 
     try:
         fctx = webutil.filectx(web.repo, web.req)
     except error.LookupError as inst:
         try:
             return manifest(web)
         except ErrorResponse:
             raise inst
 
     path = fctx.path()
     text = fctx.data()
     mt = b'application/binary'
     if guessmime:
         mt = mimetypes.guess_type(pycompat.fsdecode(path))[0]
         if mt is None:
             if stringutil.binary(text):
                 mt = b'application/binary'
             else:
                 mt = b'text/plain'
         else:
             mt = pycompat.sysbytes(mt)
 
     if mt.startswith(b'text/'):
         mt += b'; charset="%s"' % encoding.encoding
 
     web.res.headers[b'Content-Type'] = mt
     filename = (
         path.rpartition(b'/')[-1].replace(b'\\', b'\\\\').replace(b'"', b'\\"')
     )
     web.res.headers[b'Content-Disposition'] = (
         b'inline; filename="%s"' % filename
     )
     web.res.setbodybytes(text)
     return web.res.sendresponse()
 
 
 def _filerevision(web, fctx):
     f = fctx.path()
     text = fctx.data()
     parity = paritygen(web.stripecount)
     ishead = fctx.filenode() in fctx.filelog().heads()
 
     if stringutil.binary(text):
         mt = pycompat.sysbytes(
             mimetypes.guess_type(pycompat.fsdecode(f))[0]
             or r'application/octet-stream'
         )
         text = b'(binary:%s)' % mt
 
     def lines(context):
         for lineno, t in enumerate(text.splitlines(True)):
             yield {
                 b"line": t,
                 b"lineid": b"l%d" % (lineno + 1),
                 b"linenumber": b"% 6d" % (lineno + 1),
                 b"parity": next(parity),
             }
 
     return web.sendtemplate(
         b'filerevision',
         file=f,
         path=webutil.up(f),
         text=templateutil.mappinggenerator(lines),
         symrev=webutil.symrevorshortnode(web.req, fctx),
         rename=webutil.renamelink(fctx),
         permissions=fctx.manifest().flags(f),
         ishead=int(ishead),
         **pycompat.strkwargs(webutil.commonentry(web.repo, fctx))
     )
 
 
 @webcommand(b'file')
 def file(web):
     """
     /file/{revision}[/{path}]
     -------------------------
 
     Show information about a directory or file in the repository.
 
     Info about the ``path`` given as a URL parameter will be rendered.
 
     If ``path`` is a directory, information about the entries in that
     directory will be rendered. This form is equivalent to the ``manifest``
     handler.
 
     If ``path`` is a file, information about that file will be shown via
     the ``filerevision`` template.
 
     If ``path`` is not defined, information about the root directory will
     be rendered.
     """
     if web.req.qsparams.get(b'style') == b'raw':
         return rawfile(web)
 
     path = webutil.cleanpath(web.repo, web.req.qsparams.get(b'file', b''))
     if not path:
         return manifest(web)
     try:
         return _filerevision(web, webutil.filectx(web.repo, web.req))
     except error.LookupError as inst:
         try:
             return manifest(web)
         except ErrorResponse:
             raise inst
 
 
 def _search(web):
     MODE_REVISION = b'rev'
     MODE_KEYWORD = b'keyword'
     MODE_REVSET = b'revset'
 
     def revsearch(ctx):
         yield ctx
 
     def keywordsearch(query):
         lower = encoding.lower
         qw = lower(query).split()
 
         def revgen():
             cl = web.repo.changelog
             for i in range(len(web.repo) - 1, 0, -100):
                 l = []
                 for j in cl.revs(max(0, i - 99), i):
                     ctx = web.repo[j]
                     l.append(ctx)
                 l.reverse()
                 for e in l:
                     yield e
 
         for ctx in revgen():
             miss = 0
             for q in qw:
                 if not (
                     q in lower(ctx.user())
                     or q in lower(ctx.description())
                     or q in lower(b" ".join(ctx.files()))
                 ):
                     miss = 1
                     break
             if miss:
                 continue
 
             yield ctx
 
     def revsetsearch(revs):
         for r in revs:
             yield web.repo[r]
 
     searchfuncs = {
         MODE_REVISION: (revsearch, b'exact revision search'),
         MODE_KEYWORD: (keywordsearch, b'literal keyword search'),
         MODE_REVSET: (revsetsearch, b'revset expression search'),
     }
 
     def getsearchmode(query):
         try:
             ctx = scmutil.revsymbol(web.repo, query)
         except (error.RepoError, error.LookupError):
             # query is not an exact revision pointer, need to
             # decide if it's a revset expression or keywords
             pass
         else:
             return MODE_REVISION, ctx
 
         revdef = b'reverse(%s)' % query
         try:
             tree = revsetlang.parse(revdef)
         except error.ParseError:
             # can't parse to a revset tree
             return MODE_KEYWORD, query
 
         if revsetlang.depth(tree) <= 2:
             # no revset syntax used
             return MODE_KEYWORD, query
 
         if any(
             (token, (value or b'')[:3]) == (b'string', b're:')
             for token, value, pos in revsetlang.tokenize(revdef)
         ):
             return MODE_KEYWORD, query
 
         funcsused = revsetlang.funcsused(tree)
         if not funcsused.issubset(revset.safesymbols):
             return MODE_KEYWORD, query
 
         try:
             mfunc = revset.match(
                 web.repo.ui, revdef, lookup=revset.lookupfn(web.repo)
             )
             revs = mfunc(web.repo)
             return MODE_REVSET, revs
             # ParseError: wrongly placed tokens, wrongs arguments, etc
             # RepoLookupError: no such revision, e.g. in 'revision:'
             # Abort: bookmark/tag not exists
             # LookupError: ambiguous identifier, e.g. in '(bc)' on a large repo
         except (
             error.ParseError,
             error.RepoLookupError,
             error.Abort,
             LookupError,
         ):
             return MODE_KEYWORD, query
 
     def changelist(context):
         count = 0
 
         for ctx in searchfunc[0](funcarg):
             count += 1
             n = scmutil.binnode(ctx)
             showtags = webutil.showtag(web.repo, b'changelogtag', n)
             files = webutil.listfilediffs(ctx.files(), n, web.maxfiles)
 
             lm = webutil.commonentry(web.repo, ctx)
             lm.update(
                 {
                     b'parity': next(parity),
                     b'changelogtag': showtags,
                     b'files': files,
                 }
             )
             yield lm
 
             if count >= revcount:
                 break
 
     query = web.req.qsparams[b'rev']
     revcount = web.maxchanges
     if b'revcount' in web.req.qsparams:
         try:
             revcount = int(web.req.qsparams.get(b'revcount', revcount))
             revcount = max(revcount, 1)
             web.tmpl.defaults[b'sessionvars'][b'revcount'] = revcount
         except ValueError:
             pass
 
     lessvars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     lessvars[b'revcount'] = max(revcount // 2, 1)
     lessvars[b'rev'] = query
     morevars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     morevars[b'revcount'] = revcount * 2
     morevars[b'rev'] = query
 
     mode, funcarg = getsearchmode(query)
 
     if b'forcekw' in web.req.qsparams:
         showforcekw = b''
         showunforcekw = searchfuncs[mode][1]
         mode = MODE_KEYWORD
         funcarg = query
     else:
         if mode != MODE_KEYWORD:
             showforcekw = searchfuncs[MODE_KEYWORD][1]
         else:
             showforcekw = b''
         showunforcekw = b''
 
     searchfunc = searchfuncs[mode]
 
     tip = web.repo[b'tip']
     parity = paritygen(web.stripecount)
 
     return web.sendtemplate(
         b'search',
         query=query,
         node=tip.hex(),
         symrev=b'tip',
         entries=templateutil.mappinggenerator(changelist, name=b'searchentry'),
         archives=web.archivelist(b'tip'),
         morevars=morevars,
         lessvars=lessvars,
         modedesc=searchfunc[1],
         showforcekw=showforcekw,
         showunforcekw=showunforcekw,
     )
 
 
 @webcommand(b'changelog')
 def changelog(web, shortlog=False):
     """
     /changelog[/{revision}]
     -----------------------
 
     Show information about multiple changesets.
 
     If the optional ``revision`` URL argument is absent, information about
     all changesets starting at ``tip`` will be rendered. If the ``revision``
     argument is present, changesets will be shown starting from the specified
     revision.
 
     If ``revision`` is absent, the ``rev`` query string argument may be
     defined. This will perform a search for changesets.
 
     The argument for ``rev`` can be a single revision, a revision set,
     or a literal keyword to search for in changeset data (equivalent to
     :hg:`log -k`).
 
     The ``revcount`` query string argument defines the maximum numbers of
     changesets to render.
 
     For non-searches, the ``changelog`` template will be rendered.
     """
 
     query = b''
     if b'node' in web.req.qsparams:
         ctx = webutil.changectx(web.repo, web.req)
         symrev = webutil.symrevorshortnode(web.req, ctx)
     elif b'rev' in web.req.qsparams:
         return _search(web)
     else:
         ctx = web.repo[b'tip']
         symrev = b'tip'
 
     def changelist(maxcount):
         revs = []
         if pos != -1:
             revs = web.repo.changelog.revs(pos, 0)
 
         for entry in webutil.changelistentries(web, revs, maxcount, parity):
             yield entry
 
     if shortlog:
         revcount = web.maxshortchanges
     else:
         revcount = web.maxchanges
 
     if b'revcount' in web.req.qsparams:
         try:
             revcount = int(web.req.qsparams.get(b'revcount', revcount))
             revcount = max(revcount, 1)
             web.tmpl.defaults[b'sessionvars'][b'revcount'] = revcount
         except ValueError:
             pass
 
     lessvars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     lessvars[b'revcount'] = max(revcount // 2, 1)
     morevars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     morevars[b'revcount'] = revcount * 2
 
     count = len(web.repo)
     pos = ctx.rev()
     parity = paritygen(web.stripecount)
 
     changenav = webutil.revnav(web.repo).gen(pos, revcount, count)
 
     entries = list(changelist(revcount + 1))
     latestentry = entries[:1]
     if len(entries) > revcount:
         nextentry = entries[-1:]
         entries = entries[:-1]
     else:
         nextentry = []
 
     return web.sendtemplate(
         b'shortlog' if shortlog else b'changelog',
         changenav=changenav,
         node=ctx.hex(),
         rev=pos,
         symrev=symrev,
         changesets=count,
         entries=templateutil.mappinglist(entries),
         latestentry=templateutil.mappinglist(latestentry),
         nextentry=templateutil.mappinglist(nextentry),
         archives=web.archivelist(b'tip'),
         revcount=revcount,
         morevars=morevars,
         lessvars=lessvars,
         query=query,
     )
 
 
 @webcommand(b'shortlog')
 def shortlog(web):
     """
     /shortlog
     ---------
 
     Show basic information about a set of changesets.
 
     This accepts the same parameters as the ``changelog`` handler. The only
     difference is the ``shortlog`` template will be rendered instead of the
     ``changelog`` template.
     """
     return changelog(web, shortlog=True)
 
 
 @webcommand(b'changeset')
 def changeset(web):
     """
     /changeset[/{revision}]
     -----------------------
 
     Show information about a single changeset.
 
     A URL path argument is the changeset identifier to show. See ``hg help
     revisions`` for possible values. If not defined, the ``tip`` changeset
     will be shown.
 
     The ``changeset`` template is rendered. Contents of the ``changesettag``,
     ``changesetbookmark``, ``filenodelink``, ``filenolink``, and the many
     templates related to diffs may all be used to produce the output.
     """
     ctx = webutil.changectx(web.repo, web.req)
 
     return web.sendtemplate(b'changeset', **webutil.changesetentry(web, ctx))
 
 
 rev = webcommand(b'rev')(changeset)
 
 
 def decodepath(path: bytes) -> bytes:
     """Hook for mapping a path in the repository to a path in the
     working copy.
 
     Extensions (e.g., largefiles) can override this to remap files in
     the virtual file system presented by the manifest command below."""
     return path
 
 
 @webcommand(b'manifest')
 def manifest(web):
     """
     /manifest[/{revision}[/{path}]]
     -------------------------------
 
     Show information about a directory.
 
     If the URL path arguments are omitted, information about the root
     directory for the ``tip`` changeset will be shown.
 
     Because this handler can only show information for directories, it
     is recommended to use the ``file`` handler instead, as it can handle both
     directories and files.
 
     The ``manifest`` template will be rendered for this handler.
     """
     if b'node' in web.req.qsparams:
         ctx = webutil.changectx(web.repo, web.req)
         symrev = webutil.symrevorshortnode(web.req, ctx)
     else:
         ctx = web.repo[b'tip']
         symrev = b'tip'
     path = webutil.cleanpath(web.repo, web.req.qsparams.get(b'file', b''))
     mf = ctx.manifest()
     node = scmutil.binnode(ctx)
 
     files = {}
     dirs = {}
     parity = paritygen(web.stripecount)
 
     if path and path[-1:] != b"/":
         path += b"/"
     l = len(path)
     abspath = b"/" + path
 
     for full, n in mf.items():
         # the virtual path (working copy path) used for the full
         # (repository) path
         f = decodepath(full)
 
         if f[:l] != path:
             continue
         remain = f[l:]
         elements = remain.split(b'/')
         if len(elements) == 1:
             files[remain] = full
         else:
             h = dirs  # need to retain ref to dirs (root)
             for elem in elements[0:-1]:
                 if elem not in h:
                     h[elem] = {}
                 h = h[elem]
                 if len(h) > 1:
                     break
             h[None] = None  # denotes files present
 
     if mf and not files and not dirs:
         raise ErrorResponse(HTTP_NOT_FOUND, b'path not found: ' + path)
 
     def filelist(context):
         for f in sorted(files):
             full = files[f]
 
             fctx = ctx.filectx(full)
             yield {
                 b"file": full,
                 b"parity": next(parity),
                 b"basename": f,
                 b"date": fctx.date(),
                 b"size": fctx.size(),
                 b"permissions": mf.flags(full),
             }
 
     def dirlist(context):
         for d in sorted(dirs):
             emptydirs = []
             h = dirs[d]
             while isinstance(h, dict) and len(h) == 1:
                 k, v = next(iter(h.items()))
                 if v:
                     emptydirs.append(k)
                 h = v
 
             path = b"%s%s" % (abspath, d)
             yield {
                 b"parity": next(parity),
                 b"path": path,
                 # pytype: disable=wrong-arg-types
                 b"emptydirs": b"/".join(emptydirs),
                 # pytype: enable=wrong-arg-types
                 b"basename": d,
             }
 
     return web.sendtemplate(
         b'manifest',
         symrev=symrev,
         path=abspath,
         up=webutil.up(abspath),
         upparity=next(parity),
         fentries=templateutil.mappinggenerator(filelist),
         dentries=templateutil.mappinggenerator(dirlist),
         archives=web.archivelist(hex(node)),
         **pycompat.strkwargs(webutil.commonentry(web.repo, ctx))
     )
 
 
 @webcommand(b'tags')
 def tags(web):
     """
     /tags
     -----
 
     Show information about tags.
 
     No arguments are accepted.
 
     The ``tags`` template is rendered.
     """
     i = list(reversed(web.repo.tagslist()))
     parity = paritygen(web.stripecount)
 
     def entries(context, notip, latestonly):
         t = i
         if notip:
             t = [(k, n) for k, n in i if k != b"tip"]
         if latestonly:
             t = t[:1]
         for k, n in t:
             yield {
                 b"parity": next(parity),
                 b"tag": k,
                 b"date": web.repo[n].date(),
                 b"node": hex(n),
             }
 
     return web.sendtemplate(
         b'tags',
         node=hex(web.repo.changelog.tip()),
         entries=templateutil.mappinggenerator(entries, args=(False, False)),
         entriesnotip=templateutil.mappinggenerator(entries, args=(True, False)),
         latestentry=templateutil.mappinggenerator(entries, args=(True, True)),
     )
 
 
 @webcommand(b'bookmarks')
 def bookmarks(web):
     """
     /bookmarks
     ----------
 
     Show information about bookmarks.
 
     No arguments are accepted.
 
     The ``bookmarks`` template is rendered.
     """
     i = [b for b in web.repo._bookmarks.items() if b[1] in web.repo]
     sortkey = lambda b: (web.repo[b[1]].rev(), b[0])
     i = sorted(i, key=sortkey, reverse=True)
     parity = paritygen(web.stripecount)
 
     def entries(context, latestonly):
         t = i
         if latestonly:
             t = i[:1]
         for k, n in t:
             yield {
                 b"parity": next(parity),
                 b"bookmark": k,
                 b"date": web.repo[n].date(),
                 b"node": hex(n),
             }
 
     if i:
         latestrev = i[0][1]
     else:
         latestrev = -1
     lastdate = web.repo[latestrev].date()
 
     return web.sendtemplate(
         b'bookmarks',
         node=hex(web.repo.changelog.tip()),
         lastchange=templateutil.mappinglist([{b'date': lastdate}]),
         entries=templateutil.mappinggenerator(entries, args=(False,)),
         latestentry=templateutil.mappinggenerator(entries, args=(True,)),
     )
 
 
 @webcommand(b'branches')
 def branches(web):
     """
     /branches
     ---------
 
     Show information about branches.
 
     All known branches are contained in the output, even closed branches.
 
     No arguments are accepted.
 
     The ``branches`` template is rendered.
     """
     entries = webutil.branchentries(web.repo, web.stripecount)
     latestentry = webutil.branchentries(web.repo, web.stripecount, 1)
 
     return web.sendtemplate(
         b'branches',
         node=hex(web.repo.changelog.tip()),
         entries=entries,
         latestentry=latestentry,
     )
 
 
 @webcommand(b'summary')
 def summary(web):
     """
     /summary
     --------
 
     Show a summary of repository state.
 
     Information about the latest changesets, bookmarks, tags, and branches
     is captured by this handler.
 
     The ``summary`` template is rendered.
     """
     i = reversed(web.repo.tagslist())
 
     def tagentries(context):
         parity = paritygen(web.stripecount)
         count = 0
         for k, n in i:
             if k == b"tip":  # skip tip
                 continue
 
             count += 1
             if count > 10:  # limit to 10 tags
                 break
 
             yield {
                 b'parity': next(parity),
                 b'tag': k,
                 b'node': hex(n),
                 b'date': web.repo[n].date(),
             }
 
     def bookmarks(context):
         parity = paritygen(web.stripecount)
         marks = [b for b in web.repo._bookmarks.items() if b[1] in web.repo]
         sortkey = lambda b: (web.repo[b[1]].rev(), b[0])
         marks = sorted(marks, key=sortkey, reverse=True)
         for k, n in marks[:10]:  # limit to 10 bookmarks
             yield {
                 b'parity': next(parity),
                 b'bookmark': k,
                 b'date': web.repo[n].date(),
                 b'node': hex(n),
             }
 
     def changelist(context):
         parity = paritygen(web.stripecount, offset=start - end)
         l = []  # build a list in forward order for efficiency
         revs = []
         if start < end:
             revs = web.repo.changelog.revs(start, end - 1)
         for i in revs:
             ctx = web.repo[i]
             lm = webutil.commonentry(web.repo, ctx)
             lm[b'parity'] = next(parity)
             l.append(lm)
 
         for entry in reversed(l):
             yield entry
 
     tip = web.repo[b'tip']
     count = len(web.repo)
     start = max(0, count - web.maxchanges)
     end = min(count, start + web.maxchanges)
 
     desc = web.config(b"web", b"description")
     if not desc:
         desc = b'unknown'
     labels = web.configlist(b'web', b'labels')
 
     return web.sendtemplate(
         b'summary',
         desc=desc,
         owner=get_contact(web.config) or b'unknown',
         lastchange=tip.date(),
         tags=templateutil.mappinggenerator(tagentries, name=b'tagentry'),
         bookmarks=templateutil.mappinggenerator(bookmarks),
         branches=webutil.branchentries(web.repo, web.stripecount, 10),
         shortlog=templateutil.mappinggenerator(
             changelist, name=b'shortlogentry'
         ),
         node=tip.hex(),
         symrev=b'tip',
         archives=web.archivelist(b'tip'),
         labels=templateutil.hybridlist(labels, name=b'label'),
     )
 
 
 @webcommand(b'filediff')
 def filediff(web):
     """
     /diff/{revision}/{path}
     -----------------------
 
     Show how a file changed in a particular commit.
 
     The ``filediff`` template is rendered.
 
     This handler is registered under both the ``/diff`` and ``/filediff``
     paths. ``/diff`` is used in modern code.
     """
     fctx, ctx = None, None
     try:
         fctx = webutil.filectx(web.repo, web.req)
     except LookupError:
         ctx = webutil.changectx(web.repo, web.req)
         path = webutil.cleanpath(web.repo, web.req.qsparams[b'file'])
         if path not in ctx.files():
             raise
 
     if fctx is not None:
         path = fctx.path()
         ctx = fctx.changectx()
     basectx = ctx.p1()
 
     style = web.config(b'web', b'style')
     if b'style' in web.req.qsparams:
         style = web.req.qsparams[b'style']
 
     diffs = webutil.diffs(web, ctx, basectx, [path], style)
     if fctx is not None:
         rename = webutil.renamelink(fctx)
         ctx = fctx
     else:
         rename = templateutil.mappinglist([])
         ctx = ctx
 
     return web.sendtemplate(
         b'filediff',
         file=path,
         symrev=webutil.symrevorshortnode(web.req, ctx),
         rename=rename,
         diff=diffs,
         **pycompat.strkwargs(webutil.commonentry(web.repo, ctx))
     )
 
 
 diff = webcommand(b'diff')(filediff)
 
 
 @webcommand(b'comparison')
 def comparison(web):
     """
     /comparison/{revision}/{path}
     -----------------------------
 
     Show a comparison between the old and new versions of a file from changes
     made on a particular revision.
 
     This is similar to the ``diff`` handler. However, this form features
     a split or side-by-side diff rather than a unified diff.
 
     The ``context`` query string argument can be used to control the lines of
     context in the diff.
 
     The ``filecomparison`` template is rendered.
     """
     ctx = webutil.changectx(web.repo, web.req)
     if b'file' not in web.req.qsparams:
         raise ErrorResponse(HTTP_NOT_FOUND, b'file not given')
     path = webutil.cleanpath(web.repo, web.req.qsparams[b'file'])
 
     parsecontext = lambda v: v == b'full' and -1 or int(v)
     if b'context' in web.req.qsparams:
         context = parsecontext(web.req.qsparams[b'context'])
     else:
         context = parsecontext(web.config(b'web', b'comparisoncontext'))
 
     def filelines(f):
         if f.isbinary():
             mt = pycompat.sysbytes(
                 mimetypes.guess_type(pycompat.fsdecode(f.path()))[0]
                 or r'application/octet-stream'
             )
             return [_(b'(binary file %s, hash: %s)') % (mt, hex(f.filenode()))]
         return f.data().splitlines()
 
     fctx = None
     parent = ctx.p1()
     leftrev = parent.rev()
     leftnode = parent.node()
     rightrev = ctx.rev()
     rightnode = scmutil.binnode(ctx)
     if path in ctx:
         fctx = ctx[path]
         rightlines = filelines(fctx)
         if path not in parent:
             leftlines = ()
         else:
             pfctx = parent[path]
             leftlines = filelines(pfctx)
     else:
         rightlines = ()
         pfctx = ctx.p1()[path]
         leftlines = filelines(pfctx)
 
     comparison = webutil.compare(context, leftlines, rightlines)
     if fctx is not None:
         rename = webutil.renamelink(fctx)
         ctx = fctx
     else:
         rename = templateutil.mappinglist([])
         ctx = ctx
 
     return web.sendtemplate(
         b'filecomparison',
         file=path,
         symrev=webutil.symrevorshortnode(web.req, ctx),
         rename=rename,
         leftrev=leftrev,
         leftnode=hex(leftnode),
         rightrev=rightrev,
         rightnode=hex(rightnode),
         comparison=comparison,
         **pycompat.strkwargs(webutil.commonentry(web.repo, ctx))
     )
 
 
 @webcommand(b'annotate')
 def annotate(web):
     """
     /annotate/{revision}/{path}
     ---------------------------
 
     Show changeset information for each line in a file.
 
     The ``ignorews``, ``ignorewsamount``, ``ignorewseol``, and
     ``ignoreblanklines`` query string arguments have the same meaning as
     their ``[annotate]`` config equivalents. It uses the hgrc boolean
     parsing logic to interpret the value. e.g. ``0`` and ``false`` are
     false and ``1`` and ``true`` are true. If not defined, the server
     default settings are used.
 
     The ``fileannotate`` template is rendered.
     """
     fctx = webutil.filectx(web.repo, web.req)
     f = fctx.path()
     parity = paritygen(web.stripecount)
     ishead = fctx.filenode() in fctx.filelog().heads()
 
     # parents() is called once per line and several lines likely belong to
     # same revision. So it is worth caching.
     # TODO there are still redundant operations within basefilectx.parents()
     # and from the fctx.annotate() call itself that could be cached.
     parentscache = {}
 
     def parents(context, f):
         rev = f.rev()
         if rev not in parentscache:
             parentscache[rev] = []
             for p in f.parents():
                 entry = {
                     b'node': p.hex(),
                     b'rev': p.rev(),
                 }
                 parentscache[rev].append(entry)
 
         for p in parentscache[rev]:
             yield p
 
     def annotate(context):
         if fctx.isbinary():
             mt = pycompat.sysbytes(
                 mimetypes.guess_type(pycompat.fsdecode(fctx.path()))[0]
                 or r'application/octet-stream'
             )
             lines = [
                 dagop.annotateline(
                     fctx=fctx.filectx(fctx.filerev()),
                     lineno=1,
                     text=b'(binary:%s)' % mt,
                 )
             ]
         else:
             lines = webutil.annotate(web.req, fctx, web.repo.ui)
 
         previousrev = None
         blockparitygen = paritygen(1)
         for lineno, aline in enumerate(lines):
             f = aline.fctx
             rev = f.rev()
             if rev != previousrev:
                 blockhead = True
                 blockparity = next(blockparitygen)
             else:
                 blockhead = None
             previousrev = rev
             yield {
                 b"parity": next(parity),
                 b"node": f.hex(),
                 b"rev": rev,
                 b"author": f.user(),
                 b"parents": templateutil.mappinggenerator(parents, args=(f,)),
                 b"desc": f.description(),
                 b"extra": f.extra(),
                 b"file": f.path(),
                 b"blockhead": blockhead,
                 b"blockparity": blockparity,
                 b"targetline": aline.lineno,
                 b"line": aline.text,
                 b"lineno": lineno + 1,
                 b"lineid": b"l%d" % (lineno + 1),
                 b"linenumber": b"% 6d" % (lineno + 1),
                 b"revdate": f.date(),
             }
 
     diffopts = webutil.difffeatureopts(web.req, web.repo.ui, b'annotate')
     diffopts = {
         k: getattr(diffopts, pycompat.sysstr(k)) for k in diffopts.defaults
     }
 
     return web.sendtemplate(
         b'fileannotate',
         file=f,
         annotate=templateutil.mappinggenerator(annotate),
         path=webutil.up(f),
         symrev=webutil.symrevorshortnode(web.req, fctx),
         rename=webutil.renamelink(fctx),
         permissions=fctx.manifest().flags(f),
         ishead=int(ishead),
         diffopts=templateutil.hybriddict(diffopts),
         **pycompat.strkwargs(webutil.commonentry(web.repo, fctx))
     )
 
 
 @webcommand(b'filelog')
 def filelog(web):
     """
     /filelog/{revision}/{path}
     --------------------------
 
     Show information about the history of a file in the repository.
 
     The ``revcount`` query string argument can be defined to control the
     maximum number of entries to show.
 
     The ``filelog`` template will be rendered.
     """
 
     try:
         fctx = webutil.filectx(web.repo, web.req)
         f = fctx.path()
         fl = fctx.filelog()
     except error.LookupError:
         f = webutil.cleanpath(web.repo, web.req.qsparams[b'file'])
         fl = web.repo.file(f)
         numrevs = len(fl)
         if not numrevs:  # file doesn't exist at all
             raise
         rev = webutil.changectx(web.repo, web.req).rev()
         first = fl.linkrev(0)
         if rev < first:  # current rev is from before file existed
             raise
         frev = numrevs - 1
         while fl.linkrev(frev) > rev:
             frev -= 1
         fctx = web.repo.filectx(f, fl.linkrev(frev))
 
     revcount = web.maxshortchanges
     if b'revcount' in web.req.qsparams:
         try:
             revcount = int(web.req.qsparams.get(b'revcount', revcount))
             revcount = max(revcount, 1)
             web.tmpl.defaults[b'sessionvars'][b'revcount'] = revcount
         except ValueError:
             pass
 
     lrange = webutil.linerange(web.req)
 
     lessvars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     lessvars[b'revcount'] = max(revcount // 2, 1)
     morevars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     morevars[b'revcount'] = revcount * 2
 
     patch = b'patch' in web.req.qsparams
     if patch:
         lessvars[b'patch'] = morevars[b'patch'] = web.req.qsparams[b'patch']
     descend = b'descend' in web.req.qsparams
     if descend:
         lessvars[b'descend'] = morevars[b'descend'] = web.req.qsparams[
             b'descend'
         ]
 
     count = fctx.filerev() + 1
     start = max(0, count - revcount)  # first rev on this page
     end = min(count, start + revcount)  # last rev on this page
     parity = paritygen(web.stripecount, offset=start - end)
 
     repo = web.repo
     filelog = fctx.filelog()
     revs = [
         filerev
         for filerev in filelog.revs(start, end - 1)
         if filelog.linkrev(filerev) in repo
     ]
     entries = []
 
     diffstyle = web.config(b'web', b'style')
     if b'style' in web.req.qsparams:
         diffstyle = web.req.qsparams[b'style']
 
     def diff(fctx, linerange=None):
         ctx = fctx.changectx()
         basectx = ctx.p1()
         path = fctx.path()
         return webutil.diffs(
             web,
             ctx,
             basectx,
             [path],
             diffstyle,
             linerange=linerange,
             lineidprefix=b'%s-' % ctx.hex()[:12],
         )
 
     linerange = None
     if lrange is not None:
         assert lrange is not None  # help pytype (!?)
         linerange = webutil.formatlinerange(*lrange)
         # deactivate numeric nav links when linerange is specified as this
         # would required a dedicated "revnav" class
         nav = templateutil.mappinglist([])
         if descend:
             it = dagop.blockdescendants(fctx, *lrange)
         else:
             it = dagop.blockancestors(fctx, *lrange)
         for i, (c, lr) in enumerate(it, 1):
             diffs = None
             if patch:
                 diffs = diff(c, linerange=lr)
             # follow renames accross filtered (not in range) revisions
             path = c.path()
             lm = webutil.commonentry(repo, c)
             lm.update(
                 {
                     b'parity': next(parity),
                     b'filerev': c.rev(),
                     b'file': path,
                     b'diff': diffs,
                     b'linerange': webutil.formatlinerange(*lr),
                     b'rename': templateutil.mappinglist([]),
                 }
             )
             entries.append(lm)
             if i == revcount:
                 break
         lessvars[b'linerange'] = webutil.formatlinerange(*lrange)
         morevars[b'linerange'] = lessvars[b'linerange']
     else:
         for i in revs:
             iterfctx = fctx.filectx(i)
             diffs = None
             if patch:
                 diffs = diff(iterfctx)
             lm = webutil.commonentry(repo, iterfctx)
             lm.update(
                 {
                     b'parity': next(parity),
                     b'filerev': i,
                     b'file': f,
                     b'diff': diffs,
                     b'rename': webutil.renamelink(iterfctx),
                 }
             )
             entries.append(lm)
         entries.reverse()
         revnav = webutil.filerevnav(web.repo, fctx.path())
         nav = revnav.gen(end - 1, revcount, count)
 
     latestentry = entries[:1]
 
     return web.sendtemplate(
         b'filelog',
         file=f,
         nav=nav,
         symrev=webutil.symrevorshortnode(web.req, fctx),
         entries=templateutil.mappinglist(entries),
         descend=descend,
         patch=patch,
         latestentry=templateutil.mappinglist(latestentry),
         linerange=linerange,
         revcount=revcount,
         morevars=morevars,
         lessvars=lessvars,
         **pycompat.strkwargs(webutil.commonentry(web.repo, fctx))
     )
 
 
 @webcommand(b'archive')
 def archive(web):
     """
     /archive/{revision}.{format}[/{path}]
     -------------------------------------
 
     Obtain an archive of repository content.
 
     The content and type of the archive is defined by a URL path parameter.
     ``format`` is the file extension of the archive type to be generated. e.g.
     ``zip`` or ``tar.bz2``. Not all archive types may be allowed by your
     server configuration.
 
     The optional ``path`` URL parameter controls content to include in the
     archive. If omitted, every file in the specified revision is present in the
     archive. If included, only the specified file or contents of the specified
     directory will be included in the archive.
 
     No template is used for this handler. Raw, binary content is generated.
     """
 
     type_ = web.req.qsparams.get(b'type')
     allowed = web.configlist(b"web", b"allow-archive")
     key = web.req.qsparams[b'node']
 
     if type_ not in webutil.archivespecs:
         msg = b'Unsupported archive type: %s' % stringutil.pprint(type_)
         raise ErrorResponse(HTTP_NOT_FOUND, msg)
 
     if not ((type_ in allowed or web.configbool(b"web", b"allow" + type_))):
         msg = b'Archive type not allowed: %s' % type_
         raise ErrorResponse(HTTP_FORBIDDEN, msg)
 
     reponame = re.sub(br"\W+", b"-", os.path.basename(web.reponame))
     cnode = web.repo.lookup(key)
     arch_version = key
     if cnode == key or key == b'tip':
         arch_version = short(cnode)
     name = b"%s-%s" % (reponame, arch_version)
 
     ctx = webutil.changectx(web.repo, web.req)
     match = scmutil.match(ctx, [])
     file = web.req.qsparams.get(b'file')
     if file:
         pats = [b'path:' + file]
         match = scmutil.match(ctx, pats, default=b'path')
         if pats:
             files = [f for f in ctx.manifest().keys() if match(f)]
             if not files:
                 raise ErrorResponse(
                     HTTP_NOT_FOUND, b'file(s) not found: %s' % file
                 )
 
     mimetype, artype, extension, encoding = webutil.archivespecs[type_]
 
     web.res.headers[b'Content-Type'] = mimetype
     web.res.headers[b'Content-Disposition'] = b'attachment; filename=%s%s' % (
         name,
         extension,
     )
 
     if encoding:
         web.res.headers[b'Content-Encoding'] = encoding
 
     web.res.setbodywillwrite()
     if list(web.res.sendresponse()):
         raise error.ProgrammingError(
             b'sendresponse() should not emit data if writing later'
         )
 
     if web.req.method == b'HEAD':
         return []
 
     bodyfh = web.res.getbodyfile()
 
     archival.archive(
         web.repo,
         bodyfh,
         cnode,
         artype,
         prefix=name,
         match=match,
         subrepos=web.configbool(b"web", b"archivesubrepos"),
     )
 
     return []
 
 
 @webcommand(b'static')
 def static(web):
     fname = web.req.qsparams[b'file']
     # a repo owner may set web.static in .hg/hgrc to get any file
     # readable by the user running the CGI script
     static = web.config(b"web", b"static", untrusted=False)
     staticfile(web.templatepath, static, fname, web.res)
     return web.res.sendresponse()
 
 
 @webcommand(b'graph')
 def graph(web):
     """
     /graph[/{revision}]
     -------------------
 
     Show information about the graphical topology of the repository.
 
     Information rendered by this handler can be used to create visual
     representations of repository topology.
 
     The ``revision`` URL parameter controls the starting changeset. If it's
     absent, the default is ``tip``.
 
     The ``revcount`` query string argument can define the number of changesets
     to show information for.
 
     The ``graphtop`` query string argument can specify the starting changeset
     for producing ``jsdata`` variable that is used for rendering graph in
     JavaScript. By default it has the same value as ``revision``.
 
     This handler will render the ``graph`` template.
     """
 
     if b'node' in web.req.qsparams:
         ctx = webutil.changectx(web.repo, web.req)
         symrev = webutil.symrevorshortnode(web.req, ctx)
     else:
         ctx = web.repo[b'tip']
         symrev = b'tip'
     rev = ctx.rev()
 
     bg_height = 39
     revcount = web.maxshortchanges
     if b'revcount' in web.req.qsparams:
         try:
             revcount = int(web.req.qsparams.get(b'revcount', revcount))
             revcount = max(revcount, 1)
             web.tmpl.defaults[b'sessionvars'][b'revcount'] = revcount
         except ValueError:
             pass
 
     lessvars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     lessvars[b'revcount'] = max(revcount // 2, 1)
     morevars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     morevars[b'revcount'] = revcount * 2
 
     graphtop = web.req.qsparams.get(b'graphtop', ctx.hex())
     graphvars = copy.copy(web.tmpl.defaults[b'sessionvars'])
     graphvars[b'graphtop'] = graphtop
 
     count = len(web.repo)
     pos = rev
 
     uprev = min(max(0, count - 1), rev + revcount)
     downrev = max(0, rev - revcount)
     changenav = webutil.revnav(web.repo).gen(pos, revcount, count)
 
     tree = []
     nextentry = []
     lastrev = 0
     if pos != -1:
         allrevs = web.repo.changelog.revs(pos, 0)
         revs = []
         for i in allrevs:
             revs.append(i)
             if len(revs) >= revcount + 1:
                 break
 
         if len(revs) > revcount:
             nextentry = [webutil.commonentry(web.repo, web.repo[revs[-1]])]
             revs = revs[:-1]
 
         lastrev = revs[-1]
 
         # We have to feed a baseset to dagwalker as it is expecting smartset
         # object. This does not have a big impact on hgweb performance itself
         # since hgweb graphing code is not itself lazy yet.
         dag = graphmod.dagwalker(web.repo, smartset.baseset(revs))
         # As we said one line above... not lazy.
         tree = list(
             item
             for item in graphmod.colored(dag, web.repo)
             if item[1] == graphmod.CHANGESET
         )
 
     def fulltree():
         pos = web.repo[graphtop].rev()
         tree = []
         if pos != -1:
             revs = web.repo.changelog.revs(pos, lastrev)
             dag = graphmod.dagwalker(web.repo, smartset.baseset(revs))
             tree = list(
                 item
                 for item in graphmod.colored(dag, web.repo)
                 if item[1] == graphmod.CHANGESET
             )
         return tree
 
     def jsdata(context):
         for id, type, ctx, vtx, edges in fulltree():
             yield {
                 b'node': pycompat.bytestr(ctx),
                 b'graphnode': webutil.getgraphnode(web.repo, ctx),
                 b'vertex': vtx,
                 b'edges': edges,
             }
 
     def nodes(context):
         parity = paritygen(web.stripecount)
         for row, (id, type, ctx, vtx, edges) in enumerate(tree):
             entry = webutil.commonentry(web.repo, ctx)
             edgedata = [
                 {
                     b'col': edge[0],
                     b'nextcol': edge[1],
                     b'color': (edge[2] - 1) % 6 + 1,
                     b'width': edge[3],
                     b'bcolor': edge[4],
                 }
                 for edge in edges
             ]
 
             entry.update(
                 {
                     b'col': vtx[0],
                     b'color': (vtx[1] - 1) % 6 + 1,
                     b'parity': next(parity),
                     b'edges': templateutil.mappinglist(edgedata),
                     b'row': row,
                     b'nextrow': row + 1,
                 }
             )
 
             yield entry
 
     rows = len(tree)
 
     return web.sendtemplate(
         b'graph',
         rev=rev,
         symrev=symrev,
         revcount=revcount,
         uprev=uprev,
         lessvars=lessvars,
         morevars=morevars,
         downrev=downrev,
         graphvars=graphvars,
         rows=rows,
         bg_height=bg_height,
         changesets=count,
         nextentry=templateutil.mappinglist(nextentry),
         jsdata=templateutil.mappinggenerator(jsdata),
         nodes=templateutil.mappinggenerator(nodes),
         node=ctx.hex(),
         archives=web.archivelist(b'tip'),
         changenav=changenav,
     )
 
 
 def _getdoc(e):
     doc = e[0].__doc__
     if doc:
         doc = _(doc).partition(b'\n')[0]
     else:
         doc = _(b'(no help text available)')
     return doc
 
 
 @webcommand(b'help')
 def help(web):
     """
     /help[/{topic}]
     ---------------
 
     Render help documentation.
 
     This web command is roughly equivalent to :hg:`help`. If a ``topic``
     is defined, that help topic will be rendered. If not, an index of
     available help topics will be rendered.
 
     The ``help`` template will be rendered when requesting help for a topic.
     ``helptopics`` will be rendered for the index of help topics.
     """
     from .. import commands, help as helpmod  # avoid cycle
 
     topicname = web.req.qsparams.get(b'node')
     if not topicname:
 
         def topics(context):
             for h in helpmod.helptable:
                 entries, summary, _doc = h[0:3]
                 yield {b'topic': entries[0], b'summary': summary}
 
         early, other = [], []
         primary = lambda s: s.partition(b'|')[0]
         for c, e in commands.table.items():
             doc = _getdoc(e)
             if b'DEPRECATED' in doc or c.startswith(b'debug'):
                 continue
             cmd = primary(c)
             if getattr(e[0], 'helpbasic', False):
                 early.append((cmd, doc))
             else:
                 other.append((cmd, doc))
 
         early.sort()
         other.sort()
 
         def earlycommands(context):
             for c, doc in early:
                 yield {b'topic': c, b'summary': doc}
 
         def othercommands(context):
             for c, doc in other:
                 yield {b'topic': c, b'summary': doc}
 
         return web.sendtemplate(
             b'helptopics',
             topics=templateutil.mappinggenerator(topics),
             earlycommands=templateutil.mappinggenerator(earlycommands),
             othercommands=templateutil.mappinggenerator(othercommands),
             title=b'Index',
         )
 
     # Render an index of sub-topics.
     if topicname in helpmod.subtopics:
         topics = []
         for entries, summary, _doc in helpmod.subtopics[topicname]:
             topics.append(
                 {
                     b'topic': b'%s.%s' % (topicname, entries[0]),
                     b'basename': entries[0],
                     b'summary': summary,
                 }
             )
 
         return web.sendtemplate(
             b'helptopics',
             topics=templateutil.mappinglist(topics),
             title=topicname,
             subindex=True,
         )
 
     u = webutil.wsgiui.load()
     u.verbose = True
 
     # Render a page from a sub-topic.
     if b'.' in topicname:
         # TODO implement support for rendering sections, like
         # `hg help` works.
         topic, subtopic = topicname.split(b'.', 1)
         if topic not in helpmod.subtopics:
             raise ErrorResponse(HTTP_NOT_FOUND)
     else:
         topic = topicname
         subtopic = None
 
     try:
         doc = helpmod.help_(u, commands, topic, subtopic=subtopic)
     except error.Abort:
         raise ErrorResponse(HTTP_NOT_FOUND)
 
     return web.sendtemplate(b'help', topic=topicname, doc=doc)
 
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = commands.values()

mercurial/keepalive.py

@@ -1,692 +1,692
 #   This library is free software; you can redistribute it and/or
 #   modify it under the terms of the GNU Lesser General Public
 #   License as published by the Free Software Foundation; either
 #   version 2.1 of the License, or (at your option) any later version.
 #
 #   This library is distributed in the hope that it will be useful,
 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 #   Lesser General Public License for more details.
 #
 #   You should have received a copy of the GNU Lesser General Public
 #   License along with this library; if not, see
 #   <http://www.gnu.org/licenses/>.
 
 # This file is part of urlgrabber, a high-level cross-protocol url-grabber
 # Copyright 2002-2004 Michael D. Stenner, Ryan Tomayko
 
 # Modified by Benoit Boissinot:
 #  - fix for digest auth (inspired from urllib2.py @ Python v2.4)
 # Modified by Dirkjan Ochtman:
 #  - import md5 function from a local util module
 # Modified by Augie Fackler:
 #  - add safesend method and use it to prevent broken pipe errors
 #    on large POST requests
 
 """An HTTP handler for urllib2 that supports HTTP 1.1 and keepalive.
 
 >>> import urllib2
 >>> from keepalive import HTTPHandler
 >>> keepalive_handler = HTTPHandler()
 >>> opener = urlreq.buildopener(keepalive_handler)
 >>> urlreq.installopener(opener)
 >>>
 >>> fo = urlreq.urlopen('http://www.python.org')
 
 If a connection to a given host is requested, and all of the existing
 connections are still in use, another connection will be opened.  If
 the handler tries to use an existing connection but it fails in some
 way, it will be closed and removed from the pool.
 
 To remove the handler, simply re-run build_opener with no arguments, and
 install that opener.
 
 You can explicitly close connections by using the close_connection()
 method of the returned file-like object (described below) or you can
 use the handler methods:
 
   close_connection(host)
   close_all()
   open_connections()
 
 NOTE: using the close_connection and close_all methods of the handler
 should be done with care when using multiple threads.
   * there is nothing that prevents another thread from creating new
     connections immediately after connections are closed
   * no checks are done to prevent in-use connections from being closed
 
 >>> keepalive_handler.close_all()
 
 EXTRA ATTRIBUTES AND METHODS
 
   Upon a status of 200, the object returned has a few additional
   attributes and methods, which should not be used if you want to
   remain consistent with the normal urllib2-returned objects:
 
     close_connection()  -  close the connection to the host
     readlines()         -  you know, readlines()
     status              -  the return status (i.e. 404)
     reason              -  english translation of status (i.e. 'File not found')
 
   If you want the best of both worlds, use this inside an
   AttributeError-catching try:
 
   >>> try: status = fo.status
   >>> except AttributeError: status = None
 
   Unfortunately, these are ONLY there if status == 200, so it's not
   easy to distinguish between non-200 responses.  The reason is that
   urllib2 tries to do clever things with error codes 301, 302, 401,
   and 407, and it wraps the object upon return.
 """
 
 # $Id: keepalive.py,v 1.14 2006/04/04 21:00:32 mstenner Exp $
 
 
 import collections
 import hashlib
 import socket
 import sys
 import threading
 
 from .i18n import _
 from .node import hex
 from . import (
     pycompat,
     urllibcompat,
     util,
 )
 from .utils import procutil
 
 httplib = util.httplib
 urlerr = util.urlerr
 urlreq = util.urlreq
 
 DEBUG = None
 
 
 class ConnectionManager:
     """
     The connection manager must be able to:
       * keep track of all existing
     """
 
     def __init__(self):
         self._lock = threading.Lock()
         self._hostmap = collections.defaultdict(list)  # host -> [connection]
         self._connmap = {}  # map connections to host
         self._readymap = {}  # map connection to ready state
 
     def add(self, host, connection, ready):
         self._lock.acquire()
         try:
             self._hostmap[host].append(connection)
             self._connmap[connection] = host
             self._readymap[connection] = ready
         finally:
             self._lock.release()
 
     def remove(self, connection):
         self._lock.acquire()
         try:
             try:
                 host = self._connmap[connection]
             except KeyError:
                 pass
             else:
                 del self._connmap[connection]
                 del self._readymap[connection]
                 self._hostmap[host].remove(connection)
                 if not self._hostmap[host]:
                     del self._hostmap[host]
         finally:
             self._lock.release()
 
     def set_ready(self, connection, ready):
         try:
             self._readymap[connection] = ready
         except KeyError:
             pass
 
     def get_ready_conn(self, host):
         conn = None
         self._lock.acquire()
         try:
             for c in self._hostmap[host]:
                 if self._readymap[c]:
                     self._readymap[c] = False
                     conn = c
                     break
         finally:
             self._lock.release()
         return conn
 
     def get_all(self, host=None):
         if host:
             return list(self._hostmap[host])
         else:
             return dict(
                 {h: list(conns) for (h, conns) in self._hostmap.items()}
             )
 
 
 class KeepAliveHandler:
     def __init__(self, timeout=None):
         self._cm = ConnectionManager()
         self._timeout = timeout
         self.requestscount = 0
         self.sentbytescount = 0
 
     #### Connection Management
     def open_connections(self):
         """return a list of connected hosts and the number of connections
         to each.  [('foo.com:80', 2), ('bar.org', 1)]"""
         return [(host, len(li)) for (host, li) in self._cm.get_all().items()]
 
     def close_connection(self, host):
         """close connection(s) to <host>
         host is the host:port spec, as in 'www.cnn.com:8080' as passed in.
         no error occurs if there is no connection to that host."""
         for h in self._cm.get_all(host):
             self._cm.remove(h)
             h.close()
 
     def close_all(self):
         """close all open connections"""
         for host, conns in self._cm.get_all().items():
             for h in conns:
                 self._cm.remove(h)
                 h.close()
 
     def _request_closed(self, request, host, connection):
         """tells us that this request is now closed and that the
         connection is ready for another request"""
         self._cm.set_ready(connection, True)
 
     def _remove_connection(self, host, connection, close=0):
         if close:
             connection.close()
         self._cm.remove(connection)
 
     #### Transaction Execution
     def http_open(self, req):
         return self.do_open(HTTPConnection, req)
 
     def do_open(self, http_class, req):
         host = urllibcompat.gethost(req)
         if not host:
             raise urlerr.urlerror(b'no host given')
 
         try:
             h = self._cm.get_ready_conn(host)
             while h:
                 r = self._reuse_connection(h, req, host)
 
                 # if this response is non-None, then it worked and we're
                 # done.  Break out, skipping the else block.
                 if r:
                     break
 
                 # connection is bad - possibly closed by server
                 # discard it and ask for the next free connection
                 h.close()
                 self._cm.remove(h)
                 h = self._cm.get_ready_conn(host)
             else:
                 # no (working) free connections were found.  Create a new one.
                 h = http_class(host, timeout=self._timeout)
                 if DEBUG:
                     DEBUG.info(
                         b"creating new connection to %s (%d)", host, id(h)
                     )
                 self._cm.add(host, h, False)
                 self._start_transaction(h, req)
                 r = h.getresponse()
         # The string form of BadStatusLine is the status line. Add some context
         # to make the error message slightly more useful.
         except httplib.BadStatusLine as err:
             raise urlerr.urlerror(
                 _(b'bad HTTP status line: %s') % pycompat.sysbytes(err.line)
             )
         except (socket.error, httplib.HTTPException) as err:
             raise urlerr.urlerror(err)
 
         # If not a persistent connection, don't try to reuse it. Look
         # for this using getattr() since vcr doesn't define this
         # attribute, and in that case always close the connection.
         if getattr(r, 'will_close', True):
             self._cm.remove(h)
 
         if DEBUG:
             DEBUG.info(b"STATUS: %s, %s", r.status, r.reason)
         r._handler = self
         r._host = host
         r._url = req.get_full_url()
         r._connection = h
         r.code = r.status
         r.headers = r.msg
         r.msg = r.reason
 
         return r
 
     def _reuse_connection(self, h, req, host):
         """start the transaction with a re-used connection
         return a response object (r) upon success or None on failure.
         This DOES not close or remove bad connections in cases where
         it returns.  However, if an unexpected exception occurs, it
         will close and remove the connection before re-raising.
         """
         try:
             self._start_transaction(h, req)
             r = h.getresponse()
             # note: just because we got something back doesn't mean it
             # worked.  We'll check the version below, too.
         except (socket.error, httplib.HTTPException):
             r = None
         except:  # re-raises
             # adding this block just in case we've missed
             # something we will still raise the exception, but
             # lets try and close the connection and remove it
             # first.  We previously got into a nasty loop
             # where an exception was uncaught, and so the
             # connection stayed open.  On the next try, the
             # same exception was raised, etc.  The trade-off is
             # that it's now possible this call will raise
             # a DIFFERENT exception
             if DEBUG:
                 DEBUG.error(
                     b"unexpected exception - closing connection to %s (%d)",
                     host,
                     id(h),
                 )
             self._cm.remove(h)
             h.close()
             raise
 
         if r is None or r.version == 9:
             # httplib falls back to assuming HTTP 0.9 if it gets a
             # bad header back.  This is most likely to happen if
             # the socket has been closed by the server since we
             # last used the connection.
             if DEBUG:
                 DEBUG.info(
                     b"failed to re-use connection to %s (%d)", host, id(h)
                 )
             r = None
         else:
             if DEBUG:
                 DEBUG.info(b"re-using connection to %s (%d)", host, id(h))
 
         return r
 
     def _start_transaction(self, h, req):
         oldbytescount = getattr(h, 'sentbytescount', 0)
 
         # What follows mostly reimplements HTTPConnection.request()
         # except it adds self.parent.addheaders in the mix and sends headers
         # in a deterministic order (to make testing easier).
         headers = util.sortdict(self.parent.addheaders)
         headers.update(sorted(req.headers.items()))
         headers.update(sorted(req.unredirected_hdrs.items()))
         headers = util.sortdict((n.lower(), v) for n, v in headers.items())
         skipheaders = {}
         for n in ('host', 'accept-encoding'):
             if n in headers:
                 skipheaders['skip_' + n.replace('-', '_')] = 1
         try:
             if urllibcompat.hasdata(req):
                 data = urllibcompat.getdata(req)
                 h.putrequest(
                     req.get_method(),
                     urllibcompat.getselector(req),
                     **skipheaders
                 )
                 if 'content-type' not in headers:
                     h.putheader(
                         'Content-type', 'application/x-www-form-urlencoded'
                     )
                 if 'content-length' not in headers:
                     h.putheader('Content-length', '%d' % len(data))
             else:
                 h.putrequest(
                     req.get_method(),
                     urllibcompat.getselector(req),
                     **skipheaders
                 )
         except socket.error as err:
             raise urlerr.urlerror(err)
         for k, v in headers.items():
             h.putheader(k, v)
         h.endheaders()
         if urllibcompat.hasdata(req):
             h.send(data)
 
         # This will fail to record events in case of I/O failure. That's OK.
         self.requestscount += 1
         self.sentbytescount += getattr(h, 'sentbytescount', 0) - oldbytescount
 
         try:
             self.parent.requestscount += 1
             self.parent.sentbytescount += (
                 getattr(h, 'sentbytescount', 0) - oldbytescount
             )
         except AttributeError:
             pass
 
 
 class HTTPHandler(KeepAliveHandler, urlreq.httphandler):
     pass
 
 
 class HTTPResponse(httplib.HTTPResponse):
     # we need to subclass HTTPResponse in order to
     # 1) add close_connection() method
     # 2) add geturl() method
     # 3) add accounting for read(), readlines() and readinto()
 
     def __init__(self, sock, debuglevel=0, strict=0, method=None):
         httplib.HTTPResponse.__init__(
             self, sock, debuglevel=debuglevel, method=method
         )
         self.fileno = sock.fileno
         self.code = None
         self.receivedbytescount = 0
         self._rbuf = b''
         self._rbufsize = 8096
         self._handler = None  # inserted by the handler later
         self._host = None  # (same)
         self._url = None  # (same)
         self._connection = None  # (same)
 
     # Python 2.7 has a single close() which closes the socket handle.
     # This method was effectively renamed to _close_conn() in Python 3. But
     # there is also a close(). _close_conn() is called by methods like
     # read().
 
     def close(self):
         if self.fp:
             self.fp.close()
             self.fp = None
             if self._handler:
                 self._handler._request_closed(
                     self, self._host, self._connection
                 )
 
     def _close_conn(self):
         self.close()
 
     def close_connection(self):
         self._handler._remove_connection(self._host, self._connection, close=1)
         self.close()
 
     def geturl(self):
         return self._url
 
     def read(self, amt=None):
         data = super().read(amt)
         self.receivedbytescount += len(data)
         if self._connection is not None:
             self._connection.receivedbytescount += len(data)
         if self._handler is not None:
             self._handler.parent.receivedbytescount += len(data)
         return data
 
     def readline(self):
         data = super().readline()
         self.receivedbytescount += len(data)
         if self._connection is not None:
             self._connection.receivedbytescount += len(data)
         if self._handler is not None:
             self._handler.parent.receivedbytescount += len(data)
         return data
 
     def readinto(self, dest):
         got = super().readinto(dest)
         self.receivedbytescount += got
         if self._connection is not None:
             self._connection.receivedbytescount += got
         if self._handler is not None:
             self._handler.parent.receivedbytescount += got
         return got
 
 
 def safesend(self, str):
     """Send `str' to the server.
 
     Shamelessly ripped off from httplib to patch a bad behavior.
     """
     # _broken_pipe_resp is an attribute we set in this function
     # if the socket is closed while we're sending data but
     # the server sent us a response before hanging up.
     # In that case, we want to pretend to send the rest of the
     # outgoing data, and then let the user use getresponse()
     # (which we wrap) to get this last response before
     # opening a new socket.
     if getattr(self, '_broken_pipe_resp', None) is not None:
         return
 
     if self.sock is None:
         if self.auto_open:
             self.connect()
         else:
             raise httplib.NotConnected
 
     # send the data to the server. if we get a broken pipe, then close
     # the socket. we want to reconnect when somebody tries to send again.
     #
     # NOTE: we DO propagate the error, though, because we cannot simply
     #       ignore the error... the caller will know if they can retry.
     if self.debuglevel > 0:
         print(b"send:", repr(str))
     try:
         blocksize = 8192
         read = getattr(str, 'read', None)
         if read is not None:
             if self.debuglevel > 0:
                 print(b"sending a read()able")
             data = read(blocksize)
             while data:
                 self.sock.sendall(data)
                 self.sentbytescount += len(data)
                 data = read(blocksize)
         else:
             self.sock.sendall(str)
             self.sentbytescount += len(str)
     except BrokenPipeError:
         if self._HTTPConnection__state == httplib._CS_REQ_SENT:
             self._broken_pipe_resp = None
             self._broken_pipe_resp = self.getresponse()
             reraise = False
         else:
             reraise = True
         self.close()
         if reraise:
             raise
 
 
 def wrapgetresponse(cls):
     """Wraps getresponse in cls with a broken-pipe sane version."""
 
     def safegetresponse(self):
         # In safesend() we might set the _broken_pipe_resp
         # attribute, in which case the socket has already
         # been closed and we just need to give them the response
         # back. Otherwise, we use the normal response path.
         r = getattr(self, '_broken_pipe_resp', None)
         if r is not None:
             return r
         return cls.getresponse(self)
 
     safegetresponse.__doc__ = cls.getresponse.__doc__
     return safegetresponse
 
 
 class HTTPConnection(httplib.HTTPConnection):
     # url.httpsconnection inherits from this. So when adding/removing
     # attributes, be sure to audit httpsconnection() for unintended
     # consequences.
 
     # use the modified response class
     response_class = HTTPResponse
     send = safesend
     getresponse = wrapgetresponse(httplib.HTTPConnection)
 
     def __init__(self, *args, **kwargs):
         httplib.HTTPConnection.__init__(self, *args, **kwargs)
         self.sentbytescount = 0
         self.receivedbytescount = 0
 
     def __repr__(self):
         base = super(HTTPConnection, self).__repr__()
         local = "(unconnected)"
         s = self.sock
         if s:
             try:
                 local = "%s:%d" % s.getsockname()
             except OSError:
                 pass  # Likely not connected
         return "<%s: %s <--> %s:%d>" % (base, local, self.host, self.port)
 
 
 #########################################################################
 #####   TEST FUNCTIONS
 #########################################################################
 
 
 def continuity(url):
     md5 = hashlib.md5
     format = b'%25s: %s'
 
     # first fetch the file with the normal http handler
     opener = urlreq.buildopener()
     urlreq.installopener(opener)
     fo = urlreq.urlopen(url)
     foo = fo.read()
     fo.close()
     m = md5(foo)
     print(format % (b'normal urllib', hex(m.digest())))
 
     # now install the keepalive handler and try again
     opener = urlreq.buildopener(HTTPHandler())
     urlreq.installopener(opener)
 
     fo = urlreq.urlopen(url)
     foo = fo.read()
     fo.close()
     m = md5(foo)
     print(format % (b'keepalive read', hex(m.digest())))
 
     fo = urlreq.urlopen(url)
     foo = b''
     while True:
         f = fo.readline()
         if f:
             foo = foo + f
         else:
             break
     fo.close()
     m = md5(foo)
     print(format % (b'keepalive readline', hex(m.digest())))
 
 
 def comp(N, url):
     print(b'  making %i connections to:\n  %s' % (N, url))
 
     procutil.stdout.write(b'  first using the normal urllib handlers')
     # first use normal opener
     opener = urlreq.buildopener()
     urlreq.installopener(opener)
     t1 = fetch(N, url)
     print(b'  TIME: %.3f s' % t1)
 
     procutil.stdout.write(b'  now using the keepalive handler       ')
     # now install the keepalive handler and try again
     opener = urlreq.buildopener(HTTPHandler())
     urlreq.installopener(opener)
     t2 = fetch(N, url)
     print(b'  TIME: %.3f s' % t2)
     print(b'  improvement factor: %.2f' % (t1 / t2))
 
 
 def fetch(N, url, delay=0):
     import time
 
     lens = []
     starttime = time.time()
     for i in range(N):
         if delay and i > 0:
             time.sleep(delay)
         fo = urlreq.urlopen(url)
         foo = fo.read()
         fo.close()
         lens.append(len(foo))
     diff = time.time() - starttime
 
     j = 0
     for i in lens[1:]:
         j = j + 1
         if not i == lens[0]:
             print(b"WARNING: inconsistent length on read %i: %i" % (j, i))
 
     return diff
 
 
 def test_timeout(url):
     global DEBUG
     dbbackup = DEBUG
 
     class FakeLogger:
         def debug(self, msg, *args):
             print(msg % args)
 
         info = warning = error = debug
 
     DEBUG = FakeLogger()
     print(b"  fetching the file to establish a connection")
     fo = urlreq.urlopen(url)
     data1 = fo.read()
     fo.close()
 
     i = 20
     print(b"  waiting %i seconds for the server to close the connection" % i)
     while i > 0:
         procutil.stdout.write(b'\r  %2i' % i)
         procutil.stdout.flush()
         time.sleep(1)
         i -= 1
     procutil.stderr.write(b'\r')
 
     print(b"  fetching the file a second time")
     fo = urlreq.urlopen(url)
     data2 = fo.read()
     fo.close()
 
     if data1 == data2:
         print(b'  data are identical')
     else:
         print(b'  ERROR: DATA DIFFER')
 
     DEBUG = dbbackup
 
 
 def test(url, N=10):
     print(b"performing continuity test (making sure stuff isn't corrupted)")
     continuity(url)
     print(b'')
     print(b"performing speed comparison")
     comp(N, url)
     print(b'')
     print(b"performing dropped-connection check")
     test_timeout(url)
 
 
 if __name__ == '__main__':
     import time
 
     try:
         N = int(sys.argv[1])
         url = sys.argv[2]
     except (IndexError, ValueError):
-        print(b"%s <integer> <url>" % sys.argv[0])
+        print("%s <integer> <url>" % sys.argv[0])
     else:
         test(url, N)

mercurial/lsprof.py

@@ -1,135 +1,135
 import _lsprof
 import sys
 
 Profiler = _lsprof.Profiler
 
 # PyPy doesn't expose profiler_entry from the module.
 profiler_entry = getattr(_lsprof, 'profiler_entry', None)
 
-__all__ = [b'profile', b'Stats']
+__all__ = ['profile', 'Stats']
 
 
 def profile(f, *args, **kwds):
     """XXX docstring"""
     p = Profiler()
     p.enable(subcalls=True, builtins=True)
     try:
         f(*args, **kwds)
     finally:
         p.disable()
     return Stats(p.getstats())
 
 
 class Stats:
     """XXX docstring"""
 
     def __init__(self, data):
         self.data = data
 
     def sort(self, crit="inlinetime"):
         """XXX docstring"""
         # profiler_entries isn't defined when running under PyPy.
         if profiler_entry:
             if crit not in profiler_entry.__dict__:
                 raise ValueError(b"Can't sort by %s" % crit)
         elif self.data and not getattr(self.data[0], crit, None):
             raise ValueError(b"Can't sort by %s" % crit)
 
         self.data.sort(key=lambda x: getattr(x, crit), reverse=True)
         for e in self.data:
             if e.calls:
                 e.calls.sort(key=lambda x: getattr(x, crit), reverse=True)
 
     def pprint(self, top=None, file=None, limit=None, climit=None):
         """XXX docstring"""
         if file is None:
             file = sys.stdout
         d = self.data
         if top is not None:
             d = d[:top]
         cols = b"% 12d %12d %11.4f %11.4f   %s\n"
         hcols = b"% 12s %12s %12s %12s %s\n"
         file.write(
             hcols
             % (
                 b"CallCount",
                 b"Recursive",
                 b"Total(s)",
                 b"Inline(s)",
                 b"module:lineno(function)",
             )
         )
         count = 0
         for e in d:
             file.write(
                 cols
                 % (
                     e.callcount,
                     e.reccallcount,
                     e.totaltime,
                     e.inlinetime,
                     label(e.code),
                 )
             )
             count += 1
             if limit is not None and count == limit:
                 return
             ccount = 0
             if climit and e.calls:
                 for se in e.calls:
                     file.write(
                         cols
                         % (
                             se.callcount,
                             se.reccallcount,
                             se.totaltime,
                             se.inlinetime,
                             b"    %s" % label(se.code),
                         )
                     )
                     count += 1
                     ccount += 1
                     if limit is not None and count == limit:
                         return
                     if climit is not None and ccount == climit:
                         break
 
     def freeze(self):
         """Replace all references to code objects with string
         descriptions; this makes it possible to pickle the instance."""
 
         # this code is probably rather ickier than it needs to be!
         for i in range(len(self.data)):
             e = self.data[i]
             if not isinstance(e.code, str):
                 self.data[i] = type(e)((label(e.code),) + e[1:])
             if e.calls:
                 for j in range(len(e.calls)):
                     se = e.calls[j]
                     if not isinstance(se.code, str):
                         e.calls[j] = type(se)((label(se.code),) + se[1:])
 
 
 _fn2mod = {}
 
 
 def label(code):
     if isinstance(code, str):
         return code.encode('latin-1')
     try:
         mname = _fn2mod[code.co_filename]
     except KeyError:
         for k, v in list(sys.modules.items()):
             if v is None:
                 continue
             if not isinstance(getattr(v, '__file__', None), str):
                 continue
             if v.__file__.startswith(code.co_filename):
                 mname = _fn2mod[code.co_filename] = k
                 break
         else:
             mname = _fn2mod[code.co_filename] = '<%s>' % code.co_filename
 
     res = '%s:%d(%s)' % (mname, code.co_firstlineno, code.co_name)
 
     return res.encode('latin-1')

mercurial/merge.py

@@ -1,2520 +1,2520
 # merge.py - directory-level update/merge handling for Mercurial
 #
 # Copyright 2006, 2007 Olivia Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import collections
 import struct
 import typing
 
 from .i18n import _
 from .node import nullrev
 from .thirdparty import attr
 
 # Force pytype to use the non-vendored package
 if typing.TYPE_CHECKING:
     # noinspection PyPackageRequirements
     import attr
 
 from .utils import stringutil
 from .dirstateutils import timestamp
 from . import (
     copies,
     encoding,
     error,
     filemerge,
     match as matchmod,
     mergestate as mergestatemod,
     obsutil,
     pathutil,
     policy,
     pycompat,
     scmutil,
     subrepoutil,
     util,
     worker,
 )
 
 _pack = struct.pack
 _unpack = struct.unpack
 
 
 def _getcheckunknownconfig(repo, section, name):
     config = repo.ui.config(section, name)
     valid = [b'abort', b'ignore', b'warn']
     if config not in valid:
         validstr = b', '.join([b"'" + v + b"'" for v in valid])
         msg = _(b"%s.%s not valid ('%s' is none of %s)")
         msg %= (section, name, config, validstr)
         raise error.ConfigError(msg)
     return config
 
 
 def _checkunknownfile(dirstate, wvfs, dircache, wctx, mctx, f, f2=None):
     if wctx.isinmemory():
         # Nothing to do in IMM because nothing in the "working copy" can be an
         # unknown file.
         #
         # Note that we should bail out here, not in ``_checkunknownfiles()``,
         # because that function does other useful work.
         return False
 
     if f2 is None:
         f2 = f
     return (
         wvfs.isfileorlink_checkdir(dircache, f)
         and dirstate.normalize(f) not in dirstate
         and mctx[f2].cmp(wctx[f])
     )
 
 
 class _unknowndirschecker:
     """
     Look for any unknown files or directories that may have a path conflict
     with a file.  If any path prefix of the file exists as a file or link,
     then it conflicts.  If the file itself is a directory that contains any
     file that is not tracked, then it conflicts.
 
     Returns the shortest path at which a conflict occurs, or None if there is
     no conflict.
     """
 
     def __init__(self):
         # A set of paths known to be good.  This prevents repeated checking of
         # dirs.  It will be updated with any new dirs that are checked and found
         # to be safe.
         self._unknowndircache = set()
 
         # A set of paths that are known to be absent.  This prevents repeated
         # checking of subdirectories that are known not to exist. It will be
         # updated with any new dirs that are checked and found to be absent.
         self._missingdircache = set()
 
     def __call__(self, repo, wctx, f):
         if wctx.isinmemory():
             # Nothing to do in IMM for the same reason as ``_checkunknownfile``.
             return False
 
         # Check for path prefixes that exist as unknown files.
         for p in reversed(list(pathutil.finddirs(f))):
             if p in self._missingdircache:
                 return
             if p in self._unknowndircache:
                 continue
             if repo.wvfs.audit.check(p):
                 if (
                     repo.wvfs.isfileorlink(p)
                     and repo.dirstate.normalize(p) not in repo.dirstate
                 ):
                     return p
                 if not repo.wvfs.lexists(p):
                     self._missingdircache.add(p)
                     return
                 self._unknowndircache.add(p)
 
         # Check if the file conflicts with a directory containing unknown files.
         if repo.wvfs.audit.check(f) and repo.wvfs.isdir(f):
             # Does the directory contain any files that are not in the dirstate?
             for p, dirs, files in repo.wvfs.walk(f):
                 for fn in files:
                     relf = util.pconvert(repo.wvfs.reljoin(p, fn))
                     relf = repo.dirstate.normalize(relf, isknown=True)
                     if relf not in repo.dirstate:
                         return f
         return None
 
 
 def _checkunknownfiles(repo, wctx, mctx, force, mresult, mergeforce):
     """
     Considers any actions that care about the presence of conflicting unknown
     files. For some actions, the result is to abort; for others, it is to
     choose a different action.
     """
     fileconflicts = set()
     pathconflicts = set()
     warnconflicts = set()
     abortconflicts = set()
     unknownconfig = _getcheckunknownconfig(repo, b'merge', b'checkunknown')
     ignoredconfig = _getcheckunknownconfig(repo, b'merge', b'checkignored')
     pathconfig = repo.ui.configbool(
         b'experimental', b'merge.checkpathconflicts'
     )
     dircache = dict()
     dirstate = repo.dirstate
     wvfs = repo.wvfs
     if not force:
 
         def collectconflicts(conflicts, config):
             if config == b'abort':
                 abortconflicts.update(conflicts)
             elif config == b'warn':
                 warnconflicts.update(conflicts)
 
         checkunknowndirs = _unknowndirschecker()
         for f in mresult.files(
             (
                 mergestatemod.ACTION_CREATED,
                 mergestatemod.ACTION_DELETED_CHANGED,
             )
         ):
             if _checkunknownfile(dirstate, wvfs, dircache, wctx, mctx, f):
                 fileconflicts.add(f)
             elif pathconfig and f not in wctx:
                 path = checkunknowndirs(repo, wctx, f)
                 if path is not None:
                     pathconflicts.add(path)
         for f, args, msg in mresult.getactions(
             [mergestatemod.ACTION_LOCAL_DIR_RENAME_GET]
         ):
             if _checkunknownfile(
                 dirstate, wvfs, dircache, wctx, mctx, f, args[0]
             ):
                 fileconflicts.add(f)
 
         allconflicts = fileconflicts | pathconflicts
         ignoredconflicts = {c for c in allconflicts if repo.dirstate._ignore(c)}
         unknownconflicts = allconflicts - ignoredconflicts
         collectconflicts(ignoredconflicts, ignoredconfig)
         collectconflicts(unknownconflicts, unknownconfig)
     else:
         for f, args, msg in list(
             mresult.getactions([mergestatemod.ACTION_CREATED_MERGE])
         ):
             fl2, anc = args
             different = _checkunknownfile(
                 dirstate, wvfs, dircache, wctx, mctx, f
             )
             if repo.dirstate._ignore(f):
                 config = ignoredconfig
             else:
                 config = unknownconfig
 
             # The behavior when force is True is described by this table:
             #  config  different  mergeforce  |    action    backup
             #    *         n          *       |      get        n
             #    *         y          y       |     merge       -
             #   abort      y          n       |     merge       -   (1)
             #   warn       y          n       |  warn + get     y
             #  ignore      y          n       |      get        y
             #
             # (1) this is probably the wrong behavior here -- we should
             #     probably abort, but some actions like rebases currently
             #     don't like an abort happening in the middle of
             #     merge.update.
             if not different:
                 mresult.addfile(
                     f,
                     mergestatemod.ACTION_GET,
                     (fl2, False),
                     b'remote created',
                 )
             elif mergeforce or config == b'abort':
                 mresult.addfile(
                     f,
                     mergestatemod.ACTION_MERGE,
                     (f, f, None, False, anc),
                     b'remote differs from untracked local',
                 )
             elif config == b'abort':
                 abortconflicts.add(f)
             else:
                 if config == b'warn':
                     warnconflicts.add(f)
                 mresult.addfile(
                     f,
                     mergestatemod.ACTION_GET,
                     (fl2, True),
                     b'remote created',
                 )
 
     for f in sorted(abortconflicts):
         warn = repo.ui.warn
         if f in pathconflicts:
             if repo.wvfs.isfileorlink(f):
                 warn(_(b"%s: untracked file conflicts with directory\n") % f)
             else:
                 warn(_(b"%s: untracked directory conflicts with file\n") % f)
         else:
             warn(_(b"%s: untracked file differs\n") % f)
     if abortconflicts:
         raise error.StateError(
             _(
                 b"untracked files in working directory "
                 b"differ from files in requested revision"
             )
         )
 
     for f in sorted(warnconflicts):
         if repo.wvfs.isfileorlink(f):
             repo.ui.warn(_(b"%s: replacing untracked file\n") % f)
         else:
             repo.ui.warn(_(b"%s: replacing untracked files in directory\n") % f)
 
     def transformargs(f, args):
         backup = (
             f in fileconflicts
             or pathconflicts
             and (
                 f in pathconflicts
                 or any(p in pathconflicts for p in pathutil.finddirs(f))
             )
         )
         (flags,) = args
         return (flags, backup)
 
     mresult.mapaction(
         mergestatemod.ACTION_CREATED, mergestatemod.ACTION_GET, transformargs
     )
 
 
 def _forgetremoved(wctx, mctx, branchmerge, mresult):
     """
     Forget removed files
 
     If we're jumping between revisions (as opposed to merging), and if
     neither the working directory nor the target rev has the file,
     then we need to remove it from the dirstate, to prevent the
     dirstate from listing the file when it is no longer in the
     manifest.
 
     If we're merging, and the other revision has removed a file
     that is not present in the working directory, we need to mark it
     as removed.
     """
 
     m = mergestatemod.ACTION_FORGET
     if branchmerge:
         m = mergestatemod.ACTION_REMOVE
     for f in wctx.deleted():
         if f not in mctx:
             mresult.addfile(f, m, None, b"forget deleted")
 
     if not branchmerge:
         for f in wctx.removed():
             if f not in mctx:
                 mresult.addfile(
                     f,
                     mergestatemod.ACTION_FORGET,
                     None,
                     b"forget removed",
                 )
 
 
 def _checkcollision(repo, wmf, mresult):
     """
     Check for case-folding collisions.
     """
     # If the repo is narrowed, filter out files outside the narrowspec.
     narrowmatch = repo.narrowmatch()
     if not narrowmatch.always():
         pmmf = set(wmf.walk(narrowmatch))
         if mresult:
             for f in list(mresult.files()):
                 if not narrowmatch(f):
                     mresult.removefile(f)
     else:
         # build provisional merged manifest up
         pmmf = set(wmf)
 
     if mresult:
         # KEEP and EXEC are no-op
         for f in mresult.files(
             (
                 mergestatemod.ACTION_ADD,
                 mergestatemod.ACTION_ADD_MODIFIED,
                 mergestatemod.ACTION_FORGET,
                 mergestatemod.ACTION_GET,
                 mergestatemod.ACTION_CHANGED_DELETED,
                 mergestatemod.ACTION_DELETED_CHANGED,
             )
         ):
             pmmf.add(f)
         for f in mresult.files((mergestatemod.ACTION_REMOVE,)):
             pmmf.discard(f)
         for f, args, msg in mresult.getactions(
             [mergestatemod.ACTION_DIR_RENAME_MOVE_LOCAL]
         ):
             f2, flags = args
             pmmf.discard(f2)
             pmmf.add(f)
         for f in mresult.files((mergestatemod.ACTION_LOCAL_DIR_RENAME_GET,)):
             pmmf.add(f)
         for f, args, msg in mresult.getactions([mergestatemod.ACTION_MERGE]):
             f1, f2, fa, move, anc = args
             if move:
                 pmmf.discard(f1)
             pmmf.add(f)
 
     # check case-folding collision in provisional merged manifest
     foldmap = {}
     for f in pmmf:
         fold = util.normcase(f)
         if fold in foldmap:
             msg = _(b"case-folding collision between %s and %s")
             msg %= (f, foldmap[fold])
             raise error.StateError(msg)
         foldmap[fold] = f
 
     # check case-folding of directories
     foldprefix = unfoldprefix = lastfull = b''
     for fold, f in sorted(foldmap.items()):
         if fold.startswith(foldprefix) and not f.startswith(unfoldprefix):
             # the folded prefix matches but actual casing is different
             msg = _(b"case-folding collision between %s and directory of %s")
             msg %= (lastfull, f)
             raise error.StateError(msg)
         foldprefix = fold + b'/'
         unfoldprefix = f + b'/'
         lastfull = f
 
 
 def _filesindirs(repo, manifest, dirs):
     """
     Generator that yields pairs of all the files in the manifest that are found
     inside the directories listed in dirs, and which directory they are found
     in.
     """
     for f in manifest:
         for p in pathutil.finddirs(f):
             if p in dirs:
                 yield f, p
                 break
 
 
 def checkpathconflicts(repo, wctx, mctx, mresult):
     """
     Check if any actions introduce path conflicts in the repository, updating
     actions to record or handle the path conflict accordingly.
     """
     mf = wctx.manifest()
 
     # The set of local files that conflict with a remote directory.
     localconflicts = set()
 
     # The set of directories that conflict with a remote file, and so may cause
     # conflicts if they still contain any files after the merge.
     remoteconflicts = set()
 
     # The set of directories that appear as both a file and a directory in the
     # remote manifest.  These indicate an invalid remote manifest, which
     # can't be updated to cleanly.
     invalidconflicts = set()
 
     # The set of directories that contain files that are being created.
     createdfiledirs = set()
 
     # The set of files deleted by all the actions.
     deletedfiles = set()
 
     for f in mresult.files(
         (
             mergestatemod.ACTION_CREATED,
             mergestatemod.ACTION_DELETED_CHANGED,
             mergestatemod.ACTION_MERGE,
             mergestatemod.ACTION_CREATED_MERGE,
         )
     ):
         # This action may create a new local file.
         createdfiledirs.update(pathutil.finddirs(f))
         if mf.hasdir(f):
             # The file aliases a local directory.  This might be ok if all
             # the files in the local directory are being deleted.  This
             # will be checked once we know what all the deleted files are.
             remoteconflicts.add(f)
     # Track the names of all deleted files.
     for f in mresult.files((mergestatemod.ACTION_REMOVE,)):
         deletedfiles.add(f)
     for f, args, msg in mresult.getactions((mergestatemod.ACTION_MERGE,)):
         f1, f2, fa, move, anc = args
         if move:
             deletedfiles.add(f1)
     for f, args, msg in mresult.getactions(
         (mergestatemod.ACTION_DIR_RENAME_MOVE_LOCAL,)
     ):
         f2, flags = args
         deletedfiles.add(f2)
 
     # Check all directories that contain created files for path conflicts.
     for p in createdfiledirs:
         if p in mf:
             if p in mctx:
                 # A file is in a directory which aliases both a local
                 # and a remote file.  This is an internal inconsistency
                 # within the remote manifest.
                 invalidconflicts.add(p)
             else:
                 # A file is in a directory which aliases a local file.
                 # We will need to rename the local file.
                 localconflicts.add(p)
         pd = mresult.getfile(p)
         if pd and pd[0] in (
             mergestatemod.ACTION_CREATED,
             mergestatemod.ACTION_DELETED_CHANGED,
             mergestatemod.ACTION_MERGE,
             mergestatemod.ACTION_CREATED_MERGE,
         ):
             # The file is in a directory which aliases a remote file.
             # This is an internal inconsistency within the remote
             # manifest.
             invalidconflicts.add(p)
 
     # Rename all local conflicting files that have not been deleted.
     for p in localconflicts:
         if p not in deletedfiles:
             ctxname = bytes(wctx).rstrip(b'+')
             pnew = util.safename(p, ctxname, wctx, set(mresult.files()))
             porig = wctx[p].copysource() or p
             mresult.addfile(
                 pnew,
                 mergestatemod.ACTION_PATH_CONFLICT_RESOLVE,
                 (p, porig),
                 b'local path conflict',
             )
             mresult.addfile(
                 p,
                 mergestatemod.ACTION_PATH_CONFLICT,
                 (pnew, b'l'),
                 b'path conflict',
             )
 
     if remoteconflicts:
         # Check if all files in the conflicting directories have been removed.
         ctxname = bytes(mctx).rstrip(b'+')
         for f, p in _filesindirs(repo, mf, remoteconflicts):
             if f not in deletedfiles:
                 m, args, msg = mresult.getfile(p)
                 pnew = util.safename(p, ctxname, wctx, set(mresult.files()))
                 if m in (
                     mergestatemod.ACTION_DELETED_CHANGED,
                     mergestatemod.ACTION_MERGE,
                 ):
                     # Action was merge, just update target.
                     mresult.addfile(pnew, m, args, msg)
                 else:
                     # Action was create, change to renamed get action.
                     fl = args[0]
                     mresult.addfile(
                         pnew,
                         mergestatemod.ACTION_LOCAL_DIR_RENAME_GET,
                         (p, fl),
                         b'remote path conflict',
                     )
                 mresult.addfile(
                     p,
                     mergestatemod.ACTION_PATH_CONFLICT,
                     (pnew, b'r'),
                     b'path conflict',
                 )
                 remoteconflicts.remove(p)
                 break
 
     if invalidconflicts:
         for p in invalidconflicts:
             repo.ui.warn(_(b"%s: is both a file and a directory\n") % p)
         raise error.StateError(
             _(b"destination manifest contains path conflicts")
         )
 
 
 def _filternarrowactions(narrowmatch, branchmerge, mresult):
     """
     Filters out actions that can ignored because the repo is narrowed.
 
     Raise an exception if the merge cannot be completed because the repo is
     narrowed.
     """
     # We mutate the items in the dict during iteration, so iterate
     # over a copy.
-    for f, action in mresult.filemap():
+    for f, action in list(mresult.filemap()):
         if narrowmatch(f):
             pass
         elif not branchmerge:
             mresult.removefile(f)  # just updating, ignore changes outside clone
         elif action[0].no_op:
             mresult.removefile(f)  # merge does not affect file
         elif action[0].narrow_safe:
             if not f.endswith(b'/'):
                 mresult.removefile(f)  # merge won't affect on-disk files
 
                 mresult.addcommitinfo(
                     f, b'outside-narrow-merge-action', action[0].changes
                 )
             else:  # TODO: handle the tree case
                 msg = _(
                     b'merge affects file \'%s\' outside narrow, '
                     b'which is not yet supported'
                 )
                 hint = _(b'merging in the other direction may work')
                 raise error.Abort(msg % f, hint=hint)
         else:
             msg = _(b'conflict in file \'%s\' is outside narrow clone')
             raise error.StateError(msg % f)
 
 
 class mergeresult:
     """An object representing result of merging manifests.
 
     It has information about what actions need to be performed on dirstate
     mapping of divergent renames and other such cases."""
 
     def __init__(self):
         """
         filemapping: dict of filename as keys and action related info as values
         diverge: mapping of source name -> list of dest name for
                  divergent renames
         renamedelete: mapping of source name -> list of destinations for files
                       deleted on one side and renamed on other.
         commitinfo: dict containing data which should be used on commit
                     contains a filename -> info mapping
         actionmapping: dict of action names as keys and values are dict of
                        filename as key and related data as values
         """
         self._filemapping = {}
         self._diverge = {}
         self._renamedelete = {}
         self._commitinfo = collections.defaultdict(dict)
         self._actionmapping = collections.defaultdict(dict)
 
     def updatevalues(self, diverge, renamedelete):
         self._diverge = diverge
         self._renamedelete = renamedelete
 
     def addfile(self, filename, action, data, message):
         """adds a new file to the mergeresult object
 
         filename: file which we are adding
         action: one of mergestatemod.ACTION_*
         data: a tuple of information like fctx and ctx related to this merge
         message: a message about the merge
         """
         # if the file already existed, we need to delete it's old
         # entry form _actionmapping too
         if filename in self._filemapping:
             a, d, m = self._filemapping[filename]
             del self._actionmapping[a][filename]
 
         self._filemapping[filename] = (action, data, message)
         self._actionmapping[action][filename] = (data, message)
 
     def mapaction(self, actionfrom, actionto, transform):
         """changes all occurrences of action `actionfrom` into `actionto`,
         transforming its args with the function `transform`.
         """
         orig = self._actionmapping[actionfrom]
         del self._actionmapping[actionfrom]
         dest = self._actionmapping[actionto]
         for f, (data, msg) in orig.items():
             data = transform(f, data)
             self._filemapping[f] = (actionto, data, msg)
             dest[f] = (data, msg)
 
     def getfile(self, filename, default_return=None):
         """returns (action, args, msg) about this file
 
         returns default_return if the file is not present"""
         if filename in self._filemapping:
             return self._filemapping[filename]
         return default_return
 
     def files(self, actions=None):
         """returns files on which provided action needs to perfromed
 
         If actions is None, all files are returned
         """
         # TODO: think whether we should return renamedelete and
         # diverge filenames also
         if actions is None:
             for f in self._filemapping:
                 yield f
 
         else:
             for a in actions:
                 for f in self._actionmapping[a]:
                     yield f
 
     def removefile(self, filename):
         """removes a file from the mergeresult object as the file might
         not merging anymore"""
         action, data, message = self._filemapping[filename]
         del self._filemapping[filename]
         del self._actionmapping[action][filename]
 
     def getactions(self, actions, sort=False):
         """get list of files which are marked with these actions
         if sort is true, files for each action is sorted and then added
 
         Returns a list of tuple of form (filename, data, message)
         """
         for a in actions:
             if sort:
                 for f in sorted(self._actionmapping[a]):
                     args, msg = self._actionmapping[a][f]
                     yield f, args, msg
             else:
                 for f, (args, msg) in self._actionmapping[a].items():
                     yield f, args, msg
 
     def len(self, actions=None):
         """returns number of files which needs actions
 
         if actions is passed, total of number of files in that action
         only is returned"""
 
         if actions is None:
             return len(self._filemapping)
 
         return sum(len(self._actionmapping[a]) for a in actions)
 
     def filemap(self, sort=False):
-        if sorted:
+        if sort:
             for key, val in sorted(self._filemapping.items()):
                 yield key, val
         else:
             for key, val in self._filemapping.items():
                 yield key, val
 
     def addcommitinfo(self, filename, key, value):
         """adds key-value information about filename which will be required
         while committing this merge"""
         self._commitinfo[filename][key] = value
 
     @property
     def diverge(self):
         return self._diverge
 
     @property
     def renamedelete(self):
         return self._renamedelete
 
     @property
     def commitinfo(self):
         return self._commitinfo
 
     @property
     def actionsdict(self):
         """returns a dictionary of actions to be perfomed with action as key
         and a list of files and related arguments as values"""
         res = collections.defaultdict(list)
         for a, d in self._actionmapping.items():
             for f, (args, msg) in d.items():
                 res[a].append((f, args, msg))
         return res
 
     def setactions(self, actions):
         self._filemapping = actions
         self._actionmapping = collections.defaultdict(dict)
         for f, (act, data, msg) in self._filemapping.items():
             self._actionmapping[act][f] = data, msg
 
     def hasconflicts(self):
         """tells whether this merge resulted in some actions which can
         result in conflicts or not"""
         for a in self._actionmapping.keys():
             if (
                 a
                 not in (
                     mergestatemod.ACTION_GET,
                     mergestatemod.ACTION_EXEC,
                     mergestatemod.ACTION_REMOVE,
                     mergestatemod.ACTION_PATH_CONFLICT_RESOLVE,
                 )
                 and self._actionmapping[a]
                 and not a.no_op
             ):
                 return True
 
         return False
 
 
 def manifestmerge(
     repo,
     wctx,
     p2,
     pa,
     branchmerge,
     force,
     matcher,
     acceptremote,
     followcopies,
     forcefulldiff=False,
 ):
     """
     Merge wctx and p2 with ancestor pa and generate merge action list
 
     branchmerge and force are as passed in to update
     matcher = matcher to filter file lists
     acceptremote = accept the incoming changes without prompting
 
     Returns an object of mergeresult class
     """
     mresult = mergeresult()
     if matcher is not None and matcher.always():
         matcher = None
 
     # manifests fetched in order are going to be faster, so prime the caches
     [
         x.manifest()
         for x in sorted(wctx.parents() + [p2, pa], key=scmutil.intrev)
     ]
 
     branch_copies1 = copies.branch_copies()
     branch_copies2 = copies.branch_copies()
     diverge = {}
     # information from merge which is needed at commit time
     # for example choosing filelog of which parent to commit
     # TODO: use specific constants in future for this mapping
     if followcopies:
         branch_copies1, branch_copies2, diverge = copies.mergecopies(
             repo, wctx, p2, pa
         )
 
     boolbm = pycompat.bytestr(bool(branchmerge))
     boolf = pycompat.bytestr(bool(force))
     boolm = pycompat.bytestr(bool(matcher))
     repo.ui.note(_(b"resolving manifests\n"))
     repo.ui.debug(
         b" branchmerge: %s, force: %s, partial: %s\n" % (boolbm, boolf, boolm)
     )
     repo.ui.debug(b" ancestor: %s, local: %s, remote: %s\n" % (pa, wctx, p2))
 
     m1, m2, ma = wctx.manifest(), p2.manifest(), pa.manifest()
     copied1 = set(branch_copies1.copy.values())
     copied1.update(branch_copies1.movewithdir.values())
     copied2 = set(branch_copies2.copy.values())
     copied2.update(branch_copies2.movewithdir.values())
 
     if b'.hgsubstate' in m1 and wctx.rev() is None:
         # Check whether sub state is modified, and overwrite the manifest
         # to flag the change. If wctx is a committed revision, we shouldn't
         # care for the dirty state of the working directory.
         if any(wctx.sub(s).dirty() for s in wctx.substate):
             m1[b'.hgsubstate'] = repo.nodeconstants.modifiednodeid
 
     # Don't use m2-vs-ma optimization if:
     # - ma is the same as m1 or m2, which we're just going to diff again later
     # - The caller specifically asks for a full diff, which is useful during bid
     #   merge.
     # - we are tracking salvaged files specifically hence should process all
     #   files
     if (
         pa not in ([wctx, p2] + wctx.parents())
         and not forcefulldiff
         and not (
             repo.ui.configbool(b'experimental', b'merge-track-salvaged')
             or repo.filecopiesmode == b'changeset-sidedata'
         )
     ):
         # Identify which files are relevant to the merge, so we can limit the
         # total m1-vs-m2 diff to just those files. This has significant
         # performance benefits in large repositories.
         relevantfiles = set(ma.diff(m2).keys())
 
         # For copied and moved files, we need to add the source file too.
         for copykey, copyvalue in branch_copies1.copy.items():
             if copyvalue in relevantfiles:
                 relevantfiles.add(copykey)
         for movedirkey in branch_copies1.movewithdir:
             relevantfiles.add(movedirkey)
         filesmatcher = scmutil.matchfiles(repo, relevantfiles)
         matcher = matchmod.intersectmatchers(matcher, filesmatcher)
 
     diff = m1.diff(m2, match=matcher)
 
     for f, ((n1, fl1), (n2, fl2)) in diff.items():
         if n1 and n2:  # file exists on both local and remote side
             if f not in ma:
                 # TODO: what if they're renamed from different sources?
                 fa = branch_copies1.copy.get(
                     f, None
                 ) or branch_copies2.copy.get(f, None)
                 args, msg = None, None
                 if fa is not None:
                     args = (f, f, fa, False, pa.node())
                     msg = b'both renamed from %s' % fa
                 else:
                     args = (f, f, None, False, pa.node())
                     msg = b'both created'
                 mresult.addfile(f, mergestatemod.ACTION_MERGE, args, msg)
             elif f in branch_copies1.copy:
                 fa = branch_copies1.copy[f]
                 mresult.addfile(
                     f,
                     mergestatemod.ACTION_MERGE,
                     (f, fa, fa, False, pa.node()),
                     b'local replaced from %s' % fa,
                 )
             elif f in branch_copies2.copy:
                 fa = branch_copies2.copy[f]
                 mresult.addfile(
                     f,
                     mergestatemod.ACTION_MERGE,
                     (fa, f, fa, False, pa.node()),
                     b'other replaced from %s' % fa,
                 )
             else:
                 a = ma[f]
                 fla = ma.flags(f)
                 nol = b'l' not in fl1 + fl2 + fla
                 if n2 == a and fl2 == fla:
                     mresult.addfile(
                         f,
                         mergestatemod.ACTION_KEEP,
                         (),
                         b'remote unchanged',
                     )
                 elif n1 == a and fl1 == fla:  # local unchanged - use remote
                     if n1 == n2:  # optimization: keep local content
                         mresult.addfile(
                             f,
                             mergestatemod.ACTION_EXEC,
                             (fl2,),
                             b'update permissions',
                         )
                     else:
                         mresult.addfile(
                             f,
                             mergestatemod.ACTION_GET,
                             (fl2, False),
                             b'remote is newer',
                         )
                         if branchmerge:
                             mresult.addcommitinfo(
                                 f, b'filenode-source', b'other'
                             )
                 elif nol and n2 == a:  # remote only changed 'x'
                     mresult.addfile(
                         f,
                         mergestatemod.ACTION_EXEC,
                         (fl2,),
                         b'update permissions',
                     )
                 elif nol and n1 == a:  # local only changed 'x'
                     mresult.addfile(
                         f,
                         mergestatemod.ACTION_GET,
                         (fl1, False),
                         b'remote is newer',
                     )
                     if branchmerge:
                         mresult.addcommitinfo(f, b'filenode-source', b'other')
                 else:  # both changed something
                     mresult.addfile(
                         f,
                         mergestatemod.ACTION_MERGE,
                         (f, f, f, False, pa.node()),
                         b'versions differ',
                     )
         elif n1:  # file exists only on local side
             if f in copied2:
                 pass  # we'll deal with it on m2 side
             elif (
                 f in branch_copies1.movewithdir
             ):  # directory rename, move local
                 f2 = branch_copies1.movewithdir[f]
                 if f2 in m2:
                     mresult.addfile(
                         f2,
                         mergestatemod.ACTION_MERGE,
                         (f, f2, None, True, pa.node()),
                         b'remote directory rename, both created',
                     )
                 else:
                     mresult.addfile(
                         f2,
                         mergestatemod.ACTION_DIR_RENAME_MOVE_LOCAL,
                         (f, fl1),
                         b'remote directory rename - move from %s' % f,
                     )
             elif f in branch_copies1.copy:
                 f2 = branch_copies1.copy[f]
                 mresult.addfile(
                     f,
                     mergestatemod.ACTION_MERGE,
                     (f, f2, f2, False, pa.node()),
                     b'local copied/moved from %s' % f2,
                 )
             elif f in ma:  # clean, a different, no remote
                 if n1 != ma[f]:
                     if acceptremote:
                         mresult.addfile(
                             f,
                             mergestatemod.ACTION_REMOVE,
                             None,
                             b'remote delete',
                         )
                     else:
                         mresult.addfile(
                             f,
                             mergestatemod.ACTION_CHANGED_DELETED,
                             (f, None, f, False, pa.node()),
                             b'prompt changed/deleted',
                         )
                         if branchmerge:
                             mresult.addcommitinfo(
                                 f, b'merge-removal-candidate', b'yes'
                             )
                 elif n1 == repo.nodeconstants.addednodeid:
                     # This file was locally added. We should forget it instead of
                     # deleting it.
                     mresult.addfile(
                         f,
                         mergestatemod.ACTION_FORGET,
                         None,
                         b'remote deleted',
                     )
                 else:
                     mresult.addfile(
                         f,
                         mergestatemod.ACTION_REMOVE,
                         None,
                         b'other deleted',
                     )
                     if branchmerge:
                         # the file must be absent after merging,
                         # howeber the user might make
                         # the file reappear using revert and if they does,
                         # we force create a new node
                         mresult.addcommitinfo(
                             f, b'merge-removal-candidate', b'yes'
                         )
 
             else:  # file not in ancestor, not in remote
                 mresult.addfile(
                     f,
                     mergestatemod.ACTION_KEEP_NEW,
                     None,
                     b'ancestor missing, remote missing',
                 )
 
         elif n2:  # file exists only on remote side
             if f in copied1:
                 pass  # we'll deal with it on m1 side
             elif f in branch_copies2.movewithdir:
                 f2 = branch_copies2.movewithdir[f]
                 if f2 in m1:
                     mresult.addfile(
                         f2,
                         mergestatemod.ACTION_MERGE,
                         (f2, f, None, False, pa.node()),
                         b'local directory rename, both created',
                     )
                 else:
                     mresult.addfile(
                         f2,
                         mergestatemod.ACTION_LOCAL_DIR_RENAME_GET,
                         (f, fl2),
                         b'local directory rename - get from %s' % f,
                     )
             elif f in branch_copies2.copy:
                 f2 = branch_copies2.copy[f]
                 msg, args = None, None
                 if f2 in m2:
                     args = (f2, f, f2, False, pa.node())
                     msg = b'remote copied from %s' % f2
                 else:
                     args = (f2, f, f2, True, pa.node())
                     msg = b'remote moved from %s' % f2
                 mresult.addfile(f, mergestatemod.ACTION_MERGE, args, msg)
             elif f not in ma:
                 # local unknown, remote created: the logic is described by the
                 # following table:
                 #
                 # force  branchmerge  different  |  action
                 #   n         *           *      |   create
                 #   y         n           *      |   create
                 #   y         y           n      |   create
                 #   y         y           y      |   merge
                 #
                 # Checking whether the files are different is expensive, so we
                 # don't do that when we can avoid it.
                 if not force:
                     mresult.addfile(
                         f,
                         mergestatemod.ACTION_CREATED,
                         (fl2,),
                         b'remote created',
                     )
                 elif not branchmerge:
                     mresult.addfile(
                         f,
                         mergestatemod.ACTION_CREATED,
                         (fl2,),
                         b'remote created',
                     )
                 else:
                     mresult.addfile(
                         f,
                         mergestatemod.ACTION_CREATED_MERGE,
                         (fl2, pa.node()),
                         b'remote created, get or merge',
                     )
             elif n2 != ma[f]:
                 df = None
                 for d in branch_copies1.dirmove:
                     if f.startswith(d):
                         # new file added in a directory that was moved
                         df = branch_copies1.dirmove[d] + f[len(d) :]
                         break
                 if df is not None and df in m1:
                     mresult.addfile(
                         df,
                         mergestatemod.ACTION_MERGE,
                         (df, f, f, False, pa.node()),
                         b'local directory rename - respect move '
                         b'from %s' % f,
                     )
                 elif acceptremote:
                     mresult.addfile(
                         f,
                         mergestatemod.ACTION_CREATED,
                         (fl2,),
                         b'remote recreating',
                     )
                 else:
                     mresult.addfile(
                         f,
                         mergestatemod.ACTION_DELETED_CHANGED,
                         (None, f, f, False, pa.node()),
                         b'prompt deleted/changed',
                     )
                     if branchmerge:
                         mresult.addcommitinfo(
                             f, b'merge-removal-candidate', b'yes'
                         )
             else:
                 mresult.addfile(
                     f,
                     mergestatemod.ACTION_KEEP_ABSENT,
                     None,
                     b'local not present, remote unchanged',
                 )
                 if branchmerge:
                     # the file must be absent after merging
                     # however the user might make
                     # the file reappear using revert and if they does,
                     # we force create a new node
                     mresult.addcommitinfo(f, b'merge-removal-candidate', b'yes')
 
     if repo.ui.configbool(b'experimental', b'merge.checkpathconflicts'):
         # If we are merging, look for path conflicts.
         checkpathconflicts(repo, wctx, p2, mresult)
 
     narrowmatch = repo.narrowmatch()
     if not narrowmatch.always():
         # Updates "actions" in place
         _filternarrowactions(narrowmatch, branchmerge, mresult)
 
     renamedelete = branch_copies1.renamedelete
     renamedelete.update(branch_copies2.renamedelete)
 
     mresult.updatevalues(diverge, renamedelete)
     return mresult
 
 
 def _resolvetrivial(repo, wctx, mctx, ancestor, mresult):
     """Resolves false conflicts where the nodeid changed but the content
     remained the same."""
     # We force a copy of actions.items() because we're going to mutate
     # actions as we resolve trivial conflicts.
     for f in list(mresult.files((mergestatemod.ACTION_CHANGED_DELETED,))):
         if f in ancestor and not wctx[f].cmp(ancestor[f]):
             # local did change but ended up with same content
             mresult.addfile(
                 f, mergestatemod.ACTION_REMOVE, None, b'prompt same'
             )
 
     for f in list(mresult.files((mergestatemod.ACTION_DELETED_CHANGED,))):
         if f in ancestor and not mctx[f].cmp(ancestor[f]):
             # remote did change but ended up with same content
             mresult.removefile(f)  # don't get = keep local deleted
 
 
 def calculateupdates(
     repo,
     wctx,
     mctx,
     ancestors,
     branchmerge,
     force,
     acceptremote,
     followcopies,
     matcher=None,
     mergeforce=False,
 ):
     """
     Calculate the actions needed to merge mctx into wctx using ancestors
 
     Uses manifestmerge() to merge manifest and get list of actions required to
     perform for merging two manifests. If there are multiple ancestors, uses bid
     merge if enabled.
 
     Also filters out actions which are unrequired if repository is sparse.
 
     Returns mergeresult object same as manifestmerge().
     """
     # Avoid cycle.
     from . import sparse
 
     mresult = None
     if len(ancestors) == 1:  # default
         mresult = manifestmerge(
             repo,
             wctx,
             mctx,
             ancestors[0],
             branchmerge,
             force,
             matcher,
             acceptremote,
             followcopies,
         )
         _checkunknownfiles(repo, wctx, mctx, force, mresult, mergeforce)
         if repo.ui.configbool(b'devel', b'debug.abort-update'):
             exit(1)
 
     else:  # only when merge.preferancestor=* - the default
         repo.ui.note(
             _(b"note: merging %s and %s using bids from ancestors %s\n")
             % (
                 wctx,
                 mctx,
                 _(b' and ').join(pycompat.bytestr(anc) for anc in ancestors),
             )
         )
 
         # mapping filename to bids (action method to list af actions)
         # {FILENAME1 : BID1, FILENAME2 : BID2}
         # BID is another dictionary which contains
         # mapping of following form:
         # {ACTION_X : [info, ..], ACTION_Y : [info, ..]}
         fbids = {}
         mresult = mergeresult()
         diverge, renamedelete = None, None
         for ancestor in ancestors:
             repo.ui.note(_(b'\ncalculating bids for ancestor %s\n') % ancestor)
             mresult1 = manifestmerge(
                 repo,
                 wctx,
                 mctx,
                 ancestor,
                 branchmerge,
                 force,
                 matcher,
                 acceptremote,
                 followcopies,
                 forcefulldiff=True,
             )
             _checkunknownfiles(repo, wctx, mctx, force, mresult1, mergeforce)
 
             # Track the shortest set of warning on the theory that bid
             # merge will correctly incorporate more information
             if diverge is None or len(mresult1.diverge) < len(diverge):
                 diverge = mresult1.diverge
             if renamedelete is None or len(renamedelete) < len(
                 mresult1.renamedelete
             ):
                 renamedelete = mresult1.renamedelete
 
             # blindly update final mergeresult commitinfo with what we get
             # from mergeresult object for each ancestor
             # TODO: some commitinfo depends on what bid merge choose and hence
             # we will need to make commitinfo also depend on bid merge logic
             mresult._commitinfo.update(mresult1._commitinfo)
 
             for f, a in mresult1.filemap(sort=True):
                 m, args, msg = a
                 repo.ui.debug(b' %s: %s -> %s\n' % (f, msg, m.__bytes__()))
                 if f in fbids:
                     d = fbids[f]
                     if m in d:
                         d[m].append(a)
                     else:
                         d[m] = [a]
                 else:
                     fbids[f] = {m: [a]}
 
         # Call for bids
         # Pick the best bid for each file
         repo.ui.note(
             _(b'\nauction for merging merge bids (%d ancestors)\n')
             % len(ancestors)
         )
         for f, bids in sorted(fbids.items()):
             if repo.ui.debugflag:
                 repo.ui.debug(b" list of bids for %s:\n" % f)
                 for m, l in sorted(bids.items()):
                     for _f, args, msg in l:
                         repo.ui.debug(b'   %s -> %s\n' % (msg, m.__bytes__()))
             # bids is a mapping from action method to list af actions
             # Consensus?
             if len(bids) == 1:  # all bids are the same kind of method
                 m, l = list(bids.items())[0]
                 if all(a == l[0] for a in l[1:]):  # len(bids) is > 1
                     repo.ui.note(
                         _(b" %s: consensus for %s\n") % (f, m.__bytes__())
                     )
                     mresult.addfile(f, *l[0])
                     continue
             # If keep is an option, just do it.
             if mergestatemod.ACTION_KEEP in bids:
                 repo.ui.note(_(b" %s: picking 'keep' action\n") % f)
                 mresult.addfile(f, *bids[mergestatemod.ACTION_KEEP][0])
                 continue
             # If keep absent is an option, just do that
             if mergestatemod.ACTION_KEEP_ABSENT in bids:
                 repo.ui.note(_(b" %s: picking 'keep absent' action\n") % f)
                 mresult.addfile(f, *bids[mergestatemod.ACTION_KEEP_ABSENT][0])
                 continue
             # ACTION_KEEP_NEW and ACTION_CHANGED_DELETED are conflicting actions
             # as one say that file is new while other says that file was present
             # earlier too and has a change delete conflict
             # Let's fall back to conflicting ACTION_CHANGED_DELETED and let user
             # do the right thing
             if (
                 mergestatemod.ACTION_CHANGED_DELETED in bids
                 and mergestatemod.ACTION_KEEP_NEW in bids
             ):
                 repo.ui.note(_(b" %s: picking 'changed/deleted' action\n") % f)
                 mresult.addfile(
                     f, *bids[mergestatemod.ACTION_CHANGED_DELETED][0]
                 )
                 continue
             # If keep new is an option, let's just do that
             if mergestatemod.ACTION_KEEP_NEW in bids:
                 repo.ui.note(_(b" %s: picking 'keep new' action\n") % f)
                 mresult.addfile(f, *bids[mergestatemod.ACTION_KEEP_NEW][0])
                 continue
             # ACTION_GET and ACTION_DELETE_CHANGED are conflicting actions as
             # one action states the file is newer/created on remote side and
             # other states that file is deleted locally and changed on remote
             # side. Let's fallback and rely on a conflicting action to let user
             # do the right thing
             if (
                 mergestatemod.ACTION_DELETED_CHANGED in bids
                 and mergestatemod.ACTION_GET in bids
             ):
                 repo.ui.note(_(b" %s: picking 'delete/changed' action\n") % f)
                 mresult.addfile(
                     f, *bids[mergestatemod.ACTION_DELETED_CHANGED][0]
                 )
                 continue
             # If there are gets and they all agree [how could they not?], do it.
             if mergestatemod.ACTION_GET in bids:
                 ga0 = bids[mergestatemod.ACTION_GET][0]
                 if all(a == ga0 for a in bids[mergestatemod.ACTION_GET][1:]):
                     repo.ui.note(_(b" %s: picking 'get' action\n") % f)
                     mresult.addfile(f, *ga0)
                     continue
             # TODO: Consider other simple actions such as mode changes
             # Handle inefficient democrazy.
             repo.ui.note(_(b' %s: multiple bids for merge action:\n') % f)
             for m, l in sorted(bids.items()):
                 for _f, args, msg in l:
                     repo.ui.note(b'  %s -> %s\n' % (msg, m.__bytes__()))
             # Pick random action. TODO: Instead, prompt user when resolving
             m, l = list(bids.items())[0]
             repo.ui.warn(
                 _(b' %s: ambiguous merge - picked %s action\n')
                 % (f, m.__bytes__())
             )
             mresult.addfile(f, *l[0])
             continue
         repo.ui.note(_(b'end of auction\n\n'))
         mresult.updatevalues(diverge, renamedelete)
 
     if wctx.rev() is None:
         _forgetremoved(wctx, mctx, branchmerge, mresult)
 
     sparse.filterupdatesactions(repo, wctx, mctx, branchmerge, mresult)
     _resolvetrivial(repo, wctx, mctx, ancestors[0], mresult)
 
     return mresult
 
 
 def _getcwd():
     try:
         return encoding.getcwd()
     except FileNotFoundError:
         return None
 
 
 def batchremove(repo, wctx, actions):
     """apply removes to the working directory
 
     yields tuples for progress updates
     """
     verbose = repo.ui.verbose
     cwd = _getcwd()
     i = 0
     for f, args, msg in actions:
         repo.ui.debug(b" %s: %s -> r\n" % (f, msg))
         if verbose:
             repo.ui.note(_(b"removing %s\n") % f)
         wctx[f].audit()
         try:
             wctx[f].remove(ignoremissing=True)
         except OSError as inst:
             repo.ui.warn(
                 _(b"update failed to remove %s: %s!\n")
                 % (f, stringutil.forcebytestr(inst.strerror))
             )
         if i == 100:
             yield i, f
             i = 0
         i += 1
     if i > 0:
         yield i, f
 
     if cwd and not _getcwd():
         # cwd was removed in the course of removing files; print a helpful
         # warning.
         repo.ui.warn(
             _(
                 b"current directory was removed\n"
                 b"(consider changing to repo root: %s)\n"
             )
             % repo.root
         )
 
 
 def batchget(repo, mctx, wctx, wantfiledata, actions):
     """apply gets to the working directory
 
     mctx is the context to get from
 
     Yields arbitrarily many (False, tuple) for progress updates, followed by
     exactly one (True, filedata). When wantfiledata is false, filedata is an
     empty dict. When wantfiledata is true, filedata[f] is a triple (mode, size,
     mtime) of the file f written for each action.
     """
     filedata = {}
     verbose = repo.ui.verbose
     fctx = mctx.filectx
     ui = repo.ui
     i = 0
     with repo.wvfs.backgroundclosing(ui, expectedcount=len(actions)):
         for f, (flags, backup), msg in actions:
             repo.ui.debug(b" %s: %s -> g\n" % (f, msg))
             if verbose:
                 repo.ui.note(_(b"getting %s\n") % f)
 
             if backup:
                 # If a file or directory exists with the same name, back that
                 # up.  Otherwise, look to see if there is a file that conflicts
                 # with a directory this file is in, and if so, back that up.
                 conflicting = f
                 if not repo.wvfs.lexists(f):
                     for p in pathutil.finddirs(f):
                         if repo.wvfs.isfileorlink(p):
                             conflicting = p
                             break
                 if repo.wvfs.lexists(conflicting):
                     orig = scmutil.backuppath(ui, repo, conflicting)
                     util.rename(repo.wjoin(conflicting), orig)
             wfctx = wctx[f]
             wfctx.clearunknown()
             atomictemp = ui.configbool(b"experimental", b"update.atomic-file")
             size = wfctx.write(
                 fctx(f).data(),
                 flags,
                 backgroundclose=True,
                 atomictemp=atomictemp,
             )
             if wantfiledata:
                 # XXX note that there is a race window between the time we
                 # write the clean data into the file and we stats it. So another
                 # writing process meddling with the file content right after we
                 # wrote it could cause bad stat data to be gathered.
                 #
                 # They are 2 data we gather here
                 # - the mode:
                 #       That we actually just wrote, we should not need to read
                 #       it from disk, (except not all mode might have survived
                 #       the disk round-trip, which is another issue: we should
                 #       not depends on this)
                 # - the mtime,
                 #       On system that support nanosecond precision, the mtime
                 #       could be accurate enough to tell the two writes appart.
                 #       However gathering it in a racy way make the mtime we
                 #       gather "unreliable".
                 #
                 # (note: we get the size from the data we write, which is sane)
                 #
                 # So in theory the data returned here are fully racy, but in
                 # practice "it works mostly fine".
                 #
                 # Do not be surprised if you end up reading this while looking
                 # for the causes of some buggy status. Feel free to improve
                 # this in the future, but we cannot simply stop gathering
                 # information. Otherwise `hg status` call made after a large `hg
                 # update` runs would have to redo a similar amount of work to
                 # restore and compare all files content.
                 s = wfctx.lstat()
                 mode = s.st_mode
                 mtime = timestamp.mtime_of(s)
                 # for dirstate.update_file's parentfiledata argument:
                 filedata[f] = (mode, size, mtime)
             if i == 100:
                 yield False, (i, f)
                 i = 0
             i += 1
     if i > 0:
         yield False, (i, f)
     yield True, filedata
 
 
 def _prefetchfiles(repo, ctx, mresult):
     """Invoke ``scmutil.prefetchfiles()`` for the files relevant to the dict
     of merge actions.  ``ctx`` is the context being merged in."""
 
     # Skipping 'a', 'am', 'f', 'r', 'dm', 'e', 'k', 'p' and 'pr', because they
     # don't touch the context to be merged in.  'cd' is skipped, because
     # changed/deleted never resolves to something from the remote side.
     files = mresult.files(
         [
             mergestatemod.ACTION_GET,
             mergestatemod.ACTION_DELETED_CHANGED,
             mergestatemod.ACTION_LOCAL_DIR_RENAME_GET,
             mergestatemod.ACTION_MERGE,
         ]
     )
 
     prefetch = scmutil.prefetchfiles
     matchfiles = scmutil.matchfiles
     prefetch(
         repo,
         [
             (
                 ctx.rev(),
                 matchfiles(repo, files),
             )
         ],
     )
 
 
 @attr.s(frozen=True)
 class updateresult:
     updatedcount = attr.ib()
     mergedcount = attr.ib()
     removedcount = attr.ib()
     unresolvedcount = attr.ib()
 
     def isempty(self):
         return not (
             self.updatedcount
             or self.mergedcount
             or self.removedcount
             or self.unresolvedcount
         )
 
 
 def applyupdates(
     repo,
     mresult,
     wctx,
     mctx,
     overwrite,
     wantfiledata,
     labels=None,
 ):
     """apply the merge action list to the working directory
 
     mresult is a mergeresult object representing result of the merge
     wctx is the working copy context
     mctx is the context to be merged into the working copy
 
     Return a tuple of (counts, filedata), where counts is a tuple
     (updated, merged, removed, unresolved) that describes how many
     files were affected by the update, and filedata is as described in
     batchget.
     """
 
     _prefetchfiles(repo, mctx, mresult)
 
     updated, merged, removed = 0, 0, 0
     ms = wctx.mergestate(clean=True)
     ms.start(wctx.p1().node(), mctx.node(), labels)
 
     for f, op in mresult.commitinfo.items():
         # the other side of filenode was choosen while merging, store this in
         # mergestate so that it can be reused on commit
         ms.addcommitinfo(f, op)
 
     num_no_op = mresult.len(mergestatemod.MergeAction.NO_OP_ACTIONS)
     numupdates = mresult.len() - num_no_op
     progress = repo.ui.makeprogress(
         _(b'updating'), unit=_(b'files'), total=numupdates
     )
 
     if b'.hgsubstate' in mresult._actionmapping[mergestatemod.ACTION_REMOVE]:
         subrepoutil.submerge(repo, wctx, mctx, wctx, overwrite, labels)
 
     # record path conflicts
     for f, args, msg in mresult.getactions(
         [mergestatemod.ACTION_PATH_CONFLICT], sort=True
     ):
         f1, fo = args
         s = repo.ui.status
         s(
             _(
                 b"%s: path conflict - a file or link has the same name as a "
                 b"directory\n"
             )
             % f
         )
         if fo == b'l':
             s(_(b"the local file has been renamed to %s\n") % f1)
         else:
             s(_(b"the remote file has been renamed to %s\n") % f1)
         s(_(b"resolve manually then use 'hg resolve --mark %s'\n") % f)
         ms.addpathconflict(f, f1, fo)
         progress.increment(item=f)
 
     # When merging in-memory, we can't support worker processes, so set the
     # per-item cost at 0 in that case.
     cost = 0 if wctx.isinmemory() else 0.001
 
     # remove in parallel (must come before resolving path conflicts and getting)
     prog = worker.worker(
         repo.ui,
         cost,
         batchremove,
         (repo, wctx),
         list(mresult.getactions([mergestatemod.ACTION_REMOVE], sort=True)),
     )
     for i, item in prog:
         progress.increment(step=i, item=item)
     removed = mresult.len((mergestatemod.ACTION_REMOVE,))
 
     # resolve path conflicts (must come before getting)
     for f, args, msg in mresult.getactions(
         [mergestatemod.ACTION_PATH_CONFLICT_RESOLVE], sort=True
     ):
         repo.ui.debug(b" %s: %s -> pr\n" % (f, msg))
         (f0, origf0) = args
         if wctx[f0].lexists():
             repo.ui.note(_(b"moving %s to %s\n") % (f0, f))
             wctx[f].audit()
             wctx[f].write(wctx.filectx(f0).data(), wctx.filectx(f0).flags())
             wctx[f0].remove()
         progress.increment(item=f)
 
     # get in parallel.
     threadsafe = repo.ui.configbool(
         b'experimental', b'worker.wdir-get-thread-safe'
     )
     prog = worker.worker(
         repo.ui,
         cost,
         batchget,
         (repo, mctx, wctx, wantfiledata),
         list(mresult.getactions([mergestatemod.ACTION_GET], sort=True)),
         threadsafe=threadsafe,
         hasretval=True,
     )
     getfiledata = {}
     for final, res in prog:
         if final:
             getfiledata = res
         else:
             i, item = res
             progress.increment(step=i, item=item)
 
     if b'.hgsubstate' in mresult._actionmapping[mergestatemod.ACTION_GET]:
         subrepoutil.submerge(repo, wctx, mctx, wctx, overwrite, labels)
 
     # forget (manifest only, just log it) (must come first)
     for f, args, msg in mresult.getactions(
         (mergestatemod.ACTION_FORGET,), sort=True
     ):
         repo.ui.debug(b" %s: %s -> f\n" % (f, msg))
         progress.increment(item=f)
 
     # re-add (manifest only, just log it)
     for f, args, msg in mresult.getactions(
         (mergestatemod.ACTION_ADD,), sort=True
     ):
         repo.ui.debug(b" %s: %s -> a\n" % (f, msg))
         progress.increment(item=f)
 
     # re-add/mark as modified (manifest only, just log it)
     for f, args, msg in mresult.getactions(
         (mergestatemod.ACTION_ADD_MODIFIED,), sort=True
     ):
         repo.ui.debug(b" %s: %s -> am\n" % (f, msg))
         progress.increment(item=f)
 
     # keep (noop, just log it)
     for a in mergestatemod.MergeAction.NO_OP_ACTIONS:
         for f, args, msg in mresult.getactions((a,), sort=True):
             repo.ui.debug(b" %s: %s -> %s\n" % (f, msg, a.__bytes__()))
             # no progress
 
     # directory rename, move local
     for f, args, msg in mresult.getactions(
         (mergestatemod.ACTION_DIR_RENAME_MOVE_LOCAL,), sort=True
     ):
         repo.ui.debug(b" %s: %s -> dm\n" % (f, msg))
         progress.increment(item=f)
         f0, flags = args
         repo.ui.note(_(b"moving %s to %s\n") % (f0, f))
         wctx[f].audit()
         wctx[f].write(wctx.filectx(f0).data(), flags)
         wctx[f0].remove()
 
     # local directory rename, get
     for f, args, msg in mresult.getactions(
         (mergestatemod.ACTION_LOCAL_DIR_RENAME_GET,), sort=True
     ):
         repo.ui.debug(b" %s: %s -> dg\n" % (f, msg))
         progress.increment(item=f)
         f0, flags = args
         repo.ui.note(_(b"getting %s to %s\n") % (f0, f))
         wctx[f].write(mctx.filectx(f0).data(), flags)
 
     # exec
     for f, args, msg in mresult.getactions(
         (mergestatemod.ACTION_EXEC,), sort=True
     ):
         repo.ui.debug(b" %s: %s -> e\n" % (f, msg))
         progress.increment(item=f)
         (flags,) = args
         wctx[f].audit()
         wctx[f].setflags(b'l' in flags, b'x' in flags)
 
     moves = []
 
     # 'cd' and 'dc' actions are treated like other merge conflicts
     mergeactions = list(
         mresult.getactions(
             [
                 mergestatemod.ACTION_CHANGED_DELETED,
                 mergestatemod.ACTION_DELETED_CHANGED,
                 mergestatemod.ACTION_MERGE,
             ],
             sort=True,
         )
     )
     for f, args, msg in mergeactions:
         f1, f2, fa, move, anc = args
         if f == b'.hgsubstate':  # merged internally
             continue
         if f1 is None:
             fcl = filemerge.absentfilectx(wctx, fa)
         else:
             repo.ui.debug(b" preserving %s for resolve of %s\n" % (f1, f))
             fcl = wctx[f1]
         if f2 is None:
             fco = filemerge.absentfilectx(mctx, fa)
         else:
             fco = mctx[f2]
         actx = repo[anc]
         if fa in actx:
             fca = actx[fa]
         else:
             # TODO: move to absentfilectx
             fca = repo.filectx(f1, fileid=nullrev)
         ms.add(fcl, fco, fca, f)
         if f1 != f and move:
             moves.append(f1)
 
     # remove renamed files after safely stored
     for f in moves:
         if wctx[f].lexists():
             repo.ui.debug(b"removing %s\n" % f)
             wctx[f].audit()
             wctx[f].remove()
 
     # these actions updates the file
     updated = mresult.len(
         (
             mergestatemod.ACTION_GET,
             mergestatemod.ACTION_EXEC,
             mergestatemod.ACTION_LOCAL_DIR_RENAME_GET,
             mergestatemod.ACTION_DIR_RENAME_MOVE_LOCAL,
         )
     )
 
     try:
         for f, args, msg in mergeactions:
             repo.ui.debug(b" %s: %s -> m\n" % (f, msg))
             ms.addcommitinfo(f, {b'merged': b'yes'})
             progress.increment(item=f)
             if f == b'.hgsubstate':  # subrepo states need updating
                 subrepoutil.submerge(
                     repo, wctx, mctx, wctx.ancestor(mctx), overwrite, labels
                 )
                 continue
             wctx[f].audit()
             ms.resolve(f, wctx)
 
     except error.InterventionRequired:
         # If the user has merge.on-failure=halt, catch the error and close the
         # merge state "properly".
         pass
     finally:
         ms.commit()
 
     unresolved = ms.unresolvedcount()
 
     msupdated, msmerged, msremoved = ms.counts()
     updated += msupdated
     merged += msmerged
     removed += msremoved
 
     extraactions = ms.actions()
 
     progress.complete()
     return (
         updateresult(updated, merged, removed, unresolved),
         getfiledata,
         extraactions,
     )
 
 
 def _advertisefsmonitor(repo, num_gets, p1node):
     # Advertise fsmonitor when its presence could be useful.
     #
     # We only advertise when performing an update from an empty working
     # directory. This typically only occurs during initial clone.
     #
     # We give users a mechanism to disable the warning in case it is
     # annoying.
     #
     # We only allow on Linux and MacOS because that's where fsmonitor is
     # considered stable.
     fsmonitorwarning = repo.ui.configbool(b'fsmonitor', b'warn_when_unused')
     fsmonitorthreshold = repo.ui.configint(
         b'fsmonitor', b'warn_update_file_count'
     )
     # avoid cycle dirstate -> sparse -> merge -> dirstate
     dirstate_rustmod = policy.importrust("dirstate")
 
     if dirstate_rustmod is not None:
         # When using rust status, fsmonitor becomes necessary at higher sizes
         fsmonitorthreshold = repo.ui.configint(
             b'fsmonitor',
             b'warn_update_file_count_rust',
         )
 
     try:
         # avoid cycle: extensions -> cmdutil -> merge
         from . import extensions
 
         extensions.find(b'fsmonitor')
         fsmonitorenabled = repo.ui.config(b'fsmonitor', b'mode') != b'off'
         # We intentionally don't look at whether fsmonitor has disabled
         # itself because a) fsmonitor may have already printed a warning
         # b) we only care about the config state here.
     except KeyError:
         fsmonitorenabled = False
 
     if (
         fsmonitorwarning
         and not fsmonitorenabled
         and p1node == repo.nullid
         and num_gets >= fsmonitorthreshold
         and pycompat.sysplatform.startswith((b'linux', b'darwin'))
     ):
         repo.ui.warn(
             _(
                 b'(warning: large working directory being used without '
                 b'fsmonitor enabled; enable fsmonitor to improve performance; '
                 b'see "hg help -e fsmonitor")\n'
             )
         )
 
 
 UPDATECHECK_ABORT = b'abort'  # handled at higher layers
 UPDATECHECK_NONE = b'none'
 UPDATECHECK_LINEAR = b'linear'
 UPDATECHECK_NO_CONFLICT = b'noconflict'
 
 
 def _update(
     repo,
     node,
     branchmerge,
     force,
     ancestor=None,
     mergeancestor=False,
     labels=None,
     matcher=None,
     mergeforce=False,
     updatedirstate=True,
     updatecheck=None,
     wc=None,
 ):
     """
     Perform a merge between the working directory and the given node
 
     node = the node to update to
     branchmerge = whether to merge between branches
     force = whether to force branch merging or file overwriting
     matcher = a matcher to filter file lists (dirstate not updated)
     mergeancestor = whether it is merging with an ancestor. If true,
       we should accept the incoming changes for any prompts that occur.
       If false, merging with an ancestor (fast-forward) is only allowed
       between different named branches. This flag is used by rebase extension
       as a temporary fix and should be avoided in general.
     labels = labels to use for local, other, and base
     mergeforce = whether the merge was run with 'merge --force' (deprecated): if
       this is True, then 'force' should be True as well.
 
     The table below shows all the behaviors of the update command given the
     -c/--check and -C/--clean or no options, whether the working directory is
     dirty, whether a revision is specified, and the relationship of the parent
     rev to the target rev (linear or not). Match from top first. The -n
     option doesn't exist on the command line, but represents the
     experimental.updatecheck=noconflict option.
 
     This logic is tested by test-update-branches.t.
 
     -c  -C  -n  -m  dirty  rev  linear  |  result
      y   y   *   *    *     *     *     |    (1)
      y   *   y   *    *     *     *     |    (1)
      y   *   *   y    *     *     *     |    (1)
      *   y   y   *    *     *     *     |    (1)
      *   y   *   y    *     *     *     |    (1)
      *   *   y   y    *     *     *     |    (1)
      *   *   *   *    *     n     n     |     x
      *   *   *   *    n     *     *     |    ok
      n   n   n   n    y     *     y     |   merge
      n   n   n   n    y     y     n     |    (2)
      n   n   n   y    y     *     *     |   merge
      n   n   y   n    y     *     *     |  merge if no conflict
      n   y   n   n    y     *     *     |  discard
      y   n   n   n    y     *     *     |    (3)
 
     x = can't happen
     * = don't-care
     1 = incompatible options (checked in commands.py)
     2 = abort: uncommitted changes (commit or update --clean to discard changes)
     3 = abort: uncommitted changes (checked in commands.py)
 
     The merge is performed inside ``wc``, a workingctx-like objects. It defaults
     to repo[None] if None is passed.
 
     Return the same tuple as applyupdates().
     """
     # Avoid cycle.
     from . import sparse
 
     # This function used to find the default destination if node was None, but
     # that's now in destutil.py.
     assert node is not None
     if not branchmerge and not force:
         # TODO: remove the default once all callers that pass branchmerge=False
         # and force=False pass a value for updatecheck. We may want to allow
         # updatecheck='abort' to better suppport some of these callers.
         if updatecheck is None:
             updatecheck = UPDATECHECK_LINEAR
         okay = (UPDATECHECK_NONE, UPDATECHECK_LINEAR, UPDATECHECK_NO_CONFLICT)
         if updatecheck not in okay:
             msg = r'Invalid updatecheck %r (can accept %r)'
             msg %= (updatecheck, okay)
             raise ValueError(msg)
     if wc is not None and wc.isinmemory():
         maybe_wlock = util.nullcontextmanager()
     else:
         maybe_wlock = repo.wlock()
     with maybe_wlock:
         if wc is None:
             wc = repo[None]
         pl = wc.parents()
         p1 = pl[0]
         p2 = repo[node]
         if ancestor is not None:
             pas = [repo[ancestor]]
         else:
             if repo.ui.configlist(b'merge', b'preferancestor') == [b'*']:
                 cahs = repo.changelog.commonancestorsheads(p1.node(), p2.node())
                 pas = [repo[anc] for anc in (sorted(cahs) or [repo.nullid])]
             else:
                 pas = [p1.ancestor(p2, warn=branchmerge)]
 
         fp1, fp2, xp1, xp2 = p1.node(), p2.node(), bytes(p1), bytes(p2)
 
         overwrite = force and not branchmerge
         ### check phase
         if not overwrite:
             if len(pl) > 1:
                 raise error.StateError(_(b"outstanding uncommitted merge"))
             ms = wc.mergestate()
             if ms.unresolvedcount():
                 msg = _(b"outstanding merge conflicts")
                 hint = _(b"use 'hg resolve' to resolve")
                 raise error.StateError(msg, hint=hint)
         if branchmerge:
             m_a = _(b"merging with a working directory ancestor has no effect")
             if pas == [p2]:
                 raise error.Abort(m_a)
             elif pas == [p1]:
                 if not mergeancestor and wc.branch() == p2.branch():
                     msg = _(b"nothing to merge")
                     hint = _(b"use 'hg update' or check 'hg heads'")
                     raise error.Abort(msg, hint=hint)
             if not force and (wc.files() or wc.deleted()):
                 msg = _(b"uncommitted changes")
                 hint = _(b"use 'hg status' to list changes")
                 raise error.StateError(msg, hint=hint)
             if not wc.isinmemory():
                 for s in sorted(wc.substate):
                     wc.sub(s).bailifchanged()
 
         elif not overwrite:
             if p1 == p2:  # no-op update
                 # call the hooks and exit early
                 repo.hook(b'preupdate', throw=True, parent1=xp2, parent2=b'')
                 repo.hook(b'update', parent1=xp2, parent2=b'', error=0)
                 return updateresult(0, 0, 0, 0)
 
             if updatecheck == UPDATECHECK_LINEAR and pas not in (
                 [p1],
                 [p2],
             ):  # nonlinear
                 dirty = wc.dirty(missing=True)
                 if dirty:
                     # Branching is a bit strange to ensure we do the minimal
                     # amount of call to obsutil.foreground.
                     foreground = obsutil.foreground(repo, [p1.node()])
                     # note: the <node> variable contains a random identifier
                     if repo[node].node() in foreground:
                         pass  # allow updating to successors
                     else:
                         msg = _(b"uncommitted changes")
                         hint = _(b"commit or update --clean to discard changes")
                         raise error.UpdateAbort(msg, hint=hint)
                 else:
                     # Allow jumping branches if clean and specific rev given
                     pass
 
         if overwrite:
             pas = [wc]
         elif not branchmerge:
             pas = [p1]
 
         # deprecated config: merge.followcopies
         followcopies = repo.ui.configbool(b'merge', b'followcopies')
         if overwrite:
             followcopies = False
         elif not pas[0]:
             followcopies = False
         if not branchmerge and not wc.dirty(missing=True):
             followcopies = False
 
         ### calculate phase
         mresult = calculateupdates(
             repo,
             wc,
             p2,
             pas,
             branchmerge,
             force,
             mergeancestor,
             followcopies,
             matcher=matcher,
             mergeforce=mergeforce,
         )
 
         if updatecheck == UPDATECHECK_NO_CONFLICT:
             if mresult.hasconflicts():
                 msg = _(b"conflicting changes")
                 hint = _(b"commit or update --clean to discard changes")
                 raise error.StateError(msg, hint=hint)
 
         # Prompt and create actions. Most of this is in the resolve phase
         # already, but we can't handle .hgsubstate in filemerge or
         # subrepoutil.submerge yet so we have to keep prompting for it.
         vals = mresult.getfile(b'.hgsubstate')
         if vals:
             f = b'.hgsubstate'
             m, args, msg = vals
             prompts = filemerge.partextras(labels)
             prompts[b'f'] = f
             if m == mergestatemod.ACTION_CHANGED_DELETED:
                 if repo.ui.promptchoice(
                     _(
                         b"local%(l)s changed %(f)s which other%(o)s deleted\n"
                         b"use (c)hanged version or (d)elete?"
                         b"$$ &Changed $$ &Delete"
                     )
                     % prompts,
                     0,
                 ):
                     mresult.addfile(
                         f,
                         mergestatemod.ACTION_REMOVE,
                         None,
                         b'prompt delete',
                     )
                 elif f in p1:
                     mresult.addfile(
                         f,
                         mergestatemod.ACTION_ADD_MODIFIED,
                         None,
                         b'prompt keep',
                     )
                 else:
                     mresult.addfile(
                         f,
                         mergestatemod.ACTION_ADD,
                         None,
                         b'prompt keep',
                     )
             elif m == mergestatemod.ACTION_DELETED_CHANGED:
                 f1, f2, fa, move, anc = args
                 flags = p2[f2].flags()
                 if (
                     repo.ui.promptchoice(
                         _(
                             b"other%(o)s changed %(f)s which local%(l)s deleted\n"
                             b"use (c)hanged version or leave (d)eleted?"
                             b"$$ &Changed $$ &Deleted"
                         )
                         % prompts,
                         0,
                     )
                     == 0
                 ):
                     mresult.addfile(
                         f,
                         mergestatemod.ACTION_GET,
                         (flags, False),
                         b'prompt recreating',
                     )
                 else:
                     mresult.removefile(f)
 
         if not util.fscasesensitive(repo.path):
             # check collision between files only in p2 for clean update
             if not branchmerge and (
                 force or not wc.dirty(missing=True, branch=False)
             ):
                 _checkcollision(repo, p2.manifest(), None)
             else:
                 _checkcollision(repo, wc.manifest(), mresult)
 
         # divergent renames
         for f, fl in sorted(mresult.diverge.items()):
             repo.ui.warn(
                 _(
                     b"note: possible conflict - %s was renamed "
                     b"multiple times to:\n"
                 )
                 % f
             )
             for nf in sorted(fl):
                 repo.ui.warn(b" %s\n" % nf)
 
         # rename and delete
         for f, fl in sorted(mresult.renamedelete.items()):
             repo.ui.warn(
                 _(
                     b"note: possible conflict - %s was deleted "
                     b"and renamed to:\n"
                 )
                 % f
             )
             for nf in sorted(fl):
                 repo.ui.warn(b" %s\n" % nf)
 
         ### apply phase
         if not branchmerge:  # just jump to the new rev
             fp1, fp2, xp1, xp2 = fp2, repo.nullid, xp2, b''
         # If we're doing a partial update, we need to skip updating
         # the dirstate.
         always = matcher is None or matcher.always()
         updatedirstate = updatedirstate and always and not wc.isinmemory()
         if updatedirstate:
             repo.hook(b'preupdate', throw=True, parent1=xp1, parent2=xp2)
             # note that we're in the middle of an update
             repo.vfs.write(b'updatestate', p2.hex())
 
         _advertisefsmonitor(
             repo, mresult.len((mergestatemod.ACTION_GET,)), p1.node()
         )
 
         wantfiledata = updatedirstate and not branchmerge
         stats, getfiledata, extraactions = applyupdates(
             repo,
             mresult,
             wc,
             p2,
             overwrite,
             wantfiledata,
             labels=labels,
         )
 
         if updatedirstate:
             if extraactions:
                 for k, acts in extraactions.items():
                     for a in acts:
                         mresult.addfile(a[0], k, *a[1:])
                     if k == mergestatemod.ACTION_GET and wantfiledata:
                         # no filedata until mergestate is updated to provide it
                         for a in acts:
                             getfiledata[a[0]] = None
 
             assert len(getfiledata) == (
                 mresult.len((mergestatemod.ACTION_GET,)) if wantfiledata else 0
             )
             with repo.dirstate.changing_parents(repo):
                 ### Filter Filedata
                 #
                 # We gathered "cache" information for the clean file while
                 # updating them: mtime, size and mode.
                 #
                 # At the time this comment is written, they are various issues
                 # with how we gather the `mode` and `mtime` information (see
                 # the comment in `batchget`).
                 #
                 # We are going to smooth one of this issue here : mtime ambiguity.
                 #
                 # i.e. even if the mtime gathered during `batchget` was
                 # correct[1] a change happening right after it could change the
                 # content while keeping the same mtime[2].
                 #
                 # When we reach the current code, the "on disk" part of the
                 # update operation is finished. We still assume that no other
                 # process raced that "on disk" part, but we want to at least
                 # prevent later file change to alter the content of the file
                 # right after the update operation. So quickly that the same
                 # mtime is record for the operation.
                 # To prevent such ambiguity to happens, we will only keep the
                 # "file data" for files with mtime that are stricly in the past,
                 # i.e. whose mtime is strictly lower than the current time.
                 #
                 # This protect us from race conditions from operation that could
                 # run right after this one, especially other Mercurial
                 # operation that could be waiting for the wlock to touch files
                 # content and the dirstate.
                 #
                 # In an ideal world, we could only get reliable information in
                 # `getfiledata` (from `getbatch`), however the current approach
                 # have been a successful compromise since many years.
                 #
                 # At the time this comment is written, not using any "cache"
                 # file data at all here would not be viable. As it would result is
                 # a very large amount of work (equivalent to the previous `hg
                 # update` during the next status after an update).
                 #
                 # [1] the current code cannot grantee that the `mtime` and
                 # `mode` are correct, but the result is "okay in practice".
                 # (see the comment in `batchget`).                #
                 #
                 # [2] using nano-second precision can greatly help here because
                 # it makes the "different write with same mtime" issue
                 # virtually vanish. However, dirstate v1 cannot store such
                 # precision and a bunch of python-runtime, operating-system and
                 # filesystem does not provide use with such precision, so we
                 # have to operate as if it wasn't available.
                 if getfiledata:
                     ambiguous_mtime = {}
                     now = timestamp.get_fs_now(repo.vfs)
                     if now is None:
                         # we can't write to the FS, so we won't actually update
                         # the dirstate content anyway, no need to put cache
                         # information.
                         getfiledata = None
                     else:
                         now_sec = now[0]
                         for f, m in getfiledata.items():
                             if m is not None and m[2][0] >= now_sec:
                                 ambiguous_mtime[f] = (m[0], m[1], None)
                         for f, m in ambiguous_mtime.items():
                             getfiledata[f] = m
 
                 repo.setparents(fp1, fp2)
                 mergestatemod.recordupdates(
                     repo, mresult.actionsdict, branchmerge, getfiledata
                 )
                 # update completed, clear state
                 util.unlink(repo.vfs.join(b'updatestate'))
 
                 if not branchmerge:
                     repo.dirstate.setbranch(
                         p2.branch(), repo.currenttransaction()
                     )
 
                 # If we're updating to a location, clean up any stale temporary includes
                 # (ex: this happens during hg rebase --abort).
                 if not branchmerge:
                     sparse.prunetemporaryincludes(repo)
 
     if updatedirstate:
         repo.hook(
             b'update', parent1=xp1, parent2=xp2, error=stats.unresolvedcount
         )
     return stats
 
 
 def merge(ctx, labels=None, force=False, wc=None):
     """Merge another topological branch into the working copy.
 
     force = whether the merge was run with 'merge --force' (deprecated)
     """
 
     return _update(
         ctx.repo(),
         ctx.rev(),
         labels=labels,
         branchmerge=True,
         force=force,
         mergeforce=force,
         wc=wc,
     )
 
 
 def update(ctx, updatecheck=None, wc=None):
     """Do a regular update to the given commit, aborting if there are conflicts.
 
     The 'updatecheck' argument can be used to control what to do in case of
     conflicts.
 
     Note: This is a new, higher-level update() than the one that used to exist
     in this module. That function is now called _update(). You can hopefully
     replace your callers to use this new update(), or clean_update(), merge(),
     revert_to(), or graft().
     """
     return _update(
         ctx.repo(),
         ctx.rev(),
         branchmerge=False,
         force=False,
         labels=[b'working copy', b'destination', b'working copy parent'],
         updatecheck=updatecheck,
         wc=wc,
     )
 
 
 def clean_update(ctx, wc=None):
     """Do a clean update to the given commit.
 
     This involves updating to the commit and discarding any changes in the
     working copy.
     """
     return _update(ctx.repo(), ctx.rev(), branchmerge=False, force=True, wc=wc)
 
 
 def revert_to(ctx, matcher=None, wc=None):
     """Revert the working copy to the given commit.
 
     The working copy will keep its current parent(s) but its content will
     be the same as in the given commit.
     """
 
     return _update(
         ctx.repo(),
         ctx.rev(),
         branchmerge=False,
         force=True,
         updatedirstate=False,
         matcher=matcher,
         wc=wc,
     )
 
 
 def graft(
     repo,
     ctx,
     base=None,
     labels=None,
     keepparent=False,
     keepconflictparent=False,
     wctx=None,
 ):
     """Do a graft-like merge.
 
     This is a merge where the merge ancestor is chosen such that one
     or more changesets are grafted onto the current changeset. In
     addition to the merge, this fixes up the dirstate to include only
     a single parent (if keepparent is False) and tries to duplicate any
     renames/copies appropriately.
 
     ctx - changeset to rebase
     base - merge base, or ctx.p1() if not specified
     labels - merge labels eg ['local', 'graft']
     keepparent - keep second parent if any
     keepconflictparent - if unresolved, keep parent used for the merge
 
     """
     # If we're grafting a descendant onto an ancestor, be sure to pass
     # mergeancestor=True to update. This does two things: 1) allows the merge if
     # the destination is the same as the parent of the ctx (so we can use graft
     # to copy commits), and 2) informs update that the incoming changes are
     # newer than the destination so it doesn't prompt about "remote changed foo
     # which local deleted".
     # We also pass mergeancestor=True when base is the same revision as p1. 2)
     # doesn't matter as there can't possibly be conflicts, but 1) is necessary.
     wctx = wctx or repo[None]
     pctx = wctx.p1()
     base = base or ctx.p1()
     mergeancestor = (
         repo.changelog.isancestor(pctx.node(), ctx.node())
         or pctx.rev() == base.rev()
     )
 
     stats = _update(
         repo,
         ctx.node(),
         True,
         True,
         base.node(),
         mergeancestor=mergeancestor,
         labels=labels,
         wc=wctx,
     )
 
     if keepconflictparent and stats.unresolvedcount:
         pother = ctx.node()
     else:
         pother = repo.nullid
         parents = ctx.parents()
         if keepparent and len(parents) == 2 and base in parents:
             parents.remove(base)
             pother = parents[0].node()
     # Never set both parents equal to each other
     if pother == pctx.node():
         pother = repo.nullid
 
     if wctx.isinmemory():
         wctx.setparents(pctx.node(), pother)
         # fix up dirstate for copies and renames
         copies.graftcopies(wctx, ctx, base)
     else:
         with repo.dirstate.changing_parents(repo):
             repo.setparents(pctx.node(), pother)
             repo.dirstate.write(repo.currenttransaction())
             # fix up dirstate for copies and renames
             copies.graftcopies(wctx, ctx, base)
     return stats
 
 
 def back_out(ctx, parent=None, wc=None):
     if parent is None:
         if ctx.p2() is not None:
             msg = b"must specify parent of merge commit to back out"
             raise error.ProgrammingError(msg)
         parent = ctx.p1()
     return _update(
         ctx.repo(),
         parent,
         branchmerge=True,
         force=True,
         ancestor=ctx.node(),
         mergeancestor=False,
     )
 
 
 def purge(
     repo,
     matcher,
     unknown=True,
     ignored=False,
     removeemptydirs=True,
     removefiles=True,
     abortonerror=False,
     noop=False,
     confirm=False,
 ):
     """Purge the working directory of untracked files.
 
     ``matcher`` is a matcher configured to scan the working directory -
     potentially a subset.
 
     ``unknown`` controls whether unknown files should be purged.
 
     ``ignored`` controls whether ignored files should be purged.
 
     ``removeemptydirs`` controls whether empty directories should be removed.
 
     ``removefiles`` controls whether files are removed.
 
     ``abortonerror`` causes an exception to be raised if an error occurs
     deleting a file or directory.
 
     ``noop`` controls whether to actually remove files. If not defined, actions
     will be taken.
 
     ``confirm`` ask confirmation before actually removing anything.
 
     Returns an iterable of relative paths in the working directory that were
     or would be removed.
     """
 
     def remove(removefn, path):
         try:
             removefn(path)
         except OSError:
             m = _(b'%s cannot be removed') % path
             if abortonerror:
                 raise error.Abort(m)
             else:
                 repo.ui.warn(_(b'warning: %s\n') % m)
 
     # There's no API to copy a matcher. So mutate the passed matcher and
     # restore it when we're done.
     oldtraversedir = matcher.traversedir
 
     res = []
 
     try:
         if removeemptydirs:
             directories = []
             matcher.traversedir = directories.append
 
         status = repo.status(match=matcher, ignored=ignored, unknown=unknown)
 
         if confirm:
             msg = None
             nb_ignored = len(status.ignored)
             nb_unknown = len(status.unknown)
             if nb_unknown and nb_ignored:
                 msg = _(b"permanently delete %d unknown and %d ignored files?")
                 msg %= (nb_unknown, nb_ignored)
             elif nb_unknown:
                 msg = _(b"permanently delete %d unknown files?")
                 msg %= nb_unknown
             elif nb_ignored:
                 msg = _(b"permanently delete %d ignored files?")
                 msg %= nb_ignored
             elif removeemptydirs:
                 dir_count = 0
                 for f in directories:
                     if matcher(f) and not repo.wvfs.listdir(f):
                         dir_count += 1
                 if dir_count:
                     msg = _(
                         b"permanently delete at least %d empty directories?"
                     )
                     msg %= dir_count
             if msg is None:
                 return res
             else:
                 msg += b" (yN)$$ &Yes $$ &No"
                 if repo.ui.promptchoice(msg, default=1) == 1:
                     raise error.CanceledError(_(b'removal cancelled'))
 
         if removefiles:
             for f in sorted(status.unknown + status.ignored):
                 if not noop:
                     repo.ui.note(_(b'removing file %s\n') % f)
                     remove(repo.wvfs.unlink, f)
                 res.append(f)
 
         if removeemptydirs:
             for f in sorted(directories, reverse=True):
                 if matcher(f) and not repo.wvfs.listdir(f):
                     if not noop:
                         repo.ui.note(_(b'removing directory %s\n') % f)
                         remove(repo.wvfs.rmdir, f)
                     res.append(f)
 
         return res
 
     finally:
         matcher.traversedir = oldtraversedir

mercurial/metadata.py

@@ -1,905 +1,905
 # coding: utf-8
 # metadata.py -- code related to various metadata computation and access.
 #
 # Copyright 2019 Google, Inc <[e-mail]>
 # Copyright 2020 Pierre-Yves David <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 import multiprocessing
 import struct
 
 from .node import nullrev
 from . import (
     error,
     util,
 )
 
 from .revlogutils import (
     flagutil as sidedataflag,
     sidedata as sidedatamod,
 )
 
 
 class ChangingFiles:
     """A class recording the changes made to files by a changeset
 
     Actions performed on files are gathered into 3 sets:
 
     - added:   files actively added in the changeset.
     - merged:  files whose history got merged
     - removed: files removed in the revision
     - salvaged: files that might have been deleted by a merge but were not
     - touched: files affected by the merge
 
     and copies information is held by 2 mappings
 
     - copied_from_p1: {"<new-name>": "<source-name-in-p1>"} mapping for copies
     - copied_from_p2: {"<new-name>": "<source-name-in-p2>"} mapping for copies
 
     See their inline help for details.
     """
 
     def __init__(
         self,
         touched=None,
         added=None,
         removed=None,
         merged=None,
         salvaged=None,
         p1_copies=None,
         p2_copies=None,
     ):
         self._added = set(() if added is None else added)
         self._merged = set(() if merged is None else merged)
         self._removed = set(() if removed is None else removed)
         self._touched = set(() if touched is None else touched)
         self._salvaged = set(() if salvaged is None else salvaged)
         self._touched.update(self._added)
         self._touched.update(self._merged)
         self._touched.update(self._removed)
         self._p1_copies = dict(() if p1_copies is None else p1_copies)
         self._p2_copies = dict(() if p2_copies is None else p2_copies)
 
     def __eq__(self, other):
         return (
             self.added == other.added
             and self.merged == other.merged
             and self.removed == other.removed
             and self.salvaged == other.salvaged
             and self.touched == other.touched
             and self.copied_from_p1 == other.copied_from_p1
             and self.copied_from_p2 == other.copied_from_p2
         )
 
     @property
     def has_copies_info(self):
         return bool(
             self.removed
             or self.merged
             or self.salvaged
             or self.copied_from_p1
             or self.copied_from_p2
         )
 
     @util.propertycache
     def added(self):
         """files actively added in the changeset
 
         Any file present in that revision that was absent in all the changeset's
         parents.
 
         In case of merge, this means a file absent in one of the parents but
         existing in the other will *not* be contained in this set. (They were
         added by an ancestor)
         """
         return frozenset(self._added)
 
     def mark_added(self, filename):
         if 'added' in vars(self):
             del self.added
         self._added.add(filename)
         self.mark_touched(filename)
 
     def update_added(self, filenames):
         for f in filenames:
             self.mark_added(f)
 
     @util.propertycache
     def merged(self):
         """files actively merged during a merge
 
         Any modified files which had modification on both size that needed merging.
 
         In this case a new filenode was created and it has two parents.
         """
         return frozenset(self._merged)
 
     def mark_merged(self, filename):
         if 'merged' in vars(self):
             del self.merged
         self._merged.add(filename)
         self.mark_touched(filename)
 
     def update_merged(self, filenames):
         for f in filenames:
             self.mark_merged(f)
 
     @util.propertycache
     def removed(self):
         """files actively removed by the changeset
 
         In case of merge this will only contain the set of files removing "new"
         content. For any file absent in the current changeset:
 
         a) If the file exists in both parents, it is clearly "actively" removed
         by this changeset.
 
         b) If a file exists in only one parent and in none of the common
         ancestors, then the file was newly added in one of the merged branches
         and then got "actively" removed.
 
         c) If a file exists in only one parent and at least one of the common
         ancestors using the same filenode, then the file was unchanged on one
         side and deleted on the other side. The merge "passively" propagated
         that deletion, but didn't "actively" remove the file. In this case the
         file is *not* included in the `removed` set.
 
         d) If a file exists in only one parent and at least one of the common
         ancestors using a different filenode, then the file was changed on one
         side and removed on the other side. The merge process "actively"
         decided to drop the new change and delete the file. Unlike in the
         previous case, (c), the file included in the `removed` set.
 
         Summary table for merge:
 
         case | exists in parents | exists in gca || removed
          (a) |       both        |     *         ||   yes
          (b) |       one         |     none      ||   yes
          (c) |       one         | same filenode ||   no
          (d) |       one         |  new filenode ||   yes
         """
         return frozenset(self._removed)
 
     def mark_removed(self, filename):
         if 'removed' in vars(self):
             del self.removed
         self._removed.add(filename)
         self.mark_touched(filename)
 
     def update_removed(self, filenames):
         for f in filenames:
             self.mark_removed(f)
 
     @util.propertycache
     def salvaged(self):
         """files that might have been deleted by a merge, but still exists.
 
         During a merge, the manifest merging might select some files for
         removal, or for a removed/changed conflict. If at commit time the file
         still exists, its removal was "reverted" and the file is "salvaged"
         """
         return frozenset(self._salvaged)
 
     def mark_salvaged(self, filename):
         if "salvaged" in vars(self):
             del self.salvaged
         self._salvaged.add(filename)
         self.mark_touched(filename)
 
     def update_salvaged(self, filenames):
         for f in filenames:
             self.mark_salvaged(f)
 
     @util.propertycache
     def touched(self):
         """files either actively modified, added or removed"""
         return frozenset(self._touched)
 
     def mark_touched(self, filename):
         if 'touched' in vars(self):
             del self.touched
         self._touched.add(filename)
 
     def update_touched(self, filenames):
         for f in filenames:
             self.mark_touched(f)
 
     @util.propertycache
     def copied_from_p1(self):
         return self._p1_copies.copy()
 
     def mark_copied_from_p1(self, source, dest):
         if 'copied_from_p1' in vars(self):
             del self.copied_from_p1
         self._p1_copies[dest] = source
 
     def update_copies_from_p1(self, copies):
         for dest, source in copies.items():
             self.mark_copied_from_p1(source, dest)
 
     @util.propertycache
     def copied_from_p2(self):
         return self._p2_copies.copy()
 
     def mark_copied_from_p2(self, source, dest):
         if 'copied_from_p2' in vars(self):
             del self.copied_from_p2
         self._p2_copies[dest] = source
 
     def update_copies_from_p2(self, copies):
         for dest, source in copies.items():
             self.mark_copied_from_p2(source, dest)
 
 
 def compute_all_files_changes(ctx):
     """compute the files changed by a revision"""
     p1 = ctx.p1()
     p2 = ctx.p2()
     if p1.rev() == nullrev and p2.rev() == nullrev:
         return _process_root(ctx)
     elif p1.rev() != nullrev and p2.rev() == nullrev:
         return _process_linear(p1, ctx)
     elif p1.rev() == nullrev and p2.rev() != nullrev:
         # In the wild, one can encounter changeset where p1 is null but p2 is not
-        return _process_linear(p1, ctx, parent=2)
+        return _process_linear(p2, ctx, parent=2)
     elif p1.rev() == p2.rev():
         # In the wild, one can encounter such "non-merge"
         return _process_linear(p1, ctx)
     else:
         return _process_merge(p1, p2, ctx)
 
 
 def _process_root(ctx):
     """compute the appropriate changed files for a changeset with no parents"""
     # Simple, there was nothing before it, so everything is added.
     md = ChangingFiles()
     manifest = ctx.manifest()
     for filename in manifest:
         md.mark_added(filename)
     return md
 
 
 def _process_linear(parent_ctx, children_ctx, parent=1):
     """compute the appropriate changed files for a changeset with a single parent"""
     md = ChangingFiles()
     parent_manifest = parent_ctx.manifest()
     children_manifest = children_ctx.manifest()
 
     copies_candidate = []
 
     for filename, d in parent_manifest.diff(children_manifest).items():
         if d[1][0] is None:
             # no filenode for the "new" value, file is absent
             md.mark_removed(filename)
         else:
             copies_candidate.append(filename)
             if d[0][0] is None:
                 # not filenode for the "old" value file was absent
                 md.mark_added(filename)
             else:
                 # filenode for both "old" and "new"
                 md.mark_touched(filename)
 
     if parent == 1:
         copied = md.mark_copied_from_p1
     elif parent == 2:
         copied = md.mark_copied_from_p2
     else:
         assert False, "bad parent value %d" % parent
 
     for filename in copies_candidate:
         copy_info = children_ctx[filename].renamed()
         if copy_info:
             source, srcnode = copy_info
             copied(source, filename)
 
     return md
 
 
 def _process_merge(p1_ctx, p2_ctx, ctx):
     """compute the appropriate changed files for a changeset with two parents
 
     This is a more advance case. The information we need to record is summarise
     in the following table:
 
     ┌──────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
     │ diff ╲  diff │       ø      │ (Some, None) │ (None, Some) │ (Some, Some) │
     │  p2   ╲  p1  │              │              │              │              │
     ├──────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
     │              │              │🄱  No Changes │🄳  No Changes │              │
     │  ø           │🄰  No Changes │      OR      │     OR       │🄵  No Changes │
     │              │              │🄲  Deleted[1] │🄴  Salvaged[2]│     [3]      │
     ├──────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
     │              │🄶  No Changes │              │              │              │
     │ (Some, None) │      OR      │🄻  Deleted    │       ø      │      ø       │
     │              │🄷  Deleted[1] │              │              │              │
     ├──────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
     │              │🄸  No Changes │              │              │   🄽 Touched  │
     │ (None, Some) │     OR       │      ø       │🄼   Added     │OR 🅀 Salvaged │
     │              │🄹  Salvaged[2]│              │   (copied?)  │   (copied?)  │
     ├──────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
     │              │              │              │   🄾 Touched  │   🄿 Merged   │
     │ (Some, Some) │🄺  No Changes │      ø       │OR 🅁 Salvaged │OR 🅂 Touched  │
     │              │     [3]      │              │   (copied?)  │   (copied?)  │
     └──────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 
     Special case [1]:
 
       The situation is:
         - parent-A:     file exists,
         - parent-B:     no file,
         - working-copy: no file.
 
       Detecting a "deletion" will depend on the presence of actual change on
       the "parent-A" branch:
 
       Subcase 🄱 or 🄶 : if the state of the file in "parent-A" is unchanged
       compared to the merge ancestors, then parent-A branch left the file
       untouched while parent-B deleted it. We simply apply the change from
       "parent-B" branch the file was automatically dropped.
       The result is:
           - file is not recorded as touched by the merge.
 
       Subcase 🄲 or 🄷 : otherwise, the change from parent-A branch were explicitly dropped and
       the file was "deleted again". From a user perspective, the message
       about "locally changed" while "remotely deleted" (or the other way
       around) was issued and the user chose to deleted the file.
       The result:
           - file is recorded as touched by the merge.
 
 
     Special case [2]:
 
       The situation is:
         - parent-A:     no file,
         - parent-B:     file,
         - working-copy: file (same content as parent-B).
 
       There are three subcases depending on the ancestors contents:
 
       - A) the file is missing in all ancestors,
       - B) at least one ancestor has the file with filenode ≠ from parent-B,
       - C) all ancestors use the same filenode as parent-B,
 
       Subcase (A) is the simpler, nothing happend on parent-A side while
       parent-B added it.
 
         The result:
             - the file is not marked as touched by the merge.
 
       Subcase (B) is the counter part of "Special case [1]", the file was
         modified on parent-B side, while parent-A side deleted it. However this
         time, the conflict was solved by keeping the file (and its
         modification). We consider the file as "salvaged".
 
         The result:
             - the file is marked as "salvaged" by the merge.
 
       Subcase (C) is subtle variation of the case above. In this case, the
         file in unchanged on the parent-B side and actively removed on the
         parent-A side. So the merge machinery correctly decide it should be
         removed. However, the file was explicitly restored to its parent-B
         content before the merge was commited. The file is be marked
         as salvaged too. From the merge result perspective, this is similar to
         Subcase (B), however from the merge resolution perspective they differ
         since in (C), there was some conflict not obvious solution to the
         merge (That got reversed)
 
     Special case [3]:
 
       The situation is:
         - parent-A:     file,
         - parent-B:     file (different filenode as parent-A),
         - working-copy: file (same filenode as parent-B).
 
       This case is in theory much simple, for this to happens, this mean the
       filenode in parent-A is purely replacing the one in parent-B (either a
       descendant, or a full new file history, see changeset). So the merge
       introduce no changes, and the file is not affected by the merge...
 
       However, in the wild it is possible to find commit with the above is not
       True. For example repository have some commit where the *new* node is an
       ancestor of the node in parent-A, or where parent-A and parent-B are two
       branches of the same file history, yet not merge-filenode were created
       (while the "merge" should have led to a "modification").
 
       Detecting such cases (and not recording the file as modified) would be a
       nice bonus. However do not any of this yet.
     """
 
     repo = ctx.repo()
     md = ChangingFiles()
 
     m = ctx.manifest()
     p1m = p1_ctx.manifest()
     p2m = p2_ctx.manifest()
     diff_p1 = p1m.diff(m)
     diff_p2 = p2m.diff(m)
 
     cahs = ctx.repo().changelog.commonancestorsheads(
         p1_ctx.node(), p2_ctx.node()
     )
     if not cahs:
         cahs = [nullrev]
     mas = [ctx.repo()[r].manifest() for r in cahs]
 
     copy_candidates = []
 
     # Dealing with case 🄰 happens automatically.  Since there are no entry in
     # d1 nor d2, we won't iterate on it ever.
 
     # Iteration over d1 content will deal with all cases, but the one in the
     # first column of the table.
     for filename, d1 in diff_p1.items():
         d2 = diff_p2.pop(filename, None)
 
         if d2 is None:
             # this deal with the first line of the table.
             _process_other_unchanged(md, mas, filename, d1)
         else:
             if d1[0][0] is None and d2[0][0] is None:
                 # case 🄼 — both deleted the file.
                 md.mark_added(filename)
                 copy_candidates.append(filename)
             elif d1[1][0] is None and d2[1][0] is None:
                 # case 🄻 — both deleted the file.
                 md.mark_removed(filename)
             elif d1[1][0] is not None and d2[1][0] is not None:
                 if d1[0][0] is None or d2[0][0] is None:
                     if any(_find(ma, filename) is not None for ma in mas):
                         # case 🅀 or 🅁
                         md.mark_salvaged(filename)
                     else:
                         # case 🄽 🄾 : touched
                         md.mark_touched(filename)
                 else:
                     fctx = repo.filectx(filename, fileid=d1[1][0])
                     if fctx.p2().rev() == nullrev:
                         # case 🅂
                         # lets assume we can trust the file history. If the
                         # filenode is not a merge, the file was not merged.
                         md.mark_touched(filename)
                     else:
                         # case 🄿
                         md.mark_merged(filename)
                 copy_candidates.append(filename)
             else:
                 # Impossible case, the post-merge file status cannot be None on
                 # one side and Something on the other side.
                 assert False, "unreachable"
 
     # Iteration over remaining d2 content deal with the first column of the
     # table.
     for filename, d2 in diff_p2.items():
         _process_other_unchanged(md, mas, filename, d2)
 
     for filename in copy_candidates:
         copy_info = ctx[filename].renamed()
         if copy_info:
             source, srcnode = copy_info
             if source in p1_ctx and p1_ctx[source].filenode() == srcnode:
                 md.mark_copied_from_p1(source, filename)
             elif source in p2_ctx and p2_ctx[source].filenode() == srcnode:
                 md.mark_copied_from_p2(source, filename)
     return md
 
 
 def _find(manifest, filename):
     """return the associate filenode or None"""
     if filename not in manifest:
         return None
     return manifest.find(filename)[0]
 
 
 def _process_other_unchanged(md, mas, filename, diff):
     source_node = diff[0][0]
     target_node = diff[1][0]
 
     if source_node is not None and target_node is None:
         if any(not _find(ma, filename) == source_node for ma in mas):
             # case 🄲 of 🄷
             md.mark_removed(filename)
         # else, we have case 🄱 or 🄶 : no change need to be recorded
     elif source_node is None and target_node is not None:
         if any(_find(ma, filename) is not None for ma in mas):
             # case 🄴 or 🄹
             md.mark_salvaged(filename)
         # else, we have case 🄳 or 🄸 : simple merge without intervention
     elif source_node is not None and target_node is not None:
         # case 🄵  or 🄺 : simple merge without intervention
         #
         # In buggy case where source_node is not an ancestors of target_node.
         # There should have a been a new filenode created, recording this as
         # "modified". We do not deal with them yet.
         pass
     else:
         # An impossible case, the diff algorithm should not return entry if the
         # file is missing on both side.
         assert False, "unreachable"
 
 
 def _missing_from_all_ancestors(mas, filename):
     return all(_find(ma, filename) is None for ma in mas)
 
 
 def computechangesetfilesadded(ctx):
     """return the list of files added in a changeset"""
     added = []
     for f in ctx.files():
         if not any(f in p for p in ctx.parents()):
             added.append(f)
     return added
 
 
 def get_removal_filter(ctx, x=None):
     """return a function to detect files "wrongly" detected as `removed`
 
     When a file is removed relative to p1 in a merge, this
     function determines whether the absence is due to a
     deletion from a parent, or whether the merge commit
     itself deletes the file. We decide this by doing a
     simplified three way merge of the manifest entry for
     the file. There are two ways we decide the merge
     itself didn't delete a file:
     - neither parent (nor the merge) contain the file
     - exactly one parent contains the file, and that
       parent has the same filelog entry as the merge
       ancestor (or all of them if there two). In other
       words, that parent left the file unchanged while the
       other one deleted it.
     One way to think about this is that deleting a file is
     similar to emptying it, so the list of changed files
     should be similar either way. The computation
     described above is not done directly in _filecommit
     when creating the list of changed files, however
     it does something very similar by comparing filelog
     nodes.
     """
 
     if x is not None:
         p1, p2, m1, m2 = x
     else:
         p1 = ctx.p1()
         p2 = ctx.p2()
         m1 = p1.manifest()
         m2 = p2.manifest()
 
     @util.cachefunc
     def mas():
         p1n = p1.node()
         p2n = p2.node()
         cahs = ctx.repo().changelog.commonancestorsheads(p1n, p2n)
         if not cahs:
             cahs = [nullrev]
         return [ctx.repo()[r].manifest() for r in cahs]
 
     def deletionfromparent(f):
         if f in m1:
             return f not in m2 and all(
                 f in ma and ma.find(f) == m1.find(f) for ma in mas()
             )
         elif f in m2:
             return all(f in ma and ma.find(f) == m2.find(f) for ma in mas())
         else:
             return True
 
     return deletionfromparent
 
 
 def computechangesetfilesremoved(ctx):
     """return the list of files removed in a changeset"""
     removed = []
     for f in ctx.files():
         if f not in ctx:
             removed.append(f)
     if removed:
         rf = get_removal_filter(ctx)
         removed = [r for r in removed if not rf(r)]
     return removed
 
 
 def computechangesetfilesmerged(ctx):
     """return the list of files merged in a changeset"""
     merged = []
     if len(ctx.parents()) < 2:
         return merged
     for f in ctx.files():
         if f in ctx:
             fctx = ctx[f]
             parents = fctx._filelog.parents(fctx._filenode)
             if parents[1] != ctx.repo().nullid:
                 merged.append(f)
     return merged
 
 
 def computechangesetcopies(ctx):
     """return the copies data for a changeset
 
     The copies data are returned as a pair of dictionnary (p1copies, p2copies).
 
     Each dictionnary are in the form: `{newname: oldname}`
     """
     p1copies = {}
     p2copies = {}
     p1 = ctx.p1()
     p2 = ctx.p2()
     narrowmatch = ctx._repo.narrowmatch()
     for dst in ctx.files():
         if not narrowmatch(dst) or dst not in ctx:
             continue
         copied = ctx[dst].renamed()
         if not copied:
             continue
         src, srcnode = copied
         if src in p1 and p1[src].filenode() == srcnode:
             p1copies[dst] = src
         elif src in p2 and p2[src].filenode() == srcnode:
             p2copies[dst] = src
     return p1copies, p2copies
 
 
 def encodecopies(files, copies):
     items = []
     for i, dst in enumerate(files):
         if dst in copies:
             items.append(b'%d\0%s' % (i, copies[dst]))
     if len(items) != len(copies):
         raise error.ProgrammingError(
             b'some copy targets missing from file list'
         )
     return b"\n".join(items)
 
 
 def decodecopies(files, data):
     try:
         copies = {}
         if not data:
             return copies
         for l in data.split(b'\n'):
             strindex, src = l.split(b'\0')
             i = int(strindex)
             dst = files[i]
             copies[dst] = src
         return copies
     except (ValueError, IndexError):
         # Perhaps someone had chosen the same key name (e.g. "p1copies") and
         # used different syntax for the value.
         return None
 
 
 def encodefileindices(files, subset):
     subset = set(subset)
     indices = []
     for i, f in enumerate(files):
         if f in subset:
             indices.append(b'%d' % i)
     return b'\n'.join(indices)
 
 
 def decodefileindices(files, data):
     try:
         subset = []
         if not data:
             return subset
         for strindex in data.split(b'\n'):
             i = int(strindex)
             if i < 0 or i >= len(files):
                 return None
             subset.append(files[i])
         return subset
     except (ValueError, IndexError):
         # Perhaps someone had chosen the same key name (e.g. "added") and
         # used different syntax for the value.
         return None
 
 
 # see mercurial/helptext/internals/revlogs.txt for details about the format
 
 ACTION_MASK = int("111" "00", 2)
 # note: untouched file used as copy source will as `000` for this mask.
 ADDED_FLAG = int("001" "00", 2)
 MERGED_FLAG = int("010" "00", 2)
 REMOVED_FLAG = int("011" "00", 2)
 SALVAGED_FLAG = int("100" "00", 2)
 TOUCHED_FLAG = int("101" "00", 2)
 
 COPIED_MASK = int("11", 2)
 COPIED_FROM_P1_FLAG = int("10", 2)
 COPIED_FROM_P2_FLAG = int("11", 2)
 
 # structure is <flag><filename-end><copy-source>
 INDEX_HEADER = struct.Struct(">L")
 INDEX_ENTRY = struct.Struct(">bLL")
 
 
 def encode_files_sidedata(files):
     all_files = set(files.touched)
     all_files.update(files.copied_from_p1.values())
     all_files.update(files.copied_from_p2.values())
     all_files = sorted(all_files)
     file_idx = {f: i for (i, f) in enumerate(all_files)}
     file_idx[None] = 0
 
     chunks = [INDEX_HEADER.pack(len(all_files))]
 
     filename_length = 0
     for f in all_files:
         filename_size = len(f)
         filename_length += filename_size
         flag = 0
         if f in files.added:
             flag |= ADDED_FLAG
         elif f in files.merged:
             flag |= MERGED_FLAG
         elif f in files.removed:
             flag |= REMOVED_FLAG
         elif f in files.salvaged:
             flag |= SALVAGED_FLAG
         elif f in files.touched:
             flag |= TOUCHED_FLAG
 
         copy = None
         if f in files.copied_from_p1:
             flag |= COPIED_FROM_P1_FLAG
             copy = files.copied_from_p1.get(f)
         elif f in files.copied_from_p2:
             copy = files.copied_from_p2.get(f)
             flag |= COPIED_FROM_P2_FLAG
         copy_idx = file_idx[copy]
         chunks.append(INDEX_ENTRY.pack(flag, filename_length, copy_idx))
     chunks.extend(all_files)
     return {sidedatamod.SD_FILES: b''.join(chunks)}
 
 
 def decode_files_sidedata(sidedata):
     md = ChangingFiles()
     raw = sidedata.get(sidedatamod.SD_FILES)
 
     if raw is None:
         return md
 
     copies = []
     all_files = []
 
     assert len(raw) >= INDEX_HEADER.size
     total_files = INDEX_HEADER.unpack_from(raw, 0)[0]
 
     offset = INDEX_HEADER.size
     file_offset_base = offset + (INDEX_ENTRY.size * total_files)
     file_offset_last = file_offset_base
 
     assert len(raw) >= file_offset_base
 
     for idx in range(total_files):
         flag, file_end, copy_idx = INDEX_ENTRY.unpack_from(raw, offset)
         file_end += file_offset_base
         filename = raw[file_offset_last:file_end]
         filesize = file_end - file_offset_last
         assert len(filename) == filesize
         offset += INDEX_ENTRY.size
         file_offset_last = file_end
         all_files.append(filename)
         if flag & ACTION_MASK == ADDED_FLAG:
             md.mark_added(filename)
         elif flag & ACTION_MASK == MERGED_FLAG:
             md.mark_merged(filename)
         elif flag & ACTION_MASK == REMOVED_FLAG:
             md.mark_removed(filename)
         elif flag & ACTION_MASK == SALVAGED_FLAG:
             md.mark_salvaged(filename)
         elif flag & ACTION_MASK == TOUCHED_FLAG:
             md.mark_touched(filename)
 
         copied = None
         if flag & COPIED_MASK == COPIED_FROM_P1_FLAG:
             copied = md.mark_copied_from_p1
         elif flag & COPIED_MASK == COPIED_FROM_P2_FLAG:
             copied = md.mark_copied_from_p2
 
         if copied is not None:
             copies.append((copied, filename, copy_idx))
 
     for copied, filename, copy_idx in copies:
         copied(all_files[copy_idx], filename)
 
     return md
 
 
 def _getsidedata(srcrepo, rev):
     ctx = srcrepo[rev]
     files = compute_all_files_changes(ctx)
     return encode_files_sidedata(files), files.has_copies_info
 
 
 def copies_sidedata_computer(repo, revlog, rev, existing_sidedata):
     sidedata, has_copies_info = _getsidedata(repo, rev)
     flags_to_add = sidedataflag.REVIDX_HASCOPIESINFO if has_copies_info else 0
     return sidedata, (flags_to_add, 0)
 
 
 def _sidedata_worker(srcrepo, revs_queue, sidedata_queue, tokens):
     """The function used by worker precomputing sidedata
 
     It read an input queue containing revision numbers
     It write in an output queue containing (rev, <sidedata-map>)
 
     The `None` input value is used as a stop signal.
 
     The `tokens` semaphore is user to avoid having too many unprocessed
     entries. The workers needs to acquire one token before fetching a task.
     They will be released by the consumer of the produced data.
     """
     tokens.acquire()
     rev = revs_queue.get()
     while rev is not None:
         data = _getsidedata(srcrepo, rev)
         sidedata_queue.put((rev, data))
         tokens.acquire()
         rev = revs_queue.get()
     # processing of `None` is completed, release the token.
     tokens.release()
 
 
 BUFF_PER_WORKER = 50
 
 
 def _get_worker_sidedata_adder(srcrepo, destrepo):
     """The parallel version of the sidedata computation
 
     This code spawn a pool of worker that precompute a buffer of sidedata
     before we actually need them"""
     # avoid circular import copies -> scmutil -> worker -> copies
     from . import worker
 
     nbworkers = worker._numworkers(srcrepo.ui)
 
     tokens = multiprocessing.BoundedSemaphore(nbworkers * BUFF_PER_WORKER)
     revsq = multiprocessing.Queue()
     sidedataq = multiprocessing.Queue()
 
     assert srcrepo.filtername is None
     # queue all tasks beforehand, revision numbers are small and it make
     # synchronisation simpler
     #
     # Since the computation for each node can be quite expensive, the overhead
     # of using a single queue is not revelant. In practice, most computation
     # are fast but some are very expensive and dominate all the other smaller
     # cost.
     for r in srcrepo.changelog.revs():
         revsq.put(r)
     # queue the "no more tasks" markers
     for i in range(nbworkers):
         revsq.put(None)
 
     allworkers = []
     for i in range(nbworkers):
         args = (srcrepo, revsq, sidedataq, tokens)
         w = multiprocessing.Process(target=_sidedata_worker, args=args)
         allworkers.append(w)
         w.start()
 
     # dictionnary to store results for revision higher than we one we are
     # looking for. For example, if we need the sidedatamap for 42, and 43 is
     # received, when shelve 43 for later use.
     staging = {}
 
     def sidedata_companion(repo, revlog, rev, old_sidedata):
         # Is the data previously shelved ?
         data = staging.pop(rev, None)
         if data is None:
             # look at the queued result until we find the one we are lookig
             # for (shelve the other ones)
             r, data = sidedataq.get()
             while r != rev:
                 staging[r] = data
                 r, data = sidedataq.get()
         tokens.release()
         sidedata, has_copies_info = data
         new_flag = 0
         if has_copies_info:
             new_flag = sidedataflag.REVIDX_HASCOPIESINFO
         return sidedata, (new_flag, 0)
 
     return sidedata_companion

mercurial/patch.py

@@ -1,3255 +1,3255
 # patch.py - patch file parsing routines
 #
 # Copyright 2006 Brendan Cully <[e-mail]>
 # Copyright 2007 Chris Mason <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import collections
 import contextlib
 import copy
 import os
 import re
 import shutil
 import zlib
 
 from .i18n import _
 from .node import (
     hex,
     sha1nodeconstants,
     short,
 )
 from .pycompat import open
 from . import (
     copies,
     diffhelper,
     diffutil,
     encoding,
     error,
     mail,
     mdiff,
     pathutil,
     pycompat,
     scmutil,
     similar,
     util,
     vfs as vfsmod,
 )
 from .utils import (
     dateutil,
     hashutil,
     procutil,
     stringutil,
 )
 
 stringio = util.stringio
 
 gitre = re.compile(br'diff --git a/(.*) b/(.*)')
 tabsplitter = re.compile(br'(\t+|[^\t]+)')
 wordsplitter = re.compile(
     br'(\t+| +|[a-zA-Z0-9_\x80-\xff]+|[^ \ta-zA-Z0-9_\x80-\xff])'
 )
 
 PatchError = error.PatchError
 PatchParseError = error.PatchParseError
 PatchApplicationError = error.PatchApplicationError
 
 # public functions
 
 
 def split(stream):
     '''return an iterator of individual patches from a stream'''
 
     def isheader(line, inheader):
         if inheader and line.startswith((b' ', b'\t')):
             # continuation
             return True
         if line.startswith((b' ', b'-', b'+')):
             # diff line - don't check for header pattern in there
             return False
         l = line.split(b': ', 1)
         return len(l) == 2 and b' ' not in l[0]
 
     def chunk(lines):
         return stringio(b''.join(lines))
 
     def hgsplit(stream, cur):
         inheader = True
 
         for line in stream:
             if not line.strip():
                 inheader = False
             if not inheader and line.startswith(b'# HG changeset patch'):
                 yield chunk(cur)
                 cur = []
                 inheader = True
 
             cur.append(line)
 
         if cur:
             yield chunk(cur)
 
     def mboxsplit(stream, cur):
         for line in stream:
             if line.startswith(b'From '):
                 for c in split(chunk(cur[1:])):
                     yield c
                 cur = []
 
             cur.append(line)
 
         if cur:
             for c in split(chunk(cur[1:])):
                 yield c
 
     def mimesplit(stream, cur):
         def msgfp(m):
             fp = stringio()
             # pytype: disable=wrong-arg-types
             g = mail.Generator(fp, mangle_from_=False)
             # pytype: enable=wrong-arg-types
             g.flatten(m)
             fp.seek(0)
             return fp
 
         for line in stream:
             cur.append(line)
         c = chunk(cur)
 
         m = mail.parse(c)
         if not m.is_multipart():
             yield msgfp(m)
         else:
-            ok_types = (b'text/plain', b'text/x-diff', b'text/x-patch')
+            ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
             for part in m.walk():
                 ct = part.get_content_type()
                 if ct not in ok_types:
                     continue
                 yield msgfp(part)
 
     def headersplit(stream, cur):
         inheader = False
 
         for line in stream:
             if not inheader and isheader(line, inheader):
                 yield chunk(cur)
                 cur = []
                 inheader = True
             if inheader and not isheader(line, inheader):
                 inheader = False
 
             cur.append(line)
 
         if cur:
             yield chunk(cur)
 
     def remainder(cur):
         yield chunk(cur)
 
     class fiter:
         def __init__(self, fp):
             self.fp = fp
 
         def __iter__(self):
             return self
 
         def next(self):
             l = self.fp.readline()
             if not l:
                 raise StopIteration
             return l
 
         __next__ = next
 
     inheader = False
     cur = []
 
     mimeheaders = [b'content-type']
 
     if not hasattr(stream, 'next'):
         # http responses, for example, have readline but not next
         stream = fiter(stream)
 
     for line in stream:
         cur.append(line)
         if line.startswith(b'# HG changeset patch'):
             return hgsplit(stream, cur)
         elif line.startswith(b'From '):
             return mboxsplit(stream, cur)
         elif isheader(line, inheader):
             inheader = True
             if line.split(b':', 1)[0].lower() in mimeheaders:
                 # let email parser handle this
                 return mimesplit(stream, cur)
         elif line.startswith(b'--- ') and inheader:
             # No evil headers seen by diff start, split by hand
             return headersplit(stream, cur)
         # Not enough info, keep reading
 
     # if we are here, we have a very plain patch
     return remainder(cur)
 
 
 ## Some facility for extensible patch parsing:
 # list of pairs ("header to match", "data key")
 patchheadermap = [
     (b'Date', b'date'),
     (b'Branch', b'branch'),
     (b'Node ID', b'nodeid'),
 ]
 
 
 @contextlib.contextmanager
 def extract(ui, fileobj):
     """extract patch from data read from fileobj.
 
     patch can be a normal patch or contained in an email message.
 
     return a dictionary. Standard keys are:
       - filename,
       - message,
       - user,
       - date,
       - branch,
       - node,
       - p1,
       - p2.
     Any item can be missing from the dictionary. If filename is missing,
     fileobj did not contain a patch. Caller must unlink filename when done."""
 
     fd, tmpname = pycompat.mkstemp(prefix=b'hg-patch-')
     tmpfp = os.fdopen(fd, 'wb')
     try:
         yield _extract(ui, fileobj, tmpname, tmpfp)
     finally:
         tmpfp.close()
         os.unlink(tmpname)
 
 
 def _extract(ui, fileobj, tmpname, tmpfp):
     # attempt to detect the start of a patch
     # (this heuristic is borrowed from quilt)
     diffre = re.compile(
         br'^(?:Index:[ \t]|diff[ \t]-|RCS file: |'
         br'retrieving revision [0-9]+(\.[0-9]+)*$|'
         br'---[ \t].*?^\+\+\+[ \t]|'
         br'\*\*\*[ \t].*?^---[ \t])',
         re.MULTILINE | re.DOTALL,
     )
 
     data = {}
 
     msg = mail.parse(fileobj)
 
     subject = msg['Subject'] and mail.headdecode(msg['Subject'])
     data[b'user'] = msg['From'] and mail.headdecode(msg['From'])
     if not subject and not data[b'user']:
         # Not an email, restore parsed headers if any
         subject = (
             b'\n'.join(
                 b': '.join(map(encoding.strtolocal, h)) for h in msg.items()
             )
             + b'\n'
         )
 
     # should try to parse msg['Date']
     parents = []
 
     nodeid = msg['X-Mercurial-Node']
     if nodeid:
         data[b'nodeid'] = nodeid = mail.headdecode(nodeid)
         ui.debug(b'Node ID: %s\n' % nodeid)
 
     if subject:
         if subject.startswith(b'[PATCH'):
             pend = subject.find(b']')
             if pend >= 0:
                 subject = subject[pend + 1 :].lstrip()
         subject = re.sub(br'\n[ \t]+', b' ', subject)
         ui.debug(b'Subject: %s\n' % subject)
     if data[b'user']:
         ui.debug(b'From: %s\n' % data[b'user'])
     diffs_seen = 0
     ok_types = (b'text/plain', b'text/x-diff', b'text/x-patch')
     message = b''
     for part in msg.walk():
         content_type = pycompat.bytestr(part.get_content_type())
         ui.debug(b'Content-Type: %s\n' % content_type)
         if content_type not in ok_types:
             continue
         payload = part.get_payload(decode=True)
         m = diffre.search(payload)
         if m:
             hgpatch = False
             hgpatchheader = False
             ignoretext = False
 
             ui.debug(b'found patch at byte %d\n' % m.start(0))
             diffs_seen += 1
             cfp = stringio()
             for line in payload[: m.start(0)].splitlines():
                 if line.startswith(b'# HG changeset patch') and not hgpatch:
                     ui.debug(b'patch generated by hg export\n')
                     hgpatch = True
                     hgpatchheader = True
                     # drop earlier commit message content
                     cfp.seek(0)
                     cfp.truncate()
                     subject = None
                 elif hgpatchheader:
                     if line.startswith(b'# User '):
                         data[b'user'] = line[7:]
                         ui.debug(b'From: %s\n' % data[b'user'])
                     elif line.startswith(b"# Parent "):
                         parents.append(line[9:].lstrip())
                     elif line.startswith(b"# "):
                         for header, key in patchheadermap:
                             prefix = b'# %s ' % header
                             if line.startswith(prefix):
                                 data[key] = line[len(prefix) :]
                                 ui.debug(b'%s: %s\n' % (header, data[key]))
                     else:
                         hgpatchheader = False
                 elif line == b'---':
                     ignoretext = True
                 if not hgpatchheader and not ignoretext:
                     cfp.write(line)
                     cfp.write(b'\n')
             message = cfp.getvalue()
             if tmpfp:
                 tmpfp.write(payload)
                 if not payload.endswith(b'\n'):
                     tmpfp.write(b'\n')
         elif not diffs_seen and message and content_type == b'text/plain':
             message += b'\n' + payload
 
     if subject and not message.startswith(subject):
         message = b'%s\n%s' % (subject, message)
     data[b'message'] = message
     tmpfp.close()
     if parents:
         data[b'p1'] = parents.pop(0)
         if parents:
             data[b'p2'] = parents.pop(0)
 
     if diffs_seen:
         data[b'filename'] = tmpname
 
     return data
 
 
 class patchmeta:
     """Patched file metadata
 
     'op' is the performed operation within ADD, DELETE, RENAME, MODIFY
     or COPY.  'path' is patched file path. 'oldpath' is set to the
     origin file when 'op' is either COPY or RENAME, None otherwise. If
     file mode is changed, 'mode' is a tuple (islink, isexec) where
     'islink' is True if the file is a symlink and 'isexec' is True if
     the file is executable. Otherwise, 'mode' is None.
     """
 
     def __init__(self, path):
         self.path = path
         self.oldpath = None
         self.mode = None
         self.op = b'MODIFY'
         self.binary = False
 
     def setmode(self, mode):
         islink = mode & 0o20000
         isexec = mode & 0o100
         self.mode = (islink, isexec)
 
     def copy(self):
         other = patchmeta(self.path)
         other.oldpath = self.oldpath
         other.mode = self.mode
         other.op = self.op
         other.binary = self.binary
         return other
 
     def _ispatchinga(self, afile):
         if afile == b'/dev/null':
             return self.op == b'ADD'
         return afile == b'a/' + (self.oldpath or self.path)
 
     def _ispatchingb(self, bfile):
         if bfile == b'/dev/null':
             return self.op == b'DELETE'
         return bfile == b'b/' + self.path
 
     def ispatching(self, afile, bfile):
         return self._ispatchinga(afile) and self._ispatchingb(bfile)
 
     def __repr__(self):
         return "<patchmeta %s %r>" % (self.op, self.path)
 
 
 def readgitpatch(lr):
     """extract git-style metadata about patches from <patchname>"""
 
     # Filter patch for git information
     gp = None
     gitpatches = []
     for line in lr:
         line = line.rstrip(b'\r\n')
         if line.startswith(b'diff --git a/'):
             m = gitre.match(line)
             if m:
                 if gp:
                     gitpatches.append(gp)
                 dst = m.group(2)
                 gp = patchmeta(dst)
         elif gp:
             if line.startswith(b'--- '):
                 gitpatches.append(gp)
                 gp = None
                 continue
             if line.startswith(b'rename from '):
                 gp.op = b'RENAME'
                 gp.oldpath = line[12:]
             elif line.startswith(b'rename to '):
                 gp.path = line[10:]
             elif line.startswith(b'copy from '):
                 gp.op = b'COPY'
                 gp.oldpath = line[10:]
             elif line.startswith(b'copy to '):
                 gp.path = line[8:]
             elif line.startswith(b'deleted file'):
                 gp.op = b'DELETE'
             elif line.startswith(b'new file mode '):
                 gp.op = b'ADD'
                 gp.setmode(int(line[-6:], 8))
             elif line.startswith(b'new mode '):
                 gp.setmode(int(line[-6:], 8))
             elif line.startswith(b'GIT binary patch'):
                 gp.binary = True
     if gp:
         gitpatches.append(gp)
 
     return gitpatches
 
 
 class linereader:
     # simple class to allow pushing lines back into the input stream
     def __init__(self, fp):
         self.fp = fp
         self.buf = []
 
     def push(self, line):
         if line is not None:
             self.buf.append(line)
 
     def readline(self):
         if self.buf:
             l = self.buf[0]
             del self.buf[0]
             return l
         return self.fp.readline()
 
     def __iter__(self):
         return iter(self.readline, b'')
 
 
 class abstractbackend:
     def __init__(self, ui):
         self.ui = ui
 
     def getfile(self, fname):
         """Return target file data and flags as a (data, (islink,
         isexec)) tuple. Data is None if file is missing/deleted.
         """
         raise NotImplementedError
 
     def setfile(self, fname, data, mode, copysource):
         """Write data to target file fname and set its mode. mode is a
         (islink, isexec) tuple. If data is None, the file content should
         be left unchanged. If the file is modified after being copied,
         copysource is set to the original file name.
         """
         raise NotImplementedError
 
     def unlink(self, fname):
         """Unlink target file."""
         raise NotImplementedError
 
     def writerej(self, fname, failed, total, lines):
         """Write rejected lines for fname. total is the number of hunks
         which failed to apply and total the total number of hunks for this
         files.
         """
 
     def exists(self, fname):
         raise NotImplementedError
 
     def close(self):
         raise NotImplementedError
 
 
 class fsbackend(abstractbackend):
     def __init__(self, ui, basedir):
         super(fsbackend, self).__init__(ui)
         self.opener = vfsmod.vfs(basedir)
 
     def getfile(self, fname):
         if self.opener.islink(fname):
             return (self.opener.readlink(fname), (True, False))
 
         isexec = False
         try:
             isexec = self.opener.lstat(fname).st_mode & 0o100 != 0
         except FileNotFoundError:
             pass
         try:
             return (self.opener.read(fname), (False, isexec))
         except FileNotFoundError:
             return None, None
 
     def setfile(self, fname, data, mode, copysource):
         islink, isexec = mode
         if data is None:
             self.opener.setflags(fname, islink, isexec)
             return
         if islink:
             self.opener.symlink(data, fname)
         else:
             self.opener.write(fname, data)
             if isexec:
                 self.opener.setflags(fname, False, True)
 
     def unlink(self, fname):
         rmdir = self.ui.configbool(b'experimental', b'removeemptydirs')
         self.opener.unlinkpath(fname, ignoremissing=True, rmdir=rmdir)
 
     def writerej(self, fname, failed, total, lines):
         fname = fname + b".rej"
         self.ui.warn(
             _(b"%d out of %d hunks FAILED -- saving rejects to file %s\n")
             % (failed, total, fname)
         )
         fp = self.opener(fname, b'w')
         fp.writelines(lines)
         fp.close()
 
     def exists(self, fname):
         return self.opener.lexists(fname)
 
 
 class workingbackend(fsbackend):
     def __init__(self, ui, repo, similarity):
         super(workingbackend, self).__init__(ui, repo.root)
         self.repo = repo
         self.similarity = similarity
         self.removed = set()
         self.changed = set()
         self.copied = []
 
     def _checkknown(self, fname):
         if not self.repo.dirstate.get_entry(fname).any_tracked and self.exists(
             fname
         ):
             raise PatchApplicationError(
                 _(b'cannot patch %s: file is not tracked') % fname
             )
 
     def setfile(self, fname, data, mode, copysource):
         self._checkknown(fname)
         super(workingbackend, self).setfile(fname, data, mode, copysource)
         if copysource is not None:
             self.copied.append((copysource, fname))
         self.changed.add(fname)
 
     def unlink(self, fname):
         self._checkknown(fname)
         super(workingbackend, self).unlink(fname)
         self.removed.add(fname)
         self.changed.add(fname)
 
     def close(self):
         with self.repo.dirstate.changing_files(self.repo):
             wctx = self.repo[None]
             changed = set(self.changed)
             for src, dst in self.copied:
                 scmutil.dirstatecopy(self.ui, self.repo, wctx, src, dst)
             if self.removed:
                 wctx.forget(sorted(self.removed))
                 for f in self.removed:
                     if f not in self.repo.dirstate:
                         # File was deleted and no longer belongs to the
                         # dirstate, it was probably marked added then
                         # deleted, and should not be considered by
                         # marktouched().
                         changed.discard(f)
             if changed:
                 scmutil.marktouched(self.repo, changed, self.similarity)
             return sorted(self.changed)
 
 
 class filestore:
     def __init__(self, maxsize=None):
         self.opener = None
         self.files = {}
         self.created = 0
         self.maxsize = maxsize
         if self.maxsize is None:
             self.maxsize = 4 * (2**20)
         self.size = 0
         self.data = {}
 
     def setfile(self, fname, data, mode, copied=None):
         if self.maxsize < 0 or (len(data) + self.size) <= self.maxsize:
             self.data[fname] = (data, mode, copied)
             self.size += len(data)
         else:
             if self.opener is None:
                 root = pycompat.mkdtemp(prefix=b'hg-patch-')
                 self.opener = vfsmod.vfs(root)
             # Avoid filename issues with these simple names
             fn = b'%d' % self.created
             self.opener.write(fn, data)
             self.created += 1
             self.files[fname] = (fn, mode, copied)
 
     def getfile(self, fname):
         if fname in self.data:
             return self.data[fname]
         if not self.opener or fname not in self.files:
             return None, None, None
         fn, mode, copied = self.files[fname]
         return self.opener.read(fn), mode, copied
 
     def close(self):
         if self.opener:
             shutil.rmtree(self.opener.base)
 
 
 class repobackend(abstractbackend):
     def __init__(self, ui, repo, ctx, store):
         super(repobackend, self).__init__(ui)
         self.repo = repo
         self.ctx = ctx
         self.store = store
         self.changed = set()
         self.removed = set()
         self.copied = {}
 
     def _checkknown(self, fname):
         if fname not in self.ctx:
             raise PatchApplicationError(
                 _(b'cannot patch %s: file is not tracked') % fname
             )
 
     def getfile(self, fname):
         try:
             fctx = self.ctx[fname]
         except error.LookupError:
             return None, None
         flags = fctx.flags()
         return fctx.data(), (b'l' in flags, b'x' in flags)
 
     def setfile(self, fname, data, mode, copysource):
         if copysource:
             self._checkknown(copysource)
         if data is None:
             data = self.ctx[fname].data()
         self.store.setfile(fname, data, mode, copysource)
         self.changed.add(fname)
         if copysource:
             self.copied[fname] = copysource
 
     def unlink(self, fname):
         self._checkknown(fname)
         self.removed.add(fname)
 
     def exists(self, fname):
         return fname in self.ctx
 
     def close(self):
         return self.changed | self.removed
 
 
 # @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1
 unidesc = re.compile(br'@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@')
 contextdesc = re.compile(br'(?:---|\*\*\*) (\d+)(?:,(\d+))? (?:---|\*\*\*)')
 eolmodes = [b'strict', b'crlf', b'lf', b'auto']
 
 
 class patchfile:
     def __init__(self, ui, gp, backend, store, eolmode=b'strict'):
         self.fname = gp.path
         self.eolmode = eolmode
         self.eol = None
         self.backend = backend
         self.ui = ui
         self.lines = []
         self.exists = False
         self.missing = True
         self.mode = gp.mode
         self.copysource = gp.oldpath
         self.create = gp.op in (b'ADD', b'COPY', b'RENAME')
         self.remove = gp.op == b'DELETE'
         if self.copysource is None:
             data, mode = backend.getfile(self.fname)
         else:
             data, mode = store.getfile(self.copysource)[:2]
         if data is not None:
             self.exists = self.copysource is None or backend.exists(self.fname)
             self.missing = False
             if data:
                 self.lines = mdiff.splitnewlines(data)
             if self.mode is None:
                 self.mode = mode
             if self.lines:
                 # Normalize line endings
                 if self.lines[0].endswith(b'\r\n'):
                     self.eol = b'\r\n'
                 elif self.lines[0].endswith(b'\n'):
                     self.eol = b'\n'
                 if eolmode != b'strict':
                     nlines = []
                     for l in self.lines:
                         if l.endswith(b'\r\n'):
                             l = l[:-2] + b'\n'
                         nlines.append(l)
                     self.lines = nlines
         else:
             if self.create:
                 self.missing = False
             if self.mode is None:
                 self.mode = (False, False)
         if self.missing:
             self.ui.warn(_(b"unable to find '%s' for patching\n") % self.fname)
             self.ui.warn(
                 _(
                     b"(use '--prefix' to apply patch relative to the "
                     b"current directory)\n"
                 )
             )
 
         self.hash = {}
         self.dirty = 0
         self.offset = 0
         self.skew = 0
         self.rej = []
         self.fileprinted = False
         self.printfile(False)
         self.hunks = 0
 
     def writelines(self, fname, lines, mode):
         if self.eolmode == b'auto':
             eol = self.eol
         elif self.eolmode == b'crlf':
             eol = b'\r\n'
         else:
             eol = b'\n'
 
         if self.eolmode != b'strict' and eol and eol != b'\n':
             rawlines = []
             for l in lines:
                 if l and l.endswith(b'\n'):
                     l = l[:-1] + eol
                 rawlines.append(l)
             lines = rawlines
 
         self.backend.setfile(fname, b''.join(lines), mode, self.copysource)
 
     def printfile(self, warn):
         if self.fileprinted:
             return
         if warn or self.ui.verbose:
             self.fileprinted = True
         s = _(b"patching file %s\n") % self.fname
         if warn:
             self.ui.warn(s)
         else:
             self.ui.note(s)
 
     def findlines(self, l, linenum):
         # looks through the hash and finds candidate lines.  The
         # result is a list of line numbers sorted based on distance
         # from linenum
 
         cand = self.hash.get(l, [])
         if len(cand) > 1:
             # resort our list of potentials forward then back.
             cand.sort(key=lambda x: abs(x - linenum))
         return cand
 
     def write_rej(self):
         # our rejects are a little different from patch(1).  This always
         # creates rejects in the same form as the original patch.  A file
         # header is inserted so that you can run the reject through patch again
         # without having to type the filename.
         if not self.rej:
             return
         base = os.path.basename(self.fname)
         lines = [b"--- %s\n+++ %s\n" % (base, base)]
         for x in self.rej:
             for l in x.hunk:
                 lines.append(l)
                 if l[-1:] != b'\n':
                     lines.append(b'\n' + diffhelper.MISSING_NEWLINE_MARKER)
         self.backend.writerej(self.fname, len(self.rej), self.hunks, lines)
 
     def apply(self, h):
         if not h.complete():
             raise PatchParseError(
                 _(b"bad hunk #%d %s (%d %d %d %d)")
                 % (h.number, h.desc, len(h.a), h.lena, len(h.b), h.lenb)
             )
 
         self.hunks += 1
 
         if self.missing:
             self.rej.append(h)
             return -1
 
         if self.exists and self.create:
             if self.copysource:
                 self.ui.warn(
                     _(b"cannot create %s: destination already exists\n")
                     % self.fname
                 )
             else:
                 self.ui.warn(_(b"file %s already exists\n") % self.fname)
             self.rej.append(h)
             return -1
 
         if isinstance(h, binhunk):
             if self.remove:
                 self.backend.unlink(self.fname)
             else:
                 l = h.new(self.lines)
                 self.lines[:] = l
                 self.offset += len(l)
                 self.dirty = True
             return 0
 
         horig = h
         if (
             self.eolmode in (b'crlf', b'lf')
             or self.eolmode == b'auto'
             and self.eol
         ):
             # If new eols are going to be normalized, then normalize
             # hunk data before patching. Otherwise, preserve input
             # line-endings.
             h = h.getnormalized()
 
         # fast case first, no offsets, no fuzz
         old, oldstart, new, newstart = h.fuzzit(0, False)
         oldstart += self.offset
         orig_start = oldstart
         # if there's skew we want to emit the "(offset %d lines)" even
         # when the hunk cleanly applies at start + skew, so skip the
         # fast case code
         if self.skew == 0 and diffhelper.testhunk(old, self.lines, oldstart):
             if self.remove:
                 self.backend.unlink(self.fname)
             else:
                 self.lines[oldstart : oldstart + len(old)] = new
                 self.offset += len(new) - len(old)
                 self.dirty = True
             return 0
 
         # ok, we couldn't match the hunk. Lets look for offsets and fuzz it
         self.hash = {}
         for x, s in enumerate(self.lines):
             self.hash.setdefault(s, []).append(x)
 
         for fuzzlen in range(self.ui.configint(b"patch", b"fuzz") + 1):
             for toponly in [True, False]:
                 old, oldstart, new, newstart = h.fuzzit(fuzzlen, toponly)
                 oldstart = oldstart + self.offset + self.skew
                 oldstart = min(oldstart, len(self.lines))
                 if old:
                     cand = self.findlines(old[0][1:], oldstart)
                 else:
                     # Only adding lines with no or fuzzed context, just
                     # take the skew in account
                     cand = [oldstart]
 
                 for l in cand:
                     if not old or diffhelper.testhunk(old, self.lines, l):
                         self.lines[l : l + len(old)] = new
                         self.offset += len(new) - len(old)
                         self.skew = l - orig_start
                         self.dirty = True
                         offset = l - orig_start - fuzzlen
                         if fuzzlen:
                             msg = _(
                                 b"Hunk #%d succeeded at %d "
                                 b"with fuzz %d "
                                 b"(offset %d lines).\n"
                             )
                             self.printfile(True)
                             self.ui.warn(
                                 msg % (h.number, l + 1, fuzzlen, offset)
                             )
                         else:
                             msg = _(
                                 b"Hunk #%d succeeded at %d "
                                 b"(offset %d lines).\n"
                             )
                             self.ui.note(msg % (h.number, l + 1, offset))
                         return fuzzlen
         self.printfile(True)
         self.ui.warn(_(b"Hunk #%d FAILED at %d\n") % (h.number, orig_start))
         self.rej.append(horig)
         return -1
 
     def close(self):
         if self.dirty:
             self.writelines(self.fname, self.lines, self.mode)
         self.write_rej()
         return len(self.rej)
 
 
 class header:
     """patch header"""
 
     diffgit_re = re.compile(b'diff --git a/(.*) b/(.*)$')
     diff_re = re.compile(b'diff -r .* (.*)$')
     allhunks_re = re.compile(b'(?:index|deleted file) ')
     pretty_re = re.compile(b'(?:new file|deleted file) ')
     special_re = re.compile(b'(?:index|deleted|copy|rename|new mode) ')
     newfile_re = re.compile(b'(?:new file|copy to|rename to)')
 
     def __init__(self, header):
         self.header = header
         self.hunks = []
 
     def binary(self):
         return any(h.startswith(b'index ') for h in self.header)
 
     def pretty(self, fp):
         for h in self.header:
             if h.startswith(b'index '):
                 fp.write(_(b'this modifies a binary file (all or nothing)\n'))
                 break
             if self.pretty_re.match(h):
                 fp.write(h)
                 if self.binary():
                     fp.write(_(b'this is a binary file\n'))
                 break
             if h.startswith(b'---'):
                 fp.write(
                     _(b'%d hunks, %d lines changed\n')
                     % (
                         len(self.hunks),
                         sum([max(h.added, h.removed) for h in self.hunks]),
                     )
                 )
                 break
             fp.write(h)
 
     def write(self, fp):
         fp.write(b''.join(self.header))
 
     def allhunks(self):
         return any(self.allhunks_re.match(h) for h in self.header)
 
     def files(self):
         match = self.diffgit_re.match(self.header[0])
         if match:
             fromfile, tofile = match.groups()
             if fromfile == tofile:
                 return [fromfile]
             return [fromfile, tofile]
         else:
             return self.diff_re.match(self.header[0]).groups()
 
     def filename(self):
         return self.files()[-1]
 
     def __repr__(self):
         return '<header %s>' % (
             ' '.join(pycompat.rapply(pycompat.fsdecode, self.files()))
         )
 
     def isnewfile(self):
         return any(self.newfile_re.match(h) for h in self.header)
 
     def special(self):
         # Special files are shown only at the header level and not at the hunk
         # level for example a file that has been deleted is a special file.
         # The user cannot change the content of the operation, in the case of
         # the deleted file he has to take the deletion or not take it, he
         # cannot take some of it.
         # Newly added files are special if they are empty, they are not special
         # if they have some content as we want to be able to change it
         nocontent = len(self.header) == 2
         emptynewfile = self.isnewfile() and nocontent
         return emptynewfile or any(
             self.special_re.match(h) for h in self.header
         )
 
 
 class recordhunk:
     """patch hunk
 
     XXX shouldn't we merge this with the other hunk class?
     """
 
     def __init__(
         self,
         header,
         fromline,
         toline,
         proc,
         before,
         hunk,
         after,
         maxcontext=None,
     ):
         def trimcontext(lines, reverse=False):
             if maxcontext is not None:
                 delta = len(lines) - maxcontext
                 if delta > 0:
                     if reverse:
                         return delta, lines[delta:]
                     else:
                         return delta, lines[:maxcontext]
             return 0, lines
 
         self.header = header
         trimedbefore, self.before = trimcontext(before, True)
         self.fromline = fromline + trimedbefore
         self.toline = toline + trimedbefore
         _trimedafter, self.after = trimcontext(after, False)
         self.proc = proc
         self.hunk = hunk
         self.added, self.removed = self.countchanges(self.hunk)
 
     def __eq__(self, v):
         if not isinstance(v, recordhunk):
             return False
 
         return (
             (v.hunk == self.hunk)
             and (v.proc == self.proc)
             and (self.fromline == v.fromline)
             and (self.header.files() == v.header.files())
         )
 
     def __hash__(self):
         return hash(
             (
                 tuple(self.hunk),
                 tuple(self.header.files()),
                 self.fromline,
                 self.proc,
             )
         )
 
     def countchanges(self, hunk):
         """hunk -> (n+,n-)"""
         add = len([h for h in hunk if h.startswith(b'+')])
         rem = len([h for h in hunk if h.startswith(b'-')])
         return add, rem
 
     def reversehunk(self):
         """return another recordhunk which is the reverse of the hunk
 
         If this hunk is diff(A, B), the returned hunk is diff(B, A). To do
         that, swap fromline/toline and +/- signs while keep other things
         unchanged.
         """
         m = {b'+': b'-', b'-': b'+', b'\\': b'\\'}
         hunk = [b'%s%s' % (m[l[0:1]], l[1:]) for l in self.hunk]
         return recordhunk(
             self.header,
             self.toline,
             self.fromline,
             self.proc,
             self.before,
             hunk,
             self.after,
         )
 
     def write(self, fp):
         delta = len(self.before) + len(self.after)
         if self.after and self.after[-1] == diffhelper.MISSING_NEWLINE_MARKER:
             delta -= 1
         fromlen = delta + self.removed
         tolen = delta + self.added
         fp.write(
             b'@@ -%d,%d +%d,%d @@%s\n'
             % (
                 self.fromline,
                 fromlen,
                 self.toline,
                 tolen,
                 self.proc and (b' ' + self.proc),
             )
         )
         fp.write(b''.join(self.before + self.hunk + self.after))
 
     pretty = write
 
     def filename(self):
         return self.header.filename()
 
     @encoding.strmethod
     def __repr__(self):
         return b'<hunk %r@%d>' % (self.filename(), self.fromline)
 
 
 def getmessages():
     return {
         b'multiple': {
             b'apply': _(b"apply change %d/%d to '%s'?"),
             b'discard': _(b"discard change %d/%d to '%s'?"),
             b'keep': _(b"keep change %d/%d to '%s'?"),
             b'record': _(b"record change %d/%d to '%s'?"),
         },
         b'single': {
             b'apply': _(b"apply this change to '%s'?"),
             b'discard': _(b"discard this change to '%s'?"),
             b'keep': _(b"keep this change to '%s'?"),
             b'record': _(b"record this change to '%s'?"),
         },
         b'help': {
             b'apply': _(
                 b'[Ynesfdaq?]'
                 b'$$ &Yes, apply this change'
                 b'$$ &No, skip this change'
                 b'$$ &Edit this change manually'
                 b'$$ &Skip remaining changes to this file'
                 b'$$ Apply remaining changes to this &file'
                 b'$$ &Done, skip remaining changes and files'
                 b'$$ Apply &all changes to all remaining files'
                 b'$$ &Quit, applying no changes'
                 b'$$ &? (display help)'
             ),
             b'discard': _(
                 b'[Ynesfdaq?]'
                 b'$$ &Yes, discard this change'
                 b'$$ &No, skip this change'
                 b'$$ &Edit this change manually'
                 b'$$ &Skip remaining changes to this file'
                 b'$$ Discard remaining changes to this &file'
                 b'$$ &Done, skip remaining changes and files'
                 b'$$ Discard &all changes to all remaining files'
                 b'$$ &Quit, discarding no changes'
                 b'$$ &? (display help)'
             ),
             b'keep': _(
                 b'[Ynesfdaq?]'
                 b'$$ &Yes, keep this change'
                 b'$$ &No, skip this change'
                 b'$$ &Edit this change manually'
                 b'$$ &Skip remaining changes to this file'
                 b'$$ Keep remaining changes to this &file'
                 b'$$ &Done, skip remaining changes and files'
                 b'$$ Keep &all changes to all remaining files'
                 b'$$ &Quit, keeping all changes'
                 b'$$ &? (display help)'
             ),
             b'record': _(
                 b'[Ynesfdaq?]'
                 b'$$ &Yes, record this change'
                 b'$$ &No, skip this change'
                 b'$$ &Edit this change manually'
                 b'$$ &Skip remaining changes to this file'
                 b'$$ Record remaining changes to this &file'
                 b'$$ &Done, skip remaining changes and files'
                 b'$$ Record &all changes to all remaining files'
                 b'$$ &Quit, recording no changes'
                 b'$$ &? (display help)'
             ),
         },
     }
 
 
 def filterpatch(ui, headers, match, operation=None):
     """Interactively filter patch chunks into applied-only chunks"""
     messages = getmessages()
 
     if operation is None:
         operation = b'record'
 
     def prompt(skipfile, skipall, query, chunk):
         """prompt query, and process base inputs
 
         - y/n for the rest of file
         - y/n for the rest
         - ? (help)
         - q (quit)
 
         Return True/False and possibly updated skipfile and skipall.
         """
         newpatches = None
         if skipall is not None:
             return skipall, skipfile, skipall, newpatches
         if skipfile is not None:
             return skipfile, skipfile, skipall, newpatches
         while True:
             resps = messages[b'help'][operation]
             # IMPORTANT: keep the last line of this prompt short (<40 english
             # chars is a good target) because of issue6158.
             r = ui.promptchoice(b"%s\n(enter ? for help) %s" % (query, resps))
             ui.write(b"\n")
             if r == 8:  # ?
                 for c, t in ui.extractchoices(resps)[1]:
                     ui.write(b'%s - %s\n' % (c, encoding.lower(t)))
                 continue
             elif r == 0:  # yes
                 ret = True
             elif r == 1:  # no
                 ret = False
             elif r == 2:  # Edit patch
                 if chunk is None:
                     ui.write(_(b'cannot edit patch for whole file'))
                     ui.write(b"\n")
                     continue
                 if chunk.header.binary():
                     ui.write(_(b'cannot edit patch for binary file'))
                     ui.write(b"\n")
                     continue
                 # Patch comment based on the Git one (based on comment at end of
                 # https://mercurial-scm.org/wiki/RecordExtension)
                 phelp = b'---' + _(
                     b"""
 To remove '-' lines, make them ' ' lines (context).
 To remove '+' lines, delete them.
 Lines starting with # will be removed from the patch.
 
 If the patch applies cleanly, the edited hunk will immediately be
 added to the record list. If it does not apply cleanly, a rejects
 file will be generated: you can use that when you try again. If
 all lines of the hunk are removed, then the edit is aborted and
 the hunk is left unchanged.
 """
                 )
                 (patchfd, patchfn) = pycompat.mkstemp(
                     prefix=b"hg-editor-", suffix=b".diff"
                 )
                 ncpatchfp = None
                 try:
                     # Write the initial patch
                     f = util.nativeeolwriter(os.fdopen(patchfd, 'wb'))
                     chunk.header.write(f)
                     chunk.write(f)
                     f.write(
                         b''.join(
                             [b'# ' + i + b'\n' for i in phelp.splitlines()]
                         )
                     )
                     f.close()
                     # Start the editor and wait for it to complete
                     editor = ui.geteditor()
                     ret = ui.system(
                         b"%s \"%s\"" % (editor, patchfn),
                         environ={b'HGUSER': ui.username()},
                         blockedtag=b'filterpatch',
                     )
                     if ret != 0:
                         ui.warn(_(b"editor exited with exit code %d\n") % ret)
                         continue
                     # Remove comment lines
                     patchfp = open(patchfn, 'rb')
                     ncpatchfp = stringio()
                     for line in patchfp:
                         line = util.fromnativeeol(line)
                         if not line.startswith(b'#'):
                             ncpatchfp.write(line)
                     patchfp.close()
                     ncpatchfp.seek(0)
                     newpatches = parsepatch(ncpatchfp)
                 finally:
                     os.unlink(patchfn)
                     del ncpatchfp
                 # Signal that the chunk shouldn't be applied as-is, but
                 # provide the new patch to be used instead.
                 ret = False
             elif r == 3:  # Skip
                 ret = skipfile = False
             elif r == 4:  # file (Record remaining)
                 ret = skipfile = True
             elif r == 5:  # done, skip remaining
                 ret = skipall = False
             elif r == 6:  # all
                 ret = skipall = True
             elif r == 7:  # quit
                 raise error.CanceledError(_(b'user quit'))
             return ret, skipfile, skipall, newpatches
 
     seen = set()
     applied = {}  # 'filename' -> [] of chunks
     skipfile, skipall = None, None
     pos, total = 1, sum(len(h.hunks) for h in headers)
     for h in headers:
         pos += len(h.hunks)
         skipfile = None
         fixoffset = 0
         hdr = b''.join(h.header)
         if hdr in seen:
             continue
         seen.add(hdr)
         if skipall is None:
             h.pretty(ui)
         files = h.files()
         msg = _(b'examine changes to %s?') % _(b' and ').join(
             b"'%s'" % f for f in files
         )
         if all(match.exact(f) for f in files):
             r, skipall, np = True, None, None
         else:
             r, skipfile, skipall, np = prompt(skipfile, skipall, msg, None)
         if not r:
             continue
         applied[h.filename()] = [h]
         if h.allhunks():
             applied[h.filename()] += h.hunks
             continue
         for i, chunk in enumerate(h.hunks):
             if skipfile is None and skipall is None:
                 chunk.pretty(ui)
             if total == 1:
                 msg = messages[b'single'][operation] % chunk.filename()
             else:
                 idx = pos - len(h.hunks) + i
                 msg = messages[b'multiple'][operation] % (
                     idx,
                     total,
                     chunk.filename(),
                 )
             r, skipfile, skipall, newpatches = prompt(
                 skipfile, skipall, msg, chunk
             )
             if r:
                 if fixoffset:
                     chunk = copy.copy(chunk)
                     chunk.toline += fixoffset
                 applied[chunk.filename()].append(chunk)
             elif newpatches is not None:
                 for newpatch in newpatches:
                     for newhunk in newpatch.hunks:
                         if fixoffset:
                             newhunk.toline += fixoffset
                         applied[newhunk.filename()].append(newhunk)
             else:
                 fixoffset += chunk.removed - chunk.added
     return (
         sum(
             [h for h in applied.values() if h[0].special() or len(h) > 1],
             [],
         ),
         {},
     )
 
 
 class hunk:
     def __init__(self, desc, num, lr, context):
         self.number = num
         self.desc = desc
         self.hunk = [desc]
         self.a = []
         self.b = []
         self.starta = self.lena = None
         self.startb = self.lenb = None
         if lr is not None:
             if context:
                 self.read_context_hunk(lr)
             else:
                 self.read_unified_hunk(lr)
 
     def getnormalized(self):
         """Return a copy with line endings normalized to LF."""
 
         def normalize(lines):
             nlines = []
             for line in lines:
                 if line.endswith(b'\r\n'):
                     line = line[:-2] + b'\n'
                 nlines.append(line)
             return nlines
 
         # Dummy object, it is rebuilt manually
         nh = hunk(self.desc, self.number, None, None)
         nh.number = self.number
         nh.desc = self.desc
         nh.hunk = self.hunk
         nh.a = normalize(self.a)
         nh.b = normalize(self.b)
         nh.starta = self.starta
         nh.startb = self.startb
         nh.lena = self.lena
         nh.lenb = self.lenb
         return nh
 
     def read_unified_hunk(self, lr):
         m = unidesc.match(self.desc)
         if not m:
             raise PatchParseError(_(b"bad hunk #%d") % self.number)
         self.starta, self.lena, self.startb, self.lenb = m.groups()
         if self.lena is None:
             self.lena = 1
         else:
             self.lena = int(self.lena)
         if self.lenb is None:
             self.lenb = 1
         else:
             self.lenb = int(self.lenb)
         self.starta = int(self.starta)
         self.startb = int(self.startb)
         try:
             diffhelper.addlines(
                 lr, self.hunk, self.lena, self.lenb, self.a, self.b
             )
         except error.ParseError as e:
             raise PatchParseError(_(b"bad hunk #%d: %s") % (self.number, e))
         # if we hit eof before finishing out the hunk, the last line will
         # be zero length.  Lets try to fix it up.
         while len(self.hunk[-1]) == 0:
             del self.hunk[-1]
             del self.a[-1]
             del self.b[-1]
             self.lena -= 1
             self.lenb -= 1
         self._fixnewline(lr)
 
     def read_context_hunk(self, lr):
         self.desc = lr.readline()
         m = contextdesc.match(self.desc)
         if not m:
             raise PatchParseError(_(b"bad hunk #%d") % self.number)
         self.starta, aend = m.groups()
         self.starta = int(self.starta)
         if aend is None:
             aend = self.starta
         self.lena = int(aend) - self.starta
         if self.starta:
             self.lena += 1
         for x in range(self.lena):
             l = lr.readline()
             if l.startswith(b'---'):
                 # lines addition, old block is empty
                 lr.push(l)
                 break
             s = l[2:]
             if l.startswith(b'- ') or l.startswith(b'! '):
                 u = b'-' + s
             elif l.startswith(b'  '):
                 u = b' ' + s
             else:
                 raise PatchParseError(
                     _(b"bad hunk #%d old text line %d") % (self.number, x)
                 )
             self.a.append(u)
             self.hunk.append(u)
 
         l = lr.readline()
         if l.startswith(br'\ '):
             s = self.a[-1][:-1]
             self.a[-1] = s
             self.hunk[-1] = s
             l = lr.readline()
         m = contextdesc.match(l)
         if not m:
             raise PatchParseError(_(b"bad hunk #%d") % self.number)
         self.startb, bend = m.groups()
         self.startb = int(self.startb)
         if bend is None:
             bend = self.startb
         self.lenb = int(bend) - self.startb
         if self.startb:
             self.lenb += 1
         hunki = 1
         for x in range(self.lenb):
             l = lr.readline()
             if l.startswith(br'\ '):
                 # XXX: the only way to hit this is with an invalid line range.
                 # The no-eol marker is not counted in the line range, but I
                 # guess there are diff(1) out there which behave differently.
                 s = self.b[-1][:-1]
                 self.b[-1] = s
                 self.hunk[hunki - 1] = s
                 continue
             if not l:
                 # line deletions, new block is empty and we hit EOF
                 lr.push(l)
                 break
             s = l[2:]
             if l.startswith(b'+ ') or l.startswith(b'! '):
                 u = b'+' + s
             elif l.startswith(b'  '):
                 u = b' ' + s
             elif len(self.b) == 0:
                 # line deletions, new block is empty
                 lr.push(l)
                 break
             else:
                 raise PatchParseError(
                     _(b"bad hunk #%d old text line %d") % (self.number, x)
                 )
             self.b.append(s)
             while True:
                 if hunki >= len(self.hunk):
                     h = b""
                 else:
                     h = self.hunk[hunki]
                 hunki += 1
                 if h == u:
                     break
                 elif h.startswith(b'-'):
                     continue
                 else:
                     self.hunk.insert(hunki - 1, u)
                     break
 
         if not self.a:
             # this happens when lines were only added to the hunk
             for x in self.hunk:
                 if x.startswith(b'-') or x.startswith(b' '):
                     self.a.append(x)
         if not self.b:
             # this happens when lines were only deleted from the hunk
             for x in self.hunk:
                 if x.startswith(b'+') or x.startswith(b' '):
                     self.b.append(x[1:])
         # @@ -start,len +start,len @@
         self.desc = b"@@ -%d,%d +%d,%d @@\n" % (
             self.starta,
             self.lena,
             self.startb,
             self.lenb,
         )
         self.hunk[0] = self.desc
         self._fixnewline(lr)
 
     def _fixnewline(self, lr):
         l = lr.readline()
         if l.startswith(br'\ '):
             diffhelper.fixnewline(self.hunk, self.a, self.b)
         else:
             lr.push(l)
 
     def complete(self):
         return len(self.a) == self.lena and len(self.b) == self.lenb
 
     def _fuzzit(self, old, new, fuzz, toponly):
         # this removes context lines from the top and bottom of list 'l'.  It
         # checks the hunk to make sure only context lines are removed, and then
         # returns a new shortened list of lines.
         fuzz = min(fuzz, len(old))
         if fuzz:
             top = 0
             bot = 0
             hlen = len(self.hunk)
             for x in range(hlen - 1):
                 # the hunk starts with the @@ line, so use x+1
                 if self.hunk[x + 1].startswith(b' '):
                     top += 1
                 else:
                     break
             if not toponly:
                 for x in range(hlen - 1):
                     if self.hunk[hlen - bot - 1].startswith(b' '):
                         bot += 1
                     else:
                         break
 
             bot = min(fuzz, bot)
             top = min(fuzz, top)
             return old[top : len(old) - bot], new[top : len(new) - bot], top
         return old, new, 0
 
     def fuzzit(self, fuzz, toponly):
         old, new, top = self._fuzzit(self.a, self.b, fuzz, toponly)
         oldstart = self.starta + top
         newstart = self.startb + top
         # zero length hunk ranges already have their start decremented
         if self.lena and oldstart > 0:
             oldstart -= 1
         if self.lenb and newstart > 0:
             newstart -= 1
         return old, oldstart, new, newstart
 
 
 class binhunk:
     """A binary patch file."""
 
     def __init__(self, lr, fname):
         self.text = None
         self.delta = False
         self.hunk = [b'GIT binary patch\n']
         self._fname = fname
         self._read(lr)
 
     def complete(self):
         return self.text is not None
 
     def new(self, lines):
         if self.delta:
             return [applybindelta(self.text, b''.join(lines))]
         return [self.text]
 
     def _read(self, lr):
         def getline(lr, hunk):
             l = lr.readline()
             hunk.append(l)
             return l.rstrip(b'\r\n')
 
         while True:
             line = getline(lr, self.hunk)
             if not line:
                 raise PatchParseError(
                     _(b'could not extract "%s" binary data') % self._fname
                 )
             if line.startswith(b'literal '):
                 size = int(line[8:].rstrip())
                 break
             if line.startswith(b'delta '):
                 size = int(line[6:].rstrip())
                 self.delta = True
                 break
         dec = []
         line = getline(lr, self.hunk)
         while len(line) > 1:
             l = line[0:1]
             if l <= b'Z' and l >= b'A':
                 l = ord(l) - ord(b'A') + 1
             else:
                 l = ord(l) - ord(b'a') + 27
             try:
                 dec.append(util.b85decode(line[1:])[:l])
             except ValueError as e:
                 raise PatchParseError(
                     _(b'could not decode "%s" binary patch: %s')
                     % (self._fname, stringutil.forcebytestr(e))
                 )
             line = getline(lr, self.hunk)
         text = zlib.decompress(b''.join(dec))
         if len(text) != size:
             raise PatchParseError(
                 _(b'"%s" length is %d bytes, should be %d')
                 % (self._fname, len(text), size)
             )
         self.text = text
 
 
 def parsefilename(str):
     # --- filename \t|space stuff
     s = str[4:].rstrip(b'\r\n')
     i = s.find(b'\t')
     if i < 0:
         i = s.find(b' ')
         if i < 0:
             return s
     return s[:i]
 
 
 def reversehunks(hunks):
     '''reverse the signs in the hunks given as argument
 
     This function operates on hunks coming out of patch.filterpatch, that is
     a list of the form: [header1, hunk1, hunk2, header2...]. Example usage:
 
     >>> rawpatch = b"""diff --git a/folder1/g b/folder1/g
     ... --- a/folder1/g
     ... +++ b/folder1/g
     ... @@ -1,7 +1,7 @@
     ... +firstline
     ...  c
     ...  1
     ...  2
     ... + 3
     ... -4
     ...  5
     ...  d
     ... +lastline"""
     >>> hunks = parsepatch([rawpatch])
     >>> hunkscomingfromfilterpatch = []
     >>> for h in hunks:
     ...     hunkscomingfromfilterpatch.append(h)
     ...     hunkscomingfromfilterpatch.extend(h.hunks)
 
     >>> reversedhunks = reversehunks(hunkscomingfromfilterpatch)
     >>> from . import util
     >>> fp = util.stringio()
     >>> for c in reversedhunks:
     ...      c.write(fp)
     >>> fp.seek(0) or None
     >>> reversedpatch = fp.read()
     >>> print(pycompat.sysstr(reversedpatch))
     diff --git a/folder1/g b/folder1/g
     --- a/folder1/g
     +++ b/folder1/g
     @@ -1,4 +1,3 @@
     -firstline
      c
      1
      2
     @@ -2,6 +1,6 @@
      c
      1
      2
     - 3
     +4
      5
      d
     @@ -6,3 +5,2 @@
      5
      d
     -lastline
 
     '''
 
     newhunks = []
     for c in hunks:
         if hasattr(c, 'reversehunk'):
             c = c.reversehunk()
         newhunks.append(c)
     return newhunks
 
 
 def parsepatch(originalchunks, maxcontext=None):
     """patch -> [] of headers -> [] of hunks
 
     If maxcontext is not None, trim context lines if necessary.
 
     >>> rawpatch = b'''diff --git a/folder1/g b/folder1/g
     ... --- a/folder1/g
     ... +++ b/folder1/g
     ... @@ -1,8 +1,10 @@
     ...  1
     ...  2
     ... -3
     ...  4
     ...  5
     ...  6
     ... +6.1
     ... +6.2
     ...  7
     ...  8
     ... +9'''
     >>> out = util.stringio()
     >>> headers = parsepatch([rawpatch], maxcontext=1)
     >>> for header in headers:
     ...     header.write(out)
     ...     for hunk in header.hunks:
     ...         hunk.write(out)
     >>> print(pycompat.sysstr(out.getvalue()))
     diff --git a/folder1/g b/folder1/g
     --- a/folder1/g
     +++ b/folder1/g
     @@ -2,3 +2,2 @@
      2
     -3
      4
     @@ -6,2 +5,4 @@
      6
     +6.1
     +6.2
      7
     @@ -8,1 +9,2 @@
      8
     +9
     """
 
     class parser:
         """patch parsing state machine"""
 
         def __init__(self):
             self.fromline = 0
             self.toline = 0
             self.proc = b''
             self.header = None
             self.context = []
             self.before = []
             self.hunk = []
             self.headers = []
 
         def addrange(self, limits):
             self.addcontext([])
             fromstart, fromend, tostart, toend, proc = limits
             self.fromline = int(fromstart)
             self.toline = int(tostart)
             self.proc = proc
 
         def addcontext(self, context):
             if self.hunk:
                 h = recordhunk(
                     self.header,
                     self.fromline,
                     self.toline,
                     self.proc,
                     self.before,
                     self.hunk,
                     context,
                     maxcontext,
                 )
                 self.header.hunks.append(h)
                 self.fromline += len(self.before) + h.removed
                 self.toline += len(self.before) + h.added
                 self.before = []
                 self.hunk = []
             self.context = context
 
         def addhunk(self, hunk):
             if self.context:
                 self.before = self.context
                 self.context = []
             if self.hunk:
                 self.addcontext([])
             self.hunk = hunk
 
         def newfile(self, hdr):
             self.addcontext([])
             h = header(hdr)
             self.headers.append(h)
             self.header = h
 
         def addother(self, line):
             pass  # 'other' lines are ignored
 
         def finished(self):
             self.addcontext([])
             return self.headers
 
         transitions = {
             b'file': {
                 b'context': addcontext,
                 b'file': newfile,
                 b'hunk': addhunk,
                 b'range': addrange,
             },
             b'context': {
                 b'file': newfile,
                 b'hunk': addhunk,
                 b'range': addrange,
                 b'other': addother,
             },
             b'hunk': {
                 b'context': addcontext,
                 b'file': newfile,
                 b'range': addrange,
             },
             b'range': {b'context': addcontext, b'hunk': addhunk},
             b'other': {b'other': addother},
         }
 
     p = parser()
     fp = stringio()
     fp.write(b''.join(originalchunks))
     fp.seek(0)
 
     state = b'context'
     for newstate, data in scanpatch(fp):
         try:
             p.transitions[state][newstate](p, data)
         except KeyError:
             raise PatchParseError(
                 b'unhandled transition: %s -> %s' % (state, newstate)
             )
         state = newstate
     del fp
     return p.finished()
 
 
 def pathtransform(path, strip, prefix):
     """turn a path from a patch into a path suitable for the repository
 
     prefix, if not empty, is expected to be normalized with a / at the end.
 
     Returns (stripped components, path in repository).
 
     >>> pathtransform(b'a/b/c', 0, b'')
     ('', 'a/b/c')
     >>> pathtransform(b'   a/b/c   ', 0, b'')
     ('', '   a/b/c')
     >>> pathtransform(b'   a/b/c   ', 2, b'')
     ('a/b/', 'c')
     >>> pathtransform(b'a/b/c', 0, b'd/e/')
     ('', 'd/e/a/b/c')
     >>> pathtransform(b'   a//b/c   ', 2, b'd/e/')
     ('a//b/', 'd/e/c')
     >>> pathtransform(b'a/b/c', 3, b'')
     Traceback (most recent call last):
     PatchApplicationError: unable to strip away 1 of 3 dirs from a/b/c
     """
     pathlen = len(path)
     i = 0
     if strip == 0:
         return b'', prefix + path.rstrip()
     count = strip
     while count > 0:
         i = path.find(b'/', i)
         if i == -1:
             raise PatchApplicationError(
                 _(b"unable to strip away %d of %d dirs from %s")
                 % (count, strip, path)
             )
         i += 1
         # consume '//' in the path
         while i < pathlen - 1 and path[i : i + 1] == b'/':
             i += 1
         count -= 1
     return path[:i].lstrip(), prefix + path[i:].rstrip()
 
 
 def makepatchmeta(backend, afile_orig, bfile_orig, hunk, strip, prefix):
     nulla = afile_orig == b"/dev/null"
     nullb = bfile_orig == b"/dev/null"
     create = nulla and hunk.starta == 0 and hunk.lena == 0
     remove = nullb and hunk.startb == 0 and hunk.lenb == 0
     abase, afile = pathtransform(afile_orig, strip, prefix)
     gooda = not nulla and backend.exists(afile)
     bbase, bfile = pathtransform(bfile_orig, strip, prefix)
     if afile == bfile:
         goodb = gooda
     else:
         goodb = not nullb and backend.exists(bfile)
     missing = not goodb and not gooda and not create
 
     # some diff programs apparently produce patches where the afile is
     # not /dev/null, but afile starts with bfile
     abasedir = afile[: afile.rfind(b'/') + 1]
     bbasedir = bfile[: bfile.rfind(b'/') + 1]
     if (
         missing
         and abasedir == bbasedir
         and afile.startswith(bfile)
         and hunk.starta == 0
         and hunk.lena == 0
     ):
         create = True
         missing = False
 
     # If afile is "a/b/foo" and bfile is "a/b/foo.orig" we assume the
     # diff is between a file and its backup. In this case, the original
     # file should be patched (see original mpatch code).
     isbackup = abase == bbase and bfile.startswith(afile)
     fname = None
     if not missing:
         if gooda and goodb:
             if isbackup:
                 fname = afile
             else:
                 fname = bfile
         elif gooda:
             fname = afile
 
     if not fname:
         if not nullb:
             if isbackup:
                 fname = afile
             else:
                 fname = bfile
         elif not nulla:
             fname = afile
         else:
             raise PatchParseError(_(b"undefined source and destination files"))
 
     gp = patchmeta(fname)
     if create:
         gp.op = b'ADD'
     elif remove:
         gp.op = b'DELETE'
     return gp
 
 
 def scanpatch(fp):
     """like patch.iterhunks, but yield different events
 
     - ('file',    [header_lines + fromfile + tofile])
     - ('context', [context_lines])
     - ('hunk',    [hunk_lines])
     - ('range',   (-start,len, +start,len, proc))
     """
     lines_re = re.compile(br'@@ -(\d+),(\d+) \+(\d+),(\d+) @@\s*(.*)')
     lr = linereader(fp)
 
     def scanwhile(first, p):
         """scan lr while predicate holds"""
         lines = [first]
         for line in iter(lr.readline, b''):
             if p(line):
                 lines.append(line)
             else:
                 lr.push(line)
                 break
         return lines
 
     for line in iter(lr.readline, b''):
         if line.startswith(b'diff --git a/') or line.startswith(b'diff -r '):
 
             def notheader(line):
                 s = line.split(None, 1)
                 return not s or s[0] not in (b'---', b'diff')
 
             header = scanwhile(line, notheader)
             fromfile = lr.readline()
             if fromfile.startswith(b'---'):
                 tofile = lr.readline()
                 header += [fromfile, tofile]
             else:
                 lr.push(fromfile)
             yield b'file', header
         elif line.startswith(b' '):
             cs = (b' ', b'\\')
             yield b'context', scanwhile(line, lambda l: l.startswith(cs))
         elif line.startswith((b'-', b'+')):
             cs = (b'-', b'+', b'\\')
             yield b'hunk', scanwhile(line, lambda l: l.startswith(cs))
         else:
             m = lines_re.match(line)
             if m:
                 yield b'range', m.groups()
             else:
                 yield b'other', line
 
 
 def scangitpatch(lr, firstline):
     """
     Git patches can emit:
     - rename a to b
     - change b
     - copy a to c
     - change c
 
     We cannot apply this sequence as-is, the renamed 'a' could not be
     found for it would have been renamed already. And we cannot copy
     from 'b' instead because 'b' would have been changed already. So
     we scan the git patch for copy and rename commands so we can
     perform the copies ahead of time.
     """
     pos = 0
     try:
         pos = lr.fp.tell()
         fp = lr.fp
     except IOError:
         fp = stringio(lr.fp.read())
     gitlr = linereader(fp)
     gitlr.push(firstline)
     gitpatches = readgitpatch(gitlr)
     fp.seek(pos)
     return gitpatches
 
 
 def iterhunks(fp):
     """Read a patch and yield the following events:
     - ("file", afile, bfile, firsthunk): select a new target file.
     - ("hunk", hunk): a new hunk is ready to be applied, follows a
     "file" event.
     - ("git", gitchanges): current diff is in git format, gitchanges
     maps filenames to gitpatch records. Unique event.
     """
     afile = b""
     bfile = b""
     state = None
     hunknum = 0
     emitfile = newfile = False
     gitpatches = None
 
     # our states
     BFILE = 1
     context = None
     lr = linereader(fp)
 
     for x in iter(lr.readline, b''):
         if state == BFILE and (
             (not context and x.startswith(b'@'))
             or (context is not False and x.startswith(b'***************'))
             or x.startswith(b'GIT binary patch')
         ):
             gp = None
             if gitpatches and gitpatches[-1].ispatching(afile, bfile):
                 gp = gitpatches.pop()
             if x.startswith(b'GIT binary patch'):
                 h = binhunk(lr, gp.path)
             else:
                 if context is None and x.startswith(b'***************'):
                     context = True
                 h = hunk(x, hunknum + 1, lr, context)
             hunknum += 1
             if emitfile:
                 emitfile = False
                 yield b'file', (afile, bfile, h, gp and gp.copy() or None)
             yield b'hunk', h
         elif x.startswith(b'diff --git a/'):
             m = gitre.match(x.rstrip(b'\r\n'))
             if not m:
                 continue
             if gitpatches is None:
                 # scan whole input for git metadata
                 gitpatches = scangitpatch(lr, x)
                 yield b'git', [
                     g.copy() for g in gitpatches if g.op in (b'COPY', b'RENAME')
                 ]
                 gitpatches.reverse()
             afile = b'a/' + m.group(1)
             bfile = b'b/' + m.group(2)
             while gitpatches and not gitpatches[-1].ispatching(afile, bfile):
                 gp = gitpatches.pop()
                 yield b'file', (
                     b'a/' + gp.path,
                     b'b/' + gp.path,
                     None,
                     gp.copy(),
                 )
             if not gitpatches:
                 raise PatchParseError(
                     _(b'failed to synchronize metadata for "%s"') % afile[2:]
                 )
             newfile = True
         elif x.startswith(b'---'):
             # check for a unified diff
             l2 = lr.readline()
             if not l2.startswith(b'+++'):
                 lr.push(l2)
                 continue
             newfile = True
             context = False
             afile = parsefilename(x)
             bfile = parsefilename(l2)
         elif x.startswith(b'***'):
             # check for a context diff
             l2 = lr.readline()
             if not l2.startswith(b'---'):
                 lr.push(l2)
                 continue
             l3 = lr.readline()
             lr.push(l3)
             if not l3.startswith(b"***************"):
                 lr.push(l2)
                 continue
             newfile = True
             context = True
             afile = parsefilename(x)
             bfile = parsefilename(l2)
 
         if newfile:
             newfile = False
             emitfile = True
             state = BFILE
             hunknum = 0
 
     while gitpatches:
         gp = gitpatches.pop()
         yield b'file', (b'a/' + gp.path, b'b/' + gp.path, None, gp.copy())
 
 
 def applybindelta(binchunk, data):
     """Apply a binary delta hunk
     The algorithm used is the algorithm from git's patch-delta.c
     """
 
     def deltahead(binchunk):
         i = 0
         for c in pycompat.bytestr(binchunk):
             i += 1
             if not (ord(c) & 0x80):
                 return i
         return i
 
     out = b""
     s = deltahead(binchunk)
     binchunk = binchunk[s:]
     s = deltahead(binchunk)
     binchunk = binchunk[s:]
     i = 0
     while i < len(binchunk):
         cmd = ord(binchunk[i : i + 1])
         i += 1
         if cmd & 0x80:
             offset = 0
             size = 0
             if cmd & 0x01:
                 offset = ord(binchunk[i : i + 1])
                 i += 1
             if cmd & 0x02:
                 offset |= ord(binchunk[i : i + 1]) << 8
                 i += 1
             if cmd & 0x04:
                 offset |= ord(binchunk[i : i + 1]) << 16
                 i += 1
             if cmd & 0x08:
                 offset |= ord(binchunk[i : i + 1]) << 24
                 i += 1
             if cmd & 0x10:
                 size = ord(binchunk[i : i + 1])
                 i += 1
             if cmd & 0x20:
                 size |= ord(binchunk[i : i + 1]) << 8
                 i += 1
             if cmd & 0x40:
                 size |= ord(binchunk[i : i + 1]) << 16
                 i += 1
             if size == 0:
                 size = 0x10000
             offset_end = offset + size
             out += data[offset:offset_end]
         elif cmd != 0:
             offset_end = i + cmd
             out += binchunk[i:offset_end]
             i += cmd
         else:
             raise PatchApplicationError(_(b'unexpected delta opcode 0'))
     return out
 
 
 def applydiff(ui, fp, backend, store, strip=1, prefix=b'', eolmode=b'strict'):
     """Reads a patch from fp and tries to apply it.
 
     Returns 0 for a clean patch, -1 if any rejects were found and 1 if
     there was any fuzz.
 
     If 'eolmode' is 'strict', the patch content and patched file are
     read in binary mode. Otherwise, line endings are ignored when
     patching then normalized according to 'eolmode'.
     """
     return _applydiff(
         ui,
         fp,
         patchfile,
         backend,
         store,
         strip=strip,
         prefix=prefix,
         eolmode=eolmode,
     )
 
 
 def _canonprefix(repo, prefix):
     if prefix:
         prefix = pathutil.canonpath(repo.root, repo.getcwd(), prefix)
         if prefix != b'':
             prefix += b'/'
     return prefix
 
 
 def _applydiff(
     ui, fp, patcher, backend, store, strip=1, prefix=b'', eolmode=b'strict'
 ):
     prefix = _canonprefix(backend.repo, prefix)
 
     def pstrip(p):
         return pathtransform(p, strip - 1, prefix)[1]
 
     rejects = 0
     err = 0
     current_file = None
 
     for state, values in iterhunks(fp):
         if state == b'hunk':
             if not current_file:
                 continue
             ret = current_file.apply(values)
             if ret > 0:
                 err = 1
         elif state == b'file':
             if current_file:
                 rejects += current_file.close()
                 current_file = None
             afile, bfile, first_hunk, gp = values
             if gp:
                 gp.path = pstrip(gp.path)
                 if gp.oldpath:
                     gp.oldpath = pstrip(gp.oldpath)
             else:
                 gp = makepatchmeta(
                     backend, afile, bfile, first_hunk, strip, prefix
                 )
             if gp.op == b'RENAME':
                 backend.unlink(gp.oldpath)
             if not first_hunk:
                 if gp.op == b'DELETE':
                     backend.unlink(gp.path)
                     continue
                 data, mode = None, None
                 if gp.op in (b'RENAME', b'COPY'):
                     data, mode = store.getfile(gp.oldpath)[:2]
                     if data is None:
                         # This means that the old path does not exist
                         raise PatchApplicationError(
                             _(b"source file '%s' does not exist") % gp.oldpath
                         )
                 if gp.mode:
                     mode = gp.mode
                     if gp.op == b'ADD':
                         # Added files without content have no hunk and
                         # must be created
                         data = b''
                 if data or mode:
                     if gp.op in (b'ADD', b'RENAME', b'COPY') and backend.exists(
                         gp.path
                     ):
                         raise PatchApplicationError(
                             _(
                                 b"cannot create %s: destination "
                                 b"already exists"
                             )
                             % gp.path
                         )
                     backend.setfile(gp.path, data, mode, gp.oldpath)
                 continue
             try:
                 current_file = patcher(ui, gp, backend, store, eolmode=eolmode)
             except PatchError as inst:
                 ui.warn(stringutil.forcebytestr(inst) + b'\n')
                 current_file = None
                 rejects += 1
                 continue
         elif state == b'git':
             for gp in values:
                 path = pstrip(gp.oldpath)
                 data, mode = backend.getfile(path)
                 if data is None:
                     # The error ignored here will trigger a getfile()
                     # error in a place more appropriate for error
                     # handling, and will not interrupt the patching
                     # process.
                     pass
                 else:
                     store.setfile(path, data, mode)
         else:
             raise error.Abort(_(b'unsupported parser state: %s') % state)
 
     if current_file:
         rejects += current_file.close()
 
     if rejects:
         return -1
     return err
 
 
 def _externalpatch(ui, repo, patcher, patchname, strip, files, similarity):
     """use <patcher> to apply <patchname> to the working directory.
     returns whether patch was applied with fuzz factor."""
 
     fuzz = False
     args = []
     cwd = repo.root
     if cwd:
         args.append(b'-d %s' % procutil.shellquote(cwd))
     cmd = b'%s %s -p%d < %s' % (
         patcher,
         b' '.join(args),
         strip,
         procutil.shellquote(patchname),
     )
     ui.debug(b'Using external patch tool: %s\n' % cmd)
     fp = procutil.popen(cmd, b'rb')
     try:
         for line in fp:
             line = line.rstrip()
             ui.note(line + b'\n')
             if line.startswith(b'patching file '):
                 pf = util.parsepatchoutput(line)
                 printed_file = False
                 files.add(pf)
             elif line.find(b'with fuzz') >= 0:
                 fuzz = True
                 if not printed_file:
                     ui.warn(pf + b'\n')
                     printed_file = True
                 ui.warn(line + b'\n')
             elif line.find(b'saving rejects to file') >= 0:
                 ui.warn(line + b'\n')
             elif line.find(b'FAILED') >= 0:
                 if not printed_file:
                     ui.warn(pf + b'\n')
                     printed_file = True
                 ui.warn(line + b'\n')
     finally:
         if files:
             scmutil.marktouched(repo, files, similarity)
     code = fp.close()
     if code:
         raise PatchApplicationError(
             _(b"patch command failed: %s") % procutil.explainexit(code)
         )
     return fuzz
 
 
 def patchbackend(
     ui, backend, patchobj, strip, prefix, files=None, eolmode=b'strict'
 ):
     if files is None:
         files = set()
     if eolmode is None:
         eolmode = ui.config(b'patch', b'eol')
     if eolmode.lower() not in eolmodes:
         raise error.Abort(_(b'unsupported line endings type: %s') % eolmode)
     eolmode = eolmode.lower()
 
     store = filestore()
     try:
         fp = open(patchobj, b'rb')
     except TypeError:
         fp = patchobj
     try:
         ret = applydiff(
             ui, fp, backend, store, strip=strip, prefix=prefix, eolmode=eolmode
         )
     finally:
         if fp != patchobj:
             fp.close()
         files.update(backend.close())
         store.close()
     if ret < 0:
         raise PatchApplicationError(_(b'patch failed to apply'))
     return ret > 0
 
 
 def internalpatch(
     ui,
     repo,
     patchobj,
     strip,
     prefix=b'',
     files=None,
     eolmode=b'strict',
     similarity=0,
 ):
     """use builtin patch to apply <patchobj> to the working directory.
     returns whether patch was applied with fuzz factor."""
     backend = workingbackend(ui, repo, similarity)
     return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode)
 
 
 def patchrepo(
     ui, repo, ctx, store, patchobj, strip, prefix, files=None, eolmode=b'strict'
 ):
     backend = repobackend(ui, repo, ctx, store)
     return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode)
 
 
 def patch(
     ui,
     repo,
     patchname,
     strip=1,
     prefix=b'',
     files=None,
     eolmode=b'strict',
     similarity=0,
 ):
     """Apply <patchname> to the working directory.
 
     'eolmode' specifies how end of lines should be handled. It can be:
     - 'strict': inputs are read in binary mode, EOLs are preserved
     - 'crlf': EOLs are ignored when patching and reset to CRLF
     - 'lf': EOLs are ignored when patching and reset to LF
     - None: get it from user settings, default to 'strict'
     'eolmode' is ignored when using an external patcher program.
 
     Returns whether patch was applied with fuzz factor.
     """
     patcher = ui.config(b'ui', b'patch')
     if files is None:
         files = set()
     if patcher:
         return _externalpatch(
             ui, repo, patcher, patchname, strip, files, similarity
         )
     return internalpatch(
         ui, repo, patchname, strip, prefix, files, eolmode, similarity
     )
 
 
 def changedfiles(ui, repo, patchpath, strip=1, prefix=b''):
     backend = fsbackend(ui, repo.root)
     prefix = _canonprefix(repo, prefix)
     with open(patchpath, b'rb') as fp:
         changed = set()
         for state, values in iterhunks(fp):
             if state == b'file':
                 afile, bfile, first_hunk, gp = values
                 if gp:
                     gp.path = pathtransform(gp.path, strip - 1, prefix)[1]
                     if gp.oldpath:
                         gp.oldpath = pathtransform(
                             gp.oldpath, strip - 1, prefix
                         )[1]
                 else:
                     gp = makepatchmeta(
                         backend, afile, bfile, first_hunk, strip, prefix
                     )
                 changed.add(gp.path)
                 if gp.op == b'RENAME':
                     changed.add(gp.oldpath)
             elif state not in (b'hunk', b'git'):
                 raise error.Abort(_(b'unsupported parser state: %s') % state)
         return changed
 
 
 class GitDiffRequired(Exception):
     pass
 
 
 diffopts = diffutil.diffallopts
 diffallopts = diffutil.diffallopts
 difffeatureopts = diffutil.difffeatureopts
 
 
 def diff(
     repo,
     node1=None,
     node2=None,
     match=None,
     changes=None,
     opts=None,
     losedatafn=None,
     pathfn=None,
     copy=None,
     copysourcematch=None,
     hunksfilterfn=None,
 ):
     """yields diff of changes to files between two nodes, or node and
     working directory.
 
     if node1 is None, use first dirstate parent instead.
     if node2 is None, compare node1 with working directory.
 
     losedatafn(**kwarg) is a callable run when opts.upgrade=True and
     every time some change cannot be represented with the current
     patch format. Return False to upgrade to git patch format, True to
     accept the loss or raise an exception to abort the diff. It is
     called with the name of current file being diffed as 'fn'. If set
     to None, patches will always be upgraded to git format when
     necessary.
 
     prefix is a filename prefix that is prepended to all filenames on
     display (used for subrepos).
 
     relroot, if not empty, must be normalized with a trailing /. Any match
     patterns that fall outside it will be ignored.
 
     copy, if not empty, should contain mappings {dst@y: src@x} of copy
     information.
 
     if copysourcematch is not None, then copy sources will be filtered by this
     matcher
 
     hunksfilterfn, if not None, should be a function taking a filectx and
     hunks generator that may yield filtered hunks.
     """
     if not node1 and not node2:
         node1 = repo.dirstate.p1()
 
     ctx1 = repo[node1]
     ctx2 = repo[node2]
 
     for fctx1, fctx2, hdr, hunks in diffhunks(
         repo,
         ctx1=ctx1,
         ctx2=ctx2,
         match=match,
         changes=changes,
         opts=opts,
         losedatafn=losedatafn,
         pathfn=pathfn,
         copy=copy,
         copysourcematch=copysourcematch,
     ):
         if hunksfilterfn is not None:
             # If the file has been removed, fctx2 is None; but this should
             # not occur here since we catch removed files early in
             # logcmdutil.getlinerangerevs() for 'hg log -L'.
             assert (
                 fctx2 is not None
             ), b'fctx2 unexpectly None in diff hunks filtering'
             hunks = hunksfilterfn(fctx2, hunks)
         text = b''.join(b''.join(hlines) for hrange, hlines in hunks)
         if hdr and (text or len(hdr) > 1):
             yield b'\n'.join(hdr) + b'\n'
         if text:
             yield text
 
 
 def diffhunks(
     repo,
     ctx1,
     ctx2,
     match=None,
     changes=None,
     opts=None,
     losedatafn=None,
     pathfn=None,
     copy=None,
     copysourcematch=None,
 ):
     """Yield diff of changes to files in the form of (`header`, `hunks`) tuples
     where `header` is a list of diff headers and `hunks` is an iterable of
     (`hunkrange`, `hunklines`) tuples.
 
     See diff() for the meaning of parameters.
     """
 
     if opts is None:
         opts = mdiff.defaultopts
 
     def lrugetfilectx():
         cache = {}
         order = collections.deque()
 
         def getfilectx(f, ctx):
             fctx = ctx.filectx(f, filelog=cache.get(f))
             if f not in cache:
                 if len(cache) > 20:
                     del cache[order.popleft()]
                 cache[f] = fctx.filelog()
             else:
                 order.remove(f)
             order.append(f)
             return fctx
 
         return getfilectx
 
     getfilectx = lrugetfilectx()
 
     if not changes:
         changes = ctx1.status(ctx2, match=match)
     if isinstance(changes, list):
         modified, added, removed = changes[:3]
     else:
         modified, added, removed = (
             changes.modified,
             changes.added,
             changes.removed,
         )
 
     if not modified and not added and not removed:
         return []
 
     if repo.ui.debugflag:
         hexfunc = hex
     else:
         hexfunc = short
     revs = [hexfunc(node) for node in [ctx1.node(), ctx2.node()] if node]
 
     if copy is None:
         copy = {}
         if opts.git or opts.upgrade:
             copy = copies.pathcopies(ctx1, ctx2, match=match)
 
     if copysourcematch:
         # filter out copies where source side isn't inside the matcher
         # (copies.pathcopies() already filtered out the destination)
         copy = {dst: src for dst, src in copy.items() if copysourcematch(src)}
 
     modifiedset = set(modified)
     addedset = set(added)
     removedset = set(removed)
     for f in modified:
         if f not in ctx1:
             # Fix up added, since merged-in additions appear as
             # modifications during merges
             modifiedset.remove(f)
             addedset.add(f)
     for f in removed:
         if f not in ctx1:
             # Merged-in additions that are then removed are reported as removed.
             # They are not in ctx1, so We don't want to show them in the diff.
             removedset.remove(f)
     modified = sorted(modifiedset)
     added = sorted(addedset)
     removed = sorted(removedset)
     for dst, src in list(copy.items()):
         if src not in ctx1:
             # Files merged in during a merge and then copied/renamed are
             # reported as copies. We want to show them in the diff as additions.
             del copy[dst]
 
     prefetchmatch = scmutil.matchfiles(
         repo, list(modifiedset | addedset | removedset)
     )
     revmatches = [
         (ctx1.rev(), prefetchmatch),
         (ctx2.rev(), prefetchmatch),
     ]
     scmutil.prefetchfiles(repo, revmatches)
 
     def difffn(opts, losedata):
         return trydiff(
             repo,
             revs,
             ctx1,
             ctx2,
             modified,
             added,
             removed,
             copy,
             getfilectx,
             opts,
             losedata,
             pathfn,
         )
 
     if opts.upgrade and not opts.git:
         try:
 
             def losedata(fn):
                 if not losedatafn or not losedatafn(fn=fn):
                     raise GitDiffRequired
 
             # Buffer the whole output until we are sure it can be generated
             return list(difffn(opts.copy(git=False), losedata))
         except GitDiffRequired:
             return difffn(opts.copy(git=True), None)
     else:
         return difffn(opts, None)
 
 
 def diffsinglehunk(hunklines):
     """yield tokens for a list of lines in a single hunk"""
     for line in hunklines:
         # chomp
         chompline = line.rstrip(b'\r\n')
         # highlight tabs and trailing whitespace
         stripline = chompline.rstrip()
         if line.startswith(b'-'):
             label = b'diff.deleted'
         elif line.startswith(b'+'):
             label = b'diff.inserted'
         else:
             raise error.ProgrammingError(b'unexpected hunk line: %s' % line)
         for token in tabsplitter.findall(stripline):
             if token.startswith(b'\t'):
                 yield (token, b'diff.tab')
             else:
                 yield (token, label)
 
         if chompline != stripline:
             yield (chompline[len(stripline) :], b'diff.trailingwhitespace')
         if chompline != line:
             yield (line[len(chompline) :], b'')
 
 
 def diffsinglehunkinline(hunklines):
     """yield tokens for a list of lines in a single hunk, with inline colors"""
     # prepare deleted, and inserted content
     a = bytearray()
     b = bytearray()
     for line in hunklines:
         if line[0:1] == b'-':
             a += line[1:]
         elif line[0:1] == b'+':
             b += line[1:]
         else:
             raise error.ProgrammingError(b'unexpected hunk line: %s' % line)
     # fast path: if either side is empty, use diffsinglehunk
     if not a or not b:
         for t in diffsinglehunk(hunklines):
             yield t
         return
     # re-split the content into words
     al = wordsplitter.findall(bytes(a))
     bl = wordsplitter.findall(bytes(b))
     # re-arrange the words to lines since the diff algorithm is line-based
     aln = [s if s == b'\n' else s + b'\n' for s in al]
     bln = [s if s == b'\n' else s + b'\n' for s in bl]
     an = b''.join(aln)
     bn = b''.join(bln)
     # run the diff algorithm, prepare atokens and btokens
     atokens = []
     btokens = []
     blocks = mdiff.allblocks(an, bn, lines1=aln, lines2=bln)
     for (a1, a2, b1, b2), btype in blocks:
         changed = btype == b'!'
         for token in mdiff.splitnewlines(b''.join(al[a1:a2])):
             atokens.append((changed, token))
         for token in mdiff.splitnewlines(b''.join(bl[b1:b2])):
             btokens.append((changed, token))
 
     # yield deleted tokens, then inserted ones
     for prefix, label, tokens in [
         (b'-', b'diff.deleted', atokens),
         (b'+', b'diff.inserted', btokens),
     ]:
         nextisnewline = True
         for changed, token in tokens:
             if nextisnewline:
                 yield (prefix, label)
                 nextisnewline = False
             # special handling line end
             isendofline = token.endswith(b'\n')
             if isendofline:
                 chomp = token[:-1]  # chomp
                 if chomp.endswith(b'\r'):
                     chomp = chomp[:-1]
                 endofline = token[len(chomp) :]
                 token = chomp.rstrip()  # detect spaces at the end
                 endspaces = chomp[len(token) :]
             # scan tabs
             for maybetab in tabsplitter.findall(token):
                 if b'\t' == maybetab[0:1]:
                     currentlabel = b'diff.tab'
                 else:
                     if changed:
                         currentlabel = label + b'.changed'
                     else:
                         currentlabel = label + b'.unchanged'
                 yield (maybetab, currentlabel)
             if isendofline:
                 if endspaces:
                     yield (endspaces, b'diff.trailingwhitespace')
                 yield (endofline, b'')
                 nextisnewline = True
 
 
 def difflabel(func, *args, **kw):
     '''yields 2-tuples of (output, label) based on the output of func()'''
     if kw.get('opts') and kw['opts'].worddiff:
         dodiffhunk = diffsinglehunkinline
     else:
         dodiffhunk = diffsinglehunk
     headprefixes = [
         (b'diff', b'diff.diffline'),
         (b'copy', b'diff.extended'),
         (b'rename', b'diff.extended'),
         (b'old', b'diff.extended'),
         (b'new', b'diff.extended'),
         (b'deleted', b'diff.extended'),
         (b'index', b'diff.extended'),
         (b'similarity', b'diff.extended'),
         (b'---', b'diff.file_a'),
         (b'+++', b'diff.file_b'),
     ]
     textprefixes = [
         (b'@', b'diff.hunk'),
         # - and + are handled by diffsinglehunk
     ]
     head = False
 
     # buffers a hunk, i.e. adjacent "-", "+" lines without other changes.
     hunkbuffer = []
 
     def consumehunkbuffer():
         if hunkbuffer:
             for token in dodiffhunk(hunkbuffer):
                 yield token
             hunkbuffer[:] = []
 
     for chunk in func(*args, **kw):
         lines = chunk.split(b'\n')
         linecount = len(lines)
         for i, line in enumerate(lines):
             if head:
                 if line.startswith(b'@'):
                     head = False
             else:
                 if line and not line.startswith(
                     (b' ', b'+', b'-', b'@', b'\\')
                 ):
                     head = True
             diffline = False
             if not head and line and line.startswith((b'+', b'-')):
                 diffline = True
 
             prefixes = textprefixes
             if head:
                 prefixes = headprefixes
             if diffline:
                 # buffered
                 bufferedline = line
                 if i + 1 < linecount:
                     bufferedline += b"\n"
                 hunkbuffer.append(bufferedline)
             else:
                 # unbuffered
                 for token in consumehunkbuffer():
                     yield token
                 stripline = line.rstrip()
                 for prefix, label in prefixes:
                     if stripline.startswith(prefix):
                         yield (stripline, label)
                         if line != stripline:
                             yield (
                                 line[len(stripline) :],
                                 b'diff.trailingwhitespace',
                             )
                         break
                 else:
                     yield (line, b'')
                 if i + 1 < linecount:
                     yield (b'\n', b'')
         for token in consumehunkbuffer():
             yield token
 
 
 def diffui(*args, **kw):
     '''like diff(), but yields 2-tuples of (output, label) for ui.write()'''
     return difflabel(diff, *args, **kw)
 
 
 def _filepairs(modified, added, removed, copy, opts):
     """generates tuples (f1, f2, copyop), where f1 is the name of the file
     before and f2 is the the name after. For added files, f1 will be None,
     and for removed files, f2 will be None. copyop may be set to None, 'copy'
     or 'rename' (the latter two only if opts.git is set)."""
     gone = set()
 
     copyto = {v: k for k, v in copy.items()}
 
     addedset, removedset = set(added), set(removed)
 
     for f in sorted(modified + added + removed):
         copyop = None
         f1, f2 = f, f
         if f in addedset:
             f1 = None
             if f in copy:
                 if opts.git:
                     f1 = copy[f]
                     if f1 in removedset and f1 not in gone:
                         copyop = b'rename'
                         gone.add(f1)
                     else:
                         copyop = b'copy'
         elif f in removedset:
             f2 = None
             if opts.git:
                 # have we already reported a copy above?
                 if (
                     f in copyto
                     and copyto[f] in addedset
                     and copy[copyto[f]] == f
                 ):
                     continue
         yield f1, f2, copyop
 
 
 def _gitindex(text):
     if not text:
         text = b""
     l = len(text)
     s = hashutil.sha1(b'blob %d\0' % l)
     s.update(text)
     return hex(s.digest())
 
 
 _gitmode = {b'l': b'120000', b'x': b'100755', b'': b'100644'}
 
 
 def trydiff(
     repo,
     revs,
     ctx1,
     ctx2,
     modified,
     added,
     removed,
     copy,
     getfilectx,
     opts,
     losedatafn,
     pathfn,
 ):
     """given input data, generate a diff and yield it in blocks
 
     If generating a diff would lose data like flags or binary data and
     losedatafn is not None, it will be called.
 
     pathfn is applied to every path in the diff output.
     """
 
     if opts.noprefix:
         aprefix = bprefix = b''
     else:
         aprefix = b'a/'
         bprefix = b'b/'
 
     def diffline(f, revs):
         revinfo = b' '.join([b"-r %s" % rev for rev in revs])
         return b'diff %s %s' % (revinfo, f)
 
     def isempty(fctx):
         return fctx is None or fctx.size() == 0
 
     date1 = dateutil.datestr(ctx1.date())
     date2 = dateutil.datestr(ctx2.date())
 
     if not pathfn:
         pathfn = lambda f: f
 
     for f1, f2, copyop in _filepairs(modified, added, removed, copy, opts):
         content1 = None
         content2 = None
         fctx1 = None
         fctx2 = None
         flag1 = None
         flag2 = None
         if f1:
             fctx1 = getfilectx(f1, ctx1)
             if opts.git or losedatafn:
                 flag1 = ctx1.flags(f1)
         if f2:
             fctx2 = getfilectx(f2, ctx2)
             if opts.git or losedatafn:
                 flag2 = ctx2.flags(f2)
         # if binary is True, output "summary" or "base85", but not "text diff"
         if opts.text:
             binary = False
         else:
             binary = any(f.isbinary() for f in [fctx1, fctx2] if f is not None)
 
         if losedatafn and not opts.git:
             if (
                 binary
                 or
                 # copy/rename
                 f2 in copy
                 or
                 # empty file creation
                 (not f1 and isempty(fctx2))
                 or
                 # empty file deletion
                 (isempty(fctx1) and not f2)
                 or
                 # create with flags
                 (not f1 and flag2)
                 or
                 # change flags
                 (f1 and f2 and flag1 != flag2)
             ):
                 losedatafn(f2 or f1)
 
         path1 = pathfn(f1 or f2)
         path2 = pathfn(f2 or f1)
         header = []
         if opts.git:
             header.append(
                 b'diff --git %s%s %s%s' % (aprefix, path1, bprefix, path2)
             )
             if not f1:  # added
                 header.append(b'new file mode %s' % _gitmode[flag2])
             elif not f2:  # removed
                 header.append(b'deleted file mode %s' % _gitmode[flag1])
             else:  # modified/copied/renamed
                 mode1, mode2 = _gitmode[flag1], _gitmode[flag2]
                 if mode1 != mode2:
                     header.append(b'old mode %s' % mode1)
                     header.append(b'new mode %s' % mode2)
                 if copyop is not None:
                     if opts.showsimilarity:
                         sim = similar.score(ctx1[path1], ctx2[path2]) * 100
                         header.append(b'similarity index %d%%' % sim)
                     header.append(b'%s from %s' % (copyop, path1))
                     header.append(b'%s to %s' % (copyop, path2))
         elif revs:
             header.append(diffline(path1, revs))
 
         #  fctx.is  | diffopts                | what to   | is fctx.data()
         #  binary() | text nobinary git index | output?   | outputted?
         # ------------------------------------|----------------------------
         #  yes      | no   no       no  *     | summary   | no
         #  yes      | no   no       yes *     | base85    | yes
         #  yes      | no   yes      no  *     | summary   | no
         #  yes      | no   yes      yes 0     | summary   | no
         #  yes      | no   yes      yes >0    | summary   | semi [1]
         #  yes      | yes  *        *   *     | text diff | yes
         #  no       | *    *        *   *     | text diff | yes
         # [1]: hash(fctx.data()) is outputted. so fctx.data() cannot be faked
         if binary and (
             not opts.git or (opts.git and opts.nobinary and not opts.index)
         ):
             # fast path: no binary content will be displayed, content1 and
             # content2 are only used for equivalent test. cmp() could have a
             # fast path.
             if fctx1 is not None:
                 content1 = b'\0'
             if fctx2 is not None:
                 if fctx1 is not None and not fctx1.cmp(fctx2):
                     content2 = b'\0'  # not different
                 else:
                     content2 = b'\0\0'
         else:
             # normal path: load contents
             if fctx1 is not None:
                 content1 = fctx1.data()
             if fctx2 is not None:
                 content2 = fctx2.data()
 
         data1 = (ctx1, fctx1, path1, flag1, content1, date1)
         data2 = (ctx2, fctx2, path2, flag2, content2, date2)
         yield diffcontent(data1, data2, header, binary, opts)
 
 
 def diffcontent(data1, data2, header, binary, opts):
     """diffs two versions of a file.
 
     data1 and data2 are tuples containg:
 
         * ctx: changeset for the file
         * fctx: file context for that file
         * path1: name of the file
         * flag: flags of the file
         * content: full content of the file (can be null in case of binary)
         * date: date of the changeset
 
     header: the patch header
     binary: whether the any of the version of file is binary or not
     opts:   user passed options
 
     It exists as a separate function so that extensions like extdiff can wrap
     it and use the file content directly.
     """
 
     ctx1, fctx1, path1, flag1, content1, date1 = data1
     ctx2, fctx2, path2, flag2, content2, date2 = data2
     index1 = _gitindex(content1) if path1 in ctx1 else sha1nodeconstants.nullhex
     index2 = _gitindex(content2) if path2 in ctx2 else sha1nodeconstants.nullhex
     if binary and opts.git and not opts.nobinary:
         text = mdiff.b85diff(content1, content2)
         if text:
             header.append(b'index %s..%s' % (index1, index2))
         hunks = ((None, [text]),)
     else:
         if opts.git and opts.index > 0:
             flag = flag1
             if flag is None:
                 flag = flag2
             header.append(
                 b'index %s..%s %s'
                 % (
                     index1[0 : opts.index],
                     index2[0 : opts.index],
                     _gitmode[flag],
                 )
             )
 
         uheaders, hunks = mdiff.unidiff(
             content1,
             date1,
             content2,
             date2,
             path1,
             path2,
             binary=binary,
             opts=opts,
         )
         header.extend(uheaders)
     return fctx1, fctx2, header, hunks
 
 
 def diffstatsum(stats):
     maxfile, maxtotal, addtotal, removetotal, binary = 0, 0, 0, 0, False
     for f, a, r, b in stats:
         maxfile = max(maxfile, encoding.colwidth(f))
         maxtotal = max(maxtotal, a + r)
         addtotal += a
         removetotal += r
         binary = binary or b
 
     return maxfile, maxtotal, addtotal, removetotal, binary
 
 
 def diffstatdata(lines):
     diffre = re.compile(br'^diff .*-r [a-z0-9]+\s(.*)$')
 
     results = []
     filename, adds, removes, isbinary = None, 0, 0, False
 
     def addresult():
         if filename:
             results.append((filename, adds, removes, isbinary))
 
     # inheader is used to track if a line is in the
     # header portion of the diff.  This helps properly account
     # for lines that start with '--' or '++'
     inheader = False
 
     for line in lines:
         if line.startswith(b'diff'):
             addresult()
             # starting a new file diff
             # set numbers to 0 and reset inheader
             inheader = True
             adds, removes, isbinary = 0, 0, False
             if line.startswith(b'diff --git a/'):
                 filename = gitre.search(line).group(2)
             elif line.startswith(b'diff -r'):
                 # format: "diff -r ... -r ... filename"
                 filename = diffre.search(line).group(1)
         elif line.startswith(b'@@'):
             inheader = False
         elif line.startswith(b'+') and not inheader:
             adds += 1
         elif line.startswith(b'-') and not inheader:
             removes += 1
         elif line.startswith(b'GIT binary patch') or line.startswith(
             b'Binary file'
         ):
             isbinary = True
         elif line.startswith(b'rename from'):
             filename = line[12:]
         elif line.startswith(b'rename to'):
             filename += b' => %s' % line[10:]
     addresult()
     return results
 
 
 def diffstat(lines, width=80):
     output = []
     stats = diffstatdata(lines)
     maxname, maxtotal, totaladds, totalremoves, hasbinary = diffstatsum(stats)
 
     countwidth = len(str(maxtotal))
     if hasbinary and countwidth < 3:
         countwidth = 3
     graphwidth = width - countwidth - maxname - 6
     if graphwidth < 10:
         graphwidth = 10
 
     def scale(i):
         if maxtotal <= graphwidth:
             return i
         # If diffstat runs out of room it doesn't print anything,
         # which isn't very useful, so always print at least one + or -
         # if there were at least some changes.
         return max(i * graphwidth // maxtotal, int(bool(i)))
 
     for filename, adds, removes, isbinary in stats:
         if isbinary:
             count = b'Bin'
         else:
             count = b'%d' % (adds + removes)
         pluses = b'+' * scale(adds)
         minuses = b'-' * scale(removes)
         output.append(
             b' %s%s |  %*s %s%s\n'
             % (
                 filename,
                 b' ' * (maxname - encoding.colwidth(filename)),
                 countwidth,
                 count,
                 pluses,
                 minuses,
             )
         )
 
     if stats:
         output.append(
             _(b' %d files changed, %d insertions(+), %d deletions(-)\n')
             % (len(stats), totaladds, totalremoves)
         )
 
     return b''.join(output)
 
 
 def diffstatui(*args, **kw):
     """like diffstat(), but yields 2-tuples of (output, label) for
     ui.write()
     """
 
     for line in diffstat(*args, **kw).splitlines():
         if line and line[-1] in b'+-':
             name, graph = line.rsplit(b' ', 1)
             yield (name + b' ', b'')
             m = re.search(br'\++', graph)
             if m:
                 yield (m.group(0), b'diffstat.inserted')
             m = re.search(br'-+', graph)
             if m:
                 yield (m.group(0), b'diffstat.deleted')
         else:
             yield (line, b'')
         yield (b'\n', b'')

mercurial/posix.py

@@ -1,811 +1,812
 # posix.py - Posix utility function implementations for Mercurial
 #
 #  Copyright 2005-2009 Olivia Mackall <[e-mail]> and others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import errno
 import fcntl
 import getpass
 import grp
 import os
 import pwd
 import re
 import select
 import stat
 import sys
 import tempfile
 import typing
 import unicodedata
 
 from typing import (
     Any,
     AnyStr,
+    Callable,
     Iterable,
     Iterator,
     List,
     Match,
     NoReturn,
     Optional,
     Sequence,
     Tuple,
     Union,
 )
 
 from .i18n import _
 from .pycompat import (
     open,
 )
 from . import (
     encoding,
     error,
     policy,
     pycompat,
 )
 
 osutil = policy.importmod('osutil')
 
 normpath = os.path.normpath
 samestat = os.path.samestat
 abspath = os.path.abspath  # re-exports
 
 try:
     oslink = os.link
 except AttributeError:
     # Some platforms build Python without os.link on systems that are
     # vaguely unix-like but don't have hardlink support. For those
     # poor souls, just say we tried and that it failed so we fall back
     # to copies.
     def oslink(src: bytes, dst: bytes) -> NoReturn:
         raise OSError(
             errno.EINVAL, b'hardlinks not supported: %s to %s' % (src, dst)
         )
 
 
 readlink = os.readlink
 unlink = os.unlink
 rename = os.rename
 removedirs = os.removedirs
 
 if typing.TYPE_CHECKING:
 
     def normpath(path: bytes) -> bytes:
         raise NotImplementedError
 
     def abspath(path: AnyStr) -> AnyStr:
         raise NotImplementedError
 
     def oslink(src: bytes, dst: bytes) -> None:
         raise NotImplementedError
 
     def readlink(path: bytes) -> bytes:
         raise NotImplementedError
 
     def unlink(path: bytes) -> None:
         raise NotImplementedError
 
     def rename(src: bytes, dst: bytes) -> None:
         raise NotImplementedError
 
     def removedirs(name: bytes) -> None:
         raise NotImplementedError
 
 
 expandglobs: bool = False
 
 umask: int = os.umask(0)
 os.umask(umask)
 
 posixfile = open
 
 
 def split(p: bytes) -> Tuple[bytes, bytes]:
     """Same as posixpath.split, but faster
 
     >>> import posixpath
     >>> for f in [b'/absolute/path/to/file',
     ...           b'relative/path/to/file',
     ...           b'file_alone',
     ...           b'path/to/directory/',
     ...           b'/multiple/path//separators',
     ...           b'/file_at_root',
     ...           b'///multiple_leading_separators_at_root',
     ...           b'']:
     ...     assert split(f) == posixpath.split(f), f
     """
     ht = p.rsplit(b'/', 1)
     if len(ht) == 1:
         return b'', p
     nh = ht[0].rstrip(b'/')
     if nh:
         return nh, ht[1]
     return ht[0] + b'/', ht[1]
 
 
 def openhardlinks() -> bool:
     '''return true if it is safe to hold open file handles to hardlinks'''
     return True
 
 
 def nlinks(name: bytes) -> int:
     '''return number of hardlinks for the given file'''
     return os.lstat(name).st_nlink
 
 
 def parsepatchoutput(output_line: bytes) -> bytes:
     """parses the output produced by patch and returns the filename"""
     pf = output_line[14:]
     if pycompat.sysplatform == b'OpenVMS':
         if pf[0] == b'`':
             pf = pf[1:-1]  # Remove the quotes
     else:
         if pf.startswith(b"'") and pf.endswith(b"'") and b" " in pf:
             pf = pf[1:-1]  # Remove the quotes
     return pf
 
 
 def sshargs(
     sshcmd: bytes, host: bytes, user: Optional[bytes], port: Optional[bytes]
 ) -> bytes:
     '''Build argument list for ssh'''
     args = user and (b"%s@%s" % (user, host)) or host
     if b'-' in args[:1]:
         raise error.Abort(
             _(b'illegal ssh hostname or username starting with -: %s') % args
         )
     args = shellquote(args)
     if port:
         args = b'-p %s %s' % (shellquote(port), args)
     return args
 
 
 def isexec(f: bytes) -> bool:
     """check whether a file is executable"""
     return os.lstat(f).st_mode & 0o100 != 0
 
 
 def setflags(f: bytes, l: bool, x: bool) -> None:
     st = os.lstat(f)
     s = st.st_mode
     if l:
         if not stat.S_ISLNK(s):
             # switch file to link
             with open(f, b'rb') as fp:
                 data = fp.read()
             unlink(f)
             try:
                 os.symlink(data, f)
             except OSError:
                 # failed to make a link, rewrite file
                 with open(f, b"wb") as fp:
                     fp.write(data)
 
         # no chmod needed at this point
         return
     if stat.S_ISLNK(s):
         # switch link to file
         data = os.readlink(f)
         unlink(f)
         with open(f, b"wb") as fp:
             fp.write(data)
         s = 0o666 & ~umask  # avoid restatting for chmod
 
     sx = s & 0o100
     if st.st_nlink > 1 and bool(x) != bool(sx):
         # the file is a hardlink, break it
         with open(f, b"rb") as fp:
             data = fp.read()
         unlink(f)
         with open(f, b"wb") as fp:
             fp.write(data)
 
     if x and not sx:
         # Turn on +x for every +r bit when making a file executable
         # and obey umask.
         os.chmod(f, s | (s & 0o444) >> 2 & ~umask)
     elif not x and sx:
         # Turn off all +x bits
         os.chmod(f, s & 0o666)
 
 
 def copymode(
     src: bytes,
     dst: bytes,
     mode: Optional[int] = None,
     enforcewritable: bool = False,
 ) -> None:
     """Copy the file mode from the file at path src to dst.
     If src doesn't exist, we're using mode instead. If mode is None, we're
     using umask."""
     try:
         st_mode = os.lstat(src).st_mode & 0o777
     except FileNotFoundError:
         st_mode = mode
         if st_mode is None:
             st_mode = ~umask
         st_mode &= 0o666
 
     new_mode = st_mode
 
     if enforcewritable:
         new_mode |= stat.S_IWUSR
 
     os.chmod(dst, new_mode)
 
 
 def checkexec(path: bytes) -> bool:
     """
     Check whether the given path is on a filesystem with UNIX-like exec flags
 
     Requires a directory (like /foo/.hg)
     """
 
     # VFAT on some Linux versions can flip mode but it doesn't persist
     # a FS remount. Frequently we can detect it if files are created
     # with exec bit on.
 
     try:
         EXECFLAGS = stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
         basedir = os.path.join(path, b'.hg')
         cachedir = os.path.join(basedir, b'wcache')
         storedir = os.path.join(basedir, b'store')
         if not os.path.exists(cachedir):
             try:
                 # we want to create the 'cache' directory, not the '.hg' one.
                 # Automatically creating '.hg' directory could silently spawn
                 # invalid Mercurial repositories. That seems like a bad idea.
                 os.mkdir(cachedir)
                 if os.path.exists(storedir):
                     copymode(storedir, cachedir)
                 else:
                     copymode(basedir, cachedir)
             except (IOError, OSError):
                 # we other fallback logic triggers
                 pass
         if os.path.isdir(cachedir):
             checkisexec = os.path.join(cachedir, b'checkisexec')
             checknoexec = os.path.join(cachedir, b'checknoexec')
 
             try:
                 m = os.stat(checkisexec).st_mode
             except FileNotFoundError:
                 # checkisexec does not exist - fall through ...
                 pass
             else:
                 # checkisexec exists, check if it actually is exec
                 if m & EXECFLAGS != 0:
                     # ensure checknoexec exists, check it isn't exec
                     try:
                         m = os.stat(checknoexec).st_mode
                     except FileNotFoundError:
                         open(checknoexec, b'w').close()  # might fail
                         m = os.stat(checknoexec).st_mode
                     if m & EXECFLAGS == 0:
                         # check-exec is exec and check-no-exec is not exec
                         return True
                     # checknoexec exists but is exec - delete it
                     unlink(checknoexec)
                 # checkisexec exists but is not exec - delete it
                 unlink(checkisexec)
 
             # check using one file, leave it as checkisexec
             checkdir = cachedir
         else:
             # check directly in path and don't leave checkisexec behind
             checkdir = path
             checkisexec = None
         fh, fn = pycompat.mkstemp(dir=checkdir, prefix=b'hg-checkexec-')
         try:
             os.close(fh)
             m = os.stat(fn).st_mode
             if m & EXECFLAGS == 0:
                 os.chmod(fn, m & 0o777 | EXECFLAGS)
                 if os.stat(fn).st_mode & EXECFLAGS != 0:
                     if checkisexec is not None:
                         os.rename(fn, checkisexec)
                         fn = None
                     return True
         finally:
             if fn is not None:
                 unlink(fn)
     except (IOError, OSError):
         # we don't care, the user probably won't be able to commit anyway
         return False
 
 
 def checklink(path: bytes) -> bool:
     """check whether the given path is on a symlink-capable filesystem"""
     # mktemp is not racy because symlink creation will fail if the
     # file already exists
     while True:
         cachedir = os.path.join(path, b'.hg', b'wcache')
         checklink = os.path.join(cachedir, b'checklink')
         # try fast path, read only
         if os.path.islink(checklink):
             return True
         if os.path.isdir(cachedir):
             checkdir = cachedir
         else:
             checkdir = path
             cachedir = None
         name = tempfile.mktemp(
             dir=pycompat.fsdecode(checkdir), prefix=r'checklink-'
         )
         name = pycompat.fsencode(name)
         try:
             fd = None
             if cachedir is None:
                 fd = pycompat.namedtempfile(
                     dir=checkdir, prefix=b'hg-checklink-'
                 )
                 target = os.path.basename(fd.name)
             else:
                 # create a fixed file to link to; doesn't matter if it
                 # already exists.
                 target = b'checklink-target'
                 try:
                     fullpath = os.path.join(cachedir, target)
                     open(fullpath, b'w').close()
                 except PermissionError:
                     # If we can't write to cachedir, just pretend
                     # that the fs is readonly and by association
                     # that the fs won't support symlinks. This
                     # seems like the least dangerous way to avoid
                     # data loss.
                     return False
             try:
                 os.symlink(target, name)
                 if cachedir is None:
                     unlink(name)
                 else:
                     try:
                         os.rename(name, checklink)
                     except OSError:
                         unlink(name)
                 return True
             except FileExistsError:
                 # link creation might race, try again
                 continue
             finally:
                 if fd is not None:
                     fd.close()
         except AttributeError:
             return False
         except OSError as inst:
             # sshfs might report failure while successfully creating the link
             if inst.errno == errno.EIO and os.path.exists(name):
                 unlink(name)
             return False
 
 
 def checkosfilename(path: bytes) -> Optional[bytes]:
     """Check that the base-relative path is a valid filename on this platform.
     Returns None if the path is ok, or a UI string describing the problem."""
     return None  # on posix platforms, every path is ok
 
 
 def getfsmountpoint(path: bytes) -> Optional[bytes]:
     """Get the filesystem mount point from a directory (best-effort)
 
     Returns None if we are unsure. Raises OSError on ENOENT, EPERM, etc.
     """
     return getattr(osutil, 'getfsmountpoint', lambda x: None)(path)
 
 
 def getfstype(path: bytes) -> Optional[bytes]:
     """Get the filesystem type name from a directory (best-effort)
 
     Returns None if we are unsure. Raises OSError on ENOENT, EPERM, etc.
     """
     return getattr(osutil, 'getfstype', lambda x: None)(path)
 
 
 def get_password() -> bytes:
     return encoding.strtolocal(getpass.getpass(''))
 
 
 def setbinary(fd) -> None:
     pass
 
 
 def pconvert(path: bytes) -> bytes:
     return path
 
 
 def localpath(path: bytes) -> bytes:
     return path
 
 
 def samefile(fpath1: bytes, fpath2: bytes) -> bool:
     """Returns whether path1 and path2 refer to the same file. This is only
     guaranteed to work for files, not directories."""
     return os.path.samefile(fpath1, fpath2)
 
 
 def samedevice(fpath1: bytes, fpath2: bytes) -> bool:
     """Returns whether fpath1 and fpath2 are on the same device. This is only
     guaranteed to work for files, not directories."""
     st1 = os.lstat(fpath1)
     st2 = os.lstat(fpath2)
     return st1.st_dev == st2.st_dev
 
 
 # os.path.normcase is a no-op, which doesn't help us on non-native filesystems
 def normcase(path: bytes) -> bytes:
     return path.lower()
 
 
 # what normcase does to ASCII strings
 normcasespec: int = encoding.normcasespecs.lower
 # fallback normcase function for non-ASCII strings
 normcasefallback = normcase
 
 if pycompat.isdarwin:
 
     def normcase(path: bytes) -> bytes:
         """
         Normalize a filename for OS X-compatible comparison:
         - escape-encode invalid characters
         - decompose to NFD
         - lowercase
         - omit ignored characters [200c-200f, 202a-202e, 206a-206f,feff]
 
         >>> normcase(b'UPPER')
         'upper'
         >>> normcase(b'Caf\\xc3\\xa9')
         'cafe\\xcc\\x81'
         >>> normcase(b'\\xc3\\x89')
         'e\\xcc\\x81'
         >>> normcase(b'\\xb8\\xca\\xc3\\xca\\xbe\\xc8.JPG') # issue3918
         '%b8%ca%c3\\xca\\xbe%c8.jpg'
         """
 
         try:
             return encoding.asciilower(path)  # exception for non-ASCII
         except UnicodeDecodeError:
             return normcasefallback(path)
 
     normcasespec = encoding.normcasespecs.lower
 
     def normcasefallback(path: bytes) -> bytes:
         try:
             u = path.decode('utf-8')
         except UnicodeDecodeError:
             # OS X percent-encodes any bytes that aren't valid utf-8
             s = b''
             pos = 0
             l = len(path)
             while pos < l:
                 try:
                     c = encoding.getutf8char(path, pos)
                     pos += len(c)
                 except ValueError:
                     c = b'%%%02X' % ord(path[pos : pos + 1])
                     pos += 1
                 s += c
 
             u = s.decode('utf-8')
 
         # Decompose then lowercase (HFS+ technote specifies lower)
         enc = unicodedata.normalize('NFD', u).lower().encode('utf-8')
         # drop HFS+ ignored characters
         return encoding.hfsignoreclean(enc)
 
 
 if pycompat.sysplatform == b'cygwin':
     # workaround for cygwin, in which mount point part of path is
     # treated as case sensitive, even though underlying NTFS is case
     # insensitive.
 
     # default mount points
     cygwinmountpoints = sorted(
         [
             b"/usr/bin",
             b"/usr/lib",
             b"/cygdrive",
         ],
         reverse=True,
     )
 
     # use upper-ing as normcase as same as NTFS workaround
     def normcase(path: bytes) -> bytes:
         pathlen = len(path)
         if (pathlen == 0) or (path[0] != pycompat.ossep):
             # treat as relative
             return encoding.upper(path)
 
         # to preserve case of mountpoint part
         for mp in cygwinmountpoints:
             if not path.startswith(mp):
                 continue
 
             mplen = len(mp)
             if mplen == pathlen:  # mount point itself
                 return mp
             if path[mplen] == pycompat.ossep:
                 return mp + encoding.upper(path[mplen:])
 
         return encoding.upper(path)
 
     normcasespec = encoding.normcasespecs.other
     normcasefallback = normcase
 
     # Cygwin translates native ACLs to POSIX permissions,
     # but these translations are not supported by native
     # tools, so the exec bit tends to be set erroneously.
     # Therefore, disable executable bit access on Cygwin.
     def checkexec(path: bytes) -> bool:
         return False
 
     # Similarly, Cygwin's symlink emulation is likely to create
     # problems when Mercurial is used from both Cygwin and native
     # Windows, with other native tools, or on shared volumes
     def checklink(path: bytes) -> bool:
         return False
 
 
 if pycompat.sysplatform == b'OpenVMS':
     # OpenVMS's symlink emulation is broken on some OpenVMS versions.
     def checklink(path: bytes) -> bool:
         return False
 
 
-_needsshellquote: Optional[Match[bytes]] = None
+_needsshellquote: Optional[Callable[[bytes], Optional[Match[bytes]]]] = None
 
 
 def shellquote(s: bytes) -> bytes:
     if pycompat.sysplatform == b'OpenVMS':
         return b'"%s"' % s
     global _needsshellquote
     if _needsshellquote is None:
         _needsshellquote = re.compile(br'[^a-zA-Z0-9._/+-]').search
     if s and not _needsshellquote(s):
         # "s" shouldn't have to be quoted
         return s
     else:
         return b"'%s'" % s.replace(b"'", b"'\\''")
 
 
 def shellsplit(s: bytes) -> List[bytes]:
     """Parse a command string in POSIX shell way (best-effort)"""
     return pycompat.shlexsplit(s, posix=True)
 
 
 def testpid(pid: int) -> bool:
     '''return False if pid dead, True if running or not sure'''
     if pycompat.sysplatform == b'OpenVMS':
         return True
     try:
         os.kill(pid, 0)
         return True
     except OSError as inst:
         return inst.errno != errno.ESRCH
 
 
 def isowner(st: os.stat_result) -> bool:
     """Return True if the stat object st is from the current user."""
     return st.st_uid == os.getuid()
 
 
 def findexe(command: bytes) -> Optional[bytes]:
     """Find executable for command searching like which does.
     If command is a basename then PATH is searched for command.
     PATH isn't searched if command is an absolute or relative path.
     If command isn't found None is returned."""
     if pycompat.sysplatform == b'OpenVMS':
         return command
 
     def findexisting(executable: bytes) -> Optional[bytes]:
         b'Will return executable if existing file'
         if os.path.isfile(executable) and os.access(executable, os.X_OK):
             return executable
         return None
 
     if pycompat.ossep in command:
         return findexisting(command)
 
     if pycompat.sysplatform == b'plan9':
         return findexisting(os.path.join(b'/bin', command))
 
     for path in encoding.environ.get(b'PATH', b'').split(pycompat.ospathsep):
         executable = findexisting(os.path.join(path, command))
         if executable is not None:
             return executable
     return None
 
 
 def setsignalhandler() -> None:
     pass
 
 
 _wantedkinds = {stat.S_IFREG, stat.S_IFLNK}
 
 
 def statfiles(files: Sequence[bytes]) -> Iterator[Optional[os.stat_result]]:
     """Stat each file in files. Yield each stat, or None if a file does not
     exist or has a type we don't care about."""
     lstat = os.lstat
     getkind = stat.S_IFMT
     for nf in files:
         try:
             st = lstat(nf)
             if getkind(st.st_mode) not in _wantedkinds:
                 st = None
         except (FileNotFoundError, NotADirectoryError):
             st = None
         yield st
 
 
 def getuser() -> bytes:
     '''return name of current user'''
     return pycompat.fsencode(getpass.getuser())
 
 
 def username(uid: Optional[int] = None) -> Optional[bytes]:
     """Return the name of the user with the given uid.
 
     If uid is None, return the name of the current user."""
 
     if uid is None:
         uid = os.getuid()
     try:
         return pycompat.fsencode(pwd.getpwuid(uid)[0])
     except KeyError:
         return b'%d' % uid
 
 
 def groupname(gid: Optional[int] = None) -> Optional[bytes]:
     """Return the name of the group with the given gid.
 
     If gid is None, return the name of the current group."""
 
     if gid is None:
         gid = os.getgid()
     try:
         return pycompat.fsencode(grp.getgrgid(gid)[0])
     except KeyError:
         return pycompat.bytestr(gid)
 
 
 def groupmembers(name: bytes) -> List[bytes]:
     """Return the list of members of the group with the given
     name, KeyError if the group does not exist.
     """
     name = pycompat.fsdecode(name)
     return pycompat.rapply(pycompat.fsencode, list(grp.getgrnam(name).gr_mem))
 
 
 def spawndetached(args: List[bytes]) -> int:
     return os.spawnvp(os.P_NOWAIT | getattr(os, 'P_DETACH', 0), args[0], args)
 
 
 def gethgcmd():  # TODO: convert to bytes, like on Windows?
     return sys.argv[:1]
 
 
 def makedir(path: bytes, notindexed: bool) -> None:
     os.mkdir(path)
 
 
 def lookupreg(
     key: bytes,
     valname: Optional[bytes] = None,
     scope: Optional[Union[int, Iterable[int]]] = None,
 ) -> Optional[bytes]:
     return None
 
 
 def hidewindow() -> None:
     """Hide current shell window.
 
     Used to hide the window opened when starting asynchronous
     child process under Windows, unneeded on other systems.
     """
     pass
 
 
 class cachestat:
     stat: os.stat_result
 
     def __init__(self, path: bytes) -> None:
         self.stat = os.stat(path)
 
     def cacheable(self) -> bool:
         return bool(self.stat.st_ino)
 
     __hash__ = object.__hash__
 
     def __eq__(self, other: Any) -> bool:
         try:
             # Only dev, ino, size, mtime and atime are likely to change. Out
             # of these, we shouldn't compare atime but should compare the
             # rest. However, one of the other fields changing indicates
             # something fishy going on, so return False if anything but atime
             # changes.
             return (
                 self.stat.st_mode == other.stat.st_mode
                 and self.stat.st_ino == other.stat.st_ino
                 and self.stat.st_dev == other.stat.st_dev
                 and self.stat.st_nlink == other.stat.st_nlink
                 and self.stat.st_uid == other.stat.st_uid
                 and self.stat.st_gid == other.stat.st_gid
                 and self.stat.st_size == other.stat.st_size
                 and self.stat[stat.ST_MTIME] == other.stat[stat.ST_MTIME]
                 and self.stat[stat.ST_CTIME] == other.stat[stat.ST_CTIME]
             )
         except AttributeError:
             return False
 
     def __ne__(self, other: Any) -> bool:
         return not self == other
 
 
 def statislink(st: Optional[os.stat_result]) -> bool:
     '''check whether a stat result is a symlink'''
     return stat.S_ISLNK(st.st_mode) if st else False
 
 
 def statisexec(st: Optional[os.stat_result]) -> bool:
     '''check whether a stat result is an executable file'''
     return (st.st_mode & 0o100 != 0) if st else False
 
 
 def poll(fds):
     """block until something happens on any file descriptor
 
     This is a generic helper that will check for any activity
     (read, write.  exception) and return the list of touched files.
 
     In unsupported cases, it will raise a NotImplementedError"""
     try:
         res = select.select(fds, fds, fds)
     except ValueError:  # out of range file descriptor
         raise NotImplementedError()
     return sorted(list(set(sum(res, []))))
 
 
 def readpipe(pipe) -> bytes:
     """Read all available data from a pipe."""
     # We can't fstat() a pipe because Linux will always report 0.
     # So, we set the pipe to non-blocking mode and read everything
     # that's available.
     flags = fcntl.fcntl(pipe, fcntl.F_GETFL)
     flags |= os.O_NONBLOCK
     oldflags = fcntl.fcntl(pipe, fcntl.F_SETFL, flags)
 
     try:
         chunks = []
         while True:
             try:
                 s = pipe.read()
                 if not s:
                     break
                 chunks.append(s)
             except IOError:
                 break
 
         return b''.join(chunks)
     finally:
         fcntl.fcntl(pipe, fcntl.F_SETFL, oldflags)
 
 
 def bindunixsocket(sock, path: bytes) -> None:
     """Bind the UNIX domain socket to the specified path"""
     # use relative path instead of full path at bind() if possible, since
     # AF_UNIX path has very small length limit (107 chars) on common
     # platforms (see sys/un.h)
     dirname, basename = os.path.split(path)
     bakwdfd = None
 
     try:
         if dirname:
             bakwdfd = os.open(b'.', os.O_DIRECTORY)
             os.chdir(dirname)
         sock.bind(basename)
         if bakwdfd:
             os.fchdir(bakwdfd)
     finally:
         if bakwdfd:
             os.close(bakwdfd)

mercurial/statprof.py

@@ -1,1103 +1,1103
 ## statprof.py
 ## Copyright (C) 2012 Bryan O'Sullivan <[e-mail]>
 ## Copyright (C) 2011 Alex Fraser <alex at phatcore dot com>
 ## Copyright (C) 2004,2005 Andy Wingo <wingo at pobox dot com>
 ## Copyright (C) 2001 Rob Browning <rlb at defaultvalue dot org>
 
 ## This library is free software; you can redistribute it and/or
 ## modify it under the terms of the GNU Lesser General Public
 ## License as published by the Free Software Foundation; either
 ## version 2.1 of the License, or (at your option) any later version.
 ##
 ## This library is distributed in the hope that it will be useful,
 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 ## Lesser General Public License for more details.
 ##
 ## You should have received a copy of the GNU Lesser General Public
 ## License along with this program; if not, contact:
 ##
 ## Free Software Foundation           Voice:  [phone]
 ## 59 Temple Place - Suite 330        Fax:    [phone]
 ## Boston, MA  02111-1307,  USA       [e-mail]
 
 """
 statprof is intended to be a fairly simple statistical profiler for
 python. It was ported directly from a statistical profiler for guile,
 also named statprof, available from guile-lib [0].
 
 [0] http://wingolog.org/software/guile-lib/statprof/
 
 To start profiling, call statprof.start():
 >>> start()
 
 Then run whatever it is that you want to profile, for example:
 >>> import test.pystone; test.pystone.pystones()
 
 Then stop the profiling and print out the results:
 >>> stop()
 >>> display()
   %   cumulative      self
  time    seconds   seconds  name
  26.72      1.40      0.37  pystone.py:79:Proc0
  13.79      0.56      0.19  pystone.py:133:Proc1
  13.79      0.19      0.19  pystone.py:208:Proc8
  10.34      0.16      0.14  pystone.py:229:Func2
   6.90      0.10      0.10  pystone.py:45:__init__
   4.31      0.16      0.06  pystone.py:53:copy
     ...
 
 All of the numerical data is statistically approximate. In the
 following column descriptions, and in all of statprof, "time" refers
 to execution time (both user and system), not wall clock time.
 
 % time
     The percent of the time spent inside the procedure itself (not
     counting children).
 
 cumulative seconds
     The total number of seconds spent in the procedure, including
     children.
 
 self seconds
     The total number of seconds spent in the procedure itself (not
     counting children).
 
 name
     The name of the procedure.
 
 By default statprof keeps the data collected from previous runs. If you
 want to clear the collected data, call reset():
 >>> reset()
 
 reset() can also be used to change the sampling frequency from the
 default of 1000 Hz. For example, to tell statprof to sample 50 times a
 second:
 >>> reset(50)
 
 This means that statprof will sample the call stack after every 1/50 of
 a second of user + system time spent running on behalf of the python
 process. When your process is idle (for example, blocking in a read(),
 as is the case at the listener), the clock does not advance. For this
 reason statprof is not currently not suitable for profiling io-bound
 operations.
 
 The profiler uses the hash of the code object itself to identify the
 procedures, so it won't confuse different procedures with the same name.
 They will show up as two different rows in the output.
 
 Right now the profiler is quite simplistic.  I cannot provide
 call-graphs or other higher level information.  What you see in the
 table is pretty much all there is. Patches are welcome :-)
 
 
 Threading
 ---------
 
 Because signals only get delivered to the main thread in Python,
 statprof only profiles the main thread. However because the time
 reporting function uses per-process timers, the results can be
 significantly off if other threads' work patterns are not similar to the
 main thread's work patterns.
 """
 # no-check-code
 
 import collections
 import contextlib
 import getopt
 import inspect
 import json
 import os
 import signal
 import sys
 import threading
 import time
 
 from typing import (
     List,
 )
 
 from .pycompat import open
 from . import (
     encoding,
     pycompat,
 )
 
 defaultdict = collections.defaultdict
 contextmanager = contextlib.contextmanager
 
-__all__ = [b'start', b'stop', b'reset', b'display', b'profile']
+__all__ = ['start', 'stop', 'reset', 'display', 'profile']
 
 skips = {
     "util.py:check",
     "extensions.py:closure",
     "color.py:colorcmd",
     "dispatch.py:checkargs",
     "dispatch.py:<lambda>",
     "dispatch.py:_runcatch",
     "dispatch.py:_dispatch",
     "dispatch.py:_runcommand",
     "pager.py:pagecmd",
     "dispatch.py:run",
     "dispatch.py:dispatch",
     "dispatch.py:runcommand",
     "hg.py:<module>",
     "evolve.py:warnobserrors",
 }
 
 ###########################################################################
 ## Utils
 
 
 def clock():
     times = os.times()
     return (times[0] + times[1], times[4])
 
 
 ###########################################################################
 ## Collection data structures
 
 
 class ProfileState:
     samples: List["Sample"]
 
     def __init__(self, frequency=None):
         self.reset(frequency)
         self.track = b'cpu'
 
     def reset(self, frequency=None):
         # total so far
         self.accumulated_time = (0.0, 0.0)
         # start_time when timer is active
         self.last_start_time = None
         # a float
         if frequency:
             self.sample_interval = 1.0 / frequency
         elif not hasattr(self, 'sample_interval'):
             # default to 1000 Hz
             self.sample_interval = 1.0 / 1000.0
         else:
             # leave the frequency as it was
             pass
         self.remaining_prof_time = None
         # for user start/stop nesting
         self.profile_level = 0
 
         self.samples = []
 
     def accumulate_time(self, stop_time):
         increment = (
             stop_time[0] - self.last_start_time[0],
             stop_time[1] - self.last_start_time[1],
         )
         self.accumulated_time = (
             self.accumulated_time[0] + increment[0],
             self.accumulated_time[1] + increment[1],
         )
 
     def seconds_per_sample(self):
         return self.accumulated_time[self.timeidx] / len(self.samples)
 
     @property
     def timeidx(self):
         if self.track == b'real':
             return 1
         return 0
 
 
 state = ProfileState()
 
 
 class CodeSite:
     cache = {}
 
     __slots__ = ('path', 'lineno', 'function', 'source')
 
     def __init__(self, path, lineno, function):
         assert isinstance(path, bytes)
         self.path = path
         self.lineno = lineno
         assert isinstance(function, bytes)
         self.function = function
         self.source = None
 
     def __eq__(self, other):
         try:
             return self.lineno == other.lineno and self.path == other.path
         except:
             return False
 
     def __hash__(self):
         return hash((self.lineno, self.path))
 
     @classmethod
     def get(cls, path, lineno, function):
         k = (path, lineno)
         try:
             return cls.cache[k]
         except KeyError:
             v = cls(path, lineno, function)
             cls.cache[k] = v
             return v
 
     def getsource(self, length):
         if self.source is None:
             try:
                 lineno = self.lineno - 1  # lineno can be None
                 with open(self.path, b'rb') as fp:
                     for i, line in enumerate(fp):
                         if i == lineno:
                             self.source = line.strip()
                             break
             except:
                 pass
             if self.source is None:
                 self.source = b''
 
         source = self.source
         if len(source) > length:
             source = source[: (length - 3)] + b"..."
         return source
 
     def filename(self):
         return os.path.basename(self.path)
 
     def skipname(self):
         return '%s:%s' % (self.filename(), self.function)
 
 
 class Sample:
     __slots__ = ('stack', 'time')
 
     def __init__(self, stack, time):
         self.stack = stack
         self.time = time
 
     @classmethod
     def from_frame(cls, frame, time):
         stack = []
 
         while frame:
             stack.append(
                 CodeSite.get(
                     pycompat.sysbytes(frame.f_code.co_filename),
                     frame.f_lineno,
                     pycompat.sysbytes(frame.f_code.co_name),
                 )
             )
             frame = frame.f_back
 
         return Sample(stack, time)
 
 
 ###########################################################################
 ## SIGPROF handler
 
 
 def profile_signal_handler(signum, frame):
     if state.profile_level > 0:
         now = clock()
         state.accumulate_time(now)
 
         timestamp = state.accumulated_time[state.timeidx]
         state.samples.append(Sample.from_frame(frame, timestamp))
 
         signal.setitimer(signal.ITIMER_PROF, state.sample_interval, 0.0)
         state.last_start_time = now
 
 
 stopthread = threading.Event()
 
 
 def samplerthread(tid):
     while not stopthread.is_set():
         now = clock()
         state.accumulate_time(now)
 
         frame = sys._current_frames()[tid]
 
         timestamp = state.accumulated_time[state.timeidx]
         state.samples.append(Sample.from_frame(frame, timestamp))
 
         state.last_start_time = now
         time.sleep(state.sample_interval)
 
     stopthread.clear()
 
 
 ###########################################################################
 ## Profiling API
 
 
 def is_active():
     return state.profile_level > 0
 
 
 lastmechanism = None
 
 
 def start(mechanism=b'thread', track=b'cpu'):
     '''Install the profiling signal handler, and start profiling.'''
     state.track = track  # note: nesting different mode won't work
     state.profile_level += 1
     if state.profile_level == 1:
         state.last_start_time = clock()
         rpt = state.remaining_prof_time
         state.remaining_prof_time = None
 
         global lastmechanism
         lastmechanism = mechanism
 
         if mechanism == b'signal':
             signal.signal(signal.SIGPROF, profile_signal_handler)
             signal.setitimer(
                 signal.ITIMER_PROF, rpt or state.sample_interval, 0.0
             )
         elif mechanism == b'thread':
             frame = inspect.currentframe()
             tid = [k for k, f in sys._current_frames().items() if f == frame][0]
             state.thread = threading.Thread(
                 target=samplerthread, args=(tid,), name="samplerthread"
             )
             state.thread.start()
 
 
 def stop():
     '''Stop profiling, and uninstall the profiling signal handler.'''
     state.profile_level -= 1
     if state.profile_level == 0:
         if lastmechanism == b'signal':
             rpt = signal.setitimer(signal.ITIMER_PROF, 0.0, 0.0)
             signal.signal(signal.SIGPROF, signal.SIG_IGN)
             state.remaining_prof_time = rpt[0]
         elif lastmechanism == b'thread':
             stopthread.set()
             state.thread.join()
 
         state.accumulate_time(clock())
         state.last_start_time = None
         statprofpath = encoding.environ.get(b'STATPROF_DEST')
         if statprofpath:
             save_data(statprofpath)
 
     return state
 
 
 def save_data(path):
     with open(path, b'w+') as file:
         file.write(b"%f %f\n" % state.accumulated_time)
         for sample in state.samples:
             time = sample.time
             stack = sample.stack
             sites = [
                 b'\1'.join([s.path, b'%d' % s.lineno or -1, s.function])
                 for s in stack
             ]
             file.write(b"%d\0%s\n" % (time, b'\0'.join(sites)))
 
 
 def load_data(path):
     lines = open(path, b'rb').read().splitlines()
 
     state.accumulated_time = [float(value) for value in lines[0].split()]
     state.samples = []
     for line in lines[1:]:
         parts = line.split(b'\0')
         time = float(parts[0])
         rawsites = parts[1:]
         sites = []
         for rawsite in rawsites:
             siteparts = rawsite.split(b'\1')
             sites.append(
                 CodeSite.get(siteparts[0], int(siteparts[1]), siteparts[2])
             )
 
         state.samples.append(Sample(sites, time))
 
 
 def reset(frequency=None):
     """Clear out the state of the profiler.  Do not call while the
     profiler is running.
 
     The optional frequency argument specifies the number of samples to
     collect per second."""
     assert state.profile_level == 0, b"Can't reset() while statprof is running"
     CodeSite.cache.clear()
     state.reset(frequency)
 
 
 @contextmanager
 def profile():
     start()
     try:
         yield
     finally:
         stop()
         display()
 
 
 ###########################################################################
 ## Reporting API
 
 
 class SiteStats:
     def __init__(self, site):
         self.site = site
         self.selfcount = 0
         self.totalcount = 0
 
     def addself(self):
         self.selfcount += 1
 
     def addtotal(self):
         self.totalcount += 1
 
     def selfpercent(self):
         return self.selfcount / len(state.samples) * 100
 
     def totalpercent(self):
         return self.totalcount / len(state.samples) * 100
 
     def selfseconds(self):
         return self.selfcount * state.seconds_per_sample()
 
     def totalseconds(self):
         return self.totalcount * state.seconds_per_sample()
 
     @classmethod
     def buildstats(cls, samples):
         stats = {}
 
         for sample in samples:
             for i, site in enumerate(sample.stack):
                 sitestat = stats.get(site)
                 if not sitestat:
                     sitestat = SiteStats(site)
                     stats[site] = sitestat
 
                 sitestat.addtotal()
 
                 if i == 0:
                     sitestat.addself()
 
         return [s for s in stats.values()]
 
 
 class DisplayFormats:
     ByLine = 0
     ByMethod = 1
     AboutMethod = 2
     Hotpath = 3
     FlameGraph = 4
     Json = 5
     Chrome = 6
 
 
 def display(fp=None, format=3, data=None, **kwargs):
     '''Print statistics, either to stdout or the given file object.'''
     if data is None:
         data = state
 
     if fp is None:
         from .utils import procutil
 
         fp = procutil.stdout
     if len(data.samples) == 0:
         fp.write(b'No samples recorded.\n')
         return
 
     if format == DisplayFormats.ByLine:
         display_by_line(data, fp)
     elif format == DisplayFormats.ByMethod:
         display_by_method(data, fp)
     elif format == DisplayFormats.AboutMethod:
         display_about_method(data, fp, **kwargs)
     elif format == DisplayFormats.Hotpath:
         display_hotpath(data, fp, **kwargs)
     elif format == DisplayFormats.FlameGraph:
         write_to_flame(data, fp, **kwargs)
     elif format == DisplayFormats.Json:
         write_to_json(data, fp)
     elif format == DisplayFormats.Chrome:
         write_to_chrome(data, fp, **kwargs)
     else:
         raise Exception("Invalid display format")
 
     if format not in (DisplayFormats.Json, DisplayFormats.Chrome):
         fp.write(b'---\n')
         fp.write(b'Sample count: %d\n' % len(data.samples))
         fp.write(b'Total time: %f seconds (%f wall)\n' % data.accumulated_time)
 
 
 def display_by_line(data, fp):
     """Print the profiler data with each sample line represented
     as one row in a table.  Sorted by self-time per line."""
     stats = SiteStats.buildstats(data.samples)
     stats.sort(reverse=True, key=lambda x: x.selfseconds())
 
     fp.write(
         b'%5.5s %10.10s   %7.7s  %-8.8s\n'
         % (b'%  ', b'cumulative', b'self', b'')
     )
     fp.write(
         b'%5.5s  %9.9s  %8.8s  %-8.8s\n'
         % (b"time", b"seconds", b"seconds", b"name")
     )
 
     for stat in stats:
         site = stat.site
         sitelabel = b'%s:%d:%s' % (
             site.filename(),
             site.lineno or -1,
             site.function,
         )
         fp.write(
             b'%6.2f %9.2f %9.2f  %s\n'
             % (
                 stat.selfpercent(),
                 stat.totalseconds(),
                 stat.selfseconds(),
                 sitelabel,
             )
         )
 
 
 def display_by_method(data, fp):
     """Print the profiler data with each sample function represented
     as one row in a table.  Important lines within that function are
     output as nested rows.  Sorted by self-time per line."""
     fp.write(
         b'%5.5s %10.10s   %7.7s  %-8.8s\n'
         % (b'%  ', b'cumulative', b'self', b'')
     )
     fp.write(
         b'%5.5s  %9.9s  %8.8s  %-8.8s\n'
         % (b"time", b"seconds", b"seconds", b"name")
     )
 
     stats = SiteStats.buildstats(data.samples)
 
     grouped = defaultdict(list)
     for stat in stats:
         grouped[stat.site.filename() + b":" + stat.site.function].append(stat)
 
     # compute sums for each function
     functiondata = []
     for fname, sitestats in grouped.items():
         total_cum_sec = 0
         total_self_sec = 0
         total_percent = 0
         for stat in sitestats:
             total_cum_sec += stat.totalseconds()
             total_self_sec += stat.selfseconds()
             total_percent += stat.selfpercent()
 
         functiondata.append(
             (fname, total_cum_sec, total_self_sec, total_percent, sitestats)
         )
 
     # sort by total self sec
     functiondata.sort(reverse=True, key=lambda x: x[2])
 
     for function in functiondata:
         if function[3] < 0.05:
             continue
         fp.write(
             b'%6.2f %9.2f %9.2f  %s\n'
             % (
                 function[3],  # total percent
                 function[1],  # total cum sec
                 function[2],  # total self sec
                 function[0],
             )
         )  # file:function
 
         function[4].sort(reverse=True, key=lambda i: i.selfseconds())
         for stat in function[4]:
             # only show line numbers for significant locations (>1% time spent)
             if stat.selfpercent() > 1:
                 source = stat.site.getsource(25)
                 if not isinstance(source, bytes):
                     source = pycompat.bytestr(source)
 
                 stattuple = (
                     stat.selfpercent(),
                     stat.selfseconds(),
                     stat.site.lineno or -1,
                     source,
                 )
 
                 fp.write(b'%33.0f%% %6.2f   line %d: %s\n' % stattuple)
 
 
 def display_about_method(data, fp, function=None, **kwargs):
     if function is None:
         raise Exception("Invalid function")
 
     filename = None
     if b':' in function:
         filename, function = function.split(b':')
 
     relevant_samples = 0
     parents = {}
     children = {}
 
     for sample in data.samples:
         for i, site in enumerate(sample.stack):
             if site.function == function and (
                 not filename or site.filename() == filename
             ):
                 relevant_samples += 1
                 if i != len(sample.stack) - 1:
                     parent = sample.stack[i + 1]
                     if parent in parents:
                         parents[parent] = parents[parent] + 1
                     else:
                         parents[parent] = 1
 
                 if site in children:
                     children[site] = children[site] + 1
                 else:
                     children[site] = 1
 
     parents = [(parent, count) for parent, count in parents.items()]
     parents.sort(reverse=True, key=lambda x: x[1])
     for parent, count in parents:
         fp.write(
             b'%6.2f%%   %s:%s   line %s: %s\n'
             % (
                 count / relevant_samples * 100,
                 pycompat.fsencode(parent.filename()),
                 pycompat.sysbytes(parent.function),
                 parent.lineno or -1,
                 pycompat.sysbytes(parent.getsource(50)),
             )
         )
 
     stats = SiteStats.buildstats(data.samples)
     stats = [
         s
         for s in stats
         if s.site.function == function
         and (not filename or s.site.filename() == filename)
     ]
 
     total_cum_sec = 0
     total_self_sec = 0
     total_self_percent = 0
     total_cum_percent = 0
     for stat in stats:
         total_cum_sec += stat.totalseconds()
         total_self_sec += stat.selfseconds()
         total_self_percent += stat.selfpercent()
         total_cum_percent += stat.totalpercent()
 
     fp.write(
         b'\n    %s:%s    Total: %0.2fs (%0.2f%%)    Self: %0.2fs (%0.2f%%)\n\n'
         % (
             pycompat.sysbytes(filename or b'___'),
             pycompat.sysbytes(function),
             total_cum_sec,
             total_cum_percent,
             total_self_sec,
             total_self_percent,
         )
     )
 
     children = [(child, count) for child, count in children.items()]
     children.sort(reverse=True, key=lambda x: x[1])
     for child, count in children:
         fp.write(
             b'        %6.2f%%   line %s: %s\n'
             % (
                 count / relevant_samples * 100,
                 child.lineno or -1,
                 pycompat.sysbytes(child.getsource(50)),
             )
         )
 
 
 def display_hotpath(data, fp, limit=0.05, **kwargs):
     class HotNode:
         def __init__(self, site):
             self.site = site
             self.count = 0
             self.children = {}
 
         def add(self, stack, time):
             self.count += time
             site = stack[0]
             child = self.children.get(site)
             if not child:
                 child = HotNode(site)
                 self.children[site] = child
 
             if len(stack) > 1:
                 i = 1
                 # Skip boiler plate parts of the stack
                 while i < len(stack) and stack[i].skipname() in skips:
                     i += 1
                 if i < len(stack):
                     child.add(stack[i:], time)
             else:
                 # Normally this is done by the .add() calls
                 child.count += time
 
     root = HotNode(None)
     lasttime = data.samples[0].time
     for sample in data.samples:
         root.add(sample.stack[::-1], sample.time - lasttime)
         lasttime = sample.time
     showtime = kwargs.get('showtime', True)
 
     def _write(node, depth, multiple_siblings):
         site = node.site
         visiblechildren = [
             c for c in node.children.values() if c.count >= (limit * root.count)
         ]
         if site:
             indent = depth * 2 - 1
             filename = (site.filename() + b':').ljust(15)
             function = site.function
 
             # lots of string formatting
             listpattern = (
                 b''.ljust(indent)
                 + (b'\\' if multiple_siblings else b'|')
                 + b' %4.1f%%'
                 + (b' %5.2fs' % node.count if showtime else b'')
                 + b'  %s %s'
             )
             liststring = listpattern % (
                 node.count / root.count * 100,
                 filename,
                 function,
             )
             # 4 to account for the word 'line'
             spacing_len = max(4, 55 - len(liststring))
             prefix = b''
             if spacing_len == 4:
                 prefix = b', '
 
             codepattern = b'%s%s %d: %s%s'
             codestring = codepattern % (
                 prefix,
                 b'line'.rjust(spacing_len),
                 site.lineno if site.lineno is not None else -1,
                 b''.ljust(max(0, 4 - len(str(site.lineno)))),
                 site.getsource(30),
             )
 
             finalstring = liststring + codestring
             childrensamples = sum([c.count for c in node.children.values()])
             # Make frames that performed more than 10% of the operation red
             if node.count - childrensamples > (0.1 * root.count):
                 finalstring = b'\033[91m' + finalstring + b'\033[0m'
             # Make frames that didn't actually perform work dark grey
             elif node.count - childrensamples == 0:
                 finalstring = b'\033[90m' + finalstring + b'\033[0m'
             fp.write(finalstring + b'\n')
 
         newdepth = depth
         if len(visiblechildren) > 1 or multiple_siblings:
             newdepth += 1
 
         visiblechildren.sort(reverse=True, key=lambda x: x.count)
         for child in visiblechildren:
             _write(child, newdepth, len(visiblechildren) > 1)
 
     if root.count > 0:
         _write(root, 0, False)
 
 
 def write_to_flame(data, fp, scriptpath=None, outputfile=None, **kwargs):
     if scriptpath is None:
         scriptpath = encoding.environ[b'HOME'] + b'/flamegraph.pl'
     if not os.path.exists(scriptpath):
         fp.write(b'error: missing %s\n' % scriptpath)
         fp.write(b'get it here: https://github.com/brendangregg/FlameGraph\n')
         return
 
     lines = {}
     for sample in data.samples:
         sites = [s.function for s in sample.stack]
         sites.reverse()
         line = b';'.join(sites)
         if line in lines:
             lines[line] = lines[line] + 1
         else:
             lines[line] = 1
 
     fd, path = pycompat.mkstemp()
 
     with open(path, b"w+") as file:
         for line, count in lines.items():
             file.write(b"%s %d\n" % (line, count))
 
     if outputfile is None:
         outputfile = b'~/flamegraph.svg'
 
     os.system(b"perl ~/flamegraph.pl %s > %s" % (path, outputfile))
     fp.write(b'Written to %s\n' % outputfile)
 
 
 _pathcache = {}
 
 
 def simplifypath(path):
     """Attempt to make the path to a Python module easier to read by
     removing whatever part of the Python search path it was found
     on."""
 
     if path in _pathcache:
         return _pathcache[path]
     hgpath = encoding.__file__.rsplit(os.sep, 2)[0]
     for p in [hgpath] + sys.path:
         prefix = p + os.sep
         if path.startswith(prefix):
             path = path[len(prefix) :]
             break
     _pathcache[path] = path
     return path
 
 
 def write_to_json(data, fp):
     samples = []
 
     for sample in data.samples:
         stack = []
 
         for frame in sample.stack:
             stack.append(
                 (
                     pycompat.sysstr(frame.path),
                     frame.lineno or -1,
                     pycompat.sysstr(frame.function),
                 )
             )
 
         samples.append((sample.time, stack))
 
     data = json.dumps(samples)
     if not isinstance(data, bytes):
         data = data.encode('utf-8')
 
     fp.write(data)
 
 
 def write_to_chrome(data, fp, minthreshold=0.005, maxthreshold=0.999):
     samples = []
     laststack = collections.deque()
     lastseen = collections.deque()
 
     # The Chrome tracing format allows us to use a compact stack
     # representation to save space. It's fiddly but worth it.
     # We maintain a bijection between stack and ID.
     stack2id = {}
     id2stack = []  # will eventually be rendered
 
     def stackid(stack):
         if not stack:
             return
         if stack in stack2id:
             return stack2id[stack]
         parent = stackid(stack[1:])
         myid = len(stack2id)
         stack2id[stack] = myid
         id2stack.append(dict(category=stack[0][0], name='%s %s' % stack[0]))
         if parent is not None:
             id2stack[-1].update(parent=parent)
         return myid
 
     # The sampling profiler can sample multiple times without
     # advancing the clock, potentially causing the Chrome trace viewer
     # to render single-pixel columns that we cannot zoom in on.  We
     # work around this by pretending that zero-duration samples are a
     # millisecond in length.
 
     clamp = 0.001
 
     # We provide knobs that by default attempt to filter out stack
     # frames that are too noisy:
     #
     # * A few take almost all execution time. These are usually boring
     #   setup functions, giving a stack that is deep but uninformative.
     #
     # * Numerous samples take almost no time, but introduce lots of
     #   noisy, oft-deep "spines" into a rendered profile.
 
     blacklist = set()
     totaltime = data.samples[-1].time - data.samples[0].time
     minthreshold = totaltime * minthreshold
     maxthreshold = max(totaltime * maxthreshold, clamp)
 
     def poplast():
         oldsid = stackid(tuple(laststack))
         oldcat, oldfunc = laststack.popleft()
         oldtime, oldidx = lastseen.popleft()
         duration = sample.time - oldtime
         if minthreshold <= duration <= maxthreshold:
             # ensure no zero-duration events
             sampletime = max(oldtime + clamp, sample.time)
             samples.append(
                 dict(
                     ph='E',
                     name=oldfunc,
                     cat=oldcat,
                     sf=oldsid,
                     ts=sampletime * 1e6,
                     pid=0,
                 )
             )
         else:
             blacklist.add(oldidx)
 
     # Much fiddling to synthesize correctly(ish) nested begin/end
     # events given only stack snapshots.
 
     for sample in data.samples:
         stack = tuple(
             (
                 (
                     '%s:%d'
                     % (
                         simplifypath(pycompat.sysstr(frame.path)),
                         frame.lineno or -1,
                     ),
                     pycompat.sysstr(frame.function),
                 )
                 for frame in sample.stack
             )
         )
         qstack = collections.deque(stack)
         if laststack == qstack:
             continue
         while laststack and qstack and laststack[-1] == qstack[-1]:
             laststack.pop()
             qstack.pop()
         while laststack:
             poplast()
         for f in reversed(qstack):
             lastseen.appendleft((sample.time, len(samples)))
             laststack.appendleft(f)
             path, name = f
             sid = stackid(tuple(laststack))
             samples.append(
                 dict(
                     ph='B',
                     name=name,
                     cat=path,
                     ts=sample.time * 1e6,
                     sf=sid,
                     pid=0,
                 )
             )
         laststack = collections.deque(stack)
     while laststack:
         poplast()
     events = [
         sample for idx, sample in enumerate(samples) if idx not in blacklist
     ]
     frames = collections.OrderedDict(
         (str(k), v) for (k, v) in enumerate(id2stack)
     )
     data = json.dumps(dict(traceEvents=events, stackFrames=frames), indent=1)
     if not isinstance(data, bytes):
         data = data.encode('utf-8')
     fp.write(data)
     fp.write(b'\n')
 
 
 def printusage():
     print(
         r"""
 The statprof command line allows you to inspect the last profile's results in
 the following forms:
 
 usage:
     hotpath [-l --limit percent]
         Shows a graph of calls with the percent of time each takes.
         Red calls take over 10%% of the total time themselves.
     lines
         Shows the actual sampled lines.
     functions
         Shows the samples grouped by function.
     function [filename:]functionname
         Shows the callers and callees of a particular function.
     flame [-s --script-path] [-o --output-file path]
         Writes out a flamegraph to output-file (defaults to ~/flamegraph.svg)
         Requires that ~/flamegraph.pl exist.
         (Specify alternate script path with --script-path.)"""
     )
 
 
 def main(argv=None):
     if argv is None:
         argv = sys.argv
 
     if len(argv) == 1:
         printusage()
         return 0
 
     displayargs = {}
 
     optstart = 2
     displayargs[b'function'] = None
     if argv[1] == 'hotpath':
         displayargs[b'format'] = DisplayFormats.Hotpath
     elif argv[1] == 'lines':
         displayargs[b'format'] = DisplayFormats.ByLine
     elif argv[1] == 'functions':
         displayargs[b'format'] = DisplayFormats.ByMethod
     elif argv[1] == 'function':
         displayargs[b'format'] = DisplayFormats.AboutMethod
         displayargs[b'function'] = argv[2]
         optstart = 3
     elif argv[1] == 'flame':
         displayargs[b'format'] = DisplayFormats.FlameGraph
     else:
         printusage()
         return 0
 
     # process options
     try:
         opts, args = pycompat.getoptb(
             pycompat.sysargv[optstart:],
             b"hl:f:o:p:",
             [b"help", b"limit=", b"file=", b"output-file=", b"script-path="],
         )
     except getopt.error as msg:
         print(msg)
         printusage()
         return 2
 
     displayargs[b'limit'] = 0.05
     path = None
     for o, value in opts:
         if o in ("-l", "--limit"):
             displayargs[b'limit'] = float(value)
         elif o in ("-f", "--file"):
             path = value
         elif o in ("-o", "--output-file"):
             displayargs[b'outputfile'] = value
         elif o in ("-p", "--script-path"):
             displayargs[b'scriptpath'] = value
         elif o in ("-h", "help"):
             printusage()
             return 0
         else:
             assert False, "unhandled option %s" % o
 
     if not path:
         print('must specify --file to load')
         return 1
 
     load_data(path=path)
 
     display(**pycompat.strkwargs(displayargs))
 
     return 0
 
 
 if __name__ == "__main__":
     sys.exit(main())

rust/Cargo.lock

@@ -1,1773 +1,1774
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
 version = 3
 
 [[package]]
 name = "adler"
 version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
 
 [[package]]
 name = "ahash"
 version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bf6ccdb167abbf410dcb915cabd428929d7f6a04980b54a11f26a39f1c7f7107"
 dependencies = [
  "cfg-if",
  "once_cell",
  "version_check",
 ]
 
 [[package]]
 name = "aho-corasick"
 version = "0.7.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4f55bd91a0978cbfd91c457a164bab8b4001c833b7f323132c0a4e1922dd44e"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "android-tzdata"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
 
 [[package]]
 name = "android_system_properties"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "atty"
 version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
 dependencies = [
  "hermit-abi",
  "libc",
  "winapi",
 ]
 
 [[package]]
 name = "autocfg"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "bitflags"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
 version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 
 [[package]]
 name = "bitmaps"
 version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "031043d04099746d8db04daf1fa424b2bc8bd69d92b25962dcde24da39ab64a2"
 dependencies = [
  "typenum",
 ]
 
 [[package]]
 name = "bitvec"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
 dependencies = [
  "funty",
  "radium",
  "tap",
  "wyz",
 ]
 
 [[package]]
 name = "block-buffer"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
 dependencies = [
  "generic-array",
 ]
 
 [[package]]
 name = "block-buffer"
 version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69cce20737498f97b993470a6e536b8523f0af7892a4f928cceb1ac5e52ebe7e"
 dependencies = [
  "generic-array",
 ]
 
 [[package]]
 name = "bstr"
 version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6798148dccfbff0fae41c7574d2fa8f1ef3492fba0face179de5d8d447d67b05"
 dependencies = [
  "memchr",
  "regex-automata",
  "serde",
 ]
 
 [[package]]
 name = "bumpalo"
 version = "3.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba"
 
 [[package]]
 name = "byteorder"
 version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
 [[package]]
 name = "bytes-cast"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a20de93b91d7703ca0e39e12930e310acec5ff4d715f4166e0ab026babb352e8"
 dependencies = [
  "bytes-cast-derive",
 ]
 
 [[package]]
 name = "bytes-cast-derive"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7470a6fcce58cde3d62cce758bf71007978b75247e6becd9255c9b884bcb4f71"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
 ]
 
 [[package]]
 name = "cc"
 version = "1.0.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "76a284da2e6fe2092f2353e51713435363112dfd60030e22add80be333fb928f"
 dependencies = [
  "jobserver",
 ]
 
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
 version = "0.4.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5bc015644b92d5890fab7489e49d21f879d5c990186827d42ec511919404f38b"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
  "js-sys",
  "num-traits",
  "wasm-bindgen",
  "windows-targets 0.52.0",
 ]
 
 [[package]]
 name = "clap"
 version = "4.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "60494cedb60cb47462c0ff7be53de32c0e42a6fc2c772184554fa12bd9489c03"
 dependencies = [
  "atty",
  "bitflags 1.3.2",
  "clap_derive",
  "clap_lex",
  "once_cell",
  "strsim",
  "termcolor",
 ]
 
 [[package]]
 name = "clap_derive"
 version = "4.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0177313f9f02afc995627906bbd8967e2be069f5261954222dac78290c2b9014"
 dependencies = [
  "heck",
  "proc-macro-error",
  "proc-macro2",
  "quote",
  "syn",
 ]
 
 [[package]]
 name = "clap_lex"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0d4198f73e42b4936b35b5bb248d81d2b595ecb170da0bac7655c54eedfa8da8"
 dependencies = [
  "os_str_bytes",
 ]
 
 [[package]]
 name = "codespan-reporting"
 version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
 dependencies = [
  "termcolor",
  "unicode-width",
 ]
 
 [[package]]
 name = "convert_case"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
 
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
 
 [[package]]
 name = "cpufeatures"
 version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "cpython"
 version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43b398a2c65baaf5892f10bb69b52508bf7a993380cc4ecd3785aaebb5c79389"
 dependencies = [
  "libc",
  "num-traits",
  "paste",
  "python3-sys",
 ]
 
 [[package]]
 name = "crc32fast"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
 dependencies = [
  "cfg-if",
 ]
 
 [[package]]
 name = "crossbeam-channel"
 version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521"
 dependencies = [
  "cfg-if",
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-deque"
 version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc"
 dependencies = [
  "cfg-if",
  "crossbeam-epoch",
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-epoch"
 version = "0.9.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f916dfc5d356b0ed9dae65f1db9fc9770aa2851d2662b988ccf4fe3516e86348"
 dependencies = [
  "autocfg",
  "cfg-if",
  "crossbeam-utils",
  "memoffset",
  "scopeguard",
 ]
 
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "edbafec5fa1f196ca66527c1b12c2ec4745ca14b50f1ad8f9f6f720b55d11fac"
 dependencies = [
  "cfg-if",
 ]
 
 [[package]]
 name = "crypto-common"
 version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
  "generic-array",
  "typenum",
 ]
 
 [[package]]
 name = "ctor"
 version = "0.1.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6d2301688392eb071b0bf1a37be05c469d3cc4dbbd95df672fe28ab021e6a096"
 dependencies = [
  "quote",
  "syn",
 ]
 
 [[package]]
 name = "cxx"
 version = "1.0.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "97abf9f0eca9e52b7f81b945524e76710e6cb2366aead23b7d4fbf72e281f888"
 dependencies = [
  "cc",
  "cxxbridge-flags",
  "cxxbridge-macro",
  "link-cplusplus",
 ]
 
 [[package]]
 name = "cxx-build"
 version = "1.0.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7cc32cc5fea1d894b77d269ddb9f192110069a8a9c1f1d441195fba90553dea3"
 dependencies = [
  "cc",
  "codespan-reporting",
  "once_cell",
  "proc-macro2",
  "quote",
  "scratch",
  "syn",
 ]
 
 [[package]]
 name = "cxxbridge-flags"
 version = "1.0.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ca220e4794c934dc6b1207c3b42856ad4c302f2df1712e9f8d2eec5afaacf1f"
 
 [[package]]
 name = "cxxbridge-macro"
 version = "1.0.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b846f081361125bfc8dc9d3940c84e1fd83ba54bbca7b17cd29483c828be0704"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
 ]
 
 [[package]]
 name = "derive_more"
 version = "0.99.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321"
 dependencies = [
  "convert_case",
  "proc-macro2",
  "quote",
  "rustc_version",
  "syn",
 ]
 
 [[package]]
 name = "diff"
 version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
 
 [[package]]
 name = "digest"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
 dependencies = [
  "generic-array",
 ]
 
 [[package]]
 name = "digest"
 version = "0.10.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "adfbc57365a37acbd2ebf2b64d7e69bb766e2fea813521ed536f5d0520dcf86c"
 dependencies = [
  "block-buffer 0.10.3",
  "crypto-common",
 ]
 
 [[package]]
 name = "dirs"
 version = "5.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
 dependencies = [
  "dirs-sys",
 ]
 
 [[package]]
 name = "dirs-sys"
 version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
 dependencies = [
  "libc",
  "option-ext",
  "redox_users",
  "windows-sys",
 ]
 
 [[package]]
 name = "either"
 version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
 
 [[package]]
 name = "env_logger"
 version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a12e6657c4c97ebab115a42dcee77225f7f482cdd841cf7088c657a42e9e00e7"
 dependencies = [
  "atty",
  "humantime",
  "log",
  "regex",
  "termcolor",
 ]
 
 [[package]]
 name = "fastrand"
 version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499"
 dependencies = [
  "instant",
 ]
 
 [[package]]
 name = "flate2"
 version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f82b0f4c27ad9f8bfd1f3208d882da2b09c301bc1c828fd3a00d0216d2fbbff6"
 dependencies = [
  "crc32fast",
  "libz-sys",
  "miniz_oxide",
 ]
 
 [[package]]
 name = "format-bytes"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48942366ef93975da38e175ac9e10068c6fc08ca9e85930d4f098f4d5b14c2fd"
 dependencies = [
  "format-bytes-macros",
 ]
 
 [[package]]
 name = "format-bytes-macros"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "203aadebefcc73d12038296c228eabf830f99cba991b0032adf20e9fa6ce7e4f"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
 ]
 
 [[package]]
 name = "funty"
 version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "generic-array"
 version = "0.14.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
 dependencies = [
  "typenum",
  "version_check",
 ]
 
 [[package]]
 name = "getrandom"
 version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
 dependencies = [
  "cfg-if",
  "libc",
  "wasi 0.9.0+wasi-snapshot-preview1",
 ]
 
 [[package]]
 name = "getrandom"
 version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
 dependencies = [
  "cfg-if",
  "libc",
  "wasi 0.11.0+wasi-snapshot-preview1",
 ]
 
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 
 [[package]]
 name = "hashbrown"
 version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33ff8ae62cd3a9102e5637afc8452c55acf3844001bd5374e0b0bd7b6616c038"
 dependencies = [
  "ahash",
  "rayon",
 ]
 
 [[package]]
 name = "heck"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
 
 [[package]]
 name = "hermit-abi"
 version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "hex"
 version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
 name = "hg-core"
 version = "0.1.0"
 dependencies = [
  "bitflags 1.3.2",
  "bitvec",
  "byteorder",
  "bytes-cast",
  "chrono",
  "clap",
  "crossbeam-channel",
  "derive_more",
  "flate2",
  "format-bytes",
  "hashbrown 0.13.1",
  "home",
  "im-rc",
  "itertools",
  "lazy_static",
  "libc",
  "log",
  "logging_timer",
  "memmap2",
  "once_cell",
  "pretty_assertions",
  "rand 0.8.5",
  "rand_distr",
  "rand_pcg",
  "rayon",
  "regex",
  "same-file",
  "self_cell",
  "serde",
  "sha-1 0.10.0",
  "tempfile",
  "thread_local",
  "toml",
  "twox-hash",
  "zstd",
 ]
 
 [[package]]
 name = "hg-cpython"
 version = "0.1.0"
 dependencies = [
  "cpython",
  "crossbeam-channel",
  "env_logger",
  "hg-core",
  "libc",
  "log",
  "stable_deref_trait",
  "vcsgraph",
 ]
 
 [[package]]
 name = "home"
 version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "747309b4b440c06d57b0b25f2aee03ee9b5e5397d288c60e21fc709bb98a7408"
 dependencies = [
  "winapi",
 ]
 
 [[package]]
 name = "humantime"
 version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
 
 [[package]]
 name = "iana-time-zone"
 version = "0.1.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "64c122667b287044802d6ce17ee2ddf13207ed924c712de9a66a5814d5b64765"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
  "iana-time-zone-haiku",
  "js-sys",
  "wasm-bindgen",
  "winapi",
 ]
 
 [[package]]
 name = "iana-time-zone-haiku"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0703ae284fc167426161c2e3f1da3ea71d94b21bedbcc9494e92b28e334e3dca"
 dependencies = [
  "cxx",
  "cxx-build",
 ]
 
 [[package]]
 name = "im-rc"
 version = "15.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af1955a75fa080c677d3972822ec4bad316169ab1cfc6c257a942c2265dbe5fe"
 dependencies = [
  "bitmaps",
  "rand_core 0.6.4",
  "rand_xoshiro",
  "sized-chunks",
  "typenum",
  "version_check",
 ]
 
 [[package]]
 name = "indexmap"
 version = "1.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
 dependencies = [
  "autocfg",
  "hashbrown 0.12.3",
 ]
 
 [[package]]
 name = "instant"
 version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
 dependencies = [
  "cfg-if",
 ]
 
 [[package]]
 name = "itertools"
 version = "0.10.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
 dependencies = [
  "either",
 ]
 
 [[package]]
 name = "jobserver"
 version = "0.1.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "068b1ee6743e4d11fb9c6a1e6064b3693a1b600e7f5f5988047d98b3dc9fb90b"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "js-sys"
 version = "0.3.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47"
 dependencies = [
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
-version = "0.2.137"
+version = "0.2.155"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89"
+checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
 
 [[package]]
 name = "libm"
 version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "348108ab3fba42ec82ff6e9564fc4ca0247bdccdc68dd8af9764bbc79c3c8ffb"
 
 [[package]]
 name = "libredox"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
 dependencies = [
  "bitflags 2.6.0",
  "libc",
 ]
 
 [[package]]
 name = "libz-sys"
 version = "1.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9702761c3935f8cc2f101793272e202c72b99da8f4224a19ddcf1279a6450bbf"
 dependencies = [
  "cc",
  "pkg-config",
  "vcpkg",
 ]
 
 [[package]]
 name = "link-cplusplus"
 version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9272ab7b96c9046fbc5bc56c06c117cb639fe2d509df0c421cad82d2915cf369"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "log"
 version = "0.4.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
 dependencies = [
  "cfg-if",
 ]
 
 [[package]]
 name = "logging_timer"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "64e96f261d684b7089aa576bb74e823241dccd994b27d30fabf1dcb3af284fe9"
 dependencies = [
  "log",
  "logging_timer_proc_macros",
 ]
 
 [[package]]
 name = "logging_timer_proc_macros"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "10a9062912d7952c5588cc474795e0b9ee008e7e6781127945b85413d4b99d81"
 dependencies = [
  "log",
  "proc-macro2",
  "quote",
  "syn",
 ]
 
 [[package]]
 name = "memchr"
 version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
 
 [[package]]
 name = "memmap2"
 version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4b182332558b18d807c4ce1ca8ca983b34c3ee32765e47b3f0f69b90355cc1dc"
 dependencies = [
  "libc",
  "stable_deref_trait",
 ]
 
 [[package]]
 name = "memoffset"
 version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
 dependencies = [
  "autocfg",
 ]
 
 [[package]]
 name = "miniz_oxide"
 version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "96590ba8f175222643a85693f33d26e9c8a015f599c216509b1a6894af675d34"
 dependencies = [
  "adler",
 ]
 
 [[package]]
 name = "nom8"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ae01545c9c7fc4486ab7debaf2aad7003ac19431791868fb2e8066df97fad2f8"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "num-traits"
 version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
 dependencies = [
  "autocfg",
  "libm",
 ]
 
 [[package]]
 name = "num_cpus"
 version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f6058e64324c71e02bc2b150e4f3bc8286db6c83092132ffa3f6b1eab0f9def5"
 dependencies = [
  "hermit-abi",
  "libc",
 ]
 
 [[package]]
 name = "once_cell"
 version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"
 
 [[package]]
 name = "opaque-debug"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
 
 [[package]]
 name = "option-ext"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
 [[package]]
 name = "os_str_bytes"
 version = "6.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7b5bf27447411e9ee3ff51186bf7a08e16c341efdde93f4d823e8844429bed7e"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "output_vt100"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "628223faebab4e3e40667ee0b2336d34a5b960ff60ea743ddfdbcf7770bcfb66"
 dependencies = [
  "winapi",
 ]
 
 [[package]]
 name = "paste"
 version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b1de2e551fb905ac83f73f7aedf2f0cb4a0da7e35efa24a202a936269f1f18e1"
 
 [[package]]
 name = "pkg-config"
 version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
 
 [[package]]
 name = "ppv-lite86"
 version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
 [[package]]
 name = "pretty_assertions"
 version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a25e9bcb20aa780fd0bb16b72403a9064d6b3f22f026946029acb941a50af755"
 dependencies = [
  "ctor",
  "diff",
  "output_vt100",
  "yansi",
 ]
 
 [[package]]
 name = "proc-macro-error"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
 dependencies = [
  "proc-macro-error-attr",
  "proc-macro2",
  "quote",
  "syn",
  "version_check",
 ]
 
 [[package]]
 name = "proc-macro-error-attr"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
 dependencies = [
  "proc-macro2",
  "quote",
  "version_check",
 ]
 
 [[package]]
 name = "proc-macro2"
 version = "1.0.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5ea3d908b0e36316caf9e9e2c4625cdde190a7e6f440d794667ed17a1855e725"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "python3-sys"
 version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0f53ef6740367a09718d2cd21ba15b0d7972342a38e554736bcee7773e45c9f5"
 dependencies = [
  "libc",
  "regex",
 ]
 
 [[package]]
 name = "quote"
 version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "radium"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
 
 [[package]]
 name = "rand"
 version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
 dependencies = [
  "getrandom 0.1.16",
  "libc",
  "rand_chacha 0.2.2",
  "rand_core 0.5.1",
  "rand_hc",
 ]
 
 [[package]]
 name = "rand"
 version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
  "libc",
  "rand_chacha 0.3.1",
  "rand_core 0.6.4",
 ]
 
 [[package]]
 name = "rand_chacha"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
 dependencies = [
  "ppv-lite86",
  "rand_core 0.5.1",
 ]
 
 [[package]]
 name = "rand_chacha"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
  "rand_core 0.6.4",
 ]
 
 [[package]]
 name = "rand_core"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
 dependencies = [
  "getrandom 0.1.16",
 ]
 
 [[package]]
 name = "rand_core"
 version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
  "getrandom 0.2.8",
 ]
 
 [[package]]
 name = "rand_distr"
 version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32cb0b9bc82b0a0876c2dd994a7e7a2683d3e7390ca40e6886785ef0c7e3ee31"
 dependencies = [
  "num-traits",
  "rand 0.8.5",
 ]
 
 [[package]]
 name = "rand_hc"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
 dependencies = [
  "rand_core 0.5.1",
 ]
 
 [[package]]
 name = "rand_pcg"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "59cad018caf63deb318e5a4586d99a24424a364f40f1e5778c29aca23f4fc73e"
 dependencies = [
  "rand_core 0.6.4",
 ]
 
 [[package]]
 name = "rand_xoshiro"
 version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f97cdb2a36ed4183de61b2f824cc45c9f1037f28afe0a322e9fff4c108b5aaa"
 dependencies = [
  "rand_core 0.6.4",
 ]
 
 [[package]]
 name = "rayon"
 version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
 dependencies = [
  "either",
  "rayon-core",
 ]
 
 [[package]]
 name = "rayon-core"
 version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
 dependencies = [
  "crossbeam-channel",
  "crossbeam-deque",
  "crossbeam-utils",
  "num_cpus",
 ]
 
 [[package]]
 name = "redox_syscall"
 version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
 dependencies = [
  "bitflags 1.3.2",
 ]
 
 [[package]]
 name = "redox_users"
 version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"
 dependencies = [
  "getrandom 0.2.8",
  "libredox",
  "thiserror",
 ]
 
 [[package]]
 name = "regex"
 version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e076559ef8e241f2ae3479e36f97bd5741c0330689e217ad51ce2c76808b868a"
 dependencies = [
  "aho-corasick",
  "memchr",
  "regex-syntax",
 ]
 
 [[package]]
 name = "regex-automata"
 version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "59b23e92ee4318893fa3fe3e6fb365258efbfe6ac6ab30f090cdcbb7aa37efa9"
 
 [[package]]
 name = "regex-syntax"
 version = "0.6.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
 
 [[package]]
 name = "remove_dir_all"
 version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
 dependencies = [
  "winapi",
 ]
 
 [[package]]
 name = "rhg"
 version = "0.1.0"
 dependencies = [
  "atty",
  "chrono",
  "clap",
  "derive_more",
  "env_logger",
  "format-bytes",
  "hg-core",
  "home",
  "lazy_static",
+ "libc",
  "log",
  "logging_timer",
  "rayon",
  "regex",
  "shellexpand",
  "which",
  "whoami",
 ]
 
 [[package]]
 name = "rustc_version"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
 dependencies = [
  "semver",
 ]
 
 [[package]]
 name = "same-file"
 version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
 dependencies = [
  "winapi-util",
 ]
 
 [[package]]
 name = "scopeguard"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "scratch"
 version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8132065adcfd6e02db789d9285a0deb2f3fcb04002865ab67d5fb103533898"
 
 [[package]]
 name = "self_cell"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4a3926e239738d36060909ffe6f511502f92149a45a1fade7fe031cb2d33e88b"
 
 [[package]]
 name = "semver"
 version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e25dfac463d778e353db5be2449d1cce89bd6fd23c9f1ea21310ce6e5a1b29c4"
 
 [[package]]
 name = "serde"
 version = "1.0.152"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bb7d1f0d3021d347a83e556fc4683dea2ea09d87bccdf88ff5c12545d89d5efb"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
 version = "1.0.152"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af487d118eecd09402d70a5d72551860e788df87b464af30e5ea6a38c75c541e"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
 ]
 
 [[package]]
 name = "serde_spanned"
 version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0efd8caf556a6cebd3b285caf480045fcc1ac04f6bd786b09a6f11af30c4fcf4"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "sha-1"
 version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "99cd6713db3cf16b6c84e06321e049a9b9f699826e16096d23bbcc44d15d51a6"
 dependencies = [
  "block-buffer 0.9.0",
  "cfg-if",
  "cpufeatures",
  "digest 0.9.0",
  "opaque-debug",
 ]
 
 [[package]]
 name = "sha-1"
 version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "028f48d513f9678cda28f6e4064755b3fbb2af6acd672f2c209b62323f7aea0f"
 dependencies = [
  "cfg-if",
  "cpufeatures",
  "digest 0.10.5",
 ]
 
 [[package]]
 name = "shellexpand"
 version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da03fa3b94cc19e3ebfc88c4229c49d8f08cdbd1228870a45f0ffdf84988e14b"
 dependencies = [
  "bstr",
  "dirs",
  "os_str_bytes",
 ]
 
 [[package]]
 name = "sized-chunks"
 version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "16d69225bde7a69b235da73377861095455d298f2b970996eec25ddbb42b3d1e"
 dependencies = [
  "bitmaps",
  "typenum",
 ]
 
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
 name = "static_assertions"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "strsim"
 version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
 [[package]]
 name = "syn"
 version = "1.0.109"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-ident",
 ]
 
 [[package]]
 name = "tap"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
 name = "tempfile"
 version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
 dependencies = [
  "cfg-if",
  "fastrand",
  "libc",
  "redox_syscall",
  "remove_dir_all",
  "winapi",
 ]
 
 [[package]]
 name = "termcolor"
 version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
 dependencies = [
  "winapi-util",
 ]
 
 [[package]]
 name = "thiserror"
 version = "1.0.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a5ab016db510546d856297882807df8da66a16fb8c4101cb8b30054b0d5b2d9c"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
 version = "1.0.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5420d42e90af0c38c3290abcca25b9b3bdf379fc9f55c528f53a269d9c9a267e"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
 ]
 
 [[package]]
 name = "thread_local"
 version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
 dependencies = [
  "once_cell",
 ]
 
 [[package]]
 name = "toml"
 version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4fb9d890e4dc9298b70f740f615f2e05b9db37dce531f6b24fb77ac993f9f217"
 dependencies = [
  "serde",
  "serde_spanned",
  "toml_datetime",
  "toml_edit",
 ]
 
 [[package]]
 name = "toml_datetime"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4553f467ac8e3d374bc9a177a26801e5d0f9b211aa1673fb137a403afd1c9cf5"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "toml_edit"
 version = "0.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56c59d8dd7d0dcbc6428bf7aa2f0e823e26e43b3c9aca15bbc9475d23e5fa12b"
 dependencies = [
  "indexmap",
  "nom8",
  "serde",
  "serde_spanned",
  "toml_datetime",
 ]
 
 [[package]]
 name = "twox-hash"
 version = "1.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
 dependencies = [
  "cfg-if",
  "rand 0.8.5",
  "static_assertions",
 ]
 
 [[package]]
 name = "typenum"
 version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
 
 [[package]]
 name = "unicode-ident"
 version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3"
 
 [[package]]
 name = "unicode-width"
 version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
 
 [[package]]
 name = "vcpkg"
 version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
 [[package]]
 name = "vcsgraph"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4cb68c231e2575f7503a7c19213875f9d4ec2e84e963a56ce3de4b6bee351ef7"
 dependencies = [
  "hex",
  "rand 0.7.3",
  "sha-1 0.9.8",
 ]
 
 [[package]]
 name = "version_check"
 version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
 [[package]]
 name = "wasi"
 version = "0.9.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
 
 [[package]]
 name = "wasi"
 version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm-bindgen"
 version = "0.2.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268"
 dependencies = [
  "cfg-if",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
 version = "0.2.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142"
 dependencies = [
  "bumpalo",
  "log",
  "once_cell",
  "proc-macro2",
  "quote",
  "syn",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
 version = "0.2.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro-support"
 version = "0.2.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
 version = "0.2.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f"
 
 [[package]]
 name = "web-sys"
 version = "0.3.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bcda906d8be16e728fd5adc5b729afad4e444e106ab28cd1c7256e54fa61510f"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "which"
 version = "4.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1c831fbbee9e129a8cf93e7747a82da9d95ba8e16621cae60ec2cdc849bacb7b"
 dependencies = [
  "either",
  "libc",
  "once_cell",
 ]
 
 [[package]]
 name = "whoami"
 version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2c70234412ca409cc04e864e89523cb0fc37f5e1344ebed5a3ebf4192b6b9f68"
 dependencies = [
  "wasm-bindgen",
  "web-sys",
 ]
 
 [[package]]
 name = "winapi"
 version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
 dependencies = [
  "winapi-i686-pc-windows-gnu",
  "winapi-x86_64-pc-windows-gnu",
 ]
 
 [[package]]
 name = "winapi-i686-pc-windows-gnu"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
 dependencies = [
  "winapi",
 ]
 
 [[package]]
 name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
 dependencies = [
  "windows-targets 0.48.5",
 ]
 
 [[package]]
 name = "windows-targets"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
 dependencies = [
  "windows_aarch64_gnullvm 0.48.5",
  "windows_aarch64_msvc 0.48.5",
  "windows_i686_gnu 0.48.5",
  "windows_i686_msvc 0.48.5",
  "windows_x86_64_gnu 0.48.5",
  "windows_x86_64_gnullvm 0.48.5",
  "windows_x86_64_msvc 0.48.5",
 ]
 
 [[package]]
 name = "windows-targets"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a18201040b24831fbb9e4eb208f8892e1f50a37feb53cc7ff887feb8f50e7cd"
 dependencies = [
  "windows_aarch64_gnullvm 0.52.0",
  "windows_aarch64_msvc 0.52.0",
  "windows_i686_gnu 0.52.0",
  "windows_i686_msvc 0.52.0",
  "windows_x86_64_gnu 0.52.0",
  "windows_x86_64_gnullvm 0.52.0",
  "windows_x86_64_msvc 0.52.0",
 ]
 
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
 
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea"
 
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
 
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef"
 
 [[package]]
 name = "windows_i686_gnu"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
 
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313"
 
 [[package]]
 name = "windows_i686_msvc"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
 
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a"
 
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
 
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e"
 
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
 
 [[package]]
 name = "wyz"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
 dependencies = [
  "tap",
 ]
 
 [[package]]
 name = "yansi"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
 
 [[package]]
 name = "zstd"
 version = "0.12.3+zstd.1.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "76eea132fb024e0e13fd9c2f5d5d595d8a967aa72382ac2f9d39fcc95afd0806"
 dependencies = [
  "zstd-safe",
 ]
 
 [[package]]
 name = "zstd-safe"
 version = "6.0.4+zstd.1.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7afb4b54b8910cf5447638cb54bf4e8a65cbedd783af98b98c62ffe91f185543"
 dependencies = [
  "libc",
  "zstd-sys",
 ]
 
 [[package]]
 name = "zstd-sys"
 version = "2.0.7+zstd.1.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94509c3ba2fe55294d752b79842c530ccfab760192521df74a081a78d2b3c7f5"
 dependencies = [
  "cc",
  "libc",
  "pkg-config",
 ]

rust/rhg/Cargo.toml

@@ -1,26 +1,27
 [package]
 name = "rhg"
 version = "0.1.0"
 authors = [
     "Antoine Cezar <[e-mail]>",
     "Raphaël Gomès <[e-mail]>",
 ]
 edition = "2021"
 
 [dependencies]
 atty = "0.2.14"
 hg-core = { path = "../hg-core"}
 chrono = "0.4.23"
 clap = { version = "4.0.24", features = ["cargo"] }
 derive_more = "0.99.17"
 home = "0.5.4"
 lazy_static = "1.4.0"
 log = "0.4.17"
 logging_timer = "1.1.0"
 regex = "1.7.0"
 env_logger = "0.9.3"
 format-bytes = "0.3.0"
 shellexpand = { version = "3.1", features = ["full"]}
 whoami = "1.4"
 which = "4.3.0"
 rayon = "1.7.0"
+libc = "0.2.155"

rust/rhg/src/commands/status.rs

@@ -1,821 +1,825
 // status.rs
 //
 // Copyright 2020, Georges Racinet <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use crate::error::CommandError;
 use crate::ui::{
     format_pattern_file_warning, print_narrow_sparse_warnings, relative_paths,
     RelativePaths, Ui,
 };
 use crate::utils::path_utils::RelativizePaths;
 use clap::Arg;
 use format_bytes::format_bytes;
 use hg::config::Config;
 use hg::dirstate::has_exec_bit;
 use hg::dirstate::status::StatusPath;
 use hg::dirstate::TruncatedTimestamp;
 use hg::errors::{HgError, IoResultExt};
 use hg::filepatterns::parse_pattern_args;
 use hg::lock::LockError;
 use hg::manifest::Manifest;
 use hg::matchers::{AlwaysMatcher, IntersectionMatcher};
 use hg::repo::Repo;
 use hg::utils::debug::debug_wait_for_file;
 use hg::utils::files::{
     get_bytes_from_os_str, get_bytes_from_os_string, get_path_from_bytes,
 };
 use hg::utils::hg_path::{hg_path_to_path_buf, HgPath};
 use hg::PatternFileWarning;
 use hg::Revision;
 use hg::StatusError;
 use hg::StatusOptions;
 use hg::{self, narrow, sparse};
 use hg::{DirstateStatus, RevlogOpenOptions};
 use log::info;
 use rayon::prelude::*;
 use std::borrow::Cow;
 use std::io;
 use std::mem::take;
 use std::path::PathBuf;
 
 pub const HELP_TEXT: &str = "
 Show changed files in the working directory
 
 This is a pure Rust version of `hg status`.
 
 Some options might be missing, check the list below.
 ";
 
 pub fn args() -> clap::Command {
     clap::command!("status")
         .alias("st")
         .about(HELP_TEXT)
         .arg(
             Arg::new("file")
                 .value_parser(clap::value_parser!(std::ffi::OsString))
                 .help("show only these files")
                 .action(clap::ArgAction::Append),
         )
         .arg(
             Arg::new("all")
                 .help("show status of all files")
                 .short('A')
                 .action(clap::ArgAction::SetTrue)
                 .long("all"),
         )
         .arg(
             Arg::new("modified")
                 .help("show only modified files")
                 .short('m')
                 .action(clap::ArgAction::SetTrue)
                 .long("modified"),
         )
         .arg(
             Arg::new("added")
                 .help("show only added files")
                 .short('a')
                 .action(clap::ArgAction::SetTrue)
                 .long("added"),
         )
         .arg(
             Arg::new("removed")
                 .help("show only removed files")
                 .short('r')
                 .action(clap::ArgAction::SetTrue)
                 .long("removed"),
         )
         .arg(
             Arg::new("clean")
                 .help("show only clean files")
                 .short('c')
                 .action(clap::ArgAction::SetTrue)
                 .long("clean"),
         )
         .arg(
             Arg::new("deleted")
                 .help("show only deleted files")
                 .short('d')
                 .action(clap::ArgAction::SetTrue)
                 .long("deleted"),
         )
         .arg(
             Arg::new("unknown")
                 .help("show only unknown (not tracked) files")
                 .short('u')
                 .action(clap::ArgAction::SetTrue)
                 .long("unknown"),
         )
         .arg(
             Arg::new("ignored")
                 .help("show only ignored files")
                 .short('i')
                 .action(clap::ArgAction::SetTrue)
                 .long("ignored"),
         )
         .arg(
             Arg::new("copies")
                 .help("show source of copied files (DEFAULT: ui.statuscopies)")
                 .short('C')
                 .action(clap::ArgAction::SetTrue)
                 .long("copies"),
         )
         .arg(
             Arg::new("print0")
                 .help("end filenames with NUL, for use with xargs")
                 .short('0')
                 .action(clap::ArgAction::SetTrue)
                 .long("print0"),
         )
         .arg(
             Arg::new("no-status")
                 .help("hide status prefix")
                 .short('n')
                 .action(clap::ArgAction::SetTrue)
                 .long("no-status"),
         )
         .arg(
             Arg::new("verbose")
                 .help("enable additional output")
                 .short('v')
                 .action(clap::ArgAction::SetTrue)
                 .long("verbose"),
         )
         .arg(
             Arg::new("rev")
                 .help("show difference from/to revision")
                 .long("rev")
                 .num_args(1)
                 .action(clap::ArgAction::Append)
                 .value_name("REV"),
         )
 }
 
 fn parse_revpair(
     repo: &Repo,
     revs: Option<Vec<String>>,
 ) -> Result<Option<(Revision, Revision)>, CommandError> {
     let revs = match revs {
         None => return Ok(None),
         Some(revs) => revs,
     };
     if revs.is_empty() {
         return Ok(None);
     }
     if revs.len() != 2 {
         return Err(CommandError::unsupported("expected 0 or 2 --rev flags"));
     }
 
     let rev1 = &revs[0];
     let rev2 = &revs[1];
     let rev1 = hg::revset::resolve_single(rev1, repo)
         .map_err(|e| (e, rev1.as_str()))?;
     let rev2 = hg::revset::resolve_single(rev2, repo)
         .map_err(|e| (e, rev2.as_str()))?;
     Ok(Some((rev1, rev2)))
 }
 
 /// Pure data type allowing the caller to specify file states to display
 #[derive(Copy, Clone, Debug)]
 pub struct DisplayStates {
     pub modified: bool,
     pub added: bool,
     pub removed: bool,
     pub clean: bool,
     pub deleted: bool,
     pub unknown: bool,
     pub ignored: bool,
 }
 
 pub const DEFAULT_DISPLAY_STATES: DisplayStates = DisplayStates {
     modified: true,
     added: true,
     removed: true,
     clean: false,
     deleted: true,
     unknown: true,
     ignored: false,
 };
 
 pub const ALL_DISPLAY_STATES: DisplayStates = DisplayStates {
     modified: true,
     added: true,
     removed: true,
     clean: true,
     deleted: true,
     unknown: true,
     ignored: true,
 };
 
 impl DisplayStates {
     pub fn is_empty(&self) -> bool {
         !(self.modified
             || self.added
             || self.removed
             || self.clean
             || self.deleted
             || self.unknown
             || self.ignored)
     }
 }
 
 fn has_unfinished_merge(repo: &Repo) -> Result<bool, CommandError> {
     Ok(repo.dirstate_parents()?.is_merge())
 }
 
 fn has_unfinished_state(repo: &Repo) -> Result<bool, CommandError> {
     // These are all the known values for the [fname] argument of
     // [addunfinished] function in [state.py]
     let known_state_files: &[&str] = &[
         "bisect.state",
         "graftstate",
         "histedit-state",
         "rebasestate",
         "shelvedstate",
         "transplant/journal",
         "updatestate",
     ];
     if has_unfinished_merge(repo)? {
         return Ok(true);
     };
     for f in known_state_files {
         if repo.hg_vfs().join(f).exists() {
             return Ok(true);
         }
     }
     Ok(false)
 }
 
 pub fn run(invocation: &crate::CliInvocation) -> Result<(), CommandError> {
     // TODO: lift these limitations
     if invocation
         .config
         .get(b"commands", b"status.terse")
         .is_some()
     {
         return Err(CommandError::unsupported(
             "status.terse is not yet supported with rhg status",
         ));
     }
 
     let ui = invocation.ui;
     let config = invocation.config;
     let args = invocation.subcommand_args;
 
     let revs = args.get_many::<String>("rev");
     let print0 = args.get_flag("print0");
     let verbose = args.get_flag("verbose")
         || config.get_bool(b"ui", b"verbose")?
         || config.get_bool(b"commands", b"status.verbose")?;
     let verbose = verbose && !print0;
 
     let all = args.get_flag("all");
     let display_states = if all {
         // TODO when implementing `--quiet`: it excludes clean files
         // from `--all`
         ALL_DISPLAY_STATES
     } else {
         let requested = DisplayStates {
             modified: args.get_flag("modified"),
             added: args.get_flag("added"),
             removed: args.get_flag("removed"),
             clean: args.get_flag("clean"),
             deleted: args.get_flag("deleted"),
             unknown: args.get_flag("unknown"),
             ignored: args.get_flag("ignored"),
         };
         if requested.is_empty() {
             DEFAULT_DISPLAY_STATES
         } else {
             requested
         }
     };
     let no_status = args.get_flag("no-status");
     let list_copies = all
         || args.get_flag("copies")
         || config.get_bool(b"ui", b"statuscopies")?;
 
     let repo = invocation.repo?;
     let revpair = parse_revpair(repo, revs.map(|i| i.cloned().collect()))?;
 
     if verbose && has_unfinished_state(repo)? {
         return Err(CommandError::unsupported(
             "verbose status output is not supported by rhg (and is needed because we're in an unfinished operation)",
         ));
     }
 
     let mut dmap = repo.dirstate_map_mut()?;
 
     let check_exec = hg::checkexec::check_exec(repo.working_directory_path());
 
     let options = StatusOptions {
         check_exec,
         list_clean: display_states.clean,
         list_unknown: display_states.unknown,
         list_ignored: display_states.ignored,
         list_copies,
         collect_traversed_dirs: false,
     };
 
     type StatusResult<'a> =
         Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>;
 
     let relative_status = config
         .get_option(b"commands", b"status.relative")?
         .expect("commands.status.relative should have a default value");
 
     let relativize_paths = relative_status || {
         // See in Python code with `getuipathfn` usage in `commands.py`.
         let legacy_relative_behavior = args.contains_id("file");
         match relative_paths(invocation.config)? {
             RelativePaths::Legacy => legacy_relative_behavior,
             RelativePaths::Bool(v) => v,
         }
     };
 
     let mut output = DisplayStatusPaths {
         ui,
         no_status,
         relativize: if relativize_paths {
             Some(RelativizePaths::new(repo)?)
         } else {
             None
         },
         print0,
     };
 
     let after_status = |res: StatusResult| -> Result<_, CommandError> {
         let (mut ds_status, pattern_warnings) = res?;
         for warning in pattern_warnings {
             ui.write_stderr(&format_pattern_file_warning(&warning, repo))?;
         }
 
         for (path, error) in take(&mut ds_status.bad) {
             let error = match error {
                 hg::BadMatch::OsError(code) => {
                     std::io::Error::from_raw_os_error(code).to_string()
                 }
                 hg::BadMatch::BadType(ty) => {
                     format!("unsupported file type (type is {})", ty)
                 }
             };
             ui.write_stderr(&format_bytes!(
                 b"{}: {}\n",
                 path.as_bytes(),
                 error.as_bytes()
             ))?
         }
         if !ds_status.unsure.is_empty() {
             info!(
                 "Files to be rechecked by retrieval from filelog: {:?}",
                 ds_status.unsure.iter().map(|s| &s.path).collect::<Vec<_>>()
             );
         }
         let mut fixup = Vec::new();
         if !ds_status.unsure.is_empty()
             && (display_states.modified || display_states.clean)
         {
             let p1 = repo.dirstate_parents()?.p1;
             let manifest = repo.manifest_for_node(p1).map_err(|e| {
                 CommandError::from((e, &*format!("{:x}", p1.short())))
             })?;
             let working_directory_vfs = repo.working_directory_vfs();
             let store_vfs = repo.store_vfs();
             let revlog_open_options = repo.default_revlog_options(false)?;
             let res: Vec<_> = take(&mut ds_status.unsure)
                 .into_par_iter()
                 .map(|to_check| {
                     // The compiler seems to get a bit confused with complex
                     // inference when using a parallel iterator + map
                     // + map_err + collect, so let's just inline some of the
                     // logic.
                     match unsure_is_modified(
                         working_directory_vfs,
                         store_vfs,
                         check_exec,
                         &manifest,
                         &to_check.path,
                         revlog_open_options,
                     ) {
                         Err(HgError::IoError { .. }) => {
                             // IO errors most likely stem from the file being
                             // deleted even though we know it's in the
                             // dirstate.
                             Ok((to_check, UnsureOutcome::Deleted))
                         }
                         Ok(outcome) => Ok((to_check, outcome)),
                         Err(e) => Err(e),
                     }
                 })
                 .collect::<Result<_, _>>()?;
             for (status_path, outcome) in res.into_iter() {
                 match outcome {
                     UnsureOutcome::Clean => {
                         if display_states.clean {
                             ds_status.clean.push(status_path.clone());
                         }
                         fixup.push(status_path.path.into_owned())
                     }
                     UnsureOutcome::Modified => {
                         if display_states.modified {
                             ds_status.modified.push(status_path);
                         }
                     }
                     UnsureOutcome::Deleted => {
                         if display_states.deleted {
                             ds_status.deleted.push(status_path);
                         }
                     }
                 }
             }
         }
 
         let dirstate_write_needed = ds_status.dirty;
         let filesystem_time_at_status_start =
             ds_status.filesystem_time_at_status_start;
 
         output.output(display_states, ds_status)?;
 
         Ok((
             fixup,
             dirstate_write_needed,
             filesystem_time_at_status_start,
         ))
     };
     let (narrow_matcher, narrow_warnings) = narrow::matcher(repo)?;
 
     if let Some((rev1, rev2)) = revpair {
         let mut ds_status = DirstateStatus::default();
         if list_copies {
             return Err(CommandError::unsupported(
                 "status --rev --rev with copy information is not implemented yet",
             ));
         }
 
         let stat = hg::operations::status_rev_rev_no_copies(
             repo,
             rev1,
             rev2,
             narrow_matcher,
         )?;
         for entry in stat.iter() {
             let (path, status) = entry?;
             let path = StatusPath {
                 path: Cow::Borrowed(path),
                 copy_source: None,
             };
             match status {
                 hg::operations::DiffStatus::Removed => {
                     if display_states.removed {
                         ds_status.removed.push(path)
                     }
                 }
                 hg::operations::DiffStatus::Added => {
                     if display_states.added {
                         ds_status.added.push(path)
                     }
                 }
                 hg::operations::DiffStatus::Modified => {
                     if display_states.modified {
                         ds_status.modified.push(path)
                     }
                 }
                 hg::operations::DiffStatus::Matching => {
                     if display_states.clean {
                         ds_status.clean.push(path)
                     }
                 }
             }
         }
         output.output(display_states, ds_status)?;
         return Ok(());
     }
 
     let (sparse_matcher, sparse_warnings) = sparse::matcher(repo)?;
     let matcher = match (repo.has_narrow(), repo.has_sparse()) {
         (true, true) => {
             Box::new(IntersectionMatcher::new(narrow_matcher, sparse_matcher))
         }
         (true, false) => narrow_matcher,
         (false, true) => sparse_matcher,
         (false, false) => Box::new(AlwaysMatcher),
     };
     let matcher = match args.get_many::<std::ffi::OsString>("file") {
         None => matcher,
         Some(files) => {
             let patterns: Vec<Vec<u8>> = files
                 .filter(|s| !s.is_empty())
                 .map(get_bytes_from_os_str)
                 .collect();
             for file in &patterns {
                 if file.starts_with(b"set:") {
                     return Err(CommandError::unsupported("fileset"));
                 }
             }
             let cwd = hg::utils::current_dir()?;
             let root = repo.working_directory_path();
             let ignore_patterns = parse_pattern_args(patterns, &cwd, root)?;
             let files_matcher =
                 hg::matchers::PatternMatcher::new(ignore_patterns)?;
             Box::new(IntersectionMatcher::new(
                 Box::new(files_matcher),
                 matcher,
             ))
         }
     };
 
     print_narrow_sparse_warnings(
         &narrow_warnings,
         &sparse_warnings,
         ui,
         repo,
     )?;
     let (fixup, mut dirstate_write_needed, filesystem_time_at_status_start) =
         dmap.with_status(
             matcher.as_ref(),
             repo.working_directory_path().to_owned(),
             ignore_files(repo, config),
             options,
             after_status,
         )?;
 
     // Development config option to test write races
     if let Err(e) =
         debug_wait_for_file(config, "status.pre-dirstate-write-file")
     {
         ui.write_stderr(e.as_bytes()).ok();
     }
 
     if (fixup.is_empty() || filesystem_time_at_status_start.is_none())
         && !dirstate_write_needed
     {
         // Nothing to update
         return Ok(());
     }
 
     // Update the dirstate on disk if we can
     let with_lock_result =
         repo.try_with_wlock_no_wait(|| -> Result<(), CommandError> {
             if let Some(mtime_boundary) = filesystem_time_at_status_start {
                 for hg_path in fixup {
                     use std::os::unix::fs::MetadataExt;
                     let fs_path = hg_path_to_path_buf(&hg_path)
                         .expect("HgPath conversion");
                     // Specifically do not reuse `fs_metadata` from
                     // `unsure_is_clean` which was needed before reading
                     // contents. Here we access metadata again after reading
                     // content, in case it changed in the meantime.
                     let metadata_res = repo
                         .working_directory_vfs()
                         .symlink_metadata(&fs_path);
                     let fs_metadata = match metadata_res {
                         Ok(meta) => meta,
                         Err(err) => match err {
                             HgError::IoError { .. } => {
                                 // The file has probably been deleted. In any
                                 // case, it was in the dirstate before, so
                                 // let's ignore the error.
                                 continue;
                             }
                             _ => return Err(err.into()),
                         },
                     };
                     if let Some(mtime) =
                         TruncatedTimestamp::for_reliable_mtime_of(
                             &fs_metadata,
                             &mtime_boundary,
                         )
                         .when_reading_file(&fs_path)?
                     {
                         let mode = fs_metadata.mode();
                         let size = fs_metadata.len();
                         dmap.set_clean(&hg_path, mode, size as u32, mtime)?;
                         dirstate_write_needed = true
                     }
                 }
             }
             drop(dmap); // Avoid "already mutably borrowed" RefCell panics
             if dirstate_write_needed {
                 repo.write_dirstate()?
             }
             Ok(())
         });
     match with_lock_result {
         Ok(closure_result) => closure_result?,
         Err(LockError::AlreadyHeld) => {
             // Not updating the dirstate is not ideal but not critical:
             // don’t keep our caller waiting until some other Mercurial
             // process releases the lock.
             log::info!("not writing dirstate from `status`: lock is held")
         }
         Err(LockError::Other(HgError::IoError { error, .. }))
-            if error.kind() == io::ErrorKind::PermissionDenied =>
+            if error.kind() == io::ErrorKind::PermissionDenied
+                || match error.raw_os_error() {
+                    None => false,
+                    Some(errno) => libc::EROFS == errno,
+                } =>
         {
             // `hg status` on a read-only repository is fine
         }
         Err(LockError::Other(error)) => {
             // Report other I/O errors
             Err(error)?
         }
     }
     Ok(())
 }
 
 fn ignore_files(repo: &Repo, config: &Config) -> Vec<PathBuf> {
     let mut ignore_files = Vec::new();
     let repo_ignore = repo.working_directory_vfs().join(".hgignore");
     if repo_ignore.exists() {
         ignore_files.push(repo_ignore)
     }
     for (key, value) in config.iter_section(b"ui") {
         if key == b"ignore" || key.starts_with(b"ignore.") {
             let path = get_path_from_bytes(value);
             let path = shellexpand::path::full_with_context_no_errors(
                 path,
                 home::home_dir,
                 |s| std::env::var(s).ok(),
             );
             let joined = repo.working_directory_path().join(path);
             ignore_files.push(joined);
         }
     }
     ignore_files
 }
 
 struct DisplayStatusPaths<'a> {
     ui: &'a Ui,
     no_status: bool,
     relativize: Option<RelativizePaths>,
     print0: bool,
 }
 
 impl DisplayStatusPaths<'_> {
     // Probably more elegant to use a Deref or Borrow trait rather than
     // harcode HgPathBuf, but probably not really useful at this point
     fn display(
         &self,
         status_prefix: &[u8],
         label: &'static str,
         mut paths: Vec<StatusPath<'_>>,
     ) -> Result<(), CommandError> {
         paths.sort_unstable();
         // TODO: get the stdout lock once for the whole loop
         // instead of in each write
         for StatusPath { path, copy_source } in paths {
             let relative_path;
             let relative_source;
             let (path, copy_source) = if let Some(relativize) =
                 &self.relativize
             {
                 relative_path = relativize.relativize(&path);
                 relative_source =
                     copy_source.as_ref().map(|s| relativize.relativize(s));
                 (&*relative_path, relative_source.as_deref())
             } else {
                 (path.as_bytes(), copy_source.as_ref().map(|s| s.as_bytes()))
             };
             // TODO: Add a way to use `write_bytes!` instead of `format_bytes!`
             // in order to stream to stdout instead of allocating an
             // itermediate `Vec<u8>`.
             if !self.no_status {
                 self.ui.write_stdout_labelled(status_prefix, label)?
             }
             let linebreak = if self.print0 { b"\x00" } else { b"\n" };
             self.ui.write_stdout_labelled(
                 &format_bytes!(b"{}{}", path, linebreak),
                 label,
             )?;
             if let Some(source) = copy_source.filter(|_| !self.no_status) {
                 let label = "status.copied";
                 self.ui.write_stdout_labelled(
                     &format_bytes!(b"  {}{}", source, linebreak),
                     label,
                 )?
             }
         }
         Ok(())
     }
 
     fn output(
         &mut self,
         display_states: DisplayStates,
         ds_status: DirstateStatus,
     ) -> Result<(), CommandError> {
         if display_states.modified {
             self.display(b"M ", "status.modified", ds_status.modified)?;
         }
         if display_states.added {
             self.display(b"A ", "status.added", ds_status.added)?;
         }
         if display_states.removed {
             self.display(b"R ", "status.removed", ds_status.removed)?;
         }
         if display_states.deleted {
             self.display(b"! ", "status.deleted", ds_status.deleted)?;
         }
         if display_states.unknown {
             self.display(b"? ", "status.unknown", ds_status.unknown)?;
         }
         if display_states.ignored {
             self.display(b"I ", "status.ignored", ds_status.ignored)?;
         }
         if display_states.clean {
             self.display(b"C ", "status.clean", ds_status.clean)?;
         }
         Ok(())
     }
 }
 
 /// Outcome of the additional check for an ambiguous tracked file
 enum UnsureOutcome {
     /// The file is actually clean
     Clean,
     /// The file has been modified
     Modified,
     /// The file was deleted on disk (or became another type of fs entry)
     Deleted,
 }
 
 /// Check if a file is modified by comparing actual repo store and file system.
 ///
 /// This meant to be used for those that the dirstate cannot resolve, due
 /// to time resolution limits.
 fn unsure_is_modified(
     working_directory_vfs: hg::vfs::Vfs,
     store_vfs: hg::vfs::Vfs,
     check_exec: bool,
     manifest: &Manifest,
     hg_path: &HgPath,
     revlog_open_options: RevlogOpenOptions,
 ) -> Result<UnsureOutcome, HgError> {
     let vfs = working_directory_vfs;
     let fs_path = hg_path_to_path_buf(hg_path).expect("HgPath conversion");
     let fs_metadata = vfs.symlink_metadata(&fs_path)?;
     let is_symlink = fs_metadata.file_type().is_symlink();
 
     let entry = manifest
         .find_by_path(hg_path)?
         .expect("ambgious file not in p1");
 
     // TODO: Also account for `FALLBACK_SYMLINK` and `FALLBACK_EXEC` from the
     // dirstate
     let fs_flags = if is_symlink {
         Some(b'l')
     } else if check_exec && has_exec_bit(&fs_metadata) {
         Some(b'x')
     } else {
         None
     };
 
     let entry_flags = if check_exec {
         entry.flags
     } else if entry.flags == Some(b'x') {
         None
     } else {
         entry.flags
     };
 
     if entry_flags != fs_flags {
         return Ok(UnsureOutcome::Modified);
     }
     let filelog = hg::filelog::Filelog::open_vfs(
         &store_vfs,
         hg_path,
         revlog_open_options,
     )?;
     let fs_len = fs_metadata.len();
     let file_node = entry.node_id()?;
     let filelog_entry = filelog.entry_for_node(file_node).map_err(|_| {
         HgError::corrupted(format!(
             "filelog {:?} missing node {:?} from manifest",
             hg_path, file_node
         ))
     })?;
     if filelog_entry.file_data_len_not_equal_to(fs_len) {
         // No need to read file contents:
         // it cannot be equal if it has a different length.
         return Ok(UnsureOutcome::Modified);
     }
 
     let p1_filelog_data = filelog_entry.data()?;
     let p1_contents = p1_filelog_data.file_data()?;
     if p1_contents.len() as u64 != fs_len {
         // No need to read file contents:
         // it cannot be equal if it has a different length.
         return Ok(UnsureOutcome::Modified);
     }
 
     let fs_contents = if is_symlink {
         get_bytes_from_os_string(vfs.read_link(fs_path)?.into_os_string())
     } else {
         vfs.read(fs_path)?
     };
 
     Ok(if p1_contents != &*fs_contents {
         UnsureOutcome::Modified
     } else {
         UnsureOutcome::Clean
     })
 }

setup.py

@@ -1,1840 +1,1844
 #
 # This is the mercurial setup script.
 #
 # 'python setup.py install', or
 # 'python setup.py --help' for more options
 import os
 
 # Mercurial can't work on 3.6.0 or 3.6.1 due to a bug in % formatting
 # in bytestrings.
 supportedpy = ','.join(
     [
         '>=3.6.2',
     ]
 )
 
 import sys, platform
 import sysconfig
 
 
 def sysstr(s):
     return s.decode('latin-1')
 
 
 def eprint(*args, **kwargs):
     kwargs['file'] = sys.stderr
     print(*args, **kwargs)
 
 
 import ssl
 
 # ssl.HAS_TLSv1* are preferred to check support but they were added in Python
 # 3.7. Prior to CPython commit 6e8cda91d92da72800d891b2fc2073ecbc134d98
 # (backported to the 3.7 branch), ssl.PROTOCOL_TLSv1_1 / ssl.PROTOCOL_TLSv1_2
 # were defined only if compiled against a OpenSSL version with TLS 1.1 / 1.2
 # support. At the mentioned commit, they were unconditionally defined.
 _notset = object()
 has_tlsv1_1 = getattr(ssl, 'HAS_TLSv1_1', _notset)
 if has_tlsv1_1 is _notset:
     has_tlsv1_1 = getattr(ssl, 'PROTOCOL_TLSv1_1', _notset) is not _notset
 has_tlsv1_2 = getattr(ssl, 'HAS_TLSv1_2', _notset)
 if has_tlsv1_2 is _notset:
     has_tlsv1_2 = getattr(ssl, 'PROTOCOL_TLSv1_2', _notset) is not _notset
 if not (has_tlsv1_1 or has_tlsv1_2):
     error = """
 The `ssl` module does not advertise support for TLS 1.1 or TLS 1.2.
 Please make sure that your Python installation was compiled against an OpenSSL
 version enabling these features (likely this requires the OpenSSL version to
 be at least 1.0.1).
 """
     print(error, file=sys.stderr)
     sys.exit(1)
 
 DYLIB_SUFFIX = sysconfig.get_config_vars()['EXT_SUFFIX']
 
 # Solaris Python packaging brain damage
 try:
     import hashlib
 
     sha = hashlib.sha1()
 except ImportError:
     try:
         import sha
 
         sha.sha  # silence unused import warning
     except ImportError:
         raise SystemExit(
             "Couldn't import standard hashlib (incomplete Python install)."
         )
 
 try:
     import zlib
 
     zlib.compressobj  # silence unused import warning
 except ImportError:
     raise SystemExit(
         "Couldn't import standard zlib (incomplete Python install)."
     )
 
 # The base IronPython distribution (as of 2.7.1) doesn't support bz2
 isironpython = False
 try:
     isironpython = (
         platform.python_implementation().lower().find("ironpython") != -1
     )
 except AttributeError:
     pass
 
 if isironpython:
     sys.stderr.write("warning: IronPython detected (no bz2 support)\n")
 else:
     try:
         import bz2
 
         bz2.BZ2Compressor  # silence unused import warning
     except ImportError:
         raise SystemExit(
             "Couldn't import standard bz2 (incomplete Python install)."
         )
 
 ispypy = "PyPy" in sys.version
 
 import ctypes
 import stat, subprocess, time
 import re
 import shutil
 import tempfile
 
 # We have issues with setuptools on some platforms and builders. Until
 # those are resolved, setuptools is opt-in except for platforms where
 # we don't have issues.
 issetuptools = os.name == 'nt' or 'FORCE_SETUPTOOLS' in os.environ
 if issetuptools:
     from setuptools import setup
 else:
     try:
         from distutils.core import setup
     except ModuleNotFoundError:
         from setuptools import setup
 from distutils.ccompiler import new_compiler
 from distutils.core import Command, Extension
 from distutils.dist import Distribution
 from distutils.command.build import build
 from distutils.command.build_ext import build_ext
 from distutils.command.build_py import build_py
 from distutils.command.build_scripts import build_scripts
 from distutils.command.install import install
 from distutils.command.install_lib import install_lib
 from distutils.command.install_scripts import install_scripts
 from distutils import log
 from distutils.spawn import spawn, find_executable
 from distutils import file_util
 from distutils.errors import (
     CCompilerError,
     DistutilsError,
     DistutilsExecError,
 )
 from distutils.sysconfig import get_python_inc
 
 
 def write_if_changed(path, content):
     """Write content to a file iff the content hasn't changed."""
     if os.path.exists(path):
         with open(path, 'rb') as fh:
             current = fh.read()
     else:
         current = b''
 
     if current != content:
         with open(path, 'wb') as fh:
             fh.write(content)
 
 
 scripts = ['hg']
 if os.name == 'nt':
     # We remove hg.bat if we are able to build hg.exe.
     scripts.append('contrib/win32/hg.bat')
 
 
 def cancompile(cc, code):
     tmpdir = tempfile.mkdtemp(prefix='hg-install-')
     devnull = oldstderr = None
     try:
         fname = os.path.join(tmpdir, 'testcomp.c')
         f = open(fname, 'w')
         f.write(code)
         f.close()
         # Redirect stderr to /dev/null to hide any error messages
         # from the compiler.
         # This will have to be changed if we ever have to check
         # for a function on Windows.
         devnull = open('/dev/null', 'w')
         oldstderr = os.dup(sys.stderr.fileno())
         os.dup2(devnull.fileno(), sys.stderr.fileno())
         objects = cc.compile([fname], output_dir=tmpdir)
         cc.link_executable(objects, os.path.join(tmpdir, "a.out"))
         return True
     except Exception:
         return False
     finally:
         if oldstderr is not None:
             os.dup2(oldstderr, sys.stderr.fileno())
         if devnull is not None:
             devnull.close()
         shutil.rmtree(tmpdir)
 
 
 # simplified version of distutils.ccompiler.CCompiler.has_function
 # that actually removes its temporary files.
 def hasfunction(cc, funcname):
     code = 'int main(void) { %s(); }\n' % funcname
     return cancompile(cc, code)
 
 
 def hasheader(cc, headername):
     code = '#include <%s>\nint main(void) { return 0; }\n' % headername
     return cancompile(cc, code)
 
 
 # py2exe needs to be installed to work
 try:
     import py2exe
 
     py2exe.patch_distutils()
     py2exeloaded = True
     # import py2exe's patched Distribution class
     from distutils.core import Distribution
 except ImportError:
     py2exeloaded = False
 
 
 def runcmd(cmd, env, cwd=None):
     p = subprocess.Popen(
         cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env, cwd=cwd
     )
     out, err = p.communicate()
     return p.returncode, out, err
 
 
 class hgcommand:
     def __init__(self, cmd, env):
         self.cmd = cmd
         self.env = env
 
     def __repr__(self):
         return f"<hgcommand cmd={self.cmd} env={self.env}>"
 
     def run(self, args):
         cmd = self.cmd + args
         returncode, out, err = runcmd(cmd, self.env)
         err = filterhgerr(err)
         if err:
             print("stderr from '%s':" % (' '.join(cmd)), file=sys.stderr)
             print(err, file=sys.stderr)
         if returncode != 0:
             print(
                 "non zero-return '%s': %d" % (' '.join(cmd), returncode),
                 file=sys.stderr,
             )
             return b''
         return out
 
 
 def filterhgerr(err):
     # If root is executing setup.py, but the repository is owned by
     # another user (as in "sudo python setup.py install") we will get
     # trust warnings since the .hg/hgrc file is untrusted. That is
     # fine, we don't want to load it anyway.  Python may warn about
     # a missing __init__.py in mercurial/locale, we also ignore that.
     err = [
         e
         for e in err.splitlines()
         if (
             not e.startswith(b'not trusting file')
             and not e.startswith(b'warning: Not importing')
             and not (
                 e.startswith(b'obsolete feature not enabled')
                 or e.startswith(b'"obsolete" feature not enabled')
             )
             and not e.startswith(b'*** failed to import extension')
             and not e.startswith(b'devel-warn:')
             and not (
                 e.startswith(b'(third party extension')
                 and e.endswith(b'or newer of Mercurial; disabling)')
             )
         )
     ]
     return b'\n'.join(b'  ' + e for e in err)
 
 
 def findhg():
     """Try to figure out how we should invoke hg for examining the local
     repository contents.
 
     Returns an hgcommand object."""
     # By default, prefer the "hg" command in the user's path.  This was
     # presumably the hg command that the user used to create this repository.
     #
     # This repository may require extensions or other settings that would not
     # be enabled by running the hg script directly from this local repository.
     hgenv = os.environ.copy()
     # Use HGPLAIN to disable hgrc settings that would change output formatting,
     # and disable localization for the same reasons.
     hgenv['HGPLAIN'] = '1'
     hgenv['LANGUAGE'] = 'C'
     hgcmd = ['hg']
     # Run a simple "hg log" command just to see if using hg from the user's
     # path works and can successfully interact with this repository.  Windows
     # gives precedence to hg.exe in the current directory, so fall back to the
     # python invocation of local hg, where pythonXY.dll can always be found.
     check_cmd = ['log', '-r.', '-Ttest']
     attempts = []
 
     def attempt(cmd, env):
         try:
             retcode, out, err = runcmd(hgcmd + check_cmd, hgenv)
             res = (True, retcode, out, err)
             if retcode == 0 and not filterhgerr(err):
                 return True
         except EnvironmentError as e:
             res = (False, e)
         attempts.append((cmd, res))
         return False
 
     if os.name != 'nt' or not os.path.exists("hg.exe"):
         if attempt(hgcmd + check_cmd, hgenv):
             return hgcommand(hgcmd, hgenv)
 
     # Fall back to trying the local hg installation (pure python)
     repo_hg = os.path.join(os.path.dirname(__file__), 'hg')
     hgenv = localhgenv()
     hgcmd = [sys.executable, repo_hg]
     if attempt(hgcmd + check_cmd, hgenv):
         return hgcommand(hgcmd, hgenv)
     # Fall back to trying the local hg installation (whatever we can)
     hgenv = localhgenv(pure_python=False)
     hgcmd = [sys.executable, repo_hg]
     if attempt(hgcmd + check_cmd, hgenv):
         return hgcommand(hgcmd, hgenv)
 
     eprint("/!\\")
     eprint(r"/!\ Unable to find a working hg binary")
     eprint(r"/!\ Version cannot be extracted from the repository")
     eprint(r"/!\ Re-run the setup once a first version is built")
     eprint(r"/!\ Attempts:")
     for i, e in enumerate(attempts):
         eprint(r"/!\   attempt #%d:" % (i))
         eprint(r"/!\     cmd:        ", e[0])
         res = e[1]
         if res[0]:
             eprint(r"/!\     return code:", res[1])
             eprint("/!\\     std output:\n%s" % (res[2].decode()), end="")
             eprint("/!\\     std error:\n%s" % (res[3].decode()), end="")
         else:
             eprint(r"/!\     exception:  ", res[1])
     return None
 
 
 def localhgenv(pure_python=True):
     """Get an environment dictionary to use for invoking or importing
     mercurial from the local repository."""
     # Execute hg out of this directory with a custom environment which takes
     # care to not use any hgrc files and do no localization.
     env = {
         'HGRCPATH': '',
         'LANGUAGE': 'C',
         'PATH': '',
     }  # make pypi modules that use os.environ['PATH'] happy
     if pure_python:
         env['HGMODULEPOLICY'] = 'py'
     if 'LD_LIBRARY_PATH' in os.environ:
         env['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH']
     if 'SystemRoot' in os.environ:
         # SystemRoot is required by Windows to load various DLLs.  See:
         # https://bugs.python.org/issue13524#msg148850
         env['SystemRoot'] = os.environ['SystemRoot']
     return env
 
 
 version = ''
 
 
 def _try_get_version():
     hg = findhg()
     if hg is None:
         return ''
     hgid = None
     numerictags = []
     cmd = ['log', '-r', '.', '--template', '{tags}\n']
     pieces = sysstr(hg.run(cmd)).split()
     numerictags = [t for t in pieces if t[0:1].isdigit()]
     hgid = sysstr(hg.run(['id', '-i'])).strip()
     if hgid.count('+') == 2:
         hgid = hgid.replace("+", ".", 1)
     if not hgid:
         eprint("/!\\")
         eprint(r"/!\ Unable to determine hg version from local repository")
         eprint(r"/!\ Failed to retrieve current revision tags")
         return ''
     if numerictags:  # tag(s) found
         version = numerictags[-1]
         if hgid.endswith('+'):  # propagate the dirty status to the tag
             version += '+'
     else:  # no tag found on the checked out revision
         ltagcmd = ['log', '--rev', 'wdir()', '--template', '{latesttag}']
         ltag = sysstr(hg.run(ltagcmd))
         if not ltag:
             eprint("/!\\")
             eprint(r"/!\ Unable to determine hg version from local repository")
             eprint(
                 r"/!\ Failed to retrieve current revision distance to lated tag"
             )
             return ''
         changessincecmd = [
             'log',
             '-T',
             'x\n',
             '-r',
             "only(parents(),'%s')" % ltag,
         ]
         changessince = len(hg.run(changessincecmd).splitlines())
         version = '%s+hg%s.%s' % (ltag, changessince, hgid)
     if version.endswith('+'):
         version = version[:-1] + 'local' + time.strftime('%Y%m%d')
     return version
 
 
 if os.path.isdir('.hg'):
     version = _try_get_version()
 elif os.path.exists('.hg_archival.txt'):
     kw = dict(
         [[t.strip() for t in l.split(':', 1)] for l in open('.hg_archival.txt')]
     )
     if 'tag' in kw:
         version = kw['tag']
     elif 'latesttag' in kw:
         if 'changessincelatesttag' in kw:
             version = (
                 '%(latesttag)s+hg%(changessincelatesttag)s.%(node).12s' % kw
             )
         else:
             version = '%(latesttag)s+hg%(latesttagdistance)s.%(node).12s' % kw
     else:
         version = '0+hg' + kw.get('node', '')[:12]
 elif os.path.exists('mercurial/__version__.py'):
     with open('mercurial/__version__.py') as f:
         data = f.read()
     version = re.search('version = b"(.*)"', data).group(1)
 if not version:
     if os.environ.get("MERCURIAL_SETUP_MAKE_LOCAL") == "1":
         version = "0.0+0"
         eprint("/!\\")
         eprint(r"/!\ Using '0.0+0' as the default version")
         eprint(r"/!\ Re-run make local once that first version is built")
         eprint("/!\\")
     else:
         eprint("/!\\")
         eprint(r"/!\ Could not determine the Mercurial version")
         eprint(r"/!\ You need to build a local version first")
         eprint(r"/!\ Run `make local` and try again")
         eprint("/!\\")
         msg = "Run `make local` first to get a working local version"
         raise SystemExit(msg)
 
 versionb = version
 if not isinstance(versionb, bytes):
     versionb = versionb.encode('ascii')
 
 write_if_changed(
     'mercurial/__version__.py',
     b''.join(
         [
             b'# this file is autogenerated by setup.py\n'
             b'version = b"%s"\n' % versionb,
         ]
     ),
 )
 
 
 class hgbuild(build):
     # Insert hgbuildmo first so that files in mercurial/locale/ are found
     # when build_py is run next.
     sub_commands = [('build_mo', None)] + build.sub_commands
 
 
 class hgbuildmo(build):
     description = "build translations (.mo files)"
 
     def run(self):
         if not find_executable('msgfmt'):
             self.warn(
                 "could not find msgfmt executable, no translations "
                 "will be built"
             )
             return
 
         podir = 'i18n'
         if not os.path.isdir(podir):
             self.warn("could not find %s/ directory" % podir)
             return
 
         join = os.path.join
         for po in os.listdir(podir):
             if not po.endswith('.po'):
                 continue
             pofile = join(podir, po)
             modir = join('locale', po[:-3], 'LC_MESSAGES')
             mofile = join(modir, 'hg.mo')
             mobuildfile = join('mercurial', mofile)
             cmd = ['msgfmt', '-v', '-o', mobuildfile, pofile]
             if sys.platform != 'sunos5':
                 # msgfmt on Solaris does not know about -c
                 cmd.append('-c')
             self.mkpath(join('mercurial', modir))
             self.make_file([pofile], mobuildfile, spawn, (cmd,))
 
 
 class hgdist(Distribution):
     pure = False
     rust = False
     no_rust = False
     cffi = ispypy
 
     global_options = Distribution.global_options + [
         ('pure', None, "use pure (slow) Python code instead of C extensions"),
         ('rust', None, "use Rust extensions additionally to C extensions"),
         (
             'no-rust',
             None,
             "do not use Rust extensions additionally to C extensions",
         ),
     ]
 
     negative_opt = Distribution.negative_opt.copy()
     boolean_options = ['pure', 'rust', 'no-rust']
     negative_opt['no-rust'] = 'rust'
 
     def _set_command_options(self, command_obj, option_dict=None):
         # Not all distutils versions in the wild have boolean_options.
         # This should be cleaned up when we're Python 3 only.
         command_obj.boolean_options = (
             getattr(command_obj, 'boolean_options', []) + self.boolean_options
         )
         return Distribution._set_command_options(
             self, command_obj, option_dict=option_dict
         )
 
     def parse_command_line(self):
         ret = Distribution.parse_command_line(self)
         if not (self.rust or self.no_rust):
             hgrustext = os.environ.get('HGWITHRUSTEXT')
             # TODO record it for proper rebuild upon changes
             # (see mercurial/__modulepolicy__.py)
             if hgrustext != 'cpython' and hgrustext is not None:
                 if hgrustext:
                     msg = 'unknown HGWITHRUSTEXT value: %s' % hgrustext
                     print(msg, file=sys.stderr)
                 hgrustext = None
             self.rust = hgrustext is not None
             self.no_rust = not self.rust
         return ret
 
     def has_ext_modules(self):
         # self.ext_modules is emptied in hgbuildpy.finalize_options which is
         # too late for some cases
         return not self.pure and Distribution.has_ext_modules(self)
 
 
 # This is ugly as a one-liner. So use a variable.
 buildextnegops = dict(getattr(build_ext, 'negative_options', {}))
 buildextnegops['no-zstd'] = 'zstd'
 buildextnegops['no-rust'] = 'rust'
 
 
 class hgbuildext(build_ext):
     user_options = build_ext.user_options + [
         ('zstd', None, 'compile zstd bindings [default]'),
         ('no-zstd', None, 'do not compile zstd bindings'),
         (
             'rust',
             None,
             'compile Rust extensions if they are in use '
             '(requires Cargo) [default]',
         ),
         ('no-rust', None, 'do not compile Rust extensions'),
     ]
 
     boolean_options = build_ext.boolean_options + ['zstd', 'rust']
     negative_opt = buildextnegops
 
     def initialize_options(self):
         self.zstd = True
         self.rust = True
 
         return build_ext.initialize_options(self)
 
     def finalize_options(self):
         # Unless overridden by the end user, build extensions in parallel.
         # Only influences behavior on Python 3.5+.
         if getattr(self, 'parallel', None) is None:
             self.parallel = True
 
         return build_ext.finalize_options(self)
 
     def build_extensions(self):
         ruststandalones = [
             e for e in self.extensions if isinstance(e, RustStandaloneExtension)
         ]
         self.extensions = [
             e for e in self.extensions if e not in ruststandalones
         ]
         # Filter out zstd if disabled via argument.
         if not self.zstd:
             self.extensions = [
                 e for e in self.extensions if e.name != 'mercurial.zstd'
             ]
 
         # Build Rust standalone extensions if it'll be used
         # and its build is not explicitly disabled (for external build
         # as Linux distributions would do)
         if self.distribution.rust and self.rust:
             if not sys.platform.startswith('linux'):
                 self.warn(
                     "rust extensions have only been tested on Linux "
                     "and may not behave correctly on other platforms"
                 )
 
             for rustext in ruststandalones:
                 rustext.build('' if self.inplace else self.build_lib)
 
         return build_ext.build_extensions(self)
 
     def build_extension(self, ext):
         if (
             self.distribution.rust
             and self.rust
             and isinstance(ext, RustExtension)
         ):
             ext.rustbuild()
         try:
             build_ext.build_extension(self, ext)
         except CCompilerError:
             if not getattr(ext, 'optional', False):
                 raise
             log.warn(
                 "Failed to build optional extension '%s' (skipping)", ext.name
             )
 
 
 class hgbuildscripts(build_scripts):
     def run(self):
         if os.name != 'nt' or self.distribution.pure:
             return build_scripts.run(self)
 
         exebuilt = False
         try:
             self.run_command('build_hgexe')
             exebuilt = True
         except (DistutilsError, CCompilerError):
             log.warn('failed to build optional hg.exe')
 
         if exebuilt:
             # Copying hg.exe to the scripts build directory ensures it is
             # installed by the install_scripts command.
             hgexecommand = self.get_finalized_command('build_hgexe')
             dest = os.path.join(self.build_dir, 'hg.exe')
             self.mkpath(self.build_dir)
             self.copy_file(hgexecommand.hgexepath, dest)
 
             # Remove hg.bat because it is redundant with hg.exe.
             self.scripts.remove('contrib/win32/hg.bat')
 
         return build_scripts.run(self)
 
 
 class hgbuildpy(build_py):
     def finalize_options(self):
         build_py.finalize_options(self)
 
         if self.distribution.pure:
             self.distribution.ext_modules = []
         elif self.distribution.cffi:
             from mercurial.cffi import (
                 bdiffbuild,
                 mpatchbuild,
             )
 
             exts = [
                 mpatchbuild.ffi.distutils_extension(),
                 bdiffbuild.ffi.distutils_extension(),
             ]
             # cffi modules go here
             if sys.platform == 'darwin':
                 from mercurial.cffi import osutilbuild
 
                 exts.append(osutilbuild.ffi.distutils_extension())
             self.distribution.ext_modules = exts
         else:
             h = os.path.join(get_python_inc(), 'Python.h')
             if not os.path.exists(h):
                 raise SystemExit(
                     'Python headers are required to build '
                     'Mercurial but weren\'t found in %s' % h
                 )
 
     def run(self):
         basepath = os.path.join(self.build_lib, 'mercurial')
         self.mkpath(basepath)
 
         rust = self.distribution.rust
         if self.distribution.pure:
             modulepolicy = 'py'
         elif self.build_lib == '.':
             # in-place build should run without rebuilding and Rust extensions
             modulepolicy = 'rust+c-allow' if rust else 'allow'
         else:
             modulepolicy = 'rust+c' if rust else 'c'
 
         content = b''.join(
             [
                 b'# this file is autogenerated by setup.py\n',
                 b'modulepolicy = b"%s"\n' % modulepolicy.encode('ascii'),
             ]
         )
         write_if_changed(os.path.join(basepath, '__modulepolicy__.py'), content)
 
         build_py.run(self)
 
 
 class buildhgextindex(Command):
     description = 'generate prebuilt index of hgext (for frozen package)'
     user_options = []
     _indexfilename = 'hgext/__index__.py'
 
     def initialize_options(self):
         pass
 
     def finalize_options(self):
         pass
 
     def run(self):
         if os.path.exists(self._indexfilename):
             with open(self._indexfilename, 'w') as f:
                 f.write('# empty\n')
 
         # here no extension enabled, disabled() lists up everything
         code = (
             'import pprint; from mercurial import extensions; '
             'ext = extensions.disabled();'
             'ext.pop("__index__", None);'
             'pprint.pprint(ext)'
         )
         returncode, out, err = runcmd(
             [sys.executable, '-c', code], localhgenv()
         )
         if err or returncode != 0:
             raise DistutilsExecError(err)
 
         with open(self._indexfilename, 'wb') as f:
             f.write(b'# this file is autogenerated by setup.py\n')
             f.write(b'docs = ')
             f.write(out)
 
 
 class buildhgexe(build_ext):
     description = 'compile hg.exe from mercurial/exewrapper.c'
 
     LONG_PATHS_MANIFEST = """\
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
   <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
     <security>
       <requestedPrivileges>
         <requestedExecutionLevel
           level="asInvoker"
           uiAccess="false"
         />
       </requestedPrivileges>
     </security>
   </trustInfo>
   <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
     <application>
       <!-- Windows Vista -->
       <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
       <!-- Windows 7 -->
       <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
       <!-- Windows 8 -->
       <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
       <!-- Windows 8.1 -->
       <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
       <!-- Windows 10 and Windows 11 -->
       <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
     </application>
   </compatibility>
   <application xmlns="urn:schemas-microsoft-com:asm.v3">
     <windowsSettings
         xmlns:ws2="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
       <ws2:longPathAware>true</ws2:longPathAware>
     </windowsSettings>
   </application>
   <dependency>
     <dependentAssembly>
       <assemblyIdentity type="win32"
                         name="Microsoft.Windows.Common-Controls"
                         version="6.0.0.0"
                         processorArchitecture="*"
                         publicKeyToken="6595b64144ccf1df"
                         language="*" />
     </dependentAssembly>
   </dependency>
 </assembly>
 """
 
     def initialize_options(self):
         build_ext.initialize_options(self)
 
     def build_extensions(self):
         if os.name != 'nt':
             return
         if isinstance(self.compiler, HackedMingw32CCompiler):
             self.compiler.compiler_so = self.compiler.compiler  # no -mdll
             self.compiler.dll_libraries = []  # no -lmsrvc90
 
         pythonlib = None
 
         dirname = os.path.dirname(self.get_ext_fullpath('dummy'))
         self.hgtarget = os.path.join(dirname, 'hg')
 
         if getattr(sys, 'dllhandle', None):
             # Different Python installs can have different Python library
             # names. e.g. the official CPython distribution uses pythonXY.dll
             # and MinGW uses libpythonX.Y.dll.
             _kernel32 = ctypes.windll.kernel32
             _kernel32.GetModuleFileNameA.argtypes = [
                 ctypes.c_void_p,
                 ctypes.c_void_p,
                 ctypes.c_ulong,
             ]
             _kernel32.GetModuleFileNameA.restype = ctypes.c_ulong
             size = 1000
             buf = ctypes.create_string_buffer(size + 1)
             filelen = _kernel32.GetModuleFileNameA(
                 sys.dllhandle, ctypes.byref(buf), size
             )
 
             if filelen > 0 and filelen != size:
                 dllbasename = os.path.basename(buf.value)
                 if not dllbasename.lower().endswith(b'.dll'):
                     raise SystemExit(
                         'Python DLL does not end with .dll: %s' % dllbasename
                     )
                 pythonlib = dllbasename[:-4]
 
                 # Copy the pythonXY.dll next to the binary so that it runs
                 # without tampering with PATH.
                 dest = os.path.join(
                     os.path.dirname(self.hgtarget),
                     os.fsdecode(dllbasename),
                 )
 
                 if not os.path.exists(dest):
                     shutil.copy(buf.value, dest)
 
                 # Also overwrite python3.dll so that hgext.git is usable.
                 # TODO: also handle the MSYS flavor
                 python_x = os.path.join(
                     os.path.dirname(os.fsdecode(buf.value)),
                     "python3.dll",
                 )
 
                 if os.path.exists(python_x):
                     dest = os.path.join(
                         os.path.dirname(self.hgtarget),
                         os.path.basename(python_x),
                     )
 
                     shutil.copy(python_x, dest)
 
         if not pythonlib:
             log.warn(
                 'could not determine Python DLL filename; assuming pythonXY'
             )
 
             hv = sys.hexversion
             pythonlib = b'python%d%d' % (hv >> 24, (hv >> 16) & 0xFF)
 
         log.info('using %s as Python library name' % pythonlib)
         with open('mercurial/hgpythonlib.h', 'wb') as f:
             f.write(b'/* this file is autogenerated by setup.py */\n')
             f.write(b'#define HGPYTHONLIB "%s"\n' % pythonlib)
 
         objects = self.compiler.compile(
             ['mercurial/exewrapper.c'],
             output_dir=self.build_temp,
             macros=[('_UNICODE', None), ('UNICODE', None)],
         )
         self.compiler.link_executable(
             objects, self.hgtarget, libraries=[], output_dir=self.build_temp
         )
 
         self.addlongpathsmanifest()
 
     def addlongpathsmanifest(self):
         """Add manifest pieces so that hg.exe understands long paths
 
         Why resource #1 should be used for .exe manifests? I don't know and
         wasn't able to find an explanation for mortals. But it seems to work.
         """
         exefname = self.compiler.executable_filename(self.hgtarget)
         fdauto, manfname = tempfile.mkstemp(suffix='.hg.exe.manifest')
         os.close(fdauto)
         with open(manfname, 'w', encoding="UTF-8") as f:
             f.write(self.LONG_PATHS_MANIFEST)
         log.info("long paths manifest is written to '%s'" % manfname)
         outputresource = '-outputresource:%s;#1' % exefname
         log.info("running mt.exe to update hg.exe's manifest in-place")
 
         self.spawn(
             [
                 self.compiler.mt,
                 '-nologo',
                 '-manifest',
                 manfname,
                 outputresource,
             ]
         )
         log.info("done updating hg.exe's manifest")
         os.remove(manfname)
 
     @property
     def hgexepath(self):
         dir = os.path.dirname(self.get_ext_fullpath('dummy'))
         return os.path.join(self.build_temp, dir, 'hg.exe')
 
 
 class hgbuilddoc(Command):
     description = 'build documentation'
     user_options = [
         ('man', None, 'generate man pages'),
         ('html', None, 'generate html pages'),
     ]
 
     def initialize_options(self):
         self.man = None
         self.html = None
 
     def finalize_options(self):
         # If --man or --html are set, only generate what we're told to.
         # Otherwise generate everything.
         have_subset = self.man is not None or self.html is not None
 
         if have_subset:
             self.man = True if self.man else False
             self.html = True if self.html else False
         else:
             self.man = True
             self.html = True
 
     def run(self):
         def normalizecrlf(p):
             with open(p, 'rb') as fh:
                 orig = fh.read()
 
             if b'\r\n' not in orig:
                 return
 
             log.info('normalizing %s to LF line endings' % p)
             with open(p, 'wb') as fh:
                 fh.write(orig.replace(b'\r\n', b'\n'))
 
         def gentxt(root):
             txt = 'doc/%s.txt' % root
             log.info('generating %s' % txt)
             res, out, err = runcmd(
                 [sys.executable, 'gendoc.py', root], os.environ, cwd='doc'
             )
             if res:
                 raise SystemExit(
                     'error running gendoc.py: %s'
                     % '\n'.join([sysstr(out), sysstr(err)])
                 )
 
             with open(txt, 'wb') as fh:
                 fh.write(out)
 
         def gengendoc(root):
             gendoc = 'doc/%s.gendoc.txt' % root
 
             log.info('generating %s' % gendoc)
             res, out, err = runcmd(
                 [sys.executable, 'gendoc.py', '%s.gendoc' % root],
                 os.environ,
                 cwd='doc',
             )
             if res:
                 raise SystemExit(
                     'error running gendoc: %s'
                     % '\n'.join([sysstr(out), sysstr(err)])
                 )
 
             with open(gendoc, 'wb') as fh:
                 fh.write(out)
 
         def genman(root):
             log.info('generating doc/%s' % root)
             res, out, err = runcmd(
                 [
                     sys.executable,
                     'runrst',
                     'hgmanpage',
                     '--halt',
                     'warning',
                     '--strip-elements-with-class',
                     'htmlonly',
                     '%s.txt' % root,
                     root,
                 ],
                 os.environ,
                 cwd='doc',
             )
             if res:
                 raise SystemExit(
                     'error running runrst: %s'
                     % '\n'.join([sysstr(out), sysstr(err)])
                 )
 
             normalizecrlf('doc/%s' % root)
 
         def genhtml(root):
             log.info('generating doc/%s.html' % root)
             res, out, err = runcmd(
                 [
                     sys.executable,
                     'runrst',
                     'html',
                     '--halt',
                     'warning',
                     '--link-stylesheet',
                     '--stylesheet-path',
                     'style.css',
                     '%s.txt' % root,
                     '%s.html' % root,
                 ],
                 os.environ,
                 cwd='doc',
             )
             if res:
                 raise SystemExit(
                     'error running runrst: %s'
                     % '\n'.join([sysstr(out), sysstr(err)])
                 )
 
             normalizecrlf('doc/%s.html' % root)
 
         # This logic is duplicated in doc/Makefile.
         sources = {
             f
             for f in os.listdir('mercurial/helptext')
             if re.search(r'[0-9]\.txt$', f)
         }
 
         # common.txt is a one-off.
         gentxt('common')
 
         for source in sorted(sources):
             assert source[-4:] == '.txt'
             root = source[:-4]
 
             gentxt(root)
             gengendoc(root)
 
             if self.man:
                 genman(root)
             if self.html:
                 genhtml(root)
 
 
 class hginstall(install):
     user_options = install.user_options + [
         (
             'old-and-unmanageable',
             None,
             'noop, present for eggless setuptools compat',
         ),
         (
             'single-version-externally-managed',
             None,
             'noop, present for eggless setuptools compat',
         ),
     ]
 
     sub_commands = install.sub_commands + [
         ('install_completion', lambda self: True)
     ]
 
     # Also helps setuptools not be sad while we refuse to create eggs.
     single_version_externally_managed = True
 
     def get_sub_commands(self):
         # Screen out egg related commands to prevent egg generation.  But allow
         # mercurial.egg-info generation, since that is part of modern
         # packaging.
         excl = {'bdist_egg'}
         return filter(lambda x: x not in excl, install.get_sub_commands(self))
 
 
 class hginstalllib(install_lib):
     """
     This is a specialization of install_lib that replaces the copy_file used
     there so that it supports setting the mode of files after copying them,
     instead of just preserving the mode that the files originally had.  If your
     system has a umask of something like 027, preserving the permissions when
     copying will lead to a broken install.
 
     Note that just passing keep_permissions=False to copy_file would be
     insufficient, as it might still be applying a umask.
     """
 
     def run(self):
         realcopyfile = file_util.copy_file
 
         def copyfileandsetmode(*args, **kwargs):
             src, dst = args[0], args[1]
             dst, copied = realcopyfile(*args, **kwargs)
             if copied:
                 st = os.stat(src)
                 # Persist executable bit (apply it to group and other if user
                 # has it)
                 if st[stat.ST_MODE] & stat.S_IXUSR:
                     setmode = int('0755', 8)
                 else:
                     setmode = int('0644', 8)
                 m = stat.S_IMODE(st[stat.ST_MODE])
                 m = (m & ~int('0777', 8)) | setmode
                 os.chmod(dst, m)
 
         file_util.copy_file = copyfileandsetmode
         try:
             install_lib.run(self)
         finally:
             file_util.copy_file = realcopyfile
 
 
 class hginstallscripts(install_scripts):
     """
     This is a specialization of install_scripts that replaces the @LIBDIR@ with
     the configured directory for modules. If possible, the path is made relative
     to the directory for scripts.
     """
 
     def initialize_options(self):
         install_scripts.initialize_options(self)
 
         self.install_lib = None
 
     def finalize_options(self):
         install_scripts.finalize_options(self)
         self.set_undefined_options('install', ('install_lib', 'install_lib'))
 
     def run(self):
         install_scripts.run(self)
 
         # It only makes sense to replace @LIBDIR@ with the install path if
         # the install path is known. For wheels, the logic below calculates
         # the libdir to be "../..". This is because the internal layout of a
         # wheel archive looks like:
         #
         #   mercurial-3.6.1.data/scripts/hg
         #   mercurial/__init__.py
         #
         # When installing wheels, the subdirectories of the "<pkg>.data"
         # directory are translated to system local paths and files therein
         # are copied in place. The mercurial/* files are installed into the
         # site-packages directory. However, the site-packages directory
         # isn't known until wheel install time. This means we have no clue
         # at wheel generation time what the installed site-packages directory
         # will be. And, wheels don't appear to provide the ability to register
         # custom code to run during wheel installation. This all means that
         # we can't reliably set the libdir in wheels: the default behavior
         # of looking in sys.path must do.
 
         if (
             os.path.splitdrive(self.install_dir)[0]
             != os.path.splitdrive(self.install_lib)[0]
         ):
             # can't make relative paths from one drive to another, so use an
             # absolute path instead
             libdir = self.install_lib
         else:
             libdir = os.path.relpath(self.install_lib, self.install_dir)
 
         for outfile in self.outfiles:
             with open(outfile, 'rb') as fp:
                 data = fp.read()
 
             # skip binary files
             if b'\0' in data:
                 continue
 
             # During local installs, the shebang will be rewritten to the final
             # install path. During wheel packaging, the shebang has a special
             # value.
             if data.startswith(b'#!python'):
                 log.info(
                     'not rewriting @LIBDIR@ in %s because install path '
                     'not known' % outfile
                 )
                 continue
 
             data = data.replace(b'@LIBDIR@', libdir.encode('unicode_escape'))
             with open(outfile, 'wb') as fp:
                 fp.write(data)
 
 
 class hginstallcompletion(Command):
     description = 'Install shell completion'
 
     def initialize_options(self):
         self.install_dir = None
         self.outputs = []
 
     def finalize_options(self):
         self.set_undefined_options(
             'install_data', ('install_dir', 'install_dir')
         )
 
     def get_outputs(self):
         return self.outputs
 
     def run(self):
         for src, dir_path, dest in (
             (
                 'bash_completion',
                 ('share', 'bash-completion', 'completions'),
                 'hg',
             ),
             ('zsh_completion', ('share', 'zsh', 'site-functions'), '_hg'),
         ):
             dir = os.path.join(self.install_dir, *dir_path)
             self.mkpath(dir)
 
             dest = os.path.join(dir, dest)
             self.outputs.append(dest)
             self.copy_file(os.path.join('contrib', src), dest)
 
 
 # virtualenv installs custom distutils/__init__.py and
 # distutils/distutils.cfg files which essentially proxy back to the
 # "real" distutils in the main Python install. The presence of this
 # directory causes py2exe to pick up the "hacked" distutils package
 # from the virtualenv and "import distutils" will fail from the py2exe
 # build because the "real" distutils files can't be located.
 #
 # We work around this by monkeypatching the py2exe code finding Python
 # modules to replace the found virtualenv distutils modules with the
 # original versions via filesystem scanning. This is a bit hacky. But
 # it allows us to use virtualenvs for py2exe packaging, which is more
 # deterministic and reproducible.
 #
 # It's worth noting that the common StackOverflow suggestions for this
 # problem involve copying the original distutils files into the
 # virtualenv or into the staging directory after setup() is invoked.
 # The former is very brittle and can easily break setup(). Our hacking
 # of the found modules routine has a similar result as copying the files
 # manually. But it makes fewer assumptions about how py2exe works and
 # is less brittle.
 
 # This only catches virtualenvs made with virtualenv (as opposed to
 # venv, which is likely what Python 3 uses).
 py2exehacked = py2exeloaded and getattr(sys, 'real_prefix', None) is not None
 
 if py2exehacked:
     from distutils.command.py2exe import py2exe as buildpy2exe
     from py2exe.mf import Module as py2exemodule
 
     class hgbuildpy2exe(buildpy2exe):
         def find_needed_modules(self, mf, files, modules):
             res = buildpy2exe.find_needed_modules(self, mf, files, modules)
 
             # Replace virtualenv's distutils modules with the real ones.
             modules = {}
             for k, v in res.modules.items():
                 if k != 'distutils' and not k.startswith('distutils.'):
                     modules[k] = v
 
             res.modules = modules
 
             import opcode
 
             distutilsreal = os.path.join(
                 os.path.dirname(opcode.__file__), 'distutils'
             )
 
             for root, dirs, files in os.walk(distutilsreal):
                 for f in sorted(files):
                     if not f.endswith('.py'):
                         continue
 
                     full = os.path.join(root, f)
 
                     parents = ['distutils']
 
                     if root != distutilsreal:
                         rel = os.path.relpath(root, distutilsreal)
                         parents.extend(p for p in rel.split(os.sep))
 
                     modname = '%s.%s' % ('.'.join(parents), f[:-3])
 
                     if modname.startswith('distutils.tests.'):
                         continue
 
                     if modname.endswith('.__init__'):
                         modname = modname[: -len('.__init__')]
                         path = os.path.dirname(full)
                     else:
                         path = None
 
                     res.modules[modname] = py2exemodule(
                         modname, full, path=path
                     )
 
             if 'distutils' not in res.modules:
                 raise SystemExit('could not find distutils modules')
 
             return res
 
 
 cmdclass = {
     'build': hgbuild,
     'build_doc': hgbuilddoc,
     'build_mo': hgbuildmo,
     'build_ext': hgbuildext,
     'build_py': hgbuildpy,
     'build_scripts': hgbuildscripts,
     'build_hgextindex': buildhgextindex,
     'install': hginstall,
     'install_completion': hginstallcompletion,
     'install_lib': hginstalllib,
     'install_scripts': hginstallscripts,
     'build_hgexe': buildhgexe,
 }
 
 if py2exehacked:
     cmdclass['py2exe'] = hgbuildpy2exe
 
 packages = [
     'mercurial',
     'mercurial.admin',
     'mercurial.cext',
     'mercurial.cffi',
     'mercurial.defaultrc',
     'mercurial.dirstateutils',
     'mercurial.helptext',
     'mercurial.helptext.internals',
     'mercurial.hgweb',
     'mercurial.interfaces',
     'mercurial.pure',
     'mercurial.stabletailgraph',
     'mercurial.templates',
     'mercurial.thirdparty',
     'mercurial.thirdparty.attr',
     'mercurial.thirdparty.tomli',
     'mercurial.thirdparty.zope',
     'mercurial.thirdparty.zope.interface',
     'mercurial.upgrade_utils',
     'mercurial.utils',
     'mercurial.revlogutils',
     'mercurial.testing',
     'hgext',
     'hgext.convert',
     'hgext.fsmonitor',
     'hgext.fastannotate',
     'hgext.fsmonitor.pywatchman',
     'hgext.git',
     'hgext.highlight',
     'hgext.hooklib',
     'hgext.largefiles',
     'hgext.lfs',
     'hgext.narrow',
     'hgext.remotefilelog',
     'hgext.zeroconf',
     'hgext3rd',
     'hgdemandimport',
 ]
 
 for name in os.listdir(os.path.join('mercurial', 'templates')):
     if name != '__pycache__' and os.path.isdir(
         os.path.join('mercurial', 'templates', name)
     ):
         packages.append('mercurial.templates.%s' % name)
 
 if 'HG_PY2EXE_EXTRA_INSTALL_PACKAGES' in os.environ:
     # py2exe can't cope with namespace packages very well, so we have to
     # install any hgext3rd.* extensions that we want in the final py2exe
     # image here. This is gross, but you gotta do what you gotta do.
     packages.extend(os.environ['HG_PY2EXE_EXTRA_INSTALL_PACKAGES'].split(' '))
 
 common_depends = [
     'mercurial/bitmanipulation.h',
     'mercurial/compat.h',
     'mercurial/cext/util.h',
 ]
 common_include_dirs = ['mercurial']
 
 common_cflags = []
 
 # MSVC 2008 still needs declarations at the top of the scope, but Python 3.9
 # makes declarations not at the top of a scope in the headers.
 if os.name != 'nt' and sys.version_info[1] < 9:
     common_cflags = ['-Werror=declaration-after-statement']
 
 osutil_cflags = []
 osutil_ldflags = []
 
 # platform specific macros
 for plat, func in [('bsd', 'setproctitle')]:
     if re.search(plat, sys.platform) and hasfunction(new_compiler(), func):
         osutil_cflags.append('-DHAVE_%s' % func.upper())
 
 for plat, macro, code in [
     (
         'bsd|darwin',
         'BSD_STATFS',
         '''
      #include <sys/param.h>
      #include <sys/mount.h>
      int main() { struct statfs s; return sizeof(s.f_fstypename); }
      ''',
     ),
     (
         'linux',
         'LINUX_STATFS',
         '''
      #include <linux/magic.h>
      #include <sys/vfs.h>
      int main() { struct statfs s; return sizeof(s.f_type); }
      ''',
     ),
 ]:
     if re.search(plat, sys.platform) and cancompile(new_compiler(), code):
         osutil_cflags.append('-DHAVE_%s' % macro)
 
 if sys.platform == 'darwin':
     osutil_ldflags += ['-framework', 'ApplicationServices']
 
 if sys.platform == 'sunos5':
     osutil_ldflags += ['-lsocket']
 
 xdiff_srcs = [
     'mercurial/thirdparty/xdiff/xdiffi.c',
     'mercurial/thirdparty/xdiff/xprepare.c',
     'mercurial/thirdparty/xdiff/xutils.c',
 ]
 
 xdiff_headers = [
     'mercurial/thirdparty/xdiff/xdiff.h',
     'mercurial/thirdparty/xdiff/xdiffi.h',
     'mercurial/thirdparty/xdiff/xinclude.h',
     'mercurial/thirdparty/xdiff/xmacros.h',
     'mercurial/thirdparty/xdiff/xprepare.h',
     'mercurial/thirdparty/xdiff/xtypes.h',
     'mercurial/thirdparty/xdiff/xutils.h',
 ]
 
 
 class RustCompilationError(CCompilerError):
     """Exception class for Rust compilation errors."""
 
 
 class RustExtension(Extension):
     """Base classes for concrete Rust Extension classes."""
 
     rusttargetdir = os.path.join('rust', 'target', 'release')
 
     def __init__(self, mpath, sources, rustlibname, subcrate, **kw):
         Extension.__init__(self, mpath, sources, **kw)
         srcdir = self.rustsrcdir = os.path.join('rust', subcrate)
 
         # adding Rust source and control files to depends so that the extension
         # gets rebuilt if they've changed
         self.depends.append(os.path.join(srcdir, 'Cargo.toml'))
         cargo_lock = os.path.join(srcdir, 'Cargo.lock')
         if os.path.exists(cargo_lock):
             self.depends.append(cargo_lock)
         for dirpath, subdir, fnames in os.walk(os.path.join(srcdir, 'src')):
             self.depends.extend(
                 os.path.join(dirpath, fname)
                 for fname in fnames
                 if os.path.splitext(fname)[1] == '.rs'
             )
 
     @staticmethod
     def rustdylibsuffix():
         """Return the suffix for shared libraries produced by rustc.
 
         See also: https://doc.rust-lang.org/reference/linkage.html
         """
         if sys.platform == 'darwin':
             return '.dylib'
         elif os.name == 'nt':
             return '.dll'
         else:
             return '.so'
 
     def rustbuild(self):
         env = os.environ.copy()
         if 'HGTEST_RESTOREENV' in env:
             # Mercurial tests change HOME to a temporary directory,
             # but, if installed with rustup, the Rust toolchain needs
             # HOME to be correct (otherwise the 'no default toolchain'
             # error message is issued and the build fails).
             # This happens currently with test-hghave.t, which does
             # invoke this build.
 
             # Unix only fix (os.path.expanduser not really reliable if
             # HOME is shadowed like this)
             import pwd
 
             env['HOME'] = pwd.getpwuid(os.getuid()).pw_dir
 
         cargocmd = ['cargo', 'rustc', '--release']
 
         rust_features = env.get("HG_RUST_FEATURES")
         if rust_features:
             cargocmd.extend(('--features', rust_features))
 
         cargocmd.append('--')
         if sys.platform == 'darwin':
             cargocmd.extend(
                 ("-C", "link-arg=-undefined", "-C", "link-arg=dynamic_lookup")
             )
         try:
             subprocess.check_call(cargocmd, env=env, cwd=self.rustsrcdir)
         except FileNotFoundError:
             raise RustCompilationError("Cargo not found")
         except PermissionError:
             raise RustCompilationError(
                 "Cargo found, but permission to execute it is denied"
             )
         except subprocess.CalledProcessError:
             raise RustCompilationError(
                 "Cargo failed. Working directory: %r, "
                 "command: %r, environment: %r"
                 % (self.rustsrcdir, cargocmd, env)
             )
 
 
 class RustStandaloneExtension(RustExtension):
     def __init__(self, pydottedname, rustcrate, dylibname, **kw):
         RustExtension.__init__(
             self, pydottedname, [], dylibname, rustcrate, **kw
         )
         self.dylibname = dylibname
 
     def build(self, target_dir):
         self.rustbuild()
         target = [target_dir]
         target.extend(self.name.split('.'))
         target[-1] += DYLIB_SUFFIX
         target = os.path.join(*target)
         os.makedirs(os.path.dirname(target), exist_ok=True)
         shutil.copy2(
             os.path.join(
                 self.rusttargetdir, self.dylibname + self.rustdylibsuffix()
             ),
             target,
         )
 
 
 extmodules = [
     Extension(
         'mercurial.cext.base85',
         ['mercurial/cext/base85.c'],
         include_dirs=common_include_dirs,
         extra_compile_args=common_cflags,
         depends=common_depends,
     ),
     Extension(
         'mercurial.cext.bdiff',
         ['mercurial/bdiff.c', 'mercurial/cext/bdiff.c'] + xdiff_srcs,
         include_dirs=common_include_dirs,
         extra_compile_args=common_cflags,
         depends=common_depends + ['mercurial/bdiff.h'] + xdiff_headers,
     ),
     Extension(
         'mercurial.cext.mpatch',
         ['mercurial/mpatch.c', 'mercurial/cext/mpatch.c'],
         include_dirs=common_include_dirs,
         extra_compile_args=common_cflags,
         depends=common_depends,
     ),
     Extension(
         'mercurial.cext.parsers',
         [
             'mercurial/cext/charencode.c',
             'mercurial/cext/dirs.c',
             'mercurial/cext/manifest.c',
             'mercurial/cext/parsers.c',
             'mercurial/cext/pathencode.c',
             'mercurial/cext/revlog.c',
         ],
         include_dirs=common_include_dirs,
         extra_compile_args=common_cflags,
         depends=common_depends
         + [
             'mercurial/cext/charencode.h',
             'mercurial/cext/revlog.h',
         ],
     ),
     Extension(
         'mercurial.cext.osutil',
         ['mercurial/cext/osutil.c'],
         include_dirs=common_include_dirs,
         extra_compile_args=common_cflags + osutil_cflags,
         extra_link_args=osutil_ldflags,
         depends=common_depends,
     ),
     Extension(
         'mercurial.thirdparty.zope.interface._zope_interface_coptimizations',
         [
             'mercurial/thirdparty/zope/interface/_zope_interface_coptimizations.c',
         ],
         extra_compile_args=common_cflags,
     ),
     Extension(
         'mercurial.thirdparty.sha1dc',
         [
             'mercurial/thirdparty/sha1dc/cext.c',
             'mercurial/thirdparty/sha1dc/lib/sha1.c',
             'mercurial/thirdparty/sha1dc/lib/ubc_check.c',
         ],
         extra_compile_args=common_cflags,
     ),
     Extension(
         'hgext.fsmonitor.pywatchman.bser',
         ['hgext/fsmonitor/pywatchman/bser.c'],
         extra_compile_args=common_cflags,
     ),
     RustStandaloneExtension(
         'mercurial.rustext',
         'hg-cpython',
         'librusthg',
     ),
 ]
 
 
 sys.path.insert(0, 'contrib/python-zstandard')
 import setup_zstd
 
 zstd = setup_zstd.get_c_extension(
     name='mercurial.zstd', root=os.path.abspath(os.path.dirname(__file__))
 )
 zstd.extra_compile_args += common_cflags
 extmodules.append(zstd)
 
 try:
     from distutils import cygwinccompiler
 
     # the -mno-cygwin option has been deprecated for years
     mingw32compilerclass = cygwinccompiler.Mingw32CCompiler
 
     class HackedMingw32CCompiler(cygwinccompiler.Mingw32CCompiler):
         def __init__(self, *args, **kwargs):
             mingw32compilerclass.__init__(self, *args, **kwargs)
             for i in 'compiler compiler_so linker_exe linker_so'.split():
                 try:
                     getattr(self, i).remove('-mno-cygwin')
                 except ValueError:
                     pass
 
     cygwinccompiler.Mingw32CCompiler = HackedMingw32CCompiler
 except ImportError:
     # the cygwinccompiler package is not available on some Python
     # distributions like the ones from the optware project for Synology
     # DiskStation boxes
     class HackedMingw32CCompiler:
         pass
 
 
 if os.name == 'nt':
     # Allow compiler/linker flags to be added to Visual Studio builds.  Passing
     # extra_link_args to distutils.extensions.Extension() doesn't have any
     # effect.
-    from distutils import msvccompiler
+    try:
+        # setuptools < 65.0
+        from distutils import msvccompiler
+    except ImportError:
+        from distutils import _msvccompiler as msvccompiler
 
     msvccompilerclass = msvccompiler.MSVCCompiler
 
     class HackedMSVCCompiler(msvccompiler.MSVCCompiler):
         def initialize(self):
             msvccompilerclass.initialize(self)
             # "warning LNK4197: export 'func' specified multiple times"
             self.ldflags_shared.append('/ignore:4197')
             self.ldflags_shared_debug.append('/ignore:4197')
 
     msvccompiler.MSVCCompiler = HackedMSVCCompiler
 
 packagedata = {
     'mercurial': [
         'configitems.toml',
         'locale/*/LC_MESSAGES/hg.mo',
         'dummycert.pem',
     ],
     'mercurial.defaultrc': [
         '*.rc',
     ],
     'mercurial.helptext': [
         '*.txt',
     ],
     'mercurial.helptext.internals': [
         '*.txt',
     ],
     'mercurial.thirdparty.attr': [
         '*.pyi',
         'py.typed',
     ],
 }
 
 
 def ordinarypath(p):
     return p and p[0] != '.' and p[-1] != '~'
 
 
 for root in ('templates',):
     for curdir, dirs, files in os.walk(os.path.join('mercurial', root)):
         packagename = curdir.replace(os.sep, '.')
         packagedata[packagename] = list(filter(ordinarypath, files))
 
 datafiles = []
 
 # distutils expects version to be str/unicode. Converting it to
 # unicode on Python 2 still works because it won't contain any
 # non-ascii bytes and will be implicitly converted back to bytes
 # when operated on.
 assert isinstance(version, str)
 setupversion = version
 
 extra = {}
 
 py2exepackages = [
     'hgdemandimport',
     'hgext3rd',
     'hgext',
     'email',
     # implicitly imported per module policy
     # (cffi wouldn't be used as a frozen exe)
     'mercurial.cext',
     #'mercurial.cffi',
     'mercurial.pure',
 ]
 
 py2exe_includes = []
 
 py2exeexcludes = []
 py2exedllexcludes = ['crypt32.dll']
 
 if issetuptools:
     extra['python_requires'] = supportedpy
 
 if py2exeloaded:
     extra['console'] = [
         {
             'script': 'hg',
             'copyright': 'Copyright (C) 2005-2024 Olivia Mackall and others',
             'product_version': version,
         }
     ]
     # Sub command of 'build' because 'py2exe' does not handle sub_commands.
     # Need to override hgbuild because it has a private copy of
     # build.sub_commands.
     hgbuild.sub_commands.insert(0, ('build_hgextindex', None))
     # put dlls in sub directory so that they won't pollute PATH
     extra['zipfile'] = 'lib/library.zip'
 
     # We allow some configuration to be supplemented via environment
     # variables. This is better than setup.cfg files because it allows
     # supplementing configs instead of replacing them.
     extrapackages = os.environ.get('HG_PY2EXE_EXTRA_PACKAGES')
     if extrapackages:
         py2exepackages.extend(extrapackages.split(' '))
 
     extra_includes = os.environ.get('HG_PY2EXE_EXTRA_INCLUDES')
     if extra_includes:
         py2exe_includes.extend(extra_includes.split(' '))
 
     excludes = os.environ.get('HG_PY2EXE_EXTRA_EXCLUDES')
     if excludes:
         py2exeexcludes.extend(excludes.split(' '))
 
     dllexcludes = os.environ.get('HG_PY2EXE_EXTRA_DLL_EXCLUDES')
     if dllexcludes:
         py2exedllexcludes.extend(dllexcludes.split(' '))
 
 if os.environ.get('PYOXIDIZER'):
     hgbuild.sub_commands.insert(0, ('build_hgextindex', None))
 
 if os.name == 'nt':
     # Windows binary file versions for exe/dll files must have the
     # form W.X.Y.Z, where W,X,Y,Z are numbers in the range 0..65535
     setupversion = setupversion.split(r'+', 1)[0]
 
 setup(
     name='mercurial',
     version=setupversion,
     author='Olivia Mackall and many others',
     author_email='[e-mail]',
     url='https://mercurial-scm.org/',
     download_url='https://mercurial-scm.org/release/',
     description=(
         'Fast scalable distributed SCM (revision control, version '
         'control) system'
     ),
     long_description=(
         'Mercurial is a distributed SCM tool written in Python.'
         ' It is used by a number of large projects that require'
         ' fast, reliable distributed revision control, such as '
         'Mozilla.'
     ),
     license='GNU GPLv2 or any later version',
     classifiers=[
         'Development Status :: 6 - Mature',
         'Environment :: Console',
         'Intended Audience :: Developers',
         'Intended Audience :: System Administrators',
         'License :: OSI Approved :: GNU General Public License (GPL)',
         'Natural Language :: Danish',
         'Natural Language :: English',
         'Natural Language :: German',
         'Natural Language :: Italian',
         'Natural Language :: Japanese',
         'Natural Language :: Portuguese (Brazilian)',
         'Operating System :: Microsoft :: Windows',
         'Operating System :: OS Independent',
         'Operating System :: POSIX',
         'Programming Language :: C',
         'Programming Language :: Python',
         'Topic :: Software Development :: Version Control',
     ],
     scripts=scripts,
     packages=packages,
     ext_modules=extmodules,
     data_files=datafiles,
     package_data=packagedata,
     cmdclass=cmdclass,
     distclass=hgdist,
     options={
         'py2exe': {
             'bundle_files': 3,
             'dll_excludes': py2exedllexcludes,
             'includes': py2exe_includes,
             'excludes': py2exeexcludes,
             'packages': py2exepackages,
         },
         'bdist_mpkg': {
             'zipdist': False,
             'license': 'COPYING',
             'readme': 'contrib/packaging/macosx/Readme.html',
             'welcome': 'contrib/packaging/macosx/Welcome.html',
         },
     },
     **extra,
 )

tests/hgweberror.py

@@ -1,23 +1,23
 # A dummy extension that installs an hgweb command that throws an Exception.
 
 
 from mercurial.hgweb import webcommands
 
 
 def raiseerror(web):
     '''Dummy web command that raises an uncaught Exception.'''
 
     # Simulate an error after partial response.
     if b'partialresponse' in web.req.qsparams:
         web.res.status = b'200 Script output follows'
         web.res.headers[b'Content-Type'] = b'text/plain'
         web.res.setbodywillwrite()
         list(web.res.sendresponse())
         web.res.getbodyfile().write(b'partial content\n')
 
     raise AttributeError('I am an uncaught error!')
 
 
 def extsetup(ui):
     setattr(webcommands, 'raiseerror', raiseerror)
-    webcommands.__all__.append(b'raiseerror')
+    webcommands.__all__.append('raiseerror')

tests/test-largefiles.t

@@ -1,1879 +1,1884
 This file used to contains all largefile tests.
 Do not add any new tests in this file as it his already far too long to run.
 
 It contains all the testing of the basic concepts of large file in a single block.
 
   $ USERCACHE="$TESTTMP/cache"; export USERCACHE
   $ mkdir "${USERCACHE}"
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > largefiles=
   > purge=
   > rebase=
   > transplant=
   > [phases]
   > publish=False
   > [largefiles]
   > minsize=2
   > patterns=glob:**.dat
   > usercache=${USERCACHE}
   > [hooks]
   > precommit=sh -c "echo \\"Invoking status precommit hook\\"; hg status"
   > EOF
 
 Create the repo with a couple of revisions of both large and normal
 files.
 Test status and dirstate of largefiles and that summary output is correct.
 
   $ hg init a
   $ cd a
   $ mkdir sub
   $ echo normal1 > normal1
   $ echo normal2 > sub/normal2
   $ echo large1 > large1
   $ echo large2 > sub/large2
   $ hg add normal1 sub/normal2
   $ hg add --large large1 sub/large2
   $ hg commit -m "add files"
   Invoking status precommit hook
   A large1
   A normal1
   A sub/large2
   A sub/normal2
   $ touch large1 sub/large2
   $ sleep 1
   $ hg st
   $ hg debugstate --no-dates
   n 644         41 set                 .hglf/large1
   n 644         41 set                 .hglf/sub/large2
   n 644          8 set                 normal1
   n 644          8 set                 sub/normal2
   $ hg debugstate --large --no-dates
   n 644          7 set                 large1
   n 644          7 set                 sub/large2
   $ echo normal11 > normal1
   $ echo normal22 > sub/normal2
   $ echo large11 > large1
   $ echo large22 > sub/large2
   $ hg commit -m "edit files"
   Invoking status precommit hook
   M large1
   M normal1
   M sub/large2
   M sub/normal2
   $ hg sum --large
   parent: 1:ce8896473775 tip
    edit files
   branch: default
   commit: (clean)
   update: (current)
   phases: 2 draft
   largefiles: (no remote repo)
 
 Commit preserved largefile contents.
 
   $ cat normal1
   normal11
   $ cat large1
   large11
   $ cat sub/normal2
   normal22
   $ cat sub/large2
   large22
 
 Test status, subdir and unknown files
 
   $ echo unknown > sub/unknown
   $ hg st --all
   ? sub/unknown
   C large1
   C normal1
   C sub/large2
   C sub/normal2
   $ hg st --all sub
   ? sub/unknown
   C sub/large2
   C sub/normal2
   $ rm sub/unknown
 
 Test messages and exit codes for remove warning cases
 
   $ hg remove -A large1
   not removing large1: file still exists
   [1]
   $ echo 'modified' > large1
   $ hg remove large1
   not removing large1: file is modified (use -f to force removal)
   [1]
   $ echo 'new' > normalnew
   $ hg add normalnew
   $ echo 'new' > largenew
   $ hg add --large normalnew
   normalnew already tracked!
   $ hg remove normalnew largenew
   not removing largenew: file is untracked
   not removing normalnew: file has been marked for add (use 'hg forget' to undo add)
   [1]
   $ rm normalnew largenew
   $ hg up -Cq
 
 Remove both largefiles and normal files.
 
   $ hg remove normal1 large1
   $ hg status large1
   R large1
   $ hg commit -m "remove files"
   Invoking status precommit hook
   R large1
   R normal1
   $ ls -A
   .hg
   .hglf
   sub
   $ echo "testlargefile" > large1-test
   $ hg add --large large1-test
   $ hg st
   A large1-test
   $ hg rm large1-test
   not removing large1-test: file has been marked for add (use forget to undo)
   [1]
   $ hg st
   A large1-test
   $ hg forget large1-test
   $ hg st
   ? large1-test
   $ hg remove large1-test
   not removing large1-test: file is untracked
   [1]
   $ hg forget large1-test
   not removing large1-test: file is already untracked
   [1]
   $ rm large1-test
 
 Copy both largefiles and normal files (testing that status output is correct).
 
   $ hg cp sub/normal2 normal1
   $ hg cp sub/large2 large1
   $ hg commit -m "copy files"
   Invoking status precommit hook
   A large1
   A normal1
   $ cat normal1
   normal22
   $ cat large1
   large22
 
 Test moving largefiles and verify that normal files are also unaffected.
 
   $ hg mv normal1 normal3
   $ hg mv large1 large3
   $ hg mv sub/normal2 sub/normal4
   $ hg mv sub/large2 sub/large4
   $ hg commit -m "move files"
   Invoking status precommit hook
   A large3
   A normal3
   A sub/large4
   A sub/normal4
   R large1
   R normal1
   R sub/large2
   R sub/normal2
   $ cat normal3
   normal22
   $ cat large3
   large22
   $ cat sub/normal4
   normal22
   $ cat sub/large4
   large22
 
 
 #if serve
 Test display of largefiles in hgweb
 
   $ hg serve -d -p $HGPORT --pid-file ../hg.pid
   $ cat ../hg.pid >> $DAEMON_PIDS
   $ get-with-headers.py $LOCALIP:$HGPORT 'file/tip/?style=raw'
   200 Script output follows
   
   
   drwxr-xr-x sub
   -rw-r--r-- 41 large3
   -rw-r--r-- 9 normal3
   
   
   $ get-with-headers.py $LOCALIP:$HGPORT 'file/tip/sub/?style=raw'
   200 Script output follows
   
   
   -rw-r--r-- 41 large4
   -rw-r--r-- 9 normal4
   
   
   $ killdaemons.py
 #endif
 
 Test largefiles can be loaded in hgweb (wrapcommand() shouldn't fail)
 
   $ cat <<EOF > "$TESTTMP/hgweb.cgi"
   > #!$PYTHON
   > from mercurial import demandimport; demandimport.enable()
   > from mercurial.hgweb import hgweb
   > from mercurial.hgweb import wsgicgi
   > application = hgweb(b'.', b'test repo')
   > wsgicgi.launch(application)
   > EOF
   $ . "$TESTDIR/cgienv"
 
   $ SCRIPT_NAME='' \
   > "$PYTHON" "$TESTTMP/hgweb.cgi" > /dev/null
 
 Test archiving the various revisions.  These hit corner cases known with
 archiving.
 
   $ hg archive -r 0 ../archive0
   $ hg archive -r 1 ../archive1
   $ hg archive -r 2 ../archive2
   $ hg archive -r 3 ../archive3
   $ hg archive -r 4 ../archive4
   $ cd ../archive0
   $ cat normal1
   normal1
   $ cat large1
   large1
   $ cat sub/normal2
   normal2
   $ cat sub/large2
   large2
   $ cd ../archive1
   $ cat normal1
   normal11
   $ cat large1
   large11
   $ cat sub/normal2
   normal22
   $ cat sub/large2
   large22
   $ cd ../archive2
   $ ls -A
   .hg_archival.txt
   sub
   $ cat sub/normal2
   normal22
   $ cat sub/large2
   large22
   $ cd ../archive3
   $ cat normal1
   normal22
   $ cat large1
   large22
   $ cat sub/normal2
   normal22
   $ cat sub/large2
   large22
   $ cd ../archive4
   $ cat normal3
   normal22
   $ cat large3
   large22
   $ cat sub/normal4
   normal22
   $ cat sub/large4
   large22
 
 Commit corner case: specify files to commit.
 
   $ cd ../a
   $ echo normal3 > normal3
   $ echo large3 > large3
   $ echo normal4 > sub/normal4
   $ echo large4 > sub/large4
   $ hg commit normal3 large3 sub/normal4 sub/large4 -m "edit files again"
   Invoking status precommit hook
   M large3
   M normal3
   M sub/large4
   M sub/normal4
   $ cat normal3
   normal3
   $ cat large3
   large3
   $ cat sub/normal4
   normal4
   $ cat sub/large4
   large4
 
 One more commit corner case: commit from a subdirectory.
 
   $ cd ../a
   $ echo normal33 > normal3
   $ echo large33 > large3
   $ echo normal44 > sub/normal4
   $ echo large44 > sub/large4
   $ cd sub
   $ hg commit -m "edit files yet again"
   Invoking status precommit hook
   M large3
   M normal3
   M sub/large4
   M sub/normal4
   $ cat ../normal3
   normal33
   $ cat ../large3
   large33
   $ cat normal4
   normal44
   $ cat large4
   large44
 
 Committing standins is not allowed.
 
   $ cd ..
   $ echo large3 > large3
   $ hg commit .hglf/large3 -m "try to commit standin"
   abort: file ".hglf/large3" is a largefile standin
   (commit the largefile itself instead)
   [255]
 
 Corner cases for adding largefiles.
 
   $ echo large5 > large5
   $ hg add --large large5
   $ hg add --large large5
   large5 already a largefile
   $ mkdir sub2
   $ echo large6 > sub2/large6
   $ echo large7 > sub2/large7
   $ hg add --large sub2
   adding sub2/large6 as a largefile
   adding sub2/large7 as a largefile
   $ hg st
   M large3
   A large5
   A sub2/large6
   A sub2/large7
 
 Committing directories containing only largefiles.
 
   $ mkdir -p z/y/x/m
   $ touch z/y/x/m/large1
   $ touch z/y/x/large2
   $ hg add --large z/y/x/m/large1 z/y/x/large2
   $ hg commit -m "Subdir with directory only containing largefiles" z
   Invoking status precommit hook
   M large3
   A large5
   A sub2/large6
   A sub2/large7
   A z/y/x/large2
   A z/y/x/m/large1
 
 (and a bit of log testing)
 
   $ hg log -T '{rev}\n' z/y/x/m/large1
   7
   $ hg log -T '{rev}\n' z/y/x/m  # with only a largefile
   7
 
   $ hg rollback --quiet
   $ touch z/y/x/m/normal
   $ hg add z/y/x/m/normal
   $ hg commit -m "Subdir with mixed contents" z
   Invoking status precommit hook
   M large3
   A large5
   A sub2/large6
   A sub2/large7
   A z/y/x/large2
   A z/y/x/m/large1
   A z/y/x/m/normal
   $ hg st
   M large3
   A large5
   A sub2/large6
   A sub2/large7
   $ hg rollback --quiet
   $ hg revert z/y/x/large2 z/y/x/m/large1
   $ rm z/y/x/large2 z/y/x/m/large1
   $ hg commit -m "Subdir with normal contents" z
   Invoking status precommit hook
   M large3
   A large5
   A sub2/large6
   A sub2/large7
   A z/y/x/m/normal
   $ hg st
   M large3
   A large5
   A sub2/large6
   A sub2/large7
   $ hg rollback --quiet
   $ hg revert --quiet z
   $ hg commit -m "Empty subdir" z
   abort: z: no match under directory!
   [10]
   $ rm -rf z
   $ hg ci -m "standin" .hglf
   abort: file ".hglf" is a largefile standin
   (commit the largefile itself instead)
   [255]
 
 Test "hg status" with combination of 'file pattern' and 'directory
 pattern' for largefiles:
 
   $ hg status sub2/large6 sub2
   A sub2/large6
   A sub2/large7
 
 Config settings (pattern **.dat, minsize 2 MB) are respected.
 
   $ echo testdata > test.dat
   $ dd bs=1k count=2k if=/dev/zero of=reallylarge > /dev/null 2> /dev/null
   $ hg add
   adding reallylarge as a largefile
   adding test.dat as a largefile
 
 Test that minsize and --lfsize handle float values;
 also tests that --lfsize overrides largefiles.minsize.
 (0.250 MB = 256 kB = 262144 B)
 
   $ dd if=/dev/zero of=ratherlarge bs=1024 count=256 > /dev/null 2> /dev/null
   $ dd if=/dev/zero of=medium bs=1024 count=128 > /dev/null 2> /dev/null
   $ hg --config largefiles.minsize=.25 add
   adding ratherlarge as a largefile
   adding medium
   $ hg forget medium
   $ hg --config largefiles.minsize=.25 add --lfsize=.125
   adding medium as a largefile
   $ dd if=/dev/zero of=notlarge bs=1024 count=127 > /dev/null 2> /dev/null
   $ hg --config largefiles.minsize=.25 add --lfsize=.125
   adding notlarge
   $ hg forget notlarge
 
 Test forget on largefiles.
 
   $ hg forget large3 large5 test.dat reallylarge ratherlarge medium
   $ hg commit -m "add/edit more largefiles"
   Invoking status precommit hook
   A sub2/large6
   A sub2/large7
   R large3
   ? large5
   ? medium
   ? notlarge
   ? ratherlarge
   ? reallylarge
   ? test.dat
   $ hg st
   ? large3
   ? large5
   ? medium
   ? notlarge
   ? ratherlarge
   ? reallylarge
   ? test.dat
 
 Purge with largefiles: verify that largefiles are still in the working
 dir after a purge.
 
   $ hg purge --all
   $ cat sub/large4
   large44
   $ cat sub2/large6
   large6
   $ cat sub2/large7
   large7
 
 Test addremove: verify that files that should be added as largefiles are added as
 such and that already-existing largefiles are not added as normal files by
 accident.
 
   $ rm normal3
   $ rm sub/large4
   $ echo "testing addremove with patterns" > testaddremove.dat
   $ echo "normaladdremove" > normaladdremove
   $ hg addremove
   removing sub/large4
   adding testaddremove.dat as a largefile
   removing normal3
   adding normaladdremove
 
 Test addremove with -R
 
   $ hg up -C
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ rm normal3
   $ rm sub/large4
   $ echo "testing addremove with patterns" > testaddremove.dat
   $ echo "normaladdremove" > normaladdremove
   $ cd ..
   $ hg -R a -v addremove
   removing sub/large4
   adding testaddremove.dat as a largefile
   removing normal3
   adding normaladdremove
   $ cd a
 
 Test 3364
   $ hg clone . ../addrm
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../addrm
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > post-commit.stat=sh -c "echo \\"Invoking status postcommit hook\\"; hg status -A"
   > EOF
   $ touch foo
   $ hg add --large foo
   $ hg ci -m "add foo"
   Invoking status precommit hook
   A foo
   Invoking status postcommit hook
   C foo
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
   $ rm foo
   $ hg st
   ! foo
 hmm.. no precommit invoked, but there is a postcommit??
   $ hg ci -m "will not checkin"
   nothing changed (1 missing files, see 'hg status')
   Invoking status postcommit hook
   ! foo
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
   [1]
   $ hg addremove
   removing foo
   $ hg st
   R foo
   $ hg ci -m "used to say nothing changed"
   Invoking status precommit hook
   R foo
   Invoking status postcommit hook
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
   $ hg st
 
 Test 3507 (both normal files and largefiles were a problem)
 
   $ touch normal
   $ touch large
   $ hg add normal
   $ hg add --large large
   $ hg ci -m "added"
   Invoking status precommit hook
   A large
   A normal
   Invoking status postcommit hook
   C large
   C normal
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
   $ hg remove normal
   $ hg addremove --traceback
   $ hg ci -m "addremoved normal"
   Invoking status precommit hook
   R normal
   Invoking status postcommit hook
   C large
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
   $ hg up -C '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg remove large
   $ hg addremove --traceback
   $ hg ci -m "removed large"
   Invoking status precommit hook
   R large
   created new head
   Invoking status postcommit hook
   C normal
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
 
 Test commit -A (issue3542)
   $ echo large8 > large8
   $ hg add --large large8
   $ hg ci -Am 'this used to add large8 as normal and commit both'
   Invoking status precommit hook
   A large8
   Invoking status postcommit hook
   C large8
   C normal
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
   $ rm large8
   $ hg ci -Am 'this used to not notice the rm'
   removing large8
   Invoking status precommit hook
   R large8
   Invoking status postcommit hook
   C normal
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
 
 Test that a standin can't be added as a large file
 
   $ touch large
   $ hg add --large large
   $ hg ci -m "add"
   Invoking status precommit hook
   A large
   Invoking status postcommit hook
   C large
   C normal
   C normal3
   C sub/large4
   C sub/normal4
   C sub2/large6
   C sub2/large7
   $ hg remove large
   $ touch large
   $ hg addremove --config largefiles.patterns=**large --traceback
   adding large as a largefile
 
 Test that outgoing --large works (with revsets too)
   $ hg outgoing --rev '.^' --large
   comparing with $TESTTMP/a
   searching for changes
   changeset:   8:c02fd3b77ec4
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add foo
   
   changeset:   9:289dd08c9bbb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     used to say nothing changed
   
   changeset:   10:34f23ac6ac12
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     added
   
   changeset:   12:710c1b2f523c
   parent:      10:34f23ac6ac12
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     removed large
   
   changeset:   13:0a3e75774479
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     this used to add large8 as normal and commit both
   
   changeset:   14:84f3d378175c
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     this used to not notice the rm
   
   largefiles to upload (1 entities):
   large8
   
   $ cd ../a
 
 Clone a largefiles repo.
 
   $ hg clone . ../b
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../b
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'
   7:daea875e9014  add/edit more largefiles
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   3:9e8fbc4bce62  copy files
   2:51a0ae4d5864  remove files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ cat normal3
   normal33
 
 Test graph log
 
   $ hg log -G --template '{rev}:{node|short}  {desc|firstline}\n'
   @  7:daea875e9014  add/edit more largefiles
   |
   o  6:4355d653f84f  edit files yet again
   |
   o  5:9d5af5072dbd  edit files again
   |
   o  4:74c02385b94c  move files
   |
   o  3:9e8fbc4bce62  copy files
   |
   o  2:51a0ae4d5864  remove files
   |
   o  1:ce8896473775  edit files
   |
   o  0:30d30fe6a5be  add files
   
 
 Test log with --patch
 
   $ hg log --patch -r 6::7
   changeset:   6:4355d653f84f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     edit files yet again
   
   diff -r 9d5af5072dbd -r 4355d653f84f .hglf/large3
   --- a/.hglf/large3	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hglf/large3	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -baaf12afde9d8d67f25dab6dced0d2bf77dba47c
   +7838695e10da2bb75ac1156565f40a2595fa2fa0
   diff -r 9d5af5072dbd -r 4355d653f84f .hglf/sub/large4
   --- a/.hglf/sub/large4	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hglf/sub/large4	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -aeb2210d19f02886dde00dac279729a48471e2f9
   +971fb41e78fea4f8e0ba5244784239371cb00591
   diff -r 9d5af5072dbd -r 4355d653f84f normal3
   --- a/normal3	Thu Jan 01 00:00:00 1970 +0000
   +++ b/normal3	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -normal3
   +normal33
   diff -r 9d5af5072dbd -r 4355d653f84f sub/normal4
   --- a/sub/normal4	Thu Jan 01 00:00:00 1970 +0000
   +++ b/sub/normal4	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -normal4
   +normal44
   
   changeset:   7:daea875e9014
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add/edit more largefiles
   
   diff -r 4355d653f84f -r daea875e9014 .hglf/large3
   --- a/.hglf/large3	Thu Jan 01 00:00:00 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -7838695e10da2bb75ac1156565f40a2595fa2fa0
   diff -r 4355d653f84f -r daea875e9014 .hglf/sub2/large6
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hglf/sub2/large6	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +0d6d75887db61b2c7e6c74b5dd8fc6ad50c0cc30
   diff -r 4355d653f84f -r daea875e9014 .hglf/sub2/large7
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hglf/sub2/large7	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +bb3151689acb10f0c3125c560d5e63df914bc1af
   
 
   $ hg log --patch -r 6::7 sub/
   changeset:   6:4355d653f84f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     edit files yet again
   
   diff -r 9d5af5072dbd -r 4355d653f84f .hglf/sub/large4
   --- a/.hglf/sub/large4	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hglf/sub/large4	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -aeb2210d19f02886dde00dac279729a48471e2f9
   +971fb41e78fea4f8e0ba5244784239371cb00591
   diff -r 9d5af5072dbd -r 4355d653f84f sub/normal4
   --- a/sub/normal4	Thu Jan 01 00:00:00 1970 +0000
   +++ b/sub/normal4	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -normal4
   +normal44
   
 
 log with both --follow and --patch
 
   $ hg log --follow --patch --limit 2
   changeset:   7:daea875e9014
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add/edit more largefiles
   
   diff -r 4355d653f84f -r daea875e9014 .hglf/large3
   --- a/.hglf/large3	Thu Jan 01 00:00:00 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +0,0 @@
   -7838695e10da2bb75ac1156565f40a2595fa2fa0
   diff -r 4355d653f84f -r daea875e9014 .hglf/sub2/large6
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hglf/sub2/large6	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +0d6d75887db61b2c7e6c74b5dd8fc6ad50c0cc30
   diff -r 4355d653f84f -r daea875e9014 .hglf/sub2/large7
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hglf/sub2/large7	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +bb3151689acb10f0c3125c560d5e63df914bc1af
   
   changeset:   6:4355d653f84f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     edit files yet again
   
   diff -r 9d5af5072dbd -r 4355d653f84f .hglf/large3
   --- a/.hglf/large3	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hglf/large3	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -baaf12afde9d8d67f25dab6dced0d2bf77dba47c
   +7838695e10da2bb75ac1156565f40a2595fa2fa0
   diff -r 9d5af5072dbd -r 4355d653f84f .hglf/sub/large4
   --- a/.hglf/sub/large4	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hglf/sub/large4	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -aeb2210d19f02886dde00dac279729a48471e2f9
   +971fb41e78fea4f8e0ba5244784239371cb00591
   diff -r 9d5af5072dbd -r 4355d653f84f normal3
   --- a/normal3	Thu Jan 01 00:00:00 1970 +0000
   +++ b/normal3	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -normal3
   +normal33
   diff -r 9d5af5072dbd -r 4355d653f84f sub/normal4
   --- a/sub/normal4	Thu Jan 01 00:00:00 1970 +0000
   +++ b/sub/normal4	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -normal4
   +normal44
   
   $ hg log --follow --patch sub/large4
   changeset:   6:4355d653f84f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     edit files yet again
   
   diff -r 9d5af5072dbd -r 4355d653f84f .hglf/sub/large4
   --- a/.hglf/sub/large4	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hglf/sub/large4	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -aeb2210d19f02886dde00dac279729a48471e2f9
   +971fb41e78fea4f8e0ba5244784239371cb00591
   
   changeset:   5:9d5af5072dbd
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     edit files again
   
   diff -r 74c02385b94c -r 9d5af5072dbd .hglf/sub/large4
   --- a/.hglf/sub/large4	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hglf/sub/large4	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -eb7338044dc27f9bc59b8dd5a246b065ead7a9c4
   +aeb2210d19f02886dde00dac279729a48471e2f9
   
   changeset:   4:74c02385b94c
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     move files
   
   diff -r 9e8fbc4bce62 -r 74c02385b94c .hglf/sub/large4
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hglf/sub/large4	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +eb7338044dc27f9bc59b8dd5a246b065ead7a9c4
   
   changeset:   1:ce8896473775
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     edit files
   
   diff -r 30d30fe6a5be -r ce8896473775 .hglf/sub/large2
   --- a/.hglf/sub/large2	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hglf/sub/large2	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -1deebade43c8c498a3c8daddac0244dc55d1331d
   +eb7338044dc27f9bc59b8dd5a246b065ead7a9c4
   
   changeset:   0:30d30fe6a5be
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add files
   
   diff -r 000000000000 -r 30d30fe6a5be .hglf/sub/large2
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hglf/sub/large2	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +1deebade43c8c498a3c8daddac0244dc55d1331d
   
   $ cat sub/normal4
   normal44
   $ cat sub/large4
   large44
   $ cat sub2/large6
   large6
   $ cat sub2/large7
   large7
   $ hg log -qf sub2/large7
   7:daea875e9014
   $ hg log -Gqf sub2/large7
   @  7:daea875e9014
   |
   ~
   $ cd ..
 
 Test log from outside repo
 
   $ hg log  b/sub -T '{rev}:{node|short}  {desc|firstline}\n'
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
 
 Test clone at revision
 
   $ hg clone a -r 3 c
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 10 changes to 4 files
   new changesets 30d30fe6a5be:9e8fbc4bce62 (4 drafts)
   updating to branch default
   getting changed largefiles
   2 largefiles updated, 0 removed
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd c
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'
   3:9e8fbc4bce62  copy files
   2:51a0ae4d5864  remove files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ cat normal1
   normal22
   $ cat large1
   large22
   $ cat sub/normal2
   normal22
   $ cat sub/large2
   large22
 
 Old revisions of a clone have correct largefiles content (this also
 tests update).
 
   $ hg update -r 1
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat large1
   large11
   $ cat sub/large2
   large22
   $ cd ..
 
 Test cloning with --all-largefiles flag
 
   $ rm "${USERCACHE}"/*
   $ hg clone --all-largefiles a a-backup
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   7 additional largefiles cached
 
   $ rm "${USERCACHE}"/*
   $ hg clone --all-largefiles -u 0 a a-clone0
   updating to branch default
   getting changed largefiles
   2 largefiles updated, 0 removed
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   8 additional largefiles cached
   $ hg -R a-clone0 sum
   parent: 0:30d30fe6a5be 
    add files
   branch: default
   commit: (clean)
   update: 7 new changesets (update)
   phases: 8 draft
 
   $ rm "${USERCACHE}"/*
   $ hg clone --all-largefiles -u 1 a a-clone1
   updating to branch default
   getting changed largefiles
   2 largefiles updated, 0 removed
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   8 additional largefiles cached
   $ hg -R a-clone1 verify --large --lfa --lfc -q
   $ hg -R a-clone1 sum
   parent: 1:ce8896473775 
    edit files
   branch: default
   commit: (clean)
   update: 6 new changesets (update)
   phases: 8 draft
 
   $ rm "${USERCACHE}"/*
   $ hg clone --all-largefiles -U a a-clone-u
   10 additional largefiles cached
   $ hg -R a-clone-u sum
   parent: -1:000000000000  (no revision checked out)
   branch: default
   commit: (clean)
   update: 8 new changesets (update)
   phases: 8 draft
 
 Show computed destination directory:
 
   $ mkdir xyz
   $ cd xyz
   $ hg clone ../a
   destination directory: a
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
 
 Clone URL without path:
 
   $ hg clone file://
   abort: repository / not found
   [255]
 
 Ensure base clone command argument validation
 
   $ hg clone -U -u 0 a a-clone-failure
   abort: cannot specify both --noupdate and --updaterev
   [10]
 
   $ hg clone --all-largefiles a ssh://localhost/a
   abort: --all-largefiles is incompatible with non-local destination ssh://localhost/a
   [255]
 
+  $ touch existing_destination
+  $ hg clone --all-largefiles a existing_destination
+  abort: destination 'existing_destination' already exists
+  [10]
+
 Test pulling with --all-largefiles flag.  Also test that the largefiles are
 downloaded from 'default' instead of 'default-push' when no source is specified
 (issue3584)
 
   $ rm -Rf a-backup
   $ hg clone -r 1 a a-backup
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 8 changes to 4 files
   new changesets 30d30fe6a5be:ce8896473775 (2 drafts)
   updating to branch default
   getting changed largefiles
   2 largefiles updated, 0 removed
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ rm "${USERCACHE}"/*
   $ cd a-backup
   $ hg pull --all-largefiles --config paths.default-push=bogus/path
   pulling from $TESTTMP/a
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 6 changesets with 16 changes to 8 files
   new changesets 51a0ae4d5864:daea875e9014 (6 drafts)
   (run 'hg update' to get a working copy)
   6 largefiles cached
 
 redo pull with --lfrev and check it pulls largefiles for the right revs
 
   $ hg rollback
   repository tip rolled back to revision 1 (undo pull)
   $ hg pull -v --lfrev 'heads(pulled())+min(pulled())'
   pulling from $TESTTMP/a
   searching for changes
   all local changesets known remotely
   6 changesets found
   uncompressed size of bundle content:
       1401 (changelog)
       1710 (manifests)
        256  .hglf/large1
        570  .hglf/large3
        578  .hglf/sub/large4
        184  .hglf/sub2/large6
        184  .hglf/sub2/large7
        214  normal1
        463  normal3
        471  sub/normal4
   adding changesets
   adding manifests
   adding file changes
   added 6 changesets with 16 changes to 8 files
   new changesets 51a0ae4d5864:daea875e9014 (6 drafts)
   calling hook changegroup.lfiles: hgext.largefiles.reposetup.checkrequireslfiles
   (run 'hg update' to get a working copy)
   pulling largefiles for revision 7
   found 971fb41e78fea4f8e0ba5244784239371cb00591 in store
   found 0d6d75887db61b2c7e6c74b5dd8fc6ad50c0cc30 in store
   found bb3151689acb10f0c3125c560d5e63df914bc1af in store
   pulling largefiles for revision 2
   found eb7338044dc27f9bc59b8dd5a246b065ead7a9c4 in store
   0 largefiles cached
 
 lfpull
 
   $ hg lfpull -r : --config largefiles.usercache=usercache-lfpull
   2 largefiles cached
   $ hg lfpull -v -r 4+2 --config largefiles.usercache=usercache-lfpull
   pulling largefiles for revision 4
   found eb7338044dc27f9bc59b8dd5a246b065ead7a9c4 in store
   found eb7338044dc27f9bc59b8dd5a246b065ead7a9c4 in store
   pulling largefiles for revision 2
   found eb7338044dc27f9bc59b8dd5a246b065ead7a9c4 in store
   0 largefiles cached
 
   $ ls usercache-lfpull/* | sort
   usercache-lfpull/1deebade43c8c498a3c8daddac0244dc55d1331d
   usercache-lfpull/4669e532d5b2c093a78eca010077e708a071bb64
 
   $ cd ..
 
 Rebasing between two repositories does not revert largefiles to old
 revisions (this was a very bad bug that took a lot of work to fix).
 
   $ hg clone a d
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd b
   $ echo large4-modified > sub/large4
   $ echo normal3-modified > normal3
   $ hg commit -m "modify normal file and largefile in repo b"
   Invoking status precommit hook
   M normal3
   M sub/large4
   $ cd ../d
   $ echo large6-modified > sub2/large6
   $ echo normal4-modified > sub/normal4
   $ hg commit -m "modify normal file largefile in repo d"
   Invoking status precommit hook
   M sub/normal4
   M sub2/large6
   $ cd ..
   $ hg clone d e
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd d
 
 More rebase testing, but also test that the largefiles are downloaded from
 'default-push' when no source is specified (issue3584). (The largefile from the
 pulled revision is however not downloaded but found in the local cache.)
 Largefiles are fetched for the new pulled revision, not for existing revisions,
 rebased or not.
 
   $ [ ! -f .hg/largefiles/e166e74c7303192238d60af5a9c4ce9bef0b7928 ]
   $ hg pull --rebase --all-largefiles --config paths.default-push=bogus/path --config paths.default=../b
   pulling from $TESTTMP/b
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files (+1 heads)
   new changesets a381d2c8c80e (1 drafts)
   0 largefiles cached
   rebasing 8:f574fb32bb45 "modify normal file largefile in repo d"
   Invoking status precommit hook
   M sub/normal4
   M sub2/large6
   saved backup bundle to $TESTTMP/d/.hg/strip-backup/f574fb32bb45-dd1d9f80-rebase.hg
   $ [ -f .hg/largefiles/e166e74c7303192238d60af5a9c4ce9bef0b7928 ]
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'
   9:598410d3eb9a  modify normal file largefile in repo d
   8:a381d2c8c80e  modify normal file and largefile in repo b
   7:daea875e9014  add/edit more largefiles
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   3:9e8fbc4bce62  copy files
   2:51a0ae4d5864  remove files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ hg log -G --template '{rev}:{node|short}  {desc|firstline}\n'
   @  9:598410d3eb9a  modify normal file largefile in repo d
   |
   o  8:a381d2c8c80e  modify normal file and largefile in repo b
   |
   o  7:daea875e9014  add/edit more largefiles
   |
   o  6:4355d653f84f  edit files yet again
   |
   o  5:9d5af5072dbd  edit files again
   |
   o  4:74c02385b94c  move files
   |
   o  3:9e8fbc4bce62  copy files
   |
   o  2:51a0ae4d5864  remove files
   |
   o  1:ce8896473775  edit files
   |
   o  0:30d30fe6a5be  add files
   
   $ cat normal3
   normal3-modified
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-modified
   $ cat sub2/large6
   large6-modified
   $ cat sub2/large7
   large7
   $ cd ../e
   $ hg pull ../b
   pulling from ../b
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files (+1 heads)
   new changesets a381d2c8c80e (1 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg rebase
   rebasing 8:f574fb32bb45 "modify normal file largefile in repo d"
   Invoking status precommit hook
   M sub/normal4
   M sub2/large6
   saved backup bundle to $TESTTMP/e/.hg/strip-backup/f574fb32bb45-dd1d9f80-rebase.hg
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'
   9:598410d3eb9a  modify normal file largefile in repo d
   8:a381d2c8c80e  modify normal file and largefile in repo b
   7:daea875e9014  add/edit more largefiles
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   3:9e8fbc4bce62  copy files
   2:51a0ae4d5864  remove files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ cat normal3
   normal3-modified
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-modified
   $ cat sub2/large6
   large6-modified
   $ cat sub2/large7
   large7
 
 Log on largefiles
 
 - same output
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n' .hglf/sub/large4
   8:a381d2c8c80e  modify normal file and largefile in repo b
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   $ hg log -G --template '{rev}:{node|short}  {desc|firstline}\n' .hglf/sub/large4
   o  8:a381d2c8c80e  modify normal file and largefile in repo b
   :
   o  6:4355d653f84f  edit files yet again
   |
   o  5:9d5af5072dbd  edit files again
   |
   o  4:74c02385b94c  move files
   |
   ~
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n' sub/large4
   8:a381d2c8c80e  modify normal file and largefile in repo b
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   $ hg log -G --template '{rev}:{node|short}  {desc|firstline}\n' .hglf/sub/large4
   o  8:a381d2c8c80e  modify normal file and largefile in repo b
   :
   o  6:4355d653f84f  edit files yet again
   |
   o  5:9d5af5072dbd  edit files again
   |
   o  4:74c02385b94c  move files
   |
   ~
 
 - .hglf only matches largefiles, without .hglf it matches 9 bco sub/normal
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n' .hglf/sub
   8:a381d2c8c80e  modify normal file and largefile in repo b
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ hg log -G --template '{rev}:{node|short}  {desc|firstline}\n' .hglf/sub
   o  8:a381d2c8c80e  modify normal file and largefile in repo b
   :
   o  6:4355d653f84f  edit files yet again
   |
   o  5:9d5af5072dbd  edit files again
   |
   o  4:74c02385b94c  move files
   :
   o  1:ce8896473775  edit files
   |
   o  0:30d30fe6a5be  add files
   
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n' sub
   9:598410d3eb9a  modify normal file largefile in repo d
   8:a381d2c8c80e  modify normal file and largefile in repo b
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ hg log -G --template '{rev}:{node|short}  {desc|firstline}\n' sub
   @  9:598410d3eb9a  modify normal file largefile in repo d
   |
   o  8:a381d2c8c80e  modify normal file and largefile in repo b
   :
   o  6:4355d653f84f  edit files yet again
   |
   o  5:9d5af5072dbd  edit files again
   |
   o  4:74c02385b94c  move files
   :
   o  1:ce8896473775  edit files
   |
   o  0:30d30fe6a5be  add files
   
 - globbing gives same result
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n' 'glob:sub/*'
   9:598410d3eb9a  modify normal file largefile in repo d
   8:a381d2c8c80e  modify normal file and largefile in repo b
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ hg log -G --template '{rev}:{node|short}  {desc|firstline}\n' 'glob:sub/*'
   @  9:598410d3eb9a  modify normal file largefile in repo d
   |
   o  8:a381d2c8c80e  modify normal file and largefile in repo b
   :
   o  6:4355d653f84f  edit files yet again
   |
   o  5:9d5af5072dbd  edit files again
   |
   o  4:74c02385b94c  move files
   :
   o  1:ce8896473775  edit files
   |
   o  0:30d30fe6a5be  add files
   
 Rollback on largefiles.
 
   $ echo large4-modified-again > sub/large4
   $ hg commit -m "Modify large4 again"
   Invoking status precommit hook
   M sub/large4
   $ hg rollback
   repository tip rolled back to revision 9 (undo commit)
   working directory now based on revision 9
   $ hg st
   M sub/large4
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'
   9:598410d3eb9a  modify normal file largefile in repo d
   8:a381d2c8c80e  modify normal file and largefile in repo b
   7:daea875e9014  add/edit more largefiles
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   3:9e8fbc4bce62  copy files
   2:51a0ae4d5864  remove files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ cat sub/large4
   large4-modified-again
 
 "update --check" refuses to update with uncommitted changes.
   $ hg update --check 8
   abort: uncommitted changes
   [255]
 
 "update --clean" leaves correct largefiles in working copy, even when there is
 .orig files from revert in .hglf.
 
   $ echo mistake > sub2/large7
   $ hg revert sub2/large7
   $ cat sub2/large7
   large7
   $ cat sub2/large7.orig
   mistake
   $ test ! -f .hglf/sub2/large7.orig
 
   $ hg -q update --clean -r null
   $ hg update --clean
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat normal3
   normal3-modified
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-modified
   $ cat sub2/large6
   large6-modified
   $ cat sub2/large7
   large7
   $ cat sub2/large7.orig
   mistake
   $ test ! -f .hglf/sub2/large7.orig
 
 verify that largefile .orig file no longer is overwritten on every update -C:
   $ hg update --clean
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat sub2/large7.orig
   mistake
   $ rm sub2/large7.orig
 
 Now "update check" is happy.
   $ hg update --check 8
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg update --check
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Test removing empty largefiles directories on update
   $ test -d sub2 && echo "sub2 exists"
   sub2 exists
   $ hg update -q null
   $ test -d sub2 && echo "error: sub2 should not exist anymore"
   [1]
   $ hg update -q
 
 Test hg remove removes empty largefiles directories
   $ test -d sub2 && echo "sub2 exists"
   sub2 exists
   $ hg remove sub2/*
   $ test -d sub2 && echo "error: sub2 should not exist anymore"
   [1]
   $ hg revert sub2/large6 sub2/large7
 
 "revert" works on largefiles (and normal files too).
   $ echo hack3 >> normal3
   $ echo hack4 >> sub/normal4
   $ echo hack4 >> sub/large4
   $ rm sub2/large6
   $ hg revert sub2/large6
   $ hg rm sub2/large6
   $ echo new >> sub2/large8
   $ hg add --large sub2/large8
 # XXX we don't really want to report that we're reverting the standin;
 # that's just an implementation detail. But I don't see an obvious fix. ;-(
   $ hg revert sub
   reverting .hglf/sub/large4
   reverting sub/normal4
   $ hg status
   M normal3
   A sub2/large8
   R sub2/large6
   ? sub/large4.orig
   ? sub/normal4.orig
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-modified
   $ hg revert -a --no-backup
   forgetting .hglf/sub2/large8
   reverting normal3
   undeleting .hglf/sub2/large6
   $ hg status
   ? sub/large4.orig
   ? sub/normal4.orig
   ? sub2/large8
   $ cat normal3
   normal3-modified
   $ cat sub2/large6
   large6-modified
   $ rm sub/*.orig sub2/large8
 
 revert some files to an older revision
   $ hg revert --no-backup -r 8 sub2
   reverting .hglf/sub2/large6
   $ cat sub2/large6
   large6
   $ hg revert --no-backup -C -r '.^' sub2
   $ hg revert --no-backup sub2
   reverting .hglf/sub2/large6
   $ hg status
 
 "verify --large" actually verifies largefiles
 
 - Where Do We Come From? What Are We? Where Are We Going?
   $ pwd
   $TESTTMP/e
   $ hg paths
   default = $TESTTMP/d
 
   $ hg verify --large
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checking dirstate
   checked 10 changesets with 28 changes to 10 files
   searching 1 changesets for largefiles
   verified existence of 3 revisions of 3 largefiles
 
 - introduce missing blob in local store repo and remote store
 and make sure that this is caught:
 
   $ mv $TESTTMP/d/.hg/largefiles/e166e74c7303192238d60af5a9c4ce9bef0b7928 .
   $ rm .hg/largefiles/e166e74c7303192238d60af5a9c4ce9bef0b7928
   $ hg verify --large -q
   changeset 9:598410d3eb9a: sub/large4 references missing $TESTTMP/d/.hg/largefiles/e166e74c7303192238d60af5a9c4ce9bef0b7928
   [1]
 
 - introduce corruption and make sure that it is caught when checking content:
   $ echo '5 cents' > $TESTTMP/d/.hg/largefiles/e166e74c7303192238d60af5a9c4ce9bef0b7928
   $ hg verify -q --large --lfc
   changeset 9:598410d3eb9a: sub/large4 references corrupted $TESTTMP/d/.hg/largefiles/e166e74c7303192238d60af5a9c4ce9bef0b7928
   [1]
 
 - cleanup
   $ cp e166e74c7303192238d60af5a9c4ce9bef0b7928 $TESTTMP/d/.hg/largefiles/
   $ mv e166e74c7303192238d60af5a9c4ce9bef0b7928 .hg/largefiles/
 
 - verifying all revisions will fail because we didn't clone all largefiles to d:
   $ echo 'T-shirt' > $TESTTMP/d/.hg/largefiles/eb7338044dc27f9bc59b8dd5a246b065ead7a9c4
   $ hg verify -q --lfa --lfc
   changeset 0:30d30fe6a5be: large1 references missing $TESTTMP/d/.hg/largefiles/4669e532d5b2c093a78eca010077e708a071bb64
   changeset 0:30d30fe6a5be: sub/large2 references missing $TESTTMP/d/.hg/largefiles/1deebade43c8c498a3c8daddac0244dc55d1331d
   changeset 1:ce8896473775: large1 references missing $TESTTMP/d/.hg/largefiles/5f78770c0e77ba4287ad6ef3071c9bf9c379742f
   changeset 1:ce8896473775: sub/large2 references corrupted $TESTTMP/d/.hg/largefiles/eb7338044dc27f9bc59b8dd5a246b065ead7a9c4
   changeset 3:9e8fbc4bce62: large1 references corrupted $TESTTMP/d/.hg/largefiles/eb7338044dc27f9bc59b8dd5a246b065ead7a9c4
   changeset 4:74c02385b94c: large3 references corrupted $TESTTMP/d/.hg/largefiles/eb7338044dc27f9bc59b8dd5a246b065ead7a9c4
   changeset 4:74c02385b94c: sub/large4 references corrupted $TESTTMP/d/.hg/largefiles/eb7338044dc27f9bc59b8dd5a246b065ead7a9c4
   changeset 5:9d5af5072dbd: large3 references missing $TESTTMP/d/.hg/largefiles/baaf12afde9d8d67f25dab6dced0d2bf77dba47c
   changeset 5:9d5af5072dbd: sub/large4 references missing $TESTTMP/d/.hg/largefiles/aeb2210d19f02886dde00dac279729a48471e2f9
   changeset 6:4355d653f84f: large3 references missing $TESTTMP/d/.hg/largefiles/7838695e10da2bb75ac1156565f40a2595fa2fa0
   [1]
 
 - cleanup
   $ rm $TESTTMP/d/.hg/largefiles/eb7338044dc27f9bc59b8dd5a246b065ead7a9c4
   $ rm -f .hglf/sub/*.orig
 
 Update to revision with missing largefile - and make sure it really is missing
 
   $ rm ${USERCACHE}/7838695e10da2bb75ac1156565f40a2595fa2fa0
   $ hg up -r 6
   getting changed largefiles
   large3: largefile 7838695e10da2bb75ac1156565f40a2595fa2fa0 not available from file:/*/$TESTTMP/d (glob)
   1 largefiles updated, 2 removed
   4 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ rm normal3
   $ echo >> sub/normal4
   $ hg ci -m 'commit with missing files'
   Invoking status precommit hook
   M sub/normal4
   ! large3
   ! normal3
   created new head
   $ hg st
   ! large3
   ! normal3
   $ hg up -r.
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg st
   ! large3
   ! normal3
   $ hg up -Cr.
   getting changed largefiles
   large3: largefile 7838695e10da2bb75ac1156565f40a2595fa2fa0 not available from file:/*/$TESTTMP/d (glob)
   0 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg st
   ! large3
   $ hg rollback
   repository tip rolled back to revision 9 (undo commit)
   working directory now based on revision 6
 
 Merge with revision with missing largefile - and make sure it tries to fetch it.
 
   $ hg up -Cqr null
   $ echo f > f
   $ hg ci -Am branch
   adding f
   Invoking status precommit hook
   A f
   created new head
   $ hg merge -r 6
   getting changed largefiles
   large3: largefile 7838695e10da2bb75ac1156565f40a2595fa2fa0 not available from file:/*/$TESTTMP/d (glob)
   1 largefiles updated, 0 removed
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg rollback -q
   $ hg up -Cq
 
 Pulling 0 revisions with --all-largefiles should not fetch for all revisions
 
   $ hg pull --all-largefiles
   pulling from $TESTTMP/d
   searching for changes
   no changes found
 
 Merging does not revert to old versions of largefiles and also check
 that merging after having pulled from a non-default remote works
 correctly.
 
   $ cd ..
   $ hg clone -r 7 e temp
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 24 changes to 10 files
   new changesets 30d30fe6a5be:daea875e9014 (8 drafts)
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg clone temp f
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
 # Delete the largefiles in the largefiles system cache so that we have an
 # opportunity to test that caching after a pull works.
   $ rm "${USERCACHE}"/*
   $ cd f
   $ echo "large4-merge-test" > sub/large4
   $ hg commit -m "Modify large4 to test merge"
   Invoking status precommit hook
   M sub/large4
 # Test --cache-largefiles flag
   $ hg pull --lfrev 'heads(pulled())' ../e
   pulling from ../e
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 4 changes to 4 files (+1 heads)
   new changesets a381d2c8c80e:598410d3eb9a (2 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   2 largefiles cached
   $ hg merge
   largefile sub/large4 has a merge conflict
   ancestor was 971fb41e78fea4f8e0ba5244784239371cb00591
   you can keep (l)ocal d846f26643bfa8ec210be40cc93cc6b7ff1128ea or take (o)ther e166e74c7303192238d60af5a9c4ce9bef0b7928.
   what do you want to do? l
   getting changed largefiles
   1 largefiles updated, 0 removed
   3 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg commit -m "Merge repos e and f"
   Invoking status precommit hook
   M normal3
   M sub/normal4
   M sub2/large6
   $ cat normal3
   normal3-modified
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-merge-test
   $ cat sub2/large6
   large6-modified
   $ cat sub2/large7
   large7
 
 Test status after merging with a branch that introduces a new largefile:
 
   $ echo large > large
   $ hg add --large large
   $ hg commit -m 'add largefile'
   Invoking status precommit hook
   A large
   $ hg update -q ".^"
   $ echo change >> normal3
   $ hg commit -m 'some change'
   Invoking status precommit hook
   M normal3
   created new head
   $ hg merge
   getting changed largefiles
   1 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg status
   M large
 
 - make sure update of merge with removed largefiles fails as expected
   $ hg rm sub2/large6
   $ hg up -r.
   abort: outstanding uncommitted merge
   [20]
 
 - revert should be able to revert files introduced in a pending merge
   $ hg revert --all -r .
   removing .hglf/large
   undeleting .hglf/sub2/large6
 
 Test that a normal file and a largefile with the same name and path cannot
 coexist.
 
   $ rm sub2/large7
   $ echo "largeasnormal" > sub2/large7
   $ hg add sub2/large7
   sub2/large7 already a largefile
 
 Test that transplanting a largefile change works correctly.
 
   $ cd ..
   $ hg clone -r 8 d g
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 26 changes to 10 files
   new changesets 30d30fe6a5be:a381d2c8c80e (9 drafts)
   updating to branch default
   getting changed largefiles
   3 largefiles updated, 0 removed
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd g
   $ hg transplant -s ../d 598410d3eb9a
   searching for changes
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   new changesets 598410d3eb9a (1 drafts)
   $ hg log --template '{rev}:{node|short}  {desc|firstline}\n'
   9:598410d3eb9a  modify normal file largefile in repo d
   8:a381d2c8c80e  modify normal file and largefile in repo b
   7:daea875e9014  add/edit more largefiles
   6:4355d653f84f  edit files yet again
   5:9d5af5072dbd  edit files again
   4:74c02385b94c  move files
   3:9e8fbc4bce62  copy files
   2:51a0ae4d5864  remove files
   1:ce8896473775  edit files
   0:30d30fe6a5be  add files
   $ cat normal3
   normal3-modified
   $ cat sub/normal4
   normal4-modified
   $ cat sub/large4
   large4-modified
   $ cat sub2/large6
   large6-modified
   $ cat sub2/large7
   large7
 
 Cat a largefile
   $ hg cat normal3
   normal3-modified
   $ hg cat sub/large4
   large4-modified
   $ rm "${USERCACHE}"/*
   $ hg cat -r a381d2c8c80e -o cat.out sub/large4
   $ cat cat.out
   large4-modified
   $ rm cat.out
   $ hg cat -r a381d2c8c80e normal3
   normal3-modified
   $ hg cat -r '.^' normal3
   normal3-modified
   $ hg cat -r '.^' sub/large4 doesntexist
   large4-modified
   doesntexist: no such file in rev a381d2c8c80e
   $ hg --cwd sub cat -r '.^' large4
   large4-modified
   $ hg --cwd sub cat -r '.^' ../normal3
   normal3-modified
 Cat a standin
   $ hg cat .hglf/sub/large4
   e166e74c7303192238d60af5a9c4ce9bef0b7928
   $ hg cat .hglf/normal3
   .hglf/normal3: no such file in rev 598410d3eb9a
   [1]
 
 Test that renaming a largefile results in correct output for status
 
   $ hg rename sub/large4 large4-renamed
   $ hg commit -m "test rename output"
   Invoking status precommit hook
   A large4-renamed
   R sub/large4
   $ cat large4-renamed
   large4-modified
   $ cd sub2
   $ hg rename large6 large6-renamed
   $ hg st
   A sub2/large6-renamed
   R sub2/large6
   $ cd ..
 
 Test --normal flag
 
   $ dd if=/dev/zero bs=2k count=11k > new-largefile 2> /dev/null
   $ hg add --normal --large new-largefile
   abort: --normal cannot be used with --large
   [255]
   $ hg add --normal new-largefile
   new-largefile: up to 69 MB of RAM may be required to manage this file
   (use 'hg revert new-largefile' to cancel the pending addition)
   $ hg revert new-largefile
   $ hg --config ui.large-file-limit=22M add --normal new-largefile
 
 Test explicit commit of switch between normal and largefile - make sure both
 the add and the remove is committed.
 
   $ hg up -qC
   $ hg forget normal3 large4-renamed
   $ hg add --large normal3
   $ hg add large4-renamed
   $ hg commit -m 'swap' normal3 large4-renamed
   Invoking status precommit hook
   A large4-renamed
   A normal3
   ? new-largefile
   ? sub2/large6-renamed
   $ hg mani
   .hglf/normal3
   .hglf/sub2/large6
   .hglf/sub2/large7
   large4-renamed
   sub/normal4
 
   $ cd ..