|
|
# color.py color output for the status and qseries commands
|
|
|
#
|
|
|
# Copyright (C) 2007 Kevin Christen <kevin.christen@gmail.com>
|
|
|
#
|
|
|
# This software may be used and distributed according to the terms of the
|
|
|
# GNU General Public License version 2 or any later version.
|
|
|
|
|
|
'''colorize output from some commands
|
|
|
|
|
|
This extension modifies the status and resolve commands to add color
|
|
|
to their output to reflect file status, the qseries command to add
|
|
|
color to reflect patch status (applied, unapplied, missing), and to
|
|
|
diff-related commands to highlight additions, removals, diff headers,
|
|
|
and trailing whitespace.
|
|
|
|
|
|
Other effects in addition to color, like bold and underlined text, are
|
|
|
also available. By default, the terminfo database is used to find the
|
|
|
terminal codes used to change color and effect. If terminfo is not
|
|
|
available, then effects are rendered with the ECMA-48 SGR control
|
|
|
function (aka ANSI escape codes).
|
|
|
|
|
|
Default effects may be overridden from your configuration file::
|
|
|
|
|
|
[color]
|
|
|
status.modified = blue bold underline red_background
|
|
|
status.added = green bold
|
|
|
status.removed = red bold blue_background
|
|
|
status.deleted = cyan bold underline
|
|
|
status.unknown = magenta bold underline
|
|
|
status.ignored = black bold
|
|
|
|
|
|
# 'none' turns off all effects
|
|
|
status.clean = none
|
|
|
status.copied = none
|
|
|
|
|
|
qseries.applied = blue bold underline
|
|
|
qseries.unapplied = black bold
|
|
|
qseries.missing = red bold
|
|
|
|
|
|
diff.diffline = bold
|
|
|
diff.extended = cyan bold
|
|
|
diff.file_a = red bold
|
|
|
diff.file_b = green bold
|
|
|
diff.hunk = magenta
|
|
|
diff.deleted = red
|
|
|
diff.inserted = green
|
|
|
diff.changed = white
|
|
|
diff.trailingwhitespace = bold red_background
|
|
|
|
|
|
resolve.unresolved = red bold
|
|
|
resolve.resolved = green bold
|
|
|
|
|
|
bookmarks.current = green
|
|
|
|
|
|
branches.active = none
|
|
|
branches.closed = black bold
|
|
|
branches.current = green
|
|
|
branches.inactive = none
|
|
|
|
|
|
tags.normal = green
|
|
|
tags.local = black bold
|
|
|
|
|
|
The available effects in terminfo mode are 'blink', 'bold', 'dim',
|
|
|
'inverse', 'invisible', 'italic', 'standout', and 'underline'; in
|
|
|
ECMA-48 mode, the options are 'bold', 'inverse', 'italic', and
|
|
|
'underline'. How each is rendered depends on the terminal emulator.
|
|
|
Some may not be available for a given terminal type, and will be
|
|
|
silently ignored.
|
|
|
|
|
|
Note that on some systems, terminfo mode may cause problems when using
|
|
|
color with the pager extension and less -R. less with the -R option
|
|
|
will only display ECMA-48 color codes, and terminfo mode may sometimes
|
|
|
emit codes that less doesn't understand. You can work around this by
|
|
|
either using ansi mode (or auto mode), or by using less -r (which will
|
|
|
pass through all terminal control codes, not just color control
|
|
|
codes).
|
|
|
|
|
|
Because there are only eight standard colors, this module allows you
|
|
|
to define color names for other color slots which might be available
|
|
|
for your terminal type, assuming terminfo mode. For instance::
|
|
|
|
|
|
color.brightblue = 12
|
|
|
color.pink = 207
|
|
|
color.orange = 202
|
|
|
|
|
|
to set 'brightblue' to color slot 12 (useful for 16 color terminals
|
|
|
that have brighter colors defined in the upper eight) and, 'pink' and
|
|
|
'orange' to colors in 256-color xterm's default color cube. These
|
|
|
defined colors may then be used as any of the pre-defined eight,
|
|
|
including appending '_background' to set the background to that color.
|
|
|
|
|
|
By default, the color extension will use ANSI mode (or win32 mode on
|
|
|
Windows) if it detects a terminal. To override auto mode (to enable
|
|
|
terminfo mode, for example), set the following configuration option::
|
|
|
|
|
|
[color]
|
|
|
mode = terminfo
|
|
|
|
|
|
Any value other than 'ansi', 'win32', 'terminfo', or 'auto' will
|
|
|
disable color.
|
|
|
'''
|
|
|
|
|
|
import os
|
|
|
|
|
|
from mercurial import commands, dispatch, extensions, ui as uimod, util
|
|
|
from mercurial import templater, error
|
|
|
from mercurial.i18n import _
|
|
|
|
|
|
testedwith = 'internal'
|
|
|
|
|
|
# start and stop parameters for effects
|
|
|
_effects = {'none': 0, 'black': 30, 'red': 31, 'green': 32, 'yellow': 33,
|
|
|
'blue': 34, 'magenta': 35, 'cyan': 36, 'white': 37, 'bold': 1,
|
|
|
'italic': 3, 'underline': 4, 'inverse': 7,
|
|
|
'black_background': 40, 'red_background': 41,
|
|
|
'green_background': 42, 'yellow_background': 43,
|
|
|
'blue_background': 44, 'purple_background': 45,
|
|
|
'cyan_background': 46, 'white_background': 47}
|
|
|
|
|
|
def _terminfosetup(ui, mode):
|
|
|
'''Initialize terminfo data and the terminal if we're in terminfo mode.'''
|
|
|
|
|
|
global _terminfo_params
|
|
|
# If we failed to load curses, we go ahead and return.
|
|
|
if not _terminfo_params:
|
|
|
return
|
|
|
# Otherwise, see what the config file says.
|
|
|
if mode not in ('auto', 'terminfo'):
|
|
|
return
|
|
|
|
|
|
_terminfo_params.update((key[6:], (False, int(val)))
|
|
|
for key, val in ui.configitems('color')
|
|
|
if key.startswith('color.'))
|
|
|
|
|
|
try:
|
|
|
curses.setupterm()
|
|
|
except curses.error, e:
|
|
|
_terminfo_params = {}
|
|
|
return
|
|
|
|
|
|
for key, (b, e) in _terminfo_params.items():
|
|
|
if not b:
|
|
|
continue
|
|
|
if not curses.tigetstr(e):
|
|
|
# Most terminals don't support dim, invis, etc, so don't be
|
|
|
# noisy and use ui.debug().
|
|
|
ui.debug("no terminfo entry for %s\n" % e)
|
|
|
del _terminfo_params[key]
|
|
|
if not curses.tigetstr('setaf') or not curses.tigetstr('setab'):
|
|
|
# Only warn about missing terminfo entries if we explicitly asked for
|
|
|
# terminfo mode.
|
|
|
if mode == "terminfo":
|
|
|
ui.warn(_("no terminfo entry for setab/setaf: reverting to "
|
|
|
"ECMA-48 color\n"))
|
|
|
_terminfo_params = {}
|
|
|
|
|
|
def _modesetup(ui, opts):
|
|
|
global _terminfo_params
|
|
|
|
|
|
coloropt = opts['color']
|
|
|
auto = coloropt == 'auto'
|
|
|
always = not auto and util.parsebool(coloropt)
|
|
|
if not always and not auto:
|
|
|
return None
|
|
|
|
|
|
formatted = always or (os.environ.get('TERM') != 'dumb' and ui.formatted())
|
|
|
|
|
|
mode = ui.config('color', 'mode', 'auto')
|
|
|
realmode = mode
|
|
|
if mode == 'auto':
|
|
|
if os.name == 'nt' and 'TERM' not in os.environ:
|
|
|
# looks line a cmd.exe console, use win32 API or nothing
|
|
|
realmode = 'win32'
|
|
|
else:
|
|
|
realmode = 'ansi'
|
|
|
|
|
|
if realmode == 'win32':
|
|
|
_terminfo_params = {}
|
|
|
if not w32effects:
|
|
|
if mode == 'win32':
|
|
|
# only warn if color.mode is explicitly set to win32
|
|
|
ui.warn(_('warning: failed to set color mode to %s\n') % mode)
|
|
|
return None
|
|
|
_effects.update(w32effects)
|
|
|
elif realmode == 'ansi':
|
|
|
_terminfo_params = {}
|
|
|
elif realmode == 'terminfo':
|
|
|
_terminfosetup(ui, mode)
|
|
|
if not _terminfo_params:
|
|
|
if mode == 'terminfo':
|
|
|
## FIXME Shouldn't we return None in this case too?
|
|
|
# only warn if color.mode is explicitly set to win32
|
|
|
ui.warn(_('warning: failed to set color mode to %s\n') % mode)
|
|
|
realmode = 'ansi'
|
|
|
else:
|
|
|
return None
|
|
|
|
|
|
if always or (auto and formatted):
|
|
|
return realmode
|
|
|
return None
|
|
|
|
|
|
try:
|
|
|
import curses
|
|
|
# Mapping from effect name to terminfo attribute name or color number.
|
|
|
# This will also force-load the curses module.
|
|
|
_terminfo_params = {'none': (True, 'sgr0'),
|
|
|
'standout': (True, 'smso'),
|
|
|
'underline': (True, 'smul'),
|
|
|
'reverse': (True, 'rev'),
|
|
|
'inverse': (True, 'rev'),
|
|
|
'blink': (True, 'blink'),
|
|
|
'dim': (True, 'dim'),
|
|
|
'bold': (True, 'bold'),
|
|
|
'invisible': (True, 'invis'),
|
|
|
'italic': (True, 'sitm'),
|
|
|
'black': (False, curses.COLOR_BLACK),
|
|
|
'red': (False, curses.COLOR_RED),
|
|
|
'green': (False, curses.COLOR_GREEN),
|
|
|
'yellow': (False, curses.COLOR_YELLOW),
|
|
|
'blue': (False, curses.COLOR_BLUE),
|
|
|
'magenta': (False, curses.COLOR_MAGENTA),
|
|
|
'cyan': (False, curses.COLOR_CYAN),
|
|
|
'white': (False, curses.COLOR_WHITE)}
|
|
|
except ImportError:
|
|
|
_terminfo_params = False
|
|
|
|
|
|
_styles = {'grep.match': 'red bold',
|
|
|
'grep.linenumber': 'green',
|
|
|
'grep.rev': 'green',
|
|
|
'grep.change': 'green',
|
|
|
'grep.sep': 'cyan',
|
|
|
'grep.filename': 'magenta',
|
|
|
'grep.user': 'magenta',
|
|
|
'grep.date': 'magenta',
|
|
|
'bookmarks.current': 'green',
|
|
|
'branches.active': 'none',
|
|
|
'branches.closed': 'black bold',
|
|
|
'branches.current': 'green',
|
|
|
'branches.inactive': 'none',
|
|
|
'diff.changed': 'white',
|
|
|
'diff.deleted': 'red',
|
|
|
'diff.diffline': 'bold',
|
|
|
'diff.extended': 'cyan bold',
|
|
|
'diff.file_a': 'red bold',
|
|
|
'diff.file_b': 'green bold',
|
|
|
'diff.hunk': 'magenta',
|
|
|
'diff.inserted': 'green',
|
|
|
'diff.trailingwhitespace': 'bold red_background',
|
|
|
'diffstat.deleted': 'red',
|
|
|
'diffstat.inserted': 'green',
|
|
|
'ui.prompt': 'yellow',
|
|
|
'log.changeset': 'yellow',
|
|
|
'resolve.resolved': 'green bold',
|
|
|
'resolve.unresolved': 'red bold',
|
|
|
'status.added': 'green bold',
|
|
|
'status.clean': 'none',
|
|
|
'status.copied': 'none',
|
|
|
'status.deleted': 'cyan bold underline',
|
|
|
'status.ignored': 'black bold',
|
|
|
'status.modified': 'blue bold',
|
|
|
'status.removed': 'red bold',
|
|
|
'status.unknown': 'magenta bold underline',
|
|
|
'tags.normal': 'green',
|
|
|
'tags.local': 'black bold'}
|
|
|
|
|
|
|
|
|
def _effect_str(effect):
|
|
|
'''Helper function for render_effects().'''
|
|
|
|
|
|
bg = False
|
|
|
if effect.endswith('_background'):
|
|
|
bg = True
|
|
|
effect = effect[:-11]
|
|
|
attr, val = _terminfo_params[effect]
|
|
|
if attr:
|
|
|
return curses.tigetstr(val)
|
|
|
elif bg:
|
|
|
return curses.tparm(curses.tigetstr('setab'), val)
|
|
|
else:
|
|
|
return curses.tparm(curses.tigetstr('setaf'), val)
|
|
|
|
|
|
def render_effects(text, effects):
|
|
|
'Wrap text in commands to turn on each effect.'
|
|
|
if not text:
|
|
|
return text
|
|
|
if not _terminfo_params:
|
|
|
start = [str(_effects[e]) for e in ['none'] + effects.split()]
|
|
|
start = '\033[' + ';'.join(start) + 'm'
|
|
|
stop = '\033[' + str(_effects['none']) + 'm'
|
|
|
else:
|
|
|
start = ''.join(_effect_str(effect)
|
|
|
for effect in ['none'] + effects.split())
|
|
|
stop = _effect_str('none')
|
|
|
return ''.join([start, text, stop])
|
|
|
|
|
|
def extstyles():
|
|
|
for name, ext in extensions.extensions():
|
|
|
_styles.update(getattr(ext, 'colortable', {}))
|
|
|
|
|
|
def configstyles(ui):
|
|
|
for status, cfgeffects in ui.configitems('color'):
|
|
|
if '.' not in status or status.startswith('color.'):
|
|
|
continue
|
|
|
cfgeffects = ui.configlist('color', status)
|
|
|
if cfgeffects:
|
|
|
good = []
|
|
|
for e in cfgeffects:
|
|
|
if not _terminfo_params and e in _effects:
|
|
|
good.append(e)
|
|
|
elif e in _terminfo_params or e[:-11] in _terminfo_params:
|
|
|
good.append(e)
|
|
|
else:
|
|
|
ui.warn(_("ignoring unknown color/effect %r "
|
|
|
"(configured in color.%s)\n")
|
|
|
% (e, status))
|
|
|
_styles[status] = ' '.join(good)
|
|
|
|
|
|
class colorui(uimod.ui):
|
|
|
def popbuffer(self, labeled=False):
|
|
|
if labeled:
|
|
|
return ''.join(self.label(a, label) for a, label
|
|
|
in self._buffers.pop())
|
|
|
return ''.join(a for a, label in self._buffers.pop())
|
|
|
|
|
|
_colormode = 'ansi'
|
|
|
def write(self, *args, **opts):
|
|
|
label = opts.get('label', '')
|
|
|
if self._buffers:
|
|
|
self._buffers[-1].extend([(str(a), label) for a in args])
|
|
|
elif self._colormode == 'win32':
|
|
|
for a in args:
|
|
|
win32print(a, super(colorui, self).write, **opts)
|
|
|
else:
|
|
|
return super(colorui, self).write(
|
|
|
*[self.label(str(a), label) for a in args], **opts)
|
|
|
|
|
|
def write_err(self, *args, **opts):
|
|
|
label = opts.get('label', '')
|
|
|
if self._colormode == 'win32':
|
|
|
for a in args:
|
|
|
win32print(a, super(colorui, self).write_err, **opts)
|
|
|
else:
|
|
|
return super(colorui, self).write_err(
|
|
|
*[self.label(str(a), label) for a in args], **opts)
|
|
|
|
|
|
def label(self, msg, label):
|
|
|
effects = []
|
|
|
for l in label.split():
|
|
|
s = _styles.get(l, '')
|
|
|
if s:
|
|
|
effects.append(s)
|
|
|
effects = ' '.join(effects)
|
|
|
if effects:
|
|
|
return '\n'.join([render_effects(s, effects)
|
|
|
for s in msg.split('\n')])
|
|
|
return msg
|
|
|
|
|
|
def templatelabel(context, mapping, args):
|
|
|
if len(args) != 2:
|
|
|
# i18n: "label" is a keyword
|
|
|
raise error.ParseError(_("label expects two arguments"))
|
|
|
|
|
|
thing = templater.stringify(args[1][0](context, mapping, args[1][1]))
|
|
|
thing = templater.runtemplate(context, mapping,
|
|
|
templater.compiletemplate(thing, context))
|
|
|
|
|
|
# apparently, repo could be a string that is the favicon?
|
|
|
repo = mapping.get('repo', '')
|
|
|
if isinstance(repo, str):
|
|
|
return thing
|
|
|
|
|
|
label = templater.stringify(args[0][0](context, mapping, args[0][1]))
|
|
|
label = templater.runtemplate(context, mapping,
|
|
|
templater.compiletemplate(label, context))
|
|
|
|
|
|
thing = templater.stringify(thing)
|
|
|
label = templater.stringify(label)
|
|
|
|
|
|
return repo.ui.label(thing, label)
|
|
|
|
|
|
def uisetup(ui):
|
|
|
if ui.plain():
|
|
|
return
|
|
|
def colorcmd(orig, ui_, opts, cmd, cmdfunc):
|
|
|
mode = _modesetup(ui_, opts)
|
|
|
if mode:
|
|
|
colorui._colormode = mode
|
|
|
if not issubclass(ui_.__class__, colorui):
|
|
|
colorui.__bases__ = (ui_.__class__,)
|
|
|
ui_.__class__ = colorui
|
|
|
extstyles()
|
|
|
configstyles(ui_)
|
|
|
return orig(ui_, opts, cmd, cmdfunc)
|
|
|
extensions.wrapfunction(dispatch, '_runcommand', colorcmd)
|
|
|
templater.funcs['label'] = templatelabel
|
|
|
|
|
|
def extsetup(ui):
|
|
|
commands.globalopts.append(
|
|
|
('', 'color', 'auto',
|
|
|
# i18n: 'always', 'auto', and 'never' are keywords and should
|
|
|
# not be translated
|
|
|
_("when to colorize (boolean, always, auto, or never)"),
|
|
|
_('TYPE')))
|
|
|
|
|
|
if os.name != 'nt':
|
|
|
w32effects = None
|
|
|
else:
|
|
|
import re, ctypes
|
|
|
|
|
|
_kernel32 = ctypes.windll.kernel32
|
|
|
|
|
|
_WORD = ctypes.c_ushort
|
|
|
|
|
|
_INVALID_HANDLE_VALUE = -1
|
|
|
|
|
|
class _COORD(ctypes.Structure):
|
|
|
_fields_ = [('X', ctypes.c_short),
|
|
|
('Y', ctypes.c_short)]
|
|
|
|
|
|
class _SMALL_RECT(ctypes.Structure):
|
|
|
_fields_ = [('Left', ctypes.c_short),
|
|
|
('Top', ctypes.c_short),
|
|
|
('Right', ctypes.c_short),
|
|
|
('Bottom', ctypes.c_short)]
|
|
|
|
|
|
class _CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure):
|
|
|
_fields_ = [('dwSize', _COORD),
|
|
|
('dwCursorPosition', _COORD),
|
|
|
('wAttributes', _WORD),
|
|
|
('srWindow', _SMALL_RECT),
|
|
|
('dwMaximumWindowSize', _COORD)]
|
|
|
|
|
|
_STD_OUTPUT_HANDLE = 0xfffffff5L # (DWORD)-11
|
|
|
_STD_ERROR_HANDLE = 0xfffffff4L # (DWORD)-12
|
|
|
|
|
|
_FOREGROUND_BLUE = 0x0001
|
|
|
_FOREGROUND_GREEN = 0x0002
|
|
|
_FOREGROUND_RED = 0x0004
|
|
|
_FOREGROUND_INTENSITY = 0x0008
|
|
|
|
|
|
_BACKGROUND_BLUE = 0x0010
|
|
|
_BACKGROUND_GREEN = 0x0020
|
|
|
_BACKGROUND_RED = 0x0040
|
|
|
_BACKGROUND_INTENSITY = 0x0080
|
|
|
|
|
|
_COMMON_LVB_REVERSE_VIDEO = 0x4000
|
|
|
_COMMON_LVB_UNDERSCORE = 0x8000
|
|
|
|
|
|
# http://msdn.microsoft.com/en-us/library/ms682088%28VS.85%29.aspx
|
|
|
w32effects = {
|
|
|
'none': -1,
|
|
|
'black': 0,
|
|
|
'red': _FOREGROUND_RED,
|
|
|
'green': _FOREGROUND_GREEN,
|
|
|
'yellow': _FOREGROUND_RED | _FOREGROUND_GREEN,
|
|
|
'blue': _FOREGROUND_BLUE,
|
|
|
'magenta': _FOREGROUND_BLUE | _FOREGROUND_RED,
|
|
|
'cyan': _FOREGROUND_BLUE | _FOREGROUND_GREEN,
|
|
|
'white': _FOREGROUND_RED | _FOREGROUND_GREEN | _FOREGROUND_BLUE,
|
|
|
'bold': _FOREGROUND_INTENSITY,
|
|
|
'black_background': 0x100, # unused value > 0x0f
|
|
|
'red_background': _BACKGROUND_RED,
|
|
|
'green_background': _BACKGROUND_GREEN,
|
|
|
'yellow_background': _BACKGROUND_RED | _BACKGROUND_GREEN,
|
|
|
'blue_background': _BACKGROUND_BLUE,
|
|
|
'purple_background': _BACKGROUND_BLUE | _BACKGROUND_RED,
|
|
|
'cyan_background': _BACKGROUND_BLUE | _BACKGROUND_GREEN,
|
|
|
'white_background': (_BACKGROUND_RED | _BACKGROUND_GREEN |
|
|
|
_BACKGROUND_BLUE),
|
|
|
'bold_background': _BACKGROUND_INTENSITY,
|
|
|
'underline': _COMMON_LVB_UNDERSCORE, # double-byte charsets only
|
|
|
'inverse': _COMMON_LVB_REVERSE_VIDEO, # double-byte charsets only
|
|
|
}
|
|
|
|
|
|
passthrough = set([_FOREGROUND_INTENSITY,
|
|
|
_BACKGROUND_INTENSITY,
|
|
|
_COMMON_LVB_UNDERSCORE,
|
|
|
_COMMON_LVB_REVERSE_VIDEO])
|
|
|
|
|
|
stdout = _kernel32.GetStdHandle(
|
|
|
_STD_OUTPUT_HANDLE) # don't close the handle returned
|
|
|
if stdout is None or stdout == _INVALID_HANDLE_VALUE:
|
|
|
w32effects = None
|
|
|
else:
|
|
|
csbi = _CONSOLE_SCREEN_BUFFER_INFO()
|
|
|
if not _kernel32.GetConsoleScreenBufferInfo(
|
|
|
stdout, ctypes.byref(csbi)):
|
|
|
# stdout may not support GetConsoleScreenBufferInfo()
|
|
|
# when called from subprocess or redirected
|
|
|
w32effects = None
|
|
|
else:
|
|
|
origattr = csbi.wAttributes
|
|
|
ansire = re.compile('\033\[([^m]*)m([^\033]*)(.*)',
|
|
|
re.MULTILINE | re.DOTALL)
|
|
|
|
|
|
def win32print(text, orig, **opts):
|
|
|
label = opts.get('label', '')
|
|
|
attr = origattr
|
|
|
|
|
|
def mapcolor(val, attr):
|
|
|
if val == -1:
|
|
|
return origattr
|
|
|
elif val in passthrough:
|
|
|
return attr | val
|
|
|
elif val > 0x0f:
|
|
|
return (val & 0x70) | (attr & 0x8f)
|
|
|
else:
|
|
|
return (val & 0x07) | (attr & 0xf8)
|
|
|
|
|
|
# determine console attributes based on labels
|
|
|
for l in label.split():
|
|
|
style = _styles.get(l, '')
|
|
|
for effect in style.split():
|
|
|
attr = mapcolor(w32effects[effect], attr)
|
|
|
|
|
|
# hack to ensure regexp finds data
|
|
|
if not text.startswith('\033['):
|
|
|
text = '\033[m' + text
|
|
|
|
|
|
# Look for ANSI-like codes embedded in text
|
|
|
m = re.match(ansire, text)
|
|
|
|
|
|
try:
|
|
|
while m:
|
|
|
for sattr in m.group(1).split(';'):
|
|
|
if sattr:
|
|
|
attr = mapcolor(int(sattr), attr)
|
|
|
_kernel32.SetConsoleTextAttribute(stdout, attr)
|
|
|
orig(m.group(2), **opts)
|
|
|
m = re.match(ansire, m.group(3))
|
|
|
finally:
|
|
|
# Explicitly reset original attributes
|
|
|
_kernel32.SetConsoleTextAttribute(stdout, origattr)
|
|
|
|
