color: change color of grep.rev label (BC)

GNU grep uses green for line numbers as we do, but I sometimes get a
bit confused when I do `hg grep --diff -n` and get both line numbers
and revisions and don't know which one is which.

A different colour can help.

mercurial/color.py

@@ -1,534 +1,534 b''
 # utility for color output for Mercurial commands
 #
 # Copyright (C) 2007 Kevin Christen <[e-mail]> and other
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import re
 
 from .i18n import _
 
 from . import (
     encoding,
     pycompat,
 )
 
 from .utils import (
     stringutil,
 )
 
 try:
     import curses
     # Mapping from effect name to terminfo attribute name (or raw code) or
     # color number.  This will also force-load the curses module.
     _baseterminfoparams = {
         '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:
     curses = None
     _baseterminfoparams = {}
 
 # 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,
     'dim': 2,
     'black_background': 40,
     'red_background': 41,
     'green_background': 42,
     'yellow_background': 43,
     'blue_background': 44,
     'purple_background': 45,
     'cyan_background': 46,
     'white_background': 47,
     }
 
 _defaultstyles = {
     'grep.match': 'red bold',
     'grep.linenumber': 'green',
-    'grep.rev': 'green',
+    'grep.rev': 'blue',
     'grep.sep': 'cyan',
     'grep.filename': 'magenta',
     'grep.user': 'magenta',
     'grep.date': 'magenta',
     'grep.inserted': 'green bold',
     'grep.deleted': 'red bold',
     'bookmarks.active': 'green',
     'branches.active': 'none',
     'branches.closed': 'black bold',
     'branches.current': 'green',
     'branches.inactive': 'none',
     'diff.changed': 'white',
     'diff.deleted': 'red',
     'diff.deleted.changed': 'red bold underline',
     'diff.deleted.unchanged': '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.inserted.changed': 'green bold underline',
     'diff.inserted.unchanged': 'green',
     'diff.tab': '',
     'diff.trailingwhitespace': 'bold red_background',
     'changeset.public': '',
     'changeset.draft': '',
     'changeset.secret': '',
     'diffstat.deleted': 'red',
     'diffstat.inserted': 'green',
     'formatvariant.name.mismatchconfig': 'red',
     'formatvariant.name.mismatchdefault': 'yellow',
     'formatvariant.name.uptodate': 'green',
     'formatvariant.repo.mismatchconfig': 'red',
     'formatvariant.repo.mismatchdefault': 'yellow',
     'formatvariant.repo.uptodate': 'green',
     'formatvariant.config.special': 'yellow',
     'formatvariant.config.default': 'green',
     'formatvariant.default': '',
     'histedit.remaining': 'red bold',
     'ui.addremove.added': 'green',
     'ui.addremove.removed': 'red',
     'ui.error': 'red',
     'ui.prompt': 'yellow',
     'log.changeset': 'yellow',
     'patchbomb.finalsummary': '',
     'patchbomb.from': 'magenta',
     'patchbomb.to': 'cyan',
     'patchbomb.subject': 'green',
     'patchbomb.diffstats': '',
     'rebase.rebased': 'blue',
     'rebase.remaining': 'red bold',
     'resolve.resolved': 'green bold',
     'resolve.unresolved': 'red bold',
     'shelve.age': 'cyan',
     'shelve.newest': 'green bold',
     'shelve.name': 'blue 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 loadcolortable(ui, extname, colortable):
     _defaultstyles.update(colortable)
 
 def _terminfosetup(ui, mode, formatted):
     '''Initialize terminfo data and the terminal if we're in terminfo mode.'''
 
     # If we failed to load curses, we go ahead and return.
     if curses is None:
         return
     # Otherwise, see what the config file says.
     if mode not in ('auto', 'terminfo'):
         return
     ui._terminfoparams.update(_baseterminfoparams)
 
     for key, val in ui.configitems('color'):
         if key.startswith('color.'):
             newval = (False, int(val), '')
             ui._terminfoparams[key[6:]] = newval
         elif key.startswith('terminfo.'):
             newval = (True, '', val.replace('\\E', '\x1b'))
             ui._terminfoparams[key[9:]] = newval
     try:
         curses.setupterm()
     except curses.error:
         ui._terminfoparams.clear()
         return
 
     for key, (b, e, c) in ui._terminfoparams.copy().items():
         if not b:
             continue
         if not c and not curses.tigetstr(pycompat.sysstr(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 ui._terminfoparams[key]
     if not curses.tigetstr(r'setaf') or not curses.tigetstr(r'setab'):
         # Only warn about missing terminfo entries if we explicitly asked for
         # terminfo mode and we're in a formatted terminal.
         if mode == "terminfo" and formatted:
             ui.warn(_("no terminfo entry for setab/setaf: reverting to "
               "ECMA-48 color\n"))
         ui._terminfoparams.clear()
 
 def setup(ui):
     """configure color on a ui
 
     That function both set the colormode for the ui object and read
     the configuration looking for custom colors and effect definitions."""
     mode = _modesetup(ui)
     ui._colormode = mode
     if mode and mode != 'debug':
         configstyles(ui)
 
 def _modesetup(ui):
     if ui.plain('color'):
         return None
     config = ui.config('ui', 'color')
     if config == 'debug':
         return 'debug'
 
     auto = (config == 'auto')
     always = False
     if not auto and stringutil.parsebool(config):
         # We want the config to behave like a boolean, "on" is actually auto,
         # but "always" value is treated as a special case to reduce confusion.
         if ui.configsource('ui', 'color') == '--color' or config == 'always':
             always = True
         else:
             auto = True
 
     if not always and not auto:
         return None
 
     formatted = (always or (encoding.environ.get('TERM') != 'dumb'
                  and ui.formatted()))
 
     mode = ui.config('color', 'mode')
 
     # If pager is active, color.pagermode overrides color.mode.
     if getattr(ui, 'pageractive', False):
         mode = ui.config('color', 'pagermode', mode)
 
     realmode = mode
     if pycompat.iswindows:
         from . import win32
 
         term = encoding.environ.get('TERM')
         # TERM won't be defined in a vanilla cmd.exe environment.
 
         # UNIX-like environments on Windows such as Cygwin and MSYS will
         # set TERM. They appear to make a best effort attempt at setting it
         # to something appropriate. However, not all environments with TERM
         # defined support ANSI.
         ansienviron = term and 'xterm' in term
 
         if mode == 'auto':
             # Since "ansi" could result in terminal gibberish, we error on the
             # side of selecting "win32". However, if w32effects is not defined,
             # we almost certainly don't support "win32", so don't even try.
             # w32effects is not populated when stdout is redirected, so checking
             # it first avoids win32 calls in a state known to error out.
             if ansienviron or not w32effects or win32.enablevtmode():
                 realmode = 'ansi'
             else:
                 realmode = 'win32'
         # An empty w32effects is a clue that stdout is redirected, and thus
         # cannot enable VT mode.
         elif mode == 'ansi' and w32effects and not ansienviron:
             win32.enablevtmode()
     elif mode == 'auto':
         realmode = 'ansi'
 
     def modewarn():
         # only warn if color.mode was explicitly set and we're in
         # a formatted terminal
         if mode == realmode and formatted:
             ui.warn(_('warning: failed to set color mode to %s\n') % mode)
 
     if realmode == 'win32':
         ui._terminfoparams.clear()
         if not w32effects:
             modewarn()
             return None
     elif realmode == 'ansi':
         ui._terminfoparams.clear()
     elif realmode == 'terminfo':
         _terminfosetup(ui, mode, formatted)
         if not ui._terminfoparams:
             ## FIXME Shouldn't we return None in this case too?
             modewarn()
             realmode = 'ansi'
     else:
         return None
 
     if always or (auto and formatted):
         return realmode
     return None
 
 def configstyles(ui):
     ui._styles.update(_defaultstyles)
     for status, cfgeffects in ui.configitems('color'):
         if '.' not in status or status.startswith(('color.', 'terminfo.')):
             continue
         cfgeffects = ui.configlist('color', status)
         if cfgeffects:
             good = []
             for e in cfgeffects:
                 if valideffect(ui, e):
                     good.append(e)
                 else:
                     ui.warn(_("ignoring unknown color/effect %s "
                               "(configured in color.%s)\n")
                             % (stringutil.pprint(e), status))
             ui._styles[status] = ' '.join(good)
 
 def _activeeffects(ui):
     '''Return the effects map for the color mode set on the ui.'''
     if ui._colormode == 'win32':
         return w32effects
     elif ui._colormode is not None:
         return _effects
     return {}
 
 def valideffect(ui, effect):
     'Determine if the effect is valid or not.'
     return ((not ui._terminfoparams and effect in _activeeffects(ui))
              or (effect in ui._terminfoparams
                  or effect[:-11] in ui._terminfoparams))
 
 def _effect_str(ui, effect):
     '''Helper function for render_effects().'''
 
     bg = False
     if effect.endswith('_background'):
         bg = True
         effect = effect[:-11]
     try:
         attr, val, termcode = ui._terminfoparams[effect]
     except KeyError:
         return ''
     if attr:
         if termcode:
             return termcode
         else:
             return curses.tigetstr(pycompat.sysstr(val))
     elif bg:
         return curses.tparm(curses.tigetstr(r'setab'), val)
     else:
         return curses.tparm(curses.tigetstr(r'setaf'), val)
 
 def _mergeeffects(text, start, stop):
     """Insert start sequence at every occurrence of stop sequence
 
     >>> s = _mergeeffects(b'cyan', b'[C]', b'|')
     >>> s = _mergeeffects(s + b'yellow', b'[Y]', b'|')
     >>> s = _mergeeffects(b'ma' + s + b'genta', b'[M]', b'|')
     >>> s = _mergeeffects(b'red' + s, b'[R]', b'|')
     >>> s
     '[R]red[M]ma[Y][C]cyan|[R][M][Y]yellow|[R][M]genta|'
     """
     parts = []
     for t in text.split(stop):
         if not t:
             continue
         parts.extend([start, t, stop])
     return ''.join(parts)
 
 def _render_effects(ui, text, effects):
     'Wrap text in commands to turn on each effect.'
     if not text:
         return text
     if ui._terminfoparams:
         start = ''.join(_effect_str(ui, effect)
                         for effect in ['none'] + effects.split())
         stop = _effect_str(ui, 'none')
     else:
         activeeffects = _activeeffects(ui)
         start = [pycompat.bytestr(activeeffects[e])
                  for e in ['none'] + effects.split()]
         start = '\033[' + ';'.join(start) + 'm'
         stop = '\033[' + pycompat.bytestr(activeeffects['none']) + 'm'
     return _mergeeffects(text, start, stop)
 
 _ansieffectre = re.compile(br'\x1b\[[0-9;]*m')
 
 def stripeffects(text):
     """Strip ANSI control codes which could be inserted by colorlabel()"""
     return _ansieffectre.sub('', text)
 
 def colorlabel(ui, msg, label):
     """add color control code according to the mode"""
     if ui._colormode == 'debug':
         if label and msg:
             if msg.endswith('\n'):
                 msg = "[%s|%s]\n" % (label, msg[:-1])
             else:
                 msg = "[%s|%s]" % (label, msg)
     elif ui._colormode is not None:
         effects = []
         for l in label.split():
             s = ui._styles.get(l, '')
             if s:
                 effects.append(s)
             elif valideffect(ui, l):
                 effects.append(l)
         effects = ' '.join(effects)
         if effects:
             msg = '\n'.join([_render_effects(ui, line, effects)
                              for line in msg.split('\n')])
     return msg
 
 w32effects = None
 if pycompat.iswindows:
     import ctypes
 
     _kernel32 = ctypes.windll.kernel32
 
     _WORD = ctypes.c_ushort
 
     _INVALID_HANDLE_VALUE = -1
 
     class _COORD(ctypes.Structure):
         _fields_ = [(r'X', ctypes.c_short),
                     (r'Y', ctypes.c_short)]
 
     class _SMALL_RECT(ctypes.Structure):
         _fields_ = [(r'Left', ctypes.c_short),
                     (r'Top', ctypes.c_short),
                     (r'Right', ctypes.c_short),
                     (r'Bottom', ctypes.c_short)]
 
     class _CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure):
         _fields_ = [(r'dwSize', _COORD),
                     (r'dwCursorPosition', _COORD),
                     (r'wAttributes', _WORD),
                     (r'srWindow', _SMALL_RECT),
                     (r'dwMaximumWindowSize', _COORD)]
 
     _STD_OUTPUT_HANDLE = 0xfffffff5 # (DWORD)-11
     _STD_ERROR_HANDLE = 0xfffffff4  # (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 = {_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(br'\033\[([^m]*)m([^\033]*)(.*)',
                                 re.MULTILINE | re.DOTALL)
 
     def win32print(ui, writefunc, text, **opts):
         label = opts.get(r'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 = ui._styles.get(l, '')
             for effect in style.split():
                 try:
                     attr = mapcolor(w32effects[effect], attr)
                 except KeyError:
                     # w32effects could not have certain attributes so we skip
                     # them if not found
                     pass
         # hack to ensure regexp finds data
         if not text.startswith(b'\033['):
             text = b'\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(b';'):
                     if sattr:
                         attr = mapcolor(int(sattr), attr)
                 ui.flush()
                 _kernel32.SetConsoleTextAttribute(stdout, attr)
                 writefunc(m.group(2))
                 m = re.match(ansire, m.group(3))
         finally:
             # Explicitly reset original attributes
             ui.flush()
             _kernel32.SetConsoleTextAttribute(stdout, origattr)

tests/test-grep.t

@@ -1,533 +1,533 b''
   $ hg init t
   $ cd t
   $ echo import > port
   $ hg add port
   $ hg commit -m 0 -u spam -d '0 0'
   $ echo export >> port
   $ hg commit -m 1 -u eggs -d '1 0'
   $ echo export > port
   $ echo vaportight >> port
   $ echo 'import/export' >> port
   $ hg commit -m 2 -u spam -d '2 0'
   $ echo 'import/export' >> port
   $ hg commit -m 3 -u eggs -d '3 0'
   $ head -n 3 port > port1
   $ mv port1 port
   $ hg commit -m 4 -u spam -d '4 0'
 
 pattern error
 
   $ hg grep '**test**'
   grep: invalid match pattern: nothing to repeat* (glob)
   [1]
 
 simple
 
   $ hg grep -r tip:0 '.*'
   port:4:export
   port:4:vaportight
   port:4:import/export
   $ hg grep -r tip:0 port port
   port:4:export
   port:4:vaportight
   port:4:import/export
 
 simple from subdirectory
 
   $ mkdir dir
   $ cd dir
   $ hg grep -r tip:0 port
   port:4:export
   port:4:vaportight
   port:4:import/export
   $ hg grep -r tip:0 port --config ui.relative-paths=yes
   ../port:4:export
   ../port:4:vaportight
   ../port:4:import/export
   $ cd ..
 
 simple with color
 
   $ hg --config extensions.color= grep --config color.mode=ansi \
   >     --color=always port port -r tip:0
-  \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;32m4\x1b[0m\x1b[0;36m:\x1b[0mex\x1b[0;31;1mport\x1b[0m (esc)
-  \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;32m4\x1b[0m\x1b[0;36m:\x1b[0mva\x1b[0;31;1mport\x1b[0might (esc)
-  \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;32m4\x1b[0m\x1b[0;36m:\x1b[0mim\x1b[0;31;1mport\x1b[0m/ex\x1b[0;31;1mport\x1b[0m (esc)
+  \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m4\x1b[0m\x1b[0;36m:\x1b[0mex\x1b[0;31;1mport\x1b[0m (esc)
+  \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m4\x1b[0m\x1b[0;36m:\x1b[0mva\x1b[0;31;1mport\x1b[0might (esc)
+  \x1b[0;35mport\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m4\x1b[0m\x1b[0;36m:\x1b[0mim\x1b[0;31;1mport\x1b[0m/ex\x1b[0;31;1mport\x1b[0m (esc)
 
 simple templated
 
   $ hg grep port -r tip:0 \
   > -T '{path}:{rev}:{node|short}:{texts % "{if(matched, text|upper, text)}"}\n'
   port:4:914fa752cdea:exPORT
   port:4:914fa752cdea:vaPORTight
   port:4:914fa752cdea:imPORT/exPORT
 
   $ hg grep port -r tip:0 -T '{path}:{rev}:{texts}\n'
   port:4:export
   port:4:vaportight
   port:4:import/export
 
   $ hg grep port -r tip:0 -T '{path}:{tags}:{texts}\n'
   port:tip:export
   port:tip:vaportight
   port:tip:import/export
 
 simple JSON (no "change" field)
 
   $ hg grep -r tip:0 -Tjson port
   [
    {
     "date": [4, 0],
     "lineno": 1,
     "node": "914fa752cdea87777ac1a8d5c858b0c736218f6c",
     "path": "port",
     "rev": 4,
     "texts": [{"matched": false, "text": "ex"}, {"matched": true, "text": "port"}],
     "user": "spam"
    },
    {
     "date": [4, 0],
     "lineno": 2,
     "node": "914fa752cdea87777ac1a8d5c858b0c736218f6c",
     "path": "port",
     "rev": 4,
     "texts": [{"matched": false, "text": "va"}, {"matched": true, "text": "port"}, {"matched": false, "text": "ight"}],
     "user": "spam"
    },
    {
     "date": [4, 0],
     "lineno": 3,
     "node": "914fa752cdea87777ac1a8d5c858b0c736218f6c",
     "path": "port",
     "rev": 4,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}, {"matched": false, "text": "/ex"}, {"matched": true, "text": "port"}],
     "user": "spam"
    }
   ]
 
 simple JSON without matching lines
 
   $ hg grep -r tip:0 -Tjson -l port
   [
    {
     "date": [4, 0],
     "lineno": 1,
     "node": "914fa752cdea87777ac1a8d5c858b0c736218f6c",
     "path": "port",
     "rev": 4,
     "user": "spam"
    }
   ]
 
 all
 
   $ hg grep --traceback --all -nu port port
   port:4:4:-:spam:import/export
   port:3:4:+:eggs:import/export
   port:2:1:-:spam:import
   port:2:2:-:spam:export
   port:2:1:+:spam:export
   port:2:2:+:spam:vaportight
   port:2:3:+:spam:import/export
   port:1:2:+:eggs:export
   port:0:1:+:spam:import
 
 all JSON
 
   $ hg grep --all -Tjson port port
   [
    {
     "change": "-",
     "date": [4, 0],
     "lineno": 4,
     "node": "914fa752cdea87777ac1a8d5c858b0c736218f6c",
     "path": "port",
     "rev": 4,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}, {"matched": false, "text": "/ex"}, {"matched": true, "text": "port"}],
     "user": "spam"
    },
    {
     "change": "+",
     "date": [3, 0],
     "lineno": 4,
     "node": "95040cfd017d658c536071c6290230a613c4c2a6",
     "path": "port",
     "rev": 3,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}, {"matched": false, "text": "/ex"}, {"matched": true, "text": "port"}],
     "user": "eggs"
    },
    {
     "change": "-",
     "date": [2, 0],
     "lineno": 1,
     "node": "3b325e3481a1f07435d81dfdbfa434d9a0245b47",
     "path": "port",
     "rev": 2,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}],
     "user": "spam"
    },
    {
     "change": "-",
     "date": [2, 0],
     "lineno": 2,
     "node": "3b325e3481a1f07435d81dfdbfa434d9a0245b47",
     "path": "port",
     "rev": 2,
     "texts": [{"matched": false, "text": "ex"}, {"matched": true, "text": "port"}],
     "user": "spam"
    },
    {
     "change": "+",
     "date": [2, 0],
     "lineno": 1,
     "node": "3b325e3481a1f07435d81dfdbfa434d9a0245b47",
     "path": "port",
     "rev": 2,
     "texts": [{"matched": false, "text": "ex"}, {"matched": true, "text": "port"}],
     "user": "spam"
    },
    {
     "change": "+",
     "date": [2, 0],
     "lineno": 2,
     "node": "3b325e3481a1f07435d81dfdbfa434d9a0245b47",
     "path": "port",
     "rev": 2,
     "texts": [{"matched": false, "text": "va"}, {"matched": true, "text": "port"}, {"matched": false, "text": "ight"}],
     "user": "spam"
    },
    {
     "change": "+",
     "date": [2, 0],
     "lineno": 3,
     "node": "3b325e3481a1f07435d81dfdbfa434d9a0245b47",
     "path": "port",
     "rev": 2,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}, {"matched": false, "text": "/ex"}, {"matched": true, "text": "port"}],
     "user": "spam"
    },
    {
     "change": "+",
     "date": [1, 0],
     "lineno": 2,
     "node": "8b20f75c158513ff5ac80bd0e5219bfb6f0eb587",
     "path": "port",
     "rev": 1,
     "texts": [{"matched": false, "text": "ex"}, {"matched": true, "text": "port"}],
     "user": "eggs"
    },
    {
     "change": "+",
     "date": [0, 0],
     "lineno": 1,
     "node": "f31323c9217050ba245ee8b537c713ec2e8ab226",
     "path": "port",
     "rev": 0,
     "texts": [{"matched": false, "text": "im"}, {"matched": true, "text": "port"}],
     "user": "spam"
    }
   ]
 
 other
 
   $ hg grep -r tip:0 -l port port
   port:4
   $ hg grep -r tip:0 import port
   port:4:import/export
 
   $ hg cp port port2
   $ hg commit -m 4 -u spam -d '5 0'
 
 follow
 
   $ hg grep -r tip:0 --traceback -f 'import\n\Z' port2
   port:0:import
   
   $ echo deport >> port2
   $ hg commit -m 5 -u eggs -d '6 0'
   $ hg grep -f --all -nu port port2
   port2:6:4:+:eggs:deport
   port:4:4:-:spam:import/export
   port:3:4:+:eggs:import/export
   port:2:1:-:spam:import
   port:2:2:-:spam:export
   port:2:1:+:spam:export
   port:2:2:+:spam:vaportight
   port:2:3:+:spam:import/export
   port:1:2:+:eggs:export
   port:0:1:+:spam:import
 
   $ hg up -q null
   $ hg grep -r 'reverse(:.)' -f port
   port:0:import
 
 Test wdir
 (at least, this shouldn't crash)
 
   $ hg up -q
   $ echo wport >> port2
   $ hg stat
   M port2
   $ hg grep -r 'wdir()' port
   port2:2147483647:export
   port2:2147483647:vaportight
   port2:2147483647:import/export
   port2:2147483647:deport
   port2:2147483647:wport
 
   $ cd ..
   $ hg init t2
   $ cd t2
   $ hg grep -r tip:0 foobar foo
   [1]
   $ hg grep -r tip:0 foobar
   [1]
   $ echo blue >> color
   $ echo black >> color
   $ hg add color
   $ hg ci -m 0
   $ echo orange >> color
   $ hg ci -m 1
   $ echo black > color
   $ hg ci -m 2
   $ echo orange >> color
   $ echo blue >> color
   $ hg ci -m 3
   $ hg grep -r tip:0 orange
   color:3:orange
   $ hg grep --all orange
   color:3:+:orange
   color:2:-:orange
   color:1:+:orange
   $ hg grep --diff orange --color=debug
   [grep.filename|color][grep.sep|:][grep.rev|3][grep.sep|:][grep.inserted grep.change|+][grep.sep|:][grep.match|orange]
   [grep.filename|color][grep.sep|:][grep.rev|2][grep.sep|:][grep.deleted grep.change|-][grep.sep|:][grep.match|orange]
   [grep.filename|color][grep.sep|:][grep.rev|1][grep.sep|:][grep.inserted grep.change|+][grep.sep|:][grep.match|orange]
 
   $ hg grep --diff orange --color=yes
-  \x1b[0;35mcolor\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;32m3\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;32;1m+\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;31;1morange\x1b[0m (esc)
-  \x1b[0;35mcolor\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;32m2\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;31;1m-\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;31;1morange\x1b[0m (esc)
-  \x1b[0;35mcolor\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;32m1\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;32;1m+\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;31;1morange\x1b[0m (esc)
+  \x1b[0;35mcolor\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m3\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;32;1m+\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;31;1morange\x1b[0m (esc)
+  \x1b[0;35mcolor\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m2\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;31;1m-\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;31;1morange\x1b[0m (esc)
+  \x1b[0;35mcolor\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;34m1\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;32;1m+\x1b[0m\x1b[0;36m:\x1b[0m\x1b[0;31;1morange\x1b[0m (esc)
 
   $ hg grep --diff orange
   color:3:+:orange
   color:2:-:orange
   color:1:+:orange
 
 test substring match: '^' should only match at the beginning
 
   $ hg grep -r tip:0 '^.' --config extensions.color= --color debug
   [grep.filename|color][grep.sep|:][grep.rev|3][grep.sep|:][grep.match|b]lack
   [grep.filename|color][grep.sep|:][grep.rev|3][grep.sep|:][grep.match|o]range
   [grep.filename|color][grep.sep|:][grep.rev|3][grep.sep|:][grep.match|b]lue
 
 match in last "line" without newline
 
   $ "$PYTHON" -c 'fp = open("noeol", "wb"); fp.write(b"no infinite loop"); fp.close();'
   $ hg ci -Amnoeol
   adding noeol
   $ hg grep -r tip:0 loop
   noeol:4:no infinite loop
 
   $ cd ..
 
 Issue685: traceback in grep -r after rename
 
 Got a traceback when using grep on a single
 revision with renamed files.
 
   $ hg init issue685
   $ cd issue685
   $ echo octarine > color
   $ hg ci -Amcolor
   adding color
   $ hg rename color colour
   $ hg ci -Am rename
   $ hg grep -r tip:0 octarine
   colour:1:octarine
   color:0:octarine
 
 Used to crash here
 
   $ hg grep -r 1 octarine
   colour:1:octarine
   $ cd ..
 
 
 Issue337: test that grep follows parent-child relationships instead
 of just using revision numbers.
 
   $ hg init issue337
   $ cd issue337
 
   $ echo white > color
   $ hg commit -A -m "0 white"
   adding color
 
   $ echo red > color
   $ hg commit -A -m "1 red"
 
   $ hg update 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo black > color
   $ hg commit -A -m "2 black"
   created new head
 
   $ hg update --clean 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo blue > color
   $ hg commit -A -m "3 blue"
 
   $ hg grep --all red
   color:3:-:red
   color:1:+:red
 
   $ hg grep --diff red
   color:3:-:red
   color:1:+:red
 
 Issue3885: test that changing revision order does not alter the
 revisions printed, just their order.
 
   $ hg grep --all red -r "all()"
   color:1:+:red
   color:3:-:red
 
   $ hg grep --all red -r "reverse(all())"
   color:3:-:red
   color:1:+:red
 
   $ hg grep --diff red -r "all()"
   color:1:+:red
   color:3:-:red
 
   $ hg grep --diff red -r "reverse(all())"
   color:3:-:red
   color:1:+:red
 
   $ cd ..
 
   $ hg init a
   $ cd a
   $ cp "$TESTDIR/binfile.bin" .
   $ hg add binfile.bin
   $ hg ci -m 'add binfile.bin'
   $ hg grep "MaCam" --all
   binfile.bin:0:+: Binary file matches
 
   $ hg grep "MaCam" --diff
   binfile.bin:0:+: Binary file matches
 
   $ cd ..
 
 Test for showing working of allfiles flag
 
   $ hg init sng
   $ cd sng
   $ echo "unmod" >> um
   $ hg ci -A -m "adds unmod to um"
   adding um
   $ echo "something else" >> new
   $ hg ci -A -m "second commit"
   adding new
   $ hg grep -r "." "unmod"
   [1]
   $ hg grep -r "." "unmod" --all-files
   um:1:unmod
 
 With --all-files, the working directory is searched by default
 
   $ echo modified >> new
   $ hg grep --all-files mod
   new:modified
   um:unmod
 
  which can be overridden by -rREV
 
   $ hg grep --all-files -r. mod
   um:1:unmod
 
 commands.all-files can be negated by --no-all-files
 
   $ hg grep --config commands.grep.all-files=True mod
   new:modified
   um:unmod
   $ hg grep --config commands.grep.all-files=True --no-all-files mod
   um:0:unmod
 
 --diff --all-files makes no sense since --diff is the option to grep history
 
   $ hg grep --diff --all-files um
   abort: --diff and --all-files are mutually exclusive
   [255]
 
 but --diff should precede the commands.grep.all-files option
 
   $ hg grep --config commands.grep.all-files=True --diff mod
   um:0:+:unmod
 
   $ cd ..
 
 Fix_Wdir(): test that passing wdir() t -r flag does greps on the
 files modified in the working directory
 
   $ cd a
   $ echo "abracadara" >> a
   $ hg add a
   $ hg grep -r "wdir()" "abra"
   a:2147483647:abracadara
 
   $ cd ..
 
 Change Default of grep by ui.tweakdefaults, that is, the files not in current
 working directory should not be grepp-ed on
 
   $ hg init ab
   $ cd ab
   $ cat <<'EOF' >> .hg/hgrc
   > [ui]
   > tweakdefaults = True
   > EOF
   $ echo "some text">>file1
   $ hg add file1
   $ hg commit -m "adds file1"
   $ hg mv file1 file2
 
 wdir revision is hidden by default:
 
   $ hg grep "some"
   file2:some text
 
 but it should be available in template dict:
 
   $ hg grep "some" -Tjson
   [
    {
     "date": [0, 0],
     "lineno": 1,
     "node": "ffffffffffffffffffffffffffffffffffffffff",
     "path": "file2",
     "rev": 2147483647,
     "texts": [{"matched": true, "text": "some"}, {"matched": false, "text": " text"}],
     "user": "test"
    }
   ]
 
   $ cd ..
 
 test -rMULTIREV with --all-files
 
   $ cd sng
   $ hg rm um
   $ hg commit -m "deletes um"
   $ hg grep -r "0:2" "unmod" --all-files
   um:0:unmod
   um:1:unmod
   $ hg grep -r "0:2" "unmod" --all-files um
   um:0:unmod
   um:1:unmod
   $ hg grep -r "0:2" "unmod" --all-files "glob:**/um" # Check that patterns also work
   um:0:unmod
   um:1:unmod
   $ cd ..