color: wrap docstrings at 70 characters

hgext/color.py

@@ -1,288 +1,289 b''
 # color.py color output for the status and qseries commands
 #
 # Copyright (C) 2007 Kevin Christen <[e-mail]>
 #
 # This program is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by the
 # Free Software Foundation; either version 2 of the License, or (at your
 # option) any later version.
 #
 # This program is distributed in the hope that it will be useful, but
 # WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
 # Public License for more details.
 #
 # You should have received a copy of the GNU General Public License along
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 '''colorize output from some commands
 
-This extension modifies the status command to add color to its 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.
+This extension modifies the status command to add color to its 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. Effects are rendered with the ECMA-48 SGR control function (aka
-ANSI escape codes). This module also provides the render_text function, which
-can be used to add effects to any text.
+Other effects in addition to color, like bold and underlined text, are
+also available. Effects are rendered with the ECMA-48 SGR control
+function (aka ANSI escape codes). This module also provides the
+render_text function, which can be used to add effects to any text.
 
 Default effects may be overridden from the .hgrc 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
 '''
 
 import os, sys
 
 from mercurial import cmdutil, commands, extensions, error
 from mercurial.i18n import _
 
 # start and stop parameters for effects
 _effect_params = {'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 render_effects(text, effects):
     'Wrap text in commands to turn on each effect.'
     start = [str(_effect_params[e]) for e in ['none'] + effects]
     start = '\033[' + ';'.join(start) + 'm'
     stop = '\033[' + str(_effect_params['none']) + 'm'
     return ''.join([start, text, stop])
 
 def colorstatus(orig, ui, repo, *pats, **opts):
     '''run the status command with colored output'''
 
     delimiter = opts['print0'] and '\0' or '\n'
 
     nostatus = opts.get('no_status')
     opts['no_status'] = False
     # run status and capture its output
     ui.pushbuffer()
     retval = orig(ui, repo, *pats, **opts)
     # filter out empty strings
     lines_with_status = [ line for line in ui.popbuffer().split(delimiter) if line ]
 
     if nostatus:
         lines = [l[2:] for l in lines_with_status]
     else:
         lines = lines_with_status
 
     # apply color to output and display it
     for i in xrange(len(lines)):
         status = _status_abbreviations[lines_with_status[i][0]]
         effects = _status_effects[status]
         if effects:
             lines[i] = render_effects(lines[i], effects)
         ui.write(lines[i] + delimiter)
     return retval
 
 _status_abbreviations = { 'M': 'modified',
                           'A': 'added',
                           'R': 'removed',
                           '!': 'deleted',
                           '?': 'unknown',
                           'I': 'ignored',
                           'C': 'clean',
                           ' ': 'copied', }
 
 _status_effects = { 'modified': ['blue', 'bold'],
                     'added': ['green', 'bold'],
                     'removed': ['red', 'bold'],
                     'deleted': ['cyan', 'bold', 'underline'],
                     'unknown': ['magenta', 'bold', 'underline'],
                     'ignored': ['black', 'bold'],
                     'clean': ['none'],
                     'copied': ['none'], }
 
 def colorqseries(orig, ui, repo, *dummy, **opts):
     '''run the qseries command with colored output'''
     ui.pushbuffer()
     retval = orig(ui, repo, **opts)
     patches = ui.popbuffer().splitlines()
     for patch in patches:
         patchname = patch
         if opts['summary']:
             patchname = patchname.split(': ', 1)[0]
         if ui.verbose:
             patchname = patchname.lstrip().split(' ', 2)[-1]
 
         if opts['missing']:
             effects = _patch_effects['missing']
         # Determine if patch is applied.
         elif [ applied for applied in repo.mq.applied
                if patchname == applied.name ]:
             effects = _patch_effects['applied']
         else:
             effects = _patch_effects['unapplied']
 
         patch = patch.replace(patchname, render_effects(patchname, effects), 1)
         ui.write(patch + '\n')
     return retval
 
 _patch_effects = { 'applied': ['blue', 'bold', 'underline'],
                    'missing': ['red', 'bold'],
                    'unapplied': ['black', 'bold'], }
 
 def colorwrap(orig, s):
     '''wrap ui.write for colored diff output'''
     lines = s.split('\n')
     for i, line in enumerate(lines):
         stripline = line
         if line and line[0] in '+-':
             # highlight trailing whitespace, but only in changed lines
             stripline = line.rstrip()
         for prefix, style in _diff_prefixes:
             if stripline.startswith(prefix):
                 lines[i] = render_effects(stripline, _diff_effects[style])
                 break
         if line != stripline:
             lines[i] += render_effects(
                 line[len(stripline):], _diff_effects['trailingwhitespace'])
     orig('\n'.join(lines))
 
 def colorshowpatch(orig, self, node):
     '''wrap cmdutil.changeset_printer.showpatch with colored output'''
     oldwrite = extensions.wrapfunction(self.ui, 'write', colorwrap)
     try:
         orig(self, node)
     finally:
         self.ui.write = oldwrite
 
 def colordiff(orig, ui, repo, *pats, **opts):
     '''run the diff command with colored output'''
     oldwrite = extensions.wrapfunction(ui, 'write', colorwrap)
     try:
         orig(ui, repo, *pats, **opts)
     finally:
         ui.write = oldwrite
 
 _diff_prefixes = [('diff', 'diffline'),
                   ('copy', 'extended'),
                   ('rename', 'extended'),
                   ('old', 'extended'),
                   ('new', 'extended'),
                   ('deleted', 'extended'),
                   ('---', 'file_a'),
                   ('+++', 'file_b'),
                   ('@', 'hunk'),
                   ('-', 'deleted'),
                   ('+', 'inserted')]
 
 _diff_effects = {'diffline': ['bold'],
                  'extended': ['cyan', 'bold'],
                  'file_a': ['red', 'bold'],
                  'file_b': ['green', 'bold'],
                  'hunk': ['magenta'],
                  'deleted': ['red'],
                  'inserted': ['green'],
                  'changed': ['white'],
                  'trailingwhitespace': ['bold', 'red_background']}
 
 _ui = None
 
 def uisetup(ui):
     '''Initialize the extension.'''
     global _ui
     _ui = ui
     _setupcmd(ui, 'diff', commands.table, colordiff, _diff_effects)
     _setupcmd(ui, 'incoming', commands.table, None, _diff_effects)
     _setupcmd(ui, 'log', commands.table, None, _diff_effects)
     _setupcmd(ui, 'outgoing', commands.table, None, _diff_effects)
     _setupcmd(ui, 'tip', commands.table, None, _diff_effects)
     _setupcmd(ui, 'status', commands.table, colorstatus, _status_effects)
 
 def extsetup():
     try:
         mq = extensions.find('mq')
         try:
             # If we are loaded after mq, we must wrap commands.table
             _setupcmd(_ui, 'qdiff', commands.table, colordiff, _diff_effects)
             _setupcmd(_ui, 'qseries', commands.table, colorqseries, _patch_effects)
         except error.UnknownCommand:
             # Otherwise we wrap mq.cmdtable
             _setupcmd(_ui, 'qdiff', mq.cmdtable, colordiff, _diff_effects)
             _setupcmd(_ui, 'qseries', mq.cmdtable, colorqseries, _patch_effects)
     except KeyError:
         # The mq extension is not enabled
         pass
 
 def _setupcmd(ui, cmd, table, func, effectsmap):
     '''patch in command to command table and load effect map'''
     def nocolor(orig, *args, **opts):
 
         if (opts['no_color'] or opts['color'] == 'never' or
             (opts['color'] == 'auto' and (os.environ.get('TERM') == 'dumb'
                                           or not sys.__stdout__.isatty()))):
             return orig(*args, **opts)
 
         oldshowpatch = extensions.wrapfunction(cmdutil.changeset_printer,
                                                'showpatch', colorshowpatch)
         try:
             if func is not None:
                 return func(orig, *args, **opts)
             return orig(*args, **opts)
         finally:
             cmdutil.changeset_printer.showpatch = oldshowpatch
 
     entry = extensions.wrapcommand(table, cmd, nocolor)
     entry[1].extend([
         ('', 'color', 'auto', _("when to colorize (always, auto, or never)")),
         ('', 'no-color', None, _("don't colorize output")),
     ])
 
     for status in effectsmap:
         configkey = cmd + '.' + status
         effects = ui.configlist('color', configkey)
         if effects:
             good = []
             for e in effects:
                 if e in _effect_params:
                     good.append(e)
                 else:
                     ui.warn(_("ignoring unknown color/effect %r "
                               "(configured in color.%s)\n")
                             % (e, configkey))
             effectsmap[status] = good