Merge lp:~jelmer/bzr/merge-grep into lp:bzr

[Jelmer Vernooij]

Merge the grep plugin into the core.

Merge the grep plugin into core.

Now updated for tests to pass, and with the ColorFeature moved into bzrlib.tests.features.

[Martin Packman (gz)]

Tests now pass.

Idle query, why don't we use bzr join for things like this?

Don't like moving the colour stuff to bzrlib.termcolor, it's not the interface I think we'll want to be supporting in core long term. Can stick it back under grep or rename to _termcolor so it's clear we don't want other plugins basing output off this interface.

Looks good apart from that.

review: Approve

[Jelmer Vernooij (jelmer)]

This was merged using bzr join.

I've renamed termcolor to _termcolor.

Thanks for the review!

[Martin Packman (gz)]

> This was merged using bzr join.

Well I obviously fail at using blame then...

=== added file 'bzrlib/_termcolor.py'
--- bzrlib/_termcolor.py	1970-01-01 00:00:00 +0000
+++ bzrlib/_termcolor.py	2012-08-23 15:07:23 +0000
@@ -0,0 +1,78 @@
+# Copyright (C) 2010 Canonical Ltd
+#
+# 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
+
+from __future__ import absolute_import
+
+import os
+import sys
+
+
+class FG(object):
+    """Unix terminal foreground color codes (16-color)."""
+    RED = '\033[31m'
+    GREEN = '\033[32m'
+    YELLOW = '\033[33m'
+    BLUE = '\033[34m'
+    MAGENTA = '\033[35m'
+    CYAN = '\033[36m'
+    WHITE = '\033[37m'
+
+    # Bold Foreground
+    BOLD_RED = '\033[1;31m'
+    BOLD_GREEN = '\033[1;32m'
+    BOLD_YELLOW = '\033[1;33m'
+    BOLD_BLUE = '\033[1;34m'
+    BOLD_MAGENTA = '\033[1;35m'
+    BOLD_CYAN = '\033[1;36m'
+    BOLD_WHITE = '\033[1;37m'
+
+    NONE = '\033[0m'
+
+
+class BG(object):
+    """Unix terminal background color codes (16-color)."""
+    BLACK = '\033[40m'
+    RED = '\033[41m'
+    GREEN = '\033[42m'
+    YELLOW = '\033[43m'
+    BLUE = '\033[44m'
+    MAGENTA = '\033[45m'
+    CYAN = '\033[46m'
+    WHITE = '\033[47m'
+
+    NONE = '\033[0m'
+
+
+def color_string(s, fg, bg=''):
+    return fg + bg + s + FG.NONE
+
+
+def re_color_string(compiled_pattern, s, fg):
+    return compiled_pattern.sub(fg + r'\1' + FG.NONE, s)
+
+
+def allow_color():
+    if os.name != 'posix':
+        return False
+    if not sys.stdout.isatty():
+        return False
+    try:
+        import curses
+        curses.setupterm()
+        return curses.tigetnum('colors') > 2
+    except curses.error:
+        return False
+
 
=== added directory 'bzrlib/plugins/grep'
=== added file 'bzrlib/plugins/grep/.bzrignore'
--- bzrlib/plugins/grep/.bzrignore	1970-01-01 00:00:00 +0000
+++ bzrlib/plugins/grep/.bzrignore	2012-08-23 15:07:23 +0000
@@ -0,0 +1,1 @@
+./build
 
=== added file 'bzrlib/plugins/grep/NEWS'
--- bzrlib/plugins/grep/NEWS	1970-01-01 00:00:00 +0000
+++ bzrlib/plugins/grep/NEWS	2012-08-23 15:07:23 +0000
@@ -0,0 +1,73 @@
+This is the NEWS file from bzr-grep from before it was merged into bzr core.
+For changes before then, please refer to the main bzr log file.
+
+bzr-grep 0.5.0-final - Unreleased
+==================================
+* ``bzr grep`` now supports ``--diff|-p`` option to search through
+  changesets. (Parth Malwankar, #540705)
+
+* Option ``grep_color`` can be set in ``bazaar.conf`` instead of using
+  the option ``--color`` from the command line. (Johan Dahlin)
+
+bzr-grep 0.4.0-final - 08-Jun-2010
+==================================
+* Add seperate output formatter to reduce duplication of search loops,
+  additionally make -Fi use regexp rather than lowercasing pattern and
+  entirety of text for the same reason. This also fixes bug #590589
+  - UnicodeDecodeError with options -Fi. (Martin [gz])
+
+* Added fast path for no match that avoids splitting the file text into
+  seperate lines and testing each one, by checking the entire text for a
+  possible match initially. (Martin [gz])
+
+* Added Makefile. (Parth Malwankar)
+
+* Fixed setup.py to work correctly. (Martin [gz])
+
+bzr-grep 0.3.0-final - 23-May-2010
+==================================
+* Support for --color option (POSIX only). (Parth Malwankar, #571694)
+
+* Revisions in branches without trees can now be searched with
+  -r option. (Parth Malwankar, #584240)
+
+* Trying to search working tree for a treeless branch no longer
+  produces a stack trace but gives an error message suggesting use of
+  -r option. (Parth Malwankar, #572658)
+
+bzr-grep 0.2.0-final - 30-Mar-2010
+==================================
+* 'binary file skipped' warning is not shows without --verbose flag
+  (Parth Malwankar, #539031)
+
+* Added support for -F/--fixed-string for faster search.
+  Simple patterns [a-zA-Z0-9 _] are now implicitly -F and searched faster.
+  (Parth Malwankar, #539263)
+
+* Better unicode handling. bzr-grep no longer crashes with UnicodeDecode
+  error for some outputs. (Parth Malwankar, #539258)
+
+* Faster grep for revision range. bzr-grep now caches results for
+  files that have not changed between revisions.
+  (Parth Malwankar, #542375)
+
+* Faster grep for specific revision. (Parth Malwankar, #539429)
+
+* Significant performance improvement. Working tree grep for bzr.dev
+  has gone from ~7.5s to ~1s. (Parth Malwankar, #539028)
+
+* Support for -L/--files-without-match and -l/files-with-matches
+  (Parth Malwankar, #540097)
+
+bzr-grep 0.1.0-final - 14-Mar-2010
+==================================
+* --recursive is now default. (Parth Malwankar, #536688)
+
+* ``bzr grep`` searches working copy by default. (Parth Malwankar, #537072)
+
+* --include/exclude=GLOB is now supported. (Parth Malwankar, #529889)
+
+bzr-grep 0.0.1-final - 10-Mar-2010
+==================================
+* Initial release (Parth Malwankar)
+
 
=== added file 'bzrlib/plugins/grep/__init__.py'
--- bzrlib/plugins/grep/__init__.py	1970-01-01 00:00:00 +0000
+++ bzrlib/plugins/grep/__init__.py	2012-08-23 15:07:23 +0000
@@ -0,0 +1,38 @@
+# Copyright (C) 2010 Canonical Ltd
+#
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+"""Print lines matching PATTERN for specified files and revisions."""
+
+from __future__ import absolute_import
+
+from bzrlib import version_info
+from bzrlib.commands import plugin_cmds
+
+plugin_cmds.register_lazy("cmd_grep", [], "bzrlib.plugins.grep.cmds")
+
+def test_suite():
+    from bzrlib.tests import TestUtil
+
+    suite = TestUtil.TestSuite()
+    loader = TestUtil.TestLoader()
+    testmod_names = [
+        'test_grep',
+        ]
+
+    suite.addTest(loader.loadTestsFromModuleNames(
+            ["%s.%s" % (__name__, tmn) for tmn in testmod_names]))
+    return suite
+
 
=== added file 'bzrlib/plugins/grep/cmds.py'
--- bzrlib/plugins/grep/cmds.py	1970-01-01 00:00:00 +0000
+++ bzrlib/plugins/grep/cmds.py	2012-08-23 15:07:23 +0000
@@ -0,0 +1,249 @@
+# Copyright (C) 2010 Canonical Ltd
+#
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+"""Print lines matching PATTERN for specified files and revisions."""
+
+from __future__ import absolute_import
+
+from bzrlib import errors
+from bzrlib.commands import Command, display_command
+from bzrlib.option import Option, ListOption
+from bzrlib.config import GlobalConfig
+
+# FIXME: _parse_levels should be shared with bzrlib.builtins. this is a copy
+# to avoid the error
+#   "IllegalUseOfScopeReplacer: ScopeReplacer object '_parse_levels' was used
+#   incorrectly: Object already cleaned up, did you assign it to another
+#   variable?: _factory
+# with lazy import
+def _parse_levels(s):
+    try:
+        return int(s)
+    except ValueError:
+        msg = "The levels argument must be an integer."
+        raise errors.BzrCommandError(msg)
+
+
+class GrepOptions(object):
+    """Container to pass around grep options.
+
+    This class is used as a container to pass around user option and
+    some other params (like outf) to processing functions. This makes
+    it easier to add more options as grep evolves.
+    """
+    verbose = False
+    ignore_case = False
+    no_recursive = False
+    from_root = False
+    null = False
+    levels = None
+    line_number = False
+    path_list = None
+    revision = None
+    pattern = None
+    include = None
+    exclude = None
+    fixed_string = False
+    files_with_matches = False
+    files_without_match = False
+    color = None
+    diff = False
+
+    # derived options
+    recursive = None
+    eol_marker = None
+    patternc = None
+    sub_patternc = None
+    print_revno = None
+    fixed_string = None
+    outf = None
+    show_color = False
+
+
+class cmd_grep(Command):
+    """Print lines matching PATTERN for specified files and revisions.
+
+    This command searches the specified files and revisions for a given
+    pattern.  The pattern is specified as a Python regular expressions[1].
+
+    If the file name is not specified, the revisions starting with the
+    current directory are searched recursively. If the revision number is
+    not specified, the working copy is searched. To search the last committed
+    revision, use the '-r -1' or '-r last:1' option.
+
+    Unversioned files are not searched unless explicitly specified on the
+    command line. Unversioned directores are not searched.
+
+    When searching a pattern, the output is shown in the 'filepath:string'
+    format. If a revision is explicitly searched, the output is shown as
+    'filepath~N:string', where N is the revision number.
+
+    --include and --exclude options can be used to search only (or exclude
+    from search) files with base name matches the specified Unix style GLOB
+    pattern.  The GLOB pattern an use *, ?, and [...] as wildcards, and \\
+    to quote wildcard or backslash character literally. Note that the glob
+    pattern is not a regular expression.
+
+    [1] http://docs.python.org/library/re.html#regular-expression-syntax
+    """
+
+    encoding_type = 'replace'
+    takes_args = ['pattern', 'path*']
+    takes_options = [
+        'verbose',
+        'revision',
+        Option('color', type=str, argname='when',
+               help='Show match in color. WHEN is never, always or auto.'),
+        Option('diff', short_name='p',
+               help='Grep for pattern in changeset for each revision.'),
+        ListOption('exclude', type=str, argname='glob', short_name='X',
+            help="Skip files whose base name matches GLOB."),
+        ListOption('include', type=str, argname='glob', short_name='I',
+            help="Search only files whose base name matches GLOB."),
+        Option('files-with-matches', short_name='l',
+               help='Print only the name of each input file in '
+               'which PATTERN is found.'),
+        Option('files-without-match', short_name='L',
+               help='Print only the name of each input file in '
+               'which PATTERN is not found.'),
+        Option('fixed-string', short_name='F',
+               help='Interpret PATTERN is a single fixed string (not regex).'),
+        Option('from-root',
+               help='Search for pattern starting from the root of the branch. '
+               '(implies --recursive)'),
+        Option('ignore-case', short_name='i',
+               help='ignore case distinctions while matching.'),
+        Option('levels',
+           help='Number of levels to display - 0 for all, 1 for collapsed '
+           '(1 is default).',
+           argname='N',
+           type=_parse_levels),
+        Option('line-number', short_name='n',
+               help='show 1-based line number.'),
+        Option('no-recursive',
+               help="Don't recurse into subdirectories. (default is --recursive)"),
+        Option('null', short_name='Z',
+               help='Write an ASCII NUL (\\0) separator '
+               'between output lines rather than a newline.'),
+        ]
+
+
+    @display_command
+    def run(self, verbose=False, ignore_case=False, no_recursive=False,
+            from_root=False, null=False, levels=None, line_number=False,
+            path_list=None, revision=None, pattern=None, include=None,
+            exclude=None, fixed_string=False, files_with_matches=False,
+            files_without_match=False, color=None, diff=False):
+        from bzrlib import _termcolor
+        from bzrlib.plugins.grep import (
+            grep,
+            )
+        import re
+        if path_list is None:
+            path_list = ['.']
+        else:
+            if from_root:
+                raise errors.BzrCommandError('cannot specify both --from-root and PATH.')
+
+        if files_with_matches and files_without_match:
+            raise errors.BzrCommandError('cannot specify both '
+                '-l/--files-with-matches and -L/--files-without-matches.')
+
+        global_config = GlobalConfig()
+
+        if color is None:
+            color = global_config.get_user_option('grep_color')
+
+        if color is None:
+            color = 'never'
+
+        if color not in ['always', 'never', 'auto']:
+            raise errors.BzrCommandError('Valid values for --color are '
+                '"always", "never" or "auto".')
+
+        if levels==None:
+            levels=1
+
+        print_revno = False
+        if revision != None or levels == 0:
+            # print revision numbers as we may be showing multiple revisions
+            print_revno = True
+
+        eol_marker = '\n'
+        if null:
+            eol_marker = '\0'
+
+        if not ignore_case and grep.is_fixed_string(pattern):
+            # if the pattern isalnum, implicitly use to -F for faster grep
+            fixed_string = True
+        elif ignore_case and fixed_string:
+            # GZ 2010-06-02: Fall back to regexp rather than lowercasing
+            #                pattern and text which will cause pain later
+            fixed_string = False
+            pattern = re.escape(pattern)
+
+        patternc = None
+        re_flags = re.MULTILINE
+        if ignore_case:
+            re_flags |= re.IGNORECASE
+
+        if not fixed_string:
+            patternc = grep.compile_pattern(pattern, re_flags)
+
+        if color == 'always':
+            show_color = True
+        elif color == 'never':
+            show_color = False
+        elif color == 'auto':
+            show_color = _termcolor.allow_color()
+
+        GrepOptions.verbose = verbose
+        GrepOptions.ignore_case = ignore_case
+        GrepOptions.no_recursive = no_recursive
+        GrepOptions.from_root = from_root
+        GrepOptions.null = null
+        GrepOptions.levels = levels
+        GrepOptions.line_number = line_number
+        GrepOptions.path_list = path_list
+        GrepOptions.revision = revision
+        GrepOptions.pattern = pattern
+        GrepOptions.include = include
+        GrepOptions.exclude = exclude
+        GrepOptions.fixed_string = fixed_string
+        GrepOptions.files_with_matches = files_with_matches
+        GrepOptions.files_without_match = files_without_match
+        GrepOptions.color = color
+        GrepOptions.diff = False
+
+        GrepOptions.eol_marker = eol_marker
+        GrepOptions.print_revno = print_revno
+        GrepOptions.patternc = patternc
+        GrepOptions.recursive = not no_recursive
+        GrepOptions.fixed_string = fixed_string
+        GrepOptions.outf = self.outf
+        GrepOptions.show_color = show_color
+
+        if diff:
+            # options not used:
+            # files_with_matches, files_without_match
+            # levels(?), line_number, from_root
+            # include, exclude
+            # These are silently ignored.
+            grep.grep_diff(GrepOptions)
+        elif revision is None:
+            grep.workingtree_grep(GrepOptions)
+        else:
+            grep.versioned_grep(GrepOptions)
 
=== added file 'bzrlib/plugins/grep/grep.py'
--- bzrlib/plugins/grep/grep.py	1970-01-01 00:00:00 +0000
+++ bzrlib/plugins/grep/grep.py	2012-08-23 15:07:23 +0000
@@ -0,0 +1,728 @@
+# Copyright (C) 2010 Canonical Ltd
+#
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+from __future__ import absolute_import
+
+import sys
+
+from bzrlib.lazy_import import lazy_import
+lazy_import(globals(), """
+from fnmatch import fnmatch
+import re
+from cStringIO import StringIO
+
+from bzrlib._termcolor import color_string, re_color_string, FG
+
+from bzrlib.revisionspec import (
+    RevisionSpec,
+    RevisionSpec_revid,
+    RevisionSpec_revno,
+    )
+from bzrlib import (
+    bzrdir,
+    diff,
+    errors,
+    lazy_regex,
+    osutils,
+    revision as _mod_revision,
+    trace,
+    )
+""")
+
+_user_encoding = osutils.get_user_encoding()
+
+
+class _RevisionNotLinear(Exception):
+    """Raised when a revision is not on left-hand history."""
+
+
+def _rev_on_mainline(rev_tuple):
+    """returns True is rev tuple is on mainline"""
+    if len(rev_tuple) == 1:
+        return True
+    return rev_tuple[1] == 0 and rev_tuple[2] == 0
+
+
+# NOTE: _linear_view_revisions is basided on
+# bzrlib.log._linear_view_revisions.
+# This should probably be a common public API
+def _linear_view_revisions(branch, start_rev_id, end_rev_id):
+    # requires that start is older than end
+    repo = branch.repository
+    graph = repo.get_graph()
+    for revision_id in graph.iter_lefthand_ancestry(
+            end_rev_id, (_mod_revision.NULL_REVISION, )):
+        revno = branch.revision_id_to_dotted_revno(revision_id)
+        revno_str = '.'.join(str(n) for n in revno)
+        if revision_id == start_rev_id:
+            yield revision_id, revno_str, 0
+            break
+        yield revision_id, revno_str, 0
+
+
+# NOTE: _graph_view_revisions is copied from
+# bzrlib.log._graph_view_revisions.
+# This should probably be a common public API
+def _graph_view_revisions(branch, start_rev_id, end_rev_id,
+                          rebase_initial_depths=True):
+    """Calculate revisions to view including merges, newest to oldest.
+
+    :param branch: the branch
+    :param start_rev_id: the lower revision-id
+    :param end_rev_id: the upper revision-id
+    :param rebase_initial_depth: should depths be rebased until a mainline
+      revision is found?
+    :return: An iterator of (revision_id, dotted_revno, merge_depth) tuples.
+    """
+    # requires that start is older than end
+    view_revisions = branch.iter_merge_sorted_revisions(
+        start_revision_id=end_rev_id, stop_revision_id=start_rev_id,
+        stop_rule="with-merges")
+    if not rebase_initial_depths:
+        for (rev_id, merge_depth, revno, end_of_merge
+             ) in view_revisions:
+            yield rev_id, '.'.join(map(str, revno)), merge_depth
+    else:
+        # We're following a development line starting at a merged revision.
+        # We need to adjust depths down by the initial depth until we find
+        # a depth less than it. Then we use that depth as the adjustment.
+        # If and when we reach the mainline, depth adjustment ends.
+        depth_adjustment = None
+        for (rev_id, merge_depth, revno, end_of_merge
+             ) in view_revisions:
+            if depth_adjustment is None:
+                depth_adjustment = merge_depth
+            if depth_adjustment:
+                if merge_depth < depth_adjustment:
+                    # From now on we reduce the depth adjustement, this can be
+                    # surprising for users. The alternative requires two passes
+                    # which breaks the fast display of the first revision
+                    # though.
+                    depth_adjustment = merge_depth
+                merge_depth -= depth_adjustment
+            yield rev_id, '.'.join(map(str, revno)), merge_depth
+
+
+def compile_pattern(pattern, flags=0):
+    patternc = None
+    try:
+        # use python's re.compile as we need to catch re.error in case of bad pattern
+        lazy_regex.reset_compile()
+        patternc = re.compile(pattern, flags)
+    except re.error, e:
+        raise errors.BzrError("Invalid pattern: '%s'" % pattern)
+    return patternc
+
+
+def is_fixed_string(s):
+    if re.match("^([A-Za-z0-9_]|\s)*$", s):
+        return True
+    return False
+
+
+class _GrepDiffOutputter(object):
+    """Precalculate formatting based on options given for diff grep.
+    """
+
+    def __init__(self, opts):
+        self.opts = opts
+        self.outf = opts.outf
+        if opts.show_color:
+            pat = opts.pattern.encode(_user_encoding, 'replace')
+            if opts.fixed_string:
+                self._old = pat
+                self._new = color_string(pat, FG.BOLD_RED)
+                self.get_writer = self._get_writer_fixed_highlighted
+            else:
+                flags = opts.patternc.flags
+                self._sub = re.compile(pat.join(("((?:",")+)")), flags).sub
+                self._highlight = color_string("\\1", FG.BOLD_RED)
+                self.get_writer = self._get_writer_regexp_highlighted
+        else:
+            self.get_writer = self._get_writer_plain
+
+    def get_file_header_writer(self):
+        """Get function for writing file headers"""
+        write = self.outf.write
+        eol_marker = self.opts.eol_marker
+        def _line_writer(line):
+            write(line + eol_marker)
+        def _line_writer_color(line):
+            write(FG.BOLD_MAGENTA + line + FG.NONE + eol_marker)
+        if self.opts.show_color:
+            return _line_writer_color
+        else:
+            return _line_writer
+        return _line_writer
+
+    def get_revision_header_writer(self):
+        """Get function for writing revno lines"""
+        write = self.outf.write
+        eol_marker = self.opts.eol_marker
+        def _line_writer(line):
+            write(line + eol_marker)
+        def _line_writer_color(line):
+            write(FG.BOLD_BLUE + line + FG.NONE + eol_marker)
+        if self.opts.show_color:
+            return _line_writer_color
+        else:
+            return _line_writer
+        return _line_writer
+
+    def _get_writer_plain(self):
+        """Get function for writing uncoloured output"""
+        write = self.outf.write
+        eol_marker = self.opts.eol_marker
+        def _line_writer(line):
+            write(line + eol_marker)
+        return _line_writer
+
+    def _get_writer_regexp_highlighted(self):
+        """Get function for writing output with regexp match highlighted"""
+        _line_writer = self._get_writer_plain()
+        sub, highlight = self._sub, self._highlight
+        def _line_writer_regexp_highlighted(line):
+            """Write formatted line with matched pattern highlighted"""
+            return _line_writer(line=sub(highlight, line))
+        return _line_writer_regexp_highlighted
+
+    def _get_writer_fixed_highlighted(self):
+        """Get function for writing output with search string highlighted"""
+        _line_writer = self._get_writer_plain()
+        old, new = self._old, self._new
+        def _line_writer_fixed_highlighted(line):
+            """Write formatted line with string searched for highlighted"""
+            return _line_writer(line=line.replace(old, new))
+        return _line_writer_fixed_highlighted
+
+
+def grep_diff(opts):
+    wt, branch, relpath = \
+        bzrdir.BzrDir.open_containing_tree_or_branch('.')
+    branch.lock_read()
+    try:
+        if opts.revision:
+            start_rev = opts.revision[0]
+        else:
+            # if no revision is sepcified for diff grep we grep all changesets.
+            opts.revision = [RevisionSpec.from_string('revno:1'),
+                RevisionSpec.from_string('last:1')]
+            start_rev = opts.revision[0]
+        start_revid = start_rev.as_revision_id(branch)
+        if start_revid == 'null:':
+            return
+        srevno_tuple = branch.revision_id_to_dotted_revno(start_revid)
+        if len(opts.revision) == 2:
+            end_rev = opts.revision[1]
+            end_revid = end_rev.as_revision_id(branch)
+            if end_revid is None:
+                end_revno, end_revid = branch.last_revision_info()
+            erevno_tuple = branch.revision_id_to_dotted_revno(end_revid)
+
+            grep_mainline = (_rev_on_mainline(srevno_tuple) and
+                _rev_on_mainline(erevno_tuple))
+
+            # ensure that we go in reverse order
+            if srevno_tuple > erevno_tuple:
+                srevno_tuple, erevno_tuple = erevno_tuple, srevno_tuple
+                start_revid, end_revid = end_revid, start_revid
+
+            # Optimization: Traversing the mainline in reverse order is much
+            # faster when we don't want to look at merged revs. We try this
+            # with _linear_view_revisions. If all revs are to be grepped we
+            # use the slower _graph_view_revisions
+            if opts.levels==1 and grep_mainline:
+                given_revs = _linear_view_revisions(branch, start_revid, end_revid)
+            else:
+                given_revs = _graph_view_revisions(branch, start_revid, end_revid)
+        else:
+            # We do an optimization below. For grepping a specific revison
+            # We don't need to call _graph_view_revisions which is slow.
+            # We create the start_rev_tuple for only that specific revision.
+            # _graph_view_revisions is used only for revision range.
+            start_revno = '.'.join(map(str, srevno_tuple))
+            start_rev_tuple = (start_revid, start_revno, 0)
+            given_revs = [start_rev_tuple]
+        repo = branch.repository
+        diff_pattern = re.compile("^[+\-].*(" + opts.pattern + ")")
+        file_pattern = re.compile("=== (modified|added|removed) file '.*'", re.UNICODE)
+        outputter = _GrepDiffOutputter(opts)
+        writeline = outputter.get_writer()
+        writerevno = outputter.get_revision_header_writer()
+        writefileheader = outputter.get_file_header_writer()
+        file_encoding = _user_encoding
+        for revid, revno, merge_depth in given_revs:
+            if opts.levels == 1 and merge_depth != 0:
+                # with level=1 show only top level
+                continue
+
+            rev_spec = RevisionSpec_revid.from_string("revid:"+revid)
+            new_rev = repo.get_revision(revid)
+            new_tree = rev_spec.as_tree(branch)
+            if len(new_rev.parent_ids) == 0:
+                ancestor_id = _mod_revision.NULL_REVISION
+            else:
+                ancestor_id = new_rev.parent_ids[0]
+            old_tree = repo.revision_tree(ancestor_id)
+            s = StringIO()
+            diff.show_diff_trees(old_tree, new_tree, s,
+                old_label='', new_label='')
+            display_revno = True
+            display_file = False
+            file_header = None
+            text = s.getvalue()
+            for line in text.splitlines():
+                if file_pattern.search(line):
+                    file_header = line
+                    display_file = True
+                elif diff_pattern.search(line):
+                    if display_revno:
+                        writerevno("=== revno:%s ===" % (revno,))
+                        display_revno = False
+                    if display_file:
+                        writefileheader("  %s" % (file_header,))
+                        display_file = False
+                    line = line.decode(file_encoding, 'replace')
+                    writeline("    %s" % (line,))
+    finally:
+        branch.unlock()
+
+
+def versioned_grep(opts):
+    wt, branch, relpath = \
+        bzrdir.BzrDir.open_containing_tree_or_branch('.')
+    branch.lock_read()
+    try:
+        start_rev = opts.revision[0]
+        start_revid = start_rev.as_revision_id(branch)
+        if start_revid is None:
+            start_rev = RevisionSpec_revno.from_string("revno:1")
+            start_revid = start_rev.as_revision_id(branch)
+        srevno_tuple = branch.revision_id_to_dotted_revno(start_revid)
+
+        if len(opts.revision) == 2:
+            end_rev = opts.revision[1]
+            end_revid = end_rev.as_revision_id(branch)
+            if end_revid is None:
+                end_revno, end_revid = branch.last_revision_info()
+            erevno_tuple = branch.revision_id_to_dotted_revno(end_revid)
+
+            grep_mainline = (_rev_on_mainline(srevno_tuple) and
+                _rev_on_mainline(erevno_tuple))
+
+            # ensure that we go in reverse order
+            if srevno_tuple > erevno_tuple:
+                srevno_tuple, erevno_tuple = erevno_tuple, srevno_tuple
+                start_revid, end_revid = end_revid, start_revid
+
+            # Optimization: Traversing the mainline in reverse order is much
+            # faster when we don't want to look at merged revs. We try this
+            # with _linear_view_revisions. If all revs are to be grepped we
+            # use the slower _graph_view_revisions
+            if opts.levels == 1 and grep_mainline:
+                given_revs = _linear_view_revisions(branch, start_revid, end_revid)
+            else:
+                given_revs = _graph_view_revisions(branch, start_revid, end_revid)
+        else:
+            # We do an optimization below. For grepping a specific revison
+            # We don't need to call _graph_view_revisions which is slow.
+            # We create the start_rev_tuple for only that specific revision.
+            # _graph_view_revisions is used only for revision range.
+            start_revno = '.'.join(map(str, srevno_tuple))
+            start_rev_tuple = (start_revid, start_revno, 0)
+            given_revs = [start_rev_tuple]
+
+        # GZ 2010-06-02: Shouldn't be smuggling this on opts, but easy for now
+        opts.outputter = _Outputter(opts, use_cache=True)
+
+        for revid, revno, merge_depth in given_revs:
+            if opts.levels == 1 and merge_depth != 0:
+                # with level=1 show only top level
+                continue
+
+            rev = RevisionSpec_revid.from_string("revid:"+revid)
+            tree = rev.as_tree(branch)
+            for path in opts.path_list:
+                path_for_id = osutils.pathjoin(relpath, path)
+                id = tree.path2id(path_for_id)
+                if not id:
+                    trace.warning("Skipped unknown file '%s'." % path)
+                    continue
+
+                if osutils.isdir(path):
+                    path_prefix = path
+                    dir_grep(tree, path, relpath, opts, revno, path_prefix)
+                else:
+                    versioned_file_grep(tree, id, '.', path, opts, revno)
+    finally:
+        branch.unlock()
+
+
+def workingtree_grep(opts):
+    revno = opts.print_revno = None # for working tree set revno to None
+
+    tree, branch, relpath = \
+        bzrdir.BzrDir.open_containing_tree_or_branch('.')
+    if not tree:
+        msg = ('Cannot search working tree. Working tree not found.\n'
+            'To search for specific revision in history use the -r option.')
+        raise errors.BzrCommandError(msg)
+
+    # GZ 2010-06-02: Shouldn't be smuggling this on opts, but easy for now
+    opts.outputter = _Outputter(opts)
+
+    tree.lock_read()
+    try:
+        for path in opts.path_list:
+            if osutils.isdir(path):
+                path_prefix = path
+                dir_grep(tree, path, relpath, opts, revno, path_prefix)
+            else:
+                _file_grep(open(path).read(), path, opts, revno)
+    finally:
+        tree.unlock()
+
+
+def _skip_file(include, exclude, path):
+    if include and not _path_in_glob_list(path, include):
+        return True
+    if exclude and _path_in_glob_list(path, exclude):
+        return True
+    return False
+
+
+def dir_grep(tree, path, relpath, opts, revno, path_prefix):
+    # setup relpath to open files relative to cwd
+    rpath = relpath
+    if relpath:
+        rpath = osutils.pathjoin('..',relpath)
+
+    from_dir = osutils.pathjoin(relpath, path)
+    if opts.from_root:
+        # start searching recursively from root
+        from_dir=None
+        recursive=True
+
+    to_grep = []
+    to_grep_append = to_grep.append
+    # GZ 2010-06-05: The cache dict used to be recycled every call to dir_grep
+    #                and hits manually refilled. Could do this again if it was
+    #                for a good reason, otherwise cache might want purging.
+    outputter = opts.outputter
+    for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
+        from_dir=from_dir, recursive=opts.recursive):
+
+        if _skip_file(opts.include, opts.exclude, fp):
+            continue
+
+        if fc == 'V' and fkind == 'file':
+            if revno != None:
+                # If old result is valid, print results immediately.
+                # Otherwise, add file info to to_grep so that the
+                # loop later will get chunks and grep them
+                cache_id = tree.get_file_revision(fid)
+                if cache_id in outputter.cache:
+                    # GZ 2010-06-05: Not really sure caching and re-outputting
+                    #                the old path is really the right thing,
+                    #                but it's what the old code seemed to do
+                    outputter.write_cached_lines(cache_id, revno)
+                else:
+                    to_grep_append((fid, (fp, fid)))
+            else:
+                # we are grepping working tree.
+                if from_dir is None:
+                    from_dir = '.'
+
+                path_for_file = osutils.pathjoin(tree.basedir, from_dir, fp)
+                if opts.files_with_matches or opts.files_without_match:
+                    # Optimize for wtree list-only as we don't need to read the
+                    # entire file
+                    file = open(path_for_file, 'r', buffering=4096)
+                    _file_grep_list_only_wtree(file, fp, opts, path_prefix)
+                else:
+                    file_text = open(path_for_file, 'r').read()
+                    _file_grep(file_text, fp, opts, revno, path_prefix)
+
+    if revno != None: # grep versioned files
+        for (path, fid), chunks in tree.iter_files_bytes(to_grep):
+            path = _make_display_path(relpath, path)
+            _file_grep(chunks[0], path, opts, revno, path_prefix,
+                tree.get_file_revision(fid, path))
+
+
+def _make_display_path(relpath, path):
+    """Return path string relative to user cwd.
+
+    Take tree's 'relpath' and user supplied 'path', and return path
+    that can be displayed to the user.
+    """
+    if relpath:
+        # update path so to display it w.r.t cwd
+        # handle windows slash separator
+        path = osutils.normpath(osutils.pathjoin(relpath, path))
+        path = path.replace('\\', '/')
+        path = path.replace(relpath + '/', '', 1)
+    return path
+
+
+def versioned_file_grep(tree, id, relpath, path, opts, revno, path_prefix = None):
+    """Create a file object for the specified id and pass it on to _file_grep.
+    """
+
+    path = _make_display_path(relpath, path)
+    file_text = tree.get_file_text(id)
+    _file_grep(file_text, path, opts, revno, path_prefix)
+
+
+def _path_in_glob_list(path, glob_list):
+    for glob in glob_list:
+        if fnmatch(path, glob):
+            return True
+    return False
+
+
+def _file_grep_list_only_wtree(file, path, opts, path_prefix=None):
+    # test and skip binary files
+    if '\x00' in file.read(1024):
+        if opts.verbose:
+            trace.warning("Binary file '%s' skipped." % path)
+        return
+
+    file.seek(0) # search from beginning
+
+    found = False
+    if opts.fixed_string:
+        pattern = opts.pattern.encode(_user_encoding, 'replace')
+        for line in file:
+            if pattern in line:
+                found = True
+                break
+    else: # not fixed_string
+        for line in file:
+            if opts.patternc.search(line):
+                found = True
+                break
+
+    if (opts.files_with_matches and found) or \
+        (opts.files_without_match and not found):
+        if path_prefix and path_prefix != '.':
+            # user has passed a dir arg, show that as result prefix
+            path = osutils.pathjoin(path_prefix, path)
+        opts.outputter.get_writer(path, None, None)()
+
+
+class _Outputter(object):
+    """Precalculate formatting based on options given
+
+    The idea here is to do this work only once per run, and finally return a
+    function that will do the minimum amount possible for each match.
+    """
+    def __init__(self, opts, use_cache=False):
+        self.outf = opts.outf
+        if use_cache:
+            # self.cache is used to cache results for dir grep based on fid.
+            # If the fid is does not change between results, it means that
+            # the result will be the same apart from revno. In such a case
+            # we avoid getting file chunks from repo and grepping. The result
+            # is just printed by replacing old revno with new one.
+            self.cache = {}
+        else:
+            self.cache = None
+        no_line = opts.files_with_matches or opts.files_without_match
+
+        if opts.show_color:
+            pat = opts.pattern.encode(_user_encoding, 'replace')
+            if no_line:
+                self.get_writer = self._get_writer_plain
+            elif opts.fixed_string:
+                self._old = pat
+                self._new = color_string(pat, FG.BOLD_RED)
+                self.get_writer = self._get_writer_fixed_highlighted
+            else:
+                flags = opts.patternc.flags
+                self._sub = re.compile(pat.join(("((?:",")+)")), flags).sub
+                self._highlight = color_string("\\1", FG.BOLD_RED)
+                self.get_writer = self._get_writer_regexp_highlighted
+            path_start = FG.MAGENTA
+            path_end = FG.NONE
+            sep = color_string(':', FG.BOLD_CYAN)
+            rev_sep = color_string('~', FG.BOLD_YELLOW)
+        else:
+            self.get_writer = self._get_writer_plain
+            path_start = path_end = ""
+            sep = ":"
+            rev_sep = "~"
+
+        parts = [path_start, "%(path)s"]
+        if opts.print_revno:
+            parts.extend([rev_sep, "%(revno)s"])
+        self._format_initial = "".join(parts)
+        parts = []
+        if no_line:
+            if not opts.print_revno:
+                parts.append(path_end)
+        else:
+            if opts.line_number:
+                parts.extend([sep, "%(lineno)s"])
+            parts.extend([sep, "%(line)s"])
+        parts.append(opts.eol_marker)
+        self._format_perline = "".join(parts)
+
+    def _get_writer_plain(self, path, revno, cache_id):
+        """Get function for writing uncoloured output"""
+        per_line = self._format_perline
+        start = self._format_initial % {"path":path, "revno":revno}
+        write = self.outf.write
+        if self.cache is not None and cache_id is not None:
+            result_list = []
+            self.cache[cache_id] = path, result_list
+            add_to_cache = result_list.append
+            def _line_cache_and_writer(**kwargs):
+                """Write formatted line and cache arguments"""
+                end = per_line % kwargs
+                add_to_cache(end)
+                write(start + end)
+            return _line_cache_and_writer
+        def _line_writer(**kwargs):
+            """Write formatted line from arguments given by underlying opts"""
+            write(start + per_line % kwargs)
+        return _line_writer
+
+    def write_cached_lines(self, cache_id, revno):
+        """Write cached results out again for new revision"""
+        cached_path, cached_matches = self.cache[cache_id]
+        start = self._format_initial % {"path":cached_path, "revno":revno}
+        write = self.outf.write
+        for end in cached_matches:
+            write(start + end)
+
+    def _get_writer_regexp_highlighted(self, path, revno, cache_id):
+        """Get function for writing output with regexp match highlighted"""
+        _line_writer = self._get_writer_plain(path, revno, cache_id)
+        sub, highlight = self._sub, self._highlight
+        def _line_writer_regexp_highlighted(line, **kwargs):
+            """Write formatted line with matched pattern highlighted"""
+            return _line_writer(line=sub(highlight, line), **kwargs)
+        return _line_writer_regexp_highlighted
+
+    def _get_writer_fixed_highlighted(self, path, revno, cache_id):
+        """Get function for writing output with search string highlighted"""
+        _line_writer = self._get_writer_plain(path, revno, cache_id)
+        old, new = self._old, self._new
+        def _line_writer_fixed_highlighted(line, **kwargs):
+            """Write formatted line with string searched for highlighted"""
+            return _line_writer(line=line.replace(old, new), **kwargs)
+        return _line_writer_fixed_highlighted
+
+
+def _file_grep(file_text, path, opts, revno, path_prefix=None, cache_id=None):
+    # test and skip binary files
+    if '\x00' in file_text[:1024]:
+        if opts.verbose:
+            trace.warning("Binary file '%s' skipped." % path)
+        return
+
+    if path_prefix and path_prefix != '.':
+        # user has passed a dir arg, show that as result prefix
+        path = osutils.pathjoin(path_prefix, path)
+
+    # GZ 2010-06-07: There's no actual guarentee the file contents will be in
+    #                the user encoding, but we have to guess something and it
+    #                is a reasonable default without a better mechanism.
+    file_encoding = _user_encoding
+    pattern = opts.pattern.encode(_user_encoding, 'replace')
+
+    writeline = opts.outputter.get_writer(path, revno, cache_id)
+
+    if opts.files_with_matches or opts.files_without_match:
+        if opts.fixed_string:
+            if sys.platform > (2, 5):
+                found = pattern in file_text
+            else:
+                for line in file_text.splitlines():
+                    if pattern in line:
+                        found = True
+                        break
+                else:
+                    found = False
+        else:
+            search = opts.patternc.search
+            if "$" not in pattern:
+                found = search(file_text) is not None
+            else:
+                for line in file_text.splitlines():
+                    if search(line):
+                        found = True
+                        break
+                else:
+                    found = False
+        if (opts.files_with_matches and found) or \
+                (opts.files_without_match and not found):
+            writeline()
+    elif opts.fixed_string:
+        # Fast path for no match, search through the entire file at once rather
+        # than a line at a time. However, we don't want this without Python 2.5
+        # as the quick string search algorithm wasn't implemented till then:
+        # <http://effbot.org/zone/stringlib.htm>
+        if sys.version_info > (2, 5):
+            i = file_text.find(pattern)
+            if i == -1:
+                return
+            b = file_text.rfind("\n", 0, i) + 1
+            if opts.line_number:
+                start = file_text.count("\n", 0, b) + 1
+            file_text = file_text[b:]
+        else:
+            start = 1
+        if opts.line_number:
+            for index, line in enumerate(file_text.splitlines()):
+                if pattern in line:
+                    line = line.decode(file_encoding, 'replace')
+                    writeline(lineno=index+start, line=line)
+        else:
+            for line in file_text.splitlines():
+                if pattern in line:
+                    line = line.decode(file_encoding, 'replace')
+                    writeline(line=line)
+    else:
+        # Fast path on no match, the re module avoids bad behaviour in most
+        # standard cases, but perhaps could try and detect backtracking
+        # patterns here and avoid whole text search in those cases
+        search = opts.patternc.search
+        if "$" not in pattern:
+            # GZ 2010-06-05: Grr, re.MULTILINE can't save us when searching
+            #                through revisions as bazaar returns binary mode
+            #                and trailing \r breaks $ as line ending match
+            m = search(file_text)
+            if m is None:
+                return
+            b = file_text.rfind("\n", 0, m.start()) + 1
+            if opts.line_number:
+                start = file_text.count("\n", 0, b) + 1
+            file_text = file_text[b:]
+        else:
+            start = 1
+        if opts.line_number:
+            for index, line in enumerate(file_text.splitlines()):
+                if search(line):
+                    line = line.decode(file_encoding, 'replace')
+                    writeline(lineno=index+start, line=line)
+        else:
+            for line in file_text.splitlines():
+                if search(line):
+                    line = line.decode(file_encoding, 'replace')
+                    writeline(line=line)
+
 
=== added file 'bzrlib/plugins/grep/test_grep.py'
--- bzrlib/plugins/grep/test_grep.py	1970-01-01 00:00:00 +0000
+++ bzrlib/plugins/grep/test_grep.py	2012-08-23 15:07:23 +0000
@@ -0,0 +1,2254 @@
+# Copyright (C) 2010 Canonical Ltd
+#
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+from __future__ import absolute_import
+
+import os
+import re
+import unicodedata as ud
+
+from bzrlib import tests, osutils
+from bzrlib._termcolor import color_string, FG
+
+from bzrlib.tests.features import (
+    ColorFeature,
+    UnicodeFilenameFeature,
+    )
+
+# NOTE: As bzr-grep optimizes PATTERN search to -F/--fixed-string
+# for patterns that are not alphanumeric+whitespace, we test grep
+# specfically with patterns that have special characters so that
+# regex path is tested. alphanumeric patterns test the -F path.
+
+class GrepTestBase(tests.TestCaseWithTransport):
+    """Base class for testing grep.
+
+    Provides support methods for creating directory and file revisions.
+    """
+    _reflags = re.MULTILINE|re.DOTALL
+
+    def _mk_file(self, path, line_prefix, total_lines, versioned):
+        text=''
+        for i in range(total_lines):
+            text += line_prefix + str(i+1) + "\n"
+
+        open(path, 'w').write(text)
+        if versioned:
+            self.run_bzr(['add', path])
+            self.run_bzr(['ci', '-m', '"' + path + '"'])
+
+    def _update_file(self, path, text, checkin=True):
+        """append text to file 'path' and check it in"""
+        open(path, 'a').write(text)
+        if checkin:
+            self.run_bzr(['ci', path, '-m', '"' + path + '"'])
+
+    def _mk_unknown_file(self, path, line_prefix='line', total_lines=10):
+        self._mk_file(path, line_prefix, total_lines, versioned=False)
+
+    def _mk_versioned_file(self, path, line_prefix='line', total_lines=10):
+        self._mk_file(path, line_prefix, total_lines, versioned=True)
+
+    def _mk_dir(self, path, versioned):
+        os.mkdir(path)
+        if versioned:
+            self.run_bzr(['add', path])
+            self.run_bzr(['ci', '-m', '"' + path + '"'])
+
+    def _mk_unknown_dir(self, path):
+        self._mk_dir(path, versioned=False)
+
+    def _mk_versioned_dir(self, path):
+        self._mk_dir(path, versioned=True)
+
+
+class TestGrep(GrepTestBase):
+    """Core functional tests for grep."""
+
+    def test_basic_unknown_file(self):
+        """Search for pattern in specfic file.
+
+        If specified file is unknown, grep it anyway."""
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_unknown_file('file0.txt')
+
+        out, err = self.run_bzr(['grep', 'line1', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
+
+        out, err = self.run_bzr(['grep', 'line\d+', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 10)
+
+        # unknown file is not grepped unless explicitely specified
+        out, err = self.run_bzr(['grep', 'line1'])
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 0)
+
+        # unknown file is not grepped unless explicitely specified
+        out, err = self.run_bzr(['grep', 'line1$'])
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 0)
+
+    def test_ver_basic_file(self):
+        """(versioned) Search for pattern in specfic file.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.txt')
+
+        out, err = self.run_bzr(['grep', '-r', '1', 'line1', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
+
+        out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]$', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 9)
+
+        # finds all the lines
+        out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 10)
+
+    def test_wtree_basic_file(self):
+        """(wtree) Search for pattern in specfic file.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.txt')
+        self._update_file('file0.txt', 'ABC\n', checkin=False)
+
+        out, err = self.run_bzr(['grep', 'ABC', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt:ABC", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '[A-Z]{3}', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt:ABC", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', 'ABC', 'file0.txt'])
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 0)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', '[A-Z]{3}', 'file0.txt'])
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 0)
+
+    def test_ver_basic_include(self):
+        """(versioned) Ensure that -I flag is respected.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.aa')
+        self._mk_versioned_file('file0.bb')
+        self._mk_versioned_file('file0.cc')
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--include', '*.aa', '--include', '*.bb', 'line1'])
+        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
+        # two lines each (line1, line10) from file0.aa and file0.bb
+        self.assertEqual(len(out.splitlines()), 4)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--include', '*.aa', '--include', '*.bb', 'line1$'])
+        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
+        # one lines each (line1) from file0.aa and file0.bb
+        self.assertEqual(len(out.splitlines()), 2)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '-I', '*.aa', '-I', '*.bb', 'line1'])
+        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
+        # two lines each (line1, line10) from file0.aa and file0.bb
+        self.assertEqual(len(out.splitlines()), 4)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '-I', '*.aa', '-I', '*.bb', 'line1$'])
+        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
+        # one lines each (line1) from file0.aa and file0.bb
+        self.assertEqual(len(out.splitlines()), 2)
+
+    def test_wtree_basic_include(self):
+        """(wtree) Ensure that --include flag is respected.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.aa')
+        self._mk_versioned_file('file0.bb')
+        self._mk_versioned_file('file0.cc')
+
+        out, err = self.run_bzr(['grep', '--include', '*.aa',
+            '--include', '*.bb', 'line1'])
+        self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
+        # two lines each (line1, line10) from file0.aa and file0.bb
+        self.assertEqual(len(out.splitlines()), 4)
+
+        out, err = self.run_bzr(['grep', '--include', '*.aa',
+            '--include', '*.bb', 'line1$'])
+        self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
+        # one line each (line1) from file0.aa and file0.bb
+        self.assertEqual(len(out.splitlines()), 2)
+
+    def test_ver_basic_exclude(self):
+        """(versioned) Ensure that --exclude flag is respected.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.aa')
+        self._mk_versioned_file('file0.bb')
+        self._mk_versioned_file('file0.cc')
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--exclude', '*.cc', 'line1'])
+        self.assertContainsRe(out, "file0.aa~.:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb~.:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.aa~.:line10", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb~.:line10", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
+        # two lines each (line1, line10) from file0.aa and file0.bb
+        self.assertEqual(len(out.splitlines()), 4)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--exclude', '*.cc', 'line1$'])
+        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
+        # one line each (line1) from file0.aa and file0.bb
+        self.assertEqual(len(out.splitlines()), 2)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '-X', '*.cc', 'line1'])
+        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
+        # two lines each (line1, line10) from file0.aa and file0.bb
+        self.assertEqual(len(out.splitlines()), 4)
+
+    def test_wtree_basic_exclude(self):
+        """(wtree) Ensure that --exclude flag is respected.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.aa')
+        self._mk_versioned_file('file0.bb')
+        self._mk_versioned_file('file0.cc')
+
+        out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
+        self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
+        # two lines each (line1, line10) from file0.aa and file0.bb
+        self.assertEqual(len(out.splitlines()), 4)
+
+        out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'lin.1$'])
+        self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
+        # one line each (line1) from file0.aa and file0.bb
+        self.assertEqual(len(out.splitlines()), 2)
+
+    def test_ver_multiple_files(self):
+        """(versioned) Search for pattern in multiple files.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.txt', total_lines=2)
+        self._mk_versioned_file('file1.txt', total_lines=2)
+        self._mk_versioned_file('file2.txt', total_lines=2)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line[1-2]$'])
+        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~.:line2", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~.:line2", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file2.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file2.txt~.:line2", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 6)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line'])
+        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~.:line2", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~.:line2", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file2.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file2.txt~.:line2", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 6)
+
+    def test_multiple_wtree_files(self):
+        """(wtree) Search for pattern in multiple files in working tree.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.txt', total_lines=2)
+        self._mk_versioned_file('file1.txt', total_lines=2)
+        self._mk_versioned_file('file2.txt', total_lines=2)
+        self._update_file('file0.txt', 'HELLO\n', checkin=False)
+        self._update_file('file1.txt', 'HELLO\n', checkin=True)
+        self._update_file('file2.txt', 'HELLO\n', checkin=False)
+
+        out, err = self.run_bzr(['grep', 'HELLO',
+            'file0.txt', 'file1.txt', 'file2.txt'])
+
+        self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file2.txt:HELLO", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 3)
+
+        out, err = self.run_bzr(['grep', 'HELLO', '-r', 'last:1',
+            'file0.txt', 'file1.txt', 'file2.txt'])
+
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~.:HELLO", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', 'HE..O',
+            'file0.txt', 'file1.txt', 'file2.txt'])
+
+        self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file2.txt:HELLO", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 3)
+
+        out, err = self.run_bzr(['grep', 'HE..O', '-r', 'last:1',
+            'file0.txt', 'file1.txt', 'file2.txt'])
+
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~.:HELLO", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+    def test_ver_null_option(self):
+        """(versioned) --null option should use NUL instead of newline.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.txt', total_lines=3)
+
+        nref = ud.normalize(u'NFC', u"file0.txt~1:line1\0file0.txt~1:line2\0file0.txt~1:line3\0")
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', '--null', 'line[1-3]'])
+        nout = ud.normalize(u'NFC', out.decode('utf-8', 'ignore'))
+        self.assertEqual(nout, nref)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', '-Z', 'line[1-3]'])
+        nout = ud.normalize(u'NFC', out.decode('utf-8', 'ignore'))
+        self.assertEqual(nout, nref)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', '--null', 'line'])
+        nout = ud.normalize(u'NFC', out.decode('utf-8', 'ignore'))
+        self.assertEqual(nout, nref)
+        self.assertEqual(len(out.splitlines()), 1)
+
+    def test_wtree_null_option(self):
+        """(wtree) --null option should use NUL instead of newline.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.txt', total_lines=3)
+
+        out, err = self.run_bzr(['grep', '--null', 'line[1-3]'])
+        self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-Z', 'line[1-3]'])
+        self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-Z', 'line'])
+        self.assertEqual(out, "file0.txt:line1\0file0.txt:line2\0file0.txt:line3\0")
+        self.assertEqual(len(out.splitlines()), 1)
+
+    def test_versioned_file_in_dir_no_recursive(self):
+        """(versioned) Should not recurse with --no-recursive"""
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('fileX.txt', line_prefix='lin')
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.txt')
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
+        self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 0)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1$'])
+        self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 0)
+
+    def test_wtree_file_in_dir_no_recursive(self):
+        """(wtree) Should not recurse with --no-recursive"""
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('fileX.txt', line_prefix='lin')
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.txt')
+
+        out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
+        self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 0)
+
+        out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
+        self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 0)
+
+    def test_versioned_file_in_dir_recurse(self):
+        """(versioned) Should recurse by default.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.txt')
+
+        out, err = self.run_bzr(['grep', '-r', '-1', '.i.e1'])
+        self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
+        # find line1 and line10
+        self.assertEqual(len(out.splitlines()), 2)
+
+        out, err = self.run_bzr(['grep', '-r', '-1', 'line1'])
+        self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
+        # find line1 and line10
+        self.assertEqual(len(out.splitlines()), 2)
+
+    def test_wtree_file_in_dir_recurse(self):
+        """(wtree) Should recurse by default.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.txt')
+
+        out, err = self.run_bzr(['grep', 'line1'])
+        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
+        # find line1 and line10
+        self.assertEqual(len(out.splitlines()), 2)
+
+        out, err = self.run_bzr(['grep', 'lin.1'])
+        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
+        # find line1 and line10
+        self.assertEqual(len(out.splitlines()), 2)
+
+    def test_versioned_file_within_dir(self):
+        """(versioned) Search for pattern while in nested dir.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.txt')
+        os.chdir('dir0')
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
+        self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
+        # finds line1 and line10
+        self.assertEqual(len(out.splitlines()), 2)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', '.i.e1'])
+        self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
+        # finds line1 and line10
+        self.assertEqual(len(out.splitlines()), 2)
+
+    def test_versioned_include_file_within_dir(self):
+        """(versioned) Ensure --include is respected with file within dir.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_dir('dir0')                  # revno 1
+        self._mk_versioned_file('dir0/file0.txt')       # revno 2
+        self._mk_versioned_file('dir0/file1.aa')        # revno 3
+        self._update_file('dir0/file1.aa', 'hello\n')   # revno 4
+        self._update_file('dir0/file0.txt', 'hello\n')  # revno 5
+        os.chdir('dir0')
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--include', '*.aa', 'line1'])
+        self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        # finds line1 and line10
+        self.assertEqual(len(out.splitlines()), 2)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:2..last:1',
+            '--include', '*.aa', 'line1'])
+        self.assertContainsRe(out, "^file1.aa~4:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~4:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        # finds line1 and line10 over two revisions
+        self.assertEqual(len(out.splitlines()), 4)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--include', '*.aa', 'lin.1'])
+        self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        # finds line1 and line10
+        self.assertEqual(len(out.splitlines()), 2)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:3..last:1',
+            '--include', '*.aa', 'lin.1'])
+        self.assertContainsRe(out, "^file1.aa~3:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~4:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~3:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~4:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        # finds line1 and line10 over 3 revisions
+        self.assertEqual(len(out.splitlines()), 6)
+
+    def test_versioned_exclude_file_within_dir(self):
+        """(versioned) Ensure --exclude is respected with file within dir.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.txt')
+        self._mk_versioned_file('dir0/file1.aa')
+        os.chdir('dir0')
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--exclude', '*.txt', 'line1'])
+        self.assertContainsRe(out, "^file1.aa~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        # finds line1 and line10
+        self.assertEqual(len(out.splitlines()), 2)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--exclude', '*.txt', 'l[a-z]ne1'])
+        self.assertContainsRe(out, "^file1.aa~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        # finds line1 and line10
+        self.assertEqual(len(out.splitlines()), 2)
+
+    def test_wtree_file_within_dir(self):
+        """(wtree) Search for pattern while in nested dir.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.txt')
+        os.chdir('dir0')
+
+        out, err = self.run_bzr(['grep', 'line1'])
+        self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
+        # finds line1 and line10
+        self.assertEqual(len(out.splitlines()), 2)
+
+        out, err = self.run_bzr(['grep', 'l[aeiou]ne1'])
+        self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
+        # finds line1 and line10
+        self.assertEqual(len(out.splitlines()), 2)
+
+    def test_wtree_include_file_within_dir(self):
+        """(wtree) Ensure --include is respected with file within dir.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.txt')
+        self._mk_versioned_file('dir0/file1.aa')
+        os.chdir('dir0')
+
+        out, err = self.run_bzr(['grep', '--include', '*.aa', 'line1'])
+        self.assertContainsRe(out, "^file1.aa:line1", flags=TestGrep._reflags)
+        # finds line1 and line10
+        self.assertEqual(len(out.splitlines()), 2)
+
+        out, err = self.run_bzr(['grep', '--include', '*.aa', 'l[ixn]ne1'])
+        self.assertContainsRe(out, "^file1.aa:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        # finds line1 and line10
+        self.assertEqual(len(out.splitlines()), 2)
+
+    def test_wtree_exclude_file_within_dir(self):
+        """(wtree) Ensure --exclude is respected with file within dir.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.txt')
+        self._mk_versioned_file('dir0/file1.aa')
+        os.chdir('dir0')
+
+        out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'li.e1'])
+        self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        # finds line1 and line10
+        self.assertEqual(len(out.splitlines()), 2)
+
+        out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'line1'])
+        self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        # finds line1 and line10
+        self.assertEqual(len(out.splitlines()), 2)
+
+    def test_versioned_include_from_outside_dir(self):
+        """(versioned) Ensure --include is respected during recursive search.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.aa')
+
+        self._mk_versioned_dir('dir1')
+        self._mk_versioned_file('dir1/file1.bb')
+
+        self._mk_versioned_dir('dir2')
+        self._mk_versioned_file('dir2/file2.cc')
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--include', '*.aa', '--include', '*.bb', 'l..e1'])
+        self.assertContainsRe(out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
+        # finds line1 and line10
+        self.assertEqual(len(out.splitlines()), 4)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--include', '*.aa', '--include', '*.bb', 'line1'])
+        self.assertContainsRe(out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
+        # finds line1 and line10
+        self.assertEqual(len(out.splitlines()), 4)
+
+    def test_wtree_include_from_outside_dir(self):
+        """(wtree) Ensure --include is respected during recursive search.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.aa')
+
+        self._mk_versioned_dir('dir1')
+        self._mk_versioned_file('dir1/file1.bb')
+
+        self._mk_versioned_dir('dir2')
+        self._mk_versioned_file('dir2/file2.cc')
+
+        out, err = self.run_bzr(['grep', '--include', '*.aa',
+            '--include', '*.bb', 'l.n.1'])
+        self.assertContainsRe(out, "^dir0/file0.aa:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
+        # finds line1 and line10
+        self.assertEqual(len(out.splitlines()), 4)
+
+        out, err = self.run_bzr(['grep', '--include', '*.aa',
+            '--include', '*.bb', 'line1'])
+        self.assertContainsRe(out, "^dir0/file0.aa:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
+        # finds line1 and line10
+        self.assertEqual(len(out.splitlines()), 4)
+
+    def test_versioned_exclude_from_outside_dir(self):
+        """(versioned) Ensure --exclude is respected during recursive search.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.aa')
+
+        self._mk_versioned_dir('dir1')
+        self._mk_versioned_file('dir1/file1.bb')
+
+        self._mk_versioned_dir('dir2')
+        self._mk_versioned_file('dir2/file2.cc')
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--exclude', '*.cc', 'l..e1'])
+        self.assertContainsRe(out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--exclude', '*.cc', 'line1'])
+        self.assertContainsRe(out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
+
+    def test_wtree_exclude_from_outside_dir(self):
+        """(wtree) Ensure --exclude is respected during recursive search.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.aa')
+
+        self._mk_versioned_dir('dir1')
+        self._mk_versioned_file('dir1/file1.bb')
+
+        self._mk_versioned_dir('dir2')
+        self._mk_versioned_file('dir2/file2.cc')
+
+        out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'l[hijk]ne1'])
+        self.assertContainsRe(out, "^dir0/file0.aa:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
+        self.assertContainsRe(out, "^dir0/file0.aa:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
+
+    def test_workingtree_files_from_outside_dir(self):
+        """(wtree) Grep for pattern with dirs passed as argument.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.txt')
+
+        self._mk_versioned_dir('dir1')
+        self._mk_versioned_file('dir1/file1.txt')
+
+        out, err = self.run_bzr(['grep', 'l[aeiou]ne1', 'dir0', 'dir1'])
+        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
+        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
+
+    def test_versioned_files_from_outside_dir(self):
+        """(versioned) Grep for pattern with dirs passed as argument.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.txt')
+
+        self._mk_versioned_dir('dir1')
+        self._mk_versioned_file('dir1/file1.txt')
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1', 'dir0', 'dir1'])
+        self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1', 'dir0', 'dir1'])
+        self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
+
+    def test_wtree_files_from_outside_dir(self):
+        """(wtree) Grep for pattern with dirs passed as argument.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.txt')
+
+        self._mk_versioned_dir('dir1')
+        self._mk_versioned_file('dir1/file1.txt')
+
+        out, err = self.run_bzr(['grep', 'li.e1', 'dir0', 'dir1'])
+        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
+        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
+
+    def test_versioned_files_from_outside_two_dirs(self):
+        """(versioned) Grep for pattern with two levels of nested dir.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.txt')
+
+        self._mk_versioned_dir('dir1')
+        self._mk_versioned_file('dir1/file1.txt')
+
+        self._mk_versioned_dir('dir0/dir00')
+        self._mk_versioned_file('dir0/dir00/file0.txt')
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1', 'dir0/dir00'])
+        self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1'])
+        self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1', 'dir0/dir00'])
+        self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
+        self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
+
+    def test_wtree_files_from_outside_two_dirs(self):
+        """(wtree) Grep for pattern with two levels of nested dir.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file0.txt')
+
+        self._mk_versioned_dir('dir1')
+        self._mk_versioned_file('dir1/file1.txt')
+
+        self._mk_versioned_dir('dir0/dir00')
+        self._mk_versioned_file('dir0/dir00/file0.txt')
+
+        out, err = self.run_bzr(['grep', 'lin.1', 'dir0/dir00'])
+        self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', 'li.e1'])
+        self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', 'line1', 'dir0/dir00'])
+        self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', 'line1'])
+        self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
+
+    def test_versioned_file_within_dir_two_levels(self):
+        """(versioned) Search for pattern while in nested dir (two levels).
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_dir('dir0/dir1')
+        self._mk_versioned_file('dir0/dir1/file0.txt')
+        os.chdir('dir0')
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1'])
+        self.assertContainsRe(out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', '--from-root', 'l.ne1'])
+        self.assertContainsRe(out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', 'lin.1'])
+        self.assertContainsRe(out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', '--from-root', 'line1'])
+        self.assertContainsRe(out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 0)
+
+    def test_wtree_file_within_dir_two_levels(self):
+        """(wtree) Search for pattern while in nested dir (two levels).
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_dir('dir0/dir1')
+        self._mk_versioned_file('dir0/dir1/file0.txt')
+        os.chdir('dir0')
+
+        out, err = self.run_bzr(['grep', 'l[hij]ne1'])
+        self.assertContainsRe(out, "^dir1/file0.txt:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '--from-root', 'l.ne1'])
+        self.assertContainsRe(out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', 'line1'])
+        self.assertContainsRe(out, "^dir1/file0.txt:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '--from-root', 'line1'])
+        self.assertContainsRe(out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+
+    def test_versioned_ignore_case_no_match(self):
+        """(versioned) Match fails without --ignore-case.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.txt')
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', 'LinE1', 'file0.txt'])
+        self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', 'Li.E1', 'file0.txt'])
+        self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
+
+    def test_wtree_ignore_case_no_match(self):
+        """(wtree) Match fails without --ignore-case.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.txt')
+
+        out, err = self.run_bzr(['grep', 'LinE1', 'file0.txt'])
+        self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '.inE1', 'file0.txt'])
+        self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
+
+    def test_versioned_ignore_case_match(self):
+        """(versioned) Match fails without --ignore-case.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.txt')
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '-i', 'Li.E1', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '-i', 'LinE1', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--ignore-case', 'LinE1', 'file0.txt'])
+        self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
+
+    def test_wtree_ignore_case_match(self):
+        """(wtree) Match fails without --ignore-case.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.txt')
+
+        out, err = self.run_bzr(['grep', '-i', 'LinE1', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '--ignore-case', 'LinE1', 'file0.txt'])
+        self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '--ignore-case', 'Li.E1', 'file0.txt'])
+        self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
+
+    def test_versioned_from_root_fail(self):
+        """(versioned) Match should fail without --from-root.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.txt')
+        self._mk_versioned_dir('dir0')
+        os.chdir('dir0')
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', 'li.e1'])
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+
+    def test_wtree_from_root_fail(self):
+        """(wtree) Match should fail without --from-root.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.txt')
+        self._mk_versioned_dir('dir0')
+        os.chdir('dir0')
+
+        out, err = self.run_bzr(['grep', 'line1'])
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', 'li.e1'])
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+
+    def test_versioned_from_root_pass(self):
+        """(versioned) Match pass with --from-root.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.txt')
+        self._mk_versioned_dir('dir0')
+        os.chdir('dir0')
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--from-root', 'l.ne1'])
+        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--from-root', 'line1'])
+        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
+
+    def test_wtree_from_root_pass(self):
+        """(wtree) Match pass with --from-root.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.txt')
+        self._mk_versioned_dir('dir0')
+        os.chdir('dir0')
+
+        out, err = self.run_bzr(['grep', '--from-root', 'lin.1'])
+        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '--from-root', 'line1'])
+        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
+
+    def test_versioned_with_line_number(self):
+        """(versioned) Search for pattern with --line-number.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.txt')
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--line-number', 'li.e3', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt~.:3:line3", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '--line-number', 'line3', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt~.:3:line3", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1',
+            '-n', 'line1', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt~.:1:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
+
+    def test_wtree_with_line_number(self):
+        """(wtree) Search for pattern with --line-number.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.txt')
+
+        out, err = self.run_bzr(['grep', '--line-number', 'line3', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-n', 'line1', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt:1:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-n', '[hjkl]ine1', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt:1:line1", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
+        self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
+
+    def test_revno_basic_history_grep_file(self):
+        """Search for pattern in specific revision number in a file.
+        """
+        wd = 'foobar0'
+        fname = 'file0.txt'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file(fname, total_lines=0)
+        self._update_file(fname, text="v2 text\n")
+        self._update_file(fname, text="v3 text\n")
+        self._update_file(fname, text="v4 text\n")
+
+        # rev 2 should not have text 'v3'
+        out, err = self.run_bzr(['grep', '-r', '2', 'v3', fname])
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+
+        # rev 3 should not have text 'v3'
+        out, err = self.run_bzr(['grep', '-r', '3', 'v3', fname])
+        self.assertContainsRe(out, "file0.txt~3:v3.*", flags=TestGrep._reflags)
+
+        # rev 3 should not have text 'v3' with line number
+        out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3', fname])
+        self.assertContainsRe(out, "file0.txt~3:2:v3.*", flags=TestGrep._reflags)
+
+        # rev 2 should not have text 'v3'
+        out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3', fname])
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+
+        # rev 3 should not have text 'v3'
+        out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3', fname])
+        self.assertContainsRe(out, "file0.txt~3:v3.*", flags=TestGrep._reflags)
+
+        # rev 3 should not have text 'v3' with line number
+        out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3', fname])
+        self.assertContainsRe(out, "file0.txt~3:2:v3.*", flags=TestGrep._reflags)
+
+    def test_revno_basic_history_grep_full(self):
+        """Search for pattern in specific revision number in a file.
+        """
+        wd = 'foobar0'
+        fname = 'file0.txt'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file(fname, total_lines=0) # rev1
+        self._mk_versioned_file('file1.txt')          # rev2
+        self._update_file(fname, text="v3 text\n")    # rev3
+        self._update_file(fname, text="v4 text\n")    # rev4
+        self._update_file(fname, text="v5 text\n")    # rev5
+
+        # rev 2 should not have text 'v3'
+        out, err = self.run_bzr(['grep', '-r', '2', 'v3'])
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+
+        # rev 3 should not have text 'v3'
+        out, err = self.run_bzr(['grep', '-r', '3', 'v3'])
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+
+        # rev 3 should not have text 'v3' with line number
+        out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3'])
+        self.assertContainsRe(out, "file0.txt~3:1:v3", flags=TestGrep._reflags)
+
+        # rev 2 should not have text 'v3'
+        out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3'])
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+
+        # rev 3 should not have text 'v3'
+        out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3'])
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+
+        # rev 3 should not have text 'v3' with line number
+        out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3'])
+        self.assertContainsRe(out, "file0.txt~3:1:v3", flags=TestGrep._reflags)
+
+    def test_revno_versioned_file_in_dir(self):
+        """Grep specific version of file withing dir.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_dir('dir0')                      # rev1
+        self._mk_versioned_file('dir0/file0.txt')           # rev2
+        self._update_file('dir0/file0.txt', "v3 text\n")    # rev3
+        self._update_file('dir0/file0.txt', "v4 text\n")    # rev4
+        self._update_file('dir0/file0.txt', "v5 text\n")    # rev5
+
+        # v4 should not be present in revno 3
+        out, err = self.run_bzr(['grep', '-r', 'last:3', 'v4'])
+        self.assertNotContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
+
+        # v4 should be present in revno 4
+        out, err = self.run_bzr(['grep', '-r', 'last:2', 'v4'])
+        self.assertContainsRe(out, "^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
+
+        # v4 should not be present in revno 3
+        out, err = self.run_bzr(['grep', '-r', 'last:3', '[tuv]4'])
+        self.assertNotContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
+
+        # v4 should be present in revno 4
+        out, err = self.run_bzr(['grep', '-r', 'last:2', '[tuv]4'])
+        self.assertContainsRe(out, "^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
+
+    def test_revno_range_basic_history_grep(self):
+        """Search for pattern in revision range for file.
+        """
+        wd = 'foobar0'
+        fname = 'file0.txt'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file(fname, total_lines=0) # rev1
+        self._mk_versioned_file('file1.txt')          # rev2
+        self._update_file(fname, text="v3 text\n")    # rev3
+        self._update_file(fname, text="v4 text\n")    # rev4
+        self._update_file(fname, text="v5 text\n")    # rev5
+        self._update_file(fname, text="v6 text\n")    # rev6
+
+        out, err = self.run_bzr(['grep', '-r', '1..', 'v3'])
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 4)
+
+        out, err = self.run_bzr(['grep', '-r', '..1', 'v3'])
+        # searching only rev1 gives nothing
+        self.assertEqual(len(out.splitlines()), 0)
+
+        out, err = self.run_bzr(['grep', '-r', '..6', 'v3'])
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 4)
+
+        out, err = self.run_bzr(['grep', '-r', '..', 'v3'])
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 4)
+
+        out, err = self.run_bzr(['grep', '-r', '1..5', 'v3'])
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 3)
+
+        out, err = self.run_bzr(['grep', '-r', '5..1', 'v3'])
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 3)
+
+        out, err = self.run_bzr(['grep', '-r', '1..', '[tuv]3'])
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 4)
+
+        out, err = self.run_bzr(['grep', '-r', '1..5', '[tuv]3'])
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 3)
+
+        out, err = self.run_bzr(['grep', '-r', '5..1', '[tuv]3'])
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 3)
+
+    def test_revno_range_versioned_file_in_dir(self):
+        """Grep rev-range for pattern for file withing a dir.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_dir('dir0')                      # rev1
+        self._mk_versioned_file('dir0/file0.txt')           # rev2
+        self._update_file('dir0/file0.txt', "v3 text\n")    # rev3
+        self._update_file('dir0/file0.txt', "v4 text\n")    # rev4
+        self._update_file('dir0/file0.txt', "v5 text\n")    # rev5
+        self._update_file('dir0/file0.txt', "v6 text\n")    # rev6
+
+        out, err = self.run_bzr(['grep', '-r', '2..5', 'v3'])
+        self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 3)
+
+        out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3'])
+        self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 3)
+
+    def test_revno_range_versioned_file_from_outside_dir(self):
+        """Grep rev-range for pattern from outside dir.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_dir('dir0')                      # rev1
+        self._mk_versioned_file('dir0/file0.txt')           # rev2
+        self._update_file('dir0/file0.txt', "v3 text\n")    # rev3
+        self._update_file('dir0/file0.txt', "v4 text\n")    # rev4
+        self._update_file('dir0/file0.txt', "v5 text\n")    # rev5
+        self._update_file('dir0/file0.txt', "v6 text\n")    # rev6
+
+        out, err = self.run_bzr(['grep', '-r', '2..5', 'v3', 'dir0'])
+        self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
+
+        out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3', 'dir0'])
+        self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
+
+    def test_levels(self):
+        """--levels=0 should show findings from merged revision.
+        """
+        wd0 = 'foobar0'
+        wd1 = 'foobar1'
+
+        self.make_branch_and_tree(wd0)
+        os.chdir(wd0)
+        self._mk_versioned_file('file0.txt')
+        os.chdir('..')
+
+        out, err = self.run_bzr(['branch', wd0, wd1])
+        os.chdir(wd1)
+        self._mk_versioned_file('file1.txt')
+        os.chdir(osutils.pathjoin('..', wd0))
+
+        out, err = self.run_bzr(['merge', osutils.pathjoin('..', wd1)])
+        out, err = self.run_bzr(['ci', '-m', 'merged'])
+
+        out, err = self.run_bzr(['grep', 'line1'])
+        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt:line1", flags=TestGrep._reflags)
+
+        # levels should be ignored by wtree grep
+        out, err = self.run_bzr(['grep', '--levels=0', 'line1'])
+        self.assertContainsRe(out, "^file0.txt:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt:line10$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 4)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1..', '--levels=0', 'line1'])
+        self.assertContainsRe(out, "^file0.txt~2:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~2:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~2:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~2:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 8)
+
+        out, err = self.run_bzr(['grep', '-r',  '-1..', '-n', '--levels=0', 'line1'])
+        self.assertContainsRe(out, "^file0.txt~2:1:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~2:1:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~2:10:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~2:10:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 8)
+
+        # levels should be ignored by wtree grep
+        out, err = self.run_bzr(['grep', '--levels=0', 'l.ne1'])
+        self.assertContainsRe(out, "^file0.txt:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt:line10$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 4)
+
+        out, err = self.run_bzr(['grep', '-r', 'last:1..', '--levels=0', 'lin.1'])
+        self.assertContainsRe(out, "^file0.txt~2:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~2:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~2:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~2:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 8)
+
+        out, err = self.run_bzr(['grep', '-r',  '-1..', '-n', '--levels=0', '.ine1'])
+        self.assertContainsRe(out, "file0.txt~2:1:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~2:1:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~1.1.1:1:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~1.1.1:1:line1", flags=TestGrep._reflags)
+
+    def test_dotted_rev_grep(self):
+        """Grep in dotted revs
+        """
+        wd0 = 'foobar0'
+        wd1 = 'foobar1'
+
+        self.make_branch_and_tree(wd0)
+        os.chdir(wd0)
+        self._mk_versioned_file('file0.txt')
+        os.chdir('..')
+
+        out, err = self.run_bzr(['branch', wd0, wd1])
+        os.chdir(wd1)
+        self._mk_versioned_file('file1.txt')        # revno 1.1.1
+        self._update_file('file1.txt', "text 0\n")  # revno 1.1.2
+        self._update_file('file1.txt', "text 1\n")  # revno 1.1.3
+        self._update_file('file1.txt', "text 2\n")  # revno 1.1.4
+        os.chdir(osutils.pathjoin('..', wd0))
+
+        out, err = self.run_bzr(['merge', osutils.pathjoin('..', wd1)])
+        out, err = self.run_bzr(['ci', '-m', 'merged'])
+
+        out, err = self.run_bzr(['grep', '-r', '1.1.1..1.1.4', 'text'])
+        self.assertContainsRe(out, "file1.txt~1.1.2:text 0", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~1.1.4:text 0", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~1.1.4:text 1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~1.1.4:text 2", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 6)
+
+    def test_versioned_binary_file_grep(self):
+        """(versioned) Grep for pattern in binary file.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file.txt')
+        self._mk_versioned_file('file0.bin')
+        self._update_file('file0.bin', "\x00lineNN\x00\n")
+
+        # note: set --verbose/-v flag to get the skip message.
+        out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
+            'lineNN', 'file0.bin'])
+        self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
+        self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 0)
+        self.assertEqual(len(err.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
+            'line.N', 'file0.bin'])
+        self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
+        self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 0)
+        self.assertEqual(len(err.splitlines()), 1)
+
+    def test_wtree_binary_file_grep(self):
+        """(wtree) Grep for pattern in binary file.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_file('file0.bin')
+        self._update_file('file0.bin', "\x00lineNN\x00\n")
+
+        # note: set --verbose/-v flag to get the skip message.
+        out, err = self.run_bzr(['grep', '-v', 'lineNN', 'file0.bin'])
+        self.assertNotContainsRe(out, "file0.bin:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
+
+        # binary warning should not be shown without --verbose
+        out, err = self.run_bzr(['grep', 'lineNN', 'file0.bin'])
+        self.assertNotContainsRe(out, "file0.bin:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(err, "Binary file", flags=TestGrep._reflags)
+
+    def test_revspec(self):
+        """Ensure various revspecs work
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        self._mk_versioned_dir('dir0')                      # rev1
+        self._mk_versioned_file('dir0/file0.txt')           # rev2
+        self._update_file('dir0/file0.txt', "v3 text\n")    # rev3
+        self._update_file('dir0/file0.txt', "v4 text\n")    # rev4
+        self._update_file('dir0/file0.txt', "v5 text\n")    # rev5
+
+        out, err = self.run_bzr(['grep', '-r', 'revno:1..2', 'v3'])
+        self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 0)
+
+        out, err = self.run_bzr(['grep', '-r', 'revno:4..', 'v4'])
+        self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2) # find v4 in rev4 and rev5
+
+        out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v4'])
+        self.assertNotContainsRe(out, "file0", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 0)
+
+        out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v3'])
+        self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+    def test_wtree_files_with_matches(self):
+        """(wtree) Ensure --files-with-matches, -l works
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+
+        self._mk_versioned_file('file0.txt', total_lines=2)
+        self._mk_versioned_file('file1.txt', total_lines=2)
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file00.txt', total_lines=2)
+        self._mk_versioned_file('dir0/file01.txt', total_lines=2)
+
+        self._update_file('file0.txt', 'HELLO\n', checkin=False)
+        self._update_file('dir0/file00.txt', 'HELLO\n', checkin=False)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '--files-with-matches', 'HELLO'])
+
+        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # regex
+        out, err = self.run_bzr(['grep', '--files-with-matches', 'HE.LO'])
+
+        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '-l', 'HELLO'])
+
+        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # regex
+        out, err = self.run_bzr(['grep', '-l', 'HE.LO'])
+
+        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '-l', 'HELLO', 'dir0', 'file1.txt'])
+
+        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # regex
+        out, err = self.run_bzr(['grep', '-l', '.ELLO', 'dir0', 'file1.txt'])
+
+        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '-l', 'HELLO', 'file0.txt'])
+
+        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # regex
+        out, err = self.run_bzr(['grep', '-l', '.ELLO', 'file0.txt'])
+
+        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '--no-recursive', '-l', 'HELLO'])
+
+        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # regex
+        out, err = self.run_bzr(['grep', '--no-recursive', '-l', '.ELLO'])
+
+        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+    def test_ver_files_with_matches(self):
+        """(ver) Ensure --files-with-matches, -l works
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+
+        self._mk_versioned_file('file0.txt', total_lines=2)         # rev 1
+        self._mk_versioned_file('file1.txt', total_lines=2)         # rev 2
+        self._mk_versioned_dir('dir0')                              # rev 3
+        self._mk_versioned_file('dir0/file00.txt', total_lines=2)   # rev 4
+        self._mk_versioned_file('dir0/file01.txt', total_lines=2)   # rev 5
+
+        self._update_file('file0.txt', 'HELLO\n')                   # rev 6
+        self._update_file('dir0/file00.txt', 'HELLO\n')             # rev 7
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
+            'HELLO'])
+
+        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # regex
+        out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
+            'H.LLO'])
+
+        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
+            'HELLO'])
+
+        self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 3)
+
+        # regex
+        out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
+            'H.LLO'])
+
+        self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 3)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'HELLO'])
+
+        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # regex
+        out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'H.LLO'])
+
+        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '-l', 'HELLO', '-r', '-1',
+            'dir0', 'file1.txt'])
+
+        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # regex
+        out, err = self.run_bzr(['grep', '-l', 'H.LLO', '-r', '-1',
+            'dir0', 'file1.txt'])
+
+        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '-l', 'HELLO',
+            '-r', '-2', 'file0.txt'])
+
+        self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # regex
+        out, err = self.run_bzr(['grep', '-l', 'HE.LO',
+            '-r', '-2', 'file0.txt'])
+
+        self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
+            '-l', 'HELLO'])
+
+        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # regex
+        out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
+            '-l', '.ELLO'])
+
+        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+    def test_wtree_files_without_matches(self):
+        """(wtree) Ensure --files-without-match, -L works
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+
+        self._mk_versioned_file('file0.txt', total_lines=2)
+        self._mk_versioned_file('file1.txt', total_lines=2)
+        self._mk_versioned_dir('dir0')
+        self._mk_versioned_file('dir0/file00.txt', total_lines=2)
+        self._mk_versioned_file('dir0/file01.txt', total_lines=2)
+
+        self._update_file('file0.txt', 'HELLO\n', checkin=False)
+        self._update_file('dir0/file00.txt', 'HELLO\n', checkin=False)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '--files-without-match', 'HELLO'])
+
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # regex
+        out, err = self.run_bzr(['grep', '--files-without-match', 'HE.LO'])
+
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '-L', 'HELLO'])
+
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # regex
+        out, err = self.run_bzr(['grep', '-L', 'HE.LO'])
+
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '-L', 'HELLO', 'dir0', 'file1.txt'])
+
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # regex
+        out, err = self.run_bzr(['grep', '-L', '.ELLO', 'dir0', 'file1.txt'])
+
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '-L', 'HELLO', 'file1.txt'])
+
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # regex
+        out, err = self.run_bzr(['grep', '-L', '.ELLO', 'file1.txt'])
+
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '--no-recursive', '-L', 'HELLO'])
+
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # regex
+        out, err = self.run_bzr(['grep', '--no-recursive', '-L', '.ELLO'])
+
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+    def test_ver_files_without_matches(self):
+        """(ver) Ensure --files-without-match, -L works
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+
+        self._mk_versioned_file('file0.txt', total_lines=2)         # rev 1
+        self._mk_versioned_file('file1.txt', total_lines=2)         # rev 2
+        self._mk_versioned_dir('dir0')                              # rev 3
+        self._mk_versioned_file('dir0/file00.txt', total_lines=2)   # rev 4
+        self._mk_versioned_file('dir0/file01.txt', total_lines=2)   # rev 5
+
+        self._update_file('file0.txt', 'HELLO\n')                   # rev 6
+        self._update_file('dir0/file00.txt', 'HELLO\n')             # rev 7
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
+            'HELLO'])
+
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # regex
+        out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
+            'H.LLO'])
+
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
+            'HELLO'])
+
+        self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 5)
+
+        # regex
+        out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
+            'H.LLO'])
+
+        self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 5)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'HELLO'])
+
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # regex
+        out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'H.LLO'])
+
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '-L', 'HELLO', '-r', '-1',
+            'dir0', 'file1.txt'])
+
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # regex
+        out, err = self.run_bzr(['grep', '-L', 'H.LLO', '-r', '-1',
+            'dir0', 'file1.txt'])
+
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '-L', 'HELLO',
+            '-r', '-2', 'file1.txt'])
+
+        self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # regex
+        out, err = self.run_bzr(['grep', '-L', 'HE.LO',
+            '-r', '-2', 'file1.txt'])
+
+        self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # fixed-string
+        out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
+            '-L', 'HELLO'])
+
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # regex
+        out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
+            '-L', '.ELLO'])
+
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 1)
+
+    def test_no_tree(self):
+        """Ensure grep works without working tree.
+        """
+        wd0 = 'foobar0'
+        wd1 = 'foobar1'
+        self.make_branch_and_tree(wd0)
+        os.chdir(wd0)
+        self._mk_versioned_file('file0.txt')
+        os.chdir('..')
+        out, err = self.run_bzr(['branch', '--no-tree', wd0, wd1])
+        os.chdir(wd1)
+
+        out, err = self.run_bzr(['grep', 'line1'], 3)
+        self.assertContainsRe(err, "Cannot search working tree", flags=TestGrep._reflags)
+        self.assertEqual(out, '')
+
+        out, err = self.run_bzr(['grep', '-r', '1', 'line1'])
+        self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
+        self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
+
+
+class TestNonAscii(GrepTestBase):
+    """Tests for non-ascii filenames and file contents"""
+
+    _test_needs_features = [UnicodeFilenameFeature]
+
+    def test_unicode_only_file(self):
+        """Test filename and contents that requires a unicode encoding"""
+        tree = self.make_branch_and_tree(".")
+        contents = [u"\u1234"]
+        self.build_tree(contents)
+        tree.add(contents)
+        tree.commit("Initial commit")
+        as_utf8 = u"\u1234".encode("UTF-8")
+
+        # GZ 2010-06-07: Note we can't actually grep for \u1234 as the pattern
+        #                is mangled according to the user encoding.
+        streams = self.run_bzr(["grep", "--files-with-matches",
+            u"contents"], encoding="UTF-8")
+        self.assertEqual(streams, (as_utf8 + "\n", ""))
+
+        streams = self.run_bzr(["grep", "-r", "1", "--files-with-matches",
+            u"contents"], encoding="UTF-8")
+        self.assertEqual(streams, (as_utf8 + "~1\n", ""))
+
+        fileencoding = osutils.get_user_encoding()
+        as_mangled = as_utf8.decode(fileencoding, "replace").encode("UTF-8")
+
+        streams = self.run_bzr(["grep", "-n",
+            u"contents"], encoding="UTF-8")
+        self.assertEqual(streams, ("%s:1:contents of %s\n" %
+            (as_utf8, as_mangled), ""))
+
+        streams = self.run_bzr(["grep", "-n", "-r", "1",
+            u"contents"], encoding="UTF-8")
+        self.assertEqual(streams, ("%s~1:1:contents of %s\n" %
+            (as_utf8, as_mangled), ""))
+
+
+class TestColorGrep(GrepTestBase):
+    """Tests for the --color option."""
+
+    # GZ 2010-06-05: Does this really require the feature? Nothing prints.
+    _test_needs_features = [ColorFeature]
+
+    _rev_sep = color_string('~', fg=FG.BOLD_YELLOW)
+    _sep = color_string(':', fg=FG.BOLD_CYAN)
+
+    def test_color_option(self):
+        """Ensure options for color are valid.
+        """
+        out, err = self.run_bzr(['grep', '--color', 'foo', 'bar'], 3)
+        self.assertEqual(out, '')
+        self.assertContainsRe(err, 'Valid values for --color are', flags=TestGrep._reflags)
+
+    def test_ver_matching_files(self):
+        """(versioned) Search for matches or no matches only"""
+        tree = self.make_branch_and_tree(".")
+        contents = ["d/", "d/aaa", "bbb"]
+        self.build_tree(contents)
+        tree.add(contents)
+        tree.commit("Initial commit")
+
+        # GZ 2010-06-05: Maybe modify the working tree here
+
+        streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
+            "--files-with-matches", "aaa"])
+        self.assertEqual(streams, ("".join([
+            FG.MAGENTA, "d/aaa", self._rev_sep, "1", "\n"
+            ]), ""))
+
+        streams = self.run_bzr(["grep", "--color", "always", "-r", "1",
+            "--files-without-match", "aaa"])
+        self.assertEqual(streams, ("".join([
+            FG.MAGENTA, "bbb", self._rev_sep, "1", "\n"
+            ]), ""))
+
+    def test_wtree_matching_files(self):
+        """(wtree) Search for matches or no matches only"""
+        tree = self.make_branch_and_tree(".")
+        contents = ["d/", "d/aaa", "bbb"]
+        self.build_tree(contents)
+        tree.add(contents)
+        tree.commit("Initial commit")
+
+        # GZ 2010-06-05: Maybe modify the working tree here
+
+        streams = self.run_bzr(["grep", "--color", "always",
+            "--files-with-matches", "aaa"])
+        self.assertEqual(streams, ("".join([
+            FG.MAGENTA, "d/aaa", FG.NONE, "\n"
+            ]), ""))
+
+        streams = self.run_bzr(["grep", "--color", "always",
+            "--files-without-match", "aaa"])
+        self.assertEqual(streams, ("".join([
+            FG.MAGENTA, "bbb", FG.NONE, "\n"
+            ]), ""))
+
+    def test_ver_basic_file(self):
+        """(versioned) Search for pattern in specfic file.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        lp = 'foo is foobar'
+        self._mk_versioned_file('file0.txt', line_prefix=lp, total_lines=1)
+
+        # prepare colored result
+        foo = color_string('foo', fg=FG.BOLD_RED)
+        res = (FG.MAGENTA + 'file0.txt'
+            + self._rev_sep + '1' + self._sep
+            + foo + ' is ' + foo + 'bar1' + '\n')
+        txt_res = 'file0.txt~1:foo is foobar1\n'
+
+        nres = (FG.MAGENTA + 'file0.txt'
+            + self._rev_sep + '1' + self._sep + '1' + self._sep
+            + foo + ' is ' + foo + 'bar1' + '\n')
+
+        out, err = self.run_bzr(['grep', '--color',
+            'always', '-r', '1', 'foo'])
+        self.assertEqual(out, res)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        # auto should produce plain text result
+        # as stdout is redireched here.
+        out, err = self.run_bzr(['grep', '--color',
+            'auto', '-r', '1', 'foo'])
+        self.assertEqual(out, txt_res)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-i', '--color',
+            'always', '-r', '1', 'FOO'])
+        self.assertEqual(out, res)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '--color',
+            'always', '-r', '1', 'f.o'])
+        self.assertEqual(out, res)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-i', '--color',
+            'always', '-r', '1', 'F.O'])
+        self.assertEqual(out, res)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-n', '--color',
+            'always', '-r', '1', 'foo'])
+        self.assertEqual(out, nres)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-n', '-i', '--color',
+            'always', '-r', '1', 'FOO'])
+        self.assertEqual(out, nres)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-n', '--color',
+            'always', '-r', '1', 'f.o'])
+        self.assertEqual(out, nres)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-n', '-i', '--color',
+            'always', '-r', '1', 'F.O'])
+        self.assertEqual(out, nres)
+        self.assertEqual(len(out.splitlines()), 1)
+
+    def test_wtree_basic_file(self):
+        """(wtree) Search for pattern in specfic file.
+        """
+        wd = 'foobar0'
+        self.make_branch_and_tree(wd)
+        os.chdir(wd)
+        lp = 'foo is foobar'
+        self._mk_versioned_file('file0.txt', line_prefix=lp, total_lines=1)
+
+        # prepare colored result
+        foo = color_string('foo', fg=FG.BOLD_RED)
+        res = (FG.MAGENTA + 'file0.txt'
+            + self._sep + foo + ' is ' + foo + 'bar1' + '\n')
+
+        nres = (FG.MAGENTA + 'file0.txt'
+            + self._sep + '1' + self._sep
+            + foo + ' is ' + foo + 'bar1' + '\n')
+
+        out, err = self.run_bzr(['grep', '--color',
+            'always', 'foo'])
+        self.assertEqual(out, res)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-i', '--color',
+            'always', 'FOO'])
+        self.assertEqual(out, res)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '--color',
+            'always', 'f.o'])
+        self.assertEqual(out, res)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-i', '--color',
+            'always', 'F.O'])
+        self.assertEqual(out, res)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-n', '--color',
+            'always', 'foo'])
+        self.assertEqual(out, nres)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-n', '-i', '--color',
+            'always', 'FOO'])
+        self.assertEqual(out, nres)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-n', '--color',
+            'always', 'f.o'])
+        self.assertEqual(out, nres)
+        self.assertEqual(len(out.splitlines()), 1)
+
+        out, err = self.run_bzr(['grep', '-n', '-i', '--color',
+            'always', 'F.O'])
+        self.assertEqual(out, nres)
+        self.assertEqual(len(out.splitlines()), 1)
+
+
+# copied from bzrlib.tests.blackbox.test_diff
+def subst_dates(string):
+    """Replace date strings with constant values."""
+    return re.sub(r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [-\+]\d{4}',
+                  'YYYY-MM-DD HH:MM:SS +ZZZZ', string)
+
+
+class TestGrepDiff(tests.TestCaseWithTransport):
+
+    def make_example_branch(self):
+        tree = self.make_branch_and_tree('.')
+        self.build_tree_contents([
+            ('hello', 'foo\n'),
+            ('goodbye', 'baz\n')])
+        tree.add(['hello'])
+        tree.commit('setup')
+        tree.add(['goodbye'])
+        tree.commit('setup')
+        return tree
+
+    def test_grep_diff_basic(self):
+        """grep -p basic test."""
+        tree = self.make_example_branch()
+        self.build_tree_contents([('hello', 'hello world!\n')])
+        tree.commit('updated hello')
+        out, err = self.run_bzr(['grep', '-p', 'hello'])
+        self.assertEquals(err, '')
+        self.assertEqualDiff(subst_dates(out), '''\
+=== revno:3 ===
+  === modified file 'hello'
+    --- hello	YYYY-MM-DD HH:MM:SS +ZZZZ
+    +++ hello	YYYY-MM-DD HH:MM:SS +ZZZZ
+    +hello world!
+=== revno:1 ===
+  === added file 'hello'
+    --- hello	YYYY-MM-DD HH:MM:SS +ZZZZ
+    +++ hello	YYYY-MM-DD HH:MM:SS +ZZZZ
+''')
+
+    def test_grep_diff_revision(self):
+        """grep -p specific revision."""
+        tree = self.make_example_branch()
+        self.build_tree_contents([('hello', 'hello world!\n')])
+        tree.commit('updated hello')
+        out, err = self.run_bzr(['grep', '-p', '-r', '3', 'hello'])
+        self.assertEquals(err, '')
+        self.assertEqualDiff(subst_dates(out), '''\
+=== revno:3 ===
+  === modified file 'hello'
+    --- hello	YYYY-MM-DD HH:MM:SS +ZZZZ
+    +++ hello	YYYY-MM-DD HH:MM:SS +ZZZZ
+    +hello world!
+''')
+
+    def test_grep_diff_revision_range(self):
+        """grep -p revision range."""
+        tree = self.make_example_branch()
+        self.build_tree_contents([('hello', 'hello world!1\n')]) # rev 3
+        tree.commit('rev3')
+        self.build_tree_contents([('blah', 'hello world!2\n')]) # rev 4
+        tree.add('blah')
+        tree.commit('rev4')
+        open('hello', 'a').write('hello world!3\n')
+        #self.build_tree_contents([('hello', 'hello world!3\n')]) # rev 5
+        tree.commit('rev5')
+        out, err = self.run_bzr(['grep', '-p', '-r', '2..5', 'hello'])
+        self.assertEquals(err, '')
+        self.assertEqualDiff(subst_dates(out), '''\
+=== revno:5 ===
+  === modified file 'hello'
+    --- hello	YYYY-MM-DD HH:MM:SS +ZZZZ
+    +++ hello	YYYY-MM-DD HH:MM:SS +ZZZZ
+    +hello world!3
+=== revno:4 ===
+  === added file 'blah'
+    +hello world!2
+=== revno:3 ===
+  === modified file 'hello'
+    --- hello	YYYY-MM-DD HH:MM:SS +ZZZZ
+    +++ hello	YYYY-MM-DD HH:MM:SS +ZZZZ
+    +hello world!1
+''')
+
+    def test_grep_diff_color(self):
+        """grep -p color test."""
+        tree = self.make_example_branch()
+        self.build_tree_contents([('hello', 'hello world!\n')])
+        tree.commit('updated hello')
+        out, err = self.run_bzr(['grep', '--diff', '-r', '3',
+            '--color', 'always', 'hello'])
+        self.assertEquals(err, '')
+        revno = color_string('=== revno:3 ===', fg=FG.BOLD_BLUE) + '\n'
+        filename = color_string("  === modified file 'hello'", fg=FG.BOLD_MAGENTA) + '\n'
+        redhello = color_string('hello', fg=FG.BOLD_RED)
+        diffstr = '''\
+    --- hello	YYYY-MM-DD HH:MM:SS +ZZZZ
+    +++ hello	YYYY-MM-DD HH:MM:SS +ZZZZ
+    +hello world!
+'''
+        diffstr = diffstr.replace('hello', redhello)
+        self.assertEqualDiff(subst_dates(out), revno + filename + diffstr)
+
+    def test_grep_norevs(self):
+        """grep -p with zero revisions."""
+        out, err = self.run_bzr(['init'])
+        out, err = self.run_bzr(['grep', '--diff', 'foo'], 3)
+        self.assertEquals(out, '')
+        self.assertContainsRe(err, "ERROR:.*revision.* does not exist in branch")
+
 
=== modified file 'bzrlib/tests/features.py'
--- bzrlib/tests/features.py	2012-03-09 16:48:55 +0000
+++ bzrlib/tests/features.py	2012-08-23 15:07:23 +0000
@@ -492,3 +492,15 @@
 
 
 win32_feature = Win32Feature()
+
+
+class _ColorFeature(Feature):
+
+    def _probe(self):
+        from bzrlib._termcolor import allow_color
+        return allow_color()
+
+    def feature_name(self):
+        return "Terminal supports color."
+
+ColorFeature = _ColorFeature()
 
=== modified file 'doc/en/release-notes/bzr-2.6.txt'
--- doc/en/release-notes/bzr-2.6.txt	2012-08-03 12:22:25 +0000
+++ doc/en/release-notes/bzr-2.6.txt	2012-08-23 15:07:23 +0000
@@ -106,6 +106,8 @@
 * New option ``--overwrite-tags`` for ``bzr pull`` and ``bzr push``.
   (Jelmer Vernooij, #681792)
 
+* The 'grep' plugin is now shipped with bzr. (Jelmer Vernooij)
+
 Improvements
 ************