Add Imperative Command Layer

Author: Behemyth

cppython/console/entry.py

@@ -204,3 +204,68 @@ def publish(
     """
     project = get_enabled_project(context)
     project.publish()
+
+
+@app.command()
+def build(
+    context: typer.Context,
+) -> None:
+    """Build the project
+
+    Assumes dependencies have been installed via `install`.
+
+    Args:
+        context: The CLI configuration object
+    """
+    project = get_enabled_project(context)
+    project.build()
+
+
+@app.command()
+def test(
+    context: typer.Context,
+) -> None:
+    """Run project tests
+
+    Assumes dependencies have been installed via `install`.
+
+    Args:
+        context: The CLI configuration object
+    """
+    project = get_enabled_project(context)
+    project.test()
+
+
+@app.command()
+def bench(
+    context: typer.Context,
+) -> None:
+    """Run project benchmarks
+
+    Assumes dependencies have been installed via `install`.
+
+    Args:
+        context: The CLI configuration object
+    """
+    project = get_enabled_project(context)
+    project.bench()
+
+
+@app.command()
+def run(
+    context: typer.Context,
+    target: Annotated[
+        str,
+        typer.Argument(help='The name of the build target/executable to run'),
+    ],
+) -> None:
+    """Run a built executable
+
+    Assumes dependencies have been installed via `install`.
+
+    Args:
+        context: The CLI configuration object
+        target: The name of the build target to run
+    """
+    project = get_enabled_project(context)
+    project.run(target)

cppython/core/plugin_schema/generator.py

@@ -69,3 +69,36 @@ def features(directory: DirectoryPath) -> SupportedFeatures:
             The supported features - `SupportedGeneratorFeatures`. Cast to this type to help us avoid generic typing
         """
         raise NotImplementedError
+
+    @abstractmethod
+    def build(self) -> None:
+        """Builds the project using the generator's build system.
+
+        Executes the build step (e.g. cmake --build --preset).
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def test(self) -> None:
+        """Runs tests using the generator's build system.
+
+        Executes the test step (e.g. ctest --preset).
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def bench(self) -> None:
+        """Runs benchmarks using the generator's build system.
+
+        Executes benchmarks, typically via test presets with a label filter.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def run(self, target: str) -> None:
+        """Runs a built executable by target name.
+
+        Args:
+            target: The name of the build target/executable to run.
+        """
+        raise NotImplementedError

cppython/data.py

@@ -103,3 +103,23 @@ async def download_provider_tools(self) -> None:
 
         self.logger.warning('Downloading the %s requirements to %s', self.plugins.provider.name(), path)
         await self.plugins.provider.download_tooling(path)
+
+    def build(self) -> None:
+        """Builds the project via the generator"""
+        self.plugins.generator.build()
+
+    def test(self) -> None:
+        """Runs tests via the generator"""
+        self.plugins.generator.test()
+
+    def bench(self) -> None:
+        """Runs benchmarks via the generator"""
+        self.plugins.generator.bench()
+
+    def run(self, target: str) -> None:
+        """Runs a built executable via the generator
+
+        Args:
+            target: The name of the build target to run
+        """
+        self.plugins.generator.run(target)

cppython/plugins/cmake/builder.py

@@ -8,6 +8,7 @@
     CMakePresets,
     CMakeSyncData,
     ConfigurePreset,
+    TestPreset,
 )
 
 
@@ -100,22 +101,25 @@ def write_cppython_preset(
     @staticmethod
     def _create_presets(
         cmake_data: CMakeData, build_directory: Path
-    ) -> tuple[list[ConfigurePreset], list[BuildPreset]]:
-        """Create the default configure and build presets for the user.
+    ) -> tuple[list[ConfigurePreset], list[BuildPreset], list[TestPreset]]:
+        """Create the default configure, build, and test presets for the user.
 
         Args:
             cmake_data: The CMake data to use
             build_directory: The build directory to use
 
         Returns:
-            A tuple containing the configure preset and list of build presets
+            A tuple containing the configure presets, build presets, and test presets
         """
         user_configure_presets: list[ConfigurePreset] = []
         user_build_presets: list[BuildPreset] = []
+        user_test_presets: list[TestPreset] = []
 
         name = cmake_data.configuration_name
         release_name = name + '-release'
         debug_name = name + '-debug'
+        bench_release_name = name + '-bench-release'
+        bench_debug_name = name + '-bench-debug'
 
         user_configure_presets.append(
             ConfigurePreset(
@@ -161,7 +165,43 @@ def _create_presets(
             )
         )
 
-        return user_configure_presets, user_build_presets
+        # Test presets
+        user_test_presets.append(
+            TestPreset(
+                name=release_name,
+                description='Run tests for release configuration',
+                configurePreset=release_name,
+            )
+        )
+
+        user_test_presets.append(
+            TestPreset(
+                name=debug_name,
+                description='Run tests for debug configuration',
+                configurePreset=debug_name,
+            )
+        )
+
+        # Benchmark test presets with label filter
+        user_test_presets.append(
+            TestPreset(
+                name=bench_release_name,
+                description='Run benchmark tests for release configuration',
+                configurePreset=release_name,
+                filter={'include': {'label': 'benchmark'}},
+            )
+        )
+
+        user_test_presets.append(
+            TestPreset(
+                name=bench_debug_name,
+                description='Run benchmark tests for debug configuration',
+                configurePreset=debug_name,
+                filter={'include': {'label': 'benchmark'}},
+            )
+        )
+
+        return user_configure_presets, user_build_presets, user_test_presets
 
     @staticmethod
     def _load_existing_preset(preset_file: Path) -> CMakePresets | None:
@@ -200,11 +240,35 @@ def _update_configure_preset(existing_preset: ConfigurePreset, build_directory:
         if not existing_preset.binaryDir:
             existing_preset.binaryDir = '${sourceDir}/' + build_directory.as_posix()  # type: ignore[misc]
 
+    @staticmethod
+    def _merge_presets[T: (ConfigurePreset, BuildPreset, TestPreset)](
+        existing: list[T] | None,
+        new_presets: list[T],
+    ) -> list[T]:
+        """Merge new presets into an existing list, adding only those not already present.
+
+        Args:
+            existing: The existing preset list (may be None)
+            new_presets: The new presets to merge in
+
+        Returns:
+            The merged list of presets
+        """
+        if existing is None:
+            return new_presets.copy()
+
+        for preset in new_presets:
+            if not any(p.name == preset.name for p in existing):
+                existing.append(preset)
+
+        return existing
+
     @staticmethod
     def _modify_presets(
         root_preset: CMakePresets,
         user_configure_presets: list[ConfigurePreset],
         user_build_presets: list[BuildPreset],
+        user_test_presets: list[TestPreset],
         build_directory: Path,
     ) -> None:
         """Handle presets in the root preset.
@@ -213,6 +277,7 @@ def _modify_presets(
             root_preset: The root preset to modify
             user_configure_presets: The user's configure presets
             user_build_presets: The user's build presets
+            user_test_presets: The user's test presets
             build_directory: The build directory to use
         """
         if root_preset.configurePresets is None:
@@ -228,14 +293,8 @@ def _modify_presets(
                 else:
                     root_preset.configurePresets.append(user_configure_preset)
 
-        if root_preset.buildPresets is None:
-            root_preset.buildPresets = user_build_presets.copy()  # type: ignore[misc]
-        else:
-            # Add build presets if they don't exist
-            for build_preset in user_build_presets:
-                existing = next((p for p in root_preset.buildPresets if p.name == build_preset.name), None)
-                if not existing:
-                    root_preset.buildPresets.append(build_preset)
+        root_preset.buildPresets = Builder._merge_presets(root_preset.buildPresets, user_build_presets)  # type: ignore[misc]
+        root_preset.testPresets = Builder._merge_presets(root_preset.testPresets, user_test_presets)  # type: ignore[misc]
 
     @staticmethod
     def _modify_includes(root_preset: CMakePresets, preset_file: Path, cppython_preset_file: Path) -> None:
@@ -273,17 +332,22 @@ def generate_root_preset(
             A CMakePresets object
         """
         # Create user presets
-        user_configure_presets, user_build_presets = Builder._create_presets(cmake_data, build_directory)
+        user_configure_presets, user_build_presets, user_test_presets = Builder._create_presets(
+            cmake_data, build_directory
+        )
 
         # Load existing preset or create new one
         root_preset = Builder._load_existing_preset(preset_file)
         if root_preset is None:
             root_preset = CMakePresets(
                 configurePresets=user_configure_presets,
                 buildPresets=user_build_presets,
+                testPresets=user_test_presets,
             )
         else:
-            Builder._modify_presets(root_preset, user_configure_presets, user_build_presets, build_directory)
+            Builder._modify_presets(
+                root_preset, user_configure_presets, user_build_presets, user_test_presets, build_directory
+            )
 
         Builder._modify_includes(root_preset, preset_file, cppython_preset_file)
 

cppython/plugins/cmake/plugin.py

@@ -1,5 +1,6 @@
 """The CMake generator implementation"""
 
+import subprocess
 from pathlib import Path
 from typing import Any
 
@@ -77,3 +78,73 @@ def sync(self, sync_data: SyncData) -> None:
                 )
             case _:
                 raise ValueError('Unsupported sync data type')
+
+    def _cmake_command(self) -> str:
+        """Returns the cmake command to use.
+
+        Returns:
+            The cmake binary path as a string
+        """
+        if self.data.cmake_binary:
+            return str(self.data.cmake_binary)
+        return 'cmake'
+
+    def _ctest_command(self) -> str:
+        """Returns the ctest command to use.
+
+        Derives the ctest path from the cmake binary path when available.
+
+        Returns:
+            The ctest binary path as a string
+        """
+        if self.data.cmake_binary:
+            # ctest is typically in the same directory as cmake
+            ctest_path = self.data.cmake_binary.parent / 'ctest'
+            if ctest_path.exists():
+                return str(ctest_path)
+            # Try with .exe on Windows
+            ctest_exe = self.data.cmake_binary.parent / 'ctest.exe'
+            if ctest_exe.exists():
+                return str(ctest_exe)
+        return 'ctest'
+
+    def build(self) -> None:
+        """Builds the project using cmake --build with the configured preset."""
+        release_preset = self.data.configuration_name + '-release'
+        cmd = [self._cmake_command(), '--build', '--preset', release_preset]
+        subprocess.run(cmd, check=True, cwd=self.data.preset_file.parent)
+
+    def test(self) -> None:
+        """Runs tests using ctest with the configured preset."""
+        release_preset = self.data.configuration_name + '-release'
+        cmd = [self._ctest_command(), '--preset', release_preset]
+        subprocess.run(cmd, check=True, cwd=self.data.preset_file.parent)
+
+    def bench(self) -> None:
+        """Runs benchmarks using ctest with the configured benchmark preset."""
+        bench_preset = self.data.configuration_name + '-bench-release'
+        cmd = [self._ctest_command(), '--preset', bench_preset]
+        subprocess.run(cmd, check=True, cwd=self.data.preset_file.parent)
+
+    def run(self, target: str) -> None:
+        """Runs a built executable by target name.
+
+        Searches the build directory for the executable matching the target name.
+
+        Args:
+            target: The name of the build target/executable to run
+
+        Raises:
+            FileNotFoundError: If the target executable cannot be found
+        """
+        build_path = self.core_data.cppython_data.build_path
+
+        # Search for the executable in the build directory
+        candidates = list(build_path.rglob(target)) + list(build_path.rglob(f'{target}.exe'))
+        executables = [c for c in candidates if c.is_file()]
+
+        if not executables:
+            raise FileNotFoundError(f"Could not find executable '{target}' in build directory: {build_path}")
+
+        executable = executables[0]
+        subprocess.run([str(executable)], check=True, cwd=self.data.preset_file.parent)