Renamed Macro.arg_list to Macro.args and changed it to a tuple.

Author: kmvanbrunt

CHANGELOG.md

@@ -47,6 +47,7 @@ shell, and the option for a persistent bottom bar that can display realtime stat
     - Removed `Statement.pipe_to` since it can be handled by `Statement.redirector` and
       `Statement.redirect_to`.
     - Changed `StatementParser.parse_command_only()` to return a `PartialStatement` object.
+    - Renamed `Macro.arg_list` to `Macro.args`.
 - Enhancements
     - New `cmd2.Cmd` parameters
         - **auto_suggest**: (boolean) if `True`, provide fish shell style auto-suggestions. These

cmd2/cmd2.py

@@ -2948,7 +2948,7 @@ def _resolve_macro(self, statement: Statement) -> str | None:
         # Resolve the arguments in reverse and read their values from statement.argv since those
         # are unquoted. Macro args should have been quoted when the macro was created.
         resolved = macro.value
-        reverse_arg_list = sorted(macro.arg_list, key=lambda ma: ma.start_index, reverse=True)
+        reverse_arg_list = sorted(macro.args, key=lambda ma: ma.start_index, reverse=True)
 
         for macro_arg in reverse_arg_list:
             if macro_arg.is_escaped:
@@ -3740,7 +3740,7 @@ def _macro_create(self, args: argparse.Namespace) -> None:
             value += ' ' + ' '.join(args.command_args)
 
         # Find all normal arguments
-        arg_list = []
+        macro_args = []
         normal_matches = re.finditer(MacroArg.macro_normal_arg_pattern, value)
         max_arg_num = 0
         arg_nums = set()
@@ -3759,7 +3759,7 @@ def _macro_create(self, args: argparse.Namespace) -> None:
                 arg_nums.add(cur_num)
                 max_arg_num = max(max_arg_num, cur_num)
 
-                arg_list.append(MacroArg(start_index=cur_match.start(), number_str=cur_num_str, is_escaped=False))
+                macro_args.append(MacroArg(start_index=cur_match.start(), number_str=cur_num_str, is_escaped=False))
         except StopIteration:
             pass
 
@@ -3778,15 +3778,15 @@ def _macro_create(self, args: argparse.Namespace) -> None:
                 # Get the number string between the braces
                 cur_num_str = re.findall(MacroArg.digit_pattern, cur_match.group())[0]
 
-                arg_list.append(MacroArg(start_index=cur_match.start(), number_str=cur_num_str, is_escaped=True))
+                macro_args.append(MacroArg(start_index=cur_match.start(), number_str=cur_num_str, is_escaped=True))
         except StopIteration:
             pass
 
         # Set the macro
         result = "overwritten" if args.name in self.macros else "created"
         self.poutput(f"Macro '{args.name}' {result}")
 
-        self.macros[args.name] = Macro(name=args.name, value=value, minimum_arg_count=max_arg_num, arg_list=arg_list)
+        self.macros[args.name] = Macro(name=args.name, value=value, minimum_arg_count=max_arg_num, args=macro_args)
         self.last_result = True
 
     # macro -> delete

cmd2/parsing.py

@@ -3,13 +3,19 @@
 import re
 import shlex
 import sys
-from collections.abc import Iterable
+from collections.abc import (
+    Iterable,
+    Sequence,
+)
 from dataclasses import (
     asdict,
     dataclass,
     field,
 )
-from typing import Any
+from typing import (
+    Any,
+    ClassVar,
+)
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -37,13 +43,9 @@ def shlex_split(str_to_split: str) -> list[str]:
     return shlex.split(str_to_split, comments=False, posix=False)
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, slots=True)
 class MacroArg:
-    """Information used to replace or unescape arguments in a macro value when the macro is resolved.
-
-    Normal argument syntax:    {5}
-    Escaped argument syntax:  {{5}}.
-    """
+    """Information used to resolve or unescape macro arguments."""
 
     # The starting index of this argument in the macro value
     start_index: int
@@ -56,21 +58,22 @@ class MacroArg:
     # Tells if this argument is escaped and therefore needs to be unescaped
     is_escaped: bool
 
-    # Pattern used to find normal argument
-    # Digits surrounded by exactly 1 brace on a side and 1 or more braces on the opposite side
-    # Match strings like: {5}, {{{{{4}, {2}}}}}
-    macro_normal_arg_pattern = re.compile(r'(?<!{){\d+}|{\d+}(?!})')
+    # Matches normal args like {5}
+    # Uses lookarounds to ensure exactly one brace.
+    # (?<!{){ -> Match '{' not preceded by '{'
+    # \d+     -> Match digits
+    # }(?!})  -> Match '}' not followed by '}'
+    macro_normal_arg_pattern: ClassVar[re.Pattern[str]] = re.compile(r'(?<!{){\d+}|{\d+}(?!})')
 
-    # Pattern used to find escaped arguments
-    # Digits surrounded by 2 or more braces on both sides
-    # Match strings like: {{5}}, {{{{{4}}, {{2}}}}}
-    macro_escaped_arg_pattern = re.compile(r'{{2}\d+}{2}')
+    # Matches escaped args like {{5}}
+    # Specifically looking for exactly two braces on each side.
+    macro_escaped_arg_pattern: ClassVar[re.Pattern[str]] = re.compile(r'{{2}\d+}{2}')
 
     # Finds a string of digits
-    digit_pattern = re.compile(r'\d+')
+    digit_pattern: ClassVar[re.Pattern[str]] = re.compile(r'\d+')
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, slots=True)
 class Macro:
     """Defines a cmd2 macro."""
 
@@ -83,8 +86,15 @@ class Macro:
     # The minimum number of args the user has to pass to this macro
     minimum_arg_count: int
 
-    # Used to fill in argument placeholders in the macro
-    arg_list: list[MacroArg] = field(default_factory=list)
+    # Metadata for argument placeholders and escaped sequences found in 'value'.
+    # This is stored internally as a tuple.
+    args: Sequence[MacroArg] = field(default_factory=tuple)
+
+    def __post_init__(self) -> None:
+        """Finalize the object after initialization."""
+        # Convert args to an immutable tuple.
+        if not isinstance(self.args, tuple):
+            object.__setattr__(self, 'args', tuple(self.args))
 
 
 @dataclass(frozen=True)