evre

#!/usr/bin/env python3

'''evREwhere is a pattern searcher like grep but enables extended capabilities

evREwhere can be used as a module or a separate utility program

Examples needed here...
'''

import sys
import pathlib
import argparse
import traceback
import collections
from evrewhere import PatternFinder
from evrewhere.printers import FileInfoPrefixPrinter, MatchPrinter, VerbosePrinter


def parse_arguments() -> argparse.Namespace:
    '''Parse program arguments'''
    def postparse(args: argparse.Namespace) -> argparse.Namespace:
        '''Post-parse program arguments'''
        if not sys.stdin.isatty():
            args.paths.append(sys.stdin)
        if args.count_only:
            if args.with_lineno:
                raise ValueError('-n and -c are mutually exclusive')
            if args.full_lines:
                raise ValueError('--full-lines and --count are mutually exclusive')
        if args.full_lines and args.template is not None:
            raise ValueError('--full-lines and --format are mutually exclusive')
        if args.with_filename is None:
            args.with_filename = args.recursive or len(args.paths) > 1
        elif args.verbose and not args.with_filename:
            raise ValueError('--verbose does not support -h/--no-filename')
        return args

    parser = argparse.ArgumentParser(add_help=False)
    parser.add_argument(
        '--help', action='help', default=argparse.SUPPRESS,
        help='show this help message and exit'
    )
    parser.add_argument(
        'pattern',
        help='pattern used in search'
    )
    parser.add_argument(
        'paths', nargs='*', type=pathlib.Path,
        help='path to a directory (-r required) or file'
    )
    parser.add_argument(
        '-r', action='store_true', dest='recursive', default=False,
        help='recursive search'
    )
    parser.add_argument(
        '-m', dest='limit', type=int, default=0,
        help='maximum matches (default: no limit)'
    )
    parser.add_argument(
        '-n', '--lineno', dest='with_lineno', action='store_true',
        help='whether to display line numbers (may affect performance)'
    )
    parser.add_argument(
        '-f', '--format', dest='template', default=None,
        help='display format, {0} means group(0) (default: {0})'
    )
    parser.add_argument(
        '-H', '--with-filename', dest='with_filename', action='store_true', default=None,
        help='print file name with output lines'
    )
    parser.add_argument(
        '-h', '--no-filename', dest='with_filename', action='store_false', default=None,
        help='suppress the file name prefix on output'
    )
    parser.add_argument(
        '-g', '--full-lines', dest='full_lines', action='store_true',
        help='print full lines like grep (may affect performance)'
    )
    parser.add_argument(
        '-i', '--ignore-case', dest='case_insensitive', action='store_true',
        help='case insensitive search'
    )
    parser.add_argument(
        '-a', '--dot-all', dest='dot_all', action='store_true',
        help='dot (.) includes newline characters'
    )
    parser.add_argument(
        '-q', '--quiet', '--silent', dest='quiet', action='store_true',
        help='suppress all normal output'
    )
    parser.add_argument(
        '-c', '--count', dest='count_only', action='store_true',
        help='print only a (positive) number of matches per file'
    )
    parser.add_argument(
        '-v', '--verbose', action='store_true', dest='verbose',
        help='outputs regex Match object instead of raw text'
    )
    args = parser.parse_args()
    try:
        return postparse(args)
    except ValueError as error:
        parser.error(error)


def main() -> int:
    '''Run program as a utility with argument parsing

    Returns 0 if a match was found or 1 if none were found'''
    args = parse_arguments()
    finder = PatternFinder(
        args.pattern,
        limit=args.limit,
        line_numbers=args.with_lineno,
        case_insensitive=args.case_insensitive,
        dot_all=args.dot_all,
        full_lines=args.full_lines,
    )
    found = finder.search(args.paths, recursive=args.recursive)
    exit_code = int(not found)
    if args.count_only:
        prefix_printer = FileInfoPrefixPrinter(with_filename=args.with_filename)
        counts = collections.Counter(result.path for result in found)
        for path in counts:
            prefix_printer.print(path, 0, counts[path], sep='')
        return exit_code
    if args.quiet:
        return exit_code
    if args.verbose:
        printer = VerbosePrinter()
    else:
        printer = MatchPrinter(
            args.template,
            finder.pattern.groups,
            with_filename=args.with_filename,
            with_lineno=args.with_lineno,
            full_lines=args.full_lines,
        )
    # Show results
    for result in found:
        printer.print(result)
    return exit_code


if __name__ == '__main__':
    EXIT_CODE = 255
    try:
        EXIT_CODE = main()
    except KeyboardInterrupt:
        EXIT_CODE = 130
    except OSError as error:
        print(f'evre: {error.filename}: {error.strerror}')
        EXIT_CODE = 2
    except SystemExit:
        sys.exit(EXIT_CODE)
    except:  # pylint: disable=bare-except
        # This bare except makes sure that all exceptions
        # have a defined exit code and are printed properly
        traceback.print_exc()
    sys.exit(EXIT_CODE)