ui.py
1406 lines
| 50.1 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 | ||
|
r30480 | import contextlib | ||
|
r25989 | import errno | ||
import getpass | ||||
|
r25629 | import inspect | ||
|
r25989 | import os | ||
|
r27392 | import re | ||
|
r25989 | import socket | ||
import sys | ||||
import tempfile | ||||
import traceback | ||||
from .i18n import _ | ||||
from .node import hex | ||||
from . import ( | ||||
config, | ||||
|
r30277 | encoding, | ||
|
r25989 | error, | ||
formatter, | ||||
progress, | ||||
|
r30519 | pycompat, | ||
|
r25989 | scmutil, | ||
util, | ||||
) | ||||
|
r207 | |||
|
r29378 | urlreq = util.urlreq | ||
|
r22419 | samplehgrcs = { | ||
'user': | ||||
|
r29978 | """# example user config (see 'hg help config' for more info) | ||
|
r22419 | [ui] | ||
# name and email, e.g. | ||||
# username = Jane Doe <jdoe@example.com> | ||||
username = | ||||
[extensions] | ||||
# uncomment these lines to enable some popular extensions | ||||
|
r29978 | # (see 'hg help extensions' for more info) | ||
|
r22419 | # | ||
# pager = | ||||
# color =""", | ||||
|
r22837 | 'cloned': | ||
|
r29978 | """# 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 | # | ||
# default-push = ssh://jdoe@example.net/hg/jdoes-fork | ||||
# my-fork = ssh://jdoe@example.net/hg/jdoes-fork | ||||
# my-clone = /home/jdoe/jdoes-clone | ||||
[ui] | ||||
# name and email (local to this repository, optional), e.g. | ||||
# username = Jane Doe <jdoe@example.com> | ||||
""", | ||||
|
r22419 | 'local': | ||
|
r29978 | """# 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 | # | ||
# default = http://example.com/hg/example-repo | ||||
# default-push = ssh://jdoe@example.net/hg/jdoes-fork | ||||
# my-fork = ssh://jdoe@example.net/hg/jdoes-fork | ||||
# my-clone = /home/jdoe/jdoes-clone | ||||
[ui] | ||||
# name and email (local to this repository, optional), e.g. | ||||
# username = Jane Doe <jdoe@example.com> | ||||
|
r22419 | """, | ||
'global': | ||||
|
r29978 | """# example system-wide hg config (see 'hg help config' for more info) | ||
|
r22419 | |||
[extensions] | ||||
# uncomment these lines to enable some popular extensions | ||||
|
r29978 | # (see 'hg help extensions' for more info) | ||
|
r22419 | # | ||
# blackbox = | ||||
# color = | ||||
# pager =""", | ||||
} | ||||
|
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 | ||
|
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 | ||||
|
r8136 | |||
|
r8190 | if src: | ||
|
r14612 | self.fout = src.fout | ||
self.ferr = src.ferr | ||||
self.fin = src.fin | ||||
|
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 | ||
|
r8143 | self.fixconfig() | ||
|
r29378 | |||
self.httppasswordmgrdb = src.httppasswordmgrdb | ||||
|
r8143 | else: | ||
|
r30473 | self.fout = util.stdout | ||
self.ferr = util.stderr | ||||
self.fin = util.stdin | ||||
|
r14612 | |||
|
r9887 | # shared read-only environment | ||
self.environ = os.environ | ||||
|
r8222 | |||
|
r29378 | self.httppasswordmgrdb = urlreq.httppasswordmgrwithdefaultrealm() | ||
|
r30559 | @classmethod | ||
def load(cls): | ||||
"""Create a ui and load global and user configs""" | ||||
u = cls() | ||||
# we always trust global config files | ||||
for f in scmutil.rcpath(): | ||||
u.readconfig(f, trust=True) | ||||
return u | ||||
|
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 | ||||
|
r29378 | self.httppasswordmgrdb = urlreq.httppasswordmgrwithdefaultrealm() | ||
|
r29366 | |||
|
r16135 | def formatter(self, topic, opts): | ||
return formatter.formatter(self, topic, opts) | ||||
|
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] | ||||
# 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: | ||||
self.warn(_("(deprecated '%%' in path %s=%s from %s)\n") | ||||
% (n, p, self.configsource('paths', n))) | ||||
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", | ||
"report_untrusted", True) | ||||
|
r12764 | self.tracebackflag = self.configbool('ui', 'traceback', False) | ||
|
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) | ||
|
r960 | |||
|
r8199 | def _data(self, untrusted): | ||
|
r8203 | return untrusted and self._ucfg or self._tcfg | ||
|
r3552 | |||
|
r8182 | def configsource(self, section, name, untrusted=False): | ||
|
r8199 | return self._data(untrusted).source(section, name) or 'none' | ||
|
r8182 | |||
|
r8144 | def config(self, section, name, default=None, untrusted=False): | ||
|
r15035 | if isinstance(name, list): | ||
alternates = name | ||||
else: | ||||
alternates = [name] | ||||
for n in alternates: | ||||
|
r19536 | value = self._data(untrusted).get(section, n, None) | ||
|
r15035 | if value is not None: | ||
name = n | ||||
break | ||||
else: | ||||
value = default | ||||
|
r8204 | if self.debugflag and not untrusted and self._reportuntrusted: | ||
|
r19536 | for n in alternates: | ||
uvalue = self._ucfg.get(section, n) | ||||
if uvalue is not None and uvalue != value: | ||||
self.debug("ignoring untrusted configuration option " | ||||
"%s.%s = %s\n" % (section, n, uvalue)) | ||||
|
r3552 | return value | ||
|
r3341 | |||
|
r27252 | def configsuboptions(self, section, name, default=None, untrusted=False): | ||
"""Get a config option and all sub-options. | ||||
Some config options have sub-options that are declared with the | ||||
format "key:opt = value". This method is used to return the main | ||||
option and all its declared sub-options. | ||||
Returns a 2-tuple of ``(option, sub-options)``, where `sub-options`` | ||||
is a dict of defined sub-options where keys and values are strings. | ||||
""" | ||||
data = self._data(untrusted) | ||||
main = data.get(section, name, default) | ||||
if self.debugflag and not untrusted and self._reportuntrusted: | ||||
uvalue = self._ucfg.get(section, name) | ||||
if uvalue is not None and uvalue != main: | ||||
self.debug('ignoring untrusted configuration option ' | ||||
'%s.%s = %s\n' % (section, name, uvalue)) | ||||
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 | ||||
|
r13238 | def configpath(self, section, name, default=None, 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 | ||||
|
r3552 | def configbool(self, section, name, default=False, untrusted=False): | ||
|
r14171 | """parse a configuration element as a boolean | ||
>>> u = ui(); s = 'foo' | ||||
>>> u.setconfig(s, 'true', 'yes') | ||||
>>> u.configbool(s, 'true') | ||||
True | ||||
>>> u.setconfig(s, 'false', 'no') | ||||
>>> u.configbool(s, 'false') | ||||
False | ||||
>>> u.configbool(s, 'unknown') | ||||
False | ||||
>>> u.configbool(s, 'unknown', True) | ||||
True | ||||
>>> u.setconfig(s, 'invalid', 'somevalue') | ||||
>>> u.configbool(s, 'invalid') | ||||
Traceback (most recent call last): | ||||
... | ||||
ConfigError: foo.invalid is not a boolean ('somevalue') | ||||
""" | ||||
|
r8144 | v = self.config(section, name, None, untrusted) | ||
|
r8527 | if v is None: | ||
|
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 | |||
|
r14171 | def configint(self, section, name, default=None, untrusted=False): | ||
"""parse a configuration element as an integer | ||||
>>> u = ui(); s = 'foo' | ||||
>>> u.setconfig(s, 'int1', '42') | ||||
>>> u.configint(s, 'int1') | ||||
42 | ||||
>>> u.setconfig(s, 'int2', '-42') | ||||
>>> u.configint(s, 'int2') | ||||
-42 | ||||
>>> u.configint(s, 'unknown', 7) | ||||
7 | ||||
>>> u.setconfig(s, 'invalid', 'somevalue') | ||||
>>> u.configint(s, 'invalid') | ||||
Traceback (most recent call last): | ||||
... | ||||
ConfigError: foo.invalid is not an integer ('somevalue') | ||||
""" | ||||
v = self.config(section, name, None, untrusted) | ||||
if v is None: | ||||
return default | ||||
try: | ||||
return int(v) | ||||
except ValueError: | ||||
raise error.ConfigError(_("%s.%s is not an integer ('%s')") | ||||
% (section, name, v)) | ||||
|
r19065 | def configbytes(self, section, name, default=0, untrusted=False): | ||
"""parse a configuration element as a quantity in bytes | ||||
Units can be specified as b (bytes), k or kb (kilobytes), m or | ||||
mb (megabytes), g or gb (gigabytes). | ||||
>>> u = ui(); s = 'foo' | ||||
>>> u.setconfig(s, 'val1', '42') | ||||
>>> u.configbytes(s, 'val1') | ||||
42 | ||||
>>> u.setconfig(s, 'val2', '42.5 kb') | ||||
>>> u.configbytes(s, 'val2') | ||||
43520 | ||||
>>> u.configbytes(s, 'unknown', '7 MB') | ||||
7340032 | ||||
>>> u.setconfig(s, 'invalid', 'somevalue') | ||||
>>> u.configbytes(s, 'invalid') | ||||
Traceback (most recent call last): | ||||
... | ||||
ConfigError: foo.invalid is not a byte quantity ('somevalue') | ||||
""" | ||||
|
r19195 | value = self.config(section, name) | ||
if value is None: | ||||
|
r19065 | if not isinstance(default, str): | ||
return default | ||||
|
r19195 | value = default | ||
|
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 | |||
|
r3552 | def configlist(self, section, name, default=None, untrusted=False): | ||
|
r14171 | """parse a configuration element as a list of comma/space separated | ||
strings | ||||
>>> u = ui(); s = 'foo' | ||||
>>> u.setconfig(s, 'list1', 'this,is "a small" ,test') | ||||
>>> u.configlist(s, 'list1') | ||||
['this', 'is', 'a small', 'test'] | ||||
""" | ||||
|
r10982 | |||
def _parse_plain(parts, s, offset): | ||||
whitespace = False | ||||
while offset < len(s) and (s[offset].isspace() or s[offset] == ','): | ||||
whitespace = True | ||||
offset += 1 | ||||
if offset >= len(s): | ||||
return None, parts, offset | ||||
if whitespace: | ||||
parts.append('') | ||||
if s[offset] == '"' and not parts[-1]: | ||||
return _parse_quote, parts, offset + 1 | ||||
elif s[offset] == '"' and parts[-1][-1] == '\\': | ||||
parts[-1] = parts[-1][:-1] + s[offset] | ||||
return _parse_plain, parts, offset + 1 | ||||
parts[-1] += s[offset] | ||||
return _parse_plain, parts, offset + 1 | ||||
def _parse_quote(parts, s, offset): | ||||
if offset < len(s) and s[offset] == '"': # "" | ||||
parts.append('') | ||||
offset += 1 | ||||
while offset < len(s) and (s[offset].isspace() or | ||||
s[offset] == ','): | ||||
offset += 1 | ||||
return _parse_plain, parts, offset | ||||
while offset < len(s) and s[offset] != '"': | ||||
|
r11036 | if (s[offset] == '\\' and offset + 1 < len(s) | ||
and s[offset + 1] == '"'): | ||||
|
r10982 | offset += 1 | ||
parts[-1] += '"' | ||||
else: | ||||
parts[-1] += s[offset] | ||||
offset += 1 | ||||
if offset >= len(s): | ||||
real_parts = _configlist(parts[-1]) | ||||
if not real_parts: | ||||
parts[-1] = '"' | ||||
else: | ||||
real_parts[0] = '"' + real_parts[0] | ||||
parts = parts[:-1] | ||||
parts.extend(real_parts) | ||||
return None, parts, offset | ||||
offset += 1 | ||||
while offset < len(s) and s[offset] in [' ', ',']: | ||||
offset += 1 | ||||
if offset < len(s): | ||||
if offset + 1 == len(s) and s[offset] == '"': | ||||
parts[-1] += '"' | ||||
offset += 1 | ||||
else: | ||||
parts.append('') | ||||
else: | ||||
return None, parts, offset | ||||
return _parse_plain, parts, offset | ||||
def _configlist(s): | ||||
s = s.rstrip(' ,') | ||||
if not s: | ||||
|
r11945 | return [] | ||
|
r10982 | parser, parts, offset = _parse_plain, [''], 0 | ||
while parser: | ||||
parser, parts, offset = parser(parts, s, offset) | ||||
return parts | ||||
|
r3552 | result = self.config(section, name, untrusted=untrusted) | ||
|
r2499 | if result is None: | ||
|
r2502 | result = default or [] | ||
|
r30569 | if isinstance(result, bytes): | ||
|
r11309 | result = _configlist(result.lstrip(' ,\n')) | ||
|
r10982 | if result is None: | ||
result = default or [] | ||||
|
r2502 | return result | ||
|
r2499 | |||
|
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 | ||||
- 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(',') | ||||
|
r14372 | if feature and exceptions: | ||
return feature not in exceptions | ||||
return True | ||||
|
r10455 | |||
|
r608 | def username(self): | ||
|
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. | ||||
|
r6862 | If not found and ui.askusername is True, ask the user, else use | ||
($LOGNAME or $USER or $LNAME or $USERNAME) + "@full.hostname". | ||||
|
r1985 | """ | ||
|
r30277 | user = encoding.environ.get("HGUSER") | ||
|
r1985 | if user is None: | ||
|
r21955 | user = self.config("ui", ["username", "user"]) | ||
|
r11225 | if user is not None: | ||
user = os.path.expandvars(user) | ||||
|
r1985 | if user is None: | ||
|
r30277 | user = encoding.environ.get("EMAIL") | ||
|
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: | ||
|
r26587 | raise error.Abort(_("username %s contains a newline\n") | ||
% repr(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 | |||
|
r10815 | def write(self, *args, **opts): | ||
'''write args to output | ||||
By default, this method simply writes to the buffer or stdout, | ||||
but extensions or GUI tools may override this method, | ||||
write_err(), popbuffer(), and label() to style output from | ||||
various parts of hg. | ||||
An optional keyword argument, "label", can be passed in. | ||||
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". | ||||
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. | ||||
''' | ||||
|
r28633 | if self._buffers and not opts.get('prompt', False): | ||
|
r27110 | self._buffers[-1].extend(a for a in args) | ||
|
r3737 | else: | ||
|
r27068 | self._progclear() | ||
|
r3737 | for a in args: | ||
|
r27110 | self.fout.write(a) | ||
|
r565 | |||
|
r10815 | def write_err(self, *args, **opts): | ||
|
r25499 | self._progclear() | ||
|
r1989 | try: | ||
|
r24848 | if self._bufferstates and self._bufferstates[-1][0]: | ||
|
r21132 | return self.write(*args, **opts) | ||
|
r14614 | if not getattr(self.fout, 'closed', False): | ||
self.fout.flush() | ||||
|
r1989 | for a in args: | ||
|
r27110 | self.ferr.write(a) | ||
|
r4023 | # stderr may be buffered under win32 when redirected to files, | ||
# including stdout. | ||||
|
r14614 | if not getattr(self.ferr, 'closed', False): | ||
self.ferr.flush() | ||||
|
r25660 | except IOError as inst: | ||
|
r16367 | if inst.errno not in (errno.EPIPE, errno.EIO, errno.EBADF): | ||
|
r1989 | raise | ||
|
r565 | |||
|
r1837 | def flush(self): | ||
|
r14614 | try: self.fout.flush() | ||
|
r16703 | except (IOError, ValueError): pass | ||
|
r14614 | try: self.ferr.flush() | ||
|
r16703 | except (IOError, ValueError): pass | ||
|
r1837 | |||
|
r16751 | def _isatty(self, fh): | ||
if self.configbool('ui', 'nontty', False): | ||||
return False | ||||
return util.isatty(fh) | ||||
|
r1837 | |||
|
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" | ||||
i = self.config("ui", "interface", None) | ||||
if i in alldefaults: | ||||
defaultinterface = i | ||||
choseninterface = defaultinterface | ||||
f = self.config("ui", "interface.%s" % feature, None) | ||||
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()'. | ||||
''' | ||||
|
r8538 | i = self.configbool("ui", "interactive", None) | ||
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 | ||||
i = self.configbool("ui", "formatted", None) | ||||
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 | ||||
|
r5337 | def _readline(self, prompt=''): | ||
|
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 | |||
|
r15000 | # call write() so output goes through subclassed implementation | ||
# e.g. color extension on Windows | ||||
|
r28633 | self.write(prompt, prompt=True) | ||
|
r15000 | |||
|
r15062 | # instead of trying to emulate raw_input, swap (self.fin, | ||
# self.fout) with (sys.stdin, sys.stdout) | ||||
oldin = sys.stdin | ||||
oldout = sys.stdout | ||||
|
r15000 | sys.stdin = self.fin | ||
|
r15062 | sys.stdout = self.fout | ||
|
r22291 | # prompt ' ' must exist; otherwise readline may delete entire line | ||
# - http://bugs.python.org/issue12833 | ||||
|
r15053 | line = raw_input(' ') | ||
|
r15062 | sys.stdin = oldin | ||
sys.stdout = oldout | ||||
|
r14614 | |||
|
r5613 | # When stdin is in binary mode on Windows, it can cause | ||
# raw_input() to emit an extra trailing carriage return | ||||
if os.linesep == '\r\n' and line and line[-1] == '\r': | ||||
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 | ||
|
r9048 | try: | ||
|
r15053 | r = self._readline(self.label(msg, 'ui.prompt')) | ||
|
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 | |||
>>> ui.extractchoices("awake? $$ &Yes $$ &No") | ||||
('awake? ', [('y', 'Yes'), ('n', 'No')]) | ||||
>>> ui.extractchoices("line\\nbreak? $$ &Yes $$ &No") | ||||
('line\\nbreak? ', [('y', 'Yes'), ('n', 'No')]) | ||||
>>> ui.extractchoices("want lots of $$money$$?$$Ye&s$$N&o") | ||||
('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. | ||||
m = re.match(r'(?s)(.+?)\$\$([^\$]*&[^ \$].*)', prompt) | ||||
msg = m.group(1) | ||||
choices = [p.strip(' ') for p in m.group(2).split('$$')] | ||||
|
r20265 | return (msg, | ||
[(s[s.index('&') + 1].lower(), s.replace('&', '', 1)) | ||||
for s in choices]) | ||||
|
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. | ||||
if self.configbool('ui', 'nontty'): | ||||
return self.fin.readline().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: | ||
|
r10815 | opts['label'] = opts.get('label', '') + ' ui.status' | ||
self.write(*msg, **opts) | ||||
def warn(self, *msg, **opts): | ||||
'''write warning message to output (stderr) | ||||
This adds an output label of "ui.warning". | ||||
''' | ||||
opts['label'] = opts.get('label', '') + ' ui.warning' | ||||
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: | ||
|
r10815 | opts['label'] = opts.get('label', '') + ' ui.note' | ||
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: | ||
|
r10815 | opts['label'] = opts.get('label', '') + ' ui.debug' | ||
self.write(*msg, **opts) | ||||
|
r26750 | |||
def edit(self, text, user, extra=None, editform=None, pending=None): | ||||
|
r28635 | extra_defaults = { | ||
'prefix': 'editor', | ||||
'suffix': '.txt', | ||||
} | ||||
|
r27153 | if extra is not None: | ||
extra_defaults.update(extra) | ||||
extra = extra_defaults | ||||
(fd, name) = tempfile.mkstemp(prefix='hg-' + extra['prefix'] + '-', | ||||
|
r28635 | suffix=extra['suffix'], text=True) | ||
|
r1984 | try: | ||
f = os.fdopen(fd, "w") | ||||
f.write(text) | ||||
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, | ||
|
r26587 | onerr=error.Abort, errprefix=_("edit failed")) | ||
|
r608 | |||
|
r1984 | f = open(name) | ||
t = f.read() | ||||
f.close() | ||||
finally: | ||||
os.unlink(name) | ||||
|
r662 | |||
|
r207 | return t | ||
|
r2200 | |||
|
r26312 | def system(self, cmd, environ=None, cwd=None, onerr=None, errprefix=None): | ||
|
r23269 | '''execute shell command with appropriate output stream. command | ||
output will be redirected if fout is not stdout. | ||||
''' | ||||
|
r24848 | out = self.fout | ||
|
r25149 | if any(s[1] for s in self._bufferstates): | ||
|
r24848 | out = self | ||
|
r23269 | return util.system(cmd, environ=environ, cwd=cwd, onerr=onerr, | ||
|
r24848 | errprefix=errprefix, 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]) | ||
self.write_err(''.join(output)) | ||||
|
r18966 | return self.tracebackflag or force | ||
|
r5660 | |||
def geteditor(self): | ||||
'''return editor to use''' | ||||
|
r16383 | if sys.platform == 'plan9': | ||
# 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 | ||
|
r5660 | self.config("ui", "editor") or | ||
|
r30277 | encoding.environ.get("VISUAL") or | ||
encoding.environ.get("EDITOR", editor)) | ||||
|
r9153 | |||
|
r25499 | @util.propertycache | ||
def _progbar(self): | ||||
"""setup the progbar singleton to the ui object""" | ||||
if (self.quiet or self.debugflag | ||||
|
r25519 | or self.configbool('progress', 'disable', False) | ||
|
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""" | ||||
|
r26781 | if '_progbar' not in vars(self): # 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 | ||||
|
r10220 | self.debug('%s:%s %s/%s%s (%4.2f%%)\n' | ||
|
r9398 | % (topic, item, pos, total, unit, pct)) | ||
|
r9153 | else: | ||
|
r9749 | self.debug('%s:%s %s%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 | ||||
Like ui.write(), this just returns msg unchanged, but extensions | ||||
and GUI tools can override it to allow styling output without | ||||
writing it. | ||||
ui.write(s, 'label') is equivalent to | ||||
ui.write(ui.label(s, 'label')). | ||||
''' | ||||
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'): | ||
if config is not None and not self.configbool('devel', config): | ||||
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) | ||||
|
r27274 | self.write_err('%s at: %s:%s (%s)\n' | ||
% ((msg,) + calframe[stacklevel][1:4])) | ||||
|
r28498 | self.log('develwarn', '%s at: %s:%s (%s)\n', | ||
msg, *calframe[stacklevel][1:4]) | ||||
|
r29762 | curframe = calframe = None # avoid cycles | ||
|
r25629 | |||
|
r27275 | def deprecwarn(self, msg, version): | ||
"""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 | ||||
|
r29096 | self.develwarn(msg, stacklevel=2, config='deprec-warn') | ||
|
r25629 | |||
|
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 | ||
self.loc = str(u) | ||||
# 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 | ||||