CMake Toolchain Sync

Author: Behemyth

cppython/plugins/cmake/builder.py

@@ -2,7 +2,7 @@
 
 from pathlib import Path
 
-from cppython.plugins.cmake.schema import CMakeData, CMakePresets, CMakeSyncData, ConfigurePreset
+from cppython.plugins.cmake.schema import CacheVariable, CMakeData, CMakePresets, CMakeSyncData, ConfigurePreset
 
 
 class Builder:
@@ -21,10 +21,18 @@ def generate_provider_preset(provider_data: CMakeSyncData) -> CMakePresets:
         """
         generated_configure_preset = ConfigurePreset(name=provider_data.provider_name, hidden=True)
 
-        # 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()),
-        }
+        # Handle both top_level_includes and toolchain options
+        cache_variables: dict[str, str | bool | CacheVariable | None] = {}
+
+        if provider_data.top_level_includes:
+            cache_variables['CMAKE_PROJECT_TOP_LEVEL_INCLUDES'] = str(provider_data.top_level_includes.as_posix())
+
+        if provider_data.toolchain:
+            # Use the toolchainFile field for better integration
+            generated_configure_preset.toolchainFile = str(provider_data.toolchain.as_posix())
+
+        if cache_variables:
+            generated_configure_preset.cacheVariables = cache_variables
 
         return CMakePresets(configurePresets=[generated_configure_preset])
 

cppython/plugins/cmake/schema.py

@@ -58,6 +58,10 @@ class ConfigurePreset(CPPythonModel, extra='allow'):
         str | None,
         Field(description='The path to the output binary directory.'),
     ] = None
+    toolchainFile: Annotated[
+        FilePath | None,
+        Field(description='Path to the toolchain file.'),
+    ] = None
     cacheVariables: dict[str, None | bool | str | CacheVariable] | None = None
 
 
@@ -77,7 +81,13 @@ class CMakePresets(CPPythonModel, extra='allow'):
 class CMakeSyncData(SyncData):
     """The CMake sync data"""
 
-    top_level_includes: FilePath
+    top_level_includes: FilePath | None = None
+    toolchain: FilePath | None = None
+
+    def model_post_init(self, __context) -> None:
+        """Validate that at least one of top_level_includes or toolchain is provided."""
+        if not self.top_level_includes and not self.toolchain:
+            raise ValueError("Either 'top_level_includes' or 'toolchain' must be provided")
 
 
 class CMakeData(CPPythonModel):

cppython/plugins/conan/plugin.py

@@ -8,7 +8,6 @@
 from pathlib import Path
 from typing import Any
 
-import requests
 from conan.api.conan_api import ConanAPI
 from conan.api.model import ListPattern
 
@@ -27,8 +26,6 @@
 class ConanProvider(Provider):
     """Conan Provider"""
 
-    _provider_url = 'https://raw.githubusercontent.com/conan-io/cmake-conan/refs/heads/develop2/conan_provider.cmake'
-
     def __init__(
         self, group_data: ProviderPluginGroupData, core_data: CorePluginData, configuration_data: dict[str, Any]
     ) -> None:
@@ -39,15 +36,6 @@ def __init__(
 
         self.builder = Builder()
 
-    @staticmethod
-    def _download_file(url: str, file: Path) -> None:
-        """Replaces the given file with the contents of the url"""
-        file.parent.mkdir(parents=True, exist_ok=True)
-
-        with open(file, 'wb') as out_file:
-            content = requests.get(url, stream=True).content
-            out_file.write(content)
-
     @staticmethod
     def features(directory: Path) -> SupportedFeatures:
         """Queries conan support
@@ -197,6 +185,13 @@ def _generate_consumer_files(self, conan_api: ConanAPI, deps_graph) -> None:
             output_folder=str(self.core_data.cppython_data.build_path),
         )
 
+        # Rename the generated toolchain file so our wrapper can include it
+        original_toolchain = self.core_data.cppython_data.build_path / 'conan_toolchain.cmake'
+        renamed_toolchain = self.core_data.cppython_data.build_path / 'conan_toolchain.cmake.real'
+
+        if original_toolchain.exists() and not renamed_toolchain.exists():
+            original_toolchain.rename(renamed_toolchain)
+
     def install(self) -> None:
         """Installs the provider"""
         self._install_dependencies(update=False)
@@ -231,17 +226,51 @@ def sync_data(self, consumer: SyncConsumer) -> SyncData:
         """
         for sync_type in consumer.sync_types():
             if sync_type == CMakeSyncData:
+                # Use the CMakeToolchain file directly as the toolchain
+                toolchain_path = self.core_data.cppython_data.build_path / 'conan_toolchain.cmake'
+
+                # Create the directory structure if it doesn't exist
+                toolchain_path.parent.mkdir(parents=True, exist_ok=True)
+
+                # Always create a minimal toolchain file that includes dependencies when they exist
+                toolchain_content = f'''# Conan CMake integration file
+# This file is managed by CPPython and integrates Conan dependencies with CMake
+
+# Set the build directory for reference
+set(CONAN_BUILD_DIR "{self.core_data.cppython_data.build_path.as_posix()}")
+
+# Include CMakeDeps generated dependency files if they exist
+file(GLOB CONAN_DEPS_FILES "${{CONAN_BUILD_DIR}}/*-config.cmake")
+foreach(DEPS_FILE ${{CONAN_DEPS_FILES}})
+    include("${{DEPS_FILE}}")
+endforeach()
+
+# Include any conan-generated toolchain files
+if(EXISTS "${{CONAN_BUILD_DIR}}/conan_toolchain.cmake.real")
+    include("${{CONAN_BUILD_DIR}}/conan_toolchain.cmake.real")
+else()
+    message(STATUS "Conan dependencies not installed yet - run conan install to install dependencies")
+endif()
+'''
+
+                toolchain_path.write_text(toolchain_content)
+
                 return CMakeSyncData(
                     provider_name=TypeName('conan'),
-                    top_level_includes=self.core_data.cppython_data.install_path / 'conan_provider.cmake',
+                    toolchain=toolchain_path,
                 )
 
         raise NotSupportedError(f'Unsupported sync types: {consumer.sync_types()}')
 
     @classmethod
     async def download_tooling(cls, directory: Path) -> None:
-        """Downloads the conan provider file"""
-        cls._download_file(cls._provider_url, directory / 'conan_provider.cmake')
+        """Download external tooling required by the Conan provider.
+
+        Since we're using CMakeToolchain generator instead of cmake-conan provider,
+        no external tooling needs to be downloaded.
+        """
+        # No external tooling required when using CMakeToolchain
+        pass
 
     def publish(self) -> None:
         """Publishes the package using conan create workflow."""