#3 Allow parsing ParamArray Args(). Closes #3.

Author: rudolfbyker

Diff for: mkdocstrings_handlers/vba/regex.py

@@ -2,8 +2,9 @@
 
 re_arg = re.compile(
     r"((?P<optional>Optional) +)?"
-    r"((?P<modifier>ByVal|ByRef) +)?"
+    r"((?P<modifier>ByVal|ByRef|ParamArray) +)?"
     r"(?P<name>[A-Z_][A-Z0-9_]*)"
+    r"(\(\))?"
     r"( +As +(?P<type>[A-Z_][A-Z0-9_]*))?"
     r"( *= *(?P<default>.*))?",
     re.IGNORECASE,

Diff for: mkdocstrings_handlers/vba/util.py

@@ -79,25 +79,35 @@ def parse_args(args: str) -> Generator[VbaArgumentInfo, None, None]:
     """
     Parse the arguments portion of a signature line of a VBA procedure.
     """
-    for arg in args.split(","):
-        arg = arg.strip()
-        if not len(arg):
-            continue
+    args = args.strip()
+    if not len(args):
+        return
 
-        match = re_arg.fullmatch(arg)
+    for arg in args.split(","):
+        yield parse_arg(arg)
 
-        if match is None:
-            raise RuntimeError(f"Failed to parse argument: {arg}")
-        match = match.groupdict()
 
-        yield VbaArgumentInfo(
-            optional=bool(match["optional"]),
-            modifier=match["modifier"],
-            name=match["name"],
-            arg_type=match["type"],
-            default=match["default"],
+def parse_arg(arg: str) -> VbaArgumentInfo:
+    arg = arg.strip()
+    if not len(arg):
+        raise NotImplementedError(
+            "What do we do with empty arguments in a function signature?"
         )
 
+    match = re_arg.fullmatch(arg)
+
+    if match is None:
+        raise RuntimeError(f"Failed to parse argument: {arg}")
+    match = match.groupdict()
+
+    return VbaArgumentInfo(
+        optional=bool(match["optional"]),
+        modifier=match["modifier"],
+        name=match["name"],
+        arg_type=match["type"],
+        default=match["default"],
+    )
+
 
 def parse_signature(line: str) -> VbaSignatureInfo:
     """

Diff for: test/util/test_parse_args.py

@@ -1,7 +1,57 @@
 import unittest
 
 from mkdocstrings_handlers.vba.types import VbaArgumentInfo
-from mkdocstrings_handlers.vba.util import parse_args
+from mkdocstrings_handlers.vba.util import parse_args, parse_arg
+
+
+class TestParseArg(unittest.TestCase):
+    def test_1(self):
+        cases = [
+            (
+                "bar As listObject",
+                VbaArgumentInfo(
+                    name="bar",
+                    optional=False,
+                    modifier=None,
+                    arg_type="listObject",
+                    default=None,
+                ),
+            ),
+            (
+                "ByVal v As Variant",
+                VbaArgumentInfo(
+                    name="v",
+                    optional=False,
+                    modifier="ByVal",
+                    arg_type="Variant",
+                    default=None,
+                ),
+            ),
+            (
+                'Optional ByRef s1 As String = "Hello"',
+                VbaArgumentInfo(
+                    name="s1",
+                    optional=True,
+                    modifier="ByRef",
+                    arg_type="String",
+                    default='"Hello"',
+                ),
+            ),
+            (
+                "ParamArray Args() As Variant",
+                VbaArgumentInfo(
+                    name="Args",
+                    optional=False,
+                    modifier="ParamArray",
+                    arg_type="Variant",
+                    default=None,
+                ),
+            ),
+        ]
+
+        for (arg_string, result) in cases:
+            with self.subTest(arg_string):
+                self.assertEqual(result, parse_arg(arg_string))
 
 
 class TestParseArgs(unittest.TestCase):
@@ -46,42 +96,6 @@ def test_1(self):
                     ),
                 ],
             ),
-            (
-                "bar As listObject",
-                [
-                    VbaArgumentInfo(
-                        name="bar",
-                        optional=False,
-                        modifier=None,
-                        arg_type="listObject",
-                        default=None,
-                    )
-                ],
-            ),
-            (
-                "ByVal v As Variant",
-                [
-                    VbaArgumentInfo(
-                        name="v",
-                        optional=False,
-                        modifier="ByVal",
-                        arg_type="Variant",
-                        default=None,
-                    )
-                ],
-            ),
-            (
-                'Optional ByRef s1 As String = "Hello"',
-                [
-                    VbaArgumentInfo(
-                        name="s1",
-                        optional=True,
-                        modifier="ByRef",
-                        arg_type="String",
-                        default='"Hello"',
-                    )
-                ],
-            ),
         ]
 
         for (args_string, result) in cases:

Diff for: test/util/test_parse_signature.py

@@ -71,6 +71,24 @@ def test_1(self):
                     ],
                 ),
             ),
+            (
+                "Function dict(ParamArray Args() As Variant)",
+                VbaSignatureInfo(
+                    visibility=None,
+                    return_type=None,
+                    procedure_type="Function",
+                    name="dict",
+                    args=[
+                        VbaArgumentInfo(
+                            name="Args",
+                            optional=False,
+                            modifier="ParamArray",
+                            arg_type="Variant",
+                            default=None,
+                        )
+                    ],
+                ),
+            ),
         ]
 
         for (signature, result) in cases: