ui.py
1131 lines
| 39.5 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 | ||
import errno | ||||
import getpass | ||||
|
r25629 | import inspect | ||
|
r25989 | import os | ||
import socket | ||||
import sys | ||||
import tempfile | ||||
import traceback | ||||
from .i18n import _ | ||||
from .node import hex | ||||
from . import ( | ||||
config, | ||||
error, | ||||
formatter, | ||||
progress, | ||||
scmutil, | ||||
util, | ||||
) | ||||
|
r207 | |||
|
r22419 | samplehgrcs = { | ||
'user': | ||||
"""# example user config (see "hg help config" for more info) | ||||
[ui] | ||||
# name and email, e.g. | ||||
# username = Jane Doe <jdoe@example.com> | ||||
username = | ||||
[extensions] | ||||
# uncomment these lines to enable some popular extensions | ||||
# (see "hg help extensions" for more info) | ||||
# | ||||
# pager = | ||||
# progress = | ||||
# color =""", | ||||
|
r22837 | 'cloned': | ||
"""# example repository config (see "hg help config" for more info) | ||||
[paths] | ||||
default = %s | ||||
# path aliases to other clones of this repo in URLs or filesystem paths | ||||
# (see "hg help config.paths" for more info) | ||||
# | ||||
# default-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': | ||
"""# 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 | ||||
# (see "hg help config.paths" for more info) | ||||
# | ||||
# 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': | ||||
"""# example system-wide hg config (see "hg help config" for more info) | ||||
[extensions] | ||||
# uncomment these lines to enable some popular extensions | ||||
# (see "hg help extensions" for more info) | ||||
# | ||||
# blackbox = | ||||
# progress = | ||||
# color = | ||||
# pager =""", | ||||
} | ||||
|
r1559 | class ui(object): | ||
|
r8190 | def __init__(self, src=None): | ||
|
r21132 | # _buffers: used for temporary capture of output | ||
|
r8202 | self._buffers = [] | ||
|
r24848 | # _bufferstates: | ||
# should the temporary capture include stderr and subprocess output | ||||
|
r21132 | self._bufferstates = [] | ||
|
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 | ||
|
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 | ||
|
r8143 | self.fixconfig() | ||
else: | ||||
|
r14612 | self.fout = sys.stdout | ||
self.ferr = sys.stderr | ||||
self.fin = sys.stdin | ||||
|
r9887 | # shared read-only environment | ||
self.environ = os.environ | ||||
|
r3676 | # we always trust global config files | ||
|
r13984 | for f in scmutil.rcpath(): | ||
|
r8200 | self.readconfig(f, trust=True) | ||
|
r8222 | |||
|
r8189 | def copy(self): | ||
|
r8220 | return self.__class__(self) | ||
|
r1839 | |||
|
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: | ||
fp = open(filename) | ||||
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] | ||||
|
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 | ||||
root = root or os.getcwd() | ||||
for c in self._tcfg, self._ucfg, self._ocfg: | ||||
for n, p in c.items('paths'): | ||||
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 | |||
|
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 [] | ||
if isinstance(result, basestring): | ||||
|
r11309 | result = _configlist(result.lstrip(' ,\n')) | ||
|
r10982 | if result is None: | ||
result = default or [] | ||||
|
r2502 | return result | ||
|
r2499 | |||
|
r4487 | def has_section(self, section, untrusted=False): | ||
|
r2343 | '''tell whether section exists in config.''' | ||
|
r8199 | return section in self._data(untrusted) | ||
|
r3552 | |||
def configitems(self, section, untrusted=False): | ||||
|
r8199 | items = self._data(untrusted).items(section) | ||
|
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 | ''' | ||
|
r13849 | if 'HGPLAIN' not in os.environ and 'HGPLAINEXCEPT' not in os.environ: | ||
return False | ||||
exceptions = os.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 | """ | ||
user = os.environ.get("HGUSER") | ||||
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: | ||
user = os.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'), | ||
|
r20574 | 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 | |||
|
r24848 | def pushbuffer(self, error=False, subproc=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 | ||||
captured too.""" | ||||
|
r8202 | self._buffers.append([]) | ||
|
r24848 | self._bufferstates.append((error, subproc)) | ||
|
r3737 | |||
|
r10815 | def popbuffer(self, labeled=False): | ||
'''pop the last buffer and return the buffered output | ||||
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. | ||||
''' | ||||
|
r21132 | self._bufferstates.pop() | ||
|
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. | ||||
''' | ||||
|
r25499 | self._progclear() | ||
|
r8202 | if self._buffers: | ||
self._buffers[-1].extend([str(a) for a in args]) | ||||
|
r3737 | else: | ||
for a in args: | ||||
|
r14614 | self.fout.write(str(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: | ||
|
r14614 | self.ferr.write(str(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 | |||
|
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? | ||||
''' | ||||
if 'COLUMNS' in os.environ: | ||||
try: | ||||
return int(os.environ['COLUMNS']) | ||||
except ValueError: | ||||
pass | ||||
return util.termwidth() | ||||
|
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 | ||||
self.write(prompt) | ||||
|
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(): | ||
|
r8940 | self.write(msg, ' ', default, "\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 &)". | ||||
""" | ||||
parts = prompt.split('$$') | ||||
msg = parts[0].rstrip(' ') | ||||
choices = [p.strip(' ') for p in parts[1:]] | ||||
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): | ||||
|
r26312 | if extra is None: | ||
extra = {} | ||||
|
r2206 | (fd, name) = tempfile.mkstemp(prefix="hg-editor-", suffix=".txt", | ||
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' | ||||
|
r5660 | return (os.environ.get("HGEDITOR") or | ||
self.config("ui", "editor") or | ||||
os.environ.get("VISUAL") or | ||||
|
r16383 | os.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 | ||||
With stock hg, this is simply a debug message that is hidden | ||||
by default, but with extensions or GUI tools it may be | ||||
visible. '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 | |||
|
r25629 | def develwarn(self, msg): | ||
"""issue a developer warning message""" | ||||
msg = 'devel-warn: ' + msg | ||||
if self.tracebackflag: | ||||
|
r26451 | util.debugstacktrace(msg, 2, self.ferr, self.fout) | ||
|
r25629 | else: | ||
curframe = inspect.currentframe() | ||||
calframe = inspect.getouterframes(curframe, 2) | ||||
self.write_err('%s at: %s:%s (%s)\n' % ((msg,) + calframe[2][1:4])) | ||||
|
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) | ||||
for name, loc in ui.configitems('paths'): | ||||
# No location is the same as not existing. | ||||
if not loc: | ||||
continue | ||||
|
r26064 | |||
# TODO ignore default-push once all consumers stop referencing it | ||||
# since it is handled specifically below. | ||||
|
r24250 | self[name] = path(name, rawloc=loc) | ||
|
r26064 | # Handle default-push, which is a one-off that defines the push URL for | ||
# the "default" path. | ||||
defaultpush = ui.config('paths', 'default-push') | ||||
|
r26820 | if defaultpush: | ||
# "default-push" can be defined without "default" entry. This is a | ||||
# bit weird, but is allowed for backwards compatibility. | ||||
if 'default' not in self: | ||||
self['default'] = path('default', rawloc=defaultpush) | ||||
|
r26064 | self['default']._pushloc = defaultpush | ||
|
r24250 | def getpath(self, name, default=None): | ||
|
r26056 | """Return a ``path`` from a string, falling back to a default. | ||
``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: | ||||
if default: | ||||
try: | ||||
return self[default] | ||||
except KeyError: | ||||
return None | ||||
else: | ||||
return None | ||||
# 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: | ||||
return path(None, rawloc=name) | ||||
except ValueError: | ||||
|
r26189 | raise error.RepoError(_('repository %s does not exist') % | ||
name) | ||||
|
r26056 | |||
|
r26189 | assert False | ||
|
r24250 | |||
class path(object): | ||||
"""Represents an individual path and its configuration.""" | ||||
|
r26064 | def __init__(self, name, rawloc=None, pushloc=None): | ||
|
r24250 | """Construct a path from its config options. | ||
``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) | ||||
|
r26064 | self._pushloc = pushloc | ||
|
r26056 | |||
# When given a raw location but not a symbolic name, validate the | ||||
# location is valid. | ||||
|
r26076 | if not name and not u.scheme and not self._isvalidlocalpath(self.loc): | ||
|
r26056 | raise ValueError('location is not a URL or path to a local ' | ||
'repo: %s' % rawloc) | ||||
|
r25498 | |||
|
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 | ||
def pushloc(self): | ||||
return self._pushloc or self.loc | ||||
|
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 | ||||