Merge pull request #155 from Pennycook/custom-argparse-actions

Add custom argparse actions

Author: Pennycook

codebasin/config.py

@@ -10,6 +10,7 @@
 import logging
 import os
 import re
+import string
 
 from codebasin import CompilationDatabase, util
 
@@ -72,6 +73,83 @@ def load_importcfg():
             _importcfg[name] = compiler["options"]
 
 
+class _StoreSplitAction(argparse.Action):
+    """
+    A custom argparse.Action that splits the value based on a user-provided
+    separator, then stores the resulting list.
+    """
+
+    def __init__(
+        self,
+        option_strings: list[str],
+        dest: str,
+        nargs=None,
+        **kwargs,
+    ):
+        self.sep = kwargs.pop("sep", None)
+        self.format = kwargs.pop("format", None)
+        super().__init__(option_strings, dest, nargs=nargs, **kwargs)
+
+    def __call__(
+        self,
+        parser: argparse.ArgumentParser,
+        namespace: argparse.Namespace,
+        values: str,
+        option_string: str,
+    ):
+        if not isinstance(values, str):
+            raise TypeError("store_split expects string values")
+        split_values = values.split(self.sep)
+        if self.format:
+            template = string.Template(self.format)
+            split_values = [template.substitute(value=v) for v in split_values]
+        if self.dest == "passes":
+            passes = getattr(namespace, self.dest)
+            passes[option_string] = split_values
+        else:
+            setattr(namespace, self.dest, split_values)
+
+
+class _ExtendMatchAction(argparse.Action):
+    """
+    A custom argparse.Action that matches the value against a user-provided
+    pattern, then extends the destination list using the result(s).
+    """
+
+    def __init__(
+        self,
+        option_strings: list[str],
+        dest: str,
+        nargs=None,
+        **kwargs,
+    ):
+        self.pattern = kwargs.pop("pattern", None)
+        self.format = kwargs.pop("format", None)
+        super().__init__(option_strings, dest, nargs=nargs, **kwargs)
+
+    def __call__(
+        self,
+        parser: argparse.ArgumentParser,
+        namespace: argparse.Namespace,
+        value: str,
+        option_string: str,
+    ):
+        if not isinstance(value, str):
+            raise TypeError("extend_match expects string value")
+        matches = re.findall(self.pattern, value)
+        if self.format:
+            template = string.Template(self.format)
+            matches = [template.substitute(value=v) for v in matches]
+        if self.dest == "passes":
+            passes = getattr(namespace, self.dest)
+            if option_string not in passes:
+                passes[option_string] = []
+            passes[option_string].extend(matches)
+        else:
+            dest = getattr(namespace, self.dest)
+            dest.extend(matches)
+
+
 class Compiler:
     """
     Represents the behavior of a specific compiler, including:

tests/compilers/test_actions.py

@@ -0,0 +1,128 @@
+# Copyright (C) 2019-2024 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+
+import argparse
+import logging
+import unittest
+
+from codebasin.config import _ExtendMatchAction, _StoreSplitAction
+
+
+class TestActions(unittest.TestCase):
+    """
+    Test that custom argparse.Action classes work as expected.
+    These classes enable handling of complex user-defined compiler options.
+    """
+
+    def setUp(self):
+        logging.disable()
+
+    def test_store_split_init(self):
+        """Check that store_split recognizes custom arguments"""
+        action = _StoreSplitAction(["--foo"], "foo", sep=",", format="$value")
+        self.assertEqual(action.sep, ",")
+        self.assertEqual(action.format, "$value")
+
+        action = _StoreSplitAction(["--foo"], "foo")
+        self.assertEqual(action.sep, None)
+        self.assertEqual(action.format, None)
+
+    def test_store_split(self):
+        """Check that argparse calls store_split correctly"""
+        namespace = argparse.Namespace()
+        namespace.passes = {}
+
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--foo", action=_StoreSplitAction, sep=",")
+        parser.add_argument(
+            "--bar",
+            action=_StoreSplitAction,
+            sep=",",
+            format="prefix-$value-suffix",
+        )
+        parser.add_argument("--baz", action=_StoreSplitAction, type=int)
+        parser.add_argument(
+            "--qux",
+            action=_StoreSplitAction,
+            sep=",",
+            dest="passes",
+        )
+
+        args, _ = parser.parse_known_args(["--foo=one,two"], namespace)
+        self.assertEqual(args.foo, ["one", "two"])
+
+        args, _ = parser.parse_known_args(["--bar=one,two"], namespace)
+        self.assertEqual(args.bar, ["prefix-one-suffix", "prefix-two-suffix"])
+
+        with self.assertRaises(TypeError):
+            args, _ = parser.parse_known_args(["--baz=1"], namespace)
+
+        args, _ = parser.parse_known_args(["--qux=one,two"], namespace)
+        self.assertEqual(args.passes, {"--qux": ["one", "two"]})
+
+    def test_extend_match_init(self):
+        """Check that extend_match recognizes custom arguments"""
+        action = _ExtendMatchAction(
+            ["--foo"],
+            "foo",
+            pattern="*",
+            format="$value",
+        )
+        self.assertEqual(action.pattern, "*")
+        self.assertEqual(action.format, "$value")
+
+        action = _ExtendMatchAction(["--foo"], "foo")
+        self.assertEqual(action.pattern, None)
+        self.assertEqual(action.format, None)
+
+    def test_extend_match(self):
+        """Check that argparse calls store_split correctly"""
+        namespace = argparse.Namespace()
+        namespace.passes = {}
+
+        parser = argparse.ArgumentParser()
+        parser.add_argument(
+            "--foo",
+            action=_ExtendMatchAction,
+            pattern=r"option_(\d+)",
+            default=[],
+        )
+        parser.add_argument(
+            "--bar",
+            action=_ExtendMatchAction,
+            pattern=r"option_(\d+)",
+            format="prefix-$value-suffix",
+            default=[],
+        )
+        parser.add_argument("--baz", action=_ExtendMatchAction, type=int)
+        parser.add_argument(
+            "--qux",
+            action=_ExtendMatchAction,
+            pattern=r"option_(\d+)",
+            dest="passes",
+        )
+
+        args, _ = parser.parse_known_args(
+            ["--foo=option_1,option_2"],
+            namespace,
+        )
+        self.assertEqual(args.foo, ["1", "2"])
+
+        args, _ = parser.parse_known_args(
+            ["--bar=option_1,option_2"],
+            namespace,
+        )
+        self.assertEqual(args.bar, ["prefix-1-suffix", "prefix-2-suffix"])
+
+        with self.assertRaises(TypeError):
+            args, _ = parser.parse_known_args(["--baz=1"], namespace)
+
+        args, _ = parser.parse_known_args(
+            ["--qux=option_1,option_2"],
+            namespace,
+        )
+        self.assertEqual(args.passes, {"--qux": ["1", "2"]})
+
+
+if __name__ == "__main__":
+    unittest.main()