lines

#!/usr/bin/env python3

# "Lines Is Not Exactly Sed"
# Sed-inspired line processor using modern Python regex and format syntax

import re
import sys


###  Main  ###
def main(args):
    # For now, the only args are command strings
    operations = [parse_command(c) for c in args[1:]]
    # print(f"{operations = }")  # TODO: some sort of debug flag/mode
    parse_lines(operations, sys.stdin)


def parse_lines(processors, lines):
    for n,l in enumerate(lines, start=1):
        context = {"Line": l, "LineNum": n}
        for p in processors:
            l, context = p(l, context)
            if l is None:
                break
        else:
            print(l, end="")  # REM: consider yielding lines, so `main` is the one dealing with files and output
#####


###  Command Parsing  ###
CMD_BASE_RE = re.compile(r"(?P<cmd>[a-z]+)(?P<sep>[^a-z])(?P<rest>.*)")
def parse_command(cmd_str):
    m = CMD_BASE_RE.match(cmd_str)
    if not m:
        raise ValueError(f"Could not parse command '{cmd_str}'")
    cmd, sep, rest = (m.group("cmd"), m.group("sep"), m.group("rest"))
    if cmd not in CMD_MAP:
        raise ValueError(f"Unrecognized command '{cmd}'")
    split_rest = rest.split(sep)
    args = split_rest[:-1]
    opts = split_rest[-1]
    # print(f"{cmd = }, {sep = }, {args = }, {opts = }")
    Op = CMD_MAP[cmd]
    return Op(*args, opts)
#####


###  Operation Classes  ###
class Filter:
    def __init__(self, pattern, options):
        # TODO: Add options like invert and re.IGNORECASE
        self.pattern = re.compile(pattern)

    def __call__(self, line, context):
        m = self.pattern.match(line)
        if m:
            # TODO: mark context as matched (or something?)
            context.update(m.groupdict())  # Match groups can be used in later transformers
            return line, context
        return None, context

    def __repr__(self):
        return f"<Filter({self.pattern}) at {id(self)}>"


class Transformer:
    def __init__(self, pattern, fmt, options):
        # TODO: Add options like pass/drop and re.IGNORECASE
        self.pattern = re.compile(pattern)
        self.fmt = fmt

    def __call__(self, line, context):
        m = self.pattern.match(line)
        if m:
            # TODO: mark context as matched (or something?)
            context.update(m.groupdict())
            return self.fmt.format(**context) + "\n", context  # FIXME: use subn to replace all matches
        return None, context

    def __repr__(self):
        return f"<Transformer({self.pattern}, {self.fmt}) at {id(self)}>"


CMD_MAP = {
    "f": Filter,
    "filter": Filter,
    "t": Transformer,
    "trans": Transformer,
    "transform": Transformer,
}
#####

if __name__ == '__main__':
    _xit = main(sys.argv)
    sys.exit(_xit)