config: gather constant and type into the `__init__.py`

This will help using them in multiple files.

mercurial/configuration/__init__.py

@@ -0,0 +1,36
+# configuration related constants
+
+from __future__ import annotations
+
+from typing import (
+    List,
+    Tuple,
+    Union,
+)
+
+# keep typing simple for now
+ConfigLevelT = str
+LEVEL_USER = 'user'  # "user" is the default level and never passed explicitly
+LEVEL_LOCAL = 'local'
+LEVEL_GLOBAL = 'global'
+LEVEL_SHARED = 'shared'
+LEVEL_NON_SHARED = 'non_shared'
+EDIT_LEVELS = (
+    LEVEL_USER,
+    LEVEL_LOCAL,
+    LEVEL_GLOBAL,
+    LEVEL_SHARED,
+    LEVEL_NON_SHARED,
+)
+
+ConfigItemT = Tuple[bytes, bytes, bytes, bytes]
+ResourceIDT = Tuple[bytes, bytes]
+FileRCT = bytes
+ComponentT = Tuple[
+    bytes,
+    Union[
+        List[ConfigItemT],
+        FileRCT,
+        ResourceIDT,
+    ],
+]

mercurial/configuration/command.py

@@ -1,201 +1,196
 # Gather code related to command dealing with configuration.
 
 from __future__ import annotations
 
 import os
 
 from typing import Any, Collection, Dict, Optional
 
 from ..i18n import _
 
 from .. import (
     cmdutil,
     error,
     formatter,
     pycompat,
     requirements,
     ui as uimod,
     util,
     vfs as vfsmod,
 )
 
-from . import rcutil
+from . import (
+    ConfigLevelT,
+    EDIT_LEVELS,
+    LEVEL_GLOBAL,
+    LEVEL_LOCAL,
+    LEVEL_NON_SHARED,
+    LEVEL_SHARED,
+    LEVEL_USER,
+    rcutil,
+)
 
 EDIT_FLAG = 'edit'
 
 
-# keep typing simple for now
-ConfigLevelT = str
-LEVEL_USER = 'user'  # "user" is the default level and never passed explicitly
-LEVEL_LOCAL = 'local'
-LEVEL_GLOBAL = 'global'
-LEVEL_SHARED = 'shared'
-LEVEL_NON_SHARED = 'non_shared'
-EDIT_LEVELS = (
-    LEVEL_USER,
-    LEVEL_LOCAL,
-    LEVEL_GLOBAL,
-    LEVEL_SHARED,
-    LEVEL_NON_SHARED,
-)
-
-
 def find_edit_level(
-    ui: uimod.ui, repo, opts: Dict[str, Any]
+    ui: uimod.ui,
+    repo,
+    opts: Dict[str, Any],
 ) -> Optional[ConfigLevelT]:
     """return the level we should edit, if any.
 
     Parse the command option to detect when an edit is requested, and if so the
     configuration level we should edit.
     """
     if opts.get(EDIT_FLAG) or any(opts.get(o) for o in EDIT_LEVELS):
         cmdutil.check_at_most_one_arg(opts, *EDIT_LEVELS)
         for level in EDIT_LEVELS:
             if opts.get(level):
                 return level
         return EDIT_LEVELS[0]
     return None
 
 
 def edit_config(ui: uimod.ui, repo, level: ConfigLevelT) -> None:
     """let the user edit configuration file for the given level"""
 
     if level == LEVEL_USER:
         paths = rcutil.userrcpath()
     elif level == LEVEL_GLOBAL:
         paths = rcutil.systemrcpath()
     elif level == LEVEL_LOCAL:
         if not repo:
             raise error.InputError(_(b"can't use --local outside a repository"))
         paths = [repo.vfs.join(b'hgrc')]
     elif level == LEVEL_NON_SHARED:
         paths = [repo.vfs.join(b'hgrc-not-shared')]
     elif level == LEVEL_SHARED:
         if not repo.shared():
             raise error.InputError(
                 _(b"repository is not shared; can't use --shared")
             )
         if requirements.SHARESAFE_REQUIREMENT not in repo.requirements:
             raise error.InputError(
                 _(
                     b"share safe feature not enabled; "
                     b"unable to edit shared source repository config"
                 )
             )
         paths = [vfsmod.vfs(repo.sharedpath).join(b'hgrc')]
     else:
         msg = 'unknown config level: %s' % level
         raise error.ProgrammingError(msg)
 
     for f in paths:
         if os.path.exists(f):
             break
     else:
         if LEVEL_GLOBAL:
             samplehgrc = uimod.samplehgrcs[b'global']
         elif LEVEL_LOCAL:
             samplehgrc = uimod.samplehgrcs[b'local']
         else:
             samplehgrc = uimod.samplehgrcs[b'user']
 
         f = paths[0]
         util.writefile(f, util.tonativeeol(samplehgrc))
 
     editor = ui.geteditor()
     ui.system(
         b"%s \"%s\"" % (editor, f),
         onerr=error.InputError,
         errprefix=_(b"edit failed"),
         blockedtag=b'config_edit',
     )
 
 
 def show_component(ui: uimod.ui, repo) -> None:
     """show the component used to build the config
 
     XXX this skip over various source and ignore the repository config, so it
     XXX is probably useless old code.
     """
     for t, f in rcutil.rccomponents():
         if t == b'path':
             ui.debug(b'read config from: %s\n' % f)
         elif t == b'resource':
             ui.debug(b'read config from: resource:%s.%s\n' % (f[0], f[1]))
         elif t == b'items':
             # Don't print anything for 'items'.
             pass
         else:
             raise error.ProgrammingError(b'unknown rctype: %s' % t)
 
 
 def show_config(
     ui: uimod.ui,
     repo,
     value_filters: Collection[bytes],
     formatter_options: dict,
     untrusted: bool = False,
     all_known: bool = False,
     show_source: bool = False,
 ) -> bool:
     """Display config value to the user
 
     The display is done using a dedicated `formatter` object.
 
 
     :value_filters:
         if non-empty filter the display value according to these filters. If
         the filter does not match any value, the function return False. True
         otherwise.
 
     :formatter_option:
         options passed to the formatter
 
     :untrusted:
         When set, use untrusted value instead of ignoring them
 
     :all_known:
         Display all known config item, not just the one with an explicit value.
 
     :show_source:
         Show where each value has been defined.
     """
     fm = ui.formatter(b'config', formatter_options)
     selsections = selentries = []
     filtered = False
     if value_filters:
         selsections = [v for v in value_filters if b'.' not in v]
         selentries = [v for v in value_filters if b'.' in v]
         filtered = True
     uniquesel = len(selentries) == 1 and not selsections
     selsections = set(selsections)
     selentries = set(selentries)
 
     matched = False
     entries = ui.walkconfig(untrusted=untrusted, all_known=all_known)
     for section, name, value in entries:
         source = ui.configsource(section, name, untrusted)
         value = pycompat.bytestr(value)
         defaultvalue = ui.configdefault(section, name)
         if fm.isplain():
             source = source or b'none'
             value = value.replace(b'\n', b'\\n')
         entryname = section + b'.' + name
         if filtered and not (section in selsections or entryname in selentries):
             continue
         fm.startitem()
         fm.condwrite(show_source, b'source', b'%s: ', source)
         if uniquesel:
             fm.data(name=entryname)
             fm.write(b'value', b'%s\n', value)
         else:
             fm.write(b'name value', b'%s=%s\n', entryname, value)
         if formatter.isprintable(defaultvalue):
             fm.data(defaultvalue=defaultvalue)
         elif isinstance(defaultvalue, list) and all(
             formatter.isprintable(e) for e in defaultvalue
         ):
             fm.data(defaultvalue=fm.formatlist(defaultvalue, name=b'value'))
         # TODO: no idea how to process unsupported defaultvalue types
         matched = True
     fm.end()
     return matched

mercurial/configuration/rcutil.py

@@ -1,173 +1,165
 # rcutil.py - utilities about config paths, special config sections etc.
 #
 #  Copyright Mercurial Contributors
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import annotations
 
 import os
 
 from typing import (
     Dict,
     List,
     Optional,
-    Tuple,
-    Union,
 )
 
 from .. import (
+    configuration as conf_mod,
     encoding,
     localrepo,
     pycompat,
     requirements as requirementsmod,
     util,
     vfs,
 )
 
 from ..utils import resourceutil
 
 if pycompat.iswindows:
     from .. import scmwindows as scmplatform
 else:
     from .. import scmposix as scmplatform
 
 fallbackpager = scmplatform.fallbackpager
 systemrcpath = scmplatform.systemrcpath
 userrcpath = scmplatform.userrcpath
 
-ConfigItemT = Tuple[bytes, bytes, bytes, bytes]
-ResourceIDT = Tuple[bytes, bytes]
-FileRCT = bytes
-ComponentT = Tuple[
-    bytes,
-    Union[
-        List[ConfigItemT],
-        FileRCT,
-        ResourceIDT,
-    ],
-]
+ComponentT = conf_mod.ComponentT
+ConfigItemT = conf_mod.ConfigItemT
+FileRCT = conf_mod.FileRCT
+ResourceIDT = conf_mod.ResourceIDT
 
 
 def _expandrcpath(path: bytes) -> List[FileRCT]:
     '''path could be a file or a directory. return a list of file paths'''
     p = util.expandpath(path)
     if os.path.isdir(p):
         join = os.path.join
         return sorted(
             join(p, f) for f, k in util.listdir(p) if f.endswith(b'.rc')
         )
     return [p]
 
 
 def envrcitems(env: Optional[Dict[bytes, bytes]] = None) -> List[ConfigItemT]:
     """Return [(section, name, value, source)] config items.
 
     The config items are extracted from environment variables specified by env,
     used to override systemrc, but not userrc.
 
     If env is not provided, encoding.environ will be used.
     """
     if env is None:
         env = encoding.environ
     checklist = [
         (b'EDITOR', b'ui', b'editor'),
         (b'VISUAL', b'ui', b'editor'),
         (b'PAGER', b'pager', b'pager'),
     ]
     result = []
     for envname, section, configname in checklist:
         if envname not in env:
             continue
         result.append((section, configname, env[envname], b'$%s' % envname))
     return result
 
 
 def default_rc_resources() -> List[ResourceIDT]:
     """return rc resource IDs in defaultrc"""
     rsrcs = resourceutil.contents(b'mercurial.defaultrc')
     return [
         (b'mercurial.defaultrc', r)
         for r in sorted(rsrcs)
         if resourceutil.is_resource(b'mercurial.defaultrc', r)
         and r.endswith(b'.rc')
     ]
 
 
 def rccomponents() -> List[ComponentT]:
     """return an ordered [(type, obj)] about where to load configs.
 
     respect $HGRCPATH. if $HGRCPATH is empty, only .hg/hgrc of current repo is
     used. if $HGRCPATH is not set, the platform default will be used.
 
     if a directory is provided, *.rc files under it will be used.
 
     type could be either 'path', 'items' or 'resource'. If type is 'path',
     obj is a string, and is the config file path. if type is 'items', obj is a
     list of (section, name, value, source) that should fill the config directly.
     If type is 'resource', obj is a tuple of (package name, resource name).
     """
     envrc = (b'items', envrcitems())
 
     if b'HGRCPATH' in encoding.environ:
         # assume HGRCPATH is all about user configs so environments can be
         # overridden.
         _rccomponents = [envrc]
         for p in encoding.environ[b'HGRCPATH'].split(pycompat.ospathsep):
             if not p:
                 continue
             _rccomponents.extend((b'path', p) for p in _expandrcpath(p))
     else:
         _rccomponents = [(b'resource', r) for r in default_rc_resources()]
 
         normpaths = lambda paths: [
             (b'path', os.path.normpath(p)) for p in paths
         ]
         _rccomponents.extend(normpaths(systemrcpath()))
         _rccomponents.append(envrc)
         _rccomponents.extend(normpaths(userrcpath()))
     return _rccomponents
 
 
 def _shared_source_component(path: bytes) -> List[FileRCT]:
     """if the current repository is shared one, this tries to read
     .hg/hgrc of shared source if we are in share-safe mode
 
     This should be called before reading .hg/hgrc or the main repo
     as that overrides config set in shared source"""
     try:
         with open(os.path.join(path, b".hg", b"requires"), "rb") as fp:
             requirements = set(fp.read().splitlines())
             if not (
                 requirementsmod.SHARESAFE_REQUIREMENT in requirements
                 and requirementsmod.SHARED_REQUIREMENT in requirements
             ):
                 return []
             hgvfs = vfs.vfs(os.path.join(path, b".hg"))
             sharedvfs = localrepo._getsharedvfs(hgvfs, requirements)
             return [sharedvfs.join(b"hgrc")]
     except IOError:
         pass
     return []
 
 
 def repo_components(repo_path: bytes) -> List[ComponentT]:
     """return the list of config file to read for a repository"""
     components = []
     components.extend(_shared_source_component(repo_path))
     components.append(os.path.join(repo_path, b".hg", b"hgrc"))
     components.append(os.path.join(repo_path, b".hg", b"hgrc-not-shared"))
     return [(b'path', c) for c in components]
 
 
 def defaultpagerenv() -> Dict[bytes, bytes]:
     """return a dict of default environment variables and their values,
     intended to be set before starting a pager.
     """
     return {b'LESS': b'FRX', b'LV': b'-c'}
 
 
 def use_repo_hgrc() -> bool:
     """True if repositories `.hg/hgrc` config should be read"""
     return b'HGRCSKIPREPO' not in encoding.environ