configitems: move blackbox's config items to the new configitems.toml

In order for the Rust code to gain access to default values of in-core
extensions that have a Rust implementation, we need to centralize them
alongside the core items declarations.

This is the first and so far only one of the extensions that have gained
Rust support, I don't think it's worth the churn to move the rest of the
extension's configitems yet.

hgext/blackbox.py

@@ -1,242 +1,207 b''
 # blackbox.py - log repository events to a file for post-mortem debugging
 #
 # Copyright 2010 Nicolas Dumazet
 # 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.
 
 """log repository events to a blackbox for debugging
 
 Logs event information to .hg/blackbox.log to help debug and diagnose problems.
 The events that get logged can be configured via the blackbox.track and
 blackbox.ignore config keys.
 
 Examples::
 
   [blackbox]
   track = *
   ignore = pythonhook
   # dirty is *EXPENSIVE* (slow);
   # each log entry indicates `+` if the repository is dirty, like :hg:`id`.
   dirty = True
   # record the source of log messages
   logsource = True
 
   [blackbox]
   track = command, commandfinish, commandexception, exthook, pythonhook
 
   [blackbox]
   track = incoming
 
   [blackbox]
   # limit the size of a log file
   maxsize = 1.5 MB
   # rotate up to N log files when the current one gets too big
   maxfiles = 3
 
   [blackbox]
   # Include microseconds in log entries with %f (see Python function
   # datetime.datetime.strftime)
   date-format = %Y-%m-%d @ %H:%M:%S.%f
 
 """
 
 
 import re
 
 from mercurial.i18n import _
 from mercurial.node import hex
 
 from mercurial import (
     encoding,
     loggingutil,
     registrar,
 )
 from mercurial.utils import (
     dateutil,
     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)
 
-configtable = {}
-configitem = registrar.configitem(configtable)
-
-configitem(
-    b'blackbox',
-    b'dirty',
-    default=False,
-)
-configitem(
-    b'blackbox',
-    b'maxsize',
-    default=b'1 MB',
-)
-configitem(
-    b'blackbox',
-    b'logsource',
-    default=False,
-)
-configitem(
-    b'blackbox',
-    b'maxfiles',
-    default=7,
-)
-configitem(
-    b'blackbox',
-    b'track',
-    default=lambda: [b'*'],
-)
-configitem(
-    b'blackbox',
-    b'ignore',
-    default=lambda: [b'chgserver', b'cmdserver', b'extension'],
-)
-configitem(b'blackbox', b'date-format', default=b'')
-
 _lastlogger = loggingutil.proxylogger()
 
 
 class blackboxlogger:
     def __init__(self, ui, repo):
         self._repo = repo
         self._trackedevents = set(ui.configlist(b'blackbox', b'track'))
         self._ignoredevents = set(ui.configlist(b'blackbox', b'ignore'))
         self._maxfiles = ui.configint(b'blackbox', b'maxfiles')
         self._maxsize = ui.configbytes(b'blackbox', b'maxsize')
         self._inlog = False
 
     def tracked(self, event):
         return (
             b'*' in self._trackedevents and event not in self._ignoredevents
         ) or event in self._trackedevents
 
     def log(self, ui, event, msg, opts):
         # self._log() -> ctx.dirty() may create new subrepo instance, which
         # ui is derived from baseui. So the recursion guard in ui.log()
         # doesn't work as it's local to the ui instance.
         if self._inlog:
             return
         self._inlog = True
         try:
             self._log(ui, event, msg, opts)
         finally:
             self._inlog = False
 
     def _log(self, ui, event, msg, opts):
         default = ui.configdate(b'devel', b'default-date')
         dateformat = ui.config(b'blackbox', b'date-format')
         if dateformat:
             date = dateutil.datestr(default, dateformat)
         else:
             # We want to display milliseconds (more precision seems
             # unnecessary).  Since %.3f is not supported, use %f and truncate
             # microseconds.
             date = dateutil.datestr(default, b'%Y-%m-%d %H:%M:%S.%f')[:-3]
         user = procutil.getuser()
         pid = b'%d' % procutil.getpid()
         changed = b''
         ctx = self._repo[None]
         parents = ctx.parents()
         rev = b'+'.join([hex(p.node()) for p in parents])
         if ui.configbool(b'blackbox', b'dirty') and ctx.dirty(
             missing=True, merge=False, branch=False
         ):
             changed = b'+'
         if ui.configbool(b'blackbox', b'logsource'):
             src = b' [%s]' % event
         else:
             src = b''
         try:
             fmt = b'%s %s @%s%s (%s)%s> %s'
             args = (date, user, rev, changed, pid, src, msg)
             with loggingutil.openlogfile(
                 ui,
                 self._repo.vfs,
                 name=b'blackbox.log',
                 maxfiles=self._maxfiles,
                 maxsize=self._maxsize,
             ) as fp:
                 fp.write(fmt % args)
         except (IOError, OSError) as err:
             # deactivate this to avoid failed logging again
             self._trackedevents.clear()
             ui.debug(
                 b'warning: cannot write to blackbox.log: %s\n'
                 % encoding.strtolocal(err.strerror)
             )
             return
         _lastlogger.logger = self
 
 
 def uipopulate(ui):
     ui.setlogger(b'blackbox', _lastlogger)
 
 
 def reposetup(ui, repo):
     # During 'hg pull' a httppeer repo is created to represent the remote repo.
     # It doesn't have a .hg directory to put a blackbox in, so we don't do
     # the blackbox setup for it.
     if not repo.local():
         return
 
     # Since blackbox.log is stored in the repo directory, the logger should be
     # instantiated per repository.
     logger = blackboxlogger(ui, repo)
     ui.setlogger(b'blackbox', logger)
 
     # Set _lastlogger even if ui.log is not called. This gives blackbox a
     # fallback place to log
     if _lastlogger.logger is None:
         _lastlogger.logger = logger
 
     repo._wlockfreeprefix.add(b'blackbox.log')
 
 
 @command(
     b'blackbox',
     [
         (b'l', b'limit', 10, _(b'the number of events to show')),
     ],
     _(b'hg blackbox [OPTION]...'),
     helpcategory=command.CATEGORY_MAINTENANCE,
     helpbasic=True,
 )
 def blackbox(ui, repo, *revs, **opts):
     """view the recent repository events"""
 
     if not repo.vfs.exists(b'blackbox.log'):
         return
 
     limit = opts.get('limit')
     assert limit is not None  # help pytype
 
     fp = repo.vfs(b'blackbox.log', b'r')
     lines = fp.read().split(b'\n')
 
     count = 0
     output = []
     for line in reversed(lines):
         if count >= limit:
             break
 
         # count the commands by matching lines like:
         # 2013/01/23 19:13:36 root>
         # 2013/01/23 19:13:36 root (1234)>
         # 2013/01/23 19:13:36 root @0000000000000000000000000000000000000000 (1234)>
         # 2013-01-23 19:13:36.000 root @0000000000000000000000000000000000000000 (1234)>
         if re.match(
             br'^\d{4}[-/]\d{2}[-/]\d{2} \d{2}:\d{2}:\d{2}(.\d*)? .*> .*', line
         ):
             count += 1
         output.append(line)
 
     ui.status(b'\n'.join(reversed(output)))

mercurial/configitems.py

@@ -1,212 +1,214 b''
 # configitems.py - centralized declaration of configuration option
 #
 #  Copyright 2017 Pierre-Yves David <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import functools
 import re
 
 from .utils import resourceutil
 
 from . import (
     encoding,
     error,
 )
 
 try:
     import tomllib  # pytype: disable=import-error
 
     tomllib.load  # trigger lazy import
 except ModuleNotFoundError:
     # Python <3.11 compat
     from .thirdparty import tomli as tomllib
 
 
 def loadconfigtable(ui, extname, configtable):
     """update config item known to the ui with the extension ones"""
     for section, items in sorted(configtable.items()):
         knownitems = ui._knownconfig.setdefault(section, itemregister())
         knownkeys = set(knownitems)
         newkeys = set(items)
         for key in sorted(knownkeys & newkeys):
             msg = b"extension '%s' overwrites config item '%s.%s'"
             msg %= (extname, section, key)
             ui.develwarn(msg, config=b'warn-config')
 
         knownitems.update(items)
 
 
 class configitem:
     """represent a known config item
 
     :section: the official config section where to find this item,
        :name: the official name within the section,
     :default: default value for this item,
     :alias: optional list of tuples as alternatives,
     :generic: this is a generic definition, match name using regular expression.
     """
 
     def __init__(
         self,
         section,
         name,
         default=None,
         alias=(),
         generic=False,
         priority=0,
         experimental=False,
         documentation="",
+        in_core_extension=None,
     ):
         self.section = section
         self.name = name
         self.default = default
         self.documentation = documentation
         self.alias = list(alias)
         self.generic = generic
         self.priority = priority
         self.experimental = experimental
         self._re = None
+        self.in_core_extension = in_core_extension
         if generic:
             self._re = re.compile(self.name)
 
 
 class itemregister(dict):
     """A specialized dictionary that can handle wild-card selection"""
 
     def __init__(self):
         super(itemregister, self).__init__()
         self._generics = set()
 
     def update(self, other):
         super(itemregister, self).update(other)
         self._generics.update(other._generics)
 
     def __setitem__(self, key, item):
         super(itemregister, self).__setitem__(key, item)
         if item.generic:
             self._generics.add(item)
 
     def get(self, key):
         baseitem = super(itemregister, self).get(key)
         if baseitem is not None and not baseitem.generic:
             return baseitem
 
         # search for a matching generic item
         generics = sorted(self._generics, key=(lambda x: (x.priority, x.name)))
         for item in generics:
             # we use 'match' instead of 'search' to make the matching simpler
             # for people unfamiliar with regular expression. Having the match
             # rooted to the start of the string will produce less surprising
             # result for user writing simple regex for sub-attribute.
             #
             # For example using "color\..*" match produces an unsurprising
             # result, while using search could suddenly match apparently
             # unrelated configuration that happens to contains "color."
             # anywhere. This is a tradeoff where we favor requiring ".*" on
             # some match to avoid the need to prefix most pattern with "^".
             # The "^" seems more error prone.
             if item._re.match(key):
                 return item
 
         return None
 
 
 def sanitize_item(item):
     """Apply the transformations that are encoded on top of the pure data"""
 
     # Set the special defaults
     default_type_key = "default-type"
     default_type = item.pop(default_type_key, None)
     if default_type == "dynamic":
         item["default"] = dynamicdefault
     elif default_type == "list_type":
         item["default"] = list
     elif default_type == "lambda":
         assert isinstance(item["default"], list)
         default = [e.encode() for e in item["default"]]
         item["default"] = lambda: default
     elif default_type == "lazy_module":
         item["default"] = lambda: encoding.encoding
     else:
         if default_type is not None:
             msg = "invalid default config type %r for '%s.%s'"
             msg %= (default_type, item["section"], item["name"])
             raise error.ProgrammingError(msg)
 
     # config expects bytes
     alias = item.get("alias")
     if alias:
         item["alias"] = [(k.encode(), v.encode()) for (k, v) in alias]
     if isinstance(item.get("default"), str):
         item["default"] = item["default"].encode()
     item["section"] = item["section"].encode()
     item["name"] = item["name"].encode()
 
 
 def read_configitems_file():
     """Returns the deserialized TOML structure from the configitems file"""
     with resourceutil.open_resource(b"mercurial", b"configitems.toml") as fp:
         return tomllib.load(fp)
 
 
 def configitems_from_toml(items):
     """Register the configitems from the *deserialized* toml file"""
     for item in items["items"]:
         sanitize_item(item)
         coreconfigitem(**item)
 
     templates = items["templates"]
 
     for application in items["template-applications"]:
         template_items = templates[application["template"]]
 
         for template_item in template_items:
             item = template_item.copy()
             prefix = application.get("prefix", "")
             item["section"] = application["section"]
             if prefix:
                 item["name"] = f'{prefix}.{item["suffix"]}'
             else:
                 item["name"] = item["suffix"]
 
             sanitize_item(item)
             item.pop("suffix", None)
             coreconfigitem(**item)
 
 
 def import_configitems_from_file():
     as_toml = read_configitems_file()
     configitems_from_toml(as_toml)
 
 
 coreitems = {}
 
 
 def _register(configtable, *args, **kwargs):
     item = configitem(*args, **kwargs)
     section = configtable.setdefault(item.section, itemregister())
     if item.name in section:
         msg = b"duplicated config item registration for '%s.%s'"
         raise error.ProgrammingError(msg % (item.section, item.name))
     section[item.name] = item
 
 
 # special value for case where the default is derived from other values
 dynamicdefault = object()
 
 # Registering actual config items
 
 
 def getitemregister(configtable):
     f = functools.partial(_register, configtable)
     # export pseudo enum as configitem.*
     f.dynamicdefault = dynamicdefault
     return f
 
 
 coreconfigitem = getitemregister(coreitems)
 
 import_configitems_from_file()

mercurial/configitems.toml

@@ -1,2759 +1,2807 b''
 # configitems.toml - centralized declaration of configuration options
 #
 # This file contains declarations of the core Mercurial configuration options.
 #
 # # Structure
 #
 # items: array of config items
 # templates: mapping of template name to template declaration
 # template-applications: array of template applications
 #
 # # Elements
 #
 # ## Item
 #
 # Declares a core Mercurial option.
 #
 # - section: string (required)
 # - name: string (required)
 # - default-type: boolean, changes how `default` is read
 # - default: any
 # - generic: boolean
 # - priority: integer, only if `generic` is true
 # - alias: list of 2-tuples of strings
 # - experimental: boolean
 # - documentation: string
+# - in_core_extension: string
 #
 # ## Template
 #
 # Declares a group of options to be re-used for multiple sections.
 #
 # - all the same fields as `Item`, except `section` and `name`
 # - `suffix` (string, required)
 #
 # ## Template applications
 #
 # Uses a `Template` to instanciate its options in a given section.
 #
 # - template: string (required, must match a `Template` name)
 # - section: string (required)
 
 [[items]]
 section = "alias"
 name = ".*"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "auth"
 name = "cookiefile"
 
 # bookmarks.pushing: internal hack for discovery
 [[items]]
 section = "bookmarks"
 name = "pushing"
 default-type = "list_type"
 
 # bundle.mainreporoot: internal hack for bundlerepo
 [[items]]
 section = "bundle"
 name = "mainreporoot"
 default = ""
 
 [[items]]
 section = "censor"
 name = "policy"
 default = "abort"
 experimental = true
 
 [[items]]
 section = "chgserver"
 name = "idletimeout"
 default = 3600
 
 [[items]]
 section = "chgserver"
 name = "skiphash"
 default = false
 
 [[items]]
 section = "cmdserver"
 name = "log"
 
 [[items]]
 section = "cmdserver"
 name = "max-log-files"
 default = 7
 
 [[items]]
 section = "cmdserver"
 name = "max-log-size"
 default = "1 MB"
 
 [[items]]
 section = "cmdserver"
 name = "max-repo-cache"
 default = 0
 experimental = true
 
 [[items]]
 section = "cmdserver"
 name = "message-encodings"
 default-type = "list_type"
 
 [[items]]
 section = "cmdserver"
 name = "shutdown-on-interrupt"
 default = true
 
 [[items]]
 section = "cmdserver"
 name = "track-log"
 default-type = "lambda"
 default = [ "chgserver", "cmdserver", "repocache",]
 
 [[items]]
 section = "color"
 name = ".*"
 generic = true
 
 [[items]]
 section = "color"
 name = "mode"
 default = "auto"
 
 [[items]]
 section = "color"
 name = "pagermode"
 default-type = "dynamic"
 
 [[items]]
 section = "command-templates"
 name = "graphnode"
 alias = [["ui", "graphnodetemplate"]]
 
 [[items]]
 section = "command-templates"
 name = "log"
 alias = [["ui", "logtemplate"]]
 
 [[items]]
 section = "command-templates"
 name = "mergemarker"
 default = '{node|short} {ifeq(tags, "tip", "", ifeq(tags, "", "", "{tags} "))}{if(bookmarks, "{bookmarks} ")}{ifeq(branch, "default", "", "{branch} ")}- {author|user}: {desc|firstline}'
 alias = [["ui", "mergemarkertemplate"]]
 
 [[items]]
 section = "command-templates"
 name = "oneline-summary"
 
 [[items]]
 section = "command-templates"
 name = "oneline-summary.*"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "command-templates"
 name = "pre-merge-tool-output"
 alias = [["ui", "pre-merge-tool-output-template"]]
 
 [[items]]
 section = "commands"
 name = "commit.post-status"
 default = false
 
 [[items]]
 section = "commands"
 name = "grep.all-files"
 default = false
 experimental = true
 
 [[items]]
 section = "commands"
 name = "merge.require-rev"
 default = false
 
 [[items]]
 section = "commands"
 name = "push.require-revs"
 default = false
 
 # Rebase related configuration moved to core because other extension are doing
 # strange things. For example, shelve import the extensions to reuse some bit
 # without formally loading it.
 [[items]]
 section = "commands"
 name = "rebase.requiredest"
 default = false
 
 [[items]]
 section = "commands"
 name = "resolve.confirm"
 default = false
 
 [[items]]
 section = "commands"
 name = "resolve.explicit-re-merge"
 default = false
 
 [[items]]
 section = "commands"
 name = "resolve.mark-check"
 default = "none"
 
 [[items]]
 section = "commands"
 name = "show.aliasprefix"
 default-type = "list_type"
 
 [[items]]
 section = "commands"
 name = "status.relative"
 default = false
 
 [[items]]
 section = "commands"
 name = "status.skipstates"
 default = []
 experimental = true
 
 [[items]]
 section = "commands"
 name = "status.terse"
 default = ""
 
 [[items]]
 section = "commands"
 name = "status.verbose"
 default = false
 
 [[items]]
 section = "commands"
 name = "update.check"
 
 [[items]]
 section = "commands"
 name = "update.requiredest"
 default = false
 
 [[items]]
 section = "committemplate"
 name = ".*"
 generic = true
 
 [[items]]
 section = "convert"
 name = "bzr.saverev"
 default = true
 
 [[items]]
 section = "convert"
 name = "cvsps.cache"
 default = true
 
 [[items]]
 section = "convert"
 name = "cvsps.fuzz"
 default = 60
 
 [[items]]
 section = "convert"
 name = "cvsps.logencoding"
 
 [[items]]
 section = "convert"
 name = "cvsps.mergefrom"
 
 [[items]]
 section = "convert"
 name = "cvsps.mergeto"
 
 [[items]]
 section = "convert"
 name = "git.committeractions"
 default-type = "lambda"
 default = [ "messagedifferent",]
 
 [[items]]
 section = "convert"
 name = "git.extrakeys"
 default-type = "list_type"
 
 [[items]]
 section = "convert"
 name = "git.findcopiesharder"
 default = false
 
 [[items]]
 section = "convert"
 name = "git.remoteprefix"
 default = "remote"
 
 [[items]]
 section = "convert"
 name = "git.renamelimit"
 default = 400
 
 [[items]]
 section = "convert"
 name = "git.saverev"
 default = true
 
 [[items]]
 section = "convert"
 name = "git.similarity"
 default = 50
 
 [[items]]
 section = "convert"
 name = "git.skipsubmodules"
 default = false
 
 [[items]]
 section = "convert"
 name = "hg.clonebranches"
 default = false
 
 [[items]]
 section = "convert"
 name = "hg.ignoreerrors"
 default = false
 
 [[items]]
 section = "convert"
 name = "hg.preserve-hash"
 default = false
 
 [[items]]
 section = "convert"
 name = "hg.revs"
 
 [[items]]
 section = "convert"
 name = "hg.saverev"
 default = false
 
 [[items]]
 section = "convert"
 name = "hg.sourcename"
 
 [[items]]
 section = "convert"
 name = "hg.startrev"
 
 [[items]]
 section = "convert"
 name = "hg.tagsbranch"
 default = "default"
 
 [[items]]
 section = "convert"
 name = "hg.usebranchnames"
 default = true
 
 [[items]]
 section = "convert"
 name = "ignoreancestorcheck"
 default = false
 experimental = true
 
 [[items]]
 section = "convert"
 name = "localtimezone"
 default = false
 
 [[items]]
 section = "convert"
 name = "p4.encoding"
 default-type = "dynamic"
 
 [[items]]
 section = "convert"
 name = "p4.startrev"
 default = 0
 
 [[items]]
 section = "convert"
 name = "skiptags"
 default = false
 
 [[items]]
 section = "convert"
 name = "svn.branches"
 
 [[items]]
 section = "convert"
 name = "svn.dangerous-set-commit-dates"
 default = false
 
 [[items]]
 section = "convert"
 name = "svn.debugsvnlog"
 default = true
 
 [[items]]
 section = "convert"
 name = "svn.startrev"
 default = 0
 
 [[items]]
 section = "convert"
 name = "svn.tags"
 
 [[items]]
 section = "convert"
 name = "svn.trunk"
 
 [[items]]
 section = "debug"
 name = "bundling-stats"
 default = false
 documentation = "Display extra information about the bundling process."
 
 [[items]]
 section = "debug"
 name = "dirstate.delaywrite"
 default = 0
 
 [[items]]
 section = "debug"
 name = "revlog.debug-delta"
 default = false
 
 [[items]]
 section = "debug"
 name = "revlog.verifyposition.changelog"
 default = ""
 
 [[items]]
 section = "debug"
 name = "unbundling-stats"
 default = false
 documentation = "Display extra information about the unbundling process."
 
 [[items]]
 section = "defaults"
 name = ".*"
 generic = true
 
 [[items]]
 section = "devel"
 name = "all-warnings"
 default = false
 
 [[items]]
 section = "devel"
 name = "bundle.delta"
 default = ""
 
 [[items]]
 section = "devel"
 name = "bundle2.debug"
 default = false
 
 [[items]]
 section = "devel"
 name = "cache-vfs"
 
 [[items]]
 section = "devel"
 name = "check-locks"
 default = false
 
 [[items]]
 section = "devel"
 name = "check-relroot"
 default = false
 
 [[items]]
 section = "devel"
 name = "copy-tracing.multi-thread"
 default = true
 
 # Track copy information for all files, not just "added" ones (very slow)
 [[items]]
 section = "devel"
 name = "copy-tracing.trace-all-files"
 default = false
 
 [[items]]
 section = "devel"
 name = "debug.abort-update"
 default = false
 documentation = """If true, then any merge with the working copy, \
 e.g. [hg update], will be aborted after figuring out what needs to be done, \
 but before spawning the parallel worker."""
 
 [[items]]
 section = "devel"
 name = "debug.copies"
 default = false
 
 [[items]]
 section = "devel"
 name = "debug.extensions"
 default = false
 
 [[items]]
 section = "devel"
 name = "debug.peer-request"
 default = false
 
 [[items]]
 section = "devel"
 name = "debug.repo-filters"
 default = false
 
 [[items]]
 section = "devel"
 name = "default-date"
 
 [[items]]
 section = "devel"
 name = "deprec-warn"
 default = false
 
 # possible values:
 # - auto (the default)
 # - force-append
 # - force-new
 [[items]]
 section = "devel"
 name = "dirstate.v2.data_update_mode"
 default = "auto"
 
 [[items]]
 section = "devel"
 name = "disableloaddefaultcerts"
 default = false
 
 [[items]]
 section = "devel"
 name = "discovery.exchange-heads"
 default = true
 documentation = """If false, the discovery will not start with remote \
 head fetching and local head querying."""
 
 [[items]]
 section = "devel"
 name = "discovery.grow-sample"
 default = true
 documentation = """If false, the sample size used in set discovery \
 will not be increased through the process."""
 
 [[items]]
 section = "devel"
 name = "discovery.grow-sample.dynamic"
 default = true
 documentation = """If true, the default, the sample size is adapted to the shape \
 of the undecided set. It is set to the max of:
 `<target-size>, len(roots(undecided)), len(heads(undecided))`"""
 
 [[items]]
 section = "devel"
 name = "discovery.grow-sample.rate"
 default = 1.05
 documentation = "Controls the rate at which the sample grows."
 
 [[items]]
 section = "devel"
 name = "discovery.randomize"
 default = true
 documentation = """If false, random samplings during discovery are deterministic. \
 It is meant for integration tests."""
 
 [[items]]
 section = "devel"
 name = "discovery.sample-size"
 default = 200
 documentation = "Controls the initial size of the discovery sample."
 
 [[items]]
 section = "devel"
 name = "discovery.sample-size.initial"
 default = 100
 documentation = "Controls the initial size of the discovery for initial change."
 
 [[items]]
 section = "devel"
 name = "legacy.exchange"
 default-type = "list_type"
 
 [[items]]
 section = "devel"
 name = "persistent-nodemap"
 default = false
 documentation = """When true, revlogs use a special reference version of the \
 nodemap, that is not performant but is "known" to behave properly."""
 
 [[items]]
 section = "devel"
 name = "server-insecure-exact-protocol"
 default = ""
 
 [[items]]
 section = "devel"
 name = "servercafile"
 default = ""
 
 [[items]]
 section = "devel"
 name = "serverexactprotocol"
 default = ""
 
 [[items]]
 section = "devel"
 name = "serverrequirecert"
 default = false
 
 [[items]]
 section = "devel"
 name = "strip-obsmarkers"
 default = true
 
 [[items]]
 section = 'devel'
 name = 'sync.status.pre-dirstate-write-file'
 documentation = """
 Makes the status algorithm wait for the existence of this file \
 (or until a timeout of `devel.sync.status.pre-dirstate-write-file-timeout` \
 seconds) before taking the lock and writing the dirstate. \
 Status signals that it's ready to wait by creating a file \
 with the same name + `.waiting`. \
 Useful when testing race conditions."""
 
 [[items]]
 section = 'devel'
 name = 'sync.status.pre-dirstate-write-file-timeout'
 default=2
 
 [[items]]
 section = 'devel'
 name = 'sync.dirstate.post-docket-read-file'
 
 [[items]]
 section = 'devel'
 name = 'sync.dirstate.post-docket-read-file-timeout'
 default=2
 
 [[items]]
 section = 'devel'
 name = 'sync.dirstate.pre-read-file'
 
 [[items]]
 section = 'devel'
 name = 'sync.dirstate.pre-read-file-timeout'
 default=2
 
 [[items]]
 section = "devel"
 name = "user.obsmarker"
 
 [[items]]
 section = "devel"
 name = "warn-config"
 
 [[items]]
 section = "devel"
 name = "warn-config-default"
 
 [[items]]
 section = "devel"
 name = "warn-config-unknown"
 
 [[items]]
 section = "devel"
 name = "warn-empty-changegroup"
 default = false
 
 [[items]]
 section = "diff"
 name = "merge"
 default = false
 experimental = true
 
 [[items]]
 section = "email"
 name = "bcc"
 
 [[items]]
 section = "email"
 name = "cc"
 
 [[items]]
 section = "email"
 name = "charsets"
 default-type = "list_type"
 
 [[items]]
 section = "email"
 name = "from"
 
 [[items]]
 section = "email"
 name = "method"
 default = "smtp"
 
 [[items]]
 section = "email"
 name = "reply-to"
 
 [[items]]
 section = "email"
 name = "to"
 
 [[items]]
 section = "experimental"
 name = "archivemetatemplate"
 default-type = "dynamic"
 
 [[items]]
 section = "experimental"
 name = "auto-publish"
 default = "publish"
 
 [[items]]
 section = "experimental"
 name = "bundle-phases"
 default = false
 
 [[items]]
 section = "experimental"
 name = "bundle2-advertise"
 default = true
 
 [[items]]
 section = "experimental"
 name = "bundle2-output-capture"
 default = false
 
 [[items]]
 section = "experimental"
 name = "bundle2.pushback"
 default = false
 
 [[items]]
 section = "experimental"
 name = "bundle2lazylocking"
 default = false
 
 [[items]]
 section = "experimental"
 name = "bundlecomplevel"
 
 [[items]]
 section = "experimental"
 name = "bundlecomplevel.bzip2"
 
 [[items]]
 section = "experimental"
 name = "bundlecomplevel.gzip"
 
 [[items]]
 section = "experimental"
 name = "bundlecomplevel.none"
 
 [[items]]
 section = "experimental"
 name = "bundlecomplevel.zstd"
 
 [[items]]
 section = "experimental"
 name = "bundlecompthreads"
 
 [[items]]
 section = "experimental"
 name = "bundlecompthreads.bzip2"
 
 [[items]]
 section = "experimental"
 name = "bundlecompthreads.gzip"
 
 [[items]]
 section = "experimental"
 name = "bundlecompthreads.none"
 
 [[items]]
 section = "experimental"
 name = "bundlecompthreads.zstd"
 
 [[items]]
 section = "experimental"
 name = "changegroup3"
 default = true
 
 [[items]]
 section = "experimental"
 name = "changegroup4"
 default = false
 
 # might remove rank configuration once the computation has no impact
 [[items]]
 section = "experimental"
 name = "changelog-v2.compute-rank"
 default = true
 
 [[items]]
 section = "experimental"
 name = "cleanup-as-archived"
 default = false
 
 [[items]]
 section = "experimental"
 name = "clientcompressionengines"
 default-type = "list_type"
 
 [[items]]
 section = "experimental"
 name = "copies.read-from"
 default = "filelog-only"
 
 [[items]]
 section = "experimental"
 name = "copies.write-to"
 default = "filelog-only"
 
 [[items]]
 section = "experimental"
 name = "copytrace"
 default = "on"
 
 [[items]]
 section = "experimental"
 name = "copytrace.movecandidateslimit"
 default = 100
 
 [[items]]
 section = "experimental"
 name = "copytrace.sourcecommitlimit"
 default = 100
 
 [[items]]
 section = "experimental"
 name = "crecordtest"
 
 [[items]]
 section = "experimental"
 name = "directaccess"
 default = false
 
 [[items]]
 section = "experimental"
 name = "directaccess.revnums"
 default = false
 
 [[items]]
 section = "experimental"
 name = "editortmpinhg"
 default = false
 
 [[items]]
 section = "experimental"
 name = "evolution"
 default-type = "list_type"
 
 [[items]]
 section = "experimental"
 name = "evolution.allowdivergence"
 default = false
 alias = [["experimental", "allowdivergence"]]
 
 [[items]]
 section = "experimental"
 name = "evolution.allowunstable"
 
 [[items]]
 section = "experimental"
 name = "evolution.bundle-obsmarker"
 default = false
 
 [[items]]
 section = "experimental"
 name = "evolution.bundle-obsmarker:mandatory"
 default = true
 
 [[items]]
 section = "experimental"
 name = "evolution.createmarkers"
 
 [[items]]
 section = "experimental"
 name = "evolution.effect-flags"
 default = true
 alias = [["experimental", "effect-flags"]]
 
 [[items]]
 section = "experimental"
 name = "evolution.exchange"
 
 [[items]]
 section = "experimental"
 name = "evolution.report-instabilities"
 default = true
 
 [[items]]
 section = "experimental"
 name = "evolution.track-operation"
 default = true
 
 [[items]]
 section = "experimental"
 name = "exportableenviron"
 default-type = "list_type"
 
 [[items]]
 section = "experimental"
 name = "extendedheader.index"
 
 [[items]]
 section = "experimental"
 name = "extendedheader.similarity"
 default = false
 
 [[items]]
 section = "experimental"
 name = "extra-filter-revs"
 documentation = """Repo-level config to prevent a revset from being visible.
 The target use case is to use `share` to expose different subsets of the same \
 repository, especially server side. See also `server.view`."""
 
 [[items]]
 section = "experimental"
 name = "graphshorten"
 default = false
 
 [[items]]
 section = "experimental"
 name = "graphstyle.grandparent"
 default-type = "dynamic"
 
 [[items]]
 section = "experimental"
 name = "graphstyle.missing"
 default-type = "dynamic"
 
 [[items]]
 section = "experimental"
 name = "graphstyle.parent"
 default-type = "dynamic"
 
 [[items]]
 section = "experimental"
 name = "hook-track-tags"
 default = false
 
 [[items]]
 section = "experimental"
 name = "httppostargs"
 default = false
 
 [[items]]
 section = "experimental"
 name = "log.topo"
 default = false
 
 [[items]]
 section = "experimental"
 name = "maxdeltachainspan"
 default = -1
 
 [[items]]
 section = "experimental"
 name = "merge-track-salvaged"
 default = false
 documentation = """Tracks files which were undeleted (merge might delete them \
 but we explicitly kept/undeleted them) and creates new filenodes for them."""
 
 [[items]]
 section = "experimental"
 name = "merge.checkpathconflicts"
 default = false
 
 [[items]]
 section = "experimental"
 name = "mmapindexthreshold"
 
 [[items]]
 section = "experimental"
 name = "narrow"
 default = false
 
 [[items]]
 section = "experimental"
 name = "nointerrupt"
 default = false
 
 [[items]]
 section = "experimental"
 name = "nointerrupt-interactiveonly"
 default = true
 
 [[items]]
 section = "experimental"
 name = "nonnormalparanoidcheck"
 default = false
 
 [[items]]
 section = "experimental"
 name = "obsmarkers-exchange-debug"
 default = false
 
 [[items]]
 section = "experimental"
 name = "rebaseskipobsolete"
 default = true
 
 [[items]]
 section = "experimental"
 name = "remotenames"
 default = false
 
 [[items]]
 section = "experimental"
 name = "removeemptydirs"
 default = true
 
 [[items]]
 section = "experimental"
 name = "revert.interactive.select-to-keep"
 default = false
 
 [[items]]
 section = "experimental"
 name = "revisions.disambiguatewithin"
 
 [[items]]
 section = "experimental"
 name = "revisions.prefixhexnode"
 default = false
 
 # "out of experimental" todo list.
 #
 # * include management of a persistent nodemap in the main docket
 # * enforce a "no-truncate" policy for mmap safety
 #      - for censoring operation
 #      - for stripping operation
 #      - for rollback operation
 # * proper streaming (race free) of the docket file
 # * track garbage data to evemtually allow rewriting -existing- sidedata.
 # * Exchange-wise, we will also need to do something more efficient than
 #   keeping references to the affected revlogs, especially memory-wise when
 #   rewriting sidedata.
 # * introduce a proper solution to reduce the number of filelog related files.
 # * use caching for reading sidedata (similar to what we do for data).
 # * no longer set offset=0 if sidedata_size=0 (simplify cutoff computation).
 # * Improvement to consider
 #   - avoid compression header in chunk using the default compression?
 #   - forbid "inline" compression mode entirely?
 #   - split the data offset and flag field (the 2 bytes save are mostly trouble)
 #   - keep track of uncompressed -chunk- size (to preallocate memory better)
 #   - keep track of chain base or size (probably not that useful anymore)
 [[items]]
 section = "experimental"
 name = "revlogv2"
 
 [[items]]
 section = "experimental"
 name = "rust.index"
 default = false
 
 [[items]]
 section = "experimental"
 name = "server.allow-hidden-access"
 default-type = "list_type"
 
 [[items]]
 section = "experimental"
 name = "server.filesdata.recommended-batch-size"
 default = 50000
 
 [[items]]
 section = "experimental"
 name = "server.manifestdata.recommended-batch-size"
 default = 100000
 
 [[items]]
 section = "experimental"
 name = "server.stream-narrow-clones"
 default = false
 
 [[items]]
 section = "experimental"
 name = "single-head-per-branch"
 default = false
 
 [[items]]
 section = "experimental"
 name = "single-head-per-branch:account-closed-heads"
 default = false
 
 [[items]]
 section = "experimental"
 name = "single-head-per-branch:public-changes-only"
 default = false
 
 [[items]]
 section = "experimental"
 name = "sparse-read"
 default = false
 
 [[items]]
 section = "experimental"
 name = "sparse-read.density-threshold"
 default = 0.5
 
 [[items]]
 section = "experimental"
 name = "sparse-read.min-gap-size"
 default = "65K"
 
 [[items]]
 section = "experimental"
 name = "stream-v3"
 default = false
 
 [[items]]
 section = "experimental"
 name = "treemanifest"
 default = false
 
 [[items]]
 section = "experimental"
 name = "update.atomic-file"
 default = false
 
 [[items]]
 section = "experimental"
 name = "web.full-garbage-collection-rate"
 default = 1  # still forcing a full collection on each request
 
 [[items]]
 section = "experimental"
 name = "worker.repository-upgrade"
 default = false
 
 [[items]]
 section = "experimental"
 name = "worker.wdir-get-thread-safe"
 default = false
 
 [[items]]
 section = "experimental"
 name = "xdiff"
 default = false
 
 [[items]]
 section = "extdata"
 name = ".*"
 generic = true
 
 [[items]]
 section = "extensions"
 name = "[^:]*"
 generic = true
 
 [[items]]
 section = "extensions"
 name = "[^:]*:required"
 default = false
 generic = true
 
 [[items]]
 section = "format"
 name = "bookmarks-in-store"
 default = false
 
 [[items]]
 section = "format"
 name = "chunkcachesize"
 experimental = true
 
 [[items]]
 section = "format"
 name = "dotencode"
 default = true
 
 # The interaction between the archived phase and obsolescence markers needs to
 # be sorted out before wider usage of this are to be considered.
 #
 # At the time this message is written, behavior when archiving obsolete
 # changeset differ significantly from stripping. As part of stripping, we also
 # remove the obsolescence marker associated to the stripped changesets,
 # revealing the precedecessors changesets when applicable. When archiving, we
 # don't touch the obsolescence markers, keeping everything hidden. This can
 # result in quite confusing situation for people combining exchanging draft
 # with the archived phases. As some markers needed by others may be skipped
 # during exchange.
 [[items]]
 section = "format"
 name = "exp-archived-phase"
 default = false
 experimental = true
 
 # Experimental TODOs:
 #
 # * Same as for revlogv2 (but for the reduction of the number of files)
 # * Actually computing the rank of changesets
 # * Improvement to investigate
 #   - storing .hgtags fnode
 #   - storing branch related identifier
 [[items]]
 section = "format"
 name = "exp-use-changelog-v2"
 experimental = true
 
 [[items]]
 section = "format"
 name = "exp-use-copies-side-data-changeset"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "generaldelta"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "manifestcachesize"
 experimental = true
 
 [[items]]
 section = "format"
 name = "maxchainlen"
 default-type = "dynamic"
 experimental = true
 
 [[items]]
 section = "format"
 name = "obsstore-version"
 
 [[items]]
 section = "format"
 name = "revlog-compression"
 default-type = "lambda"
 alias = [["experimental", "format.compression"]]
 default = [ "zstd", "zlib",]
 
 [[items]]
 section = "format"
 name = "sparse-revlog"
 default = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-tracked-hint"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-tracked-hint.automatic-upgrade-of-mismatching-repositories"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-tracked-hint.automatic-upgrade-of-mismatching-repositories:quiet"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-tracked-hint.version"
 default = 1
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-v2"
 default = false
 alias = [["format", "exp-rc-dirstate-v2"]]
 experimental = true
 documentation = """Enables dirstate-v2 format *when creating a new repository*.
 Which format to use for existing repos is controlled by `.hg/requires`."""
 
 [[items]]
 section = "format"
 name = "use-dirstate-v2.automatic-upgrade-of-mismatching-repositories"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-v2.automatic-upgrade-of-mismatching-repositories:quiet"
 default = false
 experimental = true
 
 # Having this on by default means we are confident about the scaling of phases.
 # This is not garanteed to be the case at the time this message is written.
 [[items]]
 section = "format"
 name = "use-internal-phase"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-persistent-nodemap"
 default-type = "dynamic"
 
 [[items]]
 section = "format"
 name = "use-share-safe"
 default = true
 
 [[items]]
 section = "format"
 name = "use-share-safe.automatic-upgrade-of-mismatching-repositories"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-share-safe.automatic-upgrade-of-mismatching-repositories:quiet"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "usefncache"
 default = true
 
 [[items]]
 section = "format"
 name = "usegeneraldelta"
 default = true
 
 [[items]]
 section = "format"
 name = "usestore"
 default = true
 
 [[items]]
 section = "fsmonitor"
 name = "warn_update_file_count"
 default = 50000
 
 [[items]]
 section = "fsmonitor"
 name = "warn_update_file_count_rust"
 default = 400000
 
 [[items]]
 section = "fsmonitor"
 name = "warn_when_unused"
 default = true
 
 [[items]]
 section = "help"
 name = 'hidden-command\..*'
 default = false
 generic = true
 
 [[items]]
 section = "help"
 name = 'hidden-topic\..*'
 default = false
 generic = true
 
 [[items]]
 section = "hgweb-paths"
 name = ".*"
 default-type = "list_type"
 generic = true
 
 [[items]]
 section = "hooks"
 name = ".*:run-with-plain"
 default = true
 generic = true
 
 [[items]]
 section = "hooks"
 name = "[^:]*"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "hostfingerprints"
 name = ".*"
 default-type = "list_type"
 generic = true
 
 [[items]]
 section = "hostsecurity"
 name = ".*:ciphers$"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "hostsecurity"
 name = ".*:fingerprints$"
 default-type = "list_type"
 generic = true
 
 [[items]]
 section = "hostsecurity"
 name = ".*:minimumprotocol$"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "hostsecurity"
 name = ".*:verifycertsfile$"
 generic = true
 
 [[items]]
 section = "hostsecurity"
 name = "ciphers"
 
 [[items]]
 section = "hostsecurity"
 name = "minimumprotocol"
 default-type = "dynamic"
 
 [[items]]
 section = "http"
 name = "timeout"
 
 [[items]]
 section = "http_proxy"
 name = "always"
 default = false
 
 [[items]]
 section = "http_proxy"
 name = "host"
 
 [[items]]
 section = "http_proxy"
 name = "no"
 default-type = "list_type"
 
 [[items]]
 section = "http_proxy"
 name = "passwd"
 
 [[items]]
 section = "http_proxy"
 name = "user"
 
 [[items]]
 section = "logtoprocess"
 name = "command"
 
 [[items]]
 section = "logtoprocess"
 name = "commandexception"
 
 [[items]]
 section = "logtoprocess"
 name = "commandfinish"
 
 [[items]]
 section = "logtoprocess"
 name = "develwarn"
 
 [[items]]
 section = "logtoprocess"
 name = "uiblocked"
 
 [[items]]
 section = "merge"
 name = "checkignored"
 default = "abort"
 
 [[items]]
 section = "merge"
 name = "checkunknown"
 default = "abort"
 
 [[items]]
 section = "merge"
 name = "disable-partial-tools"
 default = false
 experimental = true
 
 [[items]]
 section = "merge"
 name = "followcopies"
 default = true
 
 [[items]]
 section = "merge"
 name = "on-failure"
 default = "continue"
 
 [[items]]
 section = "merge"
 name = "preferancestor"
 default-type = "lambda"
 default = ["*"]
 experimental = true
 
 [[items]]
 section = "merge"
 name = "strict-capability-check"
 default = false
 
 [[items]]
 section = "merge-tools"
 name = ".*"
 generic = true
 
 [[items]]
 section = "merge-tools"
 name = '.*\.args$'
 default = "$local $base $other"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.binary$'
 default = false
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.check$'
 default-type = "list_type"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.checkchanged$'
 default = false
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.executable$'
 default-type = "dynamic"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.fixeol$'
 default = false
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.gui$'
 default = false
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.mergemarkers$'
 default = "basic"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.mergemarkertemplate$'  # take from command-templates.mergemarker
 default-type = "dynamic"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.premerge$'
 default-type = "dynamic"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.priority$'
 default = 0
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.regappend$'
 default = ""
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.symlink$'
 default = false
 generic = true
 priority = -1
 
 [[items]]
 section = "pager"
 name = "attend-.*"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "pager"
 name = "ignore"
 default-type = "list_type"
 
 [[items]]
 section = "pager"
 name = "pager"
 default-type = "dynamic"
 
 [[items]]
 section = "partial-merge-tools"
 name = ".*"
 generic = true
 experimental = true
 
 [[items]]
 section = "partial-merge-tools"
 name = '.*\.args'
 default = "$local $base $other"
 generic = true
 priority = -1
 experimental = true
 
 [[items]]
 section = "partial-merge-tools"
 name = '.*\.disable'
 default = false
 generic = true
 priority = -1
 experimental = true
 
 [[items]]
 section = "partial-merge-tools"
 name = '.*\.executable$'
 default-type = "dynamic"
 generic = true
 priority = -1
 experimental = true
 
 [[items]]
 section = "partial-merge-tools"
 name = '.*\.order'
 default = 0
 generic = true
 priority = -1
 experimental = true
 
 [[items]]
 section = "partial-merge-tools"
 name = '.*\.patterns'
 default-type = "dynamic"
 generic = true
 priority = -1
 experimental = true
 
 [[items]]
 section = "patch"
 name = "eol"
 default = "strict"
 
 [[items]]
 section = "patch"
 name = "fuzz"
 default = 2
 
 [[items]]
 section = "paths"
 name = "[^:]*"
 generic = true
 
 [[items]]
 section = "paths"
 name = ".*:bookmarks.mode"
 default = "default"
 generic = true
 
 [[items]]
 section = "paths"
 name = ".*:multi-urls"
 default = false
 generic = true
 
 [[items]]
 section = "paths"
 name = ".*:pulled-delta-reuse-policy"
 generic = true
 
 [[items]]
 section = "paths"
 name = ".*:pushrev"
 generic = true
 
 [[items]]
 section = "paths"
 name = ".*:pushurl"
 generic = true
 
 [[items]]
 section = "paths"
 name = "default"
 
 [[items]]
 section = "paths"
 name = "default-push"
 
 [[items]]
 section = "phases"
 name = "checksubrepos"
 default = "follow"
 
 [[items]]
 section = "phases"
 name = "new-commit"
 default = "draft"
 
 [[items]]
 section = "phases"
 name = "publish"
 default = true
 
 [[items]]
 section = "profiling"
 name = "enabled"
 default = false
 
 [[items]]
 section = "profiling"
 name = "format"
 default = "text"
 
 [[items]]
 section = "profiling"
 name = "freq"
 default = 1000
 
 [[items]]
 section = "profiling"
 name = "limit"
 default = 30
 
 [[items]]
 section = "profiling"
 name = "nested"
 default = 0
 
 [[items]]
 section = "profiling"
 name = "output"
 
 [[items]]
 section = "profiling"
 name = "showmax"
 default = 0.999
 
 [[items]]
 section = "profiling"
 name = "showmin"
 default-type = "dynamic"
 
 [[items]]
 section = "profiling"
 name = "showtime"
 default = true
 
 [[items]]
 section = "profiling"
 name = "sort"
 default = "inlinetime"
 
 [[items]]
 section = "profiling"
 name = "statformat"
 default = "hotpath"
 
 [[items]]
 section = "profiling"
 name = "time-track"
 default-type = "dynamic"
 
 [[items]]
 section = "profiling"
 name = "type"
 default = "stat"
 
 [[items]]
 section = "progress"
 name = "assume-tty"
 default = false
 
 [[items]]
 section = "progress"
 name = "changedelay"
 default = 1
 
 [[items]]
 section = "progress"
 name = "clear-complete"
 default = true
 
 [[items]]
 section = "progress"
 name = "debug"
 default = false
 
 [[items]]
 section = "progress"
 name = "delay"
 default = 3
 
 [[items]]
 section = "progress"
 name = "disable"
 default = false
 
 [[items]]
 section = "progress"
 name = "estimateinterval"
 default = 60.0
 
 [[items]]
 section = "progress"
 name = "format"
 default-type = "lambda"
 default = [ "topic", "bar", "number", "estimate",]
 
 [[items]]
 section = "progress"
 name = "refresh"
 default = 0.1
 
 [[items]]
 section = "progress"
 name = "width"
 default-type = "dynamic"
 
 [[items]]
 section = "pull"
 name = "confirm"
 default = false
 
 [[items]]
 section = "push"
 name = "pushvars.server"
 default = false
 
 [[items]]
 section = "rebase"
 name = "experimental.inmemory"
 default = false
 
 [[items]]
 section = "rebase"
 name = "singletransaction"
 default = false
 
 [[items]]
 section = "rebase"
 name = "store-source"
 default = true
 experimental = true
 documentation = """Controls creation of a `rebase_source` extra field during rebase.
 When false, no such field is created. This is useful e.g. for incrementally \
 converting changesets and then rebasing them onto an existing repo.
 WARNING: this is an advanced setting reserved for people who know \
 exactly what they are doing. Misuse of this setting can easily \
 result in obsmarker cycles and a vivid headache."""
 
 [[items]]
 section = "rewrite"
 name = "backup-bundle"
 default = true
 alias = [["ui", "history-editing-backup"]]
 
 [[items]]
 section = "rewrite"
 name = "empty-successor"
 default = "skip"
 experimental = true
 
 [[items]]
 section = "rewrite"
 name = "update-timestamp"
 default = false
 
 [[items]]
 section = "server"
 name = "bookmarks-pushkey-compat"
 default = true
 
 [[items]]
 section = "server"
 name = "bundle1"
 default = true
 
 [[items]]
 section = "server"
 name = "bundle1.pull"
 
 [[items]]
 section = "server"
 name = "bundle1.push"
 
 [[items]]
 section = "server"
 name = "bundle1gd"
 
 [[items]]
 section = "server"
 name = "bundle1gd.pull"
 
 [[items]]
 section = "server"
 name = "bundle1gd.push"
 
 [[items]]
 section = "server"
 name = "bundle2.stream"
 default = true
 alias = [["experimental", "bundle2.stream"]]
 
 [[items]]
 section = "server"
 name = "compressionengines"
 default-type = "list_type"
 
 [[items]]
 section = "server"
 name = "concurrent-push-mode"
 default = "check-related"
 
 [[items]]
 section = "server"
 name = "disablefullbundle"
 default = false
 
 [[items]]
 section = "server"
 name = "maxhttpheaderlen"
 default = 1024
 
 [[items]]
 section = "server"
 name = "preferuncompressed"
 default = false
 
 [[items]]
 section = "server"
 name = "pullbundle"
 default = true
 
 [[items]]
 section = "server"
 name = "streamunbundle"
 default = false
 
 [[items]]
 section = "server"
 name = "uncompressed"
 default = true
 
 [[items]]
 section = "server"
 name = "uncompressedallowsecret"
 default = false
 
 [[items]]
 section = "server"
 name = "validate"
 default = false
 
 [[items]]
 section = "server"
 name = "view"
 default = "served"
 
 [[items]]
 section = "server"
 name = "zliblevel"
 default = -1
 
 [[items]]
 section = "server"
 name = "zstdlevel"
 default = 3
 
 [[items]]
 section = "share"
 name = "pool"
 
 [[items]]
 section = "share"
 name = "poolnaming"
 default = "identity"
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-not-safe"
 default = "abort"
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-not-safe.warn"
 default = true
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-not-safe:verbose-upgrade"
 default = true
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-safe"
 default = "abort"
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-safe.warn"
 default = true
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-safe:verbose-upgrade"
 default = true
 
 [[items]]
 section = "shelve"
 name = "maxbackups"
 default = 10
 
 [[items]]
 section = "shelve"
 name = "store"
 default = "internal"
 experimental = true
 
 [[items]]
 section = "smtp"
 name = "host"
 
 [[items]]
 section = "smtp"
 name = "local_hostname"
 
 [[items]]
 section = "smtp"
 name = "password"
 
 [[items]]
 section = "smtp"
 name = "port"
 default-type = "dynamic"
 
 [[items]]
 section = "smtp"
 name = "tls"
 default = "none"
 
 [[items]]
 section = "smtp"
 name = "username"
 
 [[items]]
 section = "sparse"
 name = "missingwarning"
 default = true
 experimental = true
 
 [[items]]
 section = "storage"
 name = "dirstate-v2.slow-path"
 default = "abort"
 experimental = true  # experimental as long as format.use-dirstate-v2 is.
 
 [[items]]
 section = "storage"
 name = "new-repo-backend"
 default = "revlogv1"
 experimental = true
 
 [[items]]
 section = "storage"
 name = "revlog.delta-parent-search.candidate-group-chunk-size"
 default = 20
 
 [[items]]
 section = "storage"
 name = "revlog.issue6528.fix-incoming"
 default = true
 
 [[items]]
 section = "storage"
 name = "revlog.optimize-delta-parent-choice"
 default = true
 alias = [["format", "aggressivemergedeltas"]]
 
 [[items]]
 section = "storage"
 name = "revlog.persistent-nodemap.mmap"
 default = true
 
 [[items]]
 section = "storage"
 name = "revlog.persistent-nodemap.slow-path"
 default = "abort"
 
 [[items]]
 section = "storage"
 name = "revlog.reuse-external-delta"
 default = true
 
 [[items]]
 section = "storage"
 name = "revlog.reuse-external-delta-parent"
 documentation = """This option is true unless `format.generaldelta` is set."""
 
 [[items]]
 section = "storage"
 name = "revlog.zlib.level"
 
 [[items]]
 section = "storage"
 name = "revlog.zstd.level"
 
 [[items]]
 section = "subrepos"
 name = "allowed"
 default-type = "dynamic"  # to make backporting simpler
 
 [[items]]
 section = "subrepos"
 name = "git:allowed"
 default-type = "dynamic"
 
 [[items]]
 section = "subrepos"
 name = "hg:allowed"
 default-type = "dynamic"
 
 [[items]]
 section = "subrepos"
 name = "svn:allowed"
 default-type = "dynamic"
 
 [[items]]
 section = "templateconfig"
 name = ".*"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "templates"
 name = ".*"
 generic = true
 
 [[items]]
 section = "trusted"
 name = "groups"
 default-type = "list_type"
 
 [[items]]
 section = "trusted"
 name = "users"
 default-type = "list_type"
 
 [[items]]
 section = "ui"
 name = "_usedassubrepo"
 default = false
 
 [[items]]
 section = "ui"
 name = "allowemptycommit"
 default = false
 
 [[items]]
 section = "ui"
 name = "archivemeta"
 default = true
 
 [[items]]
 section = "ui"
 name = "askusername"
 default = false
 
 [[items]]
 section = "ui"
 name = "available-memory"
 
 [[items]]
 section = "ui"
 name = "clonebundlefallback"
 default = false
 
 [[items]]
 section = "ui"
 name = "clonebundleprefers"
 default-type = "list_type"
 
 [[items]]
 section = "ui"
 name = "clonebundles"
 default = true
 
 [[items]]
 section = "ui"
 name = "color"
 default = "auto"
 
 [[items]]
 section = "ui"
 name = "commitsubrepos"
 default = false
 
 [[items]]
 section = "ui"
 name = "debug"
 default = false
 
 [[items]]
 section = "ui"
 name = "debugger"
 
 [[items]]
 section = "ui"
 name = "detailed-exit-code"
 default = false
 experimental = true
 
 [[items]]
 section = "ui"
 name = "editor"
 default-type = "dynamic"
 
 [[items]]
 section = "ui"
 name = "fallbackencoding"
 
 [[items]]
 section = "ui"
 name = "forcecwd"
 
 [[items]]
 section = "ui"
 name = "forcemerge"
 
 [[items]]
 section = "ui"
 name = "formatdebug"
 default = false
 
 [[items]]
 section = "ui"
 name = "formatjson"
 default = false
 
 [[items]]
 section = "ui"
 name = "formatted"
 
 [[items]]
 section = "ui"
 name = "interactive"
 
 [[items]]
 section = "ui"
 name = "interface"
 
 [[items]]
 section = "ui"
 name = "interface.chunkselector"
 
 [[items]]
 section = "ui"
 name = "large-file-limit"
 default = 10485760
 
 [[items]]
 section = "ui"
 name = "logblockedtimes"
 default = false
 
 [[items]]
 section = "ui"
 name = "merge"
 
 [[items]]
 section = "ui"
 name = "mergemarkers"
 default = "basic"
 
 [[items]]
 section = "ui"
 name = "message-output"
 default = "stdio"
 
 [[items]]
 section = "ui"
 name = "nontty"
 default = false
 
 [[items]]
 section = "ui"
 name = "origbackuppath"
 
 [[items]]
 section = "ui"
 name = "paginate"
 default = true
 
 [[items]]
 section = "ui"
 name = "patch"
 
 [[items]]
 section = "ui"
 name = "portablefilenames"
 default = "warn"
 
 [[items]]
 section = "ui"
 name = "promptecho"
 default = false
 
 [[items]]
 section = "ui"
 name = "quiet"
 default = false
 
 [[items]]
 section = "ui"
 name = "quietbookmarkmove"
 default = false
 
 [[items]]
 section = "ui"
 name = "relative-paths"
 default = "legacy"
 
 [[items]]
 section = "ui"
 name = "remotecmd"
 default = "hg"
 
 [[items]]
 section = "ui"
 name = "report_untrusted"
 default = true
 
 [[items]]
 section = "ui"
 name = "rollback"
 default = true
 
 [[items]]
 section = "ui"
 name = "signal-safe-lock"
 default = true
 
 [[items]]
 section = "ui"
 name = "slash"
 default = false
 
 [[items]]
 section = "ui"
 name = "ssh"
 default = "ssh"
 
 [[items]]
 section = "ui"
 name = "ssherrorhint"
 
 [[items]]
 section = "ui"
 name = "statuscopies"
 default = false
 
 [[items]]
 section = "ui"
 name = "strict"
 default = false
 
 [[items]]
 section = "ui"
 name = "style"
 default = ""
 
 [[items]]
 section = "ui"
 name = "supportcontact"
 
 [[items]]
 section = "ui"
 name = "textwidth"
 default = 78
 
 [[items]]
 section = "ui"
 name = "timeout"
 default = "600"
 
 [[items]]
 section = "ui"
 name = "timeout.warn"
 default = 0
 
 [[items]]
 section = "ui"
 name = "timestamp-output"
 default = false
 
 [[items]]
 section = "ui"
 name = "traceback"
 default = false
 
 [[items]]
 section = "ui"
 name = "tweakdefaults"
 default = false
 
 [[items]]
 section = "ui"
 name = "username"
 alias = [["ui", "user"]]
 
 [[items]]
 section = "ui"
 name = "verbose"
 default = false
 
 [[items]]
 section = "verify"
 name = "skipflags"
 default = 0
 
 [[items]]
 section = "web"
 name = "accesslog"
 default = "-"
 
 [[items]]
 section = "web"
 name = "address"
 default = ""
 
 [[items]]
 section = "web"
 name = "allow-archive"
 default-type = "list_type"
 alias = [["web", "allow_archive"]]
 
 [[items]]
 section = "web"
 name = "allow-pull"
 default = true
 alias = [["web", "allowpull"]]
 
 [[items]]
 section = "web"
 name = "allow-push"
 default-type = "list_type"
 alias = [["web", "allow_push"]]
 
 [[items]]
 section = "web"
 name = "allow_read"
 default-type = "list_type"
 
 [[items]]
 section = "web"
 name = "allowbz2"
 default = false
 
 [[items]]
 section = "web"
 name = "allowgz"
 default = false
 
 [[items]]
 section = "web"
 name = "allowzip"
 default = false
 
 [[items]]
 section = "web"
 name = "archivesubrepos"
 default = false
 
 [[items]]
 section = "web"
 name = "baseurl"
 
 [[items]]
 section = "web"
 name = "cacerts"
 
 [[items]]
 section = "web"
 name = "cache"
 default = true
 
 [[items]]
 section = "web"
 name = "certificate"
 
 [[items]]
 section = "web"
 name = "collapse"
 default = false
 
 [[items]]
 section = "web"
 name = "comparisoncontext"
 default = 5
 
 [[items]]
 section = "web"
 name = "contact"
 
 [[items]]
 section = "web"
 name = "csp"
 
 [[items]]
 section = "web"
 name = "deny_push"
 default-type = "list_type"
 
 [[items]]
 section = "web"
 name = "deny_read"
 default-type = "list_type"
 
 [[items]]
 section = "web"
 name = "descend"
 default = true
 
 [[items]]
 section = "web"
 name = "description"
 default = ""
 
 [[items]]
 section = "web"
 name = "encoding"
 default-type = "lazy_module"
 default = "encoding.encoding"
 
 [[items]]
 section = "web"
 name = "errorlog"
 default = "-"
 
 [[items]]
 section = "web"
 name = "guessmime"
 default = false
 
 [[items]]
 section = "web"
 name = "hidden"
 default = false
 
 [[items]]
 section = "web"
 name = "ipv6"
 default = false
 
 [[items]]
 section = "web"
 name = "labels"
 default-type = "list_type"
 
 [[items]]
 section = "web"
 name = "logoimg"
 default = "hglogo.png"
 
 [[items]]
 section = "web"
 name = "logourl"
 default = "https://mercurial-scm.org/"
 
 [[items]]
 section = "web"
 name = "maxchanges"
 default = 10
 
 [[items]]
 section = "web"
 name = "maxfiles"
 default = 10
 
 [[items]]
 section = "web"
 name = "maxshortchanges"
 default = 60
 
 [[items]]
 section = "web"
 name = "motd"
 default = ""
 
 [[items]]
 section = "web"
 name = "name"
 default-type = "dynamic"
 
 [[items]]
 section = "web"
 name = "port"
 default = 8000
 
 [[items]]
 section = "web"
 name = "prefix"
 default = ""
 
 [[items]]
 section = "web"
 name = "push_ssl"
 default = true
 
 [[items]]
 section = "web"
 name = "refreshinterval"
 default = 20
 
 [[items]]
 section = "web"
 name = "server-header"
 
 [[items]]
 section = "web"
 name = "static"
 
 [[items]]
 section = "web"
 name = "staticurl"
 
 [[items]]
 section = "web"
 name = "stripes"
 default = 1
 
 [[items]]
 section = "web"
 name = "style"
 default = "paper"
 
 [[items]]
 section = "web"
 name = "templates"
 
 [[items]]
 section = "web"
 name = "view"
 default = "served"
 experimental = true
 
 [[items]]
 section = "worker"
 name = "backgroundclose"
 default-type = "dynamic"
 
 [[items]]
 section = "worker"
 name = "backgroundclosemaxqueue"
 # Windows defaults to a limit of 512 open files. A buffer of 128
 # should give us enough headway.
 default = 384
 
 [[items]]
 section = "worker"
 name = "backgroundcloseminfilecount"
 default = 2048
 
 [[items]]
 section = "worker"
 name = "backgroundclosethreadcount"
 default = 4
 
 [[items]]
 section = "worker"
 name = "enabled"
 default = true
 
 [[items]]
 section = "worker"
 name = "numcpus"
 
+# Templates and template applications
+
 [[template-applications]]
 template = "diff-options"
 section = "annotate"
 
 [[template-applications]]
 template = "diff-options"
 section = "commands"
 prefix = "commit.interactive"
 
 [[template-applications]]
 template = "diff-options"
 section = "commands"
 prefix = "revert.interactive"
 
 [[template-applications]]
 template = "diff-options"
 section = "diff"
 
 [templates]
 [[templates.diff-options]]
 suffix = "nodates"
 default = false
 
 [[templates.diff-options]]
 suffix = "showfunc"
 default = false
 
 [[templates.diff-options]]
 suffix = "unified"
 
 [[templates.diff-options]]
 suffix = "git"
 default = false
 
 [[templates.diff-options]]
 suffix = "ignorews"
 default = false
 
 [[templates.diff-options]]
 suffix = "ignorewsamount"
 default = false
 
 [[templates.diff-options]]
 suffix = "ignoreblanklines"
 default = false
 
 [[templates.diff-options]]
 suffix = "ignorewseol"
 default = false
 
 [[templates.diff-options]]
 suffix = "nobinary"
 default = false
 
 [[templates.diff-options]]
 suffix = "noprefix"
 default = false
 
 [[templates.diff-options]]
 suffix = "word-diff"
 default = false
 
+# In-core extensions
+
+[[items]]
+section = "blackbox"
+name = "dirty"
+default = false
+in_core_extension = "blackbox"
+
+[[items]]
+section = "blackbox"
+name = "maxsize"
+default = "1 MB"
+in_core_extension = "blackbox"
+
+[[items]]
+section = "blackbox"
+name = "logsource"
+default = false
+in_core_extension = "blackbox"
+
+[[items]]
+section = "blackbox"
+name = "maxfiles"
+default = 7
+in_core_extension = "blackbox"
+
+[[items]]
+section = "blackbox"
+name = "track"
+default-type = "lambda"
+default = ["*"]
+in_core_extension = "blackbox"
+
+[[items]]
+section = "blackbox"
+name = "ignore"
+default-type = "lambda"
+default = ["chgserver", "cmdserver", "extension"]
+in_core_extension = "blackbox"
+
+[[items]]
+section = "blackbox"
+name = "date-format"
+default = ""
+in_core_extension = "blackbox"

mercurial/ui.py

@@ -1,2337 +1,2344 b''
 # ui.py - user interface bits for mercurial
 #
 # Copyright 2005-2007 Olivia Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import collections
 import contextlib
 import datetime
 import errno
 import inspect
 import os
 import re
 import signal
 import socket
 import subprocess
 import sys
 import traceback
 
 from typing import (
     Any,
     Callable,
     Dict,
     List,
     NoReturn,
     Optional,
     Tuple,
     Type,
     TypeVar,
     Union,
     cast,
     overload,
 )
 
 from .i18n import _
 from .node import hex
 from .pycompat import (
     getattr,
     open,
 )
 
 from . import (
     color,
     config,
     configitems,
     encoding,
     error,
+    extensions,
     formatter,
     loggingutil,
     progress,
     pycompat,
     rcutil,
     scmutil,
     util,
 )
 from .utils import (
     dateutil,
     procutil,
     resourceutil,
     stringutil,
     urlutil,
 )
 
 _ConfigItems = Dict[Tuple[bytes, bytes], object]  # {(section, name) : value}
 # The **opts args of the various write() methods can be basically anything, but
 # there's no way to express it as "anything but str".  So type it to be the
 # handful of known types that are used.
 _MsgOpts = Union[bytes, bool, List["_PromptChoice"]]
 _PromptChoice = Tuple[bytes, bytes]
 _Tui = TypeVar('_Tui', bound="ui")
 
 urlreq = util.urlreq
 
 # for use with str.translate(None, _keepalnum), to keep just alphanumerics
 _keepalnum: bytes = b''.join(
     c for c in map(pycompat.bytechr, range(256)) if not c.isalnum()
 )
 
 # The config knobs that will be altered (if unset) by ui.tweakdefaults.
 tweakrc: bytes = b"""
 [ui]
 # The rollback command is dangerous. As a rule, don't use it.
 rollback = False
 # Make `hg status` report copy information
 statuscopies = yes
 # Prefer curses UIs when available. Revert to plain-text with `text`.
 interface = curses
 # Make compatible commands emit cwd-relative paths by default.
 relative-paths = yes
 
 [commands]
 # Grep working directory by default.
 grep.all-files = True
 # Refuse to perform an `hg update` that would cause a file content merge
 update.check = noconflict
 # Show conflicts information in `hg status`
 status.verbose = True
 # Make `hg resolve` with no action (like `-m`) fail instead of re-merging.
 resolve.explicit-re-merge = True
 
 [diff]
 git = 1
 showfunc = 1
 word-diff = 1
 """
 
 samplehgrcs: Dict[bytes, bytes] = {
     b'user': b"""# example user config (see 'hg help config' for more info)
 [ui]
 # name and email, e.g.
 # username = Jane Doe <[e-mail]>
 username =
 
 # We recommend enabling tweakdefaults to get slight improvements to
 # the UI over time. Make sure to set HGPLAIN in the environment when
 # writing scripts!
 # tweakdefaults = True
 
 # uncomment to disable color in command output
 # (see 'hg help color' for details)
 # color = never
 
 # uncomment to disable command output pagination
 # (see 'hg help pager' for details)
 # paginate = never
 
 [extensions]
 # uncomment the lines below to enable some popular extensions
 # (see 'hg help extensions' for more info)
 #
 # histedit =
 # rebase =
 # uncommit =
 """,
     b'cloned': b"""# example repository config (see 'hg help config' for more info)
 [paths]
 default = %s
 
 # path aliases to other clones of this repo in URLs or filesystem paths
 # (see 'hg help config.paths' for more info)
 #
 # default:pushurl = ssh://[e-mail]/hg/jdoes-fork
 # my-fork         = ssh://[e-mail]/hg/jdoes-fork
 # my-clone        = /home/jdoe/jdoes-clone
 
 [ui]
 # name and email (local to this repository, optional), e.g.
 # username = Jane Doe <[e-mail]>
 """,
     b'local': b"""# example repository config (see 'hg help config' for more info)
 [paths]
 # path aliases to other clones of this repo in URLs or filesystem paths
 # (see 'hg help config.paths' for more info)
 #
 # default         = http://example.com/hg/example-repo
 # default:pushurl = ssh://[e-mail]/hg/jdoes-fork
 # my-fork         = ssh://[e-mail]/hg/jdoes-fork
 # my-clone        = /home/jdoe/jdoes-clone
 
 [ui]
 # name and email (local to this repository, optional), e.g.
 # username = Jane Doe <[e-mail]>
 """,
     b'global': b"""# example system-wide hg config (see 'hg help config' for more info)
 
 [ui]
 # uncomment to disable color in command output
 # (see 'hg help color' for details)
 # color = never
 
 # uncomment to disable command output pagination
 # (see 'hg help pager' for details)
 # paginate = never
 
 [extensions]
 # uncomment the lines below to enable some popular extensions
 # (see 'hg help extensions' for more info)
 #
 # blackbox =
 # churn =
 """,
 }
 
 
 def _maybestrurl(maybebytes):
     return pycompat.rapply(pycompat.strurl, maybebytes)
 
 
 def _maybebytesurl(maybestr):
     return pycompat.rapply(pycompat.bytesurl, maybestr)
 
 
 class httppasswordmgrdbproxy:
     """Delays loading urllib2 until it's needed."""
 
     def __init__(self) -> None:
         self._mgr = None
 
     def _get_mgr(self):
         if self._mgr is None:
             self._mgr = urlreq.httppasswordmgrwithdefaultrealm()
         return self._mgr
 
     def add_password(self, realm, uris, user, passwd):
         return self._get_mgr().add_password(
             _maybestrurl(realm),
             _maybestrurl(uris),
             _maybestrurl(user),
             _maybestrurl(passwd),
         )
 
     def find_user_password(self, realm, uri):
         mgr = self._get_mgr()
         return _maybebytesurl(
             mgr.find_user_password(_maybestrurl(realm), _maybestrurl(uri))
         )
 
 
 def _catchterm(*args) -> NoReturn:
     raise error.SignalInterrupt
 
 
 # unique object used to detect no default value has been provided when
 # retrieving configuration value.
 _unset = object()
 
 # _reqexithandlers: callbacks run at the end of a request
 _reqexithandlers: List = []
 
 
 class ui:
     def __init__(self, src: Optional["ui"] = None) -> None:
         """Create a fresh new ui object if no src given
 
         Use uimod.ui.load() to create a ui which knows global and user configs.
         In most cases, you should use ui.copy() to create a copy of an existing
         ui object.
         """
         # _buffers: used for temporary capture of output
         self._buffers = []
         # 3-tuple describing how each buffer in the stack behaves.
         # Values are (capture stderr, capture subprocesses, apply labels).
         self._bufferstates = []
         # When a buffer is active, defines whether we are expanding labels.
         # This exists to prevent an extra list lookup.
         self._bufferapplylabels = None
         self.quiet = self.verbose = self.debugflag = self.tracebackflag = False
         self._reportuntrusted = True
         self._knownconfig = configitems.coreitems
         self._ocfg = config.config()  # overlay
         self._tcfg = config.config()  # trusted
         self._ucfg = config.config()  # untrusted
         self._trustusers = set()
         self._trustgroups = set()
         self.callhooks = True
         # hold the root to use for each [paths] entry
         self._path_to_root = {}
         # Insecure server connections requested.
         self.insecureconnections = False
         # Blocked time
         self.logblockedtimes = False
         # color mode: see mercurial/color.py for possible value
         self._colormode = None
         self._terminfoparams = {}
         self._styles = {}
         self._uninterruptible = False
         self.showtimestamp = False
 
         if src:
             self._fout = src._fout
             self._ferr = src._ferr
             self._fin = src._fin
             self._fmsg = src._fmsg
             self._fmsgout = src._fmsgout
             self._fmsgerr = src._fmsgerr
             self._finoutredirected = src._finoutredirected
             self._loggers = src._loggers.copy()
             self.pageractive = src.pageractive
             self._disablepager = src._disablepager
             self._tweaked = src._tweaked
 
             self._tcfg = src._tcfg.copy()
             self._ucfg = src._ucfg.copy()
             self._ocfg = src._ocfg.copy()
             self._trustusers = src._trustusers.copy()
             self._trustgroups = src._trustgroups.copy()
             self.environ = src.environ
             self.callhooks = src.callhooks
             self._path_to_root = src._path_to_root
             self.insecureconnections = src.insecureconnections
             self._colormode = src._colormode
             self._terminfoparams = src._terminfoparams.copy()
             self._styles = src._styles.copy()
 
             self.fixconfig()
 
             self.httppasswordmgrdb = src.httppasswordmgrdb
             self._blockedtimes = src._blockedtimes
         else:
             self._fout = procutil.stdout
             self._ferr = procutil.stderr
             self._fin = procutil.stdin
             self._fmsg = None
             self._fmsgout = self.fout  # configurable
             self._fmsgerr = self.ferr  # configurable
             self._finoutredirected = False
             self._loggers = {}
             self.pageractive = False
             self._disablepager = False
             self._tweaked = False
 
             # shared read-only environment
             self.environ = encoding.environ
 
             self.httppasswordmgrdb = httppasswordmgrdbproxy()
             self._blockedtimes = collections.defaultdict(int)
 
         allowed = self.configlist(b'experimental', b'exportableenviron')
         if b'*' in allowed:
             self._exportableenviron = self.environ
         else:
             self._exportableenviron = {}
             for k in allowed:
                 if k in self.environ:
                     self._exportableenviron[k] = self.environ[k]
 
     def _new_source(self) -> None:
         self._ocfg.new_source()
         self._tcfg.new_source()
         self._ucfg.new_source()
 
     @classmethod
     def load(cls: Type[_Tui]) -> _Tui:
         """Create a ui and load global and user configs"""
         u = cls()
         # we always trust global config files and environment variables
         for t, f in rcutil.rccomponents():
             if t == b'path':
                 u.readconfig(f, trust=True)
             elif t == b'resource':
                 u.read_resource_config(f, trust=True)
             elif t == b'items':
                 u._new_source()
                 sections = set()
                 for section, name, value, source in f:
                     # do not set u._ocfg
                     # XXX clean this up once immutable config object is a thing
                     u._tcfg.set(section, name, value, source)
                     u._ucfg.set(section, name, value, source)
                     sections.add(section)
                 for section in sections:
                     u.fixconfig(section=section)
             else:
                 raise error.ProgrammingError(b'unknown rctype: %s' % t)
         u._maybetweakdefaults()
         u._new_source()  # anything after that is a different level
         return u
 
     def _maybetweakdefaults(self) -> None:
         if not self.configbool(b'ui', b'tweakdefaults'):
             return
         if self._tweaked or self.plain(b'tweakdefaults'):
             return
 
         # Note: it is SUPER IMPORTANT that you set self._tweaked to
         # True *before* any calls to setconfig(), otherwise you'll get
         # infinite recursion between setconfig and this method.
         #
         # TODO: We should extract an inner method in setconfig() to
         # avoid this weirdness.
         self._tweaked = True
         tmpcfg = config.config()
         tmpcfg.parse(b'<tweakdefaults>', tweakrc)
         for section in tmpcfg:
             for name, value in tmpcfg.items(section):
                 if not self.hasconfig(section, name):
                     self.setconfig(section, name, value, b"<tweakdefaults>")
 
     def copy(self: _Tui) -> _Tui:
         return self.__class__(self)
 
     def resetstate(self) -> None:
         """Clear internal state that shouldn't persist across commands"""
         if self._progbar:
             self._progbar.resetstate()  # reset last-print time of progress bar
         self.httppasswordmgrdb = httppasswordmgrdbproxy()
 
     @contextlib.contextmanager
     def timeblockedsection(self, key: bytes):
         # this is open-coded below - search for timeblockedsection to find them
         starttime = util.timer()
         try:
             yield
         finally:
             self._blockedtimes[key + b'_blocked'] += (
                 util.timer() - starttime
             ) * 1000
 
     @contextlib.contextmanager
     def uninterruptible(self):
         """Mark an operation as unsafe.
 
         Most operations on a repository are safe to interrupt, but a
         few are risky (for example repair.strip). This context manager
         lets you advise Mercurial that something risky is happening so
         that control-C etc can be blocked if desired.
         """
         enabled = self.configbool(b'experimental', b'nointerrupt')
         if enabled and self.configbool(
             b'experimental', b'nointerrupt-interactiveonly'
         ):
             enabled = self.interactive()
         if self._uninterruptible or not enabled:
             # if nointerrupt support is turned off, the process isn't
             # interactive, or we're already in an uninterruptible
             # block, do nothing.
             yield
             return
 
         def warn():
             self.warn(_(b"shutting down cleanly\n"))
             self.warn(
                 _(b"press ^C again to terminate immediately (dangerous)\n")
             )
             return True
 
         with procutil.uninterruptible(warn):
             try:
                 self._uninterruptible = True
                 yield
             finally:
                 self._uninterruptible = False
 
     def formatter(self, topic: bytes, opts):
         return formatter.formatter(self, self, topic, opts)
 
     def _trusted(self, fp, f: bytes) -> bool:
         st = util.fstat(fp)
         if util.isowner(st):
             return True
 
         tusers, tgroups = self._trustusers, self._trustgroups
         if b'*' in tusers or b'*' in tgroups:
             return True
 
         user = util.username(st.st_uid)
         group = util.groupname(st.st_gid)
         if user in tusers or group in tgroups or user == util.username():
             return True
 
         if self._reportuntrusted:
             self.warn(
                 _(
                     b'not trusting file %s from untrusted '
                     b'user %s, group %s\n'
                 )
                 % (f, user, group)
             )
         return False
 
     def read_resource_config(
         self, name, root=None, trust=False, sections=None, remap=None
     ) -> None:
         try:
             fp = resourceutil.open_resource(name[0], name[1])
         except IOError:
             if not sections:  # ignore unless we were looking for something
                 return
             raise
 
         self._readconfig(
             b'resource:%s.%s' % name, fp, root, trust, sections, remap
         )
 
     def readconfig(
         self, filename, root=None, trust=False, sections=None, remap=None
     ) -> None:
         try:
             fp = open(filename, 'rb')
         except IOError:
             if not sections:  # ignore unless we were looking for something
                 return
             raise
 
         self._readconfig(filename, fp, root, trust, sections, remap)
 
     def _readconfig(
         self, filename, fp, root=None, trust=False, sections=None, remap=None
     ) -> None:
         with fp:
             cfg = config.config()
             trusted = sections or trust or self._trusted(fp, filename)
 
             try:
                 cfg.read(filename, fp, sections=sections, remap=remap)
             except error.ConfigError as inst:
                 if trusted:
                     raise
                 self.warn(
                     _(b'ignored %s: %s\n') % (inst.location, inst.message)
                 )
 
         self._applyconfig(cfg, trusted, root)
 
     def applyconfig(
         self, configitems: _ConfigItems, source=b"", root=None
     ) -> None:
         """Add configitems from a non-file source.  Unlike with ``setconfig()``,
         they can be overridden by subsequent config file reads.  The items are
         in the same format as ``configoverride()``, namely a dict of the
         following structures: {(section, name) : value}
 
         Typically this is used by extensions that inject themselves into the
         config file load procedure by monkeypatching ``localrepo.loadhgrc()``.
         """
         cfg = config.config()
 
         for (section, name), value in configitems.items():
             cfg.set(section, name, value, source)
 
         self._applyconfig(cfg, True, root)
 
     def _applyconfig(self, cfg, trusted, root) -> None:
         if self.plain():
             for k in (
                 b'debug',
                 b'fallbackencoding',
                 b'quiet',
                 b'slash',
                 b'logtemplate',
                 b'message-output',
                 b'statuscopies',
                 b'style',
                 b'traceback',
                 b'verbose',
             ):
                 if k in cfg[b'ui']:
                     del cfg[b'ui'][k]
             for k, v in cfg.items(b'defaults'):
                 del cfg[b'defaults'][k]
             for k, v in cfg.items(b'commands'):
                 del cfg[b'commands'][k]
             for k, v in cfg.items(b'command-templates'):
                 del cfg[b'command-templates'][k]
         # Don't remove aliases from the configuration if in the exceptionlist
         if self.plain(b'alias'):
             for k, v in cfg.items(b'alias'):
                 del cfg[b'alias'][k]
         if self.plain(b'revsetalias'):
             for k, v in cfg.items(b'revsetalias'):
                 del cfg[b'revsetalias'][k]
         if self.plain(b'templatealias'):
             for k, v in cfg.items(b'templatealias'):
                 del cfg[b'templatealias'][k]
 
         if trusted:
             self._tcfg.update(cfg)
             self._tcfg.update(self._ocfg)
         self._ucfg.update(cfg)
         self._ucfg.update(self._ocfg)
 
         if root is None:
             root = os.path.expanduser(b'~')
         self.fixconfig(root=root)
 
     def fixconfig(self, root=None, section=None) -> None:
         if section in (None, b'paths'):
             # expand vars and ~
             # translate paths relative to root (or home) into absolute paths
             root = root or encoding.getcwd()
             for c in self._tcfg, self._ucfg, self._ocfg:
                 for n, p in c.items(b'paths'):
                     old_p = p
                     s = self.configsource(b'paths', n) or b'none'
                     root_key = (n, p, s)
                     if root_key not in self._path_to_root:
                         self._path_to_root[root_key] = root
                     # Ignore sub-options.
                     if b':' in n:
                         continue
                     if not p:
                         continue
                     if b'%%' in p:
                         if s is None:
                             s = 'none'
                         self.warn(
                             _(b"(deprecated '%%' in path %s=%s from %s)\n")
                             % (n, p, s)
                         )
                         p = p.replace(b'%%', b'%')
                     if p != old_p:
                         c.alter(b"paths", n, p)
 
         if section in (None, b'ui'):
             # update ui options
             self._fmsgout, self._fmsgerr = _selectmsgdests(self)
             self.debugflag = self.configbool(b'ui', b'debug')
             self.verbose = self.debugflag or self.configbool(b'ui', b'verbose')
             self.quiet = not self.debugflag and self.configbool(b'ui', b'quiet')
             if self.verbose and self.quiet:
                 self.quiet = self.verbose = False
             self._reportuntrusted = self.debugflag or self.configbool(
                 b"ui", b"report_untrusted"
             )
             self.showtimestamp = self.configbool(b'ui', b'timestamp-output')
             self.tracebackflag = self.configbool(b'ui', b'traceback')
             self.logblockedtimes = self.configbool(b'ui', b'logblockedtimes')
 
         if section in (None, b'trusted'):
             # update trust information
             self._trustusers.update(self.configlist(b'trusted', b'users'))
             self._trustgroups.update(self.configlist(b'trusted', b'groups'))
 
         if section in (None, b'devel', b'ui') and self.debugflag:
             tracked = set()
             if self.configbool(b'devel', b'debug.extensions'):
                 tracked.add(b'extension')
             if tracked:
                 logger = loggingutil.fileobjectlogger(self._ferr, tracked)
                 self.setlogger(b'debug', logger)
 
     def backupconfig(self, section, item):
         return (
             self._ocfg.backup(section, item),
             self._tcfg.backup(section, item),
             self._ucfg.backup(section, item),
         )
 
     def restoreconfig(self, data) -> None:
         self._ocfg.restore(data[0])
         self._tcfg.restore(data[1])
         self._ucfg.restore(data[2])
 
     def setconfig(self, section, name, value, source=b'') -> None:
         for cfg in (self._ocfg, self._tcfg, self._ucfg):
             cfg.set(section, name, value, source)
         self.fixconfig(section=section)
         self._maybetweakdefaults()
 
     def _data(self, untrusted):
         return untrusted and self._ucfg or self._tcfg
 
     def configsource(self, section, name, untrusted=False):
         return self._data(untrusted).source(section, name)
 
     def config(self, section, name, default=_unset, untrusted=False):
         """return the plain string version of a config"""
         value = self._config(
             section, name, default=default, untrusted=untrusted
         )
         if value is _unset:
             return None
         return value
 
     def _config(self, section, name, default=_unset, untrusted=False):
         value = itemdefault = default
         item = self._knownconfig.get(section, {}).get(name)
         alternates = [(section, name)]
 
+        if item is not None and item.in_core_extension is not None:
+            # Only return the default for an in-core extension item if said
+            # extension is enabled
+            if item.in_core_extension in extensions.extensions(self):
+                item = None
+
         if item is not None:
             alternates.extend(item.alias)
             if callable(item.default):
                 itemdefault = item.default()
             else:
                 itemdefault = item.default
         else:
             msg = b"accessing unregistered config item: '%s.%s'"
             msg %= (section, name)
             self.develwarn(msg, 2, b'warn-config-unknown')
 
         if default is _unset:
             if item is None:
                 value = default
             elif item.default is configitems.dynamicdefault:
                 value = None
                 msg = b"config item requires an explicit default value: '%s.%s'"
                 msg %= (section, name)
                 self.develwarn(msg, 2, b'warn-config-default')
             else:
                 value = itemdefault
         elif (
             item is not None
             and item.default is not configitems.dynamicdefault
             and default != itemdefault
         ):
             msg = (
                 b"specifying a mismatched default value for a registered "
                 b"config item: '%s.%s' '%s'"
             )
             msg %= (section, name, pycompat.bytestr(default))
             self.develwarn(msg, 2, b'warn-config-default')
 
         candidates = []
         config = self._data(untrusted)
         for s, n in alternates:
             candidate = config.get(s, n, None)
             if candidate is not None:
                 candidates.append((s, n, candidate))
         if candidates:
 
             def level(x):
                 return config.level(x[0], x[1])
 
             value = max(candidates, key=level)[2]
 
         if self.debugflag and not untrusted and self._reportuntrusted:
             for s, n in alternates:
                 uvalue = self._ucfg.get(s, n)
                 if uvalue is not None and uvalue != value:
                     self.debug(
                         b"ignoring untrusted configuration option "
                         b"%s.%s = %s\n" % (s, n, uvalue)
                     )
         return value
 
     def config_default(self, section, name):
         """return the default value for a config option
 
         The default is returned "raw", for example if it is a callable, the
         callable was not called.
         """
         item = self._knownconfig.get(section, {}).get(name)
 
         if item is None:
             raise KeyError((section, name))
         return item.default
 
     def configsuboptions(self, section, name, default=_unset, untrusted=False):
         """Get a config option and all sub-options.
 
         Some config options have sub-options that are declared with the
         format "key:opt = value". This method is used to return the main
         option and all its declared sub-options.
 
         Returns a 2-tuple of ``(option, sub-options)``, where `sub-options``
         is a dict of defined sub-options where keys and values are strings.
         """
         main = self.config(section, name, default, untrusted=untrusted)
         data = self._data(untrusted)
         sub = {}
         prefix = b'%s:' % name
         for k, v in data.items(section):
             if k.startswith(prefix):
                 sub[k[len(prefix) :]] = v
 
         if self.debugflag and not untrusted and self._reportuntrusted:
             for k, v in sub.items():
                 uvalue = self._ucfg.get(section, b'%s:%s' % (name, k))
                 if uvalue is not None and uvalue != v:
                     self.debug(
                         b'ignoring untrusted configuration option '
                         b'%s:%s.%s = %s\n' % (section, name, k, uvalue)
                     )
 
         return main, sub
 
     def configpath(self, section, name, default=_unset, untrusted=False):
         """get a path config item, expanded relative to repo root or config
         file"""
         v = self.config(section, name, default, untrusted)
         if v is None:
             return None
         if not os.path.isabs(v) or b"://" not in v:
             src = self.configsource(section, name, untrusted)
             if b':' in src:
                 base = os.path.dirname(src.rsplit(b':')[0])
                 v = os.path.join(base, os.path.expanduser(v))
         return v
 
     def configbool(self, section, name, default=_unset, untrusted=False):
         """parse a configuration element as a boolean
 
         >>> u = ui(); s = b'foo'
         >>> u.setconfig(s, b'true', b'yes')
         >>> u.configbool(s, b'true')
         True
         >>> u.setconfig(s, b'false', b'no')
         >>> u.configbool(s, b'false')
         False
         >>> u.configbool(s, b'unknown')
         False
         >>> u.configbool(s, b'unknown', True)
         True
         >>> u.setconfig(s, b'invalid', b'somevalue')
         >>> u.configbool(s, b'invalid')
         Traceback (most recent call last):
             ...
         ConfigError: foo.invalid is not a boolean ('somevalue')
         """
 
         v = self._config(section, name, default, untrusted=untrusted)
         if v is None:
             return v
         if v is _unset:
             if default is _unset:
                 return False
             return default
         if isinstance(v, bool):
             return v
         b = stringutil.parsebool(v)
         if b is None:
             raise error.ConfigError(
                 _(b"%s.%s is not a boolean ('%s')") % (section, name, v)
             )
         return b
 
     def configwith(
         self, convert, section, name, default=_unset, desc=None, untrusted=False
     ):
         """parse a configuration element with a conversion function
 
         >>> u = ui(); s = b'foo'
         >>> u.setconfig(s, b'float1', b'42')
         >>> u.configwith(float, s, b'float1')
         42.0
         >>> u.setconfig(s, b'float2', b'-4.25')
         >>> u.configwith(float, s, b'float2')
         -4.25
         >>> u.configwith(float, s, b'unknown', 7)
         7.0
         >>> u.setconfig(s, b'invalid', b'somevalue')
         >>> u.configwith(float, s, b'invalid')
         Traceback (most recent call last):
             ...
         ConfigError: foo.invalid is not a valid float ('somevalue')
         >>> u.configwith(float, s, b'invalid', desc=b'womble')
         Traceback (most recent call last):
             ...
         ConfigError: foo.invalid is not a valid womble ('somevalue')
         """
 
         v = self.config(section, name, default, untrusted)
         if v is None:
             return v  # do not attempt to convert None
         try:
             return convert(v)
         except (ValueError, error.ParseError):
             if desc is None:
                 desc = pycompat.sysbytes(convert.__name__)
             raise error.ConfigError(
                 _(b"%s.%s is not a valid %s ('%s')") % (section, name, desc, v)
             )
 
     def configint(self, section, name, default=_unset, untrusted=False):
         """parse a configuration element as an integer
 
         >>> u = ui(); s = b'foo'
         >>> u.setconfig(s, b'int1', b'42')
         >>> u.configint(s, b'int1')
         42
         >>> u.setconfig(s, b'int2', b'-42')
         >>> u.configint(s, b'int2')
         -42
         >>> u.configint(s, b'unknown', 7)
         7
         >>> u.setconfig(s, b'invalid', b'somevalue')
         >>> u.configint(s, b'invalid')
         Traceback (most recent call last):
             ...
         ConfigError: foo.invalid is not a valid integer ('somevalue')
         """
 
         return self.configwith(
             int, section, name, default, b'integer', untrusted
         )
 
     def configbytes(self, section, name, default=_unset, untrusted=False):
         """parse a configuration element as a quantity in bytes
 
         Units can be specified as b (bytes), k or kb (kilobytes), m or
         mb (megabytes), g or gb (gigabytes).
 
         >>> u = ui(); s = b'foo'
         >>> u.setconfig(s, b'val1', b'42')
         >>> u.configbytes(s, b'val1')
         42
         >>> u.setconfig(s, b'val2', b'42.5 kb')
         >>> u.configbytes(s, b'val2')
         43520
         >>> u.configbytes(s, b'unknown', b'7 MB')
         7340032
         >>> u.setconfig(s, b'invalid', b'somevalue')
         >>> u.configbytes(s, b'invalid')
         Traceback (most recent call last):
             ...
         ConfigError: foo.invalid is not a byte quantity ('somevalue')
         """
 
         value = self._config(section, name, default, untrusted)
         if value is _unset:
             if default is _unset:
                 default = 0
             value = default
         if not isinstance(value, bytes):
             return value
         try:
             return util.sizetoint(value)
         except error.ParseError:
             raise error.ConfigError(
                 _(b"%s.%s is not a byte quantity ('%s')")
                 % (section, name, value)
             )
 
     def configlist(self, section, name, default=_unset, untrusted=False):
         """parse a configuration element as a list of comma/space separated
         strings
 
         >>> u = ui(); s = b'foo'
         >>> u.setconfig(s, b'list1', b'this,is "a small" ,test')
         >>> u.configlist(s, b'list1')
         ['this', 'is', 'a small', 'test']
         >>> u.setconfig(s, b'list2', b'this, is "a small" , test ')
         >>> u.configlist(s, b'list2')
         ['this', 'is', 'a small', 'test']
         """
         # default is not always a list
         v = self.configwith(
             stringutil.parselist, section, name, default, b'list', untrusted
         )
         if isinstance(v, bytes):
             return stringutil.parselist(v)
         elif v is None:
             return []
         return v
 
     def configdate(self, section, name, default=_unset, untrusted=False):
         """parse a configuration element as a tuple of ints
 
         >>> u = ui(); s = b'foo'
         >>> u.setconfig(s, b'date', b'0 0')
         >>> u.configdate(s, b'date')
         (0, 0)
         """
         if self.config(section, name, default, untrusted):
             return self.configwith(
                 dateutil.parsedate, section, name, default, b'date', untrusted
             )
         if default is _unset:
             return None
         return default
 
     def configdefault(self, section, name):
         """returns the default value of the config item"""
         item = self._knownconfig.get(section, {}).get(name)
         itemdefault = None
         if item is not None:
             if callable(item.default):
                 itemdefault = item.default()
             else:
                 itemdefault = item.default
         return itemdefault
 
     def hasconfig(self, section, name, untrusted=False):
         return self._data(untrusted).hasitem(section, name)
 
     def has_section(self, section, untrusted=False):
         '''tell whether section exists in config.'''
         return section in self._data(untrusted)
 
     def configitems(self, section, untrusted=False, ignoresub=False):
         items = self._data(untrusted).items(section)
         if ignoresub:
             items = [i for i in items if b':' not in i[0]]
         if self.debugflag and not untrusted and self._reportuntrusted:
             for k, v in self._ucfg.items(section):
                 if self._tcfg.get(section, k) != v:
                     self.debug(
                         b"ignoring untrusted configuration option "
                         b"%s.%s = %s\n" % (section, k, v)
                     )
         return items
 
     def walkconfig(self, untrusted=False, all_known=False):
         defined = self._walk_config(untrusted)
         if not all_known:
             for d in defined:
                 yield d
             return
         known = self._walk_known()
         current_defined = next(defined, None)
         current_known = next(known, None)
         while current_defined is not None or current_known is not None:
             if current_defined is None:
                 yield current_known
                 current_known = next(known, None)
             elif current_known is None:
                 yield current_defined
                 current_defined = next(defined, None)
             elif current_known[0:2] == current_defined[0:2]:
                 yield current_defined
                 current_defined = next(defined, None)
                 current_known = next(known, None)
             elif current_known[0:2] < current_defined[0:2]:
                 yield current_known
                 current_known = next(known, None)
             else:
                 yield current_defined
                 current_defined = next(defined, None)
 
     def _walk_known(self):
         for section, items in sorted(self._knownconfig.items()):
             for k, i in sorted(items.items()):
                 # We don't have a way to display generic well, so skip them
                 if i.generic:
                     continue
                 if callable(i.default):
                     default = i.default()
                 elif i.default is configitems.dynamicdefault:
                     default = b'<DYNAMIC>'
                 else:
                     default = i.default
                 yield section, i.name, default
 
     def _walk_config(self, untrusted):
         cfg = self._data(untrusted)
         for section in cfg.sections():
             for name, value in self.configitems(section, untrusted):
                 yield section, name, value
 
     def plain(self, feature: Optional[bytes] = None) -> bool:
         """is plain mode active?
 
         Plain mode means that all configuration variables which affect
         the behavior and output of Mercurial should be
         ignored. Additionally, the output should be stable,
         reproducible and suitable for use in scripts or applications.
 
         The only way to trigger plain mode is by setting either the
         `HGPLAIN' or `HGPLAINEXCEPT' environment variables.
 
         The return value can either be
         - False if HGPLAIN is not set, or feature is in HGPLAINEXCEPT
         - False if feature is disabled by default and not included in HGPLAIN
         - True otherwise
         """
         if (
             b'HGPLAIN' not in encoding.environ
             and b'HGPLAINEXCEPT' not in encoding.environ
         ):
             return False
         exceptions = (
             encoding.environ.get(b'HGPLAINEXCEPT', b'').strip().split(b',')
         )
         # TODO: add support for HGPLAIN=+feature,-feature syntax
         if b'+strictflags' not in encoding.environ.get(b'HGPLAIN', b'').split(
             b','
         ):
             exceptions.append(b'strictflags')
         if feature and exceptions:
             return feature not in exceptions
         return True
 
     def username(self, acceptempty=False):
         """Return default username to be used in commits.
 
         Searched in this order: $HGUSER, [ui] section of hgrcs, $EMAIL
         and stop searching if one of these is set.
         If not found and acceptempty is True, returns None.
         If not found and ui.askusername is True, ask the user, else use
         ($LOGNAME or $USER or $LNAME or $USERNAME) + "@full.hostname".
         If no username could be found, raise an Abort error.
         """
         user = encoding.environ.get(b"HGUSER")
         if user is None:
             user = self.config(b"ui", b"username")
             if user is not None:
                 user = os.path.expandvars(user)
         if user is None:
             user = encoding.environ.get(b"EMAIL")
         if user is None and acceptempty:
             return user
         if user is None and self.configbool(b"ui", b"askusername"):
             user = self.prompt(_(b"enter a commit username:"), default=None)
         if user is None and not self.interactive():
             try:
                 user = b'%s@%s' % (
                     procutil.getuser(),
                     encoding.strtolocal(socket.getfqdn()),
                 )
                 self.warn(_(b"no username found, using '%s' instead\n") % user)
             except KeyError:
                 pass
         if not user:
             raise error.Abort(
                 _(b'no username supplied'),
                 hint=_(b"use 'hg config --edit' " b'to set your username'),
             )
         if b"\n" in user:
             raise error.Abort(
                 _(b"username %r contains a newline\n") % pycompat.bytestr(user)
             )
         return user
 
     def shortuser(self, user: bytes) -> bytes:
         """Return a short representation of a user name or email address."""
         if not self.verbose:
             user = stringutil.shortuser(user)
         return user
 
     @util.propertycache
     def paths(self):
         return urlutil.paths(self)
 
     @property
     def fout(self):
         return self._fout
 
     @util.propertycache
     def _fout_is_a_tty(self):
         self._isatty(self._fout)
 
     @fout.setter
     def fout(self, f):
         self._fout = f
         self._fmsgout, self._fmsgerr = _selectmsgdests(self)
         if '_fout_is_a_tty' in vars(self):
             del self._fout_is_a_tty
 
     @property
     def ferr(self):
         return self._ferr
 
     @ferr.setter
     def ferr(self, f):
         self._ferr = f
         self._fmsgout, self._fmsgerr = _selectmsgdests(self)
 
     @property
     def fin(self):
         return self._fin
 
     @fin.setter
     def fin(self, f):
         self._fin = f
 
     @property
     def fmsg(self):
         """Stream dedicated for status/error messages; may be None if
         fout/ferr are used"""
         return self._fmsg
 
     @fmsg.setter
     def fmsg(self, f):
         self._fmsg = f
         self._fmsgout, self._fmsgerr = _selectmsgdests(self)
 
     @contextlib.contextmanager
     def silent(
         self, error: bool = False, subproc: bool = False, labeled: bool = False
     ):
         self.pushbuffer(error=error, subproc=subproc, labeled=labeled)
         try:
             yield
         finally:
             self.popbuffer()
 
     def pushbuffer(
         self, error: bool = False, subproc: bool = False, labeled: bool = False
     ) -> None:
         """install a buffer to capture standard output of the ui object
 
         If error is True, the error output will be captured too.
 
         If subproc is True, output from subprocesses (typically hooks) will be
         captured too.
 
         If labeled is True, any labels associated with buffered
         output will be handled. By default, this has no effect
         on the output returned, but extensions and GUI tools may
         handle this argument and returned styled output. If output
         is being buffered so it can be captured and parsed or
         processed, labeled should not be set to True.
         """
         self._buffers.append([])
         self._bufferstates.append((error, subproc, labeled))
         self._bufferapplylabels = labeled
 
     def popbuffer(self) -> bytes:
         '''pop the last buffer and return the buffered output'''
         self._bufferstates.pop()
         if self._bufferstates:
             self._bufferapplylabels = self._bufferstates[-1][2]
         else:
             self._bufferapplylabels = None
 
         return b"".join(self._buffers.pop())
 
     def _isbuffered(self, dest) -> bool:
         if dest is self._fout:
             return bool(self._buffers)
         if dest is self._ferr:
             return bool(self._bufferstates and self._bufferstates[-1][0])
         return False
 
     def canwritewithoutlabels(self) -> bool:
         '''check if write skips the label'''
         if self._buffers and not self._bufferapplylabels:
             return True
         return self._colormode is None
 
     def canbatchlabeledwrites(self) -> bool:
         '''check if write calls with labels are batchable'''
         # Windows color printing is special, see ``write``.
         return self._colormode != b'win32'
 
     def write(self, *args: bytes, **opts: _MsgOpts) -> None:
         """write args to output
 
         By default, this method simply writes to the buffer or stdout.
         Color mode can be set on the UI class to have the output decorated
         with color modifier before being written to stdout.
 
         The color used is controlled by an optional keyword argument, "label".
         This should be a string containing label names separated by space.
         Label names take the form of "topic.type". For example, ui.debug()
         issues a label of "ui.debug".
 
         Progress reports via stderr are normally cleared before writing as
         stdout and stderr go to the same terminal. This can be skipped with
         the optional keyword argument "keepprogressbar". The progress bar
         will continue to occupy a partial line on stderr in that case.
         This functionality is intended when Mercurial acts as data source
         in a pipe.
 
         When labeling output for a specific command, a label of
         "cmdname.type" is recommended. For example, status issues
         a label of "status.modified" for modified files.
         """
         dest = self._fout
 
         # inlined _write() for speed
         if self._buffers:
             label = opts.get('label', b'')
             if label and self._bufferapplylabels:
                 self._buffers[-1].extend(self.label(a, label) for a in args)
             else:
                 self._buffers[-1].extend(args)
             return
 
         # inlined _writenobuf() for speed
         if not opts.get('keepprogressbar', self._fout_is_a_tty):
             self._progclear()
         msg = b''.join(args)
 
         # opencode timeblockedsection because this is a critical path
         starttime = util.timer()
         try:
             if self._colormode == b'win32':
                 # windows color printing is its own can of crab, defer to
                 # the color module and that is it.
                 color.win32print(self, dest.write, msg, **opts)
             else:
                 if self._colormode is not None:
                     label = opts.get('label', b'')
                     msg = self.label(msg, label)
                 dest.write(msg)
         except IOError as err:
             raise error.StdioError(err)
         finally:
             self._blockedtimes[b'stdio_blocked'] += (
                 util.timer() - starttime
             ) * 1000
 
     def write_err(self, *args: bytes, **opts: _MsgOpts) -> None:
         self._write(self._ferr, *args, **opts)
 
     def _write(self, dest, *args: bytes, **opts: _MsgOpts) -> None:
         # update write() as well if you touch this code
         if self._isbuffered(dest):
             label = opts.get('label', b'')
             if label and self._bufferapplylabels:
                 self._buffers[-1].extend(self.label(a, label) for a in args)
             else:
                 self._buffers[-1].extend(args)
         else:
             self._writenobuf(dest, *args, **opts)
 
     def _writenobuf(self, dest, *args: bytes, **opts: _MsgOpts) -> None:
         # update write() as well if you touch this code
         if not opts.get('keepprogressbar', self._fout_is_a_tty):
             self._progclear()
         msg = b''.join(args)
 
         # opencode timeblockedsection because this is a critical path
         starttime = util.timer()
         try:
             if dest is self._ferr and not getattr(self._fout, 'closed', False):
                 self._fout.flush()
             if getattr(dest, 'structured', False):
                 # channel for machine-readable output with metadata, where
                 # no extra colorization is necessary.
                 dest.write(msg, **opts)
             elif self._colormode == b'win32':
                 # windows color printing is its own can of crab, defer to
                 # the color module and that is it.
                 color.win32print(self, dest.write, msg, **opts)
             else:
                 if self._colormode is not None:
                     label = opts.get('label', b'')
                     msg = self.label(msg, label)
                 dest.write(msg)
             # stderr may be buffered under win32 when redirected to files,
             # including stdout.
             if dest is self._ferr and not getattr(dest, 'closed', False):
                 dest.flush()
         except IOError as err:
             if dest is self._ferr and err.errno in (
                 errno.EPIPE,
                 errno.EIO,
                 errno.EBADF,
             ):
                 # no way to report the error, so ignore it
                 return
             raise error.StdioError(err)
         finally:
             self._blockedtimes[b'stdio_blocked'] += (
                 util.timer() - starttime
             ) * 1000
 
     def _writemsg(self, dest, *args: bytes, **opts: _MsgOpts) -> None:
         timestamp = self.showtimestamp and opts.get('type') in {
             b'debug',
             b'error',
             b'note',
             b'status',
             b'warning',
         }
         if timestamp:
             args = (
                 b'[%s] '
                 % pycompat.bytestr(datetime.datetime.now().isoformat()),
             ) + args
         _writemsgwith(self._write, dest, *args, **opts)
         if timestamp:
             dest.flush()
 
     def _writemsgnobuf(self, dest, *args: bytes, **opts: _MsgOpts) -> None:
         _writemsgwith(self._writenobuf, dest, *args, **opts)
 
     def flush(self) -> None:
         # opencode timeblockedsection because this is a critical path
         starttime = util.timer()
         try:
             try:
                 self._fout.flush()
             except IOError as err:
                 if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):
                     raise error.StdioError(err)
             finally:
                 try:
                     self._ferr.flush()
                 except IOError as err:
                     if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF):
                         raise error.StdioError(err)
         finally:
             self._blockedtimes[b'stdio_blocked'] += (
                 util.timer() - starttime
             ) * 1000
 
     def _isatty(self, fh) -> bool:
         if self.configbool(b'ui', b'nontty'):
             return False
         return procutil.isatty(fh)
 
     def protectfinout(self):
         """Duplicate ui streams and redirect original if they are stdio
 
         Returns (fin, fout) which point to the original ui fds, but may be
         copy of them. The returned streams can be considered "owned" in that
         print(), exec(), etc. never reach to them.
         """
         if self._finoutredirected:
             # if already redirected, protectstdio() would just create another
             # nullfd pair, which is equivalent to returning self._fin/_fout.
             return self._fin, self._fout
         fin, fout = procutil.protectstdio(self._fin, self._fout)
         self._finoutredirected = (fin, fout) != (self._fin, self._fout)
         return fin, fout
 
     def restorefinout(self, fin, fout):
         """Restore ui streams from possibly duplicated (fin, fout)"""
         if (fin, fout) == (self._fin, self._fout):
             return
         procutil.restorestdio(self._fin, self._fout, fin, fout)
         # protectfinout() won't create more than one duplicated streams,
         # so we can just turn the redirection flag off.
         self._finoutredirected = False
 
     @contextlib.contextmanager
     def protectedfinout(self):
         """Run code block with protected standard streams"""
         fin, fout = self.protectfinout()
         try:
             yield fin, fout
         finally:
             self.restorefinout(fin, fout)
 
     def disablepager(self) -> None:
         self._disablepager = True
 
     def pager(self, command: bytes) -> None:
         """Start a pager for subsequent command output.
 
         Commands which produce a long stream of output should call
         this function to activate the user's preferred pagination
         mechanism (which may be no pager). Calling this function
         precludes any future use of interactive functionality, such as
         prompting the user or activating curses.
 
         Args:
           command: The full, non-aliased name of the command. That is, "log"
                    not "history, "summary" not "summ", etc.
         """
         if self._disablepager or self.pageractive:
             # how pager should do is already determined
             return
 
         if not command.startswith(b'internal-always-') and (
             # explicit --pager=on (= 'internal-always-' prefix) should
             # take precedence over disabling factors below
             command in self.configlist(b'pager', b'ignore')
             or not self.configbool(b'ui', b'paginate')
             or not self.configbool(b'pager', b'attend-' + command, True)
             or encoding.environ.get(b'TERM') == b'dumb'
             # TODO: if we want to allow HGPLAINEXCEPT=pager,
             # formatted() will need some adjustment.
             or not self.formatted()
             or self.plain()
             or self._buffers
             # TODO: expose debugger-enabled on the UI object
             or b'--debugger' in pycompat.sysargv
         ):
             # We only want to paginate if the ui appears to be
             # interactive, the user didn't say HGPLAIN or
             # HGPLAINEXCEPT=pager, and the user didn't specify --debug.
             return
 
         # py2exe doesn't appear to be able to use legacy I/O, and nothing is
         # output to the pager for paged commands.  Piping to `more` in cmd.exe
         # works, but is easy to forget.  Just disable pager for py2exe, but
         # leave it working for pyoxidizer and exewrapper builds.
         if pycompat.iswindows and getattr(sys, "frozen", None) == "console_exe":
             self.debug(b"pager is unavailable with py2exe packaging\n")
             return
 
         pagercmd = self.config(b'pager', b'pager', rcutil.fallbackpager)
         if not pagercmd:
             return
 
         pagerenv = {}
         for name, value in rcutil.defaultpagerenv().items():
             if name not in encoding.environ:
                 pagerenv[name] = value
 
         self.debug(
             b'starting pager for command %s\n' % stringutil.pprint(command)
         )
         self.flush()
 
         wasformatted = self.formatted()
         if util.safehasattr(signal, b"SIGPIPE"):
             signal.signal(signal.SIGPIPE, _catchterm)
         if self._runpager(pagercmd, pagerenv):
             self.pageractive = True
             # Preserve the formatted-ness of the UI. This is important
             # because we mess with stdout, which might confuse
             # auto-detection of things being formatted.
             self.setconfig(b'ui', b'formatted', wasformatted, b'pager')
             self.setconfig(b'ui', b'interactive', False, b'pager')
 
             # If pagermode differs from color.mode, reconfigure color now that
             # pageractive is set.
             cm = self._colormode
             if cm != self.config(b'color', b'pagermode', cm):
                 color.setup(self)
         else:
             # If the pager can't be spawned in dispatch when --pager=on is
             # given, don't try again when the command runs, to avoid a duplicate
             # warning about a missing pager command.
             self.disablepager()
 
     def _runpager(self, command: bytes, env=None) -> bool:
         """Actually start the pager and set up file descriptors.
 
         This is separate in part so that extensions (like chg) can
         override how a pager is invoked.
         """
         if command == b'cat':
             # Save ourselves some work.
             return False
         # If the command doesn't contain any of these characters, we
         # assume it's a binary and exec it directly. This means for
         # simple pager command configurations, we can degrade
         # gracefully and tell the user about their broken pager.
         shell = any(c in command for c in b"|&;<>()$`\\\"' \t\n*?[#~=%")
 
         if pycompat.iswindows and not shell:
             # Window's built-in `more` cannot be invoked with shell=False, but
             # its `more.com` can.  Hide this implementation detail from the
             # user so we can also get sane bad PAGER behavior.  MSYS has
             # `more.exe`, so do a cmd.exe style resolution of the executable to
             # determine which one to use.
             fullcmd = procutil.findexe(command)
             if not fullcmd:
                 self.warn(
                     _(b"missing pager command '%s', skipping pager\n") % command
                 )
                 return False
 
             command = fullcmd
 
         try:
             pager = subprocess.Popen(
                 procutil.tonativestr(command),
                 shell=shell,
                 bufsize=-1,
                 close_fds=procutil.closefds,
                 stdin=subprocess.PIPE,
                 stdout=procutil.stdout,
                 stderr=procutil.stderr,
                 env=procutil.tonativeenv(procutil.shellenviron(env)),
             )
         except FileNotFoundError:
             if not shell:
                 self.warn(
                     _(b"missing pager command '%s', skipping pager\n") % command
                 )
                 return False
             raise
 
         # back up original file descriptors
         stdoutfd = os.dup(procutil.stdout.fileno())
         stderrfd = os.dup(procutil.stderr.fileno())
 
         os.dup2(pager.stdin.fileno(), procutil.stdout.fileno())
         if self._isatty(procutil.stderr):
             os.dup2(pager.stdin.fileno(), procutil.stderr.fileno())
 
         @self.atexit
         def killpager():
             if util.safehasattr(signal, b"SIGINT"):
                 signal.signal(signal.SIGINT, signal.SIG_IGN)
             # restore original fds, closing pager.stdin copies in the process
             os.dup2(stdoutfd, procutil.stdout.fileno())
             os.dup2(stderrfd, procutil.stderr.fileno())
             pager.stdin.close()
             pager.wait()
 
         return True
 
     @property
     def _exithandlers(self):
         return _reqexithandlers
 
     def atexit(self, func, *args, **kwargs):
         """register a function to run after dispatching a request
 
         Handlers do not stay registered across request boundaries."""
         self._exithandlers.append((func, args, kwargs))
         return func
 
     def interface(self, feature: bytes) -> bytes:
         """what interface to use for interactive console features?
 
         The interface is controlled by the value of `ui.interface` but also by
         the value of feature-specific configuration. For example:
 
         ui.interface.histedit = text
         ui.interface.chunkselector = curses
 
         Here the features are "histedit" and "chunkselector".
 
         The configuration above means that the default interfaces for commands
         is curses, the interface for histedit is text and the interface for
         selecting chunk is crecord (the best curses interface available).
 
         Consider the following example:
         ui.interface = curses
         ui.interface.histedit = text
 
         Then histedit will use the text interface and chunkselector will use
         the default curses interface (crecord at the moment).
         """
         alldefaults = frozenset([b"text", b"curses"])
 
         featureinterfaces = {
             b"chunkselector": [
                 b"text",
                 b"curses",
             ],
             b"histedit": [
                 b"text",
                 b"curses",
             ],
         }
 
         # Feature-specific interface
         if feature not in featureinterfaces.keys():
             # Programming error, not user error
             raise ValueError(b"Unknown feature requested %s" % feature)
 
         availableinterfaces = frozenset(featureinterfaces[feature])
         if alldefaults > availableinterfaces:
             # Programming error, not user error. We need a use case to
             # define the right thing to do here.
             raise ValueError(
                 b"Feature %s does not handle all default interfaces" % feature
             )
 
         if self.plain() or encoding.environ.get(b'TERM') == b'dumb':
             return b"text"
 
         # Default interface for all the features
         defaultinterface = b"text"
         i = self.config(b"ui", b"interface")
         if i in alldefaults:
             defaultinterface = cast(bytes, i)  # cast to help pytype
 
         choseninterface: bytes = defaultinterface
         f = self.config(b"ui", b"interface.%s" % feature)
         if f in availableinterfaces:
             choseninterface = cast(bytes, f)  # cast to help pytype
 
         if i is not None and defaultinterface != i:
             if f is not None:
                 self.warn(_(b"invalid value for ui.interface: %s\n") % (i,))
             else:
                 self.warn(
                     _(b"invalid value for ui.interface: %s (using %s)\n")
                     % (i, choseninterface)
                 )
         if f is not None and choseninterface != f:
             self.warn(
                 _(b"invalid value for ui.interface.%s: %s (using %s)\n")
                 % (feature, f, choseninterface)
             )
 
         return choseninterface
 
     def interactive(self):
         """is interactive input allowed?
 
         An interactive session is a session where input can be reasonably read
         from `sys.stdin'. If this function returns false, any attempt to read
         from stdin should fail with an error, unless a sensible default has been
         specified.
 
         Interactiveness is triggered by the value of the `ui.interactive'
         configuration variable or - if it is unset - when `sys.stdin' points
         to a terminal device.
 
         This function refers to input only; for output, see `ui.formatted()'.
         """
         i = self.configbool(b"ui", b"interactive")
         if i is None:
             # some environments replace stdin without implementing isatty
             # usually those are non-interactive
             return self._isatty(self._fin)
 
         return i
 
     def termwidth(self) -> int:
         """how wide is the terminal in columns?"""
         if b'COLUMNS' in encoding.environ:
             try:
                 return int(encoding.environ[b'COLUMNS'])
             except ValueError:
                 pass
         return scmutil.termsize(self)[0]
 
     def formatted(self):
         """should formatted output be used?
 
         It is often desirable to format the output to suite the output medium.
         Examples of this are truncating long lines or colorizing messages.
         However, this is not often not desirable when piping output into other
         utilities, e.g. `grep'.
 
         Formatted output is triggered by the value of the `ui.formatted'
         configuration variable or - if it is unset - when `sys.stdout' points
         to a terminal device. Please note that `ui.formatted' should be
         considered an implementation detail; it is not intended for use outside
         Mercurial or its extensions.
 
         This function refers to output only; for input, see `ui.interactive()'.
         This function always returns false when in plain mode, see `ui.plain()'.
         """
         if self.plain():
             return False
 
         i = self.configbool(b"ui", b"formatted")
         if i is None:
             # some environments replace stdout without implementing isatty
             # usually those are non-interactive
             return self._isatty(self._fout)
 
         return i
 
     def _readline(
         self,
         prompt: bytes = b' ',
         promptopts: Optional[Dict[str, _MsgOpts]] = None,
     ) -> bytes:
         # Replacing stdin/stdout temporarily is a hard problem on Python 3
         # because they have to be text streams with *no buffering*. Instead,
         # we use rawinput() only if call_readline() will be invoked by
         # PyOS_Readline(), so no I/O will be made at Python layer.
         usereadline = (
             self._isatty(self._fin)
             and self._isatty(self._fout)
             and procutil.isstdin(self._fin)
             and procutil.isstdout(self._fout)
         )
         if usereadline:
             try:
                 # magically add command line editing support, where
                 # available
                 import readline
 
                 # force demandimport to really load the module
                 readline.read_history_file
                 # windows sometimes raises something other than ImportError
             except Exception:
                 usereadline = False
 
         if self._colormode == b'win32' or not usereadline:
             if not promptopts:
                 promptopts = {}
             self._writemsgnobuf(
                 self._fmsgout, prompt, type=b'prompt', **promptopts
             )
             self.flush()
             prompt = b' '
         else:
             prompt = self.label(prompt, b'ui.prompt') + b' '
 
         # prompt ' ' must exist; otherwise readline may delete entire line
         # - http://bugs.python.org/issue12833
         with self.timeblockedsection(b'stdio'):
             if usereadline:
                 self.flush()
                 prompt = encoding.strfromlocal(prompt)
                 line = encoding.strtolocal(input(prompt))
                 # When stdin is in binary mode on Windows, it can cause
                 # input() to emit an extra trailing carriage return
                 if pycompat.oslinesep == b'\r\n' and line.endswith(b'\r'):
                     line = line[:-1]
             else:
                 self._fout.write(pycompat.bytestr(prompt))
                 self._fout.flush()
                 line = self._fin.readline()
                 if not line:
                     raise EOFError
                 line = line.rstrip(pycompat.oslinesep)
 
         return line
 
     if pycompat.TYPE_CHECKING:
 
         @overload
         def prompt(self, msg: bytes, default: bytes) -> bytes:
             pass
 
         @overload
         def prompt(self, msg: bytes, default: None) -> Optional[bytes]:
             pass
 
     def prompt(self, msg, default=b"y"):
         """Prompt user with msg, read response.
         If ui is not interactive, the default is returned.
         """
         return self._prompt(msg, default=default)
 
     if pycompat.TYPE_CHECKING:
 
         @overload
         def _prompt(
             self, msg: bytes, default: bytes, **opts: _MsgOpts
         ) -> bytes:
             pass
 
         @overload
         def _prompt(
             self, msg: bytes, default: None, **opts: _MsgOpts
         ) -> Optional[bytes]:
             pass
 
     def _prompt(self, msg, default=b'y', **opts):
         opts = {**opts, 'default': default}
         if not self.interactive():
             self._writemsg(self._fmsgout, msg, b' ', type=b'prompt', **opts)
             self._writemsg(
                 self._fmsgout, default or b'', b"\n", type=b'promptecho'
             )
             return default
         try:
             r = self._readline(prompt=msg, promptopts=opts)
             if not r:
                 r = default
             if self.configbool(b'ui', b'promptecho'):
                 self._writemsg(
                     self._fmsgout, r or b'', b"\n", type=b'promptecho'
                 )
             return r
         except EOFError:
             raise error.ResponseExpected()
 
     @staticmethod
     def extractchoices(prompt: bytes) -> Tuple[bytes, List[_PromptChoice]]:
         """Extract prompt message and list of choices from specified prompt.
 
         This returns tuple "(message, choices)", and "choices" is the
         list of tuple "(response character, text without &)".
 
         >>> ui.extractchoices(b"awake? $$ &Yes $$ &No")
         ('awake? ', [('y', 'Yes'), ('n', 'No')])
         >>> ui.extractchoices(b"line\\nbreak? $$ &Yes $$ &No")
         ('line\\nbreak? ', [('y', 'Yes'), ('n', 'No')])
         >>> ui.extractchoices(b"want lots of $$money$$?$$Ye&s$$N&o")
         ('want lots of $$money$$?', [('s', 'Yes'), ('o', 'No')])
         """
 
         # Sadly, the prompt string may have been built with a filename
         # containing "$$" so let's try to find the first valid-looking
         # prompt to start parsing. Sadly, we also can't rely on
         # choices containing spaces, ASCII, or basically anything
         # except an ampersand followed by a character.
         m = re.match(br'(?s)(.+?)\$\$([^$]*&[^ $].*)', prompt)
 
         assert m is not None  # help pytype
 
         msg = m.group(1)
         choices = [p.strip(b' ') for p in m.group(2).split(b'$$')]
 
         def choicetuple(s):
             ampidx = s.index(b'&')
             return s[ampidx + 1 : ampidx + 2].lower(), s.replace(b'&', b'', 1)
 
         return (msg, [choicetuple(s) for s in choices])
 
     def promptchoice(self, prompt: bytes, default: int = 0) -> int:
         """Prompt user with a message, read response, and ensure it matches
         one of the provided choices. The prompt is formatted as follows:
 
            "would you like fries with that (Yn)? $$ &Yes $$ &No"
 
         The index of the choice is returned. Responses are case
         insensitive. If ui is not interactive, the default is
         returned.
         """
 
         msg, choices = self.extractchoices(prompt)
         resps = [r for r, t in choices]
         while True:
             r = self._prompt(msg, default=resps[default], choices=choices)
             if r.lower() in resps:
                 return resps.index(r.lower())
             # TODO: shouldn't it be a warning?
             self._writemsg(self._fmsgout, _(b"unrecognized response\n"))
 
     def getpass(
         self, prompt: Optional[bytes] = None, default: Optional[bytes] = None
     ) -> Optional[bytes]:
         if not self.interactive():
             return default
         try:
             self._writemsg(
                 self._fmsgerr,
                 prompt or _(b'password: '),
                 type=b'prompt',
                 password=True,
             )
             # disable getpass() only if explicitly specified. it's still valid
             # to interact with tty even if fin is not a tty.
             with self.timeblockedsection(b'stdio'):
                 if self.configbool(b'ui', b'nontty'):
                     l = self._fin.readline()
                     if not l:
                         raise EOFError
                     return l.rstrip(b'\n')
                 else:
                     return util.get_password()
         except EOFError:
             raise error.ResponseExpected()
 
     def status(self, *msg: bytes, **opts: _MsgOpts) -> None:
         """write status message to output (if ui.quiet is False)
 
         This adds an output label of "ui.status".
         """
         if not self.quiet:
             self._writemsg(self._fmsgout, type=b'status', *msg, **opts)
 
     def warn(self, *msg: bytes, **opts: _MsgOpts) -> None:
         """write warning message to output (stderr)
 
         This adds an output label of "ui.warning".
         """
         self._writemsg(self._fmsgerr, type=b'warning', *msg, **opts)
 
     def error(self, *msg: bytes, **opts: _MsgOpts) -> None:
         """write error message to output (stderr)
 
         This adds an output label of "ui.error".
         """
         self._writemsg(self._fmsgerr, type=b'error', *msg, **opts)
 
     def note(self, *msg: bytes, **opts: _MsgOpts) -> None:
         """write note to output (if ui.verbose is True)
 
         This adds an output label of "ui.note".
         """
         if self.verbose:
             self._writemsg(self._fmsgout, type=b'note', *msg, **opts)
 
     def debug(self, *msg: bytes, **opts: _MsgOpts) -> None:
         """write debug message to output (if ui.debugflag is True)
 
         This adds an output label of "ui.debug".
         """
         if self.debugflag:
             self._writemsg(self._fmsgout, type=b'debug', *msg, **opts)
             self.log(b'debug', b'%s', b''.join(msg))
 
     # Aliases to defeat check-code.
     statusnoi18n = status
     notenoi18n = note
     warnnoi18n = warn
     writenoi18n = write
 
     def edit(
         self,
         text: bytes,
         user: bytes,
         extra: Optional[Dict[bytes, Any]] = None,  # TODO: value type of bytes?
         editform=None,
         pending=None,
         repopath: Optional[bytes] = None,
         action: Optional[bytes] = None,
     ) -> bytes:
         if action is None:
             self.develwarn(
                 b'action is None but will soon be a required '
                 b'parameter to ui.edit()'
             )
         extra_defaults = {
             b'prefix': b'editor',
             b'suffix': b'.txt',
         }
         if extra is not None:
             if extra.get(b'suffix') is not None:
                 self.develwarn(
                     b'extra.suffix is not None but will soon be '
                     b'ignored by ui.edit()'
                 )
             extra_defaults.update(extra)
         extra = extra_defaults
 
         if action == b'diff':
             suffix = b'.diff'
         elif action:
             suffix = b'.%s.hg.txt' % action
         else:
             suffix = extra[b'suffix']
 
         rdir = None
         if self.configbool(b'experimental', b'editortmpinhg'):
             rdir = repopath
         (fd, name) = pycompat.mkstemp(
             prefix=b'hg-' + extra[b'prefix'] + b'-', suffix=suffix, dir=rdir
         )
         try:
             with os.fdopen(fd, 'wb') as f:
                 f.write(util.tonativeeol(text))
 
             environ = {b'HGUSER': user}
             if b'transplant_source' in extra:
                 environ.update(
                     {b'HGREVISION': hex(extra[b'transplant_source'])}
                 )
             for label in (b'intermediate-source', b'source', b'rebase_source'):
                 if label in extra:
                     environ.update({b'HGREVISION': extra[label]})
                     break
             if editform:
                 environ.update({b'HGEDITFORM': editform})
             if pending:
                 environ.update({b'HG_PENDING': pending})
 
             editor = self.geteditor()
 
             self.system(
                 b"%s \"%s\"" % (editor, name),
                 environ=environ,
                 onerr=error.CanceledError,
                 errprefix=_(b"edit failed"),
                 blockedtag=b'editor',
             )
 
             with open(name, 'rb') as f:
                 t = util.fromnativeeol(f.read())
         finally:
             os.unlink(name)
 
         return t
 
     def system(
         self,
         cmd: bytes,
         environ=None,
         cwd: Optional[bytes] = None,
         onerr: Optional[Callable[[bytes], Exception]] = None,
         errprefix: Optional[bytes] = None,
         blockedtag: Optional[bytes] = None,
     ) -> int:
         """execute shell command with appropriate output stream. command
         output will be redirected if fout is not stdout.
 
         if command fails and onerr is None, return status, else raise onerr
         object as exception.
         """
         if blockedtag is None:
             # Long cmds tend to be because of an absolute path on cmd. Keep
             # the tail end instead
             cmdsuffix = cmd.translate(None, _keepalnum)[-85:]
             blockedtag = b'unknown_system_' + cmdsuffix
         out = self._fout
         if any(s[1] for s in self._bufferstates):
             out = self
         with self.timeblockedsection(blockedtag):
             rc = self._runsystem(cmd, environ=environ, cwd=cwd, out=out)
         if rc and onerr:
             errmsg = b'%s %s' % (
                 procutil.shellsplit(cmd)[0],
                 procutil.explainexit(rc),
             )
             if errprefix:
                 errmsg = b'%s: %s' % (errprefix, errmsg)
             raise onerr(errmsg)
         return rc
 
     def _runsystem(self, cmd: bytes, environ, cwd: Optional[bytes], out) -> int:
         """actually execute the given shell command (can be overridden by
         extensions like chg)"""
         return procutil.system(cmd, environ=environ, cwd=cwd, out=out)
 
     def traceback(self, exc=None, force: bool = False):
         """print exception traceback if traceback printing enabled or forced.
         only to call in exception handler. returns true if traceback
         printed."""
         if self.tracebackflag or force:
             if exc is None:
                 exc = sys.exc_info()
             cause = getattr(exc[1], 'cause', None)
 
             if cause is not None:
                 causetb = traceback.format_tb(cause[2])
                 exctb = traceback.format_tb(exc[2])
                 exconly = traceback.format_exception_only(cause[0], cause[1])
 
                 # exclude frame where 'exc' was chained and rethrown from exctb
                 self.write_err(
                     b'Traceback (most recent call last):\n',
                     encoding.strtolocal(''.join(exctb[:-1])),
                     encoding.strtolocal(''.join(causetb)),
                     encoding.strtolocal(''.join(exconly)),
                 )
             else:
                 output = traceback.format_exception(exc[0], exc[1], exc[2])
                 self.write_err(encoding.strtolocal(''.join(output)))
         return self.tracebackflag or force
 
     def geteditor(self):
         '''return editor to use'''
         if pycompat.sysplatform == b'plan9':
             # vi is the MIPS instruction simulator on Plan 9. We
             # instead default to E to plumb commit messages to
             # avoid confusion.
             editor = b'E'
         elif pycompat.isdarwin:
             # vi on darwin is POSIX compatible to a fault, and that includes
             # exiting non-zero if you make any mistake when running an ex
             # command. Proof: `vi -c ':unknown' -c ':qa'; echo $?` produces 1,
             # while s/vi/vim/ doesn't.
             editor = b'vim'
         else:
             editor = b'vi'
         return encoding.environ.get(b"HGEDITOR") or self.config(
             b"ui", b"editor", editor
         )
 
     @util.propertycache
     def _progbar(self) -> Optional[progress.progbar]:
         """setup the progbar singleton to the ui object"""
         if (
             self.quiet
             or self.debugflag
             or self.configbool(b'progress', b'disable')
             or not progress.shouldprint(self)
         ):
             return None
         return getprogbar(self)
 
     def _progclear(self) -> None:
         """clear progress bar output if any. use it before any output"""
         if not haveprogbar():  # nothing loaded yet
             return
         if self._progbar is not None and self._progbar.printed:
             self._progbar.clear()
 
     def makeprogress(
         self, topic: bytes, unit: bytes = b"", total: Optional[int] = None
     ) -> scmutil.progress:
         """Create a progress helper for the specified topic"""
         if getattr(self._fmsgerr, 'structured', False):
             # channel for machine-readable output with metadata, just send
             # raw information
             # TODO: consider porting some useful information (e.g. estimated
             # time) from progbar. we might want to support update delay to
             # reduce the cost of transferring progress messages.
             def updatebar(topic, pos, item, unit, total):
                 self._fmsgerr.write(
                     None,
                     type=b'progress',
                     topic=topic,
                     pos=pos,
                     item=item,
                     unit=unit,
                     total=total,
                 )
 
         elif self._progbar is not None:
             updatebar = self._progbar.progress
         else:
 
             def updatebar(topic, pos, item, unit, total):
                 pass
 
         return scmutil.progress(self, updatebar, topic, unit, total)
 
     def getlogger(self, name):
         """Returns a logger of the given name; or None if not registered"""
         return self._loggers.get(name)
 
     def setlogger(self, name, logger) -> None:
         """Install logger which can be identified later by the given name
 
         More than one loggers can be registered. Use extension or module
         name to uniquely identify the logger instance.
         """
         self._loggers[name] = logger
 
     def log(self, event, msgfmt, *msgargs, **opts) -> None:
         """hook for logging facility extensions
 
         event should be a readily-identifiable subsystem, which will
         allow filtering.
 
         msgfmt should be a newline-terminated format string to log, and
         *msgargs are %-formatted into it.
 
         **opts currently has no defined meanings.
         """
         if not self._loggers:
             return
         activeloggers = [l for l in self._loggers.values() if l.tracked(event)]
         if not activeloggers:
             return
         msg = msgfmt % msgargs
         opts = pycompat.byteskwargs(opts)
         # guard against recursion from e.g. ui.debug()
         registeredloggers = self._loggers
         self._loggers = {}
         try:
             for logger in activeloggers:
                 logger.log(self, event, msg, opts)
         finally:
             self._loggers = registeredloggers
 
     def label(self, msg: bytes, label: bytes) -> bytes:
         """style msg based on supplied label
 
         If some color mode is enabled, this will add the necessary control
         characters to apply such color. In addition, 'debug' color mode adds
         markup showing which label affects a piece of text.
 
         ui.write(s, 'label') is equivalent to
         ui.write(ui.label(s, 'label')).
         """
         if self._colormode is not None:
             return color.colorlabel(self, msg, label)
         return msg
 
     def develwarn(
         self, msg: bytes, stacklevel: int = 1, config: Optional[bytes] = None
     ) -> None:
         """issue a developer warning message
 
         Use 'stacklevel' to report the offender some layers further up in the
         stack.
         """
         if not self.configbool(b'devel', b'all-warnings'):
             if config is None or not self.configbool(b'devel', config):
                 return
         msg = b'devel-warn: ' + msg
         stacklevel += 1  # get in develwarn
         if self.tracebackflag:
             util.debugstacktrace(msg, stacklevel, self._ferr, self._fout)
             self.log(
                 b'develwarn',
                 b'%s at:\n%s'
                 % (msg, b''.join(util.getstackframes(stacklevel))),
             )
         else:
             curframe = inspect.currentframe()
             calframe = inspect.getouterframes(curframe, 2)
             fname, lineno, fmsg = calframe[stacklevel][1:4]
             fname, fmsg = pycompat.sysbytes(fname), pycompat.sysbytes(fmsg)
             self.write_err(b'%s at: %s:%d (%s)\n' % (msg, fname, lineno, fmsg))
             self.log(
                 b'develwarn', b'%s at: %s:%d (%s)\n', msg, fname, lineno, fmsg
             )
 
             # avoid cycles
             del curframe
             del calframe
 
     def deprecwarn(
         self,
         msg: bytes,
         version: bytes,
         stacklevel: int = 2,
     ) -> None:
         """issue a deprecation warning
 
         - msg: message explaining what is deprecated and how to upgrade,
         - version: last version where the API will be supported,
         """
         if not (
             self.configbool(b'devel', b'all-warnings')
             or self.configbool(b'devel', b'deprec-warn')
         ):
             return
         msg += (
             b"\n(compatibility will be dropped after Mercurial-%s,"
             b" update your code.)"
         ) % version
         self.develwarn(msg, stacklevel=stacklevel, config=b'deprec-warn')
 
     def exportableenviron(self):
         """The environment variables that are safe to export, e.g. through
         hgweb.
         """
         return self._exportableenviron
 
     @contextlib.contextmanager
     def configoverride(self, overrides: _ConfigItems, source: bytes = b""):
         """Context manager for temporary config overrides
         `overrides` must be a dict of the following structure:
         {(section, name) : value}"""
         backups = {}
         try:
             for (section, name), value in overrides.items():
                 backups[(section, name)] = self.backupconfig(section, name)
                 self.setconfig(section, name, value, source)
             yield
         finally:
             for __, backup in backups.items():
                 self.restoreconfig(backup)
             # just restoring ui.quiet config to the previous value is not enough
             # as it does not update ui.quiet class member
             if (b'ui', b'quiet') in overrides:
                 self.fixconfig(section=b'ui')
 
     def estimatememory(self) -> Optional[int]:
         """Provide an estimate for the available system memory in Bytes.
 
         This can be overriden via ui.available-memory. It returns None, if
         no estimate can be computed.
         """
         value = self.config(b'ui', b'available-memory')
         if value is not None:
             try:
                 return util.sizetoint(value)
             except error.ParseError:
                 raise error.ConfigError(
                     _(b"ui.available-memory value is invalid ('%s')") % value
                 )
         return util._estimatememory()
 
 
 # we instantiate one globally shared progress bar to avoid
 # competing progress bars when multiple UI objects get created
 _progresssingleton: Optional[progress.progbar] = None
 
 
 def getprogbar(ui: ui) -> progress.progbar:
     global _progresssingleton
     if _progresssingleton is None:
         # passing 'ui' object to the singleton is fishy,
         # this is how the extension used to work but feel free to rework it.
         _progresssingleton = progress.progbar(ui)
     return _progresssingleton
 
 
 def haveprogbar() -> bool:
     return _progresssingleton is not None
 
 
 def _selectmsgdests(ui: ui):
     name = ui.config(b'ui', b'message-output')
     if name == b'channel':
         if ui.fmsg:
             return ui.fmsg, ui.fmsg
         else:
             # fall back to ferr if channel isn't ready so that status/error
             # messages can be printed
             return ui.ferr, ui.ferr
     if name == b'stdio':
         return ui.fout, ui.ferr
     if name == b'stderr':
         return ui.ferr, ui.ferr
     raise error.Abort(b'invalid ui.message-output destination: %s' % name)
 
 
 def _writemsgwith(write, dest, *args: bytes, **opts: _MsgOpts) -> None:
     """Write ui message with the given ui._write*() function
 
     The specified message type is translated to 'ui.<type>' label if the dest
     isn't a structured channel, so that the message will be colorized.
     """
     # TODO: maybe change 'type' to a mandatory option
     if 'type' in opts and not getattr(dest, 'structured', False):
         opts['label'] = opts.get('label', b'') + b' ui.%s' % opts.pop('type')
     write(dest, *args, **opts)

rust/hg-core/src/config/config_items.rs

@@ -1,669 +1,692 b''
 //! Code for parsing default Mercurial config items.
 use itertools::Itertools;
 use serde::Deserialize;
 
 use crate::{errors::HgError, exit_codes, FastHashMap};
 
 /// Corresponds to the structure of `mercurial/configitems.toml`.
 #[derive(Debug, Deserialize)]
 pub struct ConfigItems {
     items: Vec<DefaultConfigItem>,
     templates: FastHashMap<String, Vec<TemplateItem>>,
     #[serde(rename = "template-applications")]
     template_applications: Vec<TemplateApplication>,
 }
 
 /// Corresponds to a config item declaration in `mercurial/configitems.toml`.
 #[derive(Clone, Debug, PartialEq, Deserialize)]
 #[serde(try_from = "RawDefaultConfigItem")]
 pub struct DefaultConfigItem {
     /// Section of the config the item is in (e.g. `[merge-tools]`)
     section: String,
     /// Name of the item (e.g. `meld.gui`)
     name: String,
     /// Default value (can be dynamic, see [`DefaultConfigItemType`])
     default: Option<DefaultConfigItemType>,
     /// If the config option is generic (e.g. `merge-tools.*`), defines
     /// the priority of this item relative to other generic items.
     /// If we're looking for <pattern>, then all generic items within the same
     /// section will be sorted by order of priority, and the first regex match
     /// against `name` is returned.
     #[serde(default)]
     priority: Option<isize>,
     /// Aliases, if any. Each alias is a tuple of `(section, name)` for each
     /// option that is aliased to this one.
     #[serde(default)]
     alias: Vec<(String, String)>,
     /// Whether the config item is marked as experimental
     #[serde(default)]
     experimental: bool,
     /// The (possibly empty) docstring for the item
     #[serde(default)]
     documentation: String,
+    /// Whether the item is part of an in-core extension. This allows us to
+    /// hide them if the extension is not enabled, to preserve legacy
+    /// behavior.
+    #[serde(default)]
+    in_core_extension: Option<String>,
 }
 
 /// Corresponds to the raw (i.e. on disk) structure of config items. Used as
 /// an intermediate step in deserialization.
 #[derive(Clone, Debug, Deserialize)]
 struct RawDefaultConfigItem {
     section: String,
     name: String,
     default: Option<toml::Value>,
     #[serde(rename = "default-type")]
     default_type: Option<String>,
     #[serde(default)]
     priority: isize,
     #[serde(default)]
     generic: bool,
     #[serde(default)]
     alias: Vec<(String, String)>,
     #[serde(default)]
     experimental: bool,
     #[serde(default)]
     documentation: String,
+    #[serde(default)]
+    in_core_extension: Option<String>,
 }
 
 impl TryFrom<RawDefaultConfigItem> for DefaultConfigItem {
     type Error = HgError;
 
     fn try_from(value: RawDefaultConfigItem) -> Result<Self, Self::Error> {
         Ok(Self {
             section: value.section,
             name: value.name,
             default: raw_default_to_concrete(
                 value.default_type,
                 value.default,
             )?,
             priority: if value.generic {
                 Some(value.priority)
             } else {
                 None
             },
             alias: value.alias,
             experimental: value.experimental,
             documentation: value.documentation,
+            in_core_extension: value.in_core_extension,
         })
     }
 }
 
 impl DefaultConfigItem {
     fn is_generic(&self) -> bool {
         self.priority.is_some()
     }
+
+    pub fn in_core_extension(&self) -> Option<&str> {
+        self.in_core_extension.as_deref()
+    }
+
+    pub fn section(&self) -> &str {
+        self.section.as_ref()
+    }
 }
 
 impl<'a> TryFrom<&'a DefaultConfigItem> for Option<&'a str> {
     type Error = HgError;
 
     fn try_from(
         value: &'a DefaultConfigItem,
     ) -> Result<Option<&'a str>, Self::Error> {
         match &value.default {
             Some(default) => {
                 let err = HgError::abort(
                     format!(
                         "programming error: wrong query on config item '{}.{}'",
                         value.section,
                         value.name
                     ),
                     exit_codes::ABORT,
                     Some(format!(
                         "asked for '&str', type of default is '{}'",
                         default.type_str()
                     )),
                 );
                 match default {
                     DefaultConfigItemType::Primitive(toml::Value::String(
                         s,
                     )) => Ok(Some(s)),
                     _ => Err(err),
                 }
             }
             None => Ok(None),
         }
     }
 }
 
 impl TryFrom<&DefaultConfigItem> for Option<bool> {
     type Error = HgError;
 
     fn try_from(value: &DefaultConfigItem) -> Result<Self, Self::Error> {
         match &value.default {
             Some(default) => {
                 let err = HgError::abort(
                     format!(
                         "programming error: wrong query on config item '{}.{}'",
                         value.section,
                         value.name
                     ),
                     exit_codes::ABORT,
                     Some(format!(
                         "asked for 'bool', type of default is '{}'",
                         default.type_str()
                     )),
                 );
                 match default {
                     DefaultConfigItemType::Primitive(
                         toml::Value::Boolean(b),
                     ) => Ok(Some(*b)),
                     _ => Err(err),
                 }
             }
             None => Ok(Some(false)),
         }
     }
 }
 
 impl TryFrom<&DefaultConfigItem> for Option<u32> {
     type Error = HgError;
 
     fn try_from(value: &DefaultConfigItem) -> Result<Self, Self::Error> {
         match &value.default {
             Some(default) => {
                 let err = HgError::abort(
                     format!(
                         "programming error: wrong query on config item '{}.{}'",
                         value.section,
                         value.name
                     ),
                     exit_codes::ABORT,
                     Some(format!(
                         "asked for 'u32', type of default is '{}'",
                         default.type_str()
                     )),
                 );
                 match default {
                     DefaultConfigItemType::Primitive(
                         toml::Value::Integer(b),
                     ) => {
                         Ok(Some((*b).try_into().expect("TOML integer to u32")))
                     }
                     _ => Err(err),
                 }
             }
             None => Ok(None),
         }
     }
 }
 
 impl TryFrom<&DefaultConfigItem> for Option<u64> {
     type Error = HgError;
 
     fn try_from(value: &DefaultConfigItem) -> Result<Self, Self::Error> {
         match &value.default {
             Some(default) => {
                 let err = HgError::abort(
                     format!(
                         "programming error: wrong query on config item '{}.{}'",
                         value.section,
                         value.name
                     ),
                     exit_codes::ABORT,
                     Some(format!(
                         "asked for 'u64', type of default is '{}'",
                         default.type_str()
                     )),
                 );
                 match default {
                     DefaultConfigItemType::Primitive(
                         toml::Value::Integer(b),
                     ) => {
                         Ok(Some((*b).try_into().expect("TOML integer to u64")))
                     }
                     _ => Err(err),
                 }
             }
             None => Ok(None),
         }
     }
 }
 
 /// Allows abstracting over more complex default values than just primitives.
 /// The former `configitems.py` contained some dynamic code that is encoded
 /// in this enum.
 #[derive(Debug, PartialEq, Clone, Deserialize)]
 pub enum DefaultConfigItemType {
     /// Some primitive type (string, integer, boolean)
     Primitive(toml::Value),
     /// A dynamic value that will be given by the code at runtime
     Dynamic,
     /// An lazily-returned array (possibly only relevant in the Python impl)
     /// Example: `lambda: [b"zstd", b"zlib"]`
     Lambda(Vec<String>),
     /// For now, a special case for `web.encoding` that points to the
     /// `encoding.encoding` module in the Python impl so that local encoding
     /// is correctly resolved at runtime
     LazyModule(String),
     ListType,
 }
 
 impl DefaultConfigItemType {
     pub fn type_str(&self) -> &str {
         match self {
             DefaultConfigItemType::Primitive(primitive) => {
                 primitive.type_str()
             }
             DefaultConfigItemType::Dynamic => "dynamic",
             DefaultConfigItemType::Lambda(_) => "lambda",
             DefaultConfigItemType::LazyModule(_) => "lazy_module",
             DefaultConfigItemType::ListType => "list_type",
         }
     }
 }
 
 /// Most of the fields are shared with [`DefaultConfigItem`].
 #[derive(Debug, Clone, Deserialize)]
 #[serde(try_from = "RawTemplateItem")]
 struct TemplateItem {
     suffix: String,
     default: Option<DefaultConfigItemType>,
     priority: Option<isize>,
     #[serde(default)]
     alias: Vec<(String, String)>,
     #[serde(default)]
     experimental: bool,
     #[serde(default)]
     documentation: String,
 }
 
 /// Corresponds to the raw (i.e. on disk) representation of a template item.
 /// Used as an intermediate step in deserialization.
 #[derive(Clone, Debug, Deserialize)]
 struct RawTemplateItem {
     suffix: String,
     default: Option<toml::Value>,
     #[serde(rename = "default-type")]
     default_type: Option<String>,
     #[serde(default)]
     priority: isize,
     #[serde(default)]
     generic: bool,
     #[serde(default)]
     alias: Vec<(String, String)>,
     #[serde(default)]
     experimental: bool,
     #[serde(default)]
     documentation: String,
 }
 
 impl TemplateItem {
     fn into_default_item(
         self,
         application: TemplateApplication,
     ) -> DefaultConfigItem {
         DefaultConfigItem {
             section: application.section,
             name: application
                 .prefix
                 .map(|prefix| format!("{}.{}", prefix, self.suffix))
                 .unwrap_or(self.suffix),
             default: self.default,
             priority: self.priority,
             alias: self.alias,
             experimental: self.experimental,
             documentation: self.documentation,
+            in_core_extension: None,
         }
     }
 }
 
 impl TryFrom<RawTemplateItem> for TemplateItem {
     type Error = HgError;
 
     fn try_from(value: RawTemplateItem) -> Result<Self, Self::Error> {
         Ok(Self {
             suffix: value.suffix,
             default: raw_default_to_concrete(
                 value.default_type,
                 value.default,
             )?,
             priority: if value.generic {
                 Some(value.priority)
             } else {
                 None
             },
             alias: value.alias,
             experimental: value.experimental,
             documentation: value.documentation,
         })
     }
 }
 
 /// Transforms the on-disk string-based representation of complex default types
 /// to the concrete [`DefaultconfigItemType`].
 fn raw_default_to_concrete(
     default_type: Option<String>,
     default: Option<toml::Value>,
 ) -> Result<Option<DefaultConfigItemType>, HgError> {
     Ok(match default_type.as_deref() {
         None => default.as_ref().map(|default| {
             DefaultConfigItemType::Primitive(default.to_owned())
         }),
         Some("dynamic") => Some(DefaultConfigItemType::Dynamic),
         Some("list_type") => Some(DefaultConfigItemType::ListType),
         Some("lambda") => match &default {
             Some(default) => Some(DefaultConfigItemType::Lambda(
                 default.to_owned().try_into().map_err(|e| {
                     HgError::abort(
                         e.to_string(),
                         exit_codes::ABORT,
                         Some("Check 'mercurial/configitems.toml'".into()),
                     )
                 })?,
             )),
             None => {
                 return Err(HgError::abort(
                     "lambda defined with no return value".to_string(),
                     exit_codes::ABORT,
                     Some("Check 'mercurial/configitems.toml'".into()),
                 ))
             }
         },
         Some("lazy_module") => match &default {
             Some(default) => {
                 Some(DefaultConfigItemType::LazyModule(match default {
                     toml::Value::String(module) => module.to_owned(),
                     _ => {
                         return Err(HgError::abort(
                             "lazy_module module name should be a string"
                                 .to_string(),
                             exit_codes::ABORT,
                             Some("Check 'mercurial/configitems.toml'".into()),
                         ))
                     }
                 }))
             }
             None => {
                 return Err(HgError::abort(
                     "lazy_module should have a default value".to_string(),
                     exit_codes::ABORT,
                     Some("Check 'mercurial/configitems.toml'".into()),
                 ))
             }
         },
         Some(invalid) => {
             return Err(HgError::abort(
                 format!("invalid default_type '{}'", invalid),
                 exit_codes::ABORT,
                 Some("Check 'mercurial/configitems.toml'".into()),
             ))
         }
     })
 }
 
 #[derive(Debug, Clone, Deserialize)]
 struct TemplateApplication {
     template: String,
     section: String,
     #[serde(default)]
     prefix: Option<String>,
 }
 
 /// Represents the (dynamic) set of default core Mercurial config items from
 /// `mercurial/configitems.toml`.
 #[derive(Clone, Debug, Default)]
 pub struct DefaultConfig {
     /// Mapping of section -> (mapping of name -> item)
     items: FastHashMap<String, FastHashMap<String, DefaultConfigItem>>,
 }
 
 impl DefaultConfig {
     pub fn empty() -> DefaultConfig {
         Self {
             items: Default::default(),
         }
     }
 
     /// Returns `Self`, given the contents of `mercurial/configitems.toml`
     #[logging_timer::time("trace")]
     pub fn from_contents(contents: &str) -> Result<Self, HgError> {
         let mut from_file: ConfigItems =
             toml::from_str(contents).map_err(|e| {
                 HgError::abort(
                     e.to_string(),
                     exit_codes::ABORT,
                     Some("Check 'mercurial/configitems.toml'".into()),
                 )
             })?;
 
         let mut flat_items = from_file.items;
 
         for application in from_file.template_applications.drain(..) {
             match from_file.templates.get(&application.template) {
                 None => return Err(
                     HgError::abort(
                         format!(
                             "template application refers to undefined template '{}'",
                             application.template
                         ),
                         exit_codes::ABORT,
                         Some("Check 'mercurial/configitems.toml'".into())
                     )
                 ),
                 Some(template_items) => {
                     for template_item in template_items {
                         flat_items.push(
                             template_item
                                 .clone()
                                 .into_default_item(application.clone()),
                         )
                     }
                 }
             };
         }
 
         let items = flat_items.into_iter().fold(
             FastHashMap::default(),
             |mut acc, item| {
                 acc.entry(item.section.to_owned())
                     .or_insert_with(|| {
                         let mut section = FastHashMap::default();
                         section.insert(item.name.to_owned(), item.to_owned());
                         section
                     })
                     .insert(item.name.to_owned(), item);
                 acc
             },
         );
 
         Ok(Self { items })
     }
 
     /// Return the default config item that matches `section` and `item`.
     pub fn get(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Option<&DefaultConfigItem> {
         // Core items must be valid UTF-8
         let section = String::from_utf8_lossy(section);
         let section_map = self.items.get(section.as_ref())?;
         let item_name_lossy = String::from_utf8_lossy(item);
         match section_map.get(item_name_lossy.as_ref()) {
             Some(item) => Some(item),
             None => {
                 for generic_item in section_map
                     .values()
                     .filter(|item| item.is_generic())
                     .sorted_by_key(|item| match item.priority {
                         Some(priority) => (priority, &item.name),
                         _ => unreachable!(),
                     })
                 {
                     if regex::bytes::Regex::new(&generic_item.name)
                         .expect("invalid regex in configitems")
                         .is_match(item)
                     {
                         return Some(generic_item);
                     }
                 }
                 None
             }
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
     use crate::config::config_items::{
         DefaultConfigItem, DefaultConfigItemType,
     };
 
     use super::DefaultConfig;
 
     #[test]
     fn test_config_read() {
         let contents = r#"
 [[items]]
 section = "alias"
 name = "abcd.*"
 default = 3
 generic = true
 priority = -1
 
 [[items]]
 section = "alias"
 name = ".*"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "cmdserver"
 name = "track-log"
 default-type = "lambda"
 default = [ "chgserver", "cmdserver", "repocache",]
 
 [[items]]
 section = "chgserver"
 name = "idletimeout"
 default = 3600
 
 [[items]]
 section = "cmdserver"
 name = "message-encodings"
 default-type = "list_type"
 
 [[items]]
 section = "web"
 name = "encoding"
 default-type = "lazy_module"
 default = "encoding.encoding"
 
 [[items]]
 section = "command-templates"
 name = "graphnode"
 alias = [["ui", "graphnodetemplate"]]
 documentation = """This is a docstring.
 This is another line \
 but this is not."""
 
 [[items]]
 section = "censor"
 name = "policy"
 default = "abort"
 experimental = true
 
 [[template-applications]]
 template = "diff-options"
 section = "commands"
 prefix = "revert.interactive"
 
 [[template-applications]]
 template = "diff-options"
 section = "diff"
 
 [templates]
 [[templates.diff-options]]
 suffix = "nodates"
 default = false
 
 [[templates.diff-options]]
 suffix = "showfunc"
 default = false
 
 [[templates.diff-options]]
 suffix = "unified"
 "#;
         let res = DefaultConfig::from_contents(contents);
         let config = match res {
             Ok(config) => config,
             Err(e) => panic!("{}", e),
         };
         let expected = DefaultConfigItem {
             section: "censor".into(),
             name: "policy".into(),
             default: Some(DefaultConfigItemType::Primitive("abort".into())),
             priority: None,
             alias: vec![],
             experimental: true,
             documentation: "".into(),
+            in_core_extension: None,
         };
         assert_eq!(config.get(b"censor", b"policy"), Some(&expected));
 
         // Test generic priority. The `.*` pattern is wider than `abcd.*`, but
         // `abcd.*` has priority, so it should match first.
         let expected = DefaultConfigItem {
             section: "alias".into(),
             name: "abcd.*".into(),
             default: Some(DefaultConfigItemType::Primitive(3.into())),
             priority: Some(-1),
             alias: vec![],
             experimental: false,
             documentation: "".into(),
+            in_core_extension: None,
         };
         assert_eq!(config.get(b"alias", b"abcdsomething"), Some(&expected));
 
         //... but if it doesn't, we should fallback to `.*`
         let expected = DefaultConfigItem {
             section: "alias".into(),
             name: ".*".into(),
             default: Some(DefaultConfigItemType::Dynamic),
             priority: Some(0),
             alias: vec![],
             experimental: false,
             documentation: "".into(),
+            in_core_extension: None,
         };
         assert_eq!(config.get(b"alias", b"something"), Some(&expected));
 
         let expected = DefaultConfigItem {
             section: "chgserver".into(),
             name: "idletimeout".into(),
             default: Some(DefaultConfigItemType::Primitive(3600.into())),
             priority: None,
             alias: vec![],
             experimental: false,
             documentation: "".into(),
+            in_core_extension: None,
         };
         assert_eq!(config.get(b"chgserver", b"idletimeout"), Some(&expected));
 
         let expected = DefaultConfigItem {
             section: "cmdserver".into(),
             name: "track-log".into(),
             default: Some(DefaultConfigItemType::Lambda(vec![
                 "chgserver".into(),
                 "cmdserver".into(),
                 "repocache".into(),
             ])),
             priority: None,
             alias: vec![],
             experimental: false,
             documentation: "".into(),
+            in_core_extension: None,
         };
         assert_eq!(config.get(b"cmdserver", b"track-log"), Some(&expected));
 
         let expected = DefaultConfigItem {
             section: "command-templates".into(),
             name: "graphnode".into(),
             default: None,
             priority: None,
             alias: vec![("ui".into(), "graphnodetemplate".into())],
             experimental: false,
             documentation:
                 "This is a docstring.\nThis is another line but this is not."
                     .into(),
+            in_core_extension: None,
         };
         assert_eq!(
             config.get(b"command-templates", b"graphnode"),
             Some(&expected)
         );
     }
 }

rust/hg-core/src/config/mod.rs

@@ -1,728 +1,738 b''
 // config.rs
 //
 // Copyright 2020
 //      Valentin Gatien-Baron,
 //      Raphaël Gomès <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 //! Mercurial config parsing and interfaces.
 
 pub mod config_items;
 mod layer;
 mod plain_info;
 mod values;
 pub use layer::{ConfigError, ConfigOrigin, ConfigParseError};
 use lazy_static::lazy_static;
 pub use plain_info::PlainInfo;
 
 use self::config_items::DefaultConfig;
 use self::config_items::DefaultConfigItem;
 use self::layer::ConfigLayer;
 use self::layer::ConfigValue;
 use crate::errors::HgError;
 use crate::errors::{HgResultExt, IoResultExt};
 use crate::utils::files::get_bytes_from_os_str;
 use format_bytes::{write_bytes, DisplayBytes};
 use std::collections::HashSet;
 use std::env;
 use std::fmt;
 use std::path::{Path, PathBuf};
 use std::str;
 
 lazy_static! {
     static ref DEFAULT_CONFIG: Result<DefaultConfig, HgError> = {
         DefaultConfig::from_contents(include_str!(
             "../../../../mercurial/configitems.toml"
         ))
     };
 }
 
 /// Holds the config values for the current repository
 /// TODO update this docstring once we support more sources
 #[derive(Clone)]
 pub struct Config {
     layers: Vec<layer::ConfigLayer>,
     plain: PlainInfo,
 }
 
 impl DisplayBytes for Config {
     fn display_bytes(
         &self,
         out: &mut dyn std::io::Write,
     ) -> std::io::Result<()> {
         for (index, layer) in self.layers.iter().rev().enumerate() {
             write_bytes!(
                 out,
                 b"==== Layer {} (trusted: {}) ====\n{}",
                 index,
                 if layer.trusted {
                     &b"yes"[..]
                 } else {
                     &b"no"[..]
                 },
                 layer
             )?;
         }
         Ok(())
     }
 }
 
 pub enum ConfigSource {
     /// Absolute path to a config file
     AbsPath(PathBuf),
     /// Already parsed (from the CLI, env, Python resources, etc.)
     Parsed(layer::ConfigLayer),
 }
 
 #[derive(Debug)]
 pub struct ConfigValueParseErrorDetails {
     pub origin: ConfigOrigin,
     pub line: Option<usize>,
     pub section: Vec<u8>,
     pub item: Vec<u8>,
     pub value: Vec<u8>,
     pub expected_type: &'static str,
 }
 
 // boxed to avoid very large Result types
 pub type ConfigValueParseError = Box<ConfigValueParseErrorDetails>;
 
 impl fmt::Display for ConfigValueParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // TODO: add origin and line number information, here and in
         // corresponding python code
         write!(
             f,
             "config error: {}.{} is not a {} ('{}')",
             String::from_utf8_lossy(&self.section),
             String::from_utf8_lossy(&self.item),
             self.expected_type,
             String::from_utf8_lossy(&self.value)
         )
     }
 }
 
 /// Returns true if the config item is disabled by PLAIN or PLAINEXCEPT
 fn should_ignore(plain: &PlainInfo, section: &[u8], item: &[u8]) -> bool {
     // duplication with [_applyconfig] in [ui.py],
     if !plain.is_plain() {
         return false;
     }
     if section == b"alias" {
         return plain.plainalias();
     }
     if section == b"revsetalias" {
         return plain.plainrevsetalias();
     }
     if section == b"templatealias" {
         return plain.plaintemplatealias();
     }
     if section == b"ui" {
         let to_delete: &[&[u8]] = &[
             b"debug",
             b"fallbackencoding",
             b"quiet",
             b"slash",
             b"logtemplate",
             b"message-output",
             b"statuscopies",
             b"style",
             b"traceback",
             b"verbose",
         ];
         return to_delete.contains(&item);
     }
     let sections_to_delete: &[&[u8]] =
         &[b"defaults", b"commands", b"command-templates"];
     sections_to_delete.contains(&section)
 }
 
 impl Config {
     /// The configuration to use when printing configuration-loading errors
     pub fn empty() -> Self {
         Self {
             layers: Vec::new(),
             plain: PlainInfo::empty(),
         }
     }
 
     /// Load system and user configuration from various files.
     ///
     /// This is also affected by some environment variables.
     pub fn load_non_repo() -> Result<Self, ConfigError> {
         let mut config = Self::empty();
         let opt_rc_path = env::var_os("HGRCPATH");
         // HGRCPATH replaces system config
         if opt_rc_path.is_none() {
             config.add_system_config()?
         }
 
         config.add_for_environment_variable("EDITOR", b"ui", b"editor");
         config.add_for_environment_variable("VISUAL", b"ui", b"editor");
         config.add_for_environment_variable("PAGER", b"pager", b"pager");
 
         // These are set by `run-tests.py --rhg` to enable fallback for the
         // entire test suite. Alternatives would be setting configuration
         // through `$HGRCPATH` but some tests override that, or changing the
         // `hg` shell alias to include `--config` but that disrupts tests that
         // print command lines and check expected output.
         config.add_for_environment_variable(
             "RHG_ON_UNSUPPORTED",
             b"rhg",
             b"on-unsupported",
         );
         config.add_for_environment_variable(
             "RHG_FALLBACK_EXECUTABLE",
             b"rhg",
             b"fallback-executable",
         );
 
         // HGRCPATH replaces user config
         if opt_rc_path.is_none() {
             config.add_user_config()?
         }
         if let Some(rc_path) = &opt_rc_path {
             for path in env::split_paths(rc_path) {
                 if !path.as_os_str().is_empty() {
                     if path.is_dir() {
                         config.add_trusted_dir(&path)?
                     } else {
                         config.add_trusted_file(&path)?
                     }
                 }
             }
         }
         Ok(config)
     }
 
     pub fn load_cli_args(
         &mut self,
         cli_config_args: impl IntoIterator<Item = impl AsRef<[u8]>>,
         color_arg: Option<Vec<u8>>,
     ) -> Result<(), ConfigError> {
         if let Some(layer) = ConfigLayer::parse_cli_args(cli_config_args)? {
             self.layers.push(layer)
         }
         if let Some(arg) = color_arg {
             let mut layer = ConfigLayer::new(ConfigOrigin::CommandLineColor);
             layer.add(b"ui"[..].into(), b"color"[..].into(), arg, None);
             self.layers.push(layer)
         }
         Ok(())
     }
 
     fn add_trusted_dir(&mut self, path: &Path) -> Result<(), ConfigError> {
         if let Some(entries) = std::fs::read_dir(path)
             .when_reading_file(path)
             .io_not_found_as_none()?
         {
             let mut file_paths = entries
                 .map(|result| {
                     result.when_reading_file(path).map(|entry| entry.path())
                 })
                 .collect::<Result<Vec<_>, _>>()?;
             file_paths.sort();
             for file_path in &file_paths {
                 if file_path.extension() == Some(std::ffi::OsStr::new("rc")) {
                     self.add_trusted_file(file_path)?
                 }
             }
         }
         Ok(())
     }
 
     fn add_trusted_file(&mut self, path: &Path) -> Result<(), ConfigError> {
         if let Some(data) = std::fs::read(path)
             .when_reading_file(path)
             .io_not_found_as_none()?
         {
             self.layers.extend(ConfigLayer::parse(path, &data)?)
         }
         Ok(())
     }
 
     fn add_for_environment_variable(
         &mut self,
         var: &str,
         section: &[u8],
         key: &[u8],
     ) {
         if let Some(value) = env::var_os(var) {
             let origin = layer::ConfigOrigin::Environment(var.into());
             let mut layer = ConfigLayer::new(origin);
             layer.add(
                 section.to_owned(),
                 key.to_owned(),
                 get_bytes_from_os_str(value),
                 None,
             );
             self.layers.push(layer)
         }
     }
 
     #[cfg(unix)] // TODO: other platforms
     fn add_system_config(&mut self) -> Result<(), ConfigError> {
         let mut add_for_prefix = |prefix: &Path| -> Result<(), ConfigError> {
             let etc = prefix.join("etc").join("mercurial");
             self.add_trusted_file(&etc.join("hgrc"))?;
             self.add_trusted_dir(&etc.join("hgrc.d"))
         };
         let root = Path::new("/");
         // TODO: use `std::env::args_os().next().unwrap()` a.k.a. argv[0]
         // instead? TODO: can this be a relative path?
         let hg = crate::utils::current_exe()?;
         // TODO: this order (per-installation then per-system) matches
         // `systemrcpath()` in `mercurial/scmposix.py`, but
         // `mercurial/helptext/config.txt` suggests it should be reversed
         if let Some(installation_prefix) = hg.parent().and_then(Path::parent) {
             if installation_prefix != root {
                 add_for_prefix(installation_prefix)?
             }
         }
         add_for_prefix(root)?;
         Ok(())
     }
 
     #[cfg(unix)] // TODO: other plateforms
     fn add_user_config(&mut self) -> Result<(), ConfigError> {
         let opt_home = home::home_dir();
         if let Some(home) = &opt_home {
             self.add_trusted_file(&home.join(".hgrc"))?
         }
         let darwin = cfg!(any(target_os = "macos", target_os = "ios"));
         if !darwin {
             if let Some(config_home) = env::var_os("XDG_CONFIG_HOME")
                 .map(PathBuf::from)
                 .or_else(|| opt_home.map(|home| home.join(".config")))
             {
                 self.add_trusted_file(&config_home.join("hg").join("hgrc"))?
             }
         }
         Ok(())
     }
 
     /// Loads in order, which means that the precedence is the same
     /// as the order of `sources`.
     pub fn load_from_explicit_sources(
         sources: Vec<ConfigSource>,
     ) -> Result<Self, ConfigError> {
         let mut layers = vec![];
 
         for source in sources.into_iter() {
             match source {
                 ConfigSource::Parsed(c) => layers.push(c),
                 ConfigSource::AbsPath(c) => {
                     // TODO check if it should be trusted
                     // mercurial/ui.py:427
                     let data = match std::fs::read(&c) {
                         Err(_) => continue, // same as the python code
                         Ok(data) => data,
                     };
                     layers.extend(ConfigLayer::parse(&c, &data)?)
                 }
             }
         }
 
         Ok(Config {
             layers,
             plain: PlainInfo::empty(),
         })
     }
 
     /// Loads the per-repository config into a new `Config` which is combined
     /// with `self`.
     pub(crate) fn combine_with_repo(
         &self,
         repo_config_files: &[PathBuf],
     ) -> Result<Self, ConfigError> {
         let (cli_layers, other_layers) = self
             .layers
             .iter()
             .cloned()
             .partition(ConfigLayer::is_from_command_line);
 
         let mut repo_config = Self {
             layers: other_layers,
             plain: PlainInfo::empty(),
         };
         for path in repo_config_files {
             // TODO: check if this file should be trusted:
             // `mercurial/ui.py:427`
             repo_config.add_trusted_file(path)?;
         }
         repo_config.layers.extend(cli_layers);
         Ok(repo_config)
     }
 
     pub fn apply_plain(&mut self, plain: PlainInfo) {
         self.plain = plain;
     }
 
     /// Returns the default value for the given config item, if any.
     pub fn get_default(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<Option<&DefaultConfigItem>, HgError> {
         let default_config = DEFAULT_CONFIG.as_ref().map_err(|e| {
             HgError::abort(
                 e.to_string(),
                 crate::exit_codes::ABORT,
                 Some("`mercurial/configitems.toml` is not valid".into()),
             )
         })?;
-        Ok(default_config.get(section, item))
+        let default_opt = default_config.get(section, item);
+        Ok(default_opt.filter(|default| {
+            default
+                .in_core_extension()
+                .map(|extension| {
+                    // Only return the default for an in-core extension item
+                    // if said extension is enabled
+                    self.is_extension_enabled(extension.as_bytes())
+                })
+                .unwrap_or(true)
+        }))
     }
 
     fn get_parse<'config, T: 'config>(
         &'config self,
         section: &[u8],
         item: &[u8],
         expected_type: &'static str,
         parse: impl Fn(&'config [u8]) -> Option<T>,
         fallback_to_default: bool,
     ) -> Result<Option<T>, HgError>
     where
         Option<T>: TryFrom<&'config DefaultConfigItem, Error = HgError>,
     {
         match self.get_inner(section, item) {
             Some((layer, v)) => match parse(&v.bytes) {
                 Some(b) => Ok(Some(b)),
                 None => Err(Box::new(ConfigValueParseErrorDetails {
                     origin: layer.origin.to_owned(),
                     line: v.line,
                     value: v.bytes.to_owned(),
                     section: section.to_owned(),
                     item: item.to_owned(),
                     expected_type,
                 })
                 .into()),
             },
             None => {
                 if !fallback_to_default {
                     return Ok(None);
                 }
                 match self.get_default(section, item)? {
                     Some(default) => Ok(default.try_into()?),
                     None => Ok(None),
                 }
             }
         }
     }
 
     /// Returns an `Err` if the first value found is not a valid UTF-8 string.
     /// Otherwise, returns an `Ok(value)` if found, or `None`.
     pub fn get_str(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<Option<&str>, HgError> {
         self.get_parse(
             section,
             item,
             "ASCII or UTF-8 string",
             |value| str::from_utf8(value).ok(),
             true,
         )
     }
 
     /// Same as `get_str`, but doesn't fall back to the default `configitem`
     /// if not defined in the user config.
     pub fn get_str_no_default(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<Option<&str>, HgError> {
         self.get_parse(
             section,
             item,
             "ASCII or UTF-8 string",
             |value| str::from_utf8(value).ok(),
             false,
         )
     }
 
     /// Returns an `Err` if the first value found is not a valid unsigned
     /// integer. Otherwise, returns an `Ok(value)` if found, or `None`.
     pub fn get_u32(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<Option<u32>, HgError> {
         self.get_parse(
             section,
             item,
             "valid integer",
             |value| str::from_utf8(value).ok()?.parse().ok(),
             true,
         )
     }
 
     /// Returns an `Err` if the first value found is not a valid file size
     /// value such as `30` (default unit is bytes), `7 MB`, or `42.5 kb`.
     /// Otherwise, returns an `Ok(value_in_bytes)` if found, or `None`.
     pub fn get_byte_size(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<Option<u64>, HgError> {
         self.get_parse(
             section,
             item,
             "byte quantity",
             values::parse_byte_size,
             true,
         )
     }
 
     /// Returns an `Err` if the first value found is not a valid boolean.
     /// Otherwise, returns an `Ok(option)`, where `option` is the boolean if
     /// found, or `None`.
     pub fn get_option(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<Option<bool>, HgError> {
         self.get_parse(section, item, "boolean", values::parse_bool, true)
     }
 
     /// Same as `get_option`, but doesn't fall back to the default `configitem`
     /// if not defined in the user config.
     pub fn get_option_no_default(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<Option<bool>, HgError> {
         self.get_parse(section, item, "boolean", values::parse_bool, false)
     }
 
     /// Returns the corresponding boolean in the config. Returns `Ok(false)`
     /// if the value is not found, an `Err` if it's not a valid boolean.
     pub fn get_bool(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<bool, HgError> {
         Ok(self.get_option(section, item)?.unwrap_or(false))
     }
 
     /// Same as `get_bool`, but doesn't fall back to the default `configitem`
     /// if not defined in the user config.
     pub fn get_bool_no_default(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<bool, HgError> {
         Ok(self.get_option_no_default(section, item)?.unwrap_or(false))
     }
 
     /// Returns `true` if the extension is enabled, `false` otherwise
     pub fn is_extension_enabled(&self, extension: &[u8]) -> bool {
         let value = self.get(b"extensions", extension);
         match value {
             Some(c) => !c.starts_with(b"!"),
             None => false,
         }
     }
 
     /// If there is an `item` value in `section`, parse and return a list of
     /// byte strings.
     pub fn get_list(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Option<Vec<Vec<u8>>> {
         self.get(section, item).map(values::parse_list)
     }
 
     /// Returns the raw value bytes of the first one found, or `None`.
     pub fn get(&self, section: &[u8], item: &[u8]) -> Option<&[u8]> {
         self.get_inner(section, item)
             .map(|(_, value)| value.bytes.as_ref())
     }
 
     /// Returns the raw value bytes of the first one found, or `None`.
     pub fn get_with_origin(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Option<(&[u8], &ConfigOrigin)> {
         self.get_inner(section, item)
             .map(|(layer, value)| (value.bytes.as_ref(), &layer.origin))
     }
 
     /// Returns the layer and the value of the first one found, or `None`.
     fn get_inner(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Option<(&ConfigLayer, &ConfigValue)> {
         // Filter out the config items that are hidden by [PLAIN].
         // This differs from python hg where we delete them from the config.
         let should_ignore = should_ignore(&self.plain, section, item);
         for layer in self.layers.iter().rev() {
             if !layer.trusted {
                 continue;
             }
             //The [PLAIN] config should not affect the defaults.
             //
             // However, PLAIN should also affect the "tweaked" defaults (unless
             // "tweakdefault" is part of "HGPLAINEXCEPT").
             //
             // In practice the tweak-default layer is only added when it is
             // relevant, so we can safely always take it into
             // account here.
             if should_ignore && !(layer.origin == ConfigOrigin::Tweakdefaults)
             {
                 continue;
             }
             if let Some(v) = layer.get(section, item) {
                 return Some((layer, v));
             }
         }
         None
     }
 
     /// Return all keys defined for the given section
     pub fn get_section_keys(&self, section: &[u8]) -> HashSet<&[u8]> {
         self.layers
             .iter()
             .flat_map(|layer| layer.iter_keys(section))
             .collect()
     }
 
     /// Returns whether any key is defined in the given section
     pub fn has_non_empty_section(&self, section: &[u8]) -> bool {
         self.layers
             .iter()
             .any(|layer| layer.has_non_empty_section(section))
     }
 
     /// Yields (key, value) pairs for everything in the given section
     pub fn iter_section<'a>(
         &'a self,
         section: &'a [u8],
     ) -> impl Iterator<Item = (&[u8], &[u8])> + 'a {
         // Deduplicate keys redefined in multiple layers
         let mut keys_already_seen = HashSet::new();
         let mut key_is_new =
             move |&(key, _value): &(&'a [u8], &'a [u8])| -> bool {
                 keys_already_seen.insert(key)
             };
         // This is similar to `flat_map` + `filter_map`, except with a single
         // closure that owns `key_is_new` (and therefore the
         // `keys_already_seen` set):
         let mut layer_iters = self
             .layers
             .iter()
             .rev()
             .map(move |layer| layer.iter_section(section))
             .peekable();
         std::iter::from_fn(move || loop {
             if let Some(pair) = layer_iters.peek_mut()?.find(&mut key_is_new) {
                 return Some(pair);
             } else {
                 layer_iters.next();
             }
         })
     }
 
     /// Get raw values bytes from all layers (even untrusted ones) in order
     /// of precedence.
     #[cfg(test)]
     fn get_all(&self, section: &[u8], item: &[u8]) -> Vec<&[u8]> {
         let mut res = vec![];
         for layer in self.layers.iter().rev() {
             if let Some(v) = layer.get(section, item) {
                 res.push(v.bytes.as_ref());
             }
         }
         res
     }
 
     // a config layer that's introduced by ui.tweakdefaults
     fn tweakdefaults_layer() -> ConfigLayer {
         let mut layer = ConfigLayer::new(ConfigOrigin::Tweakdefaults);
 
         let mut add = |section: &[u8], item: &[u8], value: &[u8]| {
             layer.add(
                 section[..].into(),
                 item[..].into(),
                 value[..].into(),
                 None,
             );
         };
         // duplication of [tweakrc] from [ui.py]
         add(b"ui", b"rollback", b"False");
         add(b"ui", b"statuscopies", b"yes");
         add(b"ui", b"interface", b"curses");
         add(b"ui", b"relative-paths", b"yes");
         add(b"commands", b"grep.all-files", b"True");
         add(b"commands", b"update.check", b"noconflict");
         add(b"commands", b"status.verbose", b"True");
         add(b"commands", b"resolve.explicit-re-merge", b"True");
         add(b"git", b"git", b"1");
         add(b"git", b"showfunc", b"1");
         add(b"git", b"word-diff", b"1");
         layer
     }
 
     // introduce the tweaked defaults as implied by ui.tweakdefaults
     pub fn tweakdefaults(&mut self) {
         self.layers.insert(0, Config::tweakdefaults_layer());
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
     use std::fs::File;
     use std::io::Write;
 
     #[test]
     fn test_include_layer_ordering() {
         let tmpdir = tempfile::tempdir().unwrap();
         let tmpdir_path = tmpdir.path();
         let mut included_file =
             File::create(&tmpdir_path.join("included.rc")).unwrap();
 
         included_file.write_all(b"[section]\nitem=value1").unwrap();
         let base_config_path = tmpdir_path.join("base.rc");
         let mut config_file = File::create(&base_config_path).unwrap();
         let data =
             b"[section]\nitem=value0\n%include included.rc\nitem=value2\n\
               [section2]\ncount = 4\nsize = 1.5 KB\nnot-count = 1.5\nnot-size = 1 ub";
         config_file.write_all(data).unwrap();
 
         let sources = vec![ConfigSource::AbsPath(base_config_path)];
         let config = Config::load_from_explicit_sources(sources)
             .expect("expected valid config");
 
         let (_, value) = config.get_inner(b"section", b"item").unwrap();
         assert_eq!(
             value,
             &ConfigValue {
                 bytes: b"value2".to_vec(),
                 line: Some(4)
             }
         );
 
         let value = config.get(b"section", b"item").unwrap();
         assert_eq!(value, b"value2",);
         assert_eq!(
             config.get_all(b"section", b"item"),
             [b"value2", b"value1", b"value0"]
         );
 
         assert_eq!(config.get_u32(b"section2", b"count").unwrap(), Some(4));
         assert_eq!(
             config.get_byte_size(b"section2", b"size").unwrap(),
             Some(1024 + 512)
         );
         assert!(config.get_u32(b"section2", b"not-count").is_err());
         assert!(config.get_byte_size(b"section2", b"not-size").is_err());
     }
 }

rust/rhg/src/blackbox.rs

@@ -1,171 +1,178 b''
 //! Logging for repository events, including commands run in the repository.
 
 use crate::CliInvocation;
 use format_bytes::format_bytes;
 use hg::errors::HgError;
 use hg::repo::Repo;
 use hg::utils::{files::get_bytes_from_os_str, shell_quote};
 use std::ffi::OsString;
 
-const ONE_MEBIBYTE: u64 = 1 << 20;
-
-// TODO: somehow keep defaults in sync with `configitem` in `hgext/blackbox.py`
-const DEFAULT_MAX_SIZE: u64 = ONE_MEBIBYTE;
-const DEFAULT_MAX_FILES: u32 = 7;
-
 // Python does not support %.3f, only %f
 const DEFAULT_DATE_FORMAT: &str = "%Y-%m-%d %H:%M:%S%.3f";
 
 type DateTime = chrono::DateTime<chrono::Local>;
 
 pub struct ProcessStartTime {
     /// For measuring duration
     monotonic_clock: std::time::Instant,
     /// For formatting with year, month, day, etc.
     calendar_based: DateTime,
 }
 
 impl ProcessStartTime {
     pub fn now() -> Self {
         Self {
             monotonic_clock: std::time::Instant::now(),
             calendar_based: chrono::Local::now(),
         }
     }
 }
 
 pub struct Blackbox<'a> {
     process_start_time: &'a ProcessStartTime,
     /// Do nothing if this is `None`
     configured: Option<ConfiguredBlackbox<'a>>,
 }
 
 struct ConfiguredBlackbox<'a> {
     repo: &'a Repo,
     max_size: u64,
     max_files: u32,
     date_format: &'a str,
 }
 
 impl<'a> Blackbox<'a> {
     pub fn new(
         invocation: &'a CliInvocation<'a>,
         process_start_time: &'a ProcessStartTime,
     ) -> Result<Self, HgError> {
         let configured = if let Ok(repo) = invocation.repo {
             if invocation.config.get(b"extensions", b"blackbox").is_none() {
                 // The extension is not enabled
                 None
             } else {
                 Some(ConfiguredBlackbox {
                     repo,
                     max_size: invocation
                         .config
                         .get_byte_size(b"blackbox", b"maxsize")?
-                        .unwrap_or(DEFAULT_MAX_SIZE),
+                        .expect(
+                            "blackbox.maxsize should have a default value",
+                        ),
                     max_files: invocation
                         .config
                         .get_u32(b"blackbox", b"maxfiles")?
-                        .unwrap_or(DEFAULT_MAX_FILES),
+                        .expect(
+                            "blackbox.maxfiles should have a default value",
+                        ),
                     date_format: invocation
                         .config
                         .get_str(b"blackbox", b"date-format")?
-                        .unwrap_or(DEFAULT_DATE_FORMAT),
+                        .map(|f| {
+                            if f.is_empty() {
+                                DEFAULT_DATE_FORMAT
+                            } else {
+                                f
+                            }
+                        })
+                        .expect(
+                            "blackbox.date-format should have a default value",
+                        ),
                 })
             }
         } else {
             // Without a local repository there’s no `.hg/blackbox.log` to
             // write to.
             None
         };
         Ok(Self {
             process_start_time,
             configured,
         })
     }
 
     pub fn log_command_start<'arg>(
         &self,
         argv: impl Iterator<Item = &'arg OsString>,
     ) {
         if let Some(configured) = &self.configured {
             let message = format_bytes!(b"(rust) {}", format_cli_args(argv));
             configured.log(&self.process_start_time.calendar_based, &message);
         }
     }
 
     pub fn log_command_end<'arg>(
         &self,
         argv: impl Iterator<Item = &'arg OsString>,
         exit_code: i32,
     ) {
         if let Some(configured) = &self.configured {
             let now = chrono::Local::now();
             let duration = self
                 .process_start_time
                 .monotonic_clock
                 .elapsed()
                 .as_secs_f64();
             let message = format_bytes!(
                 b"(rust) {} exited {} after {} seconds",
                 format_cli_args(argv),
                 exit_code,
                 format_bytes::Utf8(format_args!("{:.03}", duration))
             );
             configured.log(&now, &message);
         }
     }
 }
 
 impl ConfiguredBlackbox<'_> {
     fn log(&self, date_time: &DateTime, message: &[u8]) {
         let date = format_bytes::Utf8(date_time.format(self.date_format));
         let user = get_bytes_from_os_str(whoami::username_os());
         let rev = format_bytes::Utf8(match self.repo.dirstate_parents() {
             Ok(parents) if parents.p2 == hg::revlog::node::NULL_NODE => {
                 format!("{:x}", parents.p1)
             }
             Ok(parents) => format!("{:x}+{:x}", parents.p1, parents.p2),
             Err(_dirstate_corruption_error) => {
                 // TODO: log a non-fatal warning to stderr
                 "???".to_owned()
             }
         });
         let pid = std::process::id();
         let line = format_bytes!(
             b"{} {} @{} ({})> {}\n",
             date,
             user,
             rev,
             pid,
             message
         );
         let result =
             hg::logging::LogFile::new(self.repo.hg_vfs(), "blackbox.log")
                 .max_size(Some(self.max_size))
                 .max_files(self.max_files)
                 .write(&line);
         match result {
             Ok(()) => {}
             Err(_io_error) => {
                 // TODO: log a non-fatal warning to stderr
             }
         }
     }
 }
 
 fn format_cli_args<'a>(
     mut args: impl Iterator<Item = &'a OsString>,
 ) -> Vec<u8> {
     let _ = args.next(); // Skip the first (or zeroth) arg, the name of the `rhg` executable
     let mut args = args.map(|arg| shell_quote(&get_bytes_from_os_str(arg)));
     let mut formatted = Vec::new();
     if let Some(arg) = args.next() {
         formatted.extend(arg)
     }
     for arg in args {
         formatted.push(b' ');
         formatted.extend(arg)
     }
     formatted
 }