Implement Conan + Req CMake Changes

Author: Behemyth

cppython/plugins/cmake/builder.py

@@ -1,7 +1,5 @@
 """Plugin builder"""
 
-import json
-from copy import deepcopy
 from pathlib import Path
 
 from cppython.plugins.cmake.schema import CMakePresets, CMakeSyncData, ConfigurePreset
@@ -10,48 +8,85 @@
 class Builder:
     """Aids in building the information needed for the CMake plugin"""
 
+    def __init__(self) -> None:
+        """Initialize the builder"""
+
     @staticmethod
-    def write_provider_preset(provider_directory: Path, data: CMakeSyncData) -> None:
+    def write_provider_preset(provider_directory: Path, provider_data: CMakeSyncData) -> None:
         """Writes a provider preset from input sync data
 
         Args:
             provider_directory: The base directory to place the preset files
-            data: The providers synchronization data
+            provider_data: The providers synchronization data
         """
-        configure_preset = ConfigurePreset(name=data.provider_name, cacheVariables=None)
-        presets = CMakePresets(configurePresets=[configure_preset])
+        generated_configure_preset = ConfigurePreset(name=provider_data.provider_name)
+
+        # Toss in that sync data from the provider
+        generated_configure_preset.cacheVariables = {
+            'CMAKE_PROJECT_TOP_LEVEL_INCLUDES': str(provider_data.top_level_includes.as_posix()),
+        }
+
+        generated_preset = CMakePresets(configurePresets=[generated_configure_preset])
 
-        json_path = provider_directory / f'{data.provider_name}.json'
+        provider_preset_file = provider_directory / f'{provider_data.provider_name}.json'
 
-        serialized = presets.model_dump_json(exclude_none=True, by_alias=False, indent=4)
-        with open(json_path, 'w', encoding='utf8') as file:
-            file.write(serialized)
+        initial_preset = None
+
+        # If the file already exists, we need to compare it
+        if provider_preset_file.exists():
+            with open(provider_preset_file, encoding='utf-8') as file:
+                initial_json = file.read()
+            initial_preset = CMakePresets.model_validate_json(initial_json)
+
+        if generated_preset != initial_preset:
+            serialized = generated_preset.model_dump_json(exclude_none=True, by_alias=False, indent=4)
+            with open(provider_preset_file, 'w', encoding='utf8') as file:
+                file.write(serialized)
 
     @staticmethod
     def write_cppython_preset(
-        cppython_preset_directory: Path, _provider_directory: Path, _provider_data: CMakeSyncData
+        cppython_preset_directory: Path, provider_directory: Path, provider_data: CMakeSyncData
     ) -> Path:
         """Write the cppython presets which inherit from the provider presets
 
         Args:
             cppython_preset_directory: The tool directory
+            provider_directory: The base directory containing provider presets
+            provider_data: The provider's synchronization data
 
         Returns:
             A file path to the written data
         """
-        configure_preset = ConfigurePreset(name='cppython', cacheVariables=None)
-        presets = CMakePresets(configurePresets=[configure_preset])
+        generated_configure_preset = ConfigurePreset(name='cppython', inherits=provider_data.provider_name)
+        generated_preset = CMakePresets(configurePresets=[generated_configure_preset])
+
+        # Get the relative path to the provider preset file
+        provider_preset_file = provider_directory / f'{provider_data.provider_name}.json'
+        relative_preset = provider_preset_file.relative_to(cppython_preset_directory, walk_up=True).as_posix()
 
-        cppython_json_path = cppython_preset_directory / 'cppython.json'
+        # Set the data
+        generated_preset.include = [relative_preset]
 
-        serialized = presets.model_dump_json(exclude_none=True, by_alias=False, indent=4)
-        with open(cppython_json_path, 'w', encoding='utf8') as file:
-            file.write(serialized)
+        cppython_preset_file = cppython_preset_directory / 'cppython.json'
 
-        return cppython_json_path
+        initial_preset = None
+
+        # If the file already exists, we need to compare it
+        if cppython_preset_file.exists():
+            with open(cppython_preset_file, encoding='utf-8') as file:
+                initial_json = file.read()
+            initial_preset = CMakePresets.model_validate_json(initial_json)
+
+        # Only write the file if the data has changed
+        if generated_preset != initial_preset:
+            serialized = generated_preset.model_dump_json(exclude_none=True, by_alias=False, indent=4)
+            with open(cppython_preset_file, 'w', encoding='utf8') as file:
+                file.write(serialized)
+
+        return cppython_preset_file
 
     @staticmethod
-    def write_root_presets(preset_file: Path, _: Path) -> None:
+    def write_root_presets(preset_file: Path, cppython_preset_file: Path) -> None:
         """Read the top level json file and insert the include reference.
 
         Receives a relative path to the tool cmake json file
@@ -61,14 +96,37 @@ def write_root_presets(preset_file: Path, _: Path) -> None:
 
         Args:
             preset_file: Preset file to modify
+            cppython_preset_file: Path to the cppython preset file to include
         """
-        with open(preset_file, encoding='utf-8') as file:
-            initial_json = file.read()
-
-        initial_root_preset = CMakePresets.model_validate_json(initial_json)
-
-        # Only write the file if the contents have changed
-        if (root_preset := deepcopy(initial_root_preset)) != initial_root_preset:
+        initial_root_preset = None
+
+        # If the file already exists, we need to compare it
+        if preset_file.exists():
+            with open(preset_file, encoding='utf-8') as file:
+                initial_json = file.read()
+            initial_root_preset = CMakePresets.model_validate_json(initial_json)
+            root_preset = initial_root_preset.model_copy(deep=True)
+        else:
+            # If the file doesn't exist, we need to default it for the user
+
+            # Forward the tool's build directory
+            default_configure_preset = ConfigurePreset(name='default', inherits='cppython', binaryDir='build')
+            root_preset = CMakePresets(configurePresets=[default_configure_preset])
+
+        # Get the relative path to the cppython preset file
+        preset_directory = preset_file.parent.absolute()
+        relative_preset = cppython_preset_file.relative_to(preset_directory, walk_up=True).as_posix()
+
+        # If the include key doesn't exist, we know we will write to disk afterwards
+        if not root_preset.include:
+            root_preset.include = []
+
+        # Only the included preset file if it doesn't exist. Implied by the above check
+        if str(relative_preset) not in root_preset.include:
+            root_preset.include.append(str(relative_preset))
+
+        # Only write the file if the data has changed
+        if root_preset != initial_root_preset:
             with open(preset_file, 'w', encoding='utf-8') as file:
                 preset = root_preset.model_dump_json(exclude_none=True, indent=4)
                 file.write(preset)

cppython/plugins/cmake/resolution.py

@@ -1,10 +1,9 @@
 """Builder to help resolve cmake state"""
 
-import json
 from typing import Any
 
 from cppython.core.schema import CorePluginData
-from cppython.plugins.cmake.schema import CMakeConfiguration, CMakeData, CMakePresets
+from cppython.plugins.cmake.schema import CMakeConfiguration, CMakeData
 
 
 def resolve_cmake_data(data: dict[str, Any], core_data: CorePluginData) -> CMakeData:
@@ -25,12 +24,4 @@ def resolve_cmake_data(data: dict[str, Any], core_data: CorePluginData) -> CMake
     if not modified_preset_dir.is_absolute():
         modified_preset_dir = root_directory / modified_preset_dir
 
-    # If the user hasn't specified a preset file, we need to create one
-    if not modified_preset_dir.exists():
-        modified_preset_dir.parent.mkdir(parents=True, exist_ok=True)
-        presets_string = CMakePresets().model_dump_json(exclude_none=True, indent=4)
-
-        with modified_preset_dir.open('w', encoding='utf-8') as file:
-            file.write(presets_string)
-
     return CMakeData(preset_file=modified_preset_dir, configuration_name=parsed_data.configuration_name)

cppython/plugins/cmake/schema.py

@@ -47,6 +47,10 @@ class ConfigurePreset(CPPythonModel, extra='allow'):
     """Partial Configure Preset specification to allow cache variable injection"""
 
     name: str
+    inherits: Annotated[
+        str | list[str] | None, Field(description='The inherits field allows inheriting from other presets.')
+    ] = None
+    binaryDir: Annotated[str | None, Field(description='The binary directory for the build output.')] = None
     cacheVariables: dict[str, None | bool | str | CacheVariable] | None = None
 
 
@@ -57,9 +61,10 @@ class CMakePresets(CPPythonModel, extra='allow'):
     """
 
     version: Annotated[int, Field(description='The version of the JSON schema.')] = 9
-    configurePresets: Annotated[list[ConfigurePreset], Field(description='The list of configure presets')] = [
-        ConfigurePreset(name='default')
-    ]
+    include: Annotated[
+        list[str] | None, Field(description='The include field allows inheriting from another preset.')
+    ] = None
+    configurePresets: Annotated[list[ConfigurePreset] | None, Field(description='The list of configure presets')] = None
 
 
 class CMakeSyncData(SyncData):
@@ -71,7 +76,7 @@ class CMakeSyncData(SyncData):
 class CMakeData(CPPythonModel):
     """Resolved CMake data"""
 
-    preset_file: FilePath
+    preset_file: Path
     configuration_name: str
 
 

cppython/plugins/conan/builder.py

@@ -0,0 +1,68 @@
+"""Construction of Conan data"""
+
+from pathlib import Path
+from string import Template
+from textwrap import dedent
+
+from pydantic import DirectoryPath
+
+from cppython.plugins.conan.schema import ConanDependency
+
+
+class Builder:
+    """Aids in building the information needed for the Conan plugin"""
+
+    def __init__(self) -> None:
+        """Initialize the builder"""
+        self._filename = 'conanfile.py'
+
+    @staticmethod
+    def _create_conanfile(conan_file: Path, dependencies: list[ConanDependency]) -> None:
+        """Creates a conanfile.py file with the necessary content."""
+        template_string = """
+        from conan import ConanFile
+        from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
+
+        class MyProject(ConanFile):
+            name = "myproject" 
+            version = "1.0"
+            settings = "os", "compiler", "build_type", "arch"
+            requires = ${dependencies}
+            generators = "CMakeDeps"
+
+            def layout(self):
+                cmake_layout(self)
+
+            def generate(self):
+                tc = CMakeToolchain(self)
+                tc.generate()
+
+            def build(self):
+                cmake = CMake(self)
+                cmake.configure()
+                cmake.build()"""
+
+        template = Template(dedent(template_string))
+
+        values = {
+            'dependencies': [dependency.requires() for dependency in dependencies],
+        }
+
+        result = template.substitute(values)
+
+        with open(conan_file, 'w', encoding='utf-8') as file:
+            file.write(result)
+
+    def generate_conanfile(self, directory: DirectoryPath, dependencies: list[ConanDependency]) -> None:
+        """Generate a conanfile.py file for the project."""
+        conan_file = directory / self._filename
+
+        # If the file exists then we need to inject our information into it
+        if conan_file.exists():
+            raise NotImplementedError(
+                'Updating existing conanfile.py is not yet supported. Please remove the file and try again.'
+            )
+
+        else:
+            directory.mkdir(parents=True, exist_ok=True)
+            self._create_conanfile(conan_file, dependencies)

cppython/plugins/conan/plugin.py

@@ -15,7 +15,8 @@
 from cppython.core.schema import CorePluginData, Information, SyncData
 from cppython.plugins.cmake.plugin import CMakeGenerator
 from cppython.plugins.cmake.schema import CMakeSyncData
-from cppython.plugins.conan.resolution import resolve_conan_data
+from cppython.plugins.conan.builder import Builder
+from cppython.plugins.conan.resolution import resolve_conan_data, resolve_conan_dependency
 from cppython.plugins.conan.schema import ConanData
 from cppython.utility.exception import NotSupportedError
 from cppython.utility.utility import TypeName
@@ -34,6 +35,8 @@ def __init__(
         self.core_data: CorePluginData = core_data
         self.data: ConanData = resolve_conan_data(configuration_data, core_data)
 
+        self.builder = Builder()
+
     @staticmethod
     def _download_file(url: str, file: Path) -> None:
         """Replaces the given file with the contents of the url"""
@@ -66,9 +69,19 @@ def information() -> Information:
 
     def install(self) -> None:
         """Installs the provider"""
+        resolved_dependencies = [resolve_conan_dependency(req) for req in self.core_data.cppython_data.dependencies]
+
+        self.builder.generate_conanfile(self.core_data.project_data.project_root, resolved_dependencies)
+
+        self.core_data.cppython_data.build_path.mkdir(parents=True, exist_ok=True)
 
     def update(self) -> None:
         """Updates the provider"""
+        resolved_dependencies = [resolve_conan_dependency(req) for req in self.core_data.cppython_data.dependencies]
+
+        self.builder.generate_conanfile(self.core_data.project_data.project_root, resolved_dependencies)
+
+        self.core_data.cppython_data.build_path.mkdir(parents=True, exist_ok=True)
 
     @staticmethod
     def supported_sync_type(sync_type: type[SyncData]) -> bool:

cppython/plugins/conan/resolution.py

@@ -2,8 +2,33 @@
 
 from typing import Any
 
+from packaging.requirements import Requirement
+
+from cppython.core.exception import ConfigException
 from cppython.core.schema import CorePluginData
-from cppython.plugins.conan.schema import ConanData
+from cppython.plugins.conan.schema import ConanData, ConanDependency
+
+
+def resolve_conan_dependency(requirement: Requirement) -> ConanDependency:
+    """Resolves a Conan dependency from a requirement"""
+    specifiers = requirement.specifier
+
+    # If the length of specifiers is greater than one, raise a configuration error
+    if len(specifiers) > 1:
+        raise ConfigException('Multiple specifiers are not supported. Please provide a single specifier.', [])
+
+    # Extract the version from the single specifier
+    min_version = None
+    if len(specifiers) == 1:
+        specifier = next(iter(specifiers))
+        if specifier.operator != '>=':
+            raise ConfigException(f"Unsupported specifier '{specifier.operator}'. Only '>=' is supported.", [])
+        min_version = specifier.version
+
+    return ConanDependency(
+        name=requirement.name,
+        version_ge=min_version,
+    )
 
 
 def resolve_conan_data(data: dict[str, Any], core_data: CorePluginData) -> ConanData:

cppython/plugins/conan/schema.py

@@ -8,6 +8,21 @@
 from cppython.core.schema import CPPythonModel
 
 
+class ConanDependency(CPPythonModel):
+    """Dependency information"""
+
+    name: str
+    version_ge: str | None = None
+    include_prerelease: bool | None = None
+
+    def requires(self) -> str:
+        """Generate the requires attribute for Conan"""
+        # TODO: Implement lower and upper bounds per conan documentation
+        if self.version_ge:
+            return f'{self.name}/[>={self.version_ge}]'
+        return self.name
+
+
 class ConanData(CPPythonModel):
     """Resolved conan data"""
 

cppython/plugins/vcpkg/plugin.py

@@ -1,6 +1,5 @@
 """The vcpkg provider implementation"""
 
-import json
 from logging import getLogger
 from os import name as system_name
 from pathlib import Path, PosixPath, WindowsPath