mercurial: comparison mercurial/ui.py

equal deleted inserted replaced

-:346af7687c6f
+:89a2afe31e82
 for section in cfg.sections():
 for name, value in self.configitems(section, untrusted):
 yield section, name, value
 def plain(self, feature=None):
-'''is plain mode active?
+"""is plain mode active?
 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 return value can either be
 - False if HGPLAIN is not set, or feature is in HGPLAINEXCEPT
 - False if feature is disabled by default and not included in HGPLAIN
 - True otherwise
-'''
+"""
 if (
 b'HGPLAIN' not in encoding.environ
 and b'HGPLAINEXCEPT' not in encoding.environ
 ):
 return False
 '''check if write calls with labels are batchable'''
 # Windows color printing is special, see ``write``.
 return self._colormode != b'win32'
 def write(self, *args, **opts):
-'''write args to output
+"""write args to output
 By default, this method simply writes to the buffer or stdout.
 Color mode can be set on the UI class to have the output decorated
 with color modifier before being written to stdout.
 in a pipe.
 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.
-'''
+"""
 dest = self._fout
 # inlined _write() for speed
 if self._buffers:
 label = opts.get('label', b'')
 @property
 def _exithandlers(self):
 return _reqexithandlers
 def atexit(self, func, *args, **kwargs):
-'''register a function to run after dispatching a request
+"""register a function to run after dispatching a request
-Handlers do not stay registered across request boundaries.'''
+Handlers do not stay registered across request boundaries."""
 self._exithandlers.append((func, args, kwargs))
 return func
 def interface(self, feature):
 """what interface to use for interactive console features?
 the default curses interface (crecord at the moment).
 """
 alldefaults = frozenset([b"text", b"curses"])
 featureinterfaces = {
-b"chunkselector": [b"text", b"curses",],
+b"chunkselector": [
-b"histedit": [b"text", b"curses",],
+b"text",
+b"curses",
+],
+b"histedit": [
+b"text",
+b"curses",
+],
 }
 # Feature-specific interface
 if feature not in featureinterfaces.keys():
 # Programming error, not user error
 )
 return choseninterface
 def interactive(self):
-'''is interactive input allowed?
+"""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()'.
-'''
+"""
 i = self.configbool(b"ui", b"interactive")
 if i is None:
 # some environments replace stdin without implementing isatty
 # usually those are non-interactive
 return self._isatty(self._fin)
 return i
 def termwidth(self):
-'''how wide is the terminal in columns?
+"""how wide is the terminal in columns?"""
-'''
 if b'COLUMNS' in encoding.environ:
 try:
 return int(encoding.environ[b'COLUMNS'])
 except ValueError:
 pass
 return scmutil.termsize(self)[0]
 def formatted(self):
-'''should formatted output be used?
+"""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'.
 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()'.
-'''
+"""
 if self.plain():
 return False
 i = self.configbool(b"ui", b"formatted")
 if i is None:
 return encoding.strtolocal(getpass.getpass(''))
 except EOFError:
 raise error.ResponseExpected()
 def status(self, *msg, **opts):
-'''write status message to output (if ui.quiet is False)
+"""write status message to output (if ui.quiet is False)
 This adds an output label of "ui.status".
-'''
+"""
 if not self.quiet:
 self._writemsg(self._fmsgout, type=b'status', *msg, **opts)
 def warn(self, *msg, **opts):
-'''write warning message to output (stderr)
+"""write warning message to output (stderr)
 This adds an output label of "ui.warning".
-'''
+"""
 self._writemsg(self._fmsgerr, type=b'warning', *msg, **opts)
 def error(self, *msg, **opts):
-'''write error message to output (stderr)
+"""write error message to output (stderr)
 This adds an output label of "ui.error".
-'''
+"""
 self._writemsg(self._fmsgerr, type=b'error', *msg, **opts)
 def note(self, *msg, **opts):
-'''write note to output (if ui.verbose is True)
+"""write note to output (if ui.verbose is True)
 This adds an output label of "ui.note".
-'''
+"""
 if self.verbose:
 self._writemsg(self._fmsgout, type=b'note', *msg, **opts)
 def debug(self, *msg, **opts):
-'''write debug message to output (if ui.debugflag is True)
+"""write debug message to output (if ui.debugflag is True)
 This adds an output label of "ui.debug".
-'''
+"""
 if self.debugflag:
 self._writemsg(self._fmsgout, type=b'debug', *msg, **opts)
 self.log(b'debug', b'%s', b''.join(msg))
 # Aliases to defeat check-code.
 cwd=None,
 onerr=None,
 errprefix=None,
 blockedtag=None,
 ):
-'''execute shell command with appropriate output stream. command
+"""execute shell command with appropriate output stream. command
 output will be redirected if fout is not stdout.
 if command fails and onerr is None, return status, else raise onerr
 object as exception.
-'''
+"""
 if blockedtag is None:
 # Long cmds tend to be because of an absolute path on cmd. Keep
 # the tail end instead
 cmdsuffix = cmd.translate(None, _keepalnum)[-85:]
 blockedtag = b'unknown_system_' + cmdsuffix
 """actually execute the given shell command (can be overridden by
 extensions like chg)"""
 return procutil.system(cmd, environ=environ, cwd=cwd, out=out)
 def traceback(self, exc=None, force=False):
-'''print exception traceback if traceback printing enabled or forced.
+"""print exception traceback if traceback printing enabled or forced.
 only to call in exception handler. returns true if traceback
-printed.'''
+printed."""
 if self.tracebackflag or force:
 if exc is None:
 exc = sys.exc_info()
 cause = getattr(exc[1], 'cause', None)
 name to uniquely identify the logger instance.
 """
 self._loggers[name] = logger
 def log(self, event, msgfmt, *msgargs, **opts):
-'''hook for logging facility extensions
+"""hook for logging facility extensions
 event should be a readily-identifiable subsystem, which will
 allow filtering.
 msgfmt should be a newline-terminated format string to log, and
 *msgargs are %-formatted into it.
 **opts currently has no defined meanings.
-'''
+"""
 if not self._loggers:
 return
 activeloggers = [
 l for l in pycompat.itervalues(self._loggers) if l.tracked(event)
 ]
 logger.log(self, event, msg, opts)
 finally:
 self._loggers = registeredloggers
 def label(self, msg, label):
-'''style msg based on supplied label
+"""style msg based on supplied label
 If some color mode is enabled, this will add the necessary control
 characters to apply such color. In addition, 'debug' color mode adds
 markup showing which label affects a piece of text.
 ui.write(s, 'label') is equivalent to
 ui.write(ui.label(s, 'label')).
-'''
+"""
 if self._colormode is not None:
 return color.colorlabel(self, msg, label)
 return msg
 def develwarn(self, msg, stacklevel=1, config=None):

changeset 45942	89a2afe31e82
parent 45929	87e7dd8e7734
child 46030	2cf61e66c6d0