ui.py
759 lines
| 27.2 KiB
| text/x-python
|
PythonLexer
/ mercurial / ui.py
|
r207 | # ui.py - user interface bits for mercurial | ||
# | ||||
|
r4635 | # Copyright 2005-2007 Matt Mackall <mpm@selenic.com> | ||
|
r207 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r207 | |||
|
r3891 | from i18n import _ | ||
|
r8656 | import errno, getpass, os, socket, sys, tempfile, traceback | ||
|
r16135 | import config, scmutil, util, error, formatter | ||
|
r207 | |||
|
r1559 | class ui(object): | ||
|
r8190 | def __init__(self, src=None): | ||
|
r8202 | self._buffers = [] | ||
|
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() | ||||
|
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 | ||
|
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: | ||
|
r8141 | self.warn(_('Not trusting file %s from untrusted ' | ||
'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() | ||
|
r8144 | except error.ConfigError, inst: | ||
|
r8142 | if trusted: | ||
|
r8144 | raise | ||
self.warn(_("Ignored: %s\n") % str(inst)) | ||||
|
r3552 | |||
|
r10455 | if self.plain(): | ||
|
r10507 | for k in ('debug', 'fallbackencoding', 'quiet', 'slash', | ||
|
r10567 | 'logtemplate', '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] | ||||
|
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]) | ||||
|
r11965 | def setconfig(self, section, name, value, overlay=True): | ||
if overlay: | ||||
self._ocfg.set(section, name, value) | ||||
self._tcfg.set(section, name, value) | ||||
self._ucfg.set(section, name, value) | ||||
|
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: | ||||
value = self._data(untrusted).get(section, name, None) | ||||
if value is not None: | ||||
name = n | ||||
break | ||||
else: | ||||
value = default | ||||
|
r8204 | if self.debugflag and not untrusted and self._reportuntrusted: | ||
|
r8203 | uvalue = self._ucfg.get(section, name) | ||
|
r3552 | if uvalue is not None and uvalue != value: | ||
|
r14708 | self.debug("ignoring untrusted configuration option " | ||
"%s.%s = %s\n" % (section, name, 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)) | ||||
|
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: | ||||
user = self.config("ui", "username") | ||||
|
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()) | ||||
|
r4044 | self.warn(_("No username found, using '%s' instead\n") % user) | ||
|
r3721 | except KeyError: | ||
|
r4044 | pass | ||
if not user: | ||||
|
r9786 | raise util.Abort(_('no username supplied (see "hg help config")')) | ||
|
r6351 | if "\n" in user: | ||
|
r7470 | raise util.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]""" | ||
|
r14076 | if util.hasscheme(loc) or os.path.isdir(os.path.join(loc, '.hg')): | ||
|
r1892 | return loc | ||
|
r12662 | path = self.config('paths', loc) | ||
|
r2495 | if not path and default is not None: | ||
|
r12662 | path = self.config('paths', default) | ||
|
r2498 | return path or loc | ||
|
r506 | |||
|
r3737 | def pushbuffer(self): | ||
|
r8202 | self._buffers.append([]) | ||
|
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. | ||||
''' | ||||
|
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. | ||||
''' | ||||
|
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): | ||
|
r1989 | try: | ||
|
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() | ||||
|
r1989 | except IOError, 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) | ||||
|
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 | ||
|
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: | ||
return default | ||||
return r | ||||
except EOFError: | ||||
raise util.Abort(_('response expected')) | ||||
def promptchoice(self, msg, choices, default=0): | ||||
"""Prompt user with msg, read response, and ensure it matches | ||||
one of the provided choices. The index of the choice is returned. | ||||
choices is a sequence of acceptable responses with the format: | ||||
|
r9312 | ('&None', 'E&xec', 'Sym&link') Responses are case insensitive. | ||
|
r9048 | If ui is not interactive, the default is returned. | ||
""" | ||||
resps = [s[s.index('&')+1].lower() for s 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: | ||
return getpass.getpass(prompt or _('password: ')) | ||||
except EOFError: | ||||
raise util.Abort(_('response expected')) | ||||
|
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) | ||||
|
r1983 | def edit(self, text, user): | ||
|
r2206 | (fd, name) = tempfile.mkstemp(prefix="hg-editor-", suffix=".txt", | ||
text=True) | ||||
|
r1984 | try: | ||
f = os.fdopen(fd, "w") | ||||
f.write(text) | ||||
f.close() | ||||
|
r5660 | editor = self.geteditor() | ||
|
r207 | |||
|
r1984 | util.system("%s \"%s\"" % (editor, name), | ||
environ={'HGUSER': user}, | ||||
|
r14738 | onerr=util.Abort, errprefix=_("edit failed"), | ||
out=self.fout) | ||||
|
r608 | |||
|
r1984 | f = open(name) | ||
t = f.read() | ||||
f.close() | ||||
finally: | ||||
os.unlink(name) | ||||
|
r662 | |||
|
r207 | return t | ||
|
r2200 | |||
|
r9851 | def traceback(self, exc=None): | ||
|
r2335 | '''print exception traceback if traceback printing enabled. | ||
only to call in exception handler. returns true if traceback | ||||
printed.''' | ||||
|
r9851 | if self.tracebackflag: | ||
if exc: | ||||
|
r16683 | traceback.print_exception(exc[0], exc[1], exc[2], | ||
file=self.ferr) | ||||
|
r9851 | else: | ||
|
r15088 | traceback.print_exc(file=self.ferr) | ||
|
r9851 | return self.tracebackflag | ||
|
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 | |||
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 | ||||
non-numeric marker of the current position (ie the currently | ||||
in-process file), 'pos' is the current numeric position (ie | ||||
|
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 | ''' | ||
|
r13031 | if pos is None or not self.debugflag: | ||
|
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 | |||
|
r11984 | def log(self, service, message): | ||
'''hook for logging facility extensions | ||||
service should be a readily-identifiable subsystem, which will | ||||
allow filtering. | ||||
message should be a newline-terminated string to log. | ||||
''' | ||||
pass | ||||
|
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 | ||||