offgrep 0.2.0__tar.gz → 0.3.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: offgrep
-Version: 0.2.0
+Version: 0.3.1
 Summary: A lousy ripgrep rip-off in pure Python
 Keywords: grep,recursive
 Author: Rainer Schwarzbach
@@ -67,5 +67,4 @@ instead of **offgrep**.
 
 If you – however – are in a super restricted network (eg. government)
 without a chance to install **ripgrep**,
-but are able to install Python packages, **offgrep** might be an interesting
-alternative.
+but are able to install Python packages, **offgrep** might be suitable for you.

{offgrep-0.2.0 → offgrep-0.3.1}/README.md

@@ -18,5 +18,4 @@ instead of **offgrep**.
 
 If you – however – are in a super restricted network (eg. government)
 without a chance to install **ripgrep**,
-but are able to install Python packages, **offgrep** might be an interesting
-alternative.
+but are able to install Python packages, **offgrep** might be suitable for you.

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

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

offgrep-0.3.1/src/offgrep/__main__.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+
+"""
+Call as script
+"""
+
+import sys
+
+from .arguments import parse_arguments
+from .filesystem import FileSelectionOptions, iter_selected_files
+from .output import OutputOptions
+from .pattern_matching import PatternOptions, find_in_files
+
+
+def grep_files(
+    file_selection_opts: FileSelectionOptions,
+    pattern_opts: PatternOptions,
+    output_opts: OutputOptions,
+) -> int:
+    """Search for text in files"""
+    target_paths = list(iter_selected_files(file_selection_opts))
+    return find_in_files(
+        target_paths, pattern_opts, output_opts, encoding=file_selection_opts.encoding
+    )
+
+
+def list_files(file_selection_opts: FileSelectionOptions) -> int:
+    """List files that would be searched"""
+    for single_file in iter_selected_files(file_selection_opts):
+        print(single_file)
+    #
+    return 0
+
+
+def main() -> int:
+    """Main script interface
+
+    Returns:
+        the script returncode
+    """
+    file_selection_opts, maybe_pattern_opts, output_opts = parse_arguments()
+    if isinstance(maybe_pattern_opts, PatternOptions):
+        return grep_files(file_selection_opts, maybe_pattern_opts, output_opts)
+    #
+    return list_files(file_selection_opts)
+
+
+if __name__ == "__main__":
+    sys.exit(main())  # pragma: no cover

offgrep-0.3.1/src/offgrep/arguments.py

@@ -0,0 +1,426 @@
+# -*- coding: utf-8 -*-
+
+"""
+Command line argument parsing
+"""
+
+from argparse import (
+    ArgumentParser,
+    Namespace,
+    RawDescriptionHelpFormatter,
+    SUPPRESS,
+)
+from importlib.metadata import PackageNotFoundError, version as metadata_version
+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,
+    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"""
+
+_EPILOG = """The provided options (or usage in a shell pipeline)
+determine how the positional arguments are interpreted:
+
+  (1) offgrep [OPTIONS] PATTERN [PATH ...],
+        the first positional argument is interpreted as the pattern,
+        the remaining ones as paths.
+  (2) offgrep [OPTIONS] -e PATTERN ... [PATH ...]
+        all positional argument are interpreted as paths.
+  (3) offgrep [OPTIONS] -f PATTERNFILE ... [PATH ...]
+        all positional argument are interpreted as paths.
+  (4) offgrep [OPTIONS] --files [PATH ...]
+        all positional argument are interpreted as paths.
+  (5) offgrep [OPTIONS] --type-list
+        all positional arguments are ignored.
+  (6) command | offgrep [OPTIONS] PATTERN
+        the first positional argument is interpreted as the pattern
+        if no pattern has been provided through -e or -f,
+        the remaining positional arguments are ignored.
+
+If no paths were provided as positional arguments in scenarios 1 through 4,
+the current working directory will be used as the starting point.
+"""
+
+
+def get_file_contents(file_name: str, up_dirs: int = 0) -> str:
+    """get contents of a file in an ancestor directory
+    of the current file
+
+    ...
+    """
+    file_dir_path = Path(__file__).resolve()
+    for _ in range(up_dirs):
+        file_dir_path = file_dir_path.parent
+    #
+    file_path = file_dir_path / file_name
+    return file_path.read_text(encoding=UTF_8)
+
+
+def get_metadata_version(
+    metadata_file_name: str = "pyproject.toml", up_dirs: int = 3
+) -> str:
+    """get version information from _metadata_file_name_ in an ancestor directory
+
+    ...
+    """
+    try:
+        metadata_file_contents = get_file_contents(metadata_file_name, up_dirs=up_dirs)
+    except IOError as io_error:
+        return str(io_error)
+    #
+    metadata = tomli_loads(metadata_file_contents)
+    try:
+        # logging.warning(str(metadata.items()))
+        version = metadata["project"]["version"]
+    except KeyError:
+        return f"Error: no version information in metadata from {metadata_file_name}"
+    #
+    return f"{version} (read directly from {metadata_file_name})"
+
+
+def determine_ignore_file_mode() -> IgnoreFileMode:
+    """dummy for now"""
+    return IgnoreFileMode.AUTOMATIC
+
+
+def determine_types(types_arg: list[str] | None) -> list[str]:
+    """dummy for now"""
+    if isinstance(types_arg, list):
+        for single_type in types_arg:
+            warning("--type %s option not implemented yet", single_type)
+        #
+    #
+    return []
+
+
+def print_supported_file_tyoes() -> None:
+    """Print the list of supported file types"""
+    warning("--type-list option not implemented yet")
+
+
+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}.",
+        )
+    #
+    match_highlight_mutex.add_argument(
+        "--highlighters",
+        action="store_true",
+        help="Show highlighter effects on examples.",
+    )
+    output_group.add_argument(
+        "--stats",
+        action="store_true",
+        help="Collect and show statistics.",
+    )
+    output_group.add_argument(
+        "--files",
+        action="store_true",
+        help="Print the path of each file that would be searched,"
+        " without actually performing the search.",
+    )
+    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",
+        metavar="DIRECTORY-NAMES",
+        help="DEPRECATED, please use --pre-ignore or --post-ignore instead."
+        " Original purpose: always ignore the directories named here,"
+        " separated by commas.",
+    )
+    file_group.add_argument(
+        "--default-ignore-priority",
+        choices=list(Priority),
+        type=Priority,
+        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}.",
+    )
+    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)r).",
+    )
+    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)r).",
+    )
+    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="+",
+        dest="patterns",
+        metavar="PATTERN",
+        help="Patterns (by default, reular exoressions) to search for."
+        " Use this option with multiple arguments if you want to seatch for"
+        " multpile patterns at once.",
+    )
+    pattern_group.add_argument(
+        "-f",
+        "--file",
+        nargs="+",
+        type=Path,
+        dest="patternfiles",
+        metavar="PATTERNFILE",
+        help="Files containing patterns (by default, regular expressions",
+    )
+    pattern_group.add_argument(
+        "-F",
+        "--fixed-strings",
+        action="store_true",
+        help="treat the given pattern(s) as fixed strings instead of regular"
+        " expressions so special characters – .+*()[]{} – do not need to be escaped,"
+        " also saving some energy.",
+    )
+    pattern_group.add_argument(
+        "-i",
+        "--ignore-case",
+        action="store_false",
+        dest="case_sensitive",
+        help="case-insensitive matching",
+    )
+
+
+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(
+        "positional",
+        nargs="*",
+        help=SUPPRESS,
+    )
+    return main_parser
+
+
+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)
+    if args.default_ignore_dirs:
+        ignore_list = [f"{dirname}/" for dirname in args.default_ignore_dirs]
+        match args.default_ignore_priority:
+            case Priority.LOW:
+                pre_ignore = ignore_list
+            case Priority.HIGH:
+                post_ignore = ignore_list
+            #
+        #
+    #
+    if args.files:
+        paths: list[Path] = list(map(Path, args.positional))
+        if not paths:
+            paths.append(Path.cwd())
+        #
+        return FileSelectionOptions(
+            paths=paths,
+            pre_ignore=pre_ignore,
+            post_ignore=post_ignore,
+            types=determine_types(args.type),
+            ignore_file_mode=determine_ignore_file_mode(),
+            encoding=args.encoding,
+        )
+    #
+    return FileSelectionOptions(
+        paths=[],
+        pre_ignore=pre_ignore,
+        post_ignore=post_ignore,
+        types=determine_types(args.type),
+        ignore_file_mode=determine_ignore_file_mode(),
+        encoding=args.encoding,
+    )
+
+
+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
+]:
+    """Parse commandline arguments and configure logging
+
+    Returns:
+        the parsed command line arguments
+    """
+    main_parser = build_argument_parser()
+    args = main_parser.parse_args()
+    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_selection_options(args),
+            None,
+            OutputOptions(show_files=produce_output),
+        )
+    #
+    fso = make_file_selection_options(args)
+    path_candidates = args.positional[:]
+    patterns: list[str] = []
+    if args.patterns:
+        patterns.extend(args.patterns)
+    elif args.patternfiles:
+        for single_file in args.patternfiles:
+            patterns.extend(single_file.read_text(encoding=args.encoding).splitlines())
+        #
+    else:
+        try:
+            patterns = [path_candidates.pop(0)]
+        except IndexError:
+            main_parser.exit(
+                status=1,
+                message="This command variant requires at least one pattern"
+                " as a positional argument.",
+            )
+        #
+    #
+    if stdin.isatty():
+        paths: list[Path] = list(map(Path, path_candidates))
+        if not paths:
+            paths.append(Path.cwd())
+        #
+        fso.paths = paths
+    #
+    po = PatternOptions(
+        patterns=patterns,
+        plaintext=args.fixed_strings,
+        case_sensitive=args.case_sensitive,
+    )
+    suppress_file_prefix = not fso.paths or (
+        len(fso.paths) == 1 and is_an_eligible_path(fso.paths[0])
+    )
+    oo = OutputOptions(
+        highlighter=HIGHLIGHTERS[args.hi],
+        show_files=not suppress_file_prefix,
+        show_results=produce_output,
+        show_stats=args.stats,
+    )
+    return fso, po, oo

{offgrep-0.2.0 → offgrep-0.3.1}/src/offgrep/commons.py

@@ -39,3 +39,8 @@ SLASH = "/"
 
 UTF_8 = "utf-8"
 """Explicit default encoding"""
+
+
+def split_without_empty_strings(source: str, delimiter: str = ",") -> list[str]:
+    """Split result without empty strings"""
+    return [part for part in source.split(delimiter) if part]