offgrep 0.1.1__tar.gz → 0.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: offgrep
-Version: 0.1.1
+Version: 0.3.0
 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
-alterative.
+but are able to install Python packages, **offgrep** might be suitable for you.

{offgrep-0.1.1 → offgrep-0.3.0}/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
-alterative.
+but are able to install Python packages, **offgrep** might be suitable for you.

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

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

offgrep-0.3.0/src/offgrep/__main__.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+
+"""
+Call as script
+"""
+
+import sys
+
+from .arguments import parse_arguments
+from .filesystem import FileSelectionOptions, iter_selected_files
+from .pattern_matching import PatternOptions, OutputOptions, 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
+
+# vim: fileencoding=utf-8 ts=4 sts=4 sw=4 autoindent expandtab syntax=python:

offgrep-0.3.0/src/offgrep/arguments.py

@@ -0,0 +1,359 @@
+# -*- coding: utf-8 -*-
+
+"""
+Command line argument parsing
+"""
+
+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 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
+
+DEFAULT_PRE_IGNORE = ",".join(f"{dirname}/" for dirname in VCSDirectory)
+
+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 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(
+        loglevel=WARNING,
+        encoding=UTF_8,
+        pre_ignore=DEFAULT_PRE_IGNORE,
+        post_ignore=EMPTY,
+    )
+    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",
+    )
+    main_parser.add_argument(
+        "--default-ignore-dirs",
+        help="Always ignore the directories named here, separated by commas."
+        " DEPRECATED, please use --pre-ignore or --post-ignore instead.",
+    )
+    main_parser.add_argument(
+        "--default-ignore-priority",
+        choices=list(Priority),
+        type=Priority,
+        help="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.",
+    )
+    main_parser.add_argument(
+        "--pre-ignore",
+        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).",
+    )
+    main_parser.add_argument(
+        "--post-ignore",
+        help="gitignore-style patterns for files and/or directories ignored"
+        " after applying found ignore file rules, joined with commas (,)."
+        " Empty by default (%(default)s).",
+    )
+    main_parser.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.",
+    )
+    main_parser.add_argument(
+        "-f",
+        "--file",
+        nargs="+",
+        type=Path,
+        dest="patternfiles",
+        metavar="PATTERNFILE",
+        help="Files containing patterns (by default, regular expressions",
+    )
+    main_parser.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.",
+    )
+    main_parser.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.",
+    )
+    main_parser.add_argument(
+        "--encoding",
+        help="Encoding of all files (default: %(default)s)",
+    )
+    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,
+        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:
+    """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, remove_options_end_marker(args, args.positional_args))
+        )
+        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 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()
+    basicConfig(level=args.loglevel)
+    debug(repr(args))
+    if args.type_list:
+        print_supported_file_tyoes()
+        main_parser.exit()
+    #
+    if args.files:
+        return make_file_selecton_options(args), None, OutputOptions()
+    #
+    fso = make_file_selecton_options(args)
+    path_candidates = args.positional_args[:]
+    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="Using offgrep 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))
+        )
+        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 fso.paths[0].is_file()
+    )
+    oo = OutputOptions(
+        highlighter=Highlighter[args.highlight_matches.upper()],
+        show_files=not suppress_file_prefix,
+        show_results=True,
+        show_stats=args.stats,
+    )
+    return fso, po, oo

{offgrep-0.1.1 → offgrep-0.3.0}/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]