From 20d0424930c8cd5a731fc8b8a95ebe5020220b12 Mon Sep 17 00:00:00 2001
From: nojhan <nojhan@nojhan.net>
Date: Sun, 5 Apr 2026 11:57:14 +0200
Subject: [PATCH] feat: operator arguments

---
 src/forthlift/forthlift.py | 46 +++++++++++++++++++++++++++-----------
 1 file changed, 33 insertions(+), 13 deletions(-)

diff --git a/src/forthlift/forthlift.py b/src/forthlift/forthlift.py
index fb45226..8592dcd 100755
--- a/src/forthlift/forthlift.py
+++ b/src/forthlift/forthlift.py
@@ -1,5 +1,6 @@
 #!/usr/bin/env python
 
+import re
 import sys
 import locale
 import logging
@@ -42,8 +43,8 @@ class format:
             return items
 
     class trim(Format):
-        def __init__(self, max = 14):
-            self.max = max
+        def __init__(self, max = "14"):
+            self.max = int(max)
 
         def trim(self, line):
             if len(line) > self.max:
@@ -158,6 +159,23 @@ def classes_of(namespace):
     subs = {cls.__name__:cls for cls in itf.__subclasses__()}
     return subs
 
+def operator(asked_op):
+    logger.debug(f"├ Parsed operators:")
+    for op in asked_op:
+        # We do not use a f(a) notation,
+        # because the shell would try to interpret
+        # any unescaped/unquoted parentheses.
+        # It is faster to use f:a for the user.
+        m = re.match("(\w+):(.+)", op)
+        if m:
+            name = m.group(1)
+            args = [a.strip() for a in m.group(2).split(',')]
+        else:
+            name = op
+            args = []
+        logger.debug(f"│ ├ {name}({','.join(args)})")
+        yield name,args
+    logger.debug("│ └OK")
 
 def main():
     errors = {"NO_ERROR":0, "UNKNOWN_ERROR":1, "NO_SETUP_NEEDED":2, "NO_APP_KEY":10}
@@ -169,31 +187,31 @@ def main():
 
     streamers = classes_of(stream)
     parser.add_argument("-s", "--stream",
-        choices = streamers.keys(),
-        # metavar = "STREAMER(S)",
+        # choices = streamers.keys(),
+        metavar = '{' + ','.join(streamers) + '}',
         default = [],
         action="append",
         help="Where to get items.")
 
     consumers = classes_of(consume)
     parser.add_argument("-c", "--consume",
-        choices = consumers.keys(),
-        # metavar = "CONSUMER",
+        # choices = consumers.keys(),
+        metavar = '{' + ','.join(consumers) + '}',
         default = "lines",
         help="How to get the content form items.")
 
     formaters = classes_of(format)
     parser.add_argument("-f", "--format",
-        choices = formaters.keys(),
-        # metavar = "FORMATER(S)",
+        # choices = formaters.keys(),
+        metavar = '{' + ','.join(formaters) + '}',
         default = [],
         action="append",
         help="How to format items.")
 
     lifters = classes_of(lift)
     parser.add_argument("-l", "--lift",
-        choices = lifters.keys(),
-        # metavar = "LIFTER(S)",
+        # choices = lifters.keys(),
+        metavar = '{' + ','.join(lifters) + '}',
         default = [],
         action="append",
         help="How to lift items.")
@@ -210,6 +228,8 @@ def main():
     logger.debug(f"├ formaters: {', '.join(formaters)}")
     logger.debug(f"└ lifters: {', '.join(lifters)}")
 
+    # Sane defaults. Cannot be a default in argparse,
+    # because choices would be append to it.
     if not asked.stream:
         asked.stream = ["stdin"]
 
@@ -222,9 +242,9 @@ def main():
     logger.debug("Chosen operators:")
     forthlift = Forthlifter(
         consumer   = consumers[asked.consume](),
-        streamers  = [streamers[k]() for k in asked.stream],
-        formatters = [formaters[k]() for k in asked.format],
-        lifters    = [  lifters[k]() for k in asked.lift  ],
+        streamers  = [streamers[op](*args) for op,args in operator(asked.stream)],
+        formatters = [formaters[op](*args) for op,args in operator(asked.format)],
+        lifters    = [  lifters[op](*args) for op,args in operator(asked.lift  )],
     )
     logger.debug("Run:")
     forthlift()