feat: Better support for concatenated short args.

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cappa"
-version = "0.8.5"
+version = "0.8.6"
 description = "Declarative CLI argument parser."
 
 repository = "https://github.com/dancardin/cappa"

src/cappa/arg.py

@@ -226,7 +226,7 @@ def infer_short(arg: Arg, name: str) -> list[str] | typing.Literal[False]:
     else:
         short = arg.short
 
-    return [item[:2] if item.startswith("-") else f"-{item[0]}" for item in short]
+    return [item if item.startswith("-") else f"-{item[0]}" for item in short]
 
 
 def infer_long(arg: Arg, origin: type, name: str) -> list[str] | typing.Literal[False]:

src/cappa/parser.py

@@ -234,13 +234,12 @@ class RawOption:
     @classmethod
     def from_str(cls, arg: str) -> RawOption:
         is_long = arg.startswith("--")
+        is_explicit = "=" in arg
 
         name = arg
         value = None
-        if is_long:
-            is_explicit = "=" in arg
-            if is_explicit:
-                name, value = arg.split("=")
+        if is_explicit:
+            name, value = arg.split("=")
         return cls(name=name, is_long=is_long, value=value)
 
 
@@ -299,12 +298,53 @@ def parse_short_option(context: ParseContext, arg: RawOption) -> None:
     if arg.name == "-" and context.provide_completions:
         return parse_option(context, arg)
 
-    for ch in arg.name[1:]:
-        opt = RawOption(f"-{ch}", is_long=True)
+    virtual_options, virtual_arg = generate_virtual_args(arg, context.options)
+    *first_virtual_options, last_virtual_option = virtual_options
+
+    for opt in first_virtual_options:
         parse_option(context, opt)
+
+    if virtual_arg:
+        context.remaining_args.appendleft(virtual_arg)
+
+    parse_option(context, last_virtual_option)
     return None
 
 
+def generate_virtual_args(
+    arg: RawOption, options: dict[str, typing.Any]
+) -> tuple[list[RawOption], RawArg | None]:
+    """Produce "virtual" options from short (potentially concatenated) options.
+
+    Examples:
+        -abc -> -a, -b, -c
+        -c0 -> -c 0
+        -abc0 -> -a, -b, -c, 0
+    """
+    result = []
+
+    partial_arg = ""
+    remaining_arg = arg.name[1:]
+    while remaining_arg:
+        partial_arg += remaining_arg[0]
+        remaining_arg = remaining_arg[1:]
+
+        option_name = f"-{partial_arg}"
+        if option_name in options:
+            result.append(RawOption(option_name, is_long=True, value=arg.value))
+            partial_arg = ""
+
+    if not result:
+        # i.e. -p, where -p is not a real short option. It will get skipped above.
+        return ([RawOption(arg.name, is_long=True, value=arg.value)], None)
+
+    raw_arg = None
+    if partial_arg:
+        raw_arg = RawArg(partial_arg)
+
+    return (result, raw_arg)
+
+
 def parse_args(context: ParseContext) -> None:
     while context.arguments:
         if isinstance(context.peek_value(), RawOption):

tests/parser/test_concatenated_short_options.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+
+import cappa
+from typing_extensions import Annotated
+
+from tests.utils import backends, parse
+
+
+@cappa.command(name="insiders")
+@dataclass
+class Args:
+    arg: Annotated[int, cappa.Arg(short="-a", long=True)]
+    foo: Annotated[bool, cappa.Arg(short="-f", long=True)] = False
+    bar: Annotated[bool, cappa.Arg(short="-b", long=True)] = False
+
+
+@backends
+def test_single_option_value_no_space(backend):
+    args = parse(Args, "-a0", backend=backend)
+    assert args == Args(arg=0, foo=False, bar=False)
+
+
+@backends
+def test_single_option_value_equals(backend):
+    args = parse(Args, "-a=0", backend=backend)
+    assert args == Args(arg=0, foo=False, bar=False)
+
+
+@backends
+def test_mulitple_option_no_space(backend):
+    args = parse(Args, "-fba0", backend=backend)
+    assert args == Args(arg=0, foo=True, bar=True)

tests/parser/test_multicharacter_short.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+
+import cappa
+from typing_extensions import Annotated
+
+from tests.utils import backends, parse
+
+
+@cappa.command(name="insiders")
+@dataclass
+class Args:
+    arg: Annotated[int, cappa.Arg(short="-ab")]
+    foo: Annotated[bool, cappa.Arg(short="-bc")] = False
+
+
+@backends
+def test_single_opt(backend):
+    args = parse(Args, "-ab", "1", backend=backend)
+    assert args == Args(arg=1, foo=False)