offgrep 0.3.0__tar.gz → 0.3.1__tar.gz

{offgrep-0.3.0 → offgrep-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: offgrep
-Version: 0.3.0
+Version: 0.3.1
 Summary: A lousy ripgrep rip-off in pure Python
 Keywords: grep,recursive
 Author: Rainer Schwarzbach

{offgrep-0.3.0 → offgrep-0.3.1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "uv_build"
 
 [project]
 name = "offgrep"
-version = "0.3.0"
+version = "0.3.1"
 description = "A lousy ripgrep rip-off in pure Python"
 readme = "README.md"
 authors = [

{offgrep-0.3.0 → offgrep-0.3.1}/src/offgrep/__main__.py

@@ -8,7 +8,8 @@ import sys
 
 from .arguments import parse_arguments
 from .filesystem import FileSelectionOptions, iter_selected_files
-from .pattern_matching import PatternOptions, OutputOptions, find_in_files
+from .output import OutputOptions
+from .pattern_matching import PatternOptions, find_in_files
 
 
 def grep_files(
@@ -46,5 +47,3 @@ def main() -> int:
 
 if __name__ == "__main__":
     sys.exit(main())  # pragma: no cover
-
-# vim: fileencoding=utf-8 ts=4 sts=4 sw=4 autoindent expandtab syntax=python:

{offgrep-0.3.0 → offgrep-0.3.1}/src/offgrep/arguments.py

@@ -8,20 +8,33 @@ from argparse import (
     ArgumentParser,
     Namespace,
     RawDescriptionHelpFormatter,
-    REMAINDER,
     SUPPRESS,
 )
 from importlib.metadata import PackageNotFoundError, version as metadata_version
-from logging import DEBUG, WARNING, basicConfig, debug, warning
+from logging import CRITICAL, DEBUG, INFO, WARNING, basicConfig, debug, warning
 from pathlib import Path
 from sys import stdin
 from tomllib import loads as tomli_loads
 
 from .commons import EMPTY, UTF_8, split_without_empty_strings
-from .filesystem import FileSelectionOptions, IgnoreFileMode, Priority, VCSDirectory
-from .pattern_matching import Highlighter, PatternOptions, OutputOptions
+from .filesystem import (
+    FileSelectionOptions,
+    IgnoreFileMode,
+    Priority,
+    VCSDirectory,
+    is_an_eligible_path,
+)
+from .output import (
+    OutputOptions,
+    HIGHLIGHTERS,
+    SUPPORTED_COLORS,
+    print_highlighter_examples,
+)
+from .pattern_matching import PatternOptions
+
 
 DEFAULT_PRE_IGNORE = ",".join(f"{dirname}/" for dirname in VCSDirectory)
+DEFAULT_HIGHLIGHTER_KEY = "u"
 
 PACKAGE_NAME = "offgrep"
 """The package name for metadata inspection"""
@@ -106,62 +119,120 @@ def print_supported_file_tyoes() -> None:
     warning("--type-list option not implemented yet")
 
 
-def build_argument_parser() -> ArgumentParser:
-    """build the commandline argument parser"""
-    try:
-        version = metadata_version(PACKAGE_NAME)
-    except PackageNotFoundError:
-        version = get_metadata_version()
+def _add_output_options(parser: ArgumentParser) -> None:
+    """Add output options to a parser instance"""
+    output_group = parser.add_argument_group("Output options")
+    loglevel_mutex = output_group.add_mutually_exclusive_group()
+    loglevel_mutex.add_argument(
+        "--verbose",
+        action="store_true",
+        help="log with level INFO",
+    )
+    loglevel_mutex.add_argument(
+        "--debug",
+        action="store_true",
+        help="log with level DEBUG",
+    )
+    loglevel_mutex.add_argument(
+        "-q",
+        "--quiet",
+        action="store_true",
+        help="no output except for CRITICAL errors",
+    )
+    match_highlight_mutex = output_group.add_mutually_exclusive_group()
+    match_highlight_mutex.add_argument(
+        "--hi",
+        "--highlight-matches",
+        nargs="?",
+        choices=sorted(HIGHLIGHTERS),
+        const=DEFAULT_HIGHLIGHTER_KEY,
+        help="Highlight matches with the provided profile."
+        " Default ist %(default)r (no highlighting) if not specified,"
+        " or %(const)r if provided without a value."
+        " Use the --highlighters option for an overview with examples.",
+    )
+    for color in SUPPORTED_COLORS:
+        match_highlight_mutex.add_argument(
+            f"--{color}",
+            action="store_const",
+            dest="hi",
+            const=color[0],
+            help=f"Highlight matches in {color}.",
+        )
     #
-    main_parser = ArgumentParser(
-        prog="offgrep",
-        description="searches text in (text) files recursively",
-        epilog=_EPILOG,
-        formatter_class=RawDescriptionHelpFormatter,
+    match_highlight_mutex.add_argument(
+        "--highlighters",
+        action="store_true",
+        help="Show highlighter effects on examples.",
     )
-    main_parser.set_defaults(
-        loglevel=WARNING,
-        encoding=UTF_8,
-        pre_ignore=DEFAULT_PRE_IGNORE,
-        post_ignore=EMPTY,
+    output_group.add_argument(
+        "--stats",
+        action="store_true",
+        help="Collect and show statistics.",
     )
-    main_parser.add_argument("-V", "--version", action="version", version=version)
-    main_parser.add_argument(
-        "--debug",
-        action="store_const",
-        const=DEBUG,
-        dest="loglevel",
-        help="log with debug level",
+    output_group.add_argument(
+        "--files",
+        action="store_true",
+        help="Print the path of each file that would be searched,"
+        " without actually performing the search.",
     )
-    main_parser.add_argument(
+    output_group.add_argument(
+        "--type-list",
+        action="store_true",
+        help="NOT IMPLEMTED YET: print the list of supported file types.",
+    )
+
+
+def _add_file_options(parser: ArgumentParser) -> None:
+    """Add file options to a parser instance"""
+    file_group = parser.add_argument_group("File selection options")
+    file_group.add_argument(
         "--default-ignore-dirs",
-        help="Always ignore the directories named here, separated by commas."
-        " DEPRECATED, please use --pre-ignore or --post-ignore instead.",
+        metavar="DIRECTORY-NAMES",
+        help="DEPRECATED, please use --pre-ignore or --post-ignore instead."
+        " Original purpose: always ignore the directories named here,"
+        " separated by commas.",
     )
-    main_parser.add_argument(
+    file_group.add_argument(
         "--default-ignore-priority",
         choices=list(Priority),
         type=Priority,
-        help="Priority for the ignore rules specified through -default-ignore-dirs."
+        help="DEPRECATED, please use --pre-ignore or --post-ignore instead."
+        " Original purpose: priority for the ignore rules specified through"
+        " --default-ignore-dirs."
         f" Choices: %(choices)s ({str(Priority.LOW)!r} is applied first but might"
         " be overridden by eg. directory defined rules,"
         f" while {str(Priority.HIGH)!r} is applied last but cannot be overridden anymore)."
-        f" The preset is {str(Priority.LOW)!r}."
-        " DEPRECATED, please use --pre-ignore or --post-ignore instead.",
+        f" The preset is {str(Priority.LOW)!r}.",
     )
-    main_parser.add_argument(
+    file_group.add_argument(
         "--pre-ignore",
+        metavar="PATTERNS",
         help="gitignore-style patterns for files and/or directories ignored"
         " before applying found ignore file rules, joined with commas (,)."
-        " Defaults to VCS repository directories (%(default)s).",
+        " Defaults to VCS repository directories (%(default)r).",
     )
-    main_parser.add_argument(
+    file_group.add_argument(
         "--post-ignore",
+        metavar="PATTERNS",
         help="gitignore-style patterns for files and/or directories ignored"
         " after applying found ignore file rules, joined with commas (,)."
-        " Empty by default (%(default)s).",
+        " Empty by default (%(default)r).",
     )
-    main_parser.add_argument(
+    file_group.add_argument(
+        "-t",
+        "--type",
+        nargs="+",
+        metavar="FILETYPE",
+        help="NOT IMPLEMTED YET: search only in files of type %(metavar)s.",
+        #  See --type-list output for supported file types.",
+    )
+
+
+def _add_pattern_options(parser: ArgumentParser) -> None:
+    """Add pattern options to a parser instance"""
+    pattern_group = parser.add_argument_group("Pattern options")
+    pattern_group.add_argument(
         "-e",
         "--expression",
         nargs="+",
@@ -171,7 +242,7 @@ def build_argument_parser() -> ArgumentParser:
         " Use this option with multiple arguments if you want to seatch for"
         " multpile patterns at once.",
     )
-    main_parser.add_argument(
+    pattern_group.add_argument(
         "-f",
         "--file",
         nargs="+",
@@ -180,7 +251,7 @@ def build_argument_parser() -> ArgumentParser:
         metavar="PATTERNFILE",
         help="Files containing patterns (by default, regular expressions",
     )
-    main_parser.add_argument(
+    pattern_group.add_argument(
         "-F",
         "--fixed-strings",
         action="store_true",
@@ -188,73 +259,51 @@ def build_argument_parser() -> ArgumentParser:
         " expressions so special characters – .+*()[]{} – do not need to be escaped,"
         " also saving some energy.",
     )
-    main_parser.add_argument(
+    pattern_group.add_argument(
         "-i",
         "--ignore-case",
         action="store_false",
         dest="case_sensitive",
         help="case-insensitive matching",
     )
-    main_parser.add_argument(
-        "-t",
-        "--type",
-        nargs="+",
-        help="search only in files of type %(metavar)s. NOT IMPLEMENTED YET.",
-        #  See --type-list output for supported file types.",
+
+
+def build_argument_parser() -> ArgumentParser:
+    """build the commandline argument parser"""
+    try:
+        version = metadata_version(PACKAGE_NAME)
+    except PackageNotFoundError:
+        version = get_metadata_version()
+    #
+    main_parser = ArgumentParser(
+        prog="offgrep",
+        description="searches text in (text) files recursively",
+        epilog=_EPILOG,
+        formatter_class=RawDescriptionHelpFormatter,
+    )
+    main_parser.set_defaults(
+        encoding=UTF_8,
+        hi="z",
+        pre_ignore=DEFAULT_PRE_IGNORE,
+        post_ignore=EMPTY,
     )
+    main_parser.add_argument("-V", "--version", action="version", version=version)
     main_parser.add_argument(
         "--encoding",
         help="Encoding of all files (default: %(default)s)",
     )
+    _add_output_options(main_parser)
+    _add_file_options(main_parser)
+    _add_pattern_options(main_parser)
     main_parser.add_argument(
-        "--highlight-matches",
-        "--hm",
-        nargs="?",
-        type=str.lower,
-        choices=[hi.name.lower() for hi in Highlighter],
-        default=Highlighter.NONE.name.lower(),
-        const=Highlighter.RED.name.lower(),
-        help="Highlight matches with the provided profile."
-        f" Defaults to {Highlighter.RED.value.enclose('%(const)s')}"
-        " if provided without a value.",
-    )
-    main_parser.add_argument(
-        "--files",
-        action="store_true",
-        help="Print the path of each file that would be searched,"
-        " without actually performing the search.",
-    )
-    main_parser.add_argument(
-        "--stats",
-        action="store_true",
-        help="Show statistics.",
-    )
-    main_parser.add_argument(
-        "--type-list",
-        action="store_true",
-        help="Print the list of supported file types. NOT IMPLEMENTED YET.",
-    )
-    main_parser.add_argument(
-        "positional_args",
-        nargs=REMAINDER,
+        "positional",
+        nargs="*",
         help=SUPPRESS,
     )
     return main_parser
 
 
-def remove_options_end_marker(args: Namespace, path_candidates: list[str]) -> list[str]:
-    """Remove an optins end marke if it is at the start of the paths list
-    after multiple-value options
-    """
-    if not path_candidates:
-        return []
-    if any((args.patterns, args.patternfiles)) and path_candidates[0] == "--":
-        return path_candidates[1:]
-    #
-    return path_candidates[:]
-
-
-def make_file_selecton_options(args: Namespace) -> FileSelectionOptions:
+def make_file_selection_options(args: Namespace) -> FileSelectionOptions:
     """Initailize an FSO instance from the arguments"""
     pre_ignore = split_without_empty_strings(args.pre_ignore)
     post_ignore = split_without_empty_strings(args.post_ignore)
@@ -269,9 +318,7 @@ def make_file_selecton_options(args: Namespace) -> FileSelectionOptions:
         #
     #
     if args.files:
-        paths: list[Path] = list(
-            map(Path, remove_options_end_marker(args, args.positional_args))
-        )
+        paths: list[Path] = list(map(Path, args.positional))
         if not paths:
             paths.append(Path.cwd())
         #
@@ -294,6 +341,19 @@ def make_file_selecton_options(args: Namespace) -> FileSelectionOptions:
     )
 
 
+def initialize_logging(args: Namespace) -> None:
+    """Initialize logging"""
+    loglevel = WARNING
+    if args.debug:
+        loglevel = DEBUG
+    elif args.verbose:
+        loglevel = INFO
+    elif args.quiet:
+        loglevel = CRITICAL
+    #
+    basicConfig(level=loglevel)
+
+
 def parse_arguments() -> tuple[
     FileSelectionOptions, PatternOptions | None, OutputOptions
 ]:
@@ -304,17 +364,26 @@ def parse_arguments() -> tuple[
     """
     main_parser = build_argument_parser()
     args = main_parser.parse_args()
-    basicConfig(level=args.loglevel)
+    initialize_logging(args)
     debug(repr(args))
+    if args.highlighters:
+        print_highlighter_examples()
+        main_parser.exit()
+    #
     if args.type_list:
         print_supported_file_tyoes()
         main_parser.exit()
     #
+    produce_output = not args.quiet
     if args.files:
-        return make_file_selecton_options(args), None, OutputOptions()
+        return (
+            make_file_selection_options(args),
+            None,
+            OutputOptions(show_files=produce_output),
+        )
     #
-    fso = make_file_selecton_options(args)
-    path_candidates = args.positional_args[:]
+    fso = make_file_selection_options(args)
+    path_candidates = args.positional[:]
     patterns: list[str] = []
     if args.patterns:
         patterns.extend(args.patterns)
@@ -328,15 +397,13 @@ def parse_arguments() -> tuple[
         except IndexError:
             main_parser.exit(
                 status=1,
-                message="Using offgrep requires at least one pattern"
+                message="This command variant requires at least one pattern"
                 " as a positional argument.",
             )
         #
     #
     if stdin.isatty():
-        paths: list[Path] = list(
-            map(Path, remove_options_end_marker(args, path_candidates))
-        )
+        paths: list[Path] = list(map(Path, path_candidates))
         if not paths:
             paths.append(Path.cwd())
         #
@@ -348,12 +415,12 @@ def parse_arguments() -> tuple[
         case_sensitive=args.case_sensitive,
     )
     suppress_file_prefix = not fso.paths or (
-        len(fso.paths) == 1 and fso.paths[0].is_file()
+        len(fso.paths) == 1 and is_an_eligible_path(fso.paths[0])
     )
     oo = OutputOptions(
-        highlighter=Highlighter[args.highlight_matches.upper()],
+        highlighter=HIGHLIGHTERS[args.hi],
         show_files=not suppress_file_prefix,
-        show_results=True,
+        show_results=produce_output,
         show_stats=args.stats,
     )
     return fso, po, oo

{offgrep-0.3.0 → offgrep-0.3.1}/src/offgrep/filesystem.py

@@ -187,8 +187,11 @@ class DirectoryWalker:
         effective_ignore_rulesets.extend(self.post_rulesets)
         for contained_path in directory_contents:
             # name = contained_path.name
-            if not (contained_path.is_dir() or contained_path.is_file()):
-                debug("Skipping %s, not a directory or regular file", contained_path)
+            if not (contained_path.is_dir() or is_an_eligible_path(contained_path)):
+                debug(
+                    "Skipping %s, not a directory, regular file, or named pipe",
+                    contained_path,
+                )
                 continue
             #
             is_excluded = False
@@ -201,7 +204,7 @@ class DirectoryWalker:
                 debug("Ignoring %s", contained_path)
                 continue
             #
-            if contained_path.is_file():
+            if is_an_eligible_path(contained_path):
                 if self.use_relative_paths:
                     yield contained_path.relative_to(self.cwd)
                 else:
@@ -402,6 +405,11 @@ def determine_vcs_rules(
     )
 
 
+def is_an_eligible_path(path: Path) -> bool:
+    """Allow regular files or named pipes"""
+    return path.is_file() or path.is_fifo()
+
+
 def is_repository_root_path(directory: Path, repo_type: VCSDirectory) -> bool:
     """Check if path is the repository root path of the proviede type"""
     path_to_check = directory / str(repo_type)
@@ -410,17 +418,17 @@ def is_repository_root_path(directory: Path, repo_type: VCSDirectory) -> bool:
 
 def iter_selected_files(file_selection_opts: FileSelectionOptions) -> Iterator[Path]:
     """Select files"""
-    for single_path in file_selection_opts.paths:
-        if single_path.is_file():
-            debug("Omitting ignore rules for file %s", single_path)
-            yield single_path
-        elif single_path.is_dir():
+    for current_path in file_selection_opts.paths:
+        if is_an_eligible_path(current_path):
+            debug("Omitting ignore rules for file %s", current_path)
+            yield current_path
+        elif current_path.is_dir():
             walker = DirectoryWalker(
-                single_path,
+                current_path,
                 file_selection_opts,
             )
             yield from walker.iter_files()
         else:
-            warning("Ignoring %s, not a regular file", single_path)
+            warning("Ignoring %s, not a regular file", current_path)
         #
     #

offgrep-0.3.1/src/offgrep/output.py

@@ -0,0 +1,185 @@
+# -*- coding: utf-8 -*-
+
+"""
+Output
+"""
+
+from dataclasses import dataclass
+from functools import cached_property
+from secrets import choice
+from sys import stdout
+from textwrap import indent
+
+from .commons import EMPTY
+
+
+STDOUT_IS_A_TTY = stdout.isatty()
+
+_CSI = "\x1b["
+
+## Keys
+
+RED = "red"
+GREEN = "green"
+YELLOW = "yellow"
+BLUE = "blue"
+PURPLE = "purple"
+CYAN = "cyan"
+
+SUPPORTED_COLORS = (RED, GREEN, YELLOW, BLUE, PURPLE, CYAN)
+
+LOREM_IPSUM = """Lorem ipsum dolor sit amet, consetetur sadipscing elitr,
+sed diam nonumy eirmod tempor invidunt
+ut labore et dolore magna aliquyam erat,
+sed diam voluptua.
+At vero eos et accusam et justo duo dolores et ea rebum.
+Stet clita kasd gubergren, no sea takimata sanctus
+est Lorem ipsum dolor sit amet."""
+
+
+def sgr(content: str | int) -> str:
+    """The ANSI SGR sequence"""
+    return f"{_CSI}{content}m"
+
+
+@dataclass(frozen=True)
+class Highlighter:
+    """Highlighting profile"""
+
+    short: str
+    description: str
+    start: str = EMPTY
+    end: str = sgr(0)
+    apply_in_pipeline: bool = True
+    apply_on_tty: bool = True
+
+    @cached_property
+    def is_applicable(self) -> bool:
+        """Indicate if the highlighter may be used"""
+        if STDOUT_IS_A_TTY:
+            return self.apply_on_tty
+        #
+        return self.apply_in_pipeline
+
+    @cached_property
+    def does_anything(self) -> bool:
+        """Indicate if the highlighter defines a start and/or an end"""
+        return bool(f"{self.start}{self.end}")
+
+    def __bool__(self) -> bool:
+        """Booelan evaluation: applicable and not empty"""
+        return self.is_applicable and self.does_anything
+
+    def enclose(self, text: str) -> str:
+        """Return the enclosed text if possible"""
+        if self:
+            return f"{self.start}{text}{self.end}"
+        #
+        return text
+
+    def emphasize_matches(
+        self,
+        line: str,
+        *match_areas: tuple[int, int],
+    ) -> str:
+        """Return a line mith the match areas emphasized"""
+        if not self or not match_areas:
+            return line
+        #
+        pos = 0
+        collector: list[str] = []
+        marked = False
+        for a_start, a_end in sorted(match_areas):
+            if a_start > pos:
+                if pos > 0 and marked:
+                    collector.append(self.end)
+                    marked = False
+                #
+                collector.append(line[pos:a_start])
+            #
+            if a_start < pos:
+                a_start = pos
+                if a_end <= pos:
+                    continue
+                #
+            #
+            if not marked:
+                collector.append(self.start)
+                marked = True
+            #
+            collector.append(line[a_start:a_end])
+            pos = a_end
+        #
+        if marked:
+            collector.append(self.end)
+        #
+        if pos < len(line):
+            collector.append(line[pos:])
+        #
+        return EMPTY.join(collector)
+
+
+NO_HIGHLIGHTING = Highlighter(
+    "z", "default: Zero highlighting", apply_on_tty=False, apply_in_pipeline=False
+)
+HIGHLIGHT_STRESSED = Highlighter(
+    "s", "Stressed text", start=sgr(1), apply_in_pipeline=False
+)
+HIGHLIGHT_UNDERLINE = Highlighter(
+    "u", "Underlined text", start=sgr(4), apply_in_pipeline=False
+)
+
+HIGHLIGHTERS: dict[str, Highlighter] = {
+    instance.short: instance
+    for instance in [
+        NO_HIGHLIGHTING,
+        Highlighter("a", "text enclosed in Arrows", start="→", end="←"),
+        Highlighter(".", "text enclosed in POINTing hand emojis", start="👉", end="👈"),
+        HIGHLIGHT_STRESSED,
+        HIGHLIGHT_UNDERLINE,
+    ]
+    + [
+        Highlighter(
+            color_name[0],
+            f"{color_name.title()} colored text",
+            sgr(sgr_index),
+            apply_in_pipeline=False,
+        )
+        for sgr_index, color_name in enumerate(SUPPORTED_COLORS, start=31)
+    ]
+}
+
+
+@dataclass
+class OutputOptions:
+    """Options for pattern matching"""
+
+    highlighter: Highlighter = NO_HIGHLIGHTING
+    show_files: bool = True
+    show_results: bool = True
+    show_stats: bool = False
+
+
+def single_example(highlighter: Highlighter, text: str) -> str:
+    """split text into words, and apply highlighting to a randow word"""
+    words = text.split()
+    random_word = choice(words).strip(",.")
+    splitted_text = text.split(random_word)
+    return highlighter.enclose(random_word).join(splitted_text)
+
+
+def print_highlighter_examples() -> None:
+    """Print examples of all highlighters"""
+    print(HIGHLIGHT_STRESSED.enclose("– Highlighters showcase –\n"))
+    lorem_ipsum_lines = LOREM_IPSUM.splitlines()
+    for key, highlighter in sorted(HIGHLIGHTERS.items()):
+        random_line = choice(lorem_ipsum_lines)
+        stressed = HIGHLIGHT_STRESSED.enclose(repr(key))
+        addition = (
+            EMPTY
+            if highlighter.apply_in_pipeline or not highlighter
+            else ", not applied if stdout is redirected"
+        )
+        print(f"{stressed} ({highlighter.description}{addition}):")
+        print(indent(f"\n{single_example(highlighter, random_line)}\n", "    > "))
+    #

{offgrep-0.3.0 → offgrep-0.3.1}/src/offgrep/pattern_matching.py

@@ -6,26 +6,22 @@ Pattern matching
 
 from collections import Counter
 from dataclasses import dataclass, field
-from enum import Enum
 from logging import debug, error
 from pathlib import Path
 from re import compile as re_compile, Pattern, IGNORECASE
-from sys import stdin, stdout
+from sys import stdin
 from time import monotonic
 from typing import TextIO, Any
 
-from .commons import EMPTY, UTF_8
+from .commons import UTF_8
+from .output import (
+    OutputOptions,
+    Highlighter,
+    HIGHLIGHT_STRESSED,
+    NO_HIGHLIGHTING,
+)
 
 
-STDOUT_IS_A_TTY = stdout.isatty()
-
-PACKAGE_NAME = "offgrep"
-"""The package name for metadata inspection"""
-ANSI_HI = "\x1b[1m"
-ANSI_NORMAL = "\x1b[0m"
-ANSI_COLOR_RED = "\x1b[31m"
-ANSI_COLOR_GREEN = "\x1b[32m"
-
 _UNDERLINE = "_"
 _SPACE = " "
 
@@ -33,53 +29,6 @@ _FILES_WITH_MATCHES = "files_with_matches"
 _TOTAL_MATCHES = "total_matches"
 
 
-@dataclass(frozen=True)
-class HighlightProfile:
-    """Highlighting profile"""
-
-    start: str = EMPTY
-    end: str = EMPTY
-    requires_tty: bool = True
-
-    @property
-    def is_applicable(self) -> bool:
-        """Indicate if the highlighter can be used"""
-        return not self.requires_tty or STDOUT_IS_A_TTY
-
-    def __bool__(self) -> bool:
-        """Booelan evaluation: not empty"""
-        return bool(f"{self.start}{self.end}")
-
-    def enclose(self, text: str) -> str:
-        """Return the enclosed text if possible"""
-        if self.is_applicable:
-            return f"{self.start}{text}{self.end}"
-        #
-        return text
-
-
-class Highlighter(Enum):
-    """Highlighting profiles container"""
-
-    ARROWS = HighlightProfile(start="➡️", end="⬅️", requires_tty=False)
-    GREEN = HighlightProfile(start=ANSI_COLOR_GREEN, end=ANSI_NORMAL)
-    NONE = HighlightProfile()
-    POINTING = HighlightProfile(start="👉", end="👈", requires_tty=False)
-    PUSHING = HighlightProfile(start="🫸", end="🫷", requires_tty=False)
-    RED = HighlightProfile(start=ANSI_COLOR_RED, end=ANSI_NORMAL)
-    STRESSED = HighlightProfile(start=ANSI_HI, end=ANSI_NORMAL)
-
-
-@dataclass
-class OutputOptions:
-    """Options for pattern matching"""
-
-    highlighter: Highlighter = Highlighter.NONE
-    show_files: bool = True
-    show_results: bool = True
-    show_stats: bool = True
-
-
 @dataclass
 class PatternOptions:
     """Options for pattern matching"""
@@ -230,53 +179,11 @@ class MultiPatternsMatcher:
         return []
 
 
-def highlight_line_matches(
-    line: str,
-    line_areas: list[tuple[int, int]],
-    highlighter: Highlighter = Highlighter.RED,
-) -> str:
-    """Return a colorized line"""
-    if not highlighter.value.is_applicable:
-        return line
-    #
-    pos = 0
-    collector: list[str] = []
-    marked = False
-    for a_start, a_end in line_areas:
-        if a_start > pos:
-            if pos > 0 and marked:
-                collector.append(highlighter.value.end)
-                marked = False
-            #
-            collector.append(line[pos:a_start])
-        #
-        if a_start < pos:
-            a_start = pos
-            if a_end <= pos:
-                continue
-            #
-        #
-        if not marked:
-            collector.append(highlighter.value.start)
-            marked = True
-        #
-        collector.append(line[a_start:a_end])
-        pos = a_end
-    #
-    if marked:
-        collector.append(highlighter.value.end)
-    #
-    if pos < len(line):
-        collector.append(line[pos:])
-    #
-    return EMPTY.join(collector)
-
-
 def find_in_stream(
     input_stream: TextIO | Any,
     mpm: MultiPatternsMatcher,
     collect_stats: bool = False,
-    highlighter: Highlighter = Highlighter.NONE,
+    highlighter: Highlighter = NO_HIGHLIGHTING,
 ) -> tuple[int, list[tuple[int, str]]]:
     """find the patterns in a single file"""
     count = 0
@@ -290,8 +197,9 @@ def find_in_stream(
                 findings.append(
                     (
                         lineno,
-                        highlight_line_matches(
-                            line.rstrip(), line_result, highlighter=highlighter
+                        highlighter.emphasize_matches(
+                            line.rstrip(),
+                            *sorted(set(line_result)),
                         ),
                     )
                 )
@@ -326,6 +234,7 @@ def process_results(
     """process single stream matching results:
     modify stats in place, and print findings
     """
+    stats.update(files_processed=1)
     if count:
         previously_matched_files = stats[_FILES_WITH_MATCHES]
         stats.update(
@@ -340,7 +249,7 @@ def process_results(
             if previously_matched_files:
                 print()
             #
-            print(Highlighter.STRESSED.value.enclose(f"{file_name} ::"))
+            print(HIGHLIGHT_STRESSED.enclose(f"{file_name} ::"))
         #
         for lineno, line in findings:
             print(f"{lineno:{number_width}d}: {line}")
@@ -353,7 +262,7 @@ def show_stats(stats: Counter[str], duration: float) -> None:
     if stats[_TOTAL_MATCHES]:
         print()
     #
-    print(Highlighter.STRESSED.value.enclose("⁘ Statistics ⁘"))
+    print(HIGHLIGHT_STRESSED.enclose("⁘ Statistics ⁘"))
     for key, value in sorted(stats.items()):
         print(f"{value:>6d} {key.replace(_UNDERLINE, _SPACE)}")
     #
@@ -407,7 +316,6 @@ def find_in_files(
                 stats.update(errors=1)
                 continue
             #
-            stats.update(files_processed=1)
             process_results(output_opts, stats, str(single_file), count, findings)
         #
     #