CMAKE generator : allow options other than variables

Prep step for migrating other builders to `master-migration`

Author: RazvanLiviuVarzaru

configuration/steps/generators/base/generator.py

@@ -45,6 +45,11 @@ def generate(self) -> list[str]:
         Generates the command as a list of strings.
         """
         result = self.base_cmd.copy()
-        for flag in sorted(self.flags, key=lambda x: x.name):
-            result.append(flag.as_cmd_arg())
+        # arg can be "" for False values in CMakeFlagOption so we skip those
+        # flag options don't have a False counterpart nor can be assigned right-hand side values .e.g --trace, --trace-expand
+        result += [
+            arg
+            for flag in sorted(self.flags, key=lambda x: x.name)
+            if (arg := flag.as_cmd_arg())
+        ]
         return result

configuration/steps/generators/cmake/options.py

@@ -34,6 +34,25 @@ def __str__(self):
         return f"CMAKE_{self.value}"
 
 
+class CMAKEWARN(StrEnum):
+    DEVELOPER_WARNINGS = "dev"
+    DEPRECATED_WARNINGS = "deprecated"
+    WARNINGS_AS_ERRORS = "error"
+
+    def __str__(self):
+        return self.value
+
+
+class CMAKEDEBUG(StrEnum):
+    TRACE = "trace"
+    TRACE_EXPAND = "trace-expand"
+    DEBUG_OUTPUT = "debug-output"
+    DEBUG_FIND = "debug-find"
+
+    def __str__(self):
+        return self.value
+
+
 class PLUGIN(StrEnum):
     """
     Enumerates valid plugin options for MariaDB's CMake configuration.
@@ -132,9 +151,9 @@ class BuildConfig(StrEnum):
     MYSQL_RELEASE = "mysql_release"
 
 
-class CMakeOption(Option):
+class CMakeVariableOption(Option):
     """
-    Represents a CMake option in the form `-D<name>=<value>`.
+    Represents a `-DNAME=VALUE` variable option
     """
 
     def __init__(self, name: StrEnum, value: Union[str, bool]):
@@ -147,3 +166,76 @@ def __init__(self, name: StrEnum, value: Union[str, bool]):
 
     def as_cmd_arg(self) -> str:
         return f"-D{self.name}={self.value}"
+
+
+class CMakeFlagOption(Option):
+    """
+    Represents a flag-like option (e.g., --trace, --trace-expand).
+    """
+
+    def __init__(self, name: StrEnum, value: bool):
+        if isinstance(value, bool):
+            value = f"--{name}" if value else ""
+        else:
+            raise ValueError(
+                f"Flag option '{type(name)}-{name}' must be initialized with a boolean value at creation time. Got {type(value)} instead."
+            )
+        super().__init__(name, value)
+
+    def as_cmd_arg(self) -> str:
+        return f"{self.value}"
+
+
+class CMakeWarnOption(Option):
+    """
+    Represents a -W option (e.g., -Wno-dev, -Wdeprecated).
+    """
+
+    def __init__(self, name: StrEnum, value: bool):
+        if isinstance(value, bool):
+            value = f"-W{'' if value else 'no-'}{name}"
+        else:
+            raise ValueError(
+                f"Flag option '{type(name)}-{name}' must be initialized with a boolean value at creation time. Got {type(value)} instead."
+            )
+        super().__init__(name, value)
+
+    def as_cmd_arg(self) -> str:
+        return f"{self.value}"
+
+
+class CMakeOption:
+    """
+    Factory class to create CMake options based on the type of the input object.
+    """
+
+    HANDLERS = (
+        (
+            (
+                CMAKE,
+                PLUGIN,
+                WITH,
+                WITHOUT,
+                OTHER,
+                BuildType,
+                BuildConfig,
+            ),
+            CMakeVariableOption,
+        ),
+        (
+            (CMAKEDEBUG,),
+            CMakeFlagOption,
+        ),
+        (
+            (CMAKEWARN,),
+            CMakeWarnOption,
+        ),
+    )
+
+    def __new__(cls, obj: StrEnum, value: Union[str, bool]) -> Option:
+        for base_classes, handler_class in cls.HANDLERS:
+            if isinstance(obj, base_classes):
+                return handler_class(obj, value)
+        raise ValueError(
+            f"No handler found for object of type {type(obj)}. Cannot create a CMake option."
+        )

configuration/test/unit/test_cmake_generator.py

@@ -5,6 +5,8 @@
 from configuration.steps.generators.cmake.generator import CMakeGenerator
 from configuration.steps.generators.cmake.options import (
     CMAKE,
+    CMAKEDEBUG,
+    CMAKEWOPT,
     PLUGIN,
     WITH,
     BuildConfig,
@@ -37,6 +39,38 @@ def test_initialization_with_flags(self):
             ],
         )
 
+    def test_all_handlers(self):
+        """Test that all CMakeOption handlers work correctly."""
+        flags = [
+            CMakeOption(CMAKE.BUILD_TYPE, BuildType.RELWITHDEBUG),
+            CMakeOption(CMAKE.INSTALL_PREFIX, "/usr/local"),
+            CMakeOption(PLUGIN.ARCHIVE_STORAGE_ENGINE, True),
+            CMakeOption(WITH.ASAN, True),
+            CMakeOption(CMAKEWOPT.DEVELOPER_WARNINGS, False),
+            CMakeOption(CMAKEDEBUG.TRACE, False),
+            CMakeOption(CMAKEDEBUG.DEBUG_OUTPUT, True),
+            CMakeOption(CMAKEWOPT.DEPRECATED_WARNINGS, True),
+            CMakeOption(CMAKEWOPT.WARNINGS_AS_ERRORS, False),
+        ]
+        generator = CMakeGenerator(flags=flags)
+        command = generator.generate()
+        self.assertEqual(
+            command,
+            [
+                "cmake",
+                "-S",
+                ".",
+                "-DCMAKE_BUILD_TYPE=RelWithDebInfo",
+                "-DCMAKE_INSTALL_PREFIX=/usr/local",
+                "-DPLUGIN_ARCHIVE=YES",
+                "-DWITH_ASAN=ON",
+                "--debug-output",
+                "-Wdeprecated",
+                "-Wno-dev",
+                "-Wno-error",
+            ],
+        )
+
     def test_append_flags_successful(self):
         """
         Test that flags are appended successfully.