Conan Dep Schema + Conversion

Author: Behemyth

cppython/plugins/conan/builder.py

@@ -0,0 +1,66 @@
+"""Construction of Conan data"""
+
+from pathlib import Path
+from string import Template
+
+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 = "zlib/1.2.13"
+            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(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():
+            with open(conan_file, encoding='utf-8') as file:
+                file_contents = file.read()
+
+        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,15 @@ 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)
 
     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)
 
     @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"""