ui.py
2311 lines
| 80.4 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 traceback | ||||
from .i18n import _ | ||||
from .node import hex | ||||
|
r43357 | from .pycompat import ( | ||
|
r43359 | getattr, | ||
|
r43357 | open, | ||
setattr, | ||||
) | ||||
|
r25989 | |||
from . import ( | ||||
|
r31087 | color, | ||
|
r25989 | config, | ||
r32984 | configitems, | |||
|
r30277 | encoding, | ||
|
r25989 | error, | ||
formatter, | ||||
|
r41030 | loggingutil, | ||
|
r25989 | progress, | ||
|
r30519 | pycompat, | ||
|
r31679 | rcutil, | ||
|
r25989 | scmutil, | ||
util, | ||||
) | ||||
|
r37102 | from .utils import ( | ||
dateutil, | ||||
|
r37137 | procutil, | ||
|
r37102 | stringutil, | ||
) | ||||
|
r207 | |||
|
r29378 | urlreq = util.urlreq | ||
|
r30979 | # for use with str.translate(None, _keepalnum), to keep just alphanumerics | ||
|
r43347 | _keepalnum = b''.join( | ||
|
r43346 | 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 | ||||
|
r41634 | # Make compatible commands emit cwd-relative paths by default. | ||
relative-paths = yes | ||||
|
r32872 | |||
[commands] | ||||
|
r38674 | # Grep working directory by default. | ||
grep.all-files = True | ||||
|
r34708 | # Refuse to perform an `hg update` that would cause a file content merge | ||
update.check = noconflict | ||||
|
r36926 | # Show conflicts information in `hg status` | ||
status.verbose = True | ||||
|
r42764 | # Make `hg resolve` with no action (like `-m`) fail instead of re-merging. | ||
resolve.explicit-re-merge = True | ||||
|
r32872 | |||
[diff] | ||||
git = 1 | ||||
|
r35308 | showfunc = 1 | ||
|
r38642 | word-diff = 1 | ||
|
r32872 | """ | ||
|
r22419 | samplehgrcs = { | ||
|
r43347 | b'user': 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] | ||
|
r42165 | # uncomment the lines below to enable some popular extensions | ||
|
r29978 | # (see 'hg help extensions' for more info) | ||
|
r22419 | # | ||
|
r42166 | # histedit = | ||
# rebase = | ||||
# uncommit = | ||||
|
r32098 | """, | ||
|
r43347 | b'cloned': 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> | ||||
""", | ||||
|
r43347 | b'local': 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 | """, | ||
|
r43347 | b'global': 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] | ||
|
r42165 | # uncomment the lines below to enable some popular extensions | ||
|
r29978 | # (see 'hg help extensions' for more info) | ||
|
r22419 | # | ||
# blackbox = | ||||
|
r32097 | # churn = | ||
|
r32098 | """, | ||
|
r22419 | } | ||
|
r43346 | |||
|
r34483 | def _maybestrurl(maybebytes): | ||
|
r38594 | return pycompat.rapply(pycompat.strurl, maybebytes) | ||
|
r34483 | |||
|
r43346 | |||
|
r34483 | def _maybebytesurl(maybestr): | ||
|
r38594 | return pycompat.rapply(pycompat.bytesurl, maybestr) | ||
|
r30945 | |||
|
r43346 | |||
|
r30945 | class httppasswordmgrdbproxy(object): | ||
"""Delays loading urllib2 until it's needed.""" | ||||
|
r43346 | |||
|
r30945 | 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( | ||
|
r43346 | _maybestrurl(realm), | ||
_maybestrurl(uris), | ||||
_maybestrurl(user), | ||||
_maybestrurl(passwd), | ||||
) | ||||
|
r30945 | |||
|
r34427 | def find_user_password(self, realm, uri): | ||
|
r35918 | mgr = self._get_mgr() | ||
|
r43346 | return _maybebytesurl( | ||
mgr.find_user_password(_maybestrurl(realm), _maybestrurl(uri)) | ||||
) | ||||
|
r30945 | |||
|
r30992 | def _catchterm(*args): | ||
raise error.SignalInterrupt | ||||
|
r30945 | |||
|
r43346 | |||
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 = [] | ||||
|
r43346 | |||
|
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 | |||
|
r43346 | 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 = {} | ||
|
r38545 | self._uninterruptible = False | ||
|
r8136 | |||
|
r8190 | if src: | ||
|
r40579 | self._fout = src._fout | ||
self._ferr = src._ferr | ||||
self._fin = src._fin | ||||
|
r40623 | self._fmsg = src._fmsg | ||
|
r40580 | self._fmsgout = src._fmsgout | ||
self._fmsgerr = src._fmsgerr | ||||
|
r39875 | self._finoutredirected = src._finoutredirected | ||
|
r40761 | self._loggers = src._loggers.copy() | ||
|
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: | ||
|
r40579 | self._fout = procutil.stdout | ||
self._ferr = procutil.stderr | ||||
self._fin = procutil.stdin | ||||
|
r40623 | self._fmsg = None | ||
|
r40580 | self._fmsgout = self.fout # configurable | ||
self._fmsgerr = self.ferr # configurable | ||||
|
r39875 | self._finoutredirected = False | ||
|
r40761 | self._loggers = {} | ||
|
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 | |||
|
r43347 | allowed = self.configlist(b'experimental', b'exportableenviron') | ||
if b'*' in allowed: | ||||
|
r30832 | 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(): | ||
|
r43347 | if t == b'path': | ||
|
r31683 | u.readconfig(f, trust=True) | ||
|
r43347 | elif t == b'items': | ||
|
r31685 | 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: | ||
|
r43347 | raise error.ProgrammingError(b'unknown rctype: %s' % t) | ||
|
r32872 | u._maybetweakdefaults() | ||
|
r30559 | return u | ||
|
r32872 | def _maybetweakdefaults(self): | ||
|
r43347 | if not self.configbool(b'ui', b'tweakdefaults'): | ||
|
r32872 | return | ||
|
r43347 | if self._tweaked or self.plain(b'tweakdefaults'): | ||
|
r32872 | 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() | ||||
|
r43347 | tmpcfg.parse(b'<tweakdefaults>', tweakrc) | ||
|
r32872 | for section in tmpcfg: | ||
for name, value in tmpcfg.items(section): | ||||
if not self.hasconfig(section, name): | ||||
|
r43347 | self.setconfig(section, name, value, b"<tweakdefaults>") | ||
|
r32872 | |||
|
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: | ||||
|
r43347 | self._blockedtimes[key + b'_blocked'] += ( | ||
|
r43346 | util.timer() - starttime | ||
) * 1000 | ||||
|
r29366 | |||
|
r38545 | @contextlib.contextmanager | ||
|
r41106 | def uninterruptible(self): | ||
|
r38545 | """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. | ||||
""" | ||||
|
r43347 | enabled = self.configbool(b'experimental', b'nointerrupt') | ||
|
r43346 | if enabled and self.configbool( | ||
|
r43347 | b'experimental', b'nointerrupt-interactiveonly' | ||
|
r43346 | ): | ||
|
r38545 | enabled = self.interactive() | ||
if self._uninterruptible or not enabled: | ||||
# if nointerrupt support is turned off, the process isn't | ||||
|
r41106 | # interactive, or we're already in an uninterruptible | ||
|
r38545 | # block, do nothing. | ||
yield | ||||
return | ||||
|
r43346 | |||
|
r38545 | def warn(): | ||
|
r43347 | self.warn(_(b"shutting down cleanly\n")) | ||
|
r38545 | self.warn( | ||
|
r43347 | _(b"press ^C again to terminate immediately (dangerous)\n") | ||
|
r43346 | ) | ||
|
r38545 | return True | ||
|
r43346 | |||
|
r41106 | with procutil.uninterruptible(warn): | ||
|
r38545 | try: | ||
self._uninterruptible = True | ||||
yield | ||||
finally: | ||||
self._uninterruptible = False | ||||
|
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 | ||
|
r43347 | if b'*' in tusers or b'*' in tgroups: | ||
|
r8141 | 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: | ||
|
r43346 | self.warn( | ||
|
r43347 | _( | ||
b'not trusting file %s from untrusted ' | ||||
b'user %s, group %s\n' | ||||
) | ||||
|
r43346 | % (f, user, group) | ||
) | ||||
|
r8141 | return False | ||
|
r3551 | |||
|
r43346 | def readconfig( | ||
self, filename, root=None, trust=False, sections=None, remap=None | ||||
): | ||||
|
r8142 | try: | ||
|
r43906 | fp = open(filename, 'rb') | ||
|
r8142 | except IOError: | ||
|
r43346 | if not sections: # ignore unless we were looking for something | ||
|
r8142 | 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 | ||
|
r43347 | self.warn(_(b"ignored: %s\n") % stringutil.forcebytestr(inst)) | ||
|
r3552 | |||
|
r10455 | if self.plain(): | ||
|
r43346 | for k in ( | ||
|
r43347 | b'debug', | ||
b'fallbackencoding', | ||||
b'quiet', | ||||
b'slash', | ||||
b'logtemplate', | ||||
b'message-output', | ||||
b'statuscopies', | ||||
b'style', | ||||
b'traceback', | ||||
b'verbose', | ||||
|
r43346 | ): | ||
|
r43347 | 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] | ||||
|
r14373 | # Don't remove aliases from the configuration if in the exceptionlist | ||
|
r43347 | 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] | ||||
|
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: | ||
|
r43347 | root = os.path.expanduser(b'~') | ||
|
r3347 | self.fixconfig(root=root) | ||
|
r3014 | |||
|
r12764 | def fixconfig(self, root=None, section=None): | ||
|
r43347 | if section in (None, b'paths'): | ||
|
r12764 | # expand vars and ~ | ||
# translate paths relative to root (or home) into absolute paths | ||||
|
r39843 | root = root or encoding.getcwd() | ||
|
r12764 | for c in self._tcfg, self._ucfg, self._ocfg: | ||
|
r43347 | for n, p in c.items(b'paths'): | ||
|
r29412 | # Ignore sub-options. | ||
|
r43347 | if b':' in n: | ||
|
r29412 | continue | ||
|
r12764 | if not p: | ||
continue | ||||
|
r43347 | if b'%%' in p: | ||
s = self.configsource(b'paths', n) or b'none' | ||||
|
r43346 | self.warn( | ||
|
r43347 | _(b"(deprecated '%%' in path %s=%s from %s)\n") | ||
|
r43346 | % (n, p, s) | ||
) | ||||
|
r43347 | p = p.replace(b'%%', b'%') | ||
|
r12764 | 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)) | ||
|
r43347 | c.set(b"paths", n, p) | ||
|
r3347 | |||
|
r43347 | if section in (None, b'ui'): | ||
|
r12764 | # update ui options | ||
|
r40580 | self._fmsgout, self._fmsgerr = _selectmsgdests(self) | ||
|
r43347 | 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') | ||||
|
r12764 | if self.verbose and self.quiet: | ||
self.quiet = self.verbose = False | ||||
|
r43346 | self._reportuntrusted = self.debugflag or self.configbool( | ||
|
r43347 | b"ui", b"report_untrusted" | ||
|
r43346 | ) | ||
|
r43347 | self.tracebackflag = self.configbool(b'ui', b'traceback') | ||
self.logblockedtimes = self.configbool(b'ui', b'logblockedtimes') | ||||
|
r3350 | |||
|
r43347 | if section in (None, b'trusted'): | ||
|
r12764 | # update trust information | ||
|
r43347 | self._trustusers.update(self.configlist(b'trusted', b'users')) | ||
self._trustgroups.update(self.configlist(b'trusted', b'groups')) | ||||
|
r3551 | |||
|
r41030 | 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) | ||||
|
r15919 | def backupconfig(self, section, item): | ||
|
r43346 | return ( | ||
self._ocfg.backup(section, item), | ||||
self._tcfg.backup(section, item), | ||||
self._ucfg.backup(section, item), | ||||
) | ||||
|
r15919 | def restoreconfig(self, data): | ||
self._ocfg.restore(data[0]) | ||||
self._tcfg.restore(data[1]) | ||||
self._ucfg.restore(data[2]) | ||||
|
r43347 | def setconfig(self, section, name, value, source=b''): | ||
|
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""" | |||
|
r43346 | value = self._config( | ||
section, name, default=default, untrusted=untrusted | ||||
) | ||||
r33058 | 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: | ||
|
r43347 | msg = b"accessing unregistered config item: '%s.%s'" | ||
|
r34859 | msg %= (section, name) | ||
|
r43347 | self.develwarn(msg, 2, b'warn-config-unknown') | ||
|
r33329 | |||
if default is _unset: | ||||
if item is None: | ||||
value = default | ||||
|
r33471 | elif item.default is configitems.dynamicdefault: | ||
value = None | ||||
|
r43347 | msg = b"config item requires an explicit default value: '%s.%s'" | ||
|
r33471 | msg %= (section, name) | ||
|
r43347 | self.develwarn(msg, 2, b'warn-config-default') | ||
|
r33329 | else: | ||
|
r34949 | value = itemdefault | ||
|
r43346 | elif ( | ||
item is not None | ||||
and item.default is not configitems.dynamicdefault | ||||
and default != itemdefault | ||||
): | ||||
msg = ( | ||||
|
r43347 | b"specifying a mismatched default value for a registered " | ||
b"config item: '%s.%s' '%s'" | ||||
|
r43346 | ) | ||
|
r36143 | msg %= (section, name, pycompat.bytestr(default)) | ||
|
r43347 | self.develwarn(msg, 2, b'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 | ||||
|
r15035 | 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: | ||
|
r43346 | self.debug( | ||
|
r43347 | b"ignoring untrusted configuration option " | ||
b"%s.%s = %s\n" % (s, n, uvalue) | ||||
|
r43346 | ) | ||
|
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 = {} | ||||
|
r43347 | prefix = b'%s:' % name | ||
|
r27252 | for k, v in data.items(section): | ||
if k.startswith(prefix): | ||||
|
r43346 | sub[k[len(prefix) :]] = v | ||
|
r27252 | |||
if self.debugflag and not untrusted and self._reportuntrusted: | ||||
for k, v in sub.items(): | ||||
|
r43347 | uvalue = self._ucfg.get(section, b'%s:%s' % (name, k)) | ||
|
r27252 | if uvalue is not None and uvalue != v: | ||
|
r43346 | self.debug( | ||
|
r43347 | b'ignoring untrusted configuration option ' | ||
b'%s:%s.%s = %s\n' % (section, name, k, uvalue) | ||||
|
r43346 | ) | ||
|
r27252 | |||
return main, sub | ||||
r32965 | def configpath(self, section, name, default=_unset, untrusted=False): | |||
|
r44226 | """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 | ||||
|
r43347 | if not os.path.isabs(v) or b"://" not in v: | ||
|
r13238 | src = self.configsource(section, name, untrusted) | ||
|
r43347 | if b':' in src: | ||
base = os.path.dirname(src.rsplit(b':')[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 | ||||
|
r37102 | b = stringutil.parsebool(v) | ||
|
r12087 | if b is None: | ||
|
r43346 | raise error.ConfigError( | ||
|
r43347 | _(b"%s.%s is not a boolean ('%s')") % (section, name, v) | ||
|
r43346 | ) | ||
|
r12087 | return b | ||
|
r3552 | |||
|
r43346 | def configwith( | ||
self, convert, section, name, default=_unset, desc=None, untrusted=False | ||||
): | ||||
|
r30926 | """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: | ||
|
r43346 | 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__) | ||
|
r43346 | raise error.ConfigError( | ||
|
r43347 | _(b"%s.%s is not a valid %s ('%s')") % (section, name, desc, v) | ||
|
r43346 | ) | ||
|
r30926 | |||
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 | """ | ||
|
r43346 | return self.configwith( | ||
|
r43347 | int, section, name, default, b'integer', untrusted | ||
|
r43346 | ) | ||
|
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: | ||||
|
r43346 | raise error.ConfigError( | ||
|
r43347 | _(b"%s.%s is not a byte quantity ('%s')") | ||
|
r43346 | % (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 | ||
|
r43346 | v = self.configwith( | ||
|
r43347 | config.parselist, section, name, default, b'list', untrusted | ||
|
r43346 | ) | ||
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): | ||||
|
r43346 | return self.configwith( | ||
|
r43347 | dateutil.parsedate, section, name, default, b'date', untrusted | ||
|
r43346 | ) | ||
r32964 | if default is _unset: | |||
return None | ||||
|
r32408 | return default | ||
|
r42899 | 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 | ||||
|
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: | ||
|
r43347 | items = [i for i in items if b':' not in i[0]] | ||
|
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: | ||
|
r43346 | self.debug( | ||
|
r43347 | b"ignoring untrusted configuration option " | ||
b"%s.%s = %s\n" % (section, k, v) | ||||
|
r43346 | ) | ||
|
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 | ''' | ||
|
r43346 | if ( | ||
|
r43347 | b'HGPLAIN' not in encoding.environ | ||
and b'HGPLAINEXCEPT' not in encoding.environ | ||||
|
r43346 | ): | ||
|
r13849 | return False | ||
|
r43346 | exceptions = ( | ||
|
r43347 | encoding.environ.get(b'HGPLAINEXCEPT', b'').strip().split(b',') | ||
|
r43346 | ) | ||
|
r35180 | # TODO: add support for HGPLAIN=+feature,-feature syntax | ||
|
r43347 | if b'+strictflags' not in encoding.environ.get(b'HGPLAIN', b'').split( | ||
b',' | ||||
): | ||||
exceptions.append(b'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 | """ | ||
|
r43347 | user = encoding.environ.get(b"HGUSER") | ||
|
r1985 | if user is None: | ||
|
r43347 | user = self.config(b"ui", b"username") | ||
|
r11225 | if user is not None: | ||
user = os.path.expandvars(user) | ||||
|
r1985 | if user is None: | ||
|
r43347 | user = encoding.environ.get(b"EMAIL") | ||
|
r34850 | if user is None and acceptempty: | ||
return user | ||||
|
r43347 | if user is None and self.configbool(b"ui", b"askusername"): | ||
user = self.prompt(_(b"enter a commit username:"), default=None) | ||||
|
r9613 | if user is None and not self.interactive(): | ||
|
r3721 | try: | ||
|
r43347 | user = b'%s@%s' % ( | ||
|
r43346 | procutil.getuser(), | ||
encoding.strtolocal(socket.getfqdn()), | ||||
) | ||||
|
r43347 | self.warn(_(b"no username found, using '%s' instead\n") % user) | ||
|
r3721 | except KeyError: | ||
|
r4044 | pass | ||
if not user: | ||||
|
r43346 | raise error.Abort( | ||
|
r43347 | _(b'no username supplied'), | ||
hint=_(b"use 'hg config --edit' " b'to set your username'), | ||||
|
r43346 | ) | ||
|
r43347 | if b"\n" in user: | ||
|
r43346 | raise error.Abort( | ||
|
r43347 | _(b"username %r contains a newline\n") % pycompat.bytestr(user) | ||
|
r43346 | ) | ||
|
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: | ||
|
r37102 | user = stringutil.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 | |||
|
r40579 | @property | ||
def fout(self): | ||||
return self._fout | ||||
@fout.setter | ||||
def fout(self, f): | ||||
self._fout = f | ||||
|
r40580 | self._fmsgout, self._fmsgerr = _selectmsgdests(self) | ||
|
r40579 | |||
@property | ||||
def ferr(self): | ||||
return self._ferr | ||||
@ferr.setter | ||||
def ferr(self, f): | ||||
self._ferr = f | ||||
|
r40580 | self._fmsgout, self._fmsgerr = _selectmsgdests(self) | ||
|
r40579 | |||
@property | ||||
def fin(self): | ||||
return self._fin | ||||
@fin.setter | ||||
def fin(self, f): | ||||
self._fin = f | ||||
|
r40623 | @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) | ||||
|
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 | ||||
|
r43347 | return b"".join(self._buffers.pop()) | ||
|
r3737 | |||
|
r40577 | def _isbuffered(self, dest): | ||
|
r40579 | if dest is self._fout: | ||
|
r40577 | return bool(self._buffers) | ||
|
r40579 | if dest is self._ferr: | ||
|
r40577 | return bool(self._bufferstates and self._bufferstates[-1][0]) | ||
return False | ||||
|
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``. | ||||
|
r43347 | return self._colormode != b'win32' | ||
|
r35979 | |||
|
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 | |||
|
r43559 | 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. | ||||
|
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. | ||||
''' | ||||
|
r41376 | dest = self._fout | ||
# inlined _write() for speed | ||||
|
r41378 | if self._buffers: | ||
|
r43906 | label = opts.get('label', b'') | ||
|
r41376 | if label and self._bufferapplylabels: | ||
self._buffers[-1].extend(self.label(a, label) for a in args) | ||||
else: | ||||
self._buffers[-1].extend(args) | ||||
|
r41377 | return | ||
|
r43559 | # inlined _writenobuf() for speed | ||
|
r43906 | if not opts.get('keepprogressbar', False): | ||
|
r43559 | self._progclear() | ||
|
r41377 | msg = b''.join(args) | ||
# opencode timeblockedsection because this is a critical path | ||||
starttime = util.timer() | ||||
try: | ||||
|
r43347 | if self._colormode == b'win32': | ||
|
r41377 | # 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: | ||||
|
r43906 | label = opts.get('label', b'') | ||
|
r41377 | msg = self.label(msg, label) | ||
dest.write(msg) | ||||
except IOError as err: | ||||
raise error.StdioError(err) | ||||
finally: | ||||
|
r43347 | self._blockedtimes[b'stdio_blocked'] += ( | ||
|
r43346 | util.timer() - starttime | ||
) * 1000 | ||||
|
r40577 | |||
def write_err(self, *args, **opts): | ||||
|
r40579 | self._write(self._ferr, *args, **opts) | ||
|
r40577 | |||
def _write(self, dest, *args, **opts): | ||||
|
r41376 | # update write() as well if you touch this code | ||
|
r40577 | if self._isbuffered(dest): | ||
|
r43906 | label = opts.get('label', b'') | ||
|
r41375 | if label and self._bufferapplylabels: | ||
|
r31091 | self._buffers[-1].extend(self.label(a, label) for a in args) | ||
else: | ||||
self._buffers[-1].extend(args) | ||||
|
r35975 | else: | ||
|
r40577 | self._writenobuf(dest, *args, **opts) | ||
|
r35975 | |||
|
r40574 | def _writenobuf(self, dest, *args, **opts): | ||
|
r41377 | # update write() as well if you touch this code | ||
|
r43906 | if not opts.get('keepprogressbar', False): | ||
|
r43559 | self._progclear() | ||
|
r40557 | msg = b''.join(args) | ||
|
r31090 | |||
|
r31128 | # opencode timeblockedsection because this is a critical path | ||
starttime = util.timer() | ||||
try: | ||||
|
r40579 | if dest is self._ferr and not getattr(self._fout, 'closed', False): | ||
self._fout.flush() | ||||
|
r40625 | if getattr(dest, 'structured', False): | ||
# channel for machine-readable output with metadata, where | ||||
# no extra colorization is necessary. | ||||
dest.write(msg, **opts) | ||||
|
r43347 | elif self._colormode == b'win32': | ||
|
r40558 | # windows color printing is its own can of crab, defer to | ||
# the color module and that is it. | ||||
|
r40576 | color.win32print(self, dest.write, msg, **opts) | ||
|
r40558 | else: | ||
if self._colormode is not None: | ||||
|
r43906 | label = opts.get('label', b'') | ||
|
r40558 | msg = self.label(msg, label) | ||
|
r40576 | dest.write(msg) | ||
|
r40575 | # stderr may be buffered under win32 when redirected to files, | ||
# including stdout. | ||||
|
r40579 | if dest is self._ferr and not getattr(self._ferr, 'closed', False): | ||
|
r40575 | dest.flush() | ||
|
r31961 | except IOError as err: | ||
|
r43346 | if dest is self._ferr and err.errno in ( | ||
errno.EPIPE, | ||||
errno.EIO, | ||||
errno.EBADF, | ||||
): | ||||
|
r40575 | # no way to report the error, so ignore it | ||
return | ||||
|
r31961 | raise error.StdioError(err) | ||
|
r31128 | finally: | ||
|
r43347 | self._blockedtimes[b'stdio_blocked'] += ( | ||
|
r43346 | util.timer() - starttime | ||
) * 1000 | ||||
|
r565 | |||
|
r40626 | def _writemsg(self, dest, *args, **opts): | ||
_writemsgwith(self._write, dest, *args, **opts) | ||||
def _writemsgnobuf(self, dest, *args, **opts): | ||||
_writemsgwith(self._writenobuf, dest, *args, **opts) | ||||
|
r1837 | def flush(self): | ||
|
r30978 | # opencode timeblockedsection because this is a critical path | ||
starttime = util.timer() | ||||
try: | ||||
|
r31963 | try: | ||
|
r40579 | self._fout.flush() | ||
|
r31963 | except IOError as err: | ||
|
r33859 | if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF): | ||
raise error.StdioError(err) | ||||
|
r31963 | finally: | ||
try: | ||||
|
r40579 | self._ferr.flush() | ||
|
r31963 | except IOError as err: | ||
|
r33859 | if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF): | ||
raise error.StdioError(err) | ||||
|
r30978 | finally: | ||
|
r43347 | self._blockedtimes[b'stdio_blocked'] += ( | ||
|
r43346 | util.timer() - starttime | ||
) * 1000 | ||||
|
r1837 | |||
|
r16751 | def _isatty(self, fh): | ||
|
r43347 | if self.configbool(b'ui', b'nontty'): | ||
|
r16751 | return False | ||
|
r37138 | return procutil.isatty(fh) | ||
|
r1837 | |||
|
r41321 | 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 | ||||
|
r41320 | @contextlib.contextmanager | ||
def protectedfinout(self): | ||||
"""Run code block with protected standard streams""" | ||||
|
r41321 | fin, fout = self.protectfinout() | ||
|
r41320 | try: | ||
yield fin, fout | ||||
finally: | ||||
|
r41321 | self.restorefinout(fin, fout) | ||
|
r41320 | |||
|
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. | ||||
""" | ||||
|
r43346 | if self._disablepager or self.pageractive: | ||
|
r33622 | # how pager should do is already determined | ||
return | ||||
|
r43347 | if not command.startswith(b'internal-always-') and ( | ||
|
r33622 | # explicit --pager=on (= 'internal-always-' prefix) should | ||
# take precedence over disabling factors below | ||||
|
r43347 | 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' | ||||
|
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 | ||
|
r43347 | or b'--debugger' in pycompat.sysargv | ||
|
r43346 | ): | ||
|
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 | ||||
|
r43347 | pagercmd = self.config(b'pager', b'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 | ||||
|
r43346 | self.debug( | ||
|
r43347 | b'starting pager for command %s\n' % stringutil.pprint(command) | ||
|
r43346 | ) | ||
|
r31490 | self.flush() | ||
|
r31690 | |||
wasformatted = self.formatted() | ||||
|
r43347 | if util.safehasattr(signal, b"SIGPIPE"): | ||
|
r30992 | 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. | ||||
|
r43347 | self.setconfig(b'ui', b'formatted', wasformatted, b'pager') | ||
self.setconfig(b'ui', b'interactive', False, b'pager') | ||||
|
r31691 | |||
# If pagermode differs from color.mode, reconfigure color now that | ||||
# pageractive is set. | ||||
cm = self._colormode | ||||
|
r43347 | if cm != self.config(b'color', b'pagermode', cm): | ||
|
r31691 | 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. | ||||
""" | ||||
|
r43347 | if command == b'cat': | ||
|
r31479 | # 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. | ||||
|
r43347 | shell = any(c in command for c in b"|&;<>()$`\\\"' \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. | ||||
|
r37138 | fullcmd = procutil.findexe(command) | ||
|
r31624 | if not fullcmd: | ||
|
r43346 | self.warn( | ||
|
r43347 | _(b"missing pager command '%s', skipping pager\n") % command | ||
|
r43346 | ) | ||
|
r31690 | return False | ||
|
r31624 | |||
command = fullcmd | ||||
|
r31478 | try: | ||
pager = subprocess.Popen( | ||||
|
r43346 | 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)), | ||||
) | ||||
|
r31478 | except OSError as e: | ||
if e.errno == errno.ENOENT and not shell: | ||||
|
r43346 | self.warn( | ||
|
r43347 | _(b"missing pager command '%s', skipping pager\n") % command | ||
|
r43346 | ) | ||
|
r31690 | return False | ||
|
r31478 | raise | ||
|
r30992 | |||
# back up original file descriptors | ||||
|
r37137 | stdoutfd = os.dup(procutil.stdout.fileno()) | ||
stderrfd = os.dup(procutil.stderr.fileno()) | ||||
|
r30992 | |||
|
r37137 | os.dup2(pager.stdin.fileno(), procutil.stdout.fileno()) | ||
if self._isatty(procutil.stderr): | ||||
os.dup2(pager.stdin.fileno(), procutil.stderr.fileno()) | ||||
|
r30992 | |||
|
r31958 | @self.atexit | ||
|
r30992 | def killpager(): | ||
|
r43347 | if util.safehasattr(signal, b"SIGINT"): | ||
|
r30992 | signal.signal(signal.SIGINT, signal.SIG_IGN) | ||
# restore original fds, closing pager.stdin copies in the process | ||||
|
r37137 | os.dup2(stdoutfd, procutil.stdout.fileno()) | ||
os.dup2(stderrfd, procutil.stderr.fileno()) | ||||
|
r30992 | 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). | ||||
""" | ||||
|
r43347 | alldefaults = frozenset([b"text", b"curses"]) | ||
|
r28542 | |||
featureinterfaces = { | ||||
|
r43347 | b"chunkselector": [b"text", b"curses",], | ||
b"histedit": [b"text", b"curses",], | ||||
|
r28542 | } | ||
# Feature-specific interface | ||||
if feature not in featureinterfaces.keys(): | ||||
# Programming error, not user error | ||||
|
r43347 | raise ValueError(b"Unknown feature requested %s" % feature) | ||
|
r28542 | |||
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( | ||||
|
r43347 | b"Feature %s does not handle all default interfaces" % feature | ||
|
r43346 | ) | ||
|
r28542 | |||
|
r43347 | if self.plain() or encoding.environ.get(b'TERM') == b'dumb': | ||
return b"text" | ||||
|
r28542 | |||
# Default interface for all the features | ||||
|
r43347 | defaultinterface = b"text" | ||
i = self.config(b"ui", b"interface") | ||||
|
r28542 | if i in alldefaults: | ||
defaultinterface = i | ||||
choseninterface = defaultinterface | ||||
|
r43347 | f = self.config(b"ui", b"interface.%s" % feature) | ||
|
r28542 | if f in availableinterfaces: | ||
choseninterface = f | ||||
if i is not None and defaultinterface != i: | ||||
if f is not None: | ||||
|
r43347 | self.warn(_(b"invalid value for ui.interface: %s\n") % (i,)) | ||
|
r28542 | else: | ||
|
r43346 | self.warn( | ||
|
r43347 | _(b"invalid value for ui.interface: %s (using %s)\n") | ||
|
r43346 | % (i, choseninterface) | ||
) | ||||
|
r28542 | if f is not None and choseninterface != f: | ||
|
r43346 | self.warn( | ||
|
r43347 | _(b"invalid value for ui.interface.%s: %s (using %s)\n") | ||
|
r43346 | % (feature, f, choseninterface) | ||
) | ||||
|
r28542 | |||
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()'. | ||||
''' | ||||
|
r43347 | i = self.configbool(b"ui", b"interactive") | ||
|
r8538 | if i is None: | ||
|
r14515 | # some environments replace stdin without implementing isatty | ||
# usually those are non-interactive | ||||
|
r40579 | return self._isatty(self._fin) | ||
|
r10077 | |||
|
r8538 | return i | ||
|
r8208 | |||
|
r12689 | def termwidth(self): | ||
'''how wide is the terminal in columns? | ||||
''' | ||||
|
r43347 | if b'COLUMNS' in encoding.environ: | ||
|
r12689 | try: | ||
|
r43347 | return int(encoding.environ[b'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 | ||||
|
r43347 | i = self.configbool(b"ui", b"formatted") | ||
|
r11324 | if i is None: | ||
|
r14515 | # some environments replace stdout without implementing isatty | ||
# usually those are non-interactive | ||||
|
r40579 | return self._isatty(self._fout) | ||
|
r11324 | |||
return i | ||||
|
r43347 | def _readline(self, prompt=b' ', promptopts=None): | ||
|
r36813 | # 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. | ||||
|
r43346 | usereadline = ( | ||
self._isatty(self._fin) | ||||
and self._isatty(self._fout) | ||||
and procutil.isstdin(self._fin) | ||||
and procutil.isstdout(self._fout) | ||||
) | ||||
|
r36812 | if usereadline: | ||
|
r5036 | try: | ||
# magically add command line editing support, where | ||||
# available | ||||
import readline | ||||
|
r43346 | |||
|
r5036 | # force demandimport to really load the module | ||
readline.read_history_file | ||||
|
r7496 | # windows sometimes raises something other than ImportError | ||
except Exception: | ||||
|
r36812 | usereadline = False | ||
|
r14614 | |||
|
r43347 | if self._colormode == b'win32' or not usereadline: | ||
|
r42288 | if not promptopts: | ||
promptopts = {} | ||||
|
r43346 | self._writemsgnobuf( | ||
|
r43347 | self._fmsgout, prompt, type=b'prompt', **promptopts | ||
|
r43346 | ) | ||
|
r42288 | self.flush() | ||
|
r43347 | prompt = b' ' | ||
|
r42288 | else: | ||
|
r43347 | prompt = self.label(prompt, b'ui.prompt') + b' ' | ||
|
r42288 | |||
|
r22291 | # prompt ' ' must exist; otherwise readline may delete entire line | ||
# - http://bugs.python.org/issue12833 | ||||
|
r43347 | with self.timeblockedsection(b'stdio'): | ||
|
r36813 | if usereadline: | ||
|
r43694 | self.flush() | ||
|
r43388 | prompt = encoding.strfromlocal(prompt) | ||
|
r42288 | line = encoding.strtolocal(pycompat.rawinput(prompt)) | ||
|
r36814 | # When stdin is in binary mode on Windows, it can cause | ||
# raw_input() to emit an extra trailing carriage return | ||||
if pycompat.oslinesep == b'\r\n' and line.endswith(b'\r'): | ||||
line = line[:-1] | ||||
|
r36813 | else: | ||
|
r42288 | self._fout.write(pycompat.bytestr(prompt)) | ||
|
r40579 | self._fout.flush() | ||
line = self._fin.readline() | ||||
|
r36813 | if not line: | ||
raise EOFError | ||||
|
r36852 | line = line.rstrip(pycompat.oslinesep) | ||
|
r14614 | |||
|
r5613 | return line | ||
|
r5036 | |||
|
r43347 | def prompt(self, msg, default=b"y"): | ||
|
r9048 | """Prompt user with msg, read response. | ||
If ui is not interactive, the default is returned. | ||||
|
r5751 | """ | ||
|
r40628 | return self._prompt(msg, default=default) | ||
def _prompt(self, msg, **opts): | ||||
|
r43906 | default = opts['default'] | ||
|
r8208 | if not self.interactive(): | ||
|
r43347 | self._writemsg(self._fmsgout, msg, b' ', type=b'prompt', **opts) | ||
|
r43346 | self._writemsg( | ||
|
r43347 | self._fmsgout, default or b'', b"\n", type=b'promptecho' | ||
|
r43346 | ) | ||
|
r7320 | return default | ||
|
r9048 | try: | ||
|
r42288 | r = self._readline(prompt=msg, promptopts=opts) | ||
|
r9048 | if not r: | ||
|
r22589 | r = default | ||
|
r43347 | if self.configbool(b'ui', b'promptecho'): | ||
self._writemsg(self._fmsgout, r, b"\n", type=b'promptecho') | ||||
|
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) | ||
|
r43347 | choices = [p.strip(b' ') for p in m.group(2).split(b'$$')] | ||
|
r43346 | |||
|
r33680 | def choicetuple(s): | ||
|
r43347 | ampidx = s.index(b'&') | ||
return s[ampidx + 1 : ampidx + 2].lower(), s.replace(b'&', b'', 1) | ||||
|
r43346 | |||
|
r33680 | 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: | ||
|
r40628 | r = self._prompt(msg, default=resps[default], choices=choices) | ||
|
r9048 | if r.lower() in resps: | ||
return resps.index(r.lower()) | ||||
|
r40580 | # TODO: shouldn't it be a warning? | ||
|
r43347 | self._writemsg(self._fmsgout, _(b"unrecognized response\n")) | ||
|
r9048 | |||
|
r2281 | def getpass(self, prompt=None, default=None): | ||
|
r10282 | if not self.interactive(): | ||
return default | ||||
|
r7798 | try: | ||
|
r43346 | self._writemsg( | ||
self._fmsgerr, | ||||
|
r43347 | prompt or _(b'password: '), | ||
type=b'prompt', | ||||
|
r43346 | password=True, | ||
) | ||||
|
r21195 | # disable getpass() only if explicitly specified. it's still valid | ||
# to interact with tty even if fin is not a tty. | ||||
|
r43347 | with self.timeblockedsection(b'stdio'): | ||
if self.configbool(b'ui', b'nontty'): | ||||
|
r40579 | l = self._fin.readline() | ||
|
r30978 | if not l: | ||
raise EOFError | ||||
|
r43347 | return l.rstrip(b'\n') | ||
|
r30978 | else: | ||
|
r43906 | return getpass.getpass('') | ||
|
r7798 | except EOFError: | ||
|
r26896 | raise error.ResponseExpected() | ||
|
r38791 | |||
|
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: | ||
|
r43347 | self._writemsg(self._fmsgout, type=b'status', *msg, **opts) | ||
|
r38791 | |||
|
r10815 | def warn(self, *msg, **opts): | ||
'''write warning message to output (stderr) | ||||
This adds an output label of "ui.warning". | ||||
''' | ||||
|
r43347 | self._writemsg(self._fmsgerr, type=b'warning', *msg, **opts) | ||
|
r38791 | |||
def error(self, *msg, **opts): | ||||
'''write error message to output (stderr) | ||||
This adds an output label of "ui.error". | ||||
''' | ||||
|
r43347 | self._writemsg(self._fmsgerr, type=b'error', *msg, **opts) | ||
|
r38791 | |||
|
r10815 | 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: | ||
|
r43347 | self._writemsg(self._fmsgout, type=b'note', *msg, **opts) | ||
|
r38791 | |||
|
r10815 | 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: | ||
|
r43347 | self._writemsg(self._fmsgout, type=b'debug', *msg, **opts) | ||
|
r40792 | self.log(b'debug', b'%s', b''.join(msg)) | ||
|
r26750 | |||
|
r43349 | # Aliases to defeat check-code. | ||
statusnoi18n = status | ||||
notenoi18n = note | ||||
warnnoi18n = warn | ||||
writenoi18n = write | ||||
|
r43346 | def edit( | ||
self, | ||||
text, | ||||
user, | ||||
extra=None, | ||||
editform=None, | ||||
pending=None, | ||||
repopath=None, | ||||
action=None, | ||||
): | ||||
|
r34030 | if action is None: | ||
|
r43346 | self.develwarn( | ||
|
r43347 | b'action is None but will soon be a required ' | ||
b'parameter to ui.edit()' | ||||
|
r43346 | ) | ||
|
r28635 | extra_defaults = { | ||
|
r43347 | b'prefix': b'editor', | ||
b'suffix': b'.txt', | ||||
|
r28635 | } | ||
|
r27153 | if extra is not None: | ||
|
r43347 | if extra.get(b'suffix') is not None: | ||
|
r43346 | self.develwarn( | ||
|
r43347 | b'extra.suffix is not None but will soon be ' | ||
b'ignored by ui.edit()' | ||||
|
r43346 | ) | ||
|
r27153 | extra_defaults.update(extra) | ||
extra = extra_defaults | ||||
|
r30835 | |||
|
r43347 | if action == b'diff': | ||
suffix = b'.diff' | ||||
|
r34056 | elif action: | ||
|
r43347 | suffix = b'.%s.hg.txt' % action | ||
|
r34030 | else: | ||
|
r43347 | suffix = extra[b'suffix'] | ||
|
r34030 | |||
|
r30848 | rdir = None | ||
|
r43347 | if self.configbool(b'experimental', b'editortmpinhg'): | ||
|
r30848 | rdir = repopath | ||
|
r43346 | (fd, name) = pycompat.mkstemp( | ||
|
r43347 | prefix=b'hg-' + extra[b'prefix'] + b'-', suffix=suffix, dir=rdir | ||
|
r43346 | ) | ||
|
r1984 | try: | ||
|
r43906 | f = os.fdopen(fd, 'wb') | ||
|
r31778 | f.write(util.tonativeeol(text)) | ||
|
r1984 | f.close() | ||
|
r43347 | 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'): | ||||
|
r20605 | if label in extra: | ||
|
r43347 | environ.update({b'HGREVISION': extra[label]}) | ||
|
r20605 | break | ||
|
r22205 | if editform: | ||
|
r43347 | environ.update({b'HGEDITFORM': editform}) | ||
|
r26750 | if pending: | ||
|
r43347 | environ.update({b'HG_PENDING': pending}) | ||
|
r20605 | |||
|
r5660 | editor = self.geteditor() | ||
|
r207 | |||
|
r43346 | self.system( | ||
|
r43347 | b"%s \"%s\"" % (editor, name), | ||
|
r43346 | environ=environ, | ||
onerr=error.Abort, | ||||
|
r43347 | errprefix=_(b"edit failed"), | ||
blockedtag=b'editor', | ||||
|
r43346 | ) | ||
|
r608 | |||
|
r43906 | f = open(name, 'rb') | ||
|
r31778 | t = util.fromnativeeol(f.read()) | ||
|
r1984 | f.close() | ||
finally: | ||||
os.unlink(name) | ||||
|
r662 | |||
|
r207 | return t | ||
|
r2200 | |||
|
r43346 | 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:] | ||||
|
r43347 | blockedtag = b'unknown_system_' + cmdsuffix | ||
|
r40579 | 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: | ||||
|
r43347 | errmsg = b'%s %s' % ( | ||
|
r43346 | os.path.basename(cmd.split(None, 1)[0]), | ||
procutil.explainexit(rc), | ||||
) | ||||
|
r31108 | if errprefix: | ||
|
r43347 | errmsg = b'%s: %s' % (errprefix, errmsg) | ||
|
r31108 | 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)""" | ||||
|
r37138 | return procutil.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 | ||||
|
r43346 | self.write_err( | ||
|
r43347 | b'Traceback (most recent call last):\n', | ||
b''.join(exctb[:-1]), | ||||
b''.join(causetb), | ||||
b''.join(exconly), | ||||
|
r43346 | ) | ||
|
r18965 | else: | ||
|
r25568 | output = traceback.format_exception(exc[0], exc[1], exc[2]) | ||
|
r43906 | self.write_err(encoding.strtolocal(''.join(output))) | ||
|
r18966 | return self.tracebackflag or force | ||
|
r5660 | |||
def geteditor(self): | ||||
'''return editor to use''' | ||||
|
r43347 | if pycompat.sysplatform == b'plan9': | ||
|
r16383 | # vi is the MIPS instruction simulator on Plan 9. We | ||
# instead default to E to plumb commit messages to | ||||
# avoid confusion. | ||||
|
r43347 | editor = b'E' | ||
|
r16383 | else: | ||
|
r43347 | editor = b'vi' | ||
return encoding.environ.get(b"HGEDITOR") or self.config( | ||||
b"ui", b"editor", editor | ||||
|
r43346 | ) | ||
|
r9153 | |||
|
r25499 | @util.propertycache | ||
def _progbar(self): | ||||
"""setup the progbar singleton to the ui object""" | ||||
|
r43346 | if ( | ||
self.quiet | ||||
or self.debugflag | ||||
|
r43347 | or self.configbool(b'progress', b'disable') | ||
|
r43346 | or not progress.shouldprint(self) | ||
): | ||||
|
r25499 | return None | ||
return getprogbar(self) | ||||
def _progclear(self): | ||||
"""clear progress bar output if any. use it before any output""" | ||||
|
r43346 | if not haveprogbar(): # nothing loaded yet | ||
|
r25499 | return | ||
if self._progbar is not None and self._progbar.printed: | ||||
self._progbar.clear() | ||||
|
r43347 | def progress(self, topic, pos, item=b"", unit=b"", total=None): | ||
|
r9153 | '''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 | ''' | ||
|
r43347 | self.deprecwarn( | ||
b"use ui.makeprogress() instead of ui.progress()", b"5.1" | ||||
) | ||||
|
r41178 | progress = self.makeprogress(topic, unit, total) | ||
if pos is not None: | ||||
progress.update(pos, item=item) | ||||
|
r9153 | else: | ||
|
r41178 | progress.complete() | ||
|
r10815 | |||
|
r43347 | def makeprogress(self, topic, unit=b"", total=None): | ||
|
r41246 | """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): | ||||
|
r43346 | self._fmsgerr.write( | ||
None, | ||||
type=b'progress', | ||||
topic=topic, | ||||
pos=pos, | ||||
item=item, | ||||
unit=unit, | ||||
total=total, | ||||
) | ||||
|
r41246 | elif self._progbar is not None: | ||
updatebar = self._progbar.progress | ||||
else: | ||||
|
r43346 | |||
|
r41246 | def updatebar(topic, pos, item, unit, total): | ||
pass | ||||
|
r43346 | |||
|
r41246 | return scmutil.progress(self, updatebar, topic, unit, total) | ||
|
r38364 | |||
|
r40761 | 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): | ||||
"""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 | ||||
|
r40793 | def log(self, event, msgfmt, *msgargs, **opts): | ||
|
r11984 | '''hook for logging facility extensions | ||
|
r40714 | event should be a readily-identifiable subsystem, which will | ||
|
r11984 | allow filtering. | ||
|
r26235 | |||
|
r40793 | msgfmt should be a newline-terminated format string to log, and | ||
*msgargs are %-formatted into it. | ||||
|
r26235 | |||
**opts currently has no defined meanings. | ||||
|
r11984 | ''' | ||
|
r40761 | if not self._loggers: | ||
return | ||||
|
r43346 | activeloggers = [ | ||
|
r43374 | l for l in pycompat.itervalues(self._loggers) if l.tracked(event) | ||
|
r43346 | ] | ||
|
r40761 | if not activeloggers: | ||
return | ||||
|
r40793 | msg = msgfmt % msgargs | ||
|
r40794 | opts = pycompat.byteskwargs(opts) | ||
|
r40792 | # 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 | ||||
|
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. | ||||
""" | ||||
|
r43347 | if not self.configbool(b'devel', b'all-warnings'): | ||
if config is None or not self.configbool(b'devel', config): | ||||
|
r29095 | return | ||
|
r43347 | msg = b'devel-warn: ' + msg | ||
|
r43346 | stacklevel += 1 # get in develwarn | ||
|
r25629 | if self.tracebackflag: | ||
|
r40579 | util.debugstacktrace(msg, stacklevel, self._ferr, self._fout) | ||
|
r43346 | self.log( | ||
|
r43347 | b'develwarn', | ||
b'%s at:\n%s' | ||||
% (msg, b''.join(util.getstackframes(stacklevel))), | ||||
|
r43346 | ) | ||
|
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) | ||||
|
r43347 | self.write_err(b'%s at: %s:%d (%s)\n' % (msg, fname, lineno, fmsg)) | ||
|
r43346 | self.log( | ||
|
r43347 | b'develwarn', b'%s at: %s:%d (%s)\n', msg, fname, lineno, fmsg | ||
|
r43346 | ) | ||
|
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, | ||||
""" | ||||
|
r43346 | if not ( | ||
|
r43347 | self.configbool(b'devel', b'all-warnings') | ||
or self.configbool(b'devel', b'deprec-warn') | ||||
|
r43346 | ): | ||
|
r29082 | return | ||
|
r43346 | msg += ( | ||
|
r43347 | b"\n(compatibility will be dropped after Mercurial-%s," | ||
b" update your code.)" | ||||
|
r43346 | ) % version | ||
|
r43347 | self.develwarn(msg, stacklevel=stacklevel, config=b'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 | ||
|
r43347 | def configoverride(self, overrides, source=b""): | ||
|
r30480 | """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 | ||||
|
r43347 | if (b'ui', b'quiet') in overrides: | ||
self.fixconfig(section=b'ui') | ||||
|
r30480 | |||
|
r43346 | |||
|
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. | ||||
""" | ||||
|
r43346 | |||
|
r24250 | def __init__(self, ui): | ||
dict.__init__(self) | ||||
|
r43347 | for name, loc in ui.configitems(b'paths', ignoresub=True): | ||
|
r24250 | # No location is the same as not existing. | ||
if not loc: | ||||
continue | ||||
|
r43347 | loc, sub = ui.configsuboptions(b'paths', name) | ||
|
r27266 | 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: | ||
|
r43347 | raise error.RepoError(_(b'repository %s does not exist') % name) | ||
|
r43346 | |||
|
r26056 | |||
|
r27266 | _pathsuboptions = {} | ||
|
r43346 | |||
|
r27266 | 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. | ||||
""" | ||||
|
r43346 | |||
|
r27266 | def register(func): | ||
_pathsuboptions[option] = (attr, func) | ||||
return func | ||||
|
r43346 | |||
|
r27266 | return register | ||
|
r43346 | |||
|
r43347 | @pathsuboption(b'pushurl', b'pushloc') | ||
|
r27266 | def pushurlpathoption(ui, path, value): | ||
u = util.url(value) | ||||
# Actually require a URL. | ||||
if not u.scheme: | ||||
|
r43347 | ui.warn(_(b'(paths.%s:pushurl not a URL; ignoring)\n') % path.name) | ||
|
r27266 | return None | ||
# Don't support the #foo syntax in the push URL to declare branch to | ||||
# push. | ||||
if u.fragment: | ||||
|
r43346 | ui.warn( | ||
|
r43347 | _( | ||
b'("#fragment" in paths.%s:pushurl not supported; ' | ||||
b'ignoring)\n' | ||||
) | ||||
|
r43346 | % path.name | ||
) | ||||
|
r27266 | u.fragment = None | ||
|
r36749 | return bytes(u) | ||
|
r27266 | |||
|
r43346 | |||
|
r43347 | @pathsuboption(b'pushrev', b'pushrev') | ||
|
r29413 | def pushrevpathoption(ui, path, value): | ||
return value | ||||
|
r43346 | |||
|
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: | ||
|
r43347 | raise ValueError(b'rawloc must be defined') | ||
|
r26056 | |||
# 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 | ||
|
r43347 | self.loc = b'%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): | ||
|
r43346 | raise ValueError( | ||
|
r43347 | b'location is not a URL or path to a local ' | ||
b'repo: %s' % rawloc | ||||
|
r43346 | ) | ||
|
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. | ||||
|
r43376 | for suboption, (attr, func) in pycompat.iteritems(_pathsuboptions): | ||
|
r27266 | 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).""" | ||||
|
r41625 | try: | ||
|
r43347 | return os.path.isdir(os.path.join(path, b'.hg')) | ||
|
r41625 | # Python 2 may return TypeError. Python 3, ValueError. | ||
except (TypeError, ValueError): | ||||
return False | ||||
|
r26076 | |||
|
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 = {} | ||||
|
r43376 | for subopt, (attr, _func) in pycompat.iteritems(_pathsuboptions): | ||
|
r27266 | value = getattr(self, attr) | ||
if value is not None: | ||||
d[subopt] = value | ||||
return d | ||||
|
r26064 | |||
|
r43346 | |||
|
r25498 | # we instantiate one globally shared progress bar to avoid | ||
# competing progress bars when multiple UI objects get created | ||||
_progresssingleton = None | ||||
|
r43346 | |||
|
r25498 | 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 | |||
|
r43346 | |||
|
r34346 | def haveprogbar(): | ||
return _progresssingleton is not None | ||||
|
r40580 | |||
|
r43346 | |||
|
r40580 | def _selectmsgdests(ui): | ||
name = ui.config(b'ui', b'message-output') | ||||
|
r40625 | 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 | ||||
|
r40580 | 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) | ||||
|
r40626 | |||
|
r43346 | |||
|
r40626 | def _writemsgwith(write, dest, *args, **opts): | ||
"""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 | ||||
|
r43906 | if 'type' in opts and not getattr(dest, 'structured', False): | ||
opts['label'] = opts.get('label', b'') + b' ui.%s' % opts.pop('type') | ||||
|
r40626 | write(dest, *args, **opts) | ||