ui.py
1849 lines
| 67.2 KiB
| text/x-python
|
PythonLexer
/ mercurial / ui.py
|
r207 | # ui.py - user interface bits for mercurial | ||
# | ||||
|
r4635 | # Copyright 2005-2007 Matt Mackall <mpm@selenic.com> | ||
|
r207 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r207 | |||
|
r25989 | from __future__ import absolute_import | ||
|
r30976 | import collections | ||
|
r30480 | import contextlib | ||
|
r25989 | import errno | ||
import getpass | ||||
|
r25629 | import inspect | ||
|
r25989 | import os | ||
|
r27392 | import re | ||
|
r30992 | import signal | ||
|
r25989 | import socket | ||
|
r30992 | import subprocess | ||
|
r25989 | import sys | ||
import tempfile | ||||
import traceback | ||||
from .i18n import _ | ||||
from .node import hex | ||||
from . import ( | ||||
|
r31087 | color, | ||
|
r25989 | config, | ||
r32984 | configitems, | |||
|
r30277 | encoding, | ||
|
r25989 | error, | ||
formatter, | ||||
progress, | ||||
|
r30519 | pycompat, | ||
|
r31679 | rcutil, | ||
|
r25989 | scmutil, | ||
util, | ||||
) | ||||
|
r207 | |||
|
r29378 | urlreq = util.urlreq | ||
|
r30979 | # for use with str.translate(None, _keepalnum), to keep just alphanumerics | ||
|
r31253 | _keepalnum = ''.join(c for c in map(pycompat.bytechr, range(256)) | ||
if not c.isalnum()) | ||||
|
r30979 | |||
|
r32872 | # The config knobs that will be altered (if unset) by ui.tweakdefaults. | ||
|
r35929 | tweakrc = b""" | ||
|
r32872 | [ui] | ||
# The rollback command is dangerous. As a rule, don't use it. | ||||
rollback = False | ||||
|
r35066 | # Make `hg status` report copy information | ||
statuscopies = yes | ||||
|
r35307 | # Prefer curses UIs when available. Revert to plain-text with `text`. | ||
interface = curses | ||||
|
r32872 | |||
[commands] | ||||
# Make `hg status` emit cwd-relative paths by default. | ||||
status.relative = yes | ||||
|
r34708 | # Refuse to perform an `hg update` that would cause a file content merge | ||
update.check = noconflict | ||||
|
r32872 | |||
[diff] | ||||
git = 1 | ||||
|
r35308 | showfunc = 1 | ||
|
r32872 | """ | ||
|
r22419 | samplehgrcs = { | ||
'user': | ||||
|
r33650 | b"""# example user config (see 'hg help config' for more info) | ||
|
r22419 | [ui] | ||
# name and email, e.g. | ||||
# username = Jane Doe <jdoe@example.com> | ||||
username = | ||||
|
r34569 | # 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 | ||||
|
r32094 | # uncomment to disable color in command output | ||
|
r32095 | # (see 'hg help color' for details) | ||
|
r32094 | # color = never | ||
|
r31124 | |||
|
r32101 | # uncomment to disable command output pagination | ||
# (see 'hg help pager' for details) | ||||
|
r32105 | # paginate = never | ||
|
r32101 | |||
|
r22419 | [extensions] | ||
# uncomment these lines to enable some popular extensions | ||||
|
r29978 | # (see 'hg help extensions' for more info) | ||
|
r22419 | # | ||
|
r32097 | # churn = | ||
|
r32098 | """, | ||
|
r22419 | |||
|
r22837 | 'cloned': | ||
|
r33650 | b"""# example repository config (see 'hg help config' for more info) | ||
|
r22837 | [paths] | ||
default = %s | ||||
# path aliases to other clones of this repo in URLs or filesystem paths | ||||
|
r29978 | # (see 'hg help config.paths' for more info) | ||
|
r22837 | # | ||
|
r31064 | # default:pushurl = ssh://jdoe@example.net/hg/jdoes-fork | ||
# my-fork = ssh://jdoe@example.net/hg/jdoes-fork | ||||
# my-clone = /home/jdoe/jdoes-clone | ||||
|
r22837 | |||
[ui] | ||||
# name and email (local to this repository, optional), e.g. | ||||
# username = Jane Doe <jdoe@example.com> | ||||
""", | ||||
|
r22419 | 'local': | ||
|
r33650 | b"""# example repository config (see 'hg help config' for more info) | ||
|
r22836 | [paths] | ||
# path aliases to other clones of this repo in URLs or filesystem paths | ||||
|
r29978 | # (see 'hg help config.paths' for more info) | ||
|
r22836 | # | ||
|
r31064 | # default = http://example.com/hg/example-repo | ||
# default:pushurl = ssh://jdoe@example.net/hg/jdoes-fork | ||||
# my-fork = ssh://jdoe@example.net/hg/jdoes-fork | ||||
# my-clone = /home/jdoe/jdoes-clone | ||||
|
r22836 | |||
[ui] | ||||
# name and email (local to this repository, optional), e.g. | ||||
# username = Jane Doe <jdoe@example.com> | ||||
|
r22419 | """, | ||
'global': | ||||
|
r33650 | b"""# example system-wide hg config (see 'hg help config' for more info) | ||
|
r22419 | |||
|
r31124 | [ui] | ||
|
r32094 | # uncomment to disable color in command output | ||
|
r32095 | # (see 'hg help color' for details) | ||
|
r32094 | # color = never | ||
|
r31124 | |||
|
r32101 | # uncomment to disable command output pagination | ||
# (see 'hg help pager' for details) | ||||
|
r32105 | # paginate = never | ||
|
r32101 | |||
|
r22419 | [extensions] | ||
# uncomment these lines to enable some popular extensions | ||||
|
r29978 | # (see 'hg help extensions' for more info) | ||
|
r22419 | # | ||
# blackbox = | ||||
|
r32097 | # churn = | ||
|
r32098 | """, | ||
|
r22419 | } | ||
|
r34483 | def _maybestrurl(maybebytes): | ||
|
r35918 | return util.rapply(pycompat.strurl, maybebytes) | ||
|
r34483 | |||
def _maybebytesurl(maybestr): | ||||
|
r35918 | return util.rapply(pycompat.bytesurl, maybestr) | ||
|
r30945 | |||
class httppasswordmgrdbproxy(object): | ||||
"""Delays loading urllib2 until it's needed.""" | ||||
def __init__(self): | ||||
self._mgr = None | ||||
def _get_mgr(self): | ||||
if self._mgr is None: | ||||
self._mgr = urlreq.httppasswordmgrwithdefaultrealm() | ||||
return self._mgr | ||||
|
r34427 | def add_password(self, realm, uris, user, passwd): | ||
|
r34483 | return self._get_mgr().add_password( | ||
|
r35918 | _maybestrurl(realm), _maybestrurl(uris), | ||
|
r34483 | _maybestrurl(user), _maybestrurl(passwd)) | ||
|
r30945 | |||
|
r34427 | def find_user_password(self, realm, uri): | ||
|
r35918 | mgr = self._get_mgr() | ||
return _maybebytesurl(mgr.find_user_password(_maybestrurl(realm), | ||||
_maybestrurl(uri))) | ||||
|
r30945 | |||
|
r30992 | def _catchterm(*args): | ||
raise error.SignalInterrupt | ||||
|
r30945 | |||
r32958 | # unique object used to detect no default value has been provided when | |||
# retrieving configuration value. | ||||
_unset = object() | ||||
|
r34883 | # _reqexithandlers: callbacks run at the end of a request | ||
_reqexithandlers = [] | ||||
|
r1559 | class ui(object): | ||
|
r8190 | def __init__(self, src=None): | ||
|
r30559 | """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. | ||||
""" | ||||
|
r21132 | # _buffers: used for temporary capture of output | ||
|
r8202 | self._buffers = [] | ||
|
r27106 | # 3-tuple describing how each buffer in the stack behaves. | ||
# Values are (capture stderr, capture subprocesses, apply labels). | ||||
|
r21132 | self._bufferstates = [] | ||
|
r27106 | # When a buffer is active, defines whether we are expanding labels. | ||
# This exists to prevent an extra list lookup. | ||||
self._bufferapplylabels = None | ||||
|
r9851 | self.quiet = self.verbose = self.debugflag = self.tracebackflag = False | ||
|
r8208 | self._reportuntrusted = True | ||
r32984 | self._knownconfig = configitems.coreitems | |||
|
r8203 | self._ocfg = config.config() # overlay | ||
self._tcfg = config.config() # trusted | ||||
self._ucfg = config.config() # untrusted | ||||
|
r8478 | self._trustusers = set() | ||
self._trustgroups = set() | ||||
|
r17048 | self.callhooks = True | ||
|
r29109 | # Insecure server connections requested. | ||
self.insecureconnections = False | ||||
|
r30976 | # Blocked time | ||
self.logblockedtimes = False | ||||
|
r31106 | # color mode: see mercurial/color.py for possible value | ||
self._colormode = None | ||||
|
r31113 | self._terminfoparams = {} | ||
|
r31115 | self._styles = {} | ||
|
r8136 | |||
|
r8190 | if src: | ||
|
r14612 | self.fout = src.fout | ||
self.ferr = src.ferr | ||||
self.fin = src.fin | ||||
|
r30992 | self.pageractive = src.pageractive | ||
|
r31026 | self._disablepager = src._disablepager | ||
|
r32872 | self._tweaked = src._tweaked | ||
|
r14612 | |||
|
r8203 | self._tcfg = src._tcfg.copy() | ||
self._ucfg = src._ucfg.copy() | ||||
self._ocfg = src._ocfg.copy() | ||||
|
r8201 | self._trustusers = src._trustusers.copy() | ||
self._trustgroups = src._trustgroups.copy() | ||||
|
r9887 | self.environ = src.environ | ||
|
r17048 | self.callhooks = src.callhooks | ||
|
r29109 | self.insecureconnections = src.insecureconnections | ||
|
r31106 | self._colormode = src._colormode | ||
|
r31113 | self._terminfoparams = src._terminfoparams.copy() | ||
|
r31115 | self._styles = src._styles.copy() | ||
|
r31106 | |||
|
r8143 | self.fixconfig() | ||
|
r29378 | |||
self.httppasswordmgrdb = src.httppasswordmgrdb | ||||
|
r30976 | self._blockedtimes = src._blockedtimes | ||
|
r8143 | else: | ||
|
r30473 | self.fout = util.stdout | ||
self.ferr = util.stderr | ||||
self.fin = util.stdin | ||||
|
r30992 | self.pageractive = False | ||
|
r31026 | self._disablepager = False | ||
|
r32872 | self._tweaked = False | ||
|
r14612 | |||
|
r9887 | # shared read-only environment | ||
|
r30637 | self.environ = encoding.environ | ||
|
r8222 | |||
|
r30945 | self.httppasswordmgrdb = httppasswordmgrdbproxy() | ||
|
r30976 | self._blockedtimes = collections.defaultdict(int) | ||
|
r29378 | |||
|
r30832 | allowed = self.configlist('experimental', 'exportableenviron') | ||
if '*' in allowed: | ||||
self._exportableenviron = self.environ | ||||
else: | ||||
self._exportableenviron = {} | ||||
for k in allowed: | ||||
if k in self.environ: | ||||
self._exportableenviron[k] = self.environ[k] | ||||
|
r30559 | @classmethod | ||
def load(cls): | ||||
"""Create a ui and load global and user configs""" | ||||
u = cls() | ||||
|
r31685 | # we always trust global config files and environment variables | ||
|
r31683 | for t, f in rcutil.rccomponents(): | ||
if t == 'path': | ||||
u.readconfig(f, trust=True) | ||||
|
r31685 | elif t == 'items': | ||
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) | ||||
|
r31683 | else: | ||
raise error.ProgrammingError('unknown rctype: %s' % t) | ||||
|
r32872 | u._maybetweakdefaults() | ||
|
r30559 | return u | ||
|
r32872 | def _maybetweakdefaults(self): | ||
if not self.configbool('ui', 'tweakdefaults'): | ||||
return | ||||
if self._tweaked or self.plain('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('<tweakdefaults>', tweakrc) | ||||
for section in tmpcfg: | ||||
for name, value in tmpcfg.items(section): | ||||
if not self.hasconfig(section, name): | ||||
self.setconfig(section, name, value, "<tweakdefaults>") | ||||
|
r8189 | def copy(self): | ||
|
r8220 | return self.__class__(self) | ||
|
r1839 | |||
|
r29366 | def resetstate(self): | ||
"""Clear internal state that shouldn't persist across commands""" | ||||
if self._progbar: | ||||
self._progbar.resetstate() # reset last-print time of progress bar | ||||
|
r30945 | self.httppasswordmgrdb = httppasswordmgrdbproxy() | ||
|
r29366 | |||
|
r30976 | @contextlib.contextmanager | ||
def timeblockedsection(self, key): | ||||
|
r30978 | # this is open-coded below - search for timeblockedsection to find them | ||
|
r30976 | starttime = util.timer() | ||
try: | ||||
yield | ||||
finally: | ||||
self._blockedtimes[key + '_blocked'] += \ | ||||
(util.timer() - starttime) * 1000 | ||||
|
r29366 | |||
|
r16135 | def formatter(self, topic, opts): | ||
|
r32573 | return formatter.formatter(self, self, topic, opts) | ||
|
r16135 | |||
|
r14859 | def _trusted(self, fp, f): | ||
|
r3677 | st = util.fstat(fp) | ||
|
r8657 | if util.isowner(st): | ||
|
r3677 | return True | ||
|
r8141 | |||
|
r8201 | tusers, tgroups = self._trustusers, self._trustgroups | ||
|
r8141 | if '*' in tusers or '*' 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 | ||||
|
r8204 | if self._reportuntrusted: | ||
|
r16939 | self.warn(_('not trusting file %s from untrusted ' | ||
|
r8141 | 'user %s, group %s\n') % (f, user, group)) | ||
return False | ||||
|
r3551 | |||
|
r8200 | def readconfig(self, filename, root=None, trust=False, | ||
|
r8345 | sections=None, remap=None): | ||
|
r8142 | try: | ||
|
r30348 | fp = open(filename, u'rb') | ||
|
r8142 | except IOError: | ||
if not sections: # ignore unless we were looking for something | ||||
return | ||||
raise | ||||
|
r8139 | |||
|
r8203 | cfg = config.config() | ||
|
r14859 | trusted = sections or trust or self._trusted(fp, filename) | ||
|
r3552 | |||
|
r8142 | try: | ||
|
r8345 | cfg.read(filename, fp, sections=sections, remap=remap) | ||
|
r15407 | fp.close() | ||
|
r25660 | except error.ConfigError as inst: | ||
|
r8142 | if trusted: | ||
|
r8144 | raise | ||
|
r16938 | self.warn(_("ignored: %s\n") % str(inst)) | ||
|
r3552 | |||
|
r10455 | if self.plain(): | ||
|
r10507 | for k in ('debug', 'fallbackencoding', 'quiet', 'slash', | ||
|
r24663 | 'logtemplate', 'statuscopies', 'style', | ||
|
r10507 | 'traceback', 'verbose'): | ||
|
r10455 | if k in cfg['ui']: | ||
del cfg['ui'][k] | ||||
|
r14373 | for k, v in cfg.items('defaults'): | ||
del cfg['defaults'][k] | ||||
|
r31588 | for k, v in cfg.items('commands'): | ||
del cfg['commands'][k] | ||||
|
r14373 | # Don't remove aliases from the configuration if in the exceptionlist | ||
if self.plain('alias'): | ||||
|
r10506 | for k, v in cfg.items('alias'): | ||
del cfg['alias'][k] | ||||
|
r24883 | if self.plain('revsetalias'): | ||
for k, v in cfg.items('revsetalias'): | ||||
del cfg['revsetalias'][k] | ||||
|
r28958 | if self.plain('templatealias'): | ||
for k, v in cfg.items('templatealias'): | ||||
del cfg['templatealias'][k] | ||||
|
r10455 | |||
|
r8142 | if trusted: | ||
|
r8203 | self._tcfg.update(cfg) | ||
self._tcfg.update(self._ocfg) | ||||
self._ucfg.update(cfg) | ||||
self._ucfg.update(self._ocfg) | ||||
|
r8139 | |||
|
r3347 | if root is None: | ||
root = os.path.expanduser('~') | ||||
self.fixconfig(root=root) | ||||
|
r3014 | |||
|
r12764 | def fixconfig(self, root=None, section=None): | ||
if section in (None, 'paths'): | ||||
# expand vars and ~ | ||||
# translate paths relative to root (or home) into absolute paths | ||||
|
r30519 | root = root or pycompat.getcwd() | ||
|
r12764 | for c in self._tcfg, self._ucfg, self._ocfg: | ||
for n, p in c.items('paths'): | ||||
|
r29412 | # Ignore sub-options. | ||
if ':' in n: | ||||
continue | ||||
|
r12764 | if not p: | ||
continue | ||||
if '%%' in p: | ||||
|
r30618 | s = self.configsource('paths', n) or 'none' | ||
|
r12764 | self.warn(_("(deprecated '%%' in path %s=%s from %s)\n") | ||
|
r30618 | % (n, p, s)) | ||
|
r12764 | p = p.replace('%%', '%') | ||
p = util.expandpath(p) | ||||
|
r14076 | if not util.hasscheme(p) and not os.path.isabs(p): | ||
|
r12764 | p = os.path.normpath(os.path.join(root, p)) | ||
c.set("paths", n, p) | ||||
|
r3347 | |||
|
r12764 | if section in (None, 'ui'): | ||
# update ui options | ||||
self.debugflag = self.configbool('ui', 'debug') | ||||
self.verbose = self.debugflag or self.configbool('ui', 'verbose') | ||||
self.quiet = not self.debugflag and self.configbool('ui', 'quiet') | ||||
if self.verbose and self.quiet: | ||||
self.quiet = self.verbose = False | ||||
|
r13493 | self._reportuntrusted = self.debugflag or self.configbool("ui", | ||
|
r33499 | "report_untrusted") | ||
self.tracebackflag = self.configbool('ui', 'traceback') | ||||
|
r30976 | self.logblockedtimes = self.configbool('ui', 'logblockedtimes') | ||
|
r3350 | |||
|
r12764 | if section in (None, 'trusted'): | ||
# update trust information | ||||
self._trustusers.update(self.configlist('trusted', 'users')) | ||||
self._trustgroups.update(self.configlist('trusted', 'groups')) | ||||
|
r3551 | |||
|
r15919 | 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): | ||||
self._ocfg.restore(data[0]) | ||||
self._tcfg.restore(data[1]) | ||||
self._ucfg.restore(data[2]) | ||||
|
r20788 | def setconfig(self, section, name, value, source=''): | ||
|
r20787 | for cfg in (self._ocfg, self._tcfg, self._ucfg): | ||
|
r20788 | cfg.set(section, name, value, source) | ||
|
r12764 | self.fixconfig(section=section) | ||
|
r32872 | self._maybetweakdefaults() | ||
|
r960 | |||
|
r8199 | def _data(self, untrusted): | ||
|
r8203 | return untrusted and self._ucfg or self._tcfg | ||
|
r3552 | |||
|
r8182 | def configsource(self, section, name, untrusted=False): | ||
|
r30618 | return self._data(untrusted).source(section, name) | ||
|
r8182 | |||
r32958 | def config(self, section, name, default=_unset, untrusted=False): | |||
r33058 | """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): | ||||
|
r34949 | value = itemdefault = default | ||
|
r33329 | item = self._knownconfig.get(section, {}).get(name) | ||
alternates = [(section, name)] | ||||
if item is not None: | ||||
alternates.extend(item.alias) | ||||
|
r34949 | if callable(item.default): | ||
itemdefault = item.default() | ||||
else: | ||||
itemdefault = item.default | ||||
|
r34859 | else: | ||
msg = ("accessing unregistered config item: '%s.%s'") | ||||
msg %= (section, name) | ||||
self.develwarn(msg, 2, 'warn-config-unknown') | ||||
|
r33329 | |||
if default is _unset: | ||||
if item is None: | ||||
value = default | ||||
|
r33471 | elif item.default is configitems.dynamicdefault: | ||
value = None | ||||
msg = "config item requires an explicit default value: '%s.%s'" | ||||
msg %= (section, name) | ||||
self.develwarn(msg, 2, 'warn-config-default') | ||||
|
r33329 | else: | ||
|
r34949 | value = itemdefault | ||
|
r33471 | elif (item is not None | ||
|
r34949 | and item.default is not configitems.dynamicdefault | ||
and default != itemdefault): | ||||
msg = ("specifying a mismatched default value for a registered " | ||||
|
r33329 | "config item: '%s.%s' '%s'") | ||
|
r36143 | msg %= (section, name, pycompat.bytestr(default)) | ||
|
r33329 | self.develwarn(msg, 2, 'warn-config-default') | ||
r32987 | ||||
|
r33329 | for s, n in alternates: | ||
candidate = self._data(untrusted).get(s, n, None) | ||||
r33058 | if candidate is not None: | |||
value = candidate | ||||
|
r33329 | section = s | ||
|
r15035 | name = n | ||
break | ||||
|
r8204 | if self.debugflag and not untrusted and self._reportuntrusted: | ||
|
r33329 | for s, n in alternates: | ||
uvalue = self._ucfg.get(s, n) | ||||
|
r19536 | if uvalue is not None and uvalue != value: | ||
self.debug("ignoring untrusted configuration option " | ||||
|
r33329 | "%s.%s = %s\n" % (s, n, uvalue)) | ||
|
r3552 | return value | ||
|
r3341 | |||
r32967 | def configsuboptions(self, section, name, default=_unset, untrusted=False): | |||
|
r27252 | """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. | ||||
""" | ||||
r32966 | main = self.config(section, name, default, untrusted=untrusted) | |||
|
r27252 | data = self._data(untrusted) | ||
sub = {} | ||||
prefix = '%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, '%s:%s' % (name, k)) | ||||
if uvalue is not None and uvalue != v: | ||||
self.debug('ignoring untrusted configuration option ' | ||||
'%s:%s.%s = %s\n' % (section, name, k, uvalue)) | ||||
return main, sub | ||||
r32965 | def configpath(self, section, name, default=_unset, untrusted=False): | |||
|
r14924 | 'get a path config item, expanded relative to repo root or config file' | ||
|
r13238 | v = self.config(section, name, default, untrusted) | ||
|
r14923 | if v is None: | ||
return None | ||||
|
r13238 | if not os.path.isabs(v) or "://" not in v: | ||
src = self.configsource(section, name, untrusted) | ||||
if ':' in src: | ||||
|
r14922 | base = os.path.dirname(src.rsplit(':')[0]) | ||
|
r13238 | v = os.path.join(base, os.path.expanduser(v)) | ||
return v | ||||
r32959 | def configbool(self, section, name, default=_unset, untrusted=False): | |||
|
r14171 | """parse a configuration element as a boolean | ||
|
r34133 | >>> u = ui(); s = b'foo' | ||
>>> u.setconfig(s, b'true', b'yes') | ||||
>>> u.configbool(s, b'true') | ||||
|
r14171 | True | ||
|
r34133 | >>> u.setconfig(s, b'false', b'no') | ||
>>> u.configbool(s, b'false') | ||||
|
r14171 | False | ||
|
r34133 | >>> u.configbool(s, b'unknown') | ||
|
r14171 | False | ||
|
r34133 | >>> u.configbool(s, b'unknown', True) | ||
|
r14171 | True | ||
|
r34133 | >>> u.setconfig(s, b'invalid', b'somevalue') | ||
>>> u.configbool(s, b'invalid') | ||||
|
r14171 | Traceback (most recent call last): | ||
... | ||||
ConfigError: foo.invalid is not a boolean ('somevalue') | ||||
""" | ||||
r33059 | v = self._config(section, name, default, untrusted=untrusted) | |||
|
r8527 | if v is None: | ||
r33059 | return v | |||
if v is _unset: | ||||
r32959 | if default is _unset: | |||
return False | ||||
|
r8144 | return default | ||
|
r10243 | if isinstance(v, bool): | ||
return v | ||||
|
r12087 | b = util.parsebool(v) | ||
if b is None: | ||||
|
r14171 | raise error.ConfigError(_("%s.%s is not a boolean ('%s')") | ||
|
r8144 | % (section, name, v)) | ||
|
r12087 | return b | ||
|
r3552 | |||
r32960 | def configwith(self, convert, section, name, default=_unset, | |||
|
r30926 | desc=None, untrusted=False): | ||
"""parse a configuration element with a conversion function | ||||
|
r34133 | >>> u = ui(); s = b'foo' | ||
>>> u.setconfig(s, b'float1', b'42') | ||||
>>> u.configwith(float, s, b'float1') | ||||
|
r30926 | 42.0 | ||
|
r34133 | >>> u.setconfig(s, b'float2', b'-4.25') | ||
>>> u.configwith(float, s, b'float2') | ||||
|
r30932 | -4.25 | ||
|
r34133 | >>> u.configwith(float, s, b'unknown', 7) | ||
r32960 | 7.0 | |||
|
r34133 | >>> u.setconfig(s, b'invalid', b'somevalue') | ||
>>> u.configwith(float, s, b'invalid') | ||||
|
r30926 | Traceback (most recent call last): | ||
... | ||||
ConfigError: foo.invalid is not a valid float ('somevalue') | ||||
|
r34133 | >>> u.configwith(float, s, b'invalid', desc=b'womble') | ||
|
r30926 | Traceback (most recent call last): | ||
... | ||||
ConfigError: foo.invalid is not a valid womble ('somevalue') | ||||
""" | ||||
r32960 | v = self.config(section, name, default, untrusted) | |||
|
r30926 | if v is None: | ||
r32960 | return v # do not attempt to convert None | |||
|
r30926 | try: | ||
return convert(v) | ||||
|
r32462 | except (ValueError, error.ParseError): | ||
|
r30926 | if desc is None: | ||
|
r34205 | desc = pycompat.sysbytes(convert.__name__) | ||
|
r30926 | raise error.ConfigError(_("%s.%s is not a valid %s ('%s')") | ||
% (section, name, desc, v)) | ||||
r32961 | def configint(self, section, name, default=_unset, untrusted=False): | |||
|
r14171 | """parse a configuration element as an integer | ||
|
r34133 | >>> u = ui(); s = b'foo' | ||
>>> u.setconfig(s, b'int1', b'42') | ||||
>>> u.configint(s, b'int1') | ||||
|
r14171 | 42 | ||
|
r34133 | >>> u.setconfig(s, b'int2', b'-42') | ||
>>> u.configint(s, b'int2') | ||||
|
r14171 | -42 | ||
|
r34133 | >>> u.configint(s, b'unknown', 7) | ||
|
r14171 | 7 | ||
|
r34133 | >>> u.setconfig(s, b'invalid', b'somevalue') | ||
>>> u.configint(s, b'invalid') | ||||
|
r14171 | Traceback (most recent call last): | ||
... | ||||
|
r30927 | ConfigError: foo.invalid is not a valid integer ('somevalue') | ||
|
r14171 | """ | ||
|
r30927 | return self.configwith(int, section, name, default, 'integer', | ||
untrusted) | ||||
|
r14171 | |||
r32962 | def configbytes(self, section, name, default=_unset, untrusted=False): | |||
|
r19065 | """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). | ||||
|
r34133 | >>> u = ui(); s = b'foo' | ||
>>> u.setconfig(s, b'val1', b'42') | ||||
>>> u.configbytes(s, b'val1') | ||||
|
r19065 | 42 | ||
|
r34133 | >>> u.setconfig(s, b'val2', b'42.5 kb') | ||
>>> u.configbytes(s, b'val2') | ||||
|
r19065 | 43520 | ||
|
r34133 | >>> u.configbytes(s, b'unknown', b'7 MB') | ||
|
r19065 | 7340032 | ||
|
r34133 | >>> u.setconfig(s, b'invalid', b'somevalue') | ||
>>> u.configbytes(s, b'invalid') | ||||
|
r19065 | Traceback (most recent call last): | ||
... | ||||
ConfigError: foo.invalid is not a byte quantity ('somevalue') | ||||
""" | ||||
r33060 | value = self._config(section, name, default, untrusted) | |||
if value is _unset: | ||||
r32962 | if default is _unset: | |||
default = 0 | ||||
|
r19195 | value = default | ||
|
r33586 | if not isinstance(value, bytes): | ||
r32962 | return value | |||
|
r19065 | try: | ||
|
r19195 | return util.sizetoint(value) | ||
except error.ParseError: | ||||
|
r19065 | raise error.ConfigError(_("%s.%s is not a byte quantity ('%s')") | ||
|
r19195 | % (section, name, value)) | ||
|
r19065 | |||
r32963 | def configlist(self, section, name, default=_unset, untrusted=False): | |||
|
r14171 | """parse a configuration element as a list of comma/space separated | ||
strings | ||||
|
r34133 | >>> u = ui(); s = b'foo' | ||
>>> u.setconfig(s, b'list1', b'this,is "a small" ,test') | ||||
>>> u.configlist(s, b'list1') | ||||
|
r14171 | ['this', 'is', 'a small', 'test'] | ||
|
r34958 | >>> u.setconfig(s, b'list2', b'this, is "a small" , test ') | ||
>>> u.configlist(s, b'list2') | ||||
['this', 'is', 'a small', 'test'] | ||||
|
r14171 | """ | ||
|
r31481 | # default is not always a list | ||
r32963 | v = self.configwith(config.parselist, section, name, default, | |||
|
r31481 | 'list', untrusted) | ||
r32963 | if isinstance(v, bytes): | |||
return config.parselist(v) | ||||
elif v is None: | ||||
return [] | ||||
return v | ||||
|
r2499 | |||
r32964 | def configdate(self, section, name, default=_unset, untrusted=False): | |||
|
r32408 | """parse a configuration element as a tuple of ints | ||
|
r34133 | >>> u = ui(); s = b'foo' | ||
>>> u.setconfig(s, b'date', b'0 0') | ||||
>>> u.configdate(s, b'date') | ||||
|
r32408 | (0, 0) | ||
""" | ||||
if self.config(section, name, default, untrusted): | ||||
|
r32462 | return self.configwith(util.parsedate, section, name, default, | ||
|
r32408 | 'date', untrusted) | ||
r32964 | if default is _unset: | |||
return None | ||||
|
r32408 | return default | ||
|
r27696 | def hasconfig(self, section, name, untrusted=False): | ||
return self._data(untrusted).hasitem(section, name) | ||||
|
r4487 | def has_section(self, section, untrusted=False): | ||
|
r2343 | '''tell whether section exists in config.''' | ||
|
r8199 | return section in self._data(untrusted) | ||
|
r3552 | |||
|
r27253 | def configitems(self, section, untrusted=False, ignoresub=False): | ||
|
r8199 | items = self._data(untrusted).items(section) | ||
|
r27253 | if ignoresub: | ||
newitems = {} | ||||
for k, v in items: | ||||
if ':' not in k: | ||||
newitems[k] = v | ||||
items = newitems.items() | ||||
|
r8204 | if self.debugflag and not untrusted and self._reportuntrusted: | ||
|
r8222 | for k, v in self._ucfg.items(section): | ||
|
r8203 | if self._tcfg.get(section, k) != v: | ||
|
r14708 | self.debug("ignoring untrusted configuration option " | ||
"%s.%s = %s\n" % (section, k, v)) | ||||
|
r8144 | return items | ||
|
r285 | |||
|
r3552 | def walkconfig(self, untrusted=False): | ||
|
r8203 | cfg = self._data(untrusted) | ||
for section in cfg.sections(): | ||||
|
r3552 | for name, value in self.configitems(section, untrusted): | ||
|
r13576 | yield section, name, value | ||
|
r1028 | |||
|
r14372 | def plain(self, feature=None): | ||
|
r11325 | '''is plain mode active? | ||
|
r13849 | 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. | ||||
|
r11325 | |||
|
r14372 | The return value can either be | ||
- False if HGPLAIN is not set, or feature is in HGPLAINEXCEPT | ||||
|
r35180 | - False if feature is disabled by default and not included in HGPLAIN | ||
|
r14372 | - True otherwise | ||
|
r11325 | ''' | ||
|
r30277 | if ('HGPLAIN' not in encoding.environ and | ||
'HGPLAINEXCEPT' not in encoding.environ): | ||||
|
r13849 | return False | ||
|
r30277 | exceptions = encoding.environ.get('HGPLAINEXCEPT', | ||
'').strip().split(',') | ||||
|
r35180 | # TODO: add support for HGPLAIN=+feature,-feature syntax | ||
if '+strictflags' not in encoding.environ.get('HGPLAIN', '').split(','): | ||||
exceptions.append('strictflags') | ||||
|
r14372 | if feature and exceptions: | ||
return feature not in exceptions | ||||
return True | ||||
|
r10455 | |||
|
r34850 | def username(self, acceptempty=False): | ||
|
r1985 | """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. | ||||
|
r34850 | If not found and acceptempty is True, returns None. | ||
|
r6862 | If not found and ui.askusername is True, ask the user, else use | ||
($LOGNAME or $USER or $LNAME or $USERNAME) + "@full.hostname". | ||||
|
r34850 | If no username could be found, raise an Abort error. | ||
|
r1985 | """ | ||
|
r30277 | user = encoding.environ.get("HGUSER") | ||
|
r1985 | if user is None: | ||
|
r33329 | user = self.config("ui", "username") | ||
|
r11225 | if user is not None: | ||
user = os.path.expandvars(user) | ||||
|
r1985 | if user is None: | ||
|
r30277 | user = encoding.environ.get("EMAIL") | ||
|
r34850 | if user is None and acceptempty: | ||
return user | ||||
|
r6862 | if user is None and self.configbool("ui", "askusername"): | ||
|
r7600 | user = self.prompt(_("enter a commit username:"), default=None) | ||
|
r9613 | if user is None and not self.interactive(): | ||
|
r3721 | try: | ||
user = '%s@%s' % (util.getuser(), socket.getfqdn()) | ||||
|
r16940 | self.warn(_("no username found, using '%s' instead\n") % user) | ||
|
r3721 | except KeyError: | ||
|
r4044 | pass | ||
if not user: | ||||
|
r26587 | raise error.Abort(_('no username supplied'), | ||
|
r28962 | hint=_("use 'hg config --edit' " | ||
|
r20580 | 'to set your username')) | ||
|
r6351 | if "\n" in user: | ||
|
r36246 | raise error.Abort(_("username %r contains a newline\n") | ||
% pycompat.bytestr(user)) | ||||
|
r1985 | return user | ||
|
r608 | |||
|
r1129 | def shortuser(self, user): | ||
"""Return a short representation of a user name or email address.""" | ||||
|
r10282 | if not self.verbose: | ||
user = util.shortuser(user) | ||||
|
r1129 | return user | ||
|
r2494 | def expandpath(self, loc, default=None): | ||
|
r1892 | """Return repository location relative to cwd or from [paths]""" | ||
|
r26189 | try: | ||
p = self.paths.getpath(loc) | ||||
if p: | ||||
return p.rawloc | ||||
except error.RepoError: | ||||
pass | ||||
if default: | ||||
try: | ||||
p = self.paths.getpath(default) | ||||
if p: | ||||
return p.rawloc | ||||
except error.RepoError: | ||||
pass | ||||
|
r24250 | return loc | ||
@util.propertycache | ||||
def paths(self): | ||||
return paths(self) | ||||
|
r506 | |||
|
r27106 | def pushbuffer(self, error=False, subproc=False, labeled=False): | ||
|
r23139 | """install a buffer to capture standard output of the ui object | ||
|
r21132 | |||
|
r24848 | If error is True, the error output will be captured too. | ||
If subproc is True, output from subprocesses (typically hooks) will be | ||||
|
r27106 | captured too. | ||
|
r10815 | |||
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. | ||||
|
r27106 | """ | ||
|
r8202 | self._buffers.append([]) | ||
|
r27106 | self._bufferstates.append((error, subproc, labeled)) | ||
self._bufferapplylabels = labeled | ||||
|
r3737 | |||
|
r27109 | def popbuffer(self): | ||
'''pop the last buffer and return the buffered output''' | ||||
|
r21132 | self._bufferstates.pop() | ||
|
r27106 | if self._bufferstates: | ||
self._bufferapplylabels = self._bufferstates[-1][2] | ||||
else: | ||||
self._bufferapplylabels = None | ||||
|
r8202 | return "".join(self._buffers.pop()) | ||
|
r3737 | |||
|
r35979 | def canwritewithoutlabels(self): | ||
'''check if write skips the label''' | ||||
if self._buffers and not self._bufferapplylabels: | ||||
return True | ||||
return self._colormode is None | ||||
def canbatchlabeledwrites(self): | ||||
'''check if write calls with labels are batchable''' | ||||
# Windows color printing is special, see ``write``. | ||||
return self._colormode != 'win32' | ||||
|
r10815 | def write(self, *args, **opts): | ||
'''write args to output | ||||
|
r31091 | 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. | ||||
|
r10815 | |||
|
r31091 | 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". | ||||
|
r10815 | |||
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. | ||||
''' | ||||
|
r35975 | if self._buffers: | ||
|
r31091 | if self._bufferapplylabels: | ||
|
r35374 | label = opts.get(r'label', '') | ||
|
r31091 | self._buffers[-1].extend(self.label(a, label) for a in args) | ||
else: | ||||
self._buffers[-1].extend(args) | ||||
|
r35975 | else: | ||
self._writenobuf(*args, **opts) | ||||
def _writenobuf(self, *args, **opts): | ||||
if self._colormode == 'win32': | ||||
|
r31091 | # windows color printing is its own can of crab, defer to | ||
# the color module and that is it. | ||||
|
r31114 | color.win32print(self, self._write, *args, **opts) | ||
|
r3737 | else: | ||
|
r31091 | msgs = args | ||
if self._colormode is not None: | ||||
|
r35374 | label = opts.get(r'label', '') | ||
|
r31091 | msgs = [self.label(a, label) for a in args] | ||
self._write(*msgs, **opts) | ||||
|
r31090 | |||
def _write(self, *msgs, **opts): | ||||
|
r31128 | self._progclear() | ||
# opencode timeblockedsection because this is a critical path | ||||
starttime = util.timer() | ||||
try: | ||||
|
r35907 | self.fout.write(''.join(msgs)) | ||
|
r31961 | except IOError as err: | ||
raise error.StdioError(err) | ||||
|
r31128 | finally: | ||
self._blockedtimes['stdio_blocked'] += \ | ||||
(util.timer() - starttime) * 1000 | ||||
|
r565 | |||
|
r10815 | def write_err(self, *args, **opts): | ||
|
r25499 | self._progclear() | ||
|
r31092 | if self._bufferstates and self._bufferstates[-1][0]: | ||
|
r31094 | self.write(*args, **opts) | ||
elif self._colormode == 'win32': | ||||
# windows color printing is its own can of crab, defer to | ||||
# the color module and that is it. | ||||
|
r31114 | color.win32print(self, self._write_err, *args, **opts) | ||
|
r31094 | else: | ||
msgs = args | ||||
if self._colormode is not None: | ||||
|
r35374 | label = opts.get(r'label', '') | ||
|
r31094 | msgs = [self.label(a, label) for a in args] | ||
self._write_err(*msgs, **opts) | ||||
|
r31093 | |||
def _write_err(self, *msgs, **opts): | ||||
|
r1989 | try: | ||
|
r30978 | with self.timeblockedsection('stdio'): | ||
if not getattr(self.fout, 'closed', False): | ||||
self.fout.flush() | ||||
|
r31093 | for a in msgs: | ||
|
r30978 | self.ferr.write(a) | ||
# stderr may be buffered under win32 when redirected to files, | ||||
# including stdout. | ||||
if not getattr(self.ferr, 'closed', False): | ||||
self.ferr.flush() | ||||
|
r25660 | except IOError as inst: | ||
|
r33859 | if inst.errno not in (errno.EPIPE, errno.EIO, errno.EBADF): | ||
raise error.StdioError(inst) | ||||
|
r565 | |||
|
r1837 | def flush(self): | ||
|
r30978 | # opencode timeblockedsection because this is a critical path | ||
starttime = util.timer() | ||||
try: | ||||
|
r31963 | try: | ||
self.fout.flush() | ||||
except IOError as err: | ||||
|
r33859 | if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF): | ||
raise error.StdioError(err) | ||||
|
r31963 | finally: | ||
try: | ||||
self.ferr.flush() | ||||
except IOError as err: | ||||
|
r33859 | if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF): | ||
raise error.StdioError(err) | ||||
|
r30978 | finally: | ||
self._blockedtimes['stdio_blocked'] += \ | ||||
(util.timer() - starttime) * 1000 | ||||
|
r1837 | |||
|
r16751 | def _isatty(self, fh): | ||
|
r33499 | if self.configbool('ui', 'nontty'): | ||
|
r16751 | return False | ||
return util.isatty(fh) | ||||
|
r1837 | |||
|
r31026 | def disablepager(self): | ||
self._disablepager = True | ||||
|
r30994 | |||
|
r30992 | def pager(self, command): | ||
"""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. | ||||
""" | ||||
|
r31026 | if (self._disablepager | ||
|
r33622 | or self.pageractive): | ||
# how pager should do is already determined | ||||
return | ||||
if not command.startswith('internal-always-') and ( | ||||
# explicit --pager=on (= 'internal-always-' prefix) should | ||||
# take precedence over disabling factors below | ||||
command in self.configlist('pager', 'ignore') | ||||
|
r33499 | or not self.configbool('ui', 'paginate') | ||
|
r30997 | or not self.configbool('pager', 'attend-' + command, True) | ||
|
r30992 | # TODO: if we want to allow HGPLAINEXCEPT=pager, | ||
# formatted() will need some adjustment. | ||||
or not self.formatted() | ||||
or self.plain() | ||||
|
r34023 | or self._buffers | ||
|
r30992 | # TODO: expose debugger-enabled on the UI object | ||
|
r31341 | or '--debugger' in pycompat.sysargv): | ||
|
r30992 | # 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 | ||||
|
r32078 | pagercmd = self.config('pager', 'pager', rcutil.fallbackpager) | ||
|
r31079 | if not pagercmd: | ||
return | ||||
|
r31954 | pagerenv = {} | ||
for name, value in rcutil.defaultpagerenv().items(): | ||||
if name not in encoding.environ: | ||||
pagerenv[name] = value | ||||
|
r31079 | self.debug('starting pager for command %r\n' % command) | ||
|
r31490 | self.flush() | ||
|
r31690 | |||
wasformatted = self.formatted() | ||||
|
r30992 | if util.safehasattr(signal, "SIGPIPE"): | ||
signal.signal(signal.SIGPIPE, _catchterm) | ||||
|
r31954 | if self._runpager(pagercmd, pagerenv): | ||
|
r31690 | 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('ui', 'formatted', wasformatted, 'pager') | ||||
self.setconfig('ui', 'interactive', False, 'pager') | ||||
|
r31691 | |||
# If pagermode differs from color.mode, reconfigure color now that | ||||
# pageractive is set. | ||||
cm = self._colormode | ||||
if cm != self.config('color', 'pagermode', cm): | ||||
color.setup(self) | ||||
|
r31690 | 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() | ||||
|
r30992 | |||
|
r31954 | def _runpager(self, command, env=None): | ||
|
r30992 | """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. | ||||
""" | ||||
|
r31479 | if command == 'cat': | ||
# Save ourselves some work. | ||||
|
r31690 | return False | ||
|
r31478 | # 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 "|&;<>()$`\\\"' \t\n*?[#~=%") | ||||
|
r31624 | |||
|
r34646 | if pycompat.iswindows and not shell: | ||
|
r31624 | # 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 = util.findexe(command) | ||||
if not fullcmd: | ||||
self.warn(_("missing pager command '%s', skipping pager\n") | ||||
% command) | ||||
|
r31690 | return False | ||
|
r31624 | |||
command = fullcmd | ||||
|
r31478 | try: | ||
pager = subprocess.Popen( | ||||
command, shell=shell, bufsize=-1, | ||||
close_fds=util.closefds, stdin=subprocess.PIPE, | ||||
|
r31954 | stdout=util.stdout, stderr=util.stderr, | ||
env=util.shellenviron(env)) | ||||
|
r31478 | except OSError as e: | ||
if e.errno == errno.ENOENT and not shell: | ||||
self.warn(_("missing pager command '%s', skipping pager\n") | ||||
% command) | ||||
|
r31690 | return False | ||
|
r31478 | raise | ||
|
r30992 | |||
# back up original file descriptors | ||||
stdoutfd = os.dup(util.stdout.fileno()) | ||||
stderrfd = os.dup(util.stderr.fileno()) | ||||
os.dup2(pager.stdin.fileno(), util.stdout.fileno()) | ||||
if self._isatty(util.stderr): | ||||
os.dup2(pager.stdin.fileno(), util.stderr.fileno()) | ||||
|
r31958 | @self.atexit | ||
|
r30992 | def killpager(): | ||
if util.safehasattr(signal, "SIGINT"): | ||||
signal.signal(signal.SIGINT, signal.SIG_IGN) | ||||
# restore original fds, closing pager.stdin copies in the process | ||||
os.dup2(stdoutfd, util.stdout.fileno()) | ||||
os.dup2(stderrfd, util.stderr.fileno()) | ||||
pager.stdin.close() | ||||
pager.wait() | ||||
|
r31690 | return True | ||
|
r34883 | @property | ||
def _exithandlers(self): | ||||
return _reqexithandlers | ||||
|
r31956 | 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 | ||||
|
r28542 | def interface(self, feature): | ||
"""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). | ||||
|
r30332 | Consider the following example: | ||
|
r28542 | 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(["text", "curses"]) | ||||
featureinterfaces = { | ||||
"chunkselector": [ | ||||
"text", | ||||
"curses", | ||||
] | ||||
} | ||||
# Feature-specific interface | ||||
if feature not in featureinterfaces.keys(): | ||||
# Programming error, not user error | ||||
raise ValueError("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( | ||||
"Feature %s does not handle all default interfaces" % | ||||
feature) | ||||
if self.plain(): | ||||
return "text" | ||||
# Default interface for all the features | ||||
defaultinterface = "text" | ||||
|
r33499 | i = self.config("ui", "interface") | ||
|
r28542 | if i in alldefaults: | ||
defaultinterface = i | ||||
choseninterface = defaultinterface | ||||
|
r34617 | f = self.config("ui", "interface.%s" % feature) | ||
|
r28542 | if f in availableinterfaces: | ||
choseninterface = f | ||||
if i is not None and defaultinterface != i: | ||||
if f is not None: | ||||
self.warn(_("invalid value for ui.interface: %s\n") % | ||||
(i,)) | ||||
else: | ||||
self.warn(_("invalid value for ui.interface: %s (using %s)\n") % | ||||
(i, choseninterface)) | ||||
if f is not None and choseninterface != f: | ||||
self.warn(_("invalid value for ui.interface.%s: %s (using %s)\n") % | ||||
(feature, f, choseninterface)) | ||||
return choseninterface | ||||
|
r8208 | def interactive(self): | ||
|
r11325 | '''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()'. | ||||
''' | ||||
r33061 | i = self.configbool("ui", "interactive") | |||
|
r8538 | if i is None: | ||
|
r14515 | # some environments replace stdin without implementing isatty | ||
# usually those are non-interactive | ||||
|
r16751 | return self._isatty(self.fin) | ||
|
r10077 | |||
|
r8538 | return i | ||
|
r8208 | |||
|
r12689 | def termwidth(self): | ||
'''how wide is the terminal in columns? | ||||
''' | ||||
|
r30277 | if 'COLUMNS' in encoding.environ: | ||
|
r12689 | try: | ||
|
r30277 | return int(encoding.environ['COLUMNS']) | ||
|
r12689 | except ValueError: | ||
pass | ||||
|
r30314 | return scmutil.termsize(self)[0] | ||
|
r12689 | |||
|
r11324 | def formatted(self): | ||
|
r11325 | '''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()'. | ||||
''' | ||||
|
r11324 | if self.plain(): | ||
return False | ||||
|
r33499 | i = self.configbool("ui", "formatted") | ||
|
r11324 | if i is None: | ||
|
r14515 | # some environments replace stdout without implementing isatty | ||
# usually those are non-interactive | ||||
|
r16751 | return self._isatty(self.fout) | ||
|
r11324 | |||
return i | ||||
|
r35974 | def _readline(self): | ||
|
r16751 | if self._isatty(self.fin): | ||
|
r5036 | try: | ||
# magically add command line editing support, where | ||||
# available | ||||
import readline | ||||
# force demandimport to really load the module | ||||
readline.read_history_file | ||||
|
r7496 | # windows sometimes raises something other than ImportError | ||
except Exception: | ||||
|
r5036 | pass | ||
|
r14614 | |||
|
r22291 | # prompt ' ' must exist; otherwise readline may delete entire line | ||
# - http://bugs.python.org/issue12833 | ||||
|
r30978 | with self.timeblockedsection('stdio'): | ||
|
r33838 | line = util.bytesinput(self.fin, self.fout, r' ') | ||
|
r14614 | |||
|
r5613 | # When stdin is in binary mode on Windows, it can cause | ||
# raw_input() to emit an extra trailing carriage return | ||||
|
r31775 | if pycompat.oslinesep == '\r\n' and line and line[-1] == '\r': | ||
|
r5613 | line = line[:-1] | ||
return line | ||||
|
r5036 | |||
|
r9048 | def prompt(self, msg, default="y"): | ||
"""Prompt user with msg, read response. | ||||
If ui is not interactive, the default is returned. | ||||
|
r5751 | """ | ||
|
r8208 | if not self.interactive(): | ||
|
r28039 | self.write(msg, ' ', default or '', "\n") | ||
|
r7320 | return default | ||
|
r35975 | self._writenobuf(msg, label='ui.prompt') | ||
|
r35974 | self.flush() | ||
|
r9048 | try: | ||
|
r35974 | r = self._readline() | ||
|
r9048 | if not r: | ||
|
r22589 | r = default | ||
|
r23053 | if self.configbool('ui', 'promptecho'): | ||
|
r22589 | self.write(r, "\n") | ||
|
r9048 | return r | ||
except EOFError: | ||||
|
r26896 | raise error.ResponseExpected() | ||
|
r9048 | |||
|
r20265 | @staticmethod | ||
def extractchoices(prompt): | ||||
"""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 &)". | ||||
|
r27392 | |||
|
r34133 | >>> ui.extractchoices(b"awake? $$ &Yes $$ &No") | ||
|
r27392 | ('awake? ', [('y', 'Yes'), ('n', 'No')]) | ||
|
r34133 | >>> ui.extractchoices(b"line\\nbreak? $$ &Yes $$ &No") | ||
|
r27392 | ('line\\nbreak? ', [('y', 'Yes'), ('n', 'No')]) | ||
|
r34133 | >>> ui.extractchoices(b"want lots of $$money$$?$$Ye&s$$N&o") | ||
|
r27392 | ('want lots of $$money$$?', [('s', 'Yes'), ('o', 'No')]) | ||
|
r20265 | """ | ||
|
r27392 | |||
# 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. | ||||
|
r33096 | m = re.match(br'(?s)(.+?)\$\$([^\$]*&[^ \$].*)', prompt) | ||
|
r27392 | msg = m.group(1) | ||
choices = [p.strip(' ') for p in m.group(2).split('$$')] | ||||
|
r33680 | def choicetuple(s): | ||
ampidx = s.index('&') | ||||
return s[ampidx + 1:ampidx + 2].lower(), s.replace('&', '', 1) | ||||
return (msg, [choicetuple(s) for s in choices]) | ||||
|
r20265 | |||
|
r19226 | def promptchoice(self, prompt, default=0): | ||
"""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. | ||||
|
r9048 | """ | ||
|
r19226 | |||
|
r20265 | msg, choices = self.extractchoices(prompt) | ||
resps = [r for r, t in choices] | ||||
|
r5671 | while True: | ||
|
r9048 | r = self.prompt(msg, resps[default]) | ||
if r.lower() in resps: | ||||
return resps.index(r.lower()) | ||||
self.write(_("unrecognized response\n")) | ||||
|
r2281 | def getpass(self, prompt=None, default=None): | ||
|
r10282 | if not self.interactive(): | ||
return default | ||||
|
r7798 | try: | ||
|
r19880 | self.write_err(self.label(prompt or _('password: '), 'ui.prompt')) | ||
|
r21195 | # disable getpass() only if explicitly specified. it's still valid | ||
# to interact with tty even if fin is not a tty. | ||||
|
r30978 | with self.timeblockedsection('stdio'): | ||
if self.configbool('ui', 'nontty'): | ||||
l = self.fin.readline() | ||||
if not l: | ||||
raise EOFError | ||||
return l.rstrip('\n') | ||||
else: | ||||
return getpass.getpass('') | ||||
|
r7798 | except EOFError: | ||
|
r26896 | raise error.ResponseExpected() | ||
|
r10815 | def status(self, *msg, **opts): | ||
'''write status message to output (if ui.quiet is False) | ||||
This adds an output label of "ui.status". | ||||
''' | ||||
|
r10282 | if not self.quiet: | ||
|
r31177 | opts[r'label'] = opts.get(r'label', '') + ' ui.status' | ||
|
r10815 | self.write(*msg, **opts) | ||
def warn(self, *msg, **opts): | ||||
'''write warning message to output (stderr) | ||||
This adds an output label of "ui.warning". | ||||
''' | ||||
|
r31177 | opts[r'label'] = opts.get(r'label', '') + ' ui.warning' | ||
|
r10815 | self.write_err(*msg, **opts) | ||
def note(self, *msg, **opts): | ||||
'''write note to output (if ui.verbose is True) | ||||
This adds an output label of "ui.note". | ||||
''' | ||||
|
r10282 | if self.verbose: | ||
|
r31177 | opts[r'label'] = opts.get(r'label', '') + ' ui.note' | ||
|
r10815 | self.write(*msg, **opts) | ||
def debug(self, *msg, **opts): | ||||
'''write debug message to output (if ui.debugflag is True) | ||||
This adds an output label of "ui.debug". | ||||
''' | ||||
|
r10282 | if self.debugflag: | ||
|
r31177 | opts[r'label'] = opts.get(r'label', '') + ' ui.debug' | ||
|
r10815 | self.write(*msg, **opts) | ||
|
r26750 | |||
|
r30835 | def edit(self, text, user, extra=None, editform=None, pending=None, | ||
|
r34030 | repopath=None, action=None): | ||
if action is None: | ||||
self.develwarn('action is None but will soon be a required ' | ||||
'parameter to ui.edit()') | ||||
|
r28635 | extra_defaults = { | ||
'prefix': 'editor', | ||||
'suffix': '.txt', | ||||
} | ||||
|
r27153 | if extra is not None: | ||
|
r34030 | if extra.get('suffix') is not None: | ||
self.develwarn('extra.suffix is not None but will soon be ' | ||||
'ignored by ui.edit()') | ||||
|
r27153 | extra_defaults.update(extra) | ||
extra = extra_defaults | ||||
|
r30835 | |||
|
r34056 | if action == 'diff': | ||
suffix = '.diff' | ||||
elif action: | ||||
|
r34030 | suffix = '.%s.hg.txt' % action | ||
else: | ||||
suffix = extra['suffix'] | ||||
|
r30848 | rdir = None | ||
|
r30835 | if self.configbool('experimental', 'editortmpinhg'): | ||
|
r30848 | rdir = repopath | ||
|
r27153 | (fd, name) = tempfile.mkstemp(prefix='hg-' + extra['prefix'] + '-', | ||
|
r34030 | suffix=suffix, | ||
|
r30848 | dir=rdir) | ||
|
r1984 | try: | ||
|
r31778 | f = os.fdopen(fd, r'wb') | ||
f.write(util.tonativeeol(text)) | ||||
|
r1984 | f.close() | ||
|
r20605 | environ = {'HGUSER': user} | ||
|
r20606 | if 'transplant_source' in extra: | ||
environ.update({'HGREVISION': hex(extra['transplant_source'])}) | ||||
|
r24687 | for label in ('intermediate-source', 'source', 'rebase_source'): | ||
|
r20605 | if label in extra: | ||
environ.update({'HGREVISION': extra[label]}) | ||||
break | ||||
|
r22205 | if editform: | ||
environ.update({'HGEDITFORM': editform}) | ||||
|
r26750 | if pending: | ||
environ.update({'HG_PENDING': pending}) | ||||
|
r20605 | |||
|
r5660 | editor = self.geteditor() | ||
|
r207 | |||
|
r23269 | self.system("%s \"%s\"" % (editor, name), | ||
|
r20605 | environ=environ, | ||
|
r30980 | onerr=error.Abort, errprefix=_("edit failed"), | ||
blockedtag='editor') | ||||
|
r608 | |||
|
r31778 | f = open(name, r'rb') | ||
t = util.fromnativeeol(f.read()) | ||||
|
r1984 | f.close() | ||
finally: | ||||
os.unlink(name) | ||||
|
r662 | |||
|
r207 | return t | ||
|
r2200 | |||
|
r30979 | def system(self, cmd, environ=None, cwd=None, onerr=None, errprefix=None, | ||
blockedtag=None): | ||||
|
r23269 | '''execute shell command with appropriate output stream. command | ||
output will be redirected if fout is not stdout. | ||||
|
r31108 | |||
if command fails and onerr is None, return status, else raise onerr | ||||
object as exception. | ||||
|
r23269 | ''' | ||
|
r30979 | if blockedtag is None: | ||
|
r31535 | # Long cmds tend to be because of an absolute path on cmd. Keep | ||
# the tail end instead | ||||
cmdsuffix = cmd.translate(None, _keepalnum)[-85:] | ||||
blockedtag = 'unknown_system_' + cmdsuffix | ||||
|
r24848 | out = self.fout | ||
|
r25149 | if any(s[1] for s in self._bufferstates): | ||
|
r24848 | out = self | ||
|
r30979 | with self.timeblockedsection(blockedtag): | ||
|
r31108 | rc = self._runsystem(cmd, environ=environ, cwd=cwd, out=out) | ||
if rc and onerr: | ||||
errmsg = '%s %s' % (os.path.basename(cmd.split(None, 1)[0]), | ||||
util.explainexit(rc)[0]) | ||||
if errprefix: | ||||
errmsg = '%s: %s' % (errprefix, errmsg) | ||||
raise onerr(errmsg) | ||||
return rc | ||||
|
r31107 | |||
|
r31108 | def _runsystem(self, cmd, environ, cwd, out): | ||
|
r31107 | """actually execute the given shell command (can be overridden by | ||
extensions like chg)""" | ||||
|
r31108 | return util.system(cmd, environ=environ, cwd=cwd, out=out) | ||
|
r23269 | |||
|
r18966 | def traceback(self, exc=None, force=False): | ||
'''print exception traceback if traceback printing enabled or forced. | ||||
|
r2335 | only to call in exception handler. returns true if traceback | ||
printed.''' | ||||
|
r18966 | if self.tracebackflag or force: | ||
|
r18965 | 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('Traceback (most recent call last):\n', | ||||
''.join(exctb[:-1]), | ||||
''.join(causetb), | ||||
''.join(exconly)) | ||||
else: | ||||
|
r25568 | output = traceback.format_exception(exc[0], exc[1], exc[2]) | ||
|
r35915 | self.write_err(encoding.strtolocal(r''.join(output))) | ||
|
r18966 | return self.tracebackflag or force | ||
|
r5660 | |||
def geteditor(self): | ||||
'''return editor to use''' | ||||
|
r30641 | if pycompat.sysplatform == 'plan9': | ||
|
r16383 | # vi is the MIPS instruction simulator on Plan 9. We | ||
# instead default to E to plumb commit messages to | ||||
# avoid confusion. | ||||
editor = 'E' | ||||
else: | ||||
editor = 'vi' | ||||
|
r30277 | return (encoding.environ.get("HGEDITOR") or | ||
|
r31687 | self.config("ui", "editor", editor)) | ||
|
r9153 | |||
|
r25499 | @util.propertycache | ||
def _progbar(self): | ||||
"""setup the progbar singleton to the ui object""" | ||||
if (self.quiet or self.debugflag | ||||
|
r33499 | or self.configbool('progress', 'disable') | ||
|
r25499 | or not progress.shouldprint(self)): | ||
return None | ||||
return getprogbar(self) | ||||
def _progclear(self): | ||||
"""clear progress bar output if any. use it before any output""" | ||||
|
r34346 | if not haveprogbar(): # nothing loaded yet | ||
|
r25499 | return | ||
if self._progbar is not None and self._progbar.printed: | ||||
self._progbar.clear() | ||||
|
r9153 | def progress(self, topic, pos, item="", unit="", total=None): | ||
'''show a progress message | ||||
|
r28598 | By default a textual progress bar will be displayed if an operation | ||
takes too long. 'topic' is the current operation, 'item' is a | ||||
|
r17424 | non-numeric marker of the current position (i.e. the currently | ||
in-process file), 'pos' is the current numeric position (i.e. | ||||
|
r9398 | revision, bytes, etc.), unit is a corresponding unit label, | ||
|
r9153 | and total is the highest expected pos. | ||
|
r10425 | Multiple nested topics may be active at a time. | ||
All topics should be marked closed by setting pos to None at | ||||
termination. | ||||
|
r9153 | ''' | ||
|
r25499 | if self._progbar is not None: | ||
self._progbar.progress(topic, pos, item=item, unit=unit, | ||||
total=total) | ||||
|
r25125 | if pos is None or not self.configbool('progress', 'debug'): | ||
|
r9153 | return | ||
|
r9398 | if unit: | ||
unit = ' ' + unit | ||||
|
r9153 | if item: | ||
item = ' ' + item | ||||
if total: | ||||
pct = 100.0 * pos / total | ||||
|
r34272 | self.debug('%s:%s %d/%d%s (%4.2f%%)\n' | ||
|
r9398 | % (topic, item, pos, total, unit, pct)) | ||
|
r9153 | else: | ||
|
r34272 | self.debug('%s:%s %d%s\n' % (topic, item, pos, unit)) | ||
|
r10815 | |||
|
r18669 | def log(self, service, *msg, **opts): | ||
|
r11984 | '''hook for logging facility extensions | ||
service should be a readily-identifiable subsystem, which will | ||||
allow filtering. | ||||
|
r26235 | |||
*msg should be a newline-terminated format string to log, and | ||||
then any values to %-format into that format string. | ||||
**opts currently has no defined meanings. | ||||
|
r11984 | ''' | ||
|
r10815 | def label(self, msg, label): | ||
'''style msg based on supplied label | ||||
|
r31087 | 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. | ||||
|
r10815 | |||
ui.write(s, 'label') is equivalent to | ||||
ui.write(ui.label(s, 'label')). | ||||
''' | ||||
|
r31087 | if self._colormode is not None: | ||
return color.colorlabel(self, msg, label) | ||||
|
r10815 | return msg | ||
|
r24250 | |||
|
r29095 | def develwarn(self, msg, stacklevel=1, config=None): | ||
|
r27274 | """issue a developer warning message | ||
Use 'stacklevel' to report the offender some layers further up in the | ||||
stack. | ||||
""" | ||||
|
r29095 | if not self.configbool('devel', 'all-warnings'): | ||
|
r35125 | if config is None or not self.configbool('devel', config): | ||
|
r29095 | return | ||
|
r25629 | msg = 'devel-warn: ' + msg | ||
|
r27274 | stacklevel += 1 # get in develwarn | ||
|
r25629 | if self.tracebackflag: | ||
|
r27274 | util.debugstacktrace(msg, stacklevel, self.ferr, self.fout) | ||
|
r28498 | self.log('develwarn', '%s at:\n%s' % | ||
(msg, ''.join(util.getstackframes(stacklevel)))) | ||||
|
r25629 | else: | ||
curframe = inspect.currentframe() | ||||
calframe = inspect.getouterframes(curframe, 2) | ||||
|
r36144 | fname, lineno, fmsg = calframe[stacklevel][1:4] | ||
fname, fmsg = pycompat.sysbytes(fname), pycompat.sysbytes(fmsg) | ||||
self.write_err('%s at: %s:%d (%s)\n' | ||||
% (msg, fname, lineno, fmsg)) | ||||
self.log('develwarn', '%s at: %s:%d (%s)\n', | ||||
msg, fname, lineno, fmsg) | ||||
|
r29762 | curframe = calframe = None # avoid cycles | ||
|
r25629 | |||
|
r35941 | def deprecwarn(self, msg, version, stacklevel=2): | ||
|
r27275 | """issue a deprecation warning | ||
- msg: message explaining what is deprecated and how to upgrade, | ||||
- version: last version where the API will be supported, | ||||
""" | ||||
|
r29082 | if not (self.configbool('devel', 'all-warnings') | ||
or self.configbool('devel', 'deprec-warn')): | ||||
return | ||||
|
r27275 | msg += ("\n(compatibility will be dropped after Mercurial-%s," | ||
" update your code.)") % version | ||||
|
r35941 | self.develwarn(msg, stacklevel=stacklevel, config='deprec-warn') | ||
|
r25629 | |||
|
r30832 | def exportableenviron(self): | ||
"""The environment variables that are safe to export, e.g. through | ||||
hgweb. | ||||
""" | ||||
return self._exportableenviron | ||||
|
r30480 | @contextlib.contextmanager | ||
def configoverride(self, overrides, source=""): | ||||
"""Context manager for temporary config overrides | ||||
`overrides` must be a dict of the following structure: | ||||
{(section, name) : value}""" | ||||
backups = {} | ||||
|
r30537 | 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 ('ui', 'quiet') in overrides: | ||||
self.fixconfig(section='ui') | ||||
|
r30480 | |||
|
r24250 | class paths(dict): | ||
"""Represents a collection of paths and their configs. | ||||
Data is initially derived from ui instances and the config files they have | ||||
loaded. | ||||
""" | ||||
def __init__(self, ui): | ||||
dict.__init__(self) | ||||
|
r27266 | for name, loc in ui.configitems('paths', ignoresub=True): | ||
|
r24250 | # No location is the same as not existing. | ||
if not loc: | ||||
continue | ||||
|
r27266 | loc, sub = ui.configsuboptions('paths', name) | ||
self[name] = path(ui, name, rawloc=loc, suboptions=sub) | ||||
|
r24250 | |||
def getpath(self, name, default=None): | ||||
|
r27561 | """Return a ``path`` from a string, falling back to default. | ||
|
r26056 | |||
``name`` can be a named path or locations. Locations are filesystem | ||||
paths or URIs. | ||||
|
r24250 | |||
|
r26189 | Returns None if ``name`` is not a registered path, a URI, or a local | ||
path to a repo. | ||||
|
r24250 | """ | ||
|
r26189 | # Only fall back to default if no path was requested. | ||
if name is None: | ||||
|
r27561 | if not default: | ||
default = () | ||||
elif not isinstance(default, (tuple, list)): | ||||
default = (default,) | ||||
for k in default: | ||||
|
r26189 | try: | ||
|
r27561 | return self[k] | ||
|
r26189 | except KeyError: | ||
|
r27561 | continue | ||
return None | ||||
|
r26189 | |||
# Most likely empty string. | ||||
# This may need to raise in the future. | ||||
if not name: | ||||
return None | ||||
|
r24250 | try: | ||
return self[name] | ||||
except KeyError: | ||||
|
r26056 | # Try to resolve as a local path or URI. | ||
try: | ||||
|
r27265 | # We don't pass sub-options in, so no need to pass ui instance. | ||
return path(None, None, rawloc=name) | ||||
|
r26056 | except ValueError: | ||
|
r26189 | raise error.RepoError(_('repository %s does not exist') % | ||
name) | ||||
|
r26056 | |||
|
r27266 | _pathsuboptions = {} | ||
def pathsuboption(option, attr): | ||||
"""Decorator used to declare a path sub-option. | ||||
Arguments are the sub-option name and the attribute it should set on | ||||
``path`` instances. | ||||
The decorated function will receive as arguments a ``ui`` instance, | ||||
``path`` instance, and the string value of this option from the config. | ||||
The function should return the value that will be set on the ``path`` | ||||
instance. | ||||
This decorator can be used to perform additional verification of | ||||
sub-options and to change the type of sub-options. | ||||
""" | ||||
def register(func): | ||||
_pathsuboptions[option] = (attr, func) | ||||
return func | ||||
return register | ||||
@pathsuboption('pushurl', 'pushloc') | ||||
def pushurlpathoption(ui, path, value): | ||||
u = util.url(value) | ||||
# Actually require a URL. | ||||
if not u.scheme: | ||||
ui.warn(_('(paths.%s:pushurl not a URL; ignoring)\n') % path.name) | ||||
return None | ||||
# Don't support the #foo syntax in the push URL to declare branch to | ||||
# push. | ||||
if u.fragment: | ||||
ui.warn(_('("#fragment" in paths.%s:pushurl not supported; ' | ||||
'ignoring)\n') % path.name) | ||||
u.fragment = None | ||||
return str(u) | ||||
|
r29413 | @pathsuboption('pushrev', 'pushrev') | ||
def pushrevpathoption(ui, path, value): | ||||
return value | ||||
|
r24250 | class path(object): | ||
"""Represents an individual path and its configuration.""" | ||||
|
r27266 | def __init__(self, ui, name, rawloc=None, suboptions=None): | ||
|
r24250 | """Construct a path from its config options. | ||
|
r27265 | ``ui`` is the ``ui`` instance the path is coming from. | ||
|
r24250 | ``name`` is the symbolic name of the path. | ||
``rawloc`` is the raw location, as defined in the config. | ||||
|
r26064 | ``pushloc`` is the raw locations pushes should be made to. | ||
|
r26056 | |||
If ``name`` is not defined, we require that the location be a) a local | ||||
filesystem path with a .hg directory or b) a URL. If not, | ||||
``ValueError`` is raised. | ||||
|
r24250 | """ | ||
|
r26056 | if not rawloc: | ||
raise ValueError('rawloc must be defined') | ||||
# Locations may define branches via syntax <base>#<branch>. | ||||
u = util.url(rawloc) | ||||
branch = None | ||||
if u.fragment: | ||||
branch = u.fragment | ||||
u.fragment = None | ||||
self.url = u | ||||
self.branch = branch | ||||
|
r24250 | self.name = name | ||
|
r26056 | self.rawloc = rawloc | ||
|
r31350 | self.loc = '%s' % u | ||
|
r26056 | |||
# When given a raw location but not a symbolic name, validate the | ||||
# location is valid. | ||||
|
r26076 | if not name and not u.scheme and not self._isvalidlocalpath(self.loc): | ||
|
r26056 | raise ValueError('location is not a URL or path to a local ' | ||
'repo: %s' % rawloc) | ||||
|
r25498 | |||
|
r27266 | suboptions = suboptions or {} | ||
# Now process the sub-options. If a sub-option is registered, its | ||||
# attribute will always be present. The value will be None if there | ||||
# was no valid sub-option. | ||||
for suboption, (attr, func) in _pathsuboptions.iteritems(): | ||||
if suboption not in suboptions: | ||||
setattr(self, attr, None) | ||||
continue | ||||
value = func(ui, self, suboptions[suboption]) | ||||
setattr(self, attr, value) | ||||
|
r26076 | def _isvalidlocalpath(self, path): | ||
"""Returns True if the given path is a potentially valid repository. | ||||
This is its own function so that extensions can change the definition of | ||||
'valid' in this case (like when pulling from a git repo into a hg | ||||
one).""" | ||||
return os.path.isdir(os.path.join(path, '.hg')) | ||||
|
r26064 | @property | ||
|
r27266 | def suboptions(self): | ||
"""Return sub-options and their values for this path. | ||||
This is intended to be used for presentation purposes. | ||||
""" | ||||
d = {} | ||||
for subopt, (attr, _func) in _pathsuboptions.iteritems(): | ||||
value = getattr(self, attr) | ||||
if value is not None: | ||||
d[subopt] = value | ||||
return d | ||||
|
r26064 | |||
|
r25498 | # we instantiate one globally shared progress bar to avoid | ||
# competing progress bars when multiple UI objects get created | ||||
_progresssingleton = None | ||||
def getprogbar(ui): | ||||
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 | ||||
|
r34346 | |||
def haveprogbar(): | ||||
return _progresssingleton is not None | ||||