Introduce a cmake generator class

This commit introduces a utility class to allow for uniform
construction of the MariaDB (& other projects) cmake step.

Usage is documented in the unit test.
* compilers.py -> Standard type-safe way of specifying the compiler
  command
* options.py -> Standard type-safe way of specifying CMAKE args. This
  file should be extended over time, as MariaDB's cmake flags change.
* generator.py -> Holds the CMake Generator class used to build the
  command argument.

This commit also introduces an additional workflow step, to make sure we
run unit tests on the code.

Author: cvicentiu

.github/workflows/unittests.yml

@@ -0,0 +1,26 @@
+---
+name: unittests
+
+on:
+  pull_request:
+  push:
+
+jobs:
+  pre-commit:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      #//TEMP we need to check only modified files WRT main
+      - name: Install requirements (apt)
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libvirt-dev
+      - name: Install requirements (uv pip)
+        run: |
+          curl -LsSf https://astral.sh/uv/install.sh | sh
+          make venv
+          make install
+      - name: Run unit tests
+        run: |
+          source .venv/bin/activate
+          make test

Makefile

@@ -56,6 +56,10 @@ checkconfig: ## Validate master.cfg files
 	$(info --> validate master.cfg files with docker)
 	./validate_master_cfg.sh
 
+test: ## Run unittests
+	$(info --> run unittests)
+	python -m unittest discover -s tests -p "test*.py"
+
 clean: ## Clean venv
 	[[ ! -d $(VENV_DIR) ]] || rm -rf $(VENV_DIR)
 	[[ ! -d $(VENDOR_DIR) ]] || rm -rf $(VENDOR_DIR)

steps/__init__.py

@@ -0,0 +1,38 @@
+class CompilerCommand:
+    def __init__(self, cc: str, cxx: str):
+        assert isinstance(cc, str)
+        assert isinstance(cxx, str)
+        self.cc_ = cc
+        self.cxx_ = cxx
+
+    @property
+    def cc(self):
+        return self.cc_
+
+    @property
+    def cxx(self):
+        return self.cxx_
+
+
+class GCCCompiler(CompilerCommand):
+    def __init__(self, version: str = None):
+        if version:
+            super().__init__(f"gcc-{version}", f"g++-{version}")
+        else:
+            super().__init__("gcc", "g++")
+
+
+class ClangCompiler(CompilerCommand):
+    def __init__(self, version: str = None):
+        if version:
+            super().__init__(cc=f"clang-{version}", cxx=f"clang++-{version}")
+        else:
+            super().__init__(cc="clang", cxx="clang++")
+
+
+class MicrosoftCompiler(CompilerCommand):
+    def __init__(self):
+        super().__init__(cc="cl", cxx="cl++")
+
+
+# TODO(cvicentiu) aocc, intel compiler.

steps/cmake/__init__.py

@@ -0,0 +1,92 @@
+from typing import Iterable
+
+from .compilers import CompilerCommand
+from .options import CMAKE, OTHER, BuildConfig, CMakeOption
+
+
+class DuplicateFlagException(Exception):
+    def __init__(self, flag_name: str, existing_value: str, new_value: str):
+        super().__init__(
+            f"Duplicate flag detected: {flag_name}"
+            f"(existing: {existing_value}, new: {new_value})"
+        )
+        super().__init__(f"Duplicate flag detected: {flag_name}")
+
+
+class CMakeGenerator:
+    """
+    Generates a CMake command with specified flags.
+    """
+
+    def __init__(self, flags: Iterable[CMakeOption], source_path: str = "."):
+        """
+        Initializes the CMakeGenerator with an optional list of flags.
+
+        Args:
+            flags: An iterable of CMakeFlag objects.
+            source_path: The source path to the base CMakeLists.txt file.
+                         Default path is "in source build".
+        """
+        self.flags: dict[str, CMakeOption] = {}
+        self.source_path = source_path
+        self.append_flags(flags)
+
+    def set_compiler(self, compiler: CompilerCommand):
+        """
+        Sets the compiler options for C and C++ compilers.
+
+        Args:
+            compiler: An instance of CompilerCommand.
+        """
+        assert isinstance(compiler, CompilerCommand)
+        self.append_flags(
+            [
+                CMakeOption(CMAKE.C_COMPILER, compiler.cc),
+                CMakeOption(CMAKE.CXX_COMPILER, compiler.cxx),
+            ]
+        )
+
+    def use_ccache(self):
+        """
+        Configures CMake to use ccache for faster builds.
+        """
+        self.append_flags(
+            [
+                CMakeOption(CMAKE.C_COMPILER_LAUNCHER, "ccache"),
+                CMakeOption(CMAKE.CXX_COMPILER_LAUNCHER, "ccache"),
+            ]
+        )
+
+    # TODO(cvicentiu) write unit test.
+    def set_build_config(self, config: BuildConfig):
+        """
+        Set the build config flag. This is separate because of it being a
+        "one-off" special flag.
+        """
+        self.append_flags([CMakeOption(OTHER.BUILD_CONFIG, config)])
+
+    def append_flags(self, flags: Iterable[CMakeOption]):
+        """
+        Appends new flags to the generator.
+
+        Raises:
+            DuplicateFlagException: If a flag with the same name already
+                                    exists.
+        """
+        for flag in flags:
+            # Do not allow duplicate flags being set.
+            # Flags should only be set once to avoid confusion about them
+            # being overwritten.
+            if flag.name in self.flags:
+                existing_flag = self.flags[flag.name]
+                raise DuplicateFlagException(flag.name, existing_flag.value, flag.value)
+            self.flags[flag.name] = flag
+
+    def generate(self) -> list[str]:
+        """
+        Generates the CMake command as a list of strings.
+        """
+        result = ["cmake", self.source_path]
+        for flag in sorted(list(self.flags.values()), key=lambda x: x.name):
+            result.append(flag.as_cmd_arg())
+        return result

steps/cmake/compilers.py

@@ -0,0 +1,119 @@
+from enum import StrEnum
+
+
+# Flag names use UPPER_CASE
+class CMAKE(StrEnum):
+    """
+    Explicitly enumerates valid CMake flags to enforce type safety
+    and avoid typos in flag names.
+    """
+
+    AR = "AR"
+    BUILD_TYPE = "BUILD_TYPE"
+    CXX_COMPILER = "CXX_COMPILER"
+    CXX_FLAGS = "CXX_FLAGS"
+    C_COMPILER = "C_COMPILER"
+    C_FLAGS = "C_FLAGS"
+    C_COMPILER_LAUNCHER = "C_COMPILER_LAUNCHER"
+    CXX_COMPILER_LAUNCHER = "CXX_COMPILER_LAUNCHER"
+    INSTALL_PREFIX = "INSTALL_PREFIX"
+    LIBRARY_PATH = "LIBRARY_PATH"
+
+    def __str__(self):
+        return f"CMAKE_{self.value}"
+
+
+class PLUGIN(StrEnum):
+    """
+    Enumerates valid plugin options for MariaDB's CMake configuration.
+    """
+
+    ARCHIVE_STORAGE_ENGINE = "ARCHIVE"
+    CONNECT_STORAGE_ENGINE = "CONNECT"
+    ROCKSDB_STORAGE_ENGINE = "ROCKSDB"
+    TOKUDB_STORAGE_ENGINE = "TOKUDB"
+
+    def __str__(self):
+        return f"PLUGIN_{self.value}"
+
+
+class WITH(StrEnum):
+    """
+    Enumerates valid options for MariaDB's CMake configuration. Each
+    option starts with WITH_.
+    """
+
+    ASAN = "ASAN"
+    DBUG_TRACE = "DBUG_TRACE"
+    EMBEDDED_SERVER = "EMBEDDED_SERVER"
+    JEMALLOC = "JEMALLOC"
+    SAFEMALLOC = "SAFEMALLOC"
+    UBSAN = "UBSAN"
+    UNIT_TESTS = "UNIT_TESTS"
+    VALGRIND = "VALGRIND"
+
+    def __str__(self):
+        return f"WITH_{self.value}"
+
+
+class OTHER(StrEnum):
+    """
+    Enumerates other valid options for MariaDB's
+    """
+
+    BUILD_CONFIG = "BUILD_CONFIG"
+
+
+# Flag values use CapitalCase
+class BuildType(StrEnum):
+    """
+    Enumerates build types for CMake.
+    """
+
+    RELEASE = "Release"
+    DEBUG = "Debug"
+    RELWITHDEBUG = "RelWithDebInfo"
+
+
+class BuildConfig(StrEnum):
+    """
+    Used for -DBUILD_CONFIG=<value> of cmake.
+    Enumerates build configurations for MariaDB's CMake.
+    """
+
+    MYSQL_RELEASE = "mysql_release"
+
+
+class CMakeOption:
+    """
+    Represents a CMake option in the form `-D<name>=<value>`.
+    """
+
+    @staticmethod
+    def _quote_value(value: str):
+        """
+        Quote the value if it contains spaces or special characters.
+        """
+        if " " in value or '"' in value:
+            return f'"{value.replace('"', '\\\"')}"'
+        return value
+
+    def __init__(self, name: StrEnum, value: str | bool):
+        assert isinstance(name, StrEnum)
+        assert isinstance(value, str) or isinstance(value, bool)
+        self.name = str(name)
+        if isinstance(value, bool):
+            self.value = "ON" if value else "OFF"
+        elif isinstance(value, str):
+            self.value = value
+        # Quote if necessary.
+        self.value = self._quote_value(self.value)
+
+    def as_cmd_arg(self) -> str:
+        return f"-D{self.name}={self.value}"
+
+    def __str__(self) -> str:
+        return self.as_cmd_arg()
+
+    def __repr__(self) -> str:
+        return f"CMakeOption({self.name}, {self.value})"