cleanup: remove unnecessary list constructor calls around list comprehensions

hgext/githelp.py

@@ -1,1269 +1,1269 b''
 # githelp.py - Try to map Git commands to Mercurial equivalents.
 #
 # Copyright 2013 Facebook, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 """try mapping git commands to Mercurial commands
 
 Tries to map a given git command to a Mercurial command:
 
   $ hg githelp -- git checkout master
   hg update master
 
 If an unknown command or parameter combination is detected, an error is
 produced.
 """
 
 
 import getopt
 import re
 
 from mercurial.i18n import _
 from mercurial import (
     encoding,
     error,
     fancyopts,
     pycompat,
     registrar,
     scmutil,
 )
 from mercurial.utils import procutil
 
 # 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'
 
 cmdtable = {}
 command = registrar.command(cmdtable)
 
 
 def convert(s):
     if s.startswith(b"origin/"):
         return s[7:]
     if b'HEAD' in s:
         s = s.replace(b'HEAD', b'.')
     # HEAD~ in git is .~1 in mercurial
     s = re.sub(b'~$', b'~1', s)
     return s
 
 
 @command(
     b'githelp|git',
     [],
     _(b'hg githelp'),
     helpcategory=command.CATEGORY_HELP,
     helpbasic=True,
 )
 def githelp(ui, repo, *args, **kwargs):
     """suggests the Mercurial equivalent of the given git command
 
     Usage: hg githelp -- <git command>
     """
 
     if len(args) == 0 or (len(args) == 1 and args[0] == b'git'):
         raise error.Abort(
             _(b'missing git command - usage: hg githelp -- <git command>')
         )
 
     if args[0] == b'git':
         args = args[1:]
 
     cmd = args[0]
     if not cmd in gitcommands:
         raise error.Abort(_(b"error: unknown git command %s") % cmd)
 
     ui.pager(b'githelp')
     args = args[1:]
     return gitcommands[cmd](ui, repo, *args, **kwargs)
 
 
 def parseoptions(ui, cmdoptions, args):
     cmdoptions = list(cmdoptions)
     opts = {}
     args = list(args)
     while True:
         try:
             args = fancyopts.fancyopts(list(args), cmdoptions, opts, True)
             break
         except getopt.GetoptError as ex:
             if "requires argument" in ex.msg:
                 raise
             if ('--' + ex.opt) in ex.msg:
                 flag = b'--' + pycompat.bytestr(ex.opt)
             elif ('-' + ex.opt) in ex.msg:
                 flag = b'-' + pycompat.bytestr(ex.opt)
             else:
                 raise error.Abort(
                     _(b"unknown option %s") % pycompat.bytestr(ex.opt)
                 )
             try:
                 args.remove(flag)
             except Exception:
                 msg = _(b"unknown option '%s' packed with other options")
                 hint = _(b"please try passing the option as its own flag: -%s")
                 raise error.Abort(
                     msg % pycompat.bytestr(ex.opt),
                     hint=hint % pycompat.bytestr(ex.opt),
                 )
 
             ui.warn(_(b"ignoring unknown option %s\n") % flag)
 
-    args = list([convert(x) for x in args])
+    args = [convert(x) for x in args]
     opts = dict(
         [
             (k, convert(v)) if isinstance(v, bytes) else (k, v)
             for k, v in opts.items()
         ]
     )
 
     return args, opts
 
 
 class Command:
     def __init__(self, name):
         self.name = name
         self.args = []
         self.opts = {}
 
     def __bytes__(self):
         cmd = b"hg " + self.name
         if self.opts:
             for k, values in sorted(self.opts.items()):
                 for v in values:
                     if v:
                         if isinstance(v, int):
                             fmt = b' %s %d'
                         else:
                             fmt = b' %s %s'
 
                         cmd += fmt % (k, v)
                     else:
                         cmd += b" %s" % (k,)
         if self.args:
             cmd += b" "
             cmd += b" ".join(self.args)
         return cmd
 
     __str__ = encoding.strmethod(__bytes__)
 
     def append(self, value):
         self.args.append(value)
 
     def extend(self, values):
         self.args.extend(values)
 
     def __setitem__(self, key, value):
         values = self.opts.setdefault(key, [])
         values.append(value)
 
     def __and__(self, other):
         return AndCommand(self, other)
 
 
 class AndCommand:
     def __init__(self, left, right):
         self.left = left
         self.right = right
 
     def __str__(self):
         return b"%s && %s" % (self.left, self.right)
 
     def __and__(self, other):
         return AndCommand(self, other)
 
 
 def add(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'A', b'all', None, b''),
         (b'p', b'patch', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     if opts.get(b'patch'):
         ui.status(
             _(
                 b"note: Mercurial will commit when complete, "
                 b"as there is no staging area in Mercurial\n\n"
             )
         )
         cmd = Command(b'commit --interactive')
     else:
         cmd = Command(b"add")
 
         if not opts.get(b'all'):
             cmd.extend(args)
         else:
             ui.status(
                 _(
                     b"note: use hg addremove to remove files that have "
                     b"been deleted\n\n"
                 )
             )
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def am(ui, repo, *args, **kwargs):
     cmdoptions = []
     parseoptions(ui, cmdoptions, args)
     cmd = Command(b'import')
     ui.status(bytes(cmd), b"\n")
 
 
 def apply(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'p', b'p', int, b''),
         (b'', b'directory', b'', b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'import --no-commit')
     if opts.get(b'p'):
         cmd[b'-p'] = opts.get(b'p')
     if opts.get(b'directory'):
         cmd[b'--prefix'] = opts.get(b'directory')
     cmd.extend(args)
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def bisect(ui, repo, *args, **kwargs):
     ui.status(_(b"see 'hg help bisect' for how to use bisect\n\n"))
 
 
 def blame(ui, repo, *args, **kwargs):
     cmdoptions = []
     args, opts = parseoptions(ui, cmdoptions, args)
     cmd = Command(b'annotate -udl')
     cmd.extend([convert(v) for v in args])
     ui.status((bytes(cmd)), b"\n")
 
 
 def branch(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'', b'set-upstream', None, b''),
         (b'', b'set-upstream-to', b'', b''),
         (b'd', b'delete', None, b''),
         (b'D', b'delete', None, b''),
         (b'm', b'move', None, b''),
         (b'M', b'move', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b"bookmark")
 
     if opts.get(b'set_upstream') or opts.get(b'set_upstream_to'):
         ui.status(_(b"Mercurial has no concept of upstream branches\n"))
         return
     elif opts.get(b'delete'):
         cmd = Command(b"strip")
         for branch in args:
             cmd[b'-B'] = branch
         else:
             cmd[b'-B'] = None
     elif opts.get(b'move'):
         if len(args) > 0:
             if len(args) > 1:
                 old = args.pop(0)
             else:
                 # shell command to output the active bookmark for the active
                 # revision
                 old = b'`hg log -T"{activebookmark}" -r .`'
         else:
             raise error.Abort(_(b'missing newbranch argument'))
         new = args[0]
         cmd[b'-m'] = old
         cmd.append(new)
     else:
         if len(args) > 1:
             cmd[b'-r'] = args[1]
             cmd.append(args[0])
         elif len(args) == 1:
             cmd.append(args[0])
     ui.status((bytes(cmd)), b"\n")
 
 
 def ispath(repo, string):
     """
     The first argument to git checkout can either be a revision or a path. Let's
     generally assume it's a revision, unless it's obviously a path. There are
     too many ways to spell revisions in git for us to reasonably catch all of
     them, so let's be conservative.
     """
     if scmutil.isrevsymbol(repo, string):
         # if it's definitely a revision let's not even check if a file of the
         # same name exists.
         return False
 
     cwd = repo.getcwd()
     if cwd == b'':
         repopath = string
     else:
         repopath = cwd + b'/' + string
 
     exists = repo.wvfs.exists(repopath)
     if exists:
         return True
 
     manifest = repo[b'.'].manifest()
 
     didexist = (repopath in manifest) or manifest.hasdir(repopath)
 
     return didexist
 
 
 def checkout(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'b', b'branch', b'', b''),
         (b'B', b'branch', b'', b''),
         (b'f', b'force', None, b''),
         (b'p', b'patch', None, b''),
     ]
     paths = []
     if b'--' in args:
         sepindex = args.index(b'--')
         paths.extend(args[sepindex + 1 :])
         args = args[:sepindex]
 
     args, opts = parseoptions(ui, cmdoptions, args)
 
     rev = None
     if args and ispath(repo, args[0]):
         paths = args + paths
     elif args:
         rev = args[0]
         paths = args[1:] + paths
 
     cmd = Command(b'update')
 
     if opts.get(b'force'):
         if paths or rev:
             cmd[b'-C'] = None
 
     if opts.get(b'patch'):
         cmd = Command(b'revert')
         cmd[b'-i'] = None
 
     if opts.get(b'branch'):
         if len(args) == 0:
             cmd = Command(b'bookmark')
             cmd.append(opts.get(b'branch'))
         else:
             cmd.append(args[0])
             bookcmd = Command(b'bookmark')
             bookcmd.append(opts.get(b'branch'))
             cmd = cmd & bookcmd
     # if there is any path argument supplied, use revert instead of update
     elif len(paths) > 0:
         ui.status(_(b"note: use --no-backup to avoid creating .orig files\n\n"))
         cmd = Command(b'revert')
         if opts.get(b'patch'):
             cmd[b'-i'] = None
         if rev:
             cmd[b'-r'] = rev
         cmd.extend(paths)
     elif rev:
         if opts.get(b'patch'):
             cmd[b'-r'] = rev
         else:
             cmd.append(rev)
     elif opts.get(b'force'):
         cmd = Command(b'revert')
         cmd[b'--all'] = None
     else:
         raise error.Abort(_(b"a commit must be specified"))
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def cherrypick(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'', b'continue', None, b''),
         (b'', b'abort', None, b''),
         (b'e', b'edit', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'graft')
 
     if opts.get(b'edit'):
         cmd[b'--edit'] = None
     if opts.get(b'continue'):
         cmd[b'--continue'] = None
     elif opts.get(b'abort'):
         ui.status(_(b"note: hg graft does not have --abort\n\n"))
         return
     else:
         cmd.extend(args)
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def clean(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'd', b'd', None, b''),
         (b'f', b'force', None, b''),
         (b'x', b'x', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'purge')
     if opts.get(b'x'):
         cmd[b'--all'] = None
     cmd.extend(args)
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def clone(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'', b'bare', None, b''),
         (b'n', b'no-checkout', None, b''),
         (b'b', b'branch', b'', b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     if len(args) == 0:
         raise error.Abort(_(b"a repository to clone must be specified"))
 
     cmd = Command(b'clone')
     cmd.append(args[0])
     if len(args) > 1:
         cmd.append(args[1])
 
     if opts.get(b'bare'):
         cmd[b'-U'] = None
         ui.status(
             _(
                 b"note: Mercurial does not have bare clones. "
                 b"-U will clone the repo without checking out a commit\n\n"
             )
         )
     elif opts.get(b'no_checkout'):
         cmd[b'-U'] = None
 
     if opts.get(b'branch'):
         cocmd = Command(b"update")
         cocmd.append(opts.get(b'branch'))
         cmd = cmd & cocmd
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def commit(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'a', b'all', None, b''),
         (b'm', b'message', b'', b''),
         (b'p', b'patch', None, b''),
         (b'C', b'reuse-message', b'', b''),
         (b'F', b'file', b'', b''),
         (b'', b'author', b'', b''),
         (b'', b'date', b'', b''),
         (b'', b'amend', None, b''),
         (b'', b'no-edit', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'commit')
     if opts.get(b'patch'):
         cmd = Command(b'commit --interactive')
 
     if opts.get(b'amend'):
         if opts.get(b'no_edit'):
             cmd = Command(b'amend')
         else:
             cmd[b'--amend'] = None
 
     if opts.get(b'reuse_message'):
         cmd[b'-M'] = opts.get(b'reuse_message')
 
     if opts.get(b'message'):
         cmd[b'-m'] = b"'%s'" % (opts.get(b'message'),)
 
     if opts.get(b'all'):
         ui.status(
             _(
                 b"note: Mercurial doesn't have a staging area, "
                 b"so there is no --all. -A will add and remove files "
                 b"for you though.\n\n"
             )
         )
 
     if opts.get(b'file'):
         cmd[b'-l'] = opts.get(b'file')
 
     if opts.get(b'author'):
         cmd[b'-u'] = opts.get(b'author')
 
     if opts.get(b'date'):
         cmd[b'-d'] = opts.get(b'date')
 
     cmd.extend(args)
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def deprecated(ui, repo, *args, **kwargs):
     ui.warn(
         _(
             b'this command has been deprecated in the git project, '
             b'thus isn\'t supported by this tool\n\n'
         )
     )
 
 
 def diff(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'a', b'all', None, b''),
         (b'', b'cached', None, b''),
         (b'R', b'reverse', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'diff')
 
     if opts.get(b'cached'):
         ui.status(
             _(
                 b'note: Mercurial has no concept of a staging area, '
                 b'so --cached does nothing\n\n'
             )
         )
 
     if opts.get(b'reverse'):
         cmd[b'--reverse'] = None
 
     for a in list(args):
         args.remove(a)
         try:
             repo.revs(a)
             cmd[b'-r'] = a
         except Exception:
             cmd.append(a)
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def difftool(ui, repo, *args, **kwargs):
     ui.status(
         _(
             b'Mercurial does not enable external difftool by default. You '
             b'need to enable the extdiff extension in your .hgrc file by adding\n'
             b'extdiff =\n'
             b'to the [extensions] section and then running\n\n'
             b'hg extdiff -p <program>\n\n'
             b'See \'hg help extdiff\' and \'hg help -e extdiff\' for more '
             b'information.\n'
         )
     )
 
 
 def fetch(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'', b'all', None, b''),
         (b'f', b'force', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'pull')
 
     if len(args) > 0:
         cmd.append(args[0])
         if len(args) > 1:
             ui.status(
                 _(
                     b"note: Mercurial doesn't have refspecs. "
                     b"-r can be used to specify which commits you want to "
                     b"pull. -B can be used to specify which bookmark you "
                     b"want to pull.\n\n"
                 )
             )
             for v in args[1:]:
                 if v in repo._bookmarks:
                     cmd[b'-B'] = v
                 else:
                     cmd[b'-r'] = v
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def grep(ui, repo, *args, **kwargs):
     cmdoptions = []
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'grep')
 
     # For basic usage, git grep and hg grep are the same. They both have the
     # pattern first, followed by paths.
     cmd.extend(args)
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def init(ui, repo, *args, **kwargs):
     cmdoptions = []
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'init')
 
     if len(args) > 0:
         cmd.append(args[0])
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def log(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'', b'follow', None, b''),
         (b'', b'decorate', None, b''),
         (b'n', b'number', b'', b''),
         (b'1', b'1', None, b''),
         (b'', b'pretty', b'', b''),
         (b'', b'format', b'', b''),
         (b'', b'oneline', None, b''),
         (b'', b'stat', None, b''),
         (b'', b'graph', None, b''),
         (b'p', b'patch', None, b''),
         (b'G', b'grep-diff', b'', b''),
         (b'S', b'pickaxe-regex', b'', b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
     grep_pat = opts.get(b'grep_diff') or opts.get(b'pickaxe_regex')
     if grep_pat:
         cmd = Command(b'grep')
         cmd[b'--diff'] = grep_pat
         ui.status(b'%s\n' % bytes(cmd))
         return
 
     ui.status(
         _(
             b'note: -v prints the entire commit message like Git does. To '
             b'print just the first line, drop the -v.\n\n'
         )
     )
     ui.status(
         _(
             b"note: see hg help revset for information on how to filter "
             b"log output\n\n"
         )
     )
 
     cmd = Command(b'log')
     cmd[b'-v'] = None
 
     if opts.get(b'number'):
         cmd[b'-l'] = opts.get(b'number')
     if opts.get(b'1'):
         cmd[b'-l'] = b'1'
     if opts.get(b'stat'):
         cmd[b'--stat'] = None
     if opts.get(b'graph'):
         cmd[b'-G'] = None
     if opts.get(b'patch'):
         cmd[b'-p'] = None
 
     if opts.get(b'pretty') or opts.get(b'format') or opts.get(b'oneline'):
         format = opts.get(b'format', b'')
         if b'format:' in format:
             ui.status(
                 _(
                     b"note: --format format:??? equates to Mercurial's "
                     b"--template. See hg help templates for more info.\n\n"
                 )
             )
             cmd[b'--template'] = b'???'
         else:
             ui.status(
                 _(
                     b"note: --pretty/format/oneline equate to Mercurial's "
                     b"--style or --template. See hg help templates for "
                     b"more info.\n\n"
                 )
             )
             cmd[b'--style'] = b'???'
 
     if len(args) > 0:
         if b'..' in args[0]:
             since, until = args[0].split(b'..')
             cmd[b'-r'] = b"'%s::%s'" % (since, until)
             del args[0]
         cmd.extend(args)
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def lsfiles(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'c', b'cached', None, b''),
         (b'd', b'deleted', None, b''),
         (b'm', b'modified', None, b''),
         (b'o', b'others', None, b''),
         (b'i', b'ignored', None, b''),
         (b's', b'stage', None, b''),
         (b'z', b'_zero', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     if (
         opts.get(b'modified')
         or opts.get(b'deleted')
         or opts.get(b'others')
         or opts.get(b'ignored')
     ):
         cmd = Command(b'status')
         if opts.get(b'deleted'):
             cmd[b'-d'] = None
         if opts.get(b'modified'):
             cmd[b'-m'] = None
         if opts.get(b'others'):
             cmd[b'-o'] = None
         if opts.get(b'ignored'):
             cmd[b'-i'] = None
     else:
         cmd = Command(b'files')
     if opts.get(b'stage'):
         ui.status(
             _(
                 b"note: Mercurial doesn't have a staging area, ignoring "
                 b"--stage\n"
             )
         )
     if opts.get(b'_zero'):
         cmd[b'-0'] = None
     cmd.append(b'.')
     for include in args:
         cmd[b'-I'] = procutil.shellquote(include)
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def merge(ui, repo, *args, **kwargs):
     cmdoptions = []
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'merge')
 
     if len(args) > 0:
         cmd.append(args[len(args) - 1])
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def mergebase(ui, repo, *args, **kwargs):
     cmdoptions = []
     args, opts = parseoptions(ui, cmdoptions, args)
 
     if len(args) != 2:
         args = [b'A', b'B']
 
     cmd = Command(
         b"log -T '{node}\\n' -r 'ancestor(%s,%s)'" % (args[0], args[1])
     )
 
     ui.status(
         _(b'note: ancestors() is part of the revset language\n'),
         _(b"(learn more about revsets with 'hg help revsets')\n\n"),
     )
     ui.status((bytes(cmd)), b"\n")
 
 
 def mergetool(ui, repo, *args, **kwargs):
     cmdoptions = []
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b"resolve")
 
     if len(args) == 0:
         cmd[b'--all'] = None
     cmd.extend(args)
     ui.status((bytes(cmd)), b"\n")
 
 
 def mv(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'f', b'force', None, b''),
         (b'n', b'dry-run', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'mv')
     cmd.extend(args)
 
     if opts.get(b'force'):
         cmd[b'-f'] = None
     if opts.get(b'dry_run'):
         cmd[b'-n'] = None
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def pull(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'', b'all', None, b''),
         (b'f', b'force', None, b''),
         (b'r', b'rebase', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'pull')
     cmd[b'--rebase'] = None
 
     if len(args) > 0:
         cmd.append(args[0])
         if len(args) > 1:
             ui.status(
                 _(
                     b"note: Mercurial doesn't have refspecs. "
                     b"-r can be used to specify which commits you want to "
                     b"pull. -B can be used to specify which bookmark you "
                     b"want to pull.\n\n"
                 )
             )
             for v in args[1:]:
                 if v in repo._bookmarks:
                     cmd[b'-B'] = v
                 else:
                     cmd[b'-r'] = v
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def push(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'', b'all', None, b''),
         (b'f', b'force', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'push')
 
     if len(args) > 0:
         cmd.append(args[0])
         if len(args) > 1:
             ui.status(
                 _(
                     b"note: Mercurial doesn't have refspecs. "
                     b"-r can be used to specify which commits you want "
                     b"to push. -B can be used to specify which bookmark "
                     b"you want to push.\n\n"
                 )
             )
             for v in args[1:]:
                 if v in repo._bookmarks:
                     cmd[b'-B'] = v
                 else:
                     cmd[b'-r'] = v
 
     if opts.get(b'force'):
         cmd[b'-f'] = None
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def rebase(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'', b'all', None, b''),
         (b'i', b'interactive', None, b''),
         (b'', b'onto', b'', b''),
         (b'', b'abort', None, b''),
         (b'', b'continue', None, b''),
         (b'', b'skip', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     if opts.get(b'interactive'):
         ui.status(
             _(
                 b"note: hg histedit does not perform a rebase. "
                 b"It just edits history.\n\n"
             )
         )
         cmd = Command(b'histedit')
         if len(args) > 0:
             ui.status(
                 _(
                     b"also note: 'hg histedit' will automatically detect"
                     b" your stack, so no second argument is necessary\n\n"
                 )
             )
         ui.status((bytes(cmd)), b"\n")
         return
 
     if opts.get(b'skip'):
         cmd = Command(b'revert --all -r .')
         ui.status((bytes(cmd)), b"\n")
 
     cmd = Command(b'rebase')
 
     if opts.get(b'continue') or opts.get(b'skip'):
         cmd[b'--continue'] = None
     if opts.get(b'abort'):
         cmd[b'--abort'] = None
 
     if opts.get(b'onto'):
         ui.status(
             _(
                 b"note: if you're trying to lift a commit off one branch, "
                 b"try hg rebase -d <destination commit> -s <commit to be "
                 b"lifted>\n\n"
             )
         )
         cmd[b'-d'] = convert(opts.get(b'onto'))
         if len(args) < 2:
             raise error.Abort(_(b"expected format: git rebase --onto X Y Z"))
         cmd[b'-s'] = b"'::%s - ::%s'" % (convert(args[1]), convert(args[0]))
     else:
         if len(args) == 1:
             cmd[b'-d'] = convert(args[0])
         elif len(args) == 2:
             cmd[b'-d'] = convert(args[0])
             cmd[b'-b'] = convert(args[1])
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def reflog(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'', b'all', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'journal')
     if opts.get(b'all'):
         cmd[b'--all'] = None
     if len(args) > 0:
         cmd.append(args[0])
 
     ui.status(bytes(cmd), b"\n\n")
     ui.status(
         _(
             b"note: in hg commits can be deleted from repo but we always"
             b" have backups\n"
         )
     )
 
 
 def reset(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'', b'soft', None, b''),
         (b'', b'hard', None, b''),
         (b'', b'mixed', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     commit = convert(args[0] if len(args) > 0 else b'.')
     hard = opts.get(b'hard')
 
     if opts.get(b'mixed'):
         ui.status(
             _(
                 b'note: --mixed has no meaning since Mercurial has no '
                 b'staging area\n\n'
             )
         )
     if opts.get(b'soft'):
         ui.status(
             _(
                 b'note: --soft has no meaning since Mercurial has no '
                 b'staging area\n\n'
             )
         )
 
     cmd = Command(b'update')
     if hard:
         cmd.append(b'--clean')
 
     cmd.append(commit)
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def revert(ui, repo, *args, **kwargs):
     cmdoptions = []
     args, opts = parseoptions(ui, cmdoptions, args)
 
     if len(args) > 1:
         ui.status(
             _(
                 b"note: hg backout doesn't support multiple commits at "
                 b"once\n\n"
             )
         )
 
     cmd = Command(b'backout')
     if args:
         cmd.append(args[0])
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def revparse(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'', b'show-cdup', None, b''),
         (b'', b'show-toplevel', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     if opts.get(b'show_cdup') or opts.get(b'show_toplevel'):
         cmd = Command(b'root')
         if opts.get(b'show_cdup'):
             ui.status(_(b"note: hg root prints the root of the repository\n\n"))
         ui.status((bytes(cmd)), b"\n")
     else:
         ui.status(_(b"note: see hg help revset for how to refer to commits\n"))
 
 
 def rm(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'f', b'force', None, b''),
         (b'n', b'dry-run', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'rm')
     cmd.extend(args)
 
     if opts.get(b'force'):
         cmd[b'-f'] = None
     if opts.get(b'dry_run'):
         cmd[b'-n'] = None
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def show(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'', b'name-status', None, b''),
         (b'', b'pretty', b'', b''),
         (b'U', b'unified', int, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     if opts.get(b'name_status'):
         if opts.get(b'pretty') == b'format:':
             cmd = Command(b'status')
             cmd[b'--change'] = b'.'
         else:
             cmd = Command(b'log')
             cmd.append(b'--style status')
             cmd.append(b'-r .')
     elif len(args) > 0:
         if ispath(repo, args[0]):
             cmd = Command(b'cat')
         else:
             cmd = Command(b'export')
         cmd.extend(args)
         if opts.get(b'unified'):
             cmd.append(b'--config diff.unified=%d' % (opts[b'unified'],))
     elif opts.get(b'unified'):
         cmd = Command(b'export')
         cmd.append(b'--config diff.unified=%d' % (opts[b'unified'],))
     else:
         cmd = Command(b'export')
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def stash(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'p', b'patch', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'shelve')
     action = args[0] if len(args) > 0 else None
 
     if action == b'list':
         cmd[b'-l'] = None
         if opts.get(b'patch'):
             cmd[b'-p'] = None
     elif action == b'show':
         if opts.get(b'patch'):
             cmd[b'-p'] = None
         else:
             cmd[b'--stat'] = None
         if len(args) > 1:
             cmd.append(args[1])
     elif action == b'clear':
         cmd[b'--cleanup'] = None
     elif action == b'drop':
         cmd[b'-d'] = None
         if len(args) > 1:
             cmd.append(args[1])
         else:
             cmd.append(b'<shelve name>')
     elif action == b'pop' or action == b'apply':
         cmd = Command(b'unshelve')
         if len(args) > 1:
             cmd.append(args[1])
         if action == b'apply':
             cmd[b'--keep'] = None
     elif action == b'branch' or action == b'create':
         ui.status(
             _(
                 b"note: Mercurial doesn't have equivalents to the "
                 b"git stash branch or create actions\n\n"
             )
         )
         return
     else:
         if len(args) > 0:
             if args[0] != b'save':
                 cmd[b'--name'] = args[0]
             elif len(args) > 1:
                 cmd[b'--name'] = args[1]
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def status(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'', b'ignored', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'status')
     cmd.extend(args)
 
     if opts.get(b'ignored'):
         cmd[b'-i'] = None
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def svn(ui, repo, *args, **kwargs):
     if not args:
         raise error.Abort(_(b'missing svn command'))
     svncmd = args[0]
     if svncmd not in gitsvncommands:
         raise error.Abort(_(b'unknown git svn command "%s"') % svncmd)
 
     args = args[1:]
     return gitsvncommands[svncmd](ui, repo, *args, **kwargs)
 
 
 def svndcommit(ui, repo, *args, **kwargs):
     cmdoptions = []
     parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'push')
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def svnfetch(ui, repo, *args, **kwargs):
     cmdoptions = []
     parseoptions(ui, cmdoptions, args)
 
     cmd = Command(b'pull')
     cmd.append(b'default-push')
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def svnfindrev(ui, repo, *args, **kwargs):
     cmdoptions = []
     args, opts = parseoptions(ui, cmdoptions, args)
 
     if not args:
         raise error.Abort(_(b'missing find-rev argument'))
 
     cmd = Command(b'log')
     cmd[b'-r'] = args[0]
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def svnrebase(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'l', b'local', None, b''),
     ]
     parseoptions(ui, cmdoptions, args)
 
     pullcmd = Command(b'pull')
     pullcmd.append(b'default-push')
     rebasecmd = Command(b'rebase')
     rebasecmd.append(b'tip')
 
     cmd = pullcmd & rebasecmd
 
     ui.status((bytes(cmd)), b"\n")
 
 
 def tag(ui, repo, *args, **kwargs):
     cmdoptions = [
         (b'f', b'force', None, b''),
         (b'l', b'list', None, b''),
         (b'd', b'delete', None, b''),
     ]
     args, opts = parseoptions(ui, cmdoptions, args)
 
     if opts.get(b'list'):
         cmd = Command(b'tags')
     else:
         cmd = Command(b'tag')
 
         if not args:
             raise error.Abort(_(b'missing tag argument'))
 
         cmd.append(args[0])
         if len(args) > 1:
             cmd[b'-r'] = args[1]
 
         if opts.get(b'delete'):
             cmd[b'--remove'] = None
 
         if opts.get(b'force'):
             cmd[b'-f'] = None
 
     ui.status((bytes(cmd)), b"\n")
 
 
 gitcommands = {
     b'add': add,
     b'am': am,
     b'apply': apply,
     b'bisect': bisect,
     b'blame': blame,
     b'branch': branch,
     b'checkout': checkout,
     b'cherry-pick': cherrypick,
     b'clean': clean,
     b'clone': clone,
     b'commit': commit,
     b'diff': diff,
     b'difftool': difftool,
     b'fetch': fetch,
     b'grep': grep,
     b'init': init,
     b'log': log,
     b'ls-files': lsfiles,
     b'merge': merge,
     b'merge-base': mergebase,
     b'mergetool': mergetool,
     b'mv': mv,
     b'pull': pull,
     b'push': push,
     b'rebase': rebase,
     b'reflog': reflog,
     b'reset': reset,
     b'revert': revert,
     b'rev-parse': revparse,
     b'rm': rm,
     b'show': show,
     b'stash': stash,
     b'status': status,
     b'svn': svn,
     b'tag': tag,
     b'whatchanged': deprecated,
 }
 
 gitsvncommands = {
     b'dcommit': svndcommit,
     b'fetch': svnfetch,
     b'find-rev': svnfindrev,
     b'rebase': svnrebase,
 }

hgext/remotefilelog/__init__.py

@@ -1,1259 +1,1259 b''
 # __init__.py - remotefilelog extension
 #
 # Copyright 2013 Facebook, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 """remotefilelog causes Mercurial to lazilly fetch file contents (EXPERIMENTAL)
 
 This extension is HIGHLY EXPERIMENTAL. There are NO BACKWARDS COMPATIBILITY
 GUARANTEES. This means that repositories created with this extension may
 only be usable with the exact version of this extension/Mercurial that was
 used. The extension attempts to enforce this in order to prevent repository
 corruption.
 
 remotefilelog works by fetching file contents lazily and storing them
 in a cache on the client rather than in revlogs. This allows enormous
 histories to be transferred only partially, making them easier to
 operate on.
 
 Configs:
 
     ``packs.maxchainlen`` specifies the maximum delta chain length in pack files
 
     ``packs.maxpacksize`` specifies the maximum pack file size
 
     ``packs.maxpackfilecount`` specifies the maximum number of packs in the
       shared cache (trees only for now)
 
     ``remotefilelog.backgroundprefetch`` runs prefetch in background when True
 
     ``remotefilelog.bgprefetchrevs`` specifies revisions to fetch on commit and
       update, and on other commands that use them. Different from pullprefetch.
 
     ``remotefilelog.gcrepack`` does garbage collection during repack when True
 
     ``remotefilelog.nodettl`` specifies maximum TTL of a node in seconds before
       it is garbage collected
 
     ``remotefilelog.repackonhggc`` runs repack on hg gc when True
 
     ``remotefilelog.prefetchdays`` specifies the maximum age of a commit in
       days after which it is no longer prefetched.
 
     ``remotefilelog.prefetchdelay`` specifies delay between background
       prefetches in seconds after operations that change the working copy parent
 
     ``remotefilelog.data.gencountlimit`` constraints the minimum number of data
       pack files required to be considered part of a generation. In particular,
       minimum number of packs files > gencountlimit.
 
     ``remotefilelog.data.generations`` list for specifying the lower bound of
       each generation of the data pack files. For example, list ['100MB','1MB']
       or ['1MB', '100MB'] will lead to three generations: [0, 1MB), [
       1MB, 100MB) and [100MB, infinity).
 
     ``remotefilelog.data.maxrepackpacks`` the maximum number of pack files to
       include in an incremental data repack.
 
     ``remotefilelog.data.repackmaxpacksize`` the maximum size of a pack file for
       it to be considered for an incremental data repack.
 
     ``remotefilelog.data.repacksizelimit`` the maximum total size of pack files
       to include in an incremental data repack.
 
     ``remotefilelog.history.gencountlimit`` constraints the minimum number of
       history pack files required to be considered part of a generation. In
       particular, minimum number of packs files > gencountlimit.
 
     ``remotefilelog.history.generations`` list for specifying the lower bound of
       each generation of the history pack files. For example, list [
       '100MB', '1MB'] or ['1MB', '100MB'] will lead to three generations: [
       0, 1MB), [1MB, 100MB) and [100MB, infinity).
 
     ``remotefilelog.history.maxrepackpacks`` the maximum number of pack files to
       include in an incremental history repack.
 
     ``remotefilelog.history.repackmaxpacksize`` the maximum size of a pack file
       for it to be considered for an incremental history repack.
 
     ``remotefilelog.history.repacksizelimit`` the maximum total size of pack
       files to include in an incremental history repack.
 
     ``remotefilelog.backgroundrepack`` automatically consolidate packs in the
       background
 
     ``remotefilelog.cachepath`` path to cache
 
     ``remotefilelog.cachegroup`` if set, make cache directory sgid to this
       group
 
     ``remotefilelog.cacheprocess`` binary to invoke for fetching file data
 
     ``remotefilelog.debug`` turn on remotefilelog-specific debug output
 
     ``remotefilelog.excludepattern`` pattern of files to exclude from pulls
 
     ``remotefilelog.includepattern`` pattern of files to include in pulls
 
     ``remotefilelog.fetchwarning``: message to print when too many
       single-file fetches occur
 
     ``remotefilelog.getfilesstep`` number of files to request in a single RPC
 
     ``remotefilelog.getfilestype`` if set to 'threaded' use threads to fetch
       files, otherwise use optimistic fetching
 
     ``remotefilelog.pullprefetch`` revset for selecting files that should be
       eagerly downloaded rather than lazily
 
     ``remotefilelog.reponame`` name of the repo. If set, used to partition
       data from other repos in a shared store.
 
     ``remotefilelog.server`` if true, enable server-side functionality
 
     ``remotefilelog.servercachepath`` path for caching blobs on the server
 
     ``remotefilelog.serverexpiration`` number of days to keep cached server
       blobs
 
     ``remotefilelog.validatecache`` if set, check cache entries for corruption
       before returning blobs
 
     ``remotefilelog.validatecachelog`` if set, check cache entries for
       corruption before returning metadata
 
 """
 
 import os
 import time
 import traceback
 
 from mercurial.node import (
     hex,
     wdirrev,
 )
 from mercurial.i18n import _
 from mercurial.pycompat import open
 from mercurial import (
     changegroup,
     changelog,
     commands,
     configitems,
     context,
     copies,
     debugcommands as hgdebugcommands,
     dispatch,
     error,
     exchange,
     extensions,
     hg,
     localrepo,
     match as matchmod,
     merge,
     mergestate as mergestatemod,
     patch,
     pycompat,
     registrar,
     repair,
     repoview,
     revset,
     scmutil,
     smartset,
     streamclone,
     util,
 )
 from . import (
     constants,
     debugcommands,
     fileserverclient,
     remotefilectx,
     remotefilelog,
     remotefilelogserver,
     repack as repackmod,
     shallowbundle,
     shallowrepo,
     shallowstore,
     shallowutil,
     shallowverifier,
 )
 
 # ensures debug commands are registered
 hgdebugcommands.command
 
 cmdtable = {}
 command = registrar.command(cmdtable)
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 
 configitem(b'remotefilelog', b'debug', default=False)
 
 configitem(b'remotefilelog', b'reponame', default=b'')
 configitem(b'remotefilelog', b'cachepath', default=None)
 configitem(b'remotefilelog', b'cachegroup', default=None)
 configitem(b'remotefilelog', b'cacheprocess', default=None)
 configitem(b'remotefilelog', b'cacheprocess.includepath', default=None)
 configitem(b"remotefilelog", b"cachelimit", default=b"1000 GB")
 
 configitem(
     b'remotefilelog',
     b'fallbackpath',
     default=configitems.dynamicdefault,
     alias=[(b'remotefilelog', b'fallbackrepo')],
 )
 
 configitem(b'remotefilelog', b'validatecachelog', default=None)
 configitem(b'remotefilelog', b'validatecache', default=b'on')
 configitem(b'remotefilelog', b'server', default=None)
 configitem(b'remotefilelog', b'servercachepath', default=None)
 configitem(b"remotefilelog", b"serverexpiration", default=30)
 configitem(b'remotefilelog', b'backgroundrepack', default=False)
 configitem(b'remotefilelog', b'bgprefetchrevs', default=None)
 configitem(b'remotefilelog', b'pullprefetch', default=None)
 configitem(b'remotefilelog', b'backgroundprefetch', default=False)
 configitem(b'remotefilelog', b'prefetchdelay', default=120)
 configitem(b'remotefilelog', b'prefetchdays', default=14)
 # Other values include 'local' or 'none'. Any unrecognized value is 'all'.
 configitem(b'remotefilelog', b'strip.includefiles', default='all')
 
 configitem(b'remotefilelog', b'getfilesstep', default=10000)
 configitem(b'remotefilelog', b'getfilestype', default=b'optimistic')
 configitem(b'remotefilelog', b'batchsize', configitems.dynamicdefault)
 configitem(b'remotefilelog', b'fetchwarning', default=b'')
 
 configitem(b'remotefilelog', b'includepattern', default=None)
 configitem(b'remotefilelog', b'excludepattern', default=None)
 
 configitem(b'remotefilelog', b'gcrepack', default=False)
 configitem(b'remotefilelog', b'repackonhggc', default=False)
 configitem(b'repack', b'chainorphansbysize', default=True, experimental=True)
 
 configitem(b'packs', b'maxpacksize', default=0)
 configitem(b'packs', b'maxchainlen', default=1000)
 
 configitem(b'devel', b'remotefilelog.bg-wait', default=False)
 
 #  default TTL limit is 30 days
 _defaultlimit = 60 * 60 * 24 * 30
 configitem(b'remotefilelog', b'nodettl', default=_defaultlimit)
 
 configitem(b'remotefilelog', b'data.gencountlimit', default=2),
 configitem(
     b'remotefilelog', b'data.generations', default=[b'1GB', b'100MB', b'1MB']
 )
 configitem(b'remotefilelog', b'data.maxrepackpacks', default=50)
 configitem(b'remotefilelog', b'data.repackmaxpacksize', default=b'4GB')
 configitem(b'remotefilelog', b'data.repacksizelimit', default=b'100MB')
 
 configitem(b'remotefilelog', b'history.gencountlimit', default=2),
 configitem(b'remotefilelog', b'history.generations', default=[b'100MB'])
 configitem(b'remotefilelog', b'history.maxrepackpacks', default=50)
 configitem(b'remotefilelog', b'history.repackmaxpacksize', default=b'400MB')
 configitem(b'remotefilelog', b'history.repacksizelimit', default=b'100MB')
 
 # 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'
 
 repoclass = localrepo.localrepository
 repoclass._basesupported.add(constants.SHALLOWREPO_REQUIREMENT)
 
 isenabled = shallowutil.isenabled
 
 
 def uisetup(ui):
     """Wraps user facing Mercurial commands to swap them out with shallow
     versions.
     """
     hg.wirepeersetupfuncs.append(fileserverclient.peersetup)
 
     entry = extensions.wrapcommand(commands.table, b'clone', cloneshallow)
     entry[1].append(
         (
             b'',
             b'shallow',
             None,
             _(b"create a shallow clone which uses remote file history"),
         )
     )
 
     extensions.wrapcommand(
         commands.table, b'debugindex', debugcommands.debugindex
     )
     extensions.wrapcommand(
         commands.table, b'debugindexdot', debugcommands.debugindexdot
     )
     extensions.wrapcommand(commands.table, b'log', log)
     extensions.wrapcommand(commands.table, b'pull', pull)
 
     # Prevent 'hg manifest --all'
     def _manifest(orig, ui, repo, *args, **opts):
         if isenabled(repo) and opts.get('all'):
             raise error.Abort(_(b"--all is not supported in a shallow repo"))
 
         return orig(ui, repo, *args, **opts)
 
     extensions.wrapcommand(commands.table, b"manifest", _manifest)
 
     # Wrap remotefilelog with lfs code
     def _lfsloaded(loaded=False):
         lfsmod = None
         try:
             lfsmod = extensions.find(b'lfs')
         except KeyError:
             pass
         if lfsmod:
             lfsmod.wrapfilelog(remotefilelog.remotefilelog)
             fileserverclient._lfsmod = lfsmod
 
     extensions.afterloaded(b'lfs', _lfsloaded)
 
     # debugdata needs remotefilelog.len to work
     extensions.wrapcommand(commands.table, b'debugdata', debugdatashallow)
 
     changegroup.cgpacker = shallowbundle.shallowcg1packer
 
     extensions.wrapfunction(
         changegroup, '_addchangegroupfiles', shallowbundle.addchangegroupfiles
     )
     extensions.wrapfunction(
         changegroup, 'makechangegroup', shallowbundle.makechangegroup
     )
     extensions.wrapfunction(localrepo, 'makestore', storewrapper)
     extensions.wrapfunction(exchange, 'pull', exchangepull)
     extensions.wrapfunction(merge, 'applyupdates', applyupdates)
     extensions.wrapfunction(merge, '_checkunknownfiles', checkunknownfiles)
     extensions.wrapfunction(context.workingctx, '_checklookup', checklookup)
     extensions.wrapfunction(scmutil, '_findrenames', findrenames)
     extensions.wrapfunction(
         copies, '_computeforwardmissing', computeforwardmissing
     )
     extensions.wrapfunction(dispatch, 'runcommand', runcommand)
     extensions.wrapfunction(repair, '_collectbrokencsets', _collectbrokencsets)
     extensions.wrapfunction(context.changectx, 'filectx', filectx)
     extensions.wrapfunction(context.workingctx, 'filectx', workingfilectx)
     extensions.wrapfunction(patch, 'trydiff', trydiff)
     extensions.wrapfunction(hg, 'verify', _verify)
     scmutil.fileprefetchhooks.add(b'remotefilelog', _fileprefetchhook)
 
     # disappointing hacks below
     extensions.wrapfunction(scmutil, 'getrenamedfn', getrenamedfn)
     extensions.wrapfunction(revset, 'filelog', filelogrevset)
     revset.symbols[b'filelog'] = revset.filelog
 
 
 def cloneshallow(orig, ui, repo, *args, **opts):
     if opts.get('shallow'):
         repos = []
 
         def pull_shallow(orig, self, *args, **kwargs):
             if not isenabled(self):
                 repos.append(self.unfiltered())
                 # set up the client hooks so the post-clone update works
                 setupclient(self.ui, self.unfiltered())
 
                 # setupclient fixed the class on the repo itself
                 # but we also need to fix it on the repoview
                 if isinstance(self, repoview.repoview):
                     self.__class__.__bases__ = (
                         self.__class__.__bases__[0],
                         self.unfiltered().__class__,
                     )
                 self.requirements.add(constants.SHALLOWREPO_REQUIREMENT)
                 with self.lock():
                     # acquire store lock before writing requirements as some
                     # requirements might be written to .hg/store/requires
                     scmutil.writereporequirements(self)
 
                 # Since setupclient hadn't been called, exchange.pull was not
                 # wrapped. So we need to manually invoke our version of it.
                 return exchangepull(orig, self, *args, **kwargs)
             else:
                 return orig(self, *args, **kwargs)
 
         extensions.wrapfunction(exchange, 'pull', pull_shallow)
 
         # Wrap the stream logic to add requirements and to pass include/exclude
         # patterns around.
         def setup_streamout(repo, remote):
             # Replace remote.stream_out with a version that sends file
             # patterns.
             def stream_out_shallow(orig):
                 caps = remote.capabilities()
                 if constants.NETWORK_CAP_LEGACY_SSH_GETFILES in caps:
                     opts = {}
                     if repo.includepattern:
                         opts['includepattern'] = b'\0'.join(repo.includepattern)
                     if repo.excludepattern:
                         opts['excludepattern'] = b'\0'.join(repo.excludepattern)
                     return remote._callstream(b'stream_out_shallow', **opts)
                 else:
                     return orig()
 
             extensions.wrapfunction(remote, 'stream_out', stream_out_shallow)
 
         def stream_wrap(orig, op):
             setup_streamout(op.repo, op.remote)
             return orig(op)
 
         extensions.wrapfunction(
             streamclone, 'maybeperformlegacystreamclone', stream_wrap
         )
 
         def canperformstreamclone(orig, pullop, bundle2=False):
             # remotefilelog is currently incompatible with the
             # bundle2 flavor of streamclones, so force us to use
             # v1 instead.
             if b'v2' in pullop.remotebundle2caps.get(b'stream', []):
                 pullop.remotebundle2caps[b'stream'] = []
             if bundle2:
                 return False, None
             supported, requirements = orig(pullop, bundle2=bundle2)
             if requirements is not None:
                 requirements.add(constants.SHALLOWREPO_REQUIREMENT)
             return supported, requirements
 
         extensions.wrapfunction(
             streamclone, 'canperformstreamclone', canperformstreamclone
         )
 
     try:
         orig(ui, repo, *args, **opts)
     finally:
         if opts.get('shallow'):
             for r in repos:
                 if hasattr(r, 'fileservice'):
                     r.fileservice.close()
 
 
 def debugdatashallow(orig, *args, **kwds):
     oldlen = remotefilelog.remotefilelog.__len__
     try:
         remotefilelog.remotefilelog.__len__ = lambda x: 1
         return orig(*args, **kwds)
     finally:
         remotefilelog.remotefilelog.__len__ = oldlen
 
 
 def reposetup(ui, repo):
     if not repo.local():
         return
 
     # put here intentionally bc doesnt work in uisetup
     ui.setconfig(b'hooks', b'update.prefetch', wcpprefetch)
     ui.setconfig(b'hooks', b'commit.prefetch', wcpprefetch)
 
     isserverenabled = ui.configbool(b'remotefilelog', b'server')
     isshallowclient = isenabled(repo)
 
     if isserverenabled and isshallowclient:
         raise RuntimeError(b"Cannot be both a server and shallow client.")
 
     if isshallowclient:
         setupclient(ui, repo)
 
     if isserverenabled:
         remotefilelogserver.setupserver(ui, repo)
 
 
 def setupclient(ui, repo):
     if not isinstance(repo, localrepo.localrepository):
         return
 
     # Even clients get the server setup since they need to have the
     # wireprotocol endpoints registered.
     remotefilelogserver.onetimesetup(ui)
     onetimeclientsetup(ui)
 
     shallowrepo.wraprepo(repo)
     repo.store = shallowstore.wrapstore(repo.store)
 
 
 def storewrapper(orig, requirements, path, vfstype):
     s = orig(requirements, path, vfstype)
     if constants.SHALLOWREPO_REQUIREMENT in requirements:
         s = shallowstore.wrapstore(s)
 
     return s
 
 
 # prefetch files before update
 def applyupdates(
     orig, repo, mresult, wctx, mctx, overwrite, wantfiledata, **opts
 ):
     if isenabled(repo):
         manifest = mctx.manifest()
         files = []
         for f, args, msg in mresult.getactions([mergestatemod.ACTION_GET]):
             files.append((f, hex(manifest[f])))
         # batch fetch the needed files from the server
         repo.fileservice.prefetch(files)
     return orig(repo, mresult, wctx, mctx, overwrite, wantfiledata, **opts)
 
 
 # Prefetch merge checkunknownfiles
 def checkunknownfiles(orig, repo, wctx, mctx, force, mresult, *args, **kwargs):
     if isenabled(repo):
         files = []
         sparsematch = repo.maybesparsematch(mctx.rev())
         for f, (m, actionargs, msg) in mresult.filemap():
             if sparsematch and not sparsematch(f):
                 continue
             if m in (
                 mergestatemod.ACTION_CREATED,
                 mergestatemod.ACTION_DELETED_CHANGED,
                 mergestatemod.ACTION_CREATED_MERGE,
             ):
                 files.append((f, hex(mctx.filenode(f))))
             elif m == mergestatemod.ACTION_LOCAL_DIR_RENAME_GET:
                 f2 = actionargs[0]
                 files.append((f2, hex(mctx.filenode(f2))))
         # batch fetch the needed files from the server
         repo.fileservice.prefetch(files)
     return orig(repo, wctx, mctx, force, mresult, *args, **kwargs)
 
 
 # Prefetch files before status attempts to look at their size and contents
 def checklookup(orig, self, files, mtime_boundary):
     repo = self._repo
     if isenabled(repo):
         prefetchfiles = []
         for parent in self._parents:
             for f in files:
                 if f in parent:
                     prefetchfiles.append((f, hex(parent.filenode(f))))
         # batch fetch the needed files from the server
         repo.fileservice.prefetch(prefetchfiles)
     return orig(self, files, mtime_boundary)
 
 
 # Prefetch the logic that compares added and removed files for renames
 def findrenames(orig, repo, matcher, added, removed, *args, **kwargs):
     if isenabled(repo):
         files = []
         pmf = repo[b'.'].manifest()
         for f in removed:
             if f in pmf:
                 files.append((f, hex(pmf[f])))
         # batch fetch the needed files from the server
         repo.fileservice.prefetch(files)
     return orig(repo, matcher, added, removed, *args, **kwargs)
 
 
 # prefetch files before pathcopies check
 def computeforwardmissing(orig, a, b, match=None):
     missing = orig(a, b, match=match)
     repo = a._repo
     if isenabled(repo):
         mb = b.manifest()
 
         files = []
         sparsematch = repo.maybesparsematch(b.rev())
         if sparsematch:
             sparsemissing = set()
             for f in missing:
                 if sparsematch(f):
                     files.append((f, hex(mb[f])))
                     sparsemissing.add(f)
             missing = sparsemissing
 
         # batch fetch the needed files from the server
         repo.fileservice.prefetch(files)
     return missing
 
 
 # close cache miss server connection after the command has finished
 def runcommand(orig, lui, repo, *args, **kwargs):
     fileservice = None
     # repo can be None when running in chg:
     # - at startup, reposetup was called because serve is not norepo
     # - a norepo command like "help" is called
     if repo and isenabled(repo):
         fileservice = repo.fileservice
     try:
         return orig(lui, repo, *args, **kwargs)
     finally:
         if fileservice:
             fileservice.close()
 
 
 # prevent strip from stripping remotefilelogs
 def _collectbrokencsets(orig, repo, files, striprev):
     if isenabled(repo):
-        files = list([f for f in files if not repo.shallowmatch(f)])
+        files = [f for f in files if not repo.shallowmatch(f)]
     return orig(repo, files, striprev)
 
 
 # changectx wrappers
 def filectx(orig, self, path, fileid=None, filelog=None):
     if fileid is None:
         fileid = self.filenode(path)
     if isenabled(self._repo) and self._repo.shallowmatch(path):
         return remotefilectx.remotefilectx(
             self._repo, path, fileid=fileid, changectx=self, filelog=filelog
         )
     return orig(self, path, fileid=fileid, filelog=filelog)
 
 
 def workingfilectx(orig, self, path, filelog=None):
     if isenabled(self._repo) and self._repo.shallowmatch(path):
         return remotefilectx.remoteworkingfilectx(
             self._repo, path, workingctx=self, filelog=filelog
         )
     return orig(self, path, filelog=filelog)
 
 
 # prefetch required revisions before a diff
 def trydiff(
     orig,
     repo,
     revs,
     ctx1,
     ctx2,
     modified,
     added,
     removed,
     copy,
     getfilectx,
     *args,
     **kwargs
 ):
     if isenabled(repo):
         prefetch = []
         mf1 = ctx1.manifest()
         for fname in modified + added + removed:
             if fname in mf1:
                 fnode = getfilectx(fname, ctx1).filenode()
                 # fnode can be None if it's a edited working ctx file
                 if fnode:
                     prefetch.append((fname, hex(fnode)))
             if fname not in removed:
                 fnode = getfilectx(fname, ctx2).filenode()
                 if fnode:
                     prefetch.append((fname, hex(fnode)))
 
         repo.fileservice.prefetch(prefetch)
 
     return orig(
         repo,
         revs,
         ctx1,
         ctx2,
         modified,
         added,
         removed,
         copy,
         getfilectx,
         *args,
         **kwargs
     )
 
 
 # Prevent verify from processing files
 # a stub for mercurial.hg.verify()
 def _verify(orig, repo, level=None):
     lock = repo.lock()
     try:
         return shallowverifier.shallowverifier(repo).verify()
     finally:
         lock.release()
 
 
 clientonetime = False
 
 
 def onetimeclientsetup(ui):
     global clientonetime
     if clientonetime:
         return
     clientonetime = True
 
     # Don't commit filelogs until we know the commit hash, since the hash
     # is present in the filelog blob.
     # This violates Mercurial's filelog->manifest->changelog write order,
     # but is generally fine for client repos.
     pendingfilecommits = []
 
     def addrawrevision(
         orig,
         self,
         rawtext,
         transaction,
         link,
         p1,
         p2,
         node,
         flags,
         cachedelta=None,
         _metatuple=None,
     ):
         if isinstance(link, int):
             pendingfilecommits.append(
                 (
                     self,
                     rawtext,
                     transaction,
                     link,
                     p1,
                     p2,
                     node,
                     flags,
                     cachedelta,
                     _metatuple,
                 )
             )
             return node
         else:
             return orig(
                 self,
                 rawtext,
                 transaction,
                 link,
                 p1,
                 p2,
                 node,
                 flags,
                 cachedelta,
                 _metatuple=_metatuple,
             )
 
     extensions.wrapfunction(
         remotefilelog.remotefilelog, 'addrawrevision', addrawrevision
     )
 
     def changelogadd(orig, self, *args, **kwargs):
         oldlen = len(self)
         node = orig(self, *args, **kwargs)
         newlen = len(self)
         if oldlen != newlen:
             for oldargs in pendingfilecommits:
                 log, rt, tr, link, p1, p2, n, fl, c, m = oldargs
                 linknode = self.node(link)
                 if linknode == node:
                     log.addrawrevision(rt, tr, linknode, p1, p2, n, fl, c, m)
                 else:
                     raise error.ProgrammingError(
                         b'pending multiple integer revisions are not supported'
                     )
         else:
             # "link" is actually wrong here (it is set to len(changelog))
             # if changelog remains unchanged, skip writing file revisions
             # but still do a sanity check about pending multiple revisions
             if len({x[3] for x in pendingfilecommits}) > 1:
                 raise error.ProgrammingError(
                     b'pending multiple integer revisions are not supported'
                 )
         del pendingfilecommits[:]
         return node
 
     extensions.wrapfunction(changelog.changelog, 'add', changelogadd)
 
 
 def getrenamedfn(orig, repo, endrev=None):
     if not isenabled(repo) or copies.usechangesetcentricalgo(repo):
         return orig(repo, endrev)
 
     rcache = {}
 
     def getrenamed(fn, rev):
         """looks up all renames for a file (up to endrev) the first
         time the file is given. It indexes on the changerev and only
         parses the manifest if linkrev != changerev.
         Returns rename info for fn at changerev rev."""
         if rev in rcache.setdefault(fn, {}):
             return rcache[fn][rev]
 
         try:
             fctx = repo[rev].filectx(fn)
             for ancestor in fctx.ancestors():
                 if ancestor.path() == fn:
                     renamed = ancestor.renamed()
                     rcache[fn][ancestor.rev()] = renamed and renamed[0]
 
             renamed = fctx.renamed()
             return renamed and renamed[0]
         except error.LookupError:
             return None
 
     return getrenamed
 
 
 def filelogrevset(orig, repo, subset, x):
     """``filelog(pattern)``
     Changesets connected to the specified filelog.
 
     For performance reasons, ``filelog()`` does not show every changeset
     that affects the requested file(s). See :hg:`help log` for details. For
     a slower, more accurate result, use ``file()``.
     """
 
     if not isenabled(repo):
         return orig(repo, subset, x)
 
     # i18n: "filelog" is a keyword
     pat = revset.getstring(x, _(b"filelog requires a pattern"))
     m = matchmod.match(
         repo.root, repo.getcwd(), [pat], default=b'relpath', ctx=repo[None]
     )
     s = set()
 
     if not matchmod.patkind(pat):
         # slow
         for r in subset:
             ctx = repo[r]
             cfiles = ctx.files()
             for f in m.files():
                 if f in cfiles:
                     s.add(ctx.rev())
                     break
     else:
         # partial
         files = (f for f in repo[None] if m(f))
         for f in files:
             fctx = repo[None].filectx(f)
             s.add(fctx.linkrev())
             for actx in fctx.ancestors():
                 s.add(actx.linkrev())
 
     return smartset.baseset([r for r in subset if r in s])
 
 
 @command(b'gc', [], _(b'hg gc [REPO...]'), norepo=True)
 def gc(ui, *args, **opts):
     """garbage collect the client and server filelog caches"""
     cachepaths = set()
 
     # get the system client cache
     systemcache = shallowutil.getcachepath(ui, allowempty=True)
     if systemcache:
         cachepaths.add(systemcache)
 
     # get repo client and server cache
     repopaths = []
     pwd = ui.environ.get(b'PWD')
     if pwd:
         repopaths.append(pwd)
 
     repopaths.extend(args)
     repos = []
     for repopath in repopaths:
         try:
             repo = hg.peer(ui, {}, repopath)
             repos.append(repo)
 
             repocache = shallowutil.getcachepath(repo.ui, allowempty=True)
             if repocache:
                 cachepaths.add(repocache)
         except error.RepoError:
             pass
 
     # gc client cache
     for cachepath in cachepaths:
         gcclient(ui, cachepath)
 
     # gc server cache
     for repo in repos:
         remotefilelogserver.gcserver(ui, repo._repo)
 
 
 def gcclient(ui, cachepath):
     # get list of repos that use this cache
     repospath = os.path.join(cachepath, b'repos')
     if not os.path.exists(repospath):
         ui.warn(_(b"no known cache at %s\n") % cachepath)
         return
 
     reposfile = open(repospath, b'rb')
     repos = {r[:-1] for r in reposfile.readlines()}
     reposfile.close()
 
     # build list of useful files
     validrepos = []
     keepkeys = set()
 
     sharedcache = None
     filesrepacked = False
 
     count = 0
     progress = ui.makeprogress(
         _(b"analyzing repositories"), unit=b"repos", total=len(repos)
     )
     for path in repos:
         progress.update(count)
         count += 1
         try:
             path = util.expandpath(os.path.normpath(path))
         except TypeError as e:
             ui.warn(_(b"warning: malformed path: %r:%s\n") % (path, e))
             traceback.print_exc()
             continue
         try:
             peer = hg.peer(ui, {}, path)
             repo = peer._repo
         except error.RepoError:
             continue
 
         validrepos.append(path)
 
         # Protect against any repo or config changes that have happened since
         # this repo was added to the repos file. We'd rather this loop succeed
         # and too much be deleted, than the loop fail and nothing gets deleted.
         if not isenabled(repo):
             continue
 
         if not hasattr(repo, 'name'):
             ui.warn(
                 _(b"repo %s is a misconfigured remotefilelog repo\n") % path
             )
             continue
 
         # If garbage collection on repack and repack on hg gc are enabled
         # then loose files are repacked and garbage collected.
         # Otherwise regular garbage collection is performed.
         repackonhggc = repo.ui.configbool(b'remotefilelog', b'repackonhggc')
         gcrepack = repo.ui.configbool(b'remotefilelog', b'gcrepack')
         if repackonhggc and gcrepack:
             try:
                 repackmod.incrementalrepack(repo)
                 filesrepacked = True
                 continue
             except (IOError, repackmod.RepackAlreadyRunning):
                 # If repack cannot be performed due to not enough disk space
                 # continue doing garbage collection of loose files w/o repack
                 pass
 
         reponame = repo.name
         if not sharedcache:
             sharedcache = repo.sharedstore
 
         # Compute a keepset which is not garbage collected
         def keyfn(fname, fnode):
             return fileserverclient.getcachekey(reponame, fname, hex(fnode))
 
         keepkeys = repackmod.keepset(repo, keyfn=keyfn, lastkeepkeys=keepkeys)
 
     progress.complete()
 
     # write list of valid repos back
     oldumask = os.umask(0o002)
     try:
         reposfile = open(repospath, b'wb')
         reposfile.writelines([(b"%s\n" % r) for r in validrepos])
         reposfile.close()
     finally:
         os.umask(oldumask)
 
     # prune cache
     if sharedcache is not None:
         sharedcache.gc(keepkeys)
     elif not filesrepacked:
         ui.warn(_(b"warning: no valid repos in repofile\n"))
 
 
 def log(orig, ui, repo, *pats, **opts):
     if not isenabled(repo):
         return orig(ui, repo, *pats, **opts)
 
     follow = opts.get('follow')
     revs = opts.get('rev')
     if pats:
         # Force slowpath for non-follow patterns and follows that start from
         # non-working-copy-parent revs.
         if not follow or revs:
             # This forces the slowpath
             opts['removed'] = True
 
         # If this is a non-follow log without any revs specified, recommend that
         # the user add -f to speed it up.
         if not follow and not revs:
             match = scmutil.match(repo[b'.'], pats, pycompat.byteskwargs(opts))
             isfile = not match.anypats()
             if isfile:
                 for file in match.files():
                     if not os.path.isfile(repo.wjoin(file)):
                         isfile = False
                         break
 
             if isfile:
                 ui.warn(
                     _(
                         b"warning: file log can be slow on large repos - "
                         + b"use -f to speed it up\n"
                     )
                 )
 
     return orig(ui, repo, *pats, **opts)
 
 
 def revdatelimit(ui, revset):
     """Update revset so that only changesets no older than 'prefetchdays' days
     are included. The default value is set to 14 days. If 'prefetchdays' is set
     to zero or negative value then date restriction is not applied.
     """
     days = ui.configint(b'remotefilelog', b'prefetchdays')
     if days > 0:
         revset = b'(%s) & date(-%s)' % (revset, days)
     return revset
 
 
 def readytofetch(repo):
     """Check that enough time has passed since the last background prefetch.
     This only relates to prefetches after operations that change the working
     copy parent. Default delay between background prefetches is 2 minutes.
     """
     timeout = repo.ui.configint(b'remotefilelog', b'prefetchdelay')
     fname = repo.vfs.join(b'lastprefetch')
 
     ready = False
     with open(fname, b'a'):
         # the with construct above is used to avoid race conditions
         modtime = os.path.getmtime(fname)
         if (time.time() - modtime) > timeout:
             os.utime(fname, None)
             ready = True
 
     return ready
 
 
 def wcpprefetch(ui, repo, **kwargs):
     """Prefetches in background revisions specified by bgprefetchrevs revset.
     Does background repack if backgroundrepack flag is set in config.
     """
     shallow = isenabled(repo)
     bgprefetchrevs = ui.config(b'remotefilelog', b'bgprefetchrevs')
     isready = readytofetch(repo)
 
     if not (shallow and bgprefetchrevs and isready):
         return
 
     bgrepack = repo.ui.configbool(b'remotefilelog', b'backgroundrepack')
     # update a revset with a date limit
     bgprefetchrevs = revdatelimit(ui, bgprefetchrevs)
 
     def anon(unused_success):
         if hasattr(repo, 'ranprefetch') and repo.ranprefetch:
             return
         repo.ranprefetch = True
         repo.backgroundprefetch(bgprefetchrevs, repack=bgrepack)
 
     repo._afterlock(anon)
 
 
 def pull(orig, ui, repo, *pats, **opts):
     result = orig(ui, repo, *pats, **opts)
 
     if isenabled(repo):
         # prefetch if it's configured
         prefetchrevset = ui.config(b'remotefilelog', b'pullprefetch')
         bgrepack = repo.ui.configbool(b'remotefilelog', b'backgroundrepack')
         bgprefetch = repo.ui.configbool(b'remotefilelog', b'backgroundprefetch')
 
         if prefetchrevset:
             ui.status(_(b"prefetching file contents\n"))
             revs = scmutil.revrange(repo, [prefetchrevset])
             base = repo[b'.'].rev()
             if bgprefetch:
                 repo.backgroundprefetch(prefetchrevset, repack=bgrepack)
             else:
                 repo.prefetch(revs, base=base)
                 if bgrepack:
                     repackmod.backgroundrepack(repo, incremental=True)
         elif bgrepack:
             repackmod.backgroundrepack(repo, incremental=True)
 
     return result
 
 
 def exchangepull(orig, repo, remote, *args, **kwargs):
     # Hook into the callstream/getbundle to insert bundle capabilities
     # during a pull.
     def localgetbundle(
         orig, source, heads=None, common=None, bundlecaps=None, **kwargs
     ):
         if not bundlecaps:
             bundlecaps = set()
         bundlecaps.add(constants.BUNDLE2_CAPABLITY)
         return orig(
             source, heads=heads, common=common, bundlecaps=bundlecaps, **kwargs
         )
 
     if hasattr(remote, '_callstream'):
         remote._localrepo = repo
     elif hasattr(remote, 'getbundle'):
         extensions.wrapfunction(remote, 'getbundle', localgetbundle)
 
     return orig(repo, remote, *args, **kwargs)
 
 
 def _fileprefetchhook(repo, revmatches):
     if isenabled(repo):
         allfiles = []
         for rev, match in revmatches:
             if rev == wdirrev or rev is None:
                 continue
             ctx = repo[rev]
             mf = ctx.manifest()
             sparsematch = repo.maybesparsematch(ctx.rev())
             for path in ctx.walk(match):
                 if (not sparsematch or sparsematch(path)) and path in mf:
                     allfiles.append((path, hex(mf[path])))
         repo.fileservice.prefetch(allfiles)
 
 
 @command(
     b'debugremotefilelog',
     [
         (b'd', b'decompress', None, _(b'decompress the filelog first')),
     ],
     _(b'hg debugremotefilelog <path>'),
     norepo=True,
 )
 def debugremotefilelog(ui, path, **opts):
     return debugcommands.debugremotefilelog(ui, path, **opts)
 
 
 @command(
     b'verifyremotefilelog',
     [
         (b'd', b'decompress', None, _(b'decompress the filelogs first')),
     ],
     _(b'hg verifyremotefilelogs <directory>'),
     norepo=True,
 )
 def verifyremotefilelog(ui, path, **opts):
     return debugcommands.verifyremotefilelog(ui, path, **opts)
 
 
 @command(
     b'debugdatapack',
     [
         (b'', b'long', None, _(b'print the long hashes')),
         (b'', b'node', b'', _(b'dump the contents of node'), b'NODE'),
     ],
     _(b'hg debugdatapack <paths>'),
     norepo=True,
 )
 def debugdatapack(ui, *paths, **opts):
     return debugcommands.debugdatapack(ui, *paths, **opts)
 
 
 @command(b'debughistorypack', [], _(b'hg debughistorypack <path>'), norepo=True)
 def debughistorypack(ui, path, **opts):
     return debugcommands.debughistorypack(ui, path)
 
 
 @command(b'debugkeepset', [], _(b'hg debugkeepset'))
 def debugkeepset(ui, repo, **opts):
     # The command is used to measure keepset computation time
     def keyfn(fname, fnode):
         return fileserverclient.getcachekey(repo.name, fname, hex(fnode))
 
     repackmod.keepset(repo, keyfn)
     return
 
 
 @command(b'debugwaitonrepack', [], _(b'hg debugwaitonrepack'))
 def debugwaitonrepack(ui, repo, **opts):
     return debugcommands.debugwaitonrepack(repo)
 
 
 @command(b'debugwaitonprefetch', [], _(b'hg debugwaitonprefetch'))
 def debugwaitonprefetch(ui, repo, **opts):
     return debugcommands.debugwaitonprefetch(repo)
 
 
 def resolveprefetchopts(ui, opts):
     if not opts.get(b'rev'):
         revset = [b'.', b'draft()']
 
         prefetchrevset = ui.config(b'remotefilelog', b'pullprefetch', None)
         if prefetchrevset:
             revset.append(b'(%s)' % prefetchrevset)
         bgprefetchrevs = ui.config(b'remotefilelog', b'bgprefetchrevs', None)
         if bgprefetchrevs:
             revset.append(b'(%s)' % bgprefetchrevs)
         revset = b'+'.join(revset)
 
         # update a revset with a date limit
         revset = revdatelimit(ui, revset)
 
         opts[b'rev'] = [revset]
 
     if not opts.get(b'base'):
         opts[b'base'] = None
 
     return opts
 
 
 @command(
     b'prefetch',
     [
         (b'r', b'rev', [], _(b'prefetch the specified revisions'), _(b'REV')),
         (b'', b'repack', False, _(b'run repack after prefetch')),
         (b'b', b'base', b'', _(b"rev that is assumed to already be local")),
     ]
     + commands.walkopts,
     _(b'hg prefetch [OPTIONS] [FILE...]'),
     helpcategory=command.CATEGORY_MAINTENANCE,
 )
 def prefetch(ui, repo, *pats, **opts):
     """prefetch file revisions from the server
 
     Prefetchs file revisions for the specified revs and stores them in the
     local remotefilelog cache.  If no rev is specified, the default rev is
     used which is the union of dot, draft, pullprefetch and bgprefetchrev.
     File names or patterns can be used to limit which files are downloaded.
 
     Return 0 on success.
     """
     opts = pycompat.byteskwargs(opts)
     if not isenabled(repo):
         raise error.Abort(_(b"repo is not shallow"))
 
     opts = resolveprefetchopts(ui, opts)
     revs = scmutil.revrange(repo, opts.get(b'rev'))
     repo.prefetch(revs, opts.get(b'base'), pats, opts)
 
     # Run repack in background
     if opts.get(b'repack'):
         repackmod.backgroundrepack(repo, incremental=True)
 
 
 @command(
     b'repack',
     [
         (b'', b'background', None, _(b'run in a background process'), None),
         (b'', b'incremental', None, _(b'do an incremental repack'), None),
         (
             b'',
             b'packsonly',
             None,
             _(b'only repack packs (skip loose objects)'),
             None,
         ),
     ],
     _(b'hg repack [OPTIONS]'),
 )
 def repack_(ui, repo, *pats, **opts):
     if opts.get('background'):
         repackmod.backgroundrepack(
             repo,
             incremental=opts.get('incremental'),
             packsonly=opts.get('packsonly', False),
         )
         return
 
     options = {b'packsonly': opts.get('packsonly')}
 
     try:
         if opts.get('incremental'):
             repackmod.incrementalrepack(repo, options=options)
         else:
             repackmod.fullrepack(repo, options=options)
     except repackmod.RepackAlreadyRunning as ex:
         # Don't propogate the exception if the repack is already in
         # progress, since we want the command to exit 0.
         repo.ui.warn(b'%s\n' % ex)

hgext/remotefilelog/remotefilelogserver.py

@@ -1,446 +1,446 b''
 # remotefilelogserver.py - server logic for a remotefilelog server
 #
 # Copyright 2013 Facebook, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 import os
 import stat
 import time
 import zlib
 
 from mercurial.i18n import _
 from mercurial.node import bin, hex
 from mercurial.pycompat import open
 from mercurial import (
     changegroup,
     changelog,
     context,
     error,
     extensions,
     match,
     scmutil,
     store,
     streamclone,
     util,
     wireprotoserver,
     wireprototypes,
     wireprotov1server,
 )
 from . import (
     constants,
     shallowutil,
 )
 
 _sshv1server = wireprotoserver.sshv1protocolhandler
 
 
 def setupserver(ui, repo):
     """Sets up a normal Mercurial repo so it can serve files to shallow repos."""
     onetimesetup(ui)
 
     # don't send files to shallow clients during pulls
     def generatefiles(
         orig, self, changedfiles, linknodes, commonrevs, source, *args, **kwargs
     ):
         caps = self._bundlecaps or []
         if constants.BUNDLE2_CAPABLITY in caps:
             # only send files that don't match the specified patterns
             includepattern = None
             excludepattern = None
             for cap in self._bundlecaps or []:
                 if cap.startswith(b"includepattern="):
                     includepattern = cap[len(b"includepattern=") :].split(b'\0')
                 elif cap.startswith(b"excludepattern="):
                     excludepattern = cap[len(b"excludepattern=") :].split(b'\0')
 
             m = match.always()
             if includepattern or excludepattern:
                 m = match.match(
                     repo.root, b'', None, includepattern, excludepattern
                 )
 
-            changedfiles = list([f for f in changedfiles if not m(f)])
+            changedfiles = [f for f in changedfiles if not m(f)]
         return orig(
             self, changedfiles, linknodes, commonrevs, source, *args, **kwargs
         )
 
     extensions.wrapfunction(
         changegroup.cgpacker, 'generatefiles', generatefiles
     )
 
 
 onetime = False
 
 
 def onetimesetup(ui):
     """Configures the wireprotocol for both clients and servers."""
     global onetime
     if onetime:
         return
     onetime = True
 
     # support file content requests
     wireprotov1server.wireprotocommand(
         b'x_rfl_getflogheads', b'path', permission=b'pull'
     )(getflogheads)
     wireprotov1server.wireprotocommand(
         b'x_rfl_getfiles', b'', permission=b'pull'
     )(getfiles)
     wireprotov1server.wireprotocommand(
         b'x_rfl_getfile', b'file node', permission=b'pull'
     )(getfile)
 
     class streamstate:
         match = None
         shallowremote = False
         noflatmf = False
 
     state = streamstate()
 
     def stream_out_shallow(repo, proto, other):
         includepattern = None
         excludepattern = None
         raw = other.get(b'includepattern')
         if raw:
             includepattern = raw.split(b'\0')
         raw = other.get(b'excludepattern')
         if raw:
             excludepattern = raw.split(b'\0')
 
         oldshallow = state.shallowremote
         oldmatch = state.match
         oldnoflatmf = state.noflatmf
         try:
             state.shallowremote = True
             state.match = match.always()
             state.noflatmf = other.get(b'noflatmanifest') == b'True'
             if includepattern or excludepattern:
                 state.match = match.match(
                     repo.root, b'', None, includepattern, excludepattern
                 )
             streamres = wireprotov1server.stream(repo, proto)
 
             # Force the first value to execute, so the file list is computed
             # within the try/finally scope
             first = next(streamres.gen)
             second = next(streamres.gen)
 
             def gen():
                 yield first
                 yield second
                 for value in streamres.gen:
                     yield value
 
             return wireprototypes.streamres(gen())
         finally:
             state.shallowremote = oldshallow
             state.match = oldmatch
             state.noflatmf = oldnoflatmf
 
     wireprotov1server.commands[b'stream_out_shallow'] = (
         stream_out_shallow,
         b'*',
     )
 
     # don't clone filelogs to shallow clients
     def _walkstreamfiles(
         orig, repo, matcher=None, phase=False, obsolescence=False
     ):
         if state.shallowremote:
             # if we are shallow ourselves, stream our local commits
             if shallowutil.isenabled(repo):
                 striplen = len(repo.store.path) + 1
                 readdir = repo.store.rawvfs.readdir
                 visit = [os.path.join(repo.store.path, b'data')]
                 while visit:
                     p = visit.pop()
                     for f, kind, st in readdir(p, stat=True):
                         fp = p + b'/' + f
                         if kind == stat.S_IFREG:
                             if not fp.endswith(b'.i') and not fp.endswith(
                                 b'.d'
                             ):
                                 n = util.pconvert(fp[striplen:])
                                 d = store.decodedir(n)
                                 yield store.SimpleStoreEntry(
                                     entry_path=d,
                                     is_volatile=False,
                                     file_size=st.st_size,
                                 )
 
                         if kind == stat.S_IFDIR:
                             visit.append(fp)
 
             if scmutil.istreemanifest(repo):
                 for entry in repo.store.data_entries():
                     if not entry.is_revlog:
                         continue
                     if entry.is_manifestlog:
                         yield entry
 
             # Return .d and .i files that do not match the shallow pattern
             match = state.match
             if match and not match.always():
                 for entry in repo.store.data_entries():
                     if not entry.is_revlog:
                         continue
                     if not state.match(entry.target_id):
                         yield entry
 
             for x in repo.store.top_entries():
                 if state.noflatmf and x[1][:11] == b'00manifest.':
                     continue
                 yield x
 
         elif shallowutil.isenabled(repo):
             # don't allow cloning from a shallow repo to a full repo
             # since it would require fetching every version of every
             # file in order to create the revlogs.
             raise error.Abort(
                 _(b"Cannot clone from a shallow repo to a full repo.")
             )
         else:
             for x in orig(
                 repo, matcher, phase=phase, obsolescence=obsolescence
             ):
                 yield x
 
     extensions.wrapfunction(streamclone, '_walkstreamfiles', _walkstreamfiles)
 
     # expose remotefilelog capabilities
     def _capabilities(orig, repo, proto):
         caps = orig(repo, proto)
         if shallowutil.isenabled(repo) or ui.configbool(
             b'remotefilelog', b'server'
         ):
             if isinstance(proto, _sshv1server):
                 # legacy getfiles method which only works over ssh
                 caps.append(constants.NETWORK_CAP_LEGACY_SSH_GETFILES)
             caps.append(b'x_rfl_getflogheads')
             caps.append(b'x_rfl_getfile')
         return caps
 
     extensions.wrapfunction(wireprotov1server, '_capabilities', _capabilities)
 
     def _adjustlinkrev(orig, self, *args, **kwargs):
         # When generating file blobs, taking the real path is too slow on large
         # repos, so force it to just return the linkrev directly.
         repo = self._repo
         if hasattr(repo, 'forcelinkrev') and repo.forcelinkrev:
             return self._filelog.linkrev(self._filelog.rev(self._filenode))
         return orig(self, *args, **kwargs)
 
     extensions.wrapfunction(
         context.basefilectx, '_adjustlinkrev', _adjustlinkrev
     )
 
     def _iscmd(orig, cmd):
         if cmd == b'x_rfl_getfiles':
             return False
         return orig(cmd)
 
     extensions.wrapfunction(wireprotoserver, 'iscmd', _iscmd)
 
 
 def _loadfileblob(repo, cachepath, path, node):
     filecachepath = os.path.join(cachepath, path, hex(node))
     if not os.path.exists(filecachepath) or os.path.getsize(filecachepath) == 0:
         filectx = repo.filectx(path, fileid=node)
         if filectx.node() == repo.nullid:
             repo.changelog = changelog.changelog(repo.svfs)
             filectx = repo.filectx(path, fileid=node)
 
         text = createfileblob(filectx)
         # TODO configurable compression engines
         text = zlib.compress(text)
 
         # everything should be user & group read/writable
         oldumask = os.umask(0o002)
         try:
             dirname = os.path.dirname(filecachepath)
             if not os.path.exists(dirname):
                 try:
                     os.makedirs(dirname)
                 except FileExistsError:
                     pass
 
             f = None
             try:
                 f = util.atomictempfile(filecachepath, b"wb")
                 f.write(text)
             except (IOError, OSError):
                 # Don't abort if the user only has permission to read,
                 # and not write.
                 pass
             finally:
                 if f:
                     f.close()
         finally:
             os.umask(oldumask)
     else:
         with open(filecachepath, b"rb") as f:
             text = f.read()
     return text
 
 
 def getflogheads(repo, proto, path):
     """A server api for requesting a filelog's heads"""
     flog = repo.file(path)
     heads = flog.heads()
     return b'\n'.join((hex(head) for head in heads if head != repo.nullid))
 
 
 def getfile(repo, proto, file, node):
     """A server api for requesting a particular version of a file. Can be used
     in batches to request many files at once. The return protocol is:
     <errorcode>\0<data/errormsg> where <errorcode> is 0 for success or
     non-zero for an error.
 
     data is a compressed blob with revlog flag and ancestors information. See
     createfileblob for its content.
     """
     if shallowutil.isenabled(repo):
         return b'1\0' + _(b'cannot fetch remote files from shallow repo')
     cachepath = repo.ui.config(b"remotefilelog", b"servercachepath")
     if not cachepath:
         cachepath = os.path.join(repo.path, b"remotefilelogcache")
     node = bin(node.strip())
     if node == repo.nullid:
         return b'0\0'
     return b'0\0' + _loadfileblob(repo, cachepath, file, node)
 
 
 def getfiles(repo, proto):
     """A server api for requesting particular versions of particular files."""
     if shallowutil.isenabled(repo):
         raise error.Abort(_(b'cannot fetch remote files from shallow repo'))
     if not isinstance(proto, _sshv1server):
         raise error.Abort(_(b'cannot fetch remote files over non-ssh protocol'))
 
     def streamer():
         fin = proto._fin
 
         cachepath = repo.ui.config(b"remotefilelog", b"servercachepath")
         if not cachepath:
             cachepath = os.path.join(repo.path, b"remotefilelogcache")
 
         while True:
             request = fin.readline()[:-1]
             if not request:
                 break
 
             node = bin(request[:40])
             if node == repo.nullid:
                 yield b'0\n'
                 continue
 
             path = request[40:]
 
             text = _loadfileblob(repo, cachepath, path, node)
 
             yield b'%d\n%s' % (len(text), text)
 
             # it would be better to only flush after processing a whole batch
             # but currently we don't know if there are more requests coming
             proto._fout.flush()
 
     return wireprototypes.streamres(streamer())
 
 
 def createfileblob(filectx):
     """
     format:
         v0:
             str(len(rawtext)) + '\0' + rawtext + ancestortext
         v1:
             'v1' + '\n' + metalist + '\0' + rawtext + ancestortext
             metalist := metalist + '\n' + meta | meta
             meta := sizemeta | flagmeta
             sizemeta := METAKEYSIZE + str(len(rawtext))
             flagmeta := METAKEYFLAG + str(flag)
 
             note: sizemeta must exist. METAKEYFLAG and METAKEYSIZE must have a
             length of 1.
     """
     flog = filectx.filelog()
     frev = filectx.filerev()
     revlogflags = flog._revlog.flags(frev)
     if revlogflags == 0:
         # normal files
         text = filectx.data()
     else:
         # lfs, read raw revision data
         text = flog.rawdata(frev)
 
     repo = filectx._repo
 
     ancestors = [filectx]
 
     try:
         repo.forcelinkrev = True
         ancestors.extend([f for f in filectx.ancestors()])
 
         ancestortext = b""
         for ancestorctx in ancestors:
             parents = ancestorctx.parents()
             p1 = repo.nullid
             p2 = repo.nullid
             if len(parents) > 0:
                 p1 = parents[0].filenode()
             if len(parents) > 1:
                 p2 = parents[1].filenode()
 
             copyname = b""
             rename = ancestorctx.renamed()
             if rename:
                 copyname = rename[0]
             linknode = ancestorctx.node()
             ancestortext += b"%s%s%s%s%s\0" % (
                 ancestorctx.filenode(),
                 p1,
                 p2,
                 linknode,
                 copyname,
             )
     finally:
         repo.forcelinkrev = False
 
     header = shallowutil.buildfileblobheader(len(text), revlogflags)
 
     return b"%s\0%s%s" % (header, text, ancestortext)
 
 
 def gcserver(ui, repo):
     if not repo.ui.configbool(b"remotefilelog", b"server"):
         return
 
     neededfiles = set()
     heads = repo.revs(b"heads(tip~25000:) - null")
 
     cachepath = repo.vfs.join(b"remotefilelogcache")
     for head in heads:
         mf = repo[head].manifest()
         for filename, filenode in mf.items():
             filecachepath = os.path.join(cachepath, filename, hex(filenode))
             neededfiles.add(filecachepath)
 
     # delete unneeded older files
     days = repo.ui.configint(b"remotefilelog", b"serverexpiration")
     expiration = time.time() - (days * 24 * 60 * 60)
 
     progress = ui.makeprogress(_(b"removing old server cache"), unit=b"files")
     progress.update(0)
     for root, dirs, files in os.walk(cachepath):
         for file in files:
             filepath = os.path.join(root, file)
             progress.increment()
             if filepath in neededfiles:
                 continue
 
             stat = os.stat(filepath)
             if stat.st_mtime < expiration:
                 os.remove(filepath)
 
     progress.complete()

tests/hghave.py

@@ -1,1161 +1,1159 b''
 import distutils.version
 import os
 import re
 import socket
 import stat
 import subprocess
 import sys
 import tempfile
 
 tempprefix = 'hg-hghave-'
 
 checks = {
     "true": (lambda: True, "yak shaving"),
     "false": (lambda: False, "nail clipper"),
     "known-bad-output": (lambda: True, "use for currently known bad output"),
     "missing-correct-output": (lambda: False, "use for missing good output"),
 }
 
 try:
     import msvcrt
 
     msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
     msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
 except ImportError:
     pass
 
 stdout = getattr(sys.stdout, 'buffer', sys.stdout)
 stderr = getattr(sys.stderr, 'buffer', sys.stderr)
 
 
 def _sys2bytes(p):
     if p is None:
         return p
     return p.encode('utf-8')
 
 
 def _bytes2sys(p):
     if p is None:
         return p
     return p.decode('utf-8')
 
 
 def check(name, desc):
     """Registers a check function for a feature."""
 
     def decorator(func):
         checks[name] = (func, desc)
         return func
 
     return decorator
 
 
 def checkvers(name, desc, vers):
     """Registers a check function for each of a series of versions.
 
     vers can be a list or an iterator.
 
     Produces a series of feature checks that have the form <name><vers> without
     any punctuation (even if there's punctuation in 'vers'; i.e. this produces
     'py38', not 'py3.8' or 'py-38')."""
 
     def decorator(func):
         def funcv(v):
             def f():
                 return func(v)
 
             return f
 
         for v in vers:
             v = str(v)
             f = funcv(v)
             checks['%s%s' % (name, v.replace('.', ''))] = (f, desc % v)
         return func
 
     return decorator
 
 
 def checkfeatures(features):
     result = {
         'error': [],
         'missing': [],
         'skipped': [],
     }
 
     for feature in features:
         negate = feature.startswith('no-')
         if negate:
             feature = feature[3:]
 
         if feature not in checks:
             result['missing'].append(feature)
             continue
 
         check, desc = checks[feature]
         try:
             available = check()
         except Exception as e:
             result['error'].append('hghave check %s failed: %r' % (feature, e))
             continue
 
         if not negate and not available:
             result['skipped'].append('missing feature: %s' % desc)
         elif negate and available:
             result['skipped'].append('system supports %s' % desc)
 
     return result
 
 
 def require(features):
     """Require that features are available, exiting if not."""
     result = checkfeatures(features)
 
     for missing in result['missing']:
         stderr.write(
             ('skipped: unknown feature: %s\n' % missing).encode('utf-8')
         )
     for msg in result['skipped']:
         stderr.write(('skipped: %s\n' % msg).encode('utf-8'))
     for msg in result['error']:
         stderr.write(('%s\n' % msg).encode('utf-8'))
 
     if result['missing']:
         sys.exit(2)
 
     if result['skipped'] or result['error']:
         sys.exit(1)
 
 
 def matchoutput(cmd, regexp, ignorestatus=False):
     """Return the match object if cmd executes successfully and its output
     is matched by the supplied regular expression.
     """
 
     # Tests on Windows have to fake USERPROFILE to point to the test area so
     # that `~` is properly expanded on py3.8+.  However, some tools like black
     # make calls that need the real USERPROFILE in order to run `foo --version`.
     env = os.environ
     if os.name == 'nt':
         env = os.environ.copy()
         env['USERPROFILE'] = env['REALUSERPROFILE']
 
     r = re.compile(regexp)
     p = subprocess.Popen(
         cmd,
         shell=True,
         stdout=subprocess.PIPE,
         stderr=subprocess.STDOUT,
         env=env,
     )
     s = p.communicate()[0]
     ret = p.returncode
     return (ignorestatus or not ret) and r.search(s)
 
 
 @check("baz", "GNU Arch baz client")
 def has_baz():
     return matchoutput('baz --version 2>&1', br'baz Bazaar version')
 
 
 @check("bzr", "Breezy library and executable version >= 3.1")
 def has_bzr():
     try:
         # Test the Breezy python lib
         import breezy
         import breezy.bzr.bzrdir
         import breezy.errors
         import breezy.revision
         import breezy.revisionspec
 
         breezy.revisionspec.RevisionSpec
         if breezy.__doc__ is None or breezy.version_info[:2] < (3, 1):
             return False
     except (AttributeError, ImportError):
         return False
     # Test the executable
     return matchoutput('brz --version 2>&1', br'Breezy \(brz\) ')
 
 
 @check("chg", "running with chg")
 def has_chg():
     return 'CHG_INSTALLED_AS_HG' in os.environ
 
 
 @check("rhg", "running with rhg as 'hg'")
 def has_rhg():
     return 'RHG_INSTALLED_AS_HG' in os.environ
 
 
 @check("pyoxidizer", "running with pyoxidizer build as 'hg'")
 def has_pyoxidizer():
     return 'PYOXIDIZED_INSTALLED_AS_HG' in os.environ
 
 
 @check(
     "pyoxidizer-in-memory",
     "running with pyoxidizer build as 'hg' with embedded resources",
 )
 def has_pyoxidizer_mem():
     return 'PYOXIDIZED_IN_MEMORY_RSRC' in os.environ
 
 
 @check(
     "pyoxidizer-in-filesystem",
     "running with pyoxidizer build as 'hg' with external resources",
 )
 def has_pyoxidizer_fs():
     return 'PYOXIDIZED_FILESYSTEM_RSRC' in os.environ
 
 
 @check("cvs", "cvs client/server")
 def has_cvs():
     re = br'Concurrent Versions System.*?server'
     return matchoutput('cvs --version 2>&1', re) and not has_msys()
 
 
 @check("cvs112", "cvs client/server 1.12.* (not cvsnt)")
 def has_cvs112():
     re = br'Concurrent Versions System \(CVS\) 1.12.*?server'
     return matchoutput('cvs --version 2>&1', re) and not has_msys()
 
 
 @check("cvsnt", "cvsnt client/server")
 def has_cvsnt():
     re = br'Concurrent Versions System \(CVSNT\) (\d+).(\d+).*\(client/server\)'
     return matchoutput('cvsnt --version 2>&1', re)
 
 
 @check("darcs", "darcs client")
 def has_darcs():
     return matchoutput('darcs --version', br'\b2\.([2-9]|\d{2})', True)
 
 
 @check("mtn", "monotone client (>= 1.0)")
 def has_mtn():
     return matchoutput('mtn --version', br'monotone', True) and not matchoutput(
         'mtn --version', br'monotone 0\.', True
     )
 
 
 @check("eol-in-paths", "end-of-lines in paths")
 def has_eol_in_paths():
     try:
         fd, path = tempfile.mkstemp(dir='.', prefix=tempprefix, suffix='\n\r')
         os.close(fd)
         os.remove(path)
         return True
     except (IOError, OSError):
         return False
 
 
 @check("execbit", "executable bit")
 def has_executablebit():
     try:
         EXECFLAGS = stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
         fh, fn = tempfile.mkstemp(dir='.', prefix=tempprefix)
         try:
             os.close(fh)
             m = os.stat(fn).st_mode & 0o777
             new_file_has_exec = m & EXECFLAGS
             os.chmod(fn, m ^ EXECFLAGS)
             exec_flags_cannot_flip = (os.stat(fn).st_mode & 0o777) == m
         finally:
             os.unlink(fn)
     except (IOError, OSError):
         # we don't care, the user probably won't be able to commit anyway
         return False
     return not (new_file_has_exec or exec_flags_cannot_flip)
 
 
 @check("suidbit", "setuid and setgid bit")
 def has_suidbit():
     if (
         getattr(os, "statvfs", None) is None
         or getattr(os, "ST_NOSUID", None) is None
     ):
         return False
     return bool(os.statvfs('.').f_flag & os.ST_NOSUID)
 
 
 @check("icasefs", "case insensitive file system")
 def has_icasefs():
     # Stolen from mercurial.util
     fd, path = tempfile.mkstemp(dir='.', prefix=tempprefix)
     os.close(fd)
     try:
         s1 = os.stat(path)
         d, b = os.path.split(path)
         p2 = os.path.join(d, b.upper())
         if path == p2:
             p2 = os.path.join(d, b.lower())
         try:
             s2 = os.stat(p2)
             return s2 == s1
         except OSError:
             return False
     finally:
         os.remove(path)
 
 
 @check("fifo", "named pipes")
 def has_fifo():
     if getattr(os, "mkfifo", None) is None:
         return False
     name = tempfile.mktemp(dir='.', prefix=tempprefix)
     try:
         os.mkfifo(name)
         os.unlink(name)
         return True
     except OSError:
         return False
 
 
 @check("killdaemons", 'killdaemons.py support')
 def has_killdaemons():
     return True
 
 
 @check("cacheable", "cacheable filesystem")
 def has_cacheable_fs():
     from mercurial import util
 
     fd, path = tempfile.mkstemp(dir='.', prefix=tempprefix)
     os.close(fd)
     try:
         return util.cachestat(_sys2bytes(path)).cacheable()
     finally:
         os.remove(path)
 
 
 @check("lsprof", "python lsprof module")
 def has_lsprof():
     try:
         import _lsprof
 
         _lsprof.Profiler  # silence unused import warning
         return True
     except ImportError:
         return False
 
 
 def _gethgversion():
     m = matchoutput('hg --version --quiet 2>&1', br'(\d+)\.(\d+)')
     if not m:
         return (0, 0)
     return (int(m.group(1)), int(m.group(2)))
 
 
 _hgversion = None
 
 
 def gethgversion():
     global _hgversion
     if _hgversion is None:
         _hgversion = _gethgversion()
     return _hgversion
 
 
-@checkvers(
-    "hg", "Mercurial >= %s", list([(1.0 * x) / 10 for x in range(9, 99)])
-)
+@checkvers("hg", "Mercurial >= %s", [(1.0 * x) / 10 for x in range(9, 99)])
 def has_hg_range(v):
     major, minor = v.split('.')[0:2]
     return gethgversion() >= (int(major), int(minor))
 
 
 @check("rust", "Using the Rust extensions")
 def has_rust():
     """Check is the mercurial currently running is using some rust code"""
     cmd = 'hg debuginstall --quiet 2>&1'
     match = br'checking module policy \(([^)]+)\)'
     policy = matchoutput(cmd, match)
     if not policy:
         return False
     return b'rust' in policy.group(1)
 
 
 @check("hg08", "Mercurial >= 0.8")
 def has_hg08():
     if checks["hg09"][0]():
         return True
     return matchoutput('hg help annotate 2>&1', '--date')
 
 
 @check("hg07", "Mercurial >= 0.7")
 def has_hg07():
     if checks["hg08"][0]():
         return True
     return matchoutput('hg --version --quiet 2>&1', 'Mercurial Distributed SCM')
 
 
 @check("hg06", "Mercurial >= 0.6")
 def has_hg06():
     if checks["hg07"][0]():
         return True
     return matchoutput('hg --version --quiet 2>&1', 'Mercurial version')
 
 
 @check("gettext", "GNU Gettext (msgfmt)")
 def has_gettext():
     return matchoutput('msgfmt --version', br'GNU gettext-tools')
 
 
 @check("git", "git command line client")
 def has_git():
     return matchoutput('git --version 2>&1', br'^git version')
 
 
 def getgitversion():
     m = matchoutput('git --version 2>&1', br'git version (\d+)\.(\d+)')
     if not m:
         return (0, 0)
     return (int(m.group(1)), int(m.group(2)))
 
 
 @check("pygit2", "pygit2 Python library")
 def has_pygit2():
     try:
         import pygit2
 
         pygit2.Oid  # silence unused import
         return True
     except ImportError:
         return False
 
 
 # https://github.com/git-lfs/lfs-test-server
 @check("lfs-test-server", "git-lfs test server")
 def has_lfsserver():
     exe = 'lfs-test-server'
     if has_windows():
         exe = 'lfs-test-server.exe'
     return any(
         os.access(os.path.join(path, exe), os.X_OK)
         for path in os.environ["PATH"].split(os.pathsep)
     )
 
 
 @checkvers("git", "git client (with ext::sh support) version >= %s", (1.9,))
 def has_git_range(v):
     major, minor = v.split('.')[0:2]
     return getgitversion() >= (int(major), int(minor))
 
 
 @check("docutils", "Docutils text processing library")
 def has_docutils():
     try:
         import docutils.core
 
         docutils.core.publish_cmdline  # silence unused import
         return True
     except ImportError:
         return False
 
 
 def getsvnversion():
     m = matchoutput('svn --version --quiet 2>&1', br'^(\d+)\.(\d+)')
     if not m:
         return (0, 0)
     return (int(m.group(1)), int(m.group(2)))
 
 
 @checkvers("svn", "subversion client and admin tools >= %s", (1.3, 1.5))
 def has_svn_range(v):
     major, minor = v.split('.')[0:2]
     return getsvnversion() >= (int(major), int(minor))
 
 
 @check("svn", "subversion client and admin tools")
 def has_svn():
     return matchoutput('svn --version 2>&1', br'^svn, version') and matchoutput(
         'svnadmin --version 2>&1', br'^svnadmin, version'
     )
 
 
 @check("svn-bindings", "subversion python bindings")
 def has_svn_bindings():
     try:
         import svn.core
 
         version = svn.core.SVN_VER_MAJOR, svn.core.SVN_VER_MINOR
         if version < (1, 4):
             return False
         return True
     except ImportError:
         return False
 
 
 @check("p4", "Perforce server and client")
 def has_p4():
     return matchoutput('p4 -V', br'Rev\. P4/') and matchoutput(
         'p4d -V', br'Rev\. P4D/'
     )
 
 
 @check("symlink", "symbolic links")
 def has_symlink():
     # mercurial.windows.checklink() is a hard 'no' at the moment
     if os.name == 'nt' or getattr(os, "symlink", None) is None:
         return False
     name = tempfile.mktemp(dir='.', prefix=tempprefix)
     try:
         os.symlink(".", name)
         os.unlink(name)
         return True
     except (OSError, AttributeError):
         return False
 
 
 @check("hardlink", "hardlinks")
 def has_hardlink():
     from mercurial import util
 
     fh, fn = tempfile.mkstemp(dir='.', prefix=tempprefix)
     os.close(fh)
     name = tempfile.mktemp(dir='.', prefix=tempprefix)
     try:
         util.oslink(_sys2bytes(fn), _sys2bytes(name))
         os.unlink(name)
         return True
     except OSError:
         return False
     finally:
         os.unlink(fn)
 
 
 @check("hardlink-whitelisted", "hardlinks on whitelisted filesystems")
 def has_hardlink_whitelisted():
     from mercurial import util
 
     try:
         fstype = util.getfstype(b'.')
     except OSError:
         return False
     return fstype in util._hardlinkfswhitelist
 
 
 @check("rmcwd", "can remove current working directory")
 def has_rmcwd():
     ocwd = os.getcwd()
     temp = tempfile.mkdtemp(dir='.', prefix=tempprefix)
     try:
         os.chdir(temp)
         # On Linux, 'rmdir .' isn't allowed, but the other names are okay.
         # On Solaris and Windows, the cwd can't be removed by any names.
         os.rmdir(os.getcwd())
         return True
     except OSError:
         return False
     finally:
         os.chdir(ocwd)
         # clean up temp dir on platforms where cwd can't be removed
         try:
             os.rmdir(temp)
         except OSError:
             pass
 
 
 @check("tla", "GNU Arch tla client")
 def has_tla():
     return matchoutput('tla --version 2>&1', br'The GNU Arch Revision')
 
 
 @check("gpg", "gpg client")
 def has_gpg():
     return matchoutput('gpg --version 2>&1', br'GnuPG')
 
 
 @check("gpg2", "gpg client v2")
 def has_gpg2():
     return matchoutput('gpg --version 2>&1', br'GnuPG[^0-9]+2\.')
 
 
 @check("gpg21", "gpg client v2.1+")
 def has_gpg21():
     return matchoutput('gpg --version 2>&1', br'GnuPG[^0-9]+2\.(?!0)')
 
 
 @check("unix-permissions", "unix-style permissions")
 def has_unix_permissions():
     d = tempfile.mkdtemp(dir='.', prefix=tempprefix)
     try:
         fname = os.path.join(d, 'foo')
         for umask in (0o77, 0o07, 0o22):
             os.umask(umask)
             f = open(fname, 'w')
             f.close()
             mode = os.stat(fname).st_mode
             os.unlink(fname)
             if mode & 0o777 != ~umask & 0o666:
                 return False
         return True
     finally:
         os.rmdir(d)
 
 
 @check("unix-socket", "AF_UNIX socket family")
 def has_unix_socket():
     return getattr(socket, 'AF_UNIX', None) is not None
 
 
 @check("root", "root permissions")
 def has_root():
     return getattr(os, 'geteuid', None) and os.geteuid() == 0
 
 
 @check("pyflakes", "Pyflakes python linter")
 def has_pyflakes():
     try:
         import pyflakes
 
         pyflakes.__version__
     except ImportError:
         return False
     else:
         return True
 
 
 @check("pylint", "Pylint python linter")
 def has_pylint():
     return matchoutput("pylint --help", br"[Uu]sage:[ ]+pylint", True)
 
 
 @check("clang-format", "clang-format C code formatter (>= 11)")
 def has_clang_format():
     m = matchoutput('clang-format --version', br'clang-format version (\d+)')
     # style changed somewhere between 10.x and 11.x
     if m:
         return int(m.group(1)) >= 11
     # Assist Googler contributors, they have a centrally-maintained version of
     # clang-format that is generally very fresh, but unlike most builds (both
     # official and unofficial), it does *not* include a version number.
     return matchoutput(
         'clang-format --version', br'clang-format .*google3-trunk \([0-9a-f]+\)'
     )
 
 
 @check("jshint", "JSHint static code analysis tool")
 def has_jshint():
     return matchoutput("jshint --version 2>&1", br"jshint v")
 
 
 @check("pygments", "Pygments source highlighting library")
 def has_pygments():
     try:
         import pygments
 
         pygments.highlight  # silence unused import warning
         return True
     except ImportError:
         return False
 
 
 def getpygmentsversion():
     try:
         import pygments
 
         v = pygments.__version__
 
         parts = v.split(".")
         return (int(parts[0]), int(parts[1]))
     except ImportError:
         return (0, 0)
 
 
 @checkvers("pygments", "Pygments version >= %s", (2.5, 2.11, 2.14))
 def has_pygments_range(v):
     major, minor = v.split('.')[0:2]
     return getpygmentsversion() >= (int(major), int(minor))
 
 
 @check("outer-repo", "outer repo")
 def has_outer_repo():
     # failing for other reasons than 'no repo' imply that there is a repo
     return not matchoutput('hg root 2>&1', br'abort: no repository found', True)
 
 
 @check("ssl", "ssl module available")
 def has_ssl():
     try:
         import ssl
 
         ssl.CERT_NONE
         return True
     except ImportError:
         return False
 
 
 @check("defaultcacertsloaded", "detected presence of loaded system CA certs")
 def has_defaultcacertsloaded():
     import ssl
     from mercurial import sslutil, ui as uimod
 
     ui = uimod.ui.load()
     cafile = sslutil._defaultcacerts(ui)
     ctx = ssl.create_default_context()
     if cafile:
         ctx.load_verify_locations(cafile=cafile)
     else:
         ctx.load_default_certs()
 
     return len(ctx.get_ca_certs()) > 0
 
 
 @check("tls1.2", "TLS 1.2 protocol support")
 def has_tls1_2():
     from mercurial import sslutil
 
     return b'tls1.2' in sslutil.supportedprotocols
 
 
 @check("windows", "Windows")
 def has_windows():
     return os.name == 'nt'
 
 
 @check("system-sh", "system() uses sh")
 def has_system_sh():
     return os.name != 'nt'
 
 
 @check("serve", "platform and python can manage 'hg serve -d'")
 def has_serve():
     return True
 
 
 @check("setprocname", "whether osutil.setprocname is available or not")
 def has_setprocname():
     try:
         from mercurial.utils import procutil
 
         procutil.setprocname
         return True
     except AttributeError:
         return False
 
 
 @check("test-repo", "running tests from repository")
 def has_test_repo():
     t = os.environ["TESTDIR"]
     return os.path.isdir(os.path.join(t, "..", ".hg"))
 
 
 @check("network-io", "whether tests are allowed to access 3rd party services")
 def has_network_io():
     t = os.environ.get("HGTESTS_ALLOW_NETIO")
     return t == "1"
 
 
 @check("curses", "terminfo compiler and curses module")
 def has_curses():
     try:
         import curses
 
         curses.COLOR_BLUE
 
         # Windows doesn't have a `tic` executable, but the windows_curses
         # package is sufficient to run the tests without it.
         if os.name == 'nt':
             return True
 
         return has_tic()
 
     except (ImportError, AttributeError):
         return False
 
 
 @check("tic", "terminfo compiler")
 def has_tic():
     return matchoutput('test -x "`which tic`"', br'')
 
 
 @check("xz", "xz compression utility")
 def has_xz():
     # When Windows invokes a subprocess in shell mode, it uses `cmd.exe`, which
     # only knows `where`, not `which`.  So invoke MSYS shell explicitly.
     return matchoutput("sh -c 'test -x \"`which xz`\"'", b'')
 
 
 @check("msys", "Windows with MSYS")
 def has_msys():
     return os.getenv('MSYSTEM')
 
 
 @check("aix", "AIX")
 def has_aix():
     return sys.platform.startswith("aix")
 
 
 @check("osx", "OS X")
 def has_osx():
     return sys.platform == 'darwin'
 
 
 @check("osxpackaging", "OS X packaging tools")
 def has_osxpackaging():
     try:
         return (
             matchoutput('pkgbuild', br'Usage: pkgbuild ', ignorestatus=1)
             and matchoutput(
                 'productbuild', br'Usage: productbuild ', ignorestatus=1
             )
             and matchoutput('lsbom', br'Usage: lsbom', ignorestatus=1)
             and matchoutput('xar --help', br'Usage: xar', ignorestatus=1)
         )
     except ImportError:
         return False
 
 
 @check('linuxormacos', 'Linux or MacOS')
 def has_linuxormacos():
     # This isn't a perfect test for MacOS. But it is sufficient for our needs.
     return sys.platform.startswith(('linux', 'darwin'))
 
 
 @check("docker", "docker support")
 def has_docker():
     pat = br'A self-sufficient runtime for'
     if matchoutput('docker --help', pat):
         if 'linux' not in sys.platform:
             # TODO: in theory we should be able to test docker-based
             # package creation on non-linux using boot2docker, but in
             # practice that requires extra coordination to make sure
             # $TESTTEMP is going to be visible at the same path to the
             # boot2docker VM. If we figure out how to verify that, we
             # can use the following instead of just saying False:
             # return 'DOCKER_HOST' in os.environ
             return False
 
         return True
     return False
 
 
 @check("debhelper", "debian packaging tools")
 def has_debhelper():
     # Some versions of dpkg say `dpkg', some say 'dpkg' (` vs ' on the first
     # quote), so just accept anything in that spot.
     dpkg = matchoutput(
         'dpkg --version', br"Debian .dpkg' package management program"
     )
     dh = matchoutput(
         'dh --help', br'dh is a part of debhelper.', ignorestatus=True
     )
     dh_py2 = matchoutput(
         'dh_python2 --help', br'other supported Python versions'
     )
     # debuild comes from the 'devscripts' package, though you might want
     # the 'build-debs' package instead, which has a dependency on devscripts.
     debuild = matchoutput(
         'debuild --help', br'to run debian/rules with given parameter'
     )
     return dpkg and dh and dh_py2 and debuild
 
 
 @check(
     "debdeps", "debian build dependencies (run dpkg-checkbuilddeps in contrib/)"
 )
 def has_debdeps():
     # just check exit status (ignoring output)
     path = '%s/../contrib/packaging/debian/control' % os.environ['TESTDIR']
     return matchoutput('dpkg-checkbuilddeps %s' % path, br'')
 
 
 @check("demandimport", "demandimport enabled")
 def has_demandimport():
     # chg disables demandimport intentionally for performance wins.
     return (not has_chg()) and os.environ.get('HGDEMANDIMPORT') != 'disable'
 
 
 # Add "py36", "py37", ... as possible feature checks. Note that there's no
 # punctuation here.
 @checkvers("py", "Python >= %s", (3.6, 3.7, 3.8, 3.9, 3.10, 3.11))
 def has_python_range(v):
     major, minor = v.split('.')[0:2]
     py_major, py_minor = sys.version_info.major, sys.version_info.minor
 
     return (py_major, py_minor) >= (int(major), int(minor))
 
 
 @check("py3", "running with Python 3.x")
 def has_py3():
     return 3 == sys.version_info[0]
 
 
 @check("py3exe", "a Python 3.x interpreter is available")
 def has_python3exe():
     py = 'python3'
     if os.name == 'nt':
         py = 'py -3'
     return matchoutput('%s -V' % py, br'^Python 3.(6|7|8|9|10|11)')
 
 
 @check("pure", "running with pure Python code")
 def has_pure():
     return any(
         [
             os.environ.get("HGMODULEPOLICY") == "py",
             os.environ.get("HGTEST_RUN_TESTS_PURE") == "--pure",
         ]
     )
 
 
 @check("slow", "allow slow tests (use --allow-slow-tests)")
 def has_slow():
     return os.environ.get('HGTEST_SLOW') == 'slow'
 
 
 @check("hypothesis", "Hypothesis automated test generation")
 def has_hypothesis():
     try:
         import hypothesis
 
         hypothesis.given
         return True
     except ImportError:
         return False
 
 
 @check("unziplinks", "unzip(1) understands and extracts symlinks")
 def unzip_understands_symlinks():
     return matchoutput('unzip --help', br'Info-ZIP')
 
 
 @check("zstd", "zstd Python module available")
 def has_zstd():
     try:
         import mercurial.zstd
 
         mercurial.zstd.__version__
         return True
     except ImportError:
         return False
 
 
 @check("devfull", "/dev/full special file")
 def has_dev_full():
     return os.path.exists('/dev/full')
 
 
 @check("ensurepip", "ensurepip module")
 def has_ensurepip():
     try:
         import ensurepip
 
         ensurepip.bootstrap
         return True
     except ImportError:
         return False
 
 
 @check("virtualenv", "virtualenv support")
 def has_virtualenv():
     try:
         import virtualenv
 
         # --no-site-package became the default in 1.7 (Nov 2011), and the
         # argument was removed in 20.0 (Feb 2020).  Rather than make the
         # script complicated, just ignore ancient versions.
         return int(virtualenv.__version__.split('.')[0]) > 1
     except (AttributeError, ImportError, IndexError):
         return False
 
 
 @check("fsmonitor", "running tests with fsmonitor")
 def has_fsmonitor():
     return 'HGFSMONITOR_TESTS' in os.environ
 
 
 @check("fuzzywuzzy", "Fuzzy string matching library")
 def has_fuzzywuzzy():
     try:
         import fuzzywuzzy
 
         fuzzywuzzy.__version__
         return True
     except ImportError:
         return False
 
 
 @check("clang-libfuzzer", "clang new enough to include libfuzzer")
 def has_clang_libfuzzer():
     mat = matchoutput('clang --version', br'clang version (\d)')
     if mat:
         # libfuzzer is new in clang 6
         return int(mat.group(1)) > 5
     return False
 
 
 @check("clang-6.0", "clang 6.0 with version suffix (libfuzzer included)")
 def has_clang60():
     return matchoutput('clang-6.0 --version', br'clang version 6\.')
 
 
 @check("xdiff", "xdiff algorithm")
 def has_xdiff():
     try:
         from mercurial import policy
 
         bdiff = policy.importmod('bdiff')
         return bdiff.xdiffblocks(b'', b'') == [(0, 0, 0, 0)]
     except (ImportError, AttributeError):
         return False
 
 
 @check('extraextensions', 'whether tests are running with extra extensions')
 def has_extraextensions():
     return 'HGTESTEXTRAEXTENSIONS' in os.environ
 
 
 def getrepofeatures():
     """Obtain set of repository features in use.
 
     HGREPOFEATURES can be used to define or remove features. It contains
     a space-delimited list of feature strings. Strings beginning with ``-``
     mean to remove.
     """
     # Default list provided by core.
     features = {
         'bundlerepo',
         'revlogstore',
         'fncache',
     }
 
     # Features that imply other features.
     implies = {
         'simplestore': ['-revlogstore', '-bundlerepo', '-fncache'],
     }
 
     for override in os.environ.get('HGREPOFEATURES', '').split(' '):
         if not override:
             continue
 
         if override.startswith('-'):
             if override[1:] in features:
                 features.remove(override[1:])
         else:
             features.add(override)
 
             for imply in implies.get(override, []):
                 if imply.startswith('-'):
                     if imply[1:] in features:
                         features.remove(imply[1:])
                 else:
                     features.add(imply)
 
     return features
 
 
 @check('reporevlogstore', 'repository using the default revlog store')
 def has_reporevlogstore():
     return 'revlogstore' in getrepofeatures()
 
 
 @check('reposimplestore', 'repository using simple storage extension')
 def has_reposimplestore():
     return 'simplestore' in getrepofeatures()
 
 
 @check('repobundlerepo', 'whether we can open bundle files as repos')
 def has_repobundlerepo():
     return 'bundlerepo' in getrepofeatures()
 
 
 @check('repofncache', 'repository has an fncache')
 def has_repofncache():
     return 'fncache' in getrepofeatures()
 
 
 @check('dirstate-v2', 'using the v2 format of .hg/dirstate')
 def has_dirstate_v2():
     # Keep this logic in sync with `newreporequirements()` in `mercurial/localrepo.py`
     return matchoutput(
         'hg config format.use-dirstate-v2', b'(?i)1|yes|true|on|always'
     )
 
 
 @check('sqlite', 'sqlite3 module and matching cli is available')
 def has_sqlite():
     try:
         import sqlite3
 
         version = sqlite3.sqlite_version_info
     except ImportError:
         return False
 
     if version < (3, 8, 3):
         # WITH clause not supported
         return False
 
     return matchoutput('sqlite3 -version', br'^3\.\d+')
 
 
 @check('vcr', 'vcr http mocking library (pytest-vcr)')
 def has_vcr():
     try:
         import vcr
 
         vcr.VCR
         return True
     except (ImportError, AttributeError):
         pass
     return False
 
 
 @check('emacs', 'GNU Emacs')
 def has_emacs():
     # Our emacs lisp uses `with-eval-after-load` which is new in emacs
     # 24.4, so we allow emacs 24.4, 24.5, and 25+ (24.5 was the last
     # 24 release)
     return matchoutput('emacs --version', b'GNU Emacs 2(4.4|4.5|5|6|7|8|9)')
 
 
 @check('black', 'the black formatter for python (>= 20.8b1)')
 def has_black():
     blackcmd = 'black --version'
     version_regex = b'black, (?:version )?([0-9a-b.]+)'
     version = matchoutput(blackcmd, version_regex)
     sv = distutils.version.StrictVersion
     return version and sv(_bytes2sys(version.group(1))) >= sv('20.8b1')
 
 
 @check('pytype', 'the pytype type checker')
 def has_pytype():
     pytypecmd = 'pytype --version'
     version = matchoutput(pytypecmd, b'[0-9a-b.]+')
     sv = distutils.version.StrictVersion
     return version and sv(_bytes2sys(version.group(0))) >= sv('2019.10.17')
 
 
 @check("rustfmt", "rustfmt tool at version nightly-2021-11-02")
 def has_rustfmt():
     # We use Nightly's rustfmt due to current unstable config options.
     return matchoutput(
         '`rustup which --toolchain nightly-2021-11-02 rustfmt` --version',
         b'rustfmt',
     )
 
 
 @check("cargo", "cargo tool")
 def has_cargo():
     return matchoutput('`rustup which cargo` --version', b'cargo')
 
 
 @check("lzma", "python lzma module")
 def has_lzma():
     try:
         import _lzma
 
         _lzma.FORMAT_XZ
         return True
     except ImportError:
         return False
 
 
 @check("bash", "bash shell")
 def has_bash():
     return matchoutput("bash -c 'echo hi'", b'^hi$')
 
 
 @check("bigendian", "big-endian CPU")
 def has_bigendian():
     return sys.byteorder == 'big'