Update Plugin Config Table

Author: Behemyth

cppython/builder.py

@@ -34,6 +34,7 @@
 from cppython.data import Data, Plugins
 from cppython.defaults import DefaultSCM
 from cppython.utility.exception import PluginError
+from cppython.utility.utility import TypeName
 
 
 class Resolver:
@@ -59,14 +60,14 @@ def generate_plugins(
         raw_generator_plugins = self.find_generators()
         generator_plugins = self.filter_plugins(
             raw_generator_plugins,
-            cppython_local_configuration.generator_name,
+            self._get_effective_generator_name(cppython_local_configuration),
             'Generator',
         )
 
         raw_provider_plugins = self.find_providers()
         provider_plugins = self.filter_plugins(
             raw_provider_plugins,
-            cppython_local_configuration.provider_name,
+            self._get_effective_provider_name(cppython_local_configuration),
             'Provider',
         )
 
@@ -79,6 +80,74 @@ def generate_plugins(
 
         return PluginBuildData(generator_type=generator_type, provider_type=provider_type, scm_type=scm_type)
 
+    def _get_effective_generator_name(self, config: CPPythonLocalConfiguration) -> str | None:
+        """Get the effective generator name from configuration
+
+        Args:
+            config: The local configuration
+
+        Returns:
+            The generator name to use, or None for auto-detection
+        """
+        if config.generators:
+            # For now, pick the first generator (in future, could support selection logic)
+            return list(config.generators.keys())[0]
+
+        # No generators specified, use auto-detection
+        return None
+
+    def _get_effective_provider_name(self, config: CPPythonLocalConfiguration) -> str | None:
+        """Get the effective provider name from configuration
+
+        Args:
+            config: The local configuration
+
+        Returns:
+            The provider name to use, or None for auto-detection
+        """
+        if config.providers:
+            # For now, pick the first provider (in future, could support selection logic)
+            return list(config.providers.keys())[0]
+
+        # No providers specified, use auto-detection
+        return None
+
+    def _get_effective_generator_config(
+        self, config: CPPythonLocalConfiguration, generator_name: str
+    ) -> dict[str, Any]:
+        """Get the effective generator configuration
+
+        Args:
+            config: The local configuration
+            generator_name: The name of the generator being used
+
+        Returns:
+            The configuration dict for the generator
+        """
+        generator_type_name = TypeName(generator_name)
+        if config.generators and generator_type_name in config.generators:
+            return config.generators[generator_type_name]
+
+        # Return empty config if not found
+        return {}
+
+    def _get_effective_provider_config(self, config: CPPythonLocalConfiguration, provider_name: str) -> dict[str, Any]:
+        """Get the effective provider configuration
+
+        Args:
+            config: The local configuration
+            provider_name: The name of the provider being used
+
+        Returns:
+            The configuration dict for the provider
+        """
+        provider_type_name = TypeName(provider_name)
+        if config.providers and provider_type_name in config.providers:
+            return config.providers[provider_type_name]
+
+        # Return empty config if not found
+        return {}
+
     @staticmethod
     def generate_cppython_plugin_data(plugin_build_data: PluginBuildData) -> PluginCPPythonData:
         """Generates the CPPython plugin data from the resolved plugins
@@ -447,11 +516,18 @@ def build(
         pep621_data = self._resolver.generate_pep621_data(pep621_configuration, self._project_configuration, scm)
 
         # Create the chosen plugins
+        generator_config = self._resolver._get_effective_generator_config(
+            cppython_local_configuration, plugin_build_data.generator_type.name()
+        )
         generator = self._resolver.create_generator(
-            core_data, pep621_data, cppython_local_configuration.generator, plugin_build_data.generator_type
+            core_data, pep621_data, generator_config, plugin_build_data.generator_type
+        )
+
+        provider_config = self._resolver._get_effective_provider_config(
+            cppython_local_configuration, plugin_build_data.provider_type.name()
         )
         provider = self._resolver.create_provider(
-            core_data, pep621_data, cppython_local_configuration.provider, plugin_build_data.provider_type
+            core_data, pep621_data, provider_config, plugin_build_data.provider_type
         )
 
         plugins = Plugins(generator=generator, provider=provider, scm=scm)

cppython/core/resolution.py

@@ -139,16 +139,22 @@ def resolve_cppython(
     if not modified_build_path.is_absolute():
         modified_build_path = root_directory / modified_build_path
 
-    modified_provider_name = local_configuration.provider_name
-    modified_generator_name = local_configuration.generator_name
+    modified_provider_name = plugin_build_data.provider_name
+    modified_generator_name = plugin_build_data.generator_name
 
-    if modified_provider_name is None:
-        modified_provider_name = plugin_build_data.provider_name
+    modified_scm_name = plugin_build_data.scm_name
 
-    if modified_generator_name is None:
-        modified_generator_name = plugin_build_data.generator_name
+    # Extract provider and generator configuration data
+    provider_type_name = TypeName(modified_provider_name)
+    generator_type_name = TypeName(modified_generator_name)
 
-    modified_scm_name = plugin_build_data.scm_name
+    provider_data = {}
+    if local_configuration.providers and provider_type_name in local_configuration.providers:
+        provider_data = local_configuration.providers[provider_type_name]
+
+    generator_data = {}
+    if local_configuration.generators and generator_type_name in local_configuration.generators:
+        generator_data = local_configuration.generators[generator_type_name]
 
     # Construct dependencies from the local configuration only
     dependencies: list[Requirement] = []
@@ -173,6 +179,8 @@ def resolve_cppython(
         generator_name=modified_generator_name,
         scm_name=modified_scm_name,
         dependencies=dependencies,
+        provider_data=provider_data,
+        generator_data=generator_data,
     )
     return cppython_data
 
@@ -200,6 +208,8 @@ def resolve_cppython_plugin(cppython_data: CPPythonData, plugin_type: type[Plugi
         generator_name=cppython_data.generator_name,
         scm_name=cppython_data.scm_name,
         dependencies=cppython_data.dependencies,
+        provider_data=cppython_data.provider_data,
+        generator_data=cppython_data.generator_data,
     )
 
     return cast(CPPythonPluginData, plugin_data)

cppython/core/schema.py

@@ -118,6 +118,9 @@ class CPPythonData(CPPythonModel, extra='forbid'):
     scm_name: TypeName
     dependencies: list[Requirement]
 
+    provider_data: Annotated[dict[str, Any], Field(description='Resolved provider configuration data')]
+    generator_data: Annotated[dict[str, Any], Field(description='Resolved generator configuration data')]
+
     @field_validator('configuration_path', 'install_path', 'tool_path', 'build_path')  # type: ignore
     @classmethod
     def validate_absolute_path(cls, value: Path) -> Path:
@@ -302,29 +305,21 @@ class CPPythonLocalConfiguration(CPPythonModel, extra='forbid'):
         ),
     ] = Path('build')
 
-    provider: Annotated[ProviderData, Field(description="Provider plugin data associated with 'provider_name")] = (
-        ProviderData({})
-    )
-
-    provider_name: Annotated[
-        TypeName | None,
+    providers: Annotated[
+        dict[TypeName, ProviderData],
         Field(
-            alias='provider-name',
-            description='If empty, the provider will be automatically deduced.',
+            description='Named provider configurations. Key is the provider name, value is the provider configuration.'
         ),
-    ] = None
-
-    generator: Annotated[GeneratorData, Field(description="Generator plugin data associated with 'generator_name'")] = (
-        GeneratorData({})
-    )
+    ] = {}
 
-    generator_name: Annotated[
-        TypeName | None,
+    generators: Annotated[
+        dict[TypeName, GeneratorData],
         Field(
-            alias='generator-name',
-            description='If empty, the generator will be automatically deduced.',
+            description=(
+                'Named generator configurations. Key is the generator name, value is the generator configuration.'
+            )
         ),
-    ] = None
+    ] = {}
 
     dependencies: Annotated[
         list[str] | None,

cppython/test/pytest/fixtures.py

@@ -27,7 +27,6 @@
     PyProject,
     ToolData,
 )
-from cppython.utility.utility import TypeName
 
 
 @pytest.fixture(
@@ -92,7 +91,7 @@ def fixture_cppython_local_configuration(install_path: Path) -> CPPythonLocalCon
         Variation of CPPython data
     """
     cppython_local_configuration = CPPythonLocalConfiguration(
-        install_path=install_path, provider_name=TypeName('mock'), generator_name=TypeName('mock')
+        install_path=install_path, providers={'mock': {}}, generators={'mock': {}}
     )
 
     return cppython_local_configuration

examples/conan_cmake/simple/pyproject.toml

@@ -13,16 +13,13 @@ dependencies = ["cppython[conan, cmake, git]>=0.9.0"]
 
 
 [tool.cppython]
-generator-name = "cmake"
-provider-name = "conan"
-
 install-path = "install"
 
 dependencies = ["fmt>=11.2.0"]
 
-[tool.cppython.generator]
+[tool.cppython.generators.cmake]
 
-[tool.cppython.provider]
+[tool.cppython.providers.conan]
 
 [tool.pdm]
 distribution = false

examples/vcpkg_cmake/simple/pyproject.toml

@@ -13,16 +13,13 @@ dependencies = ["cppython[vcpkg, cmake, git]>=0.9.0"]
 
 
 [tool.cppython]
-generator-name = "cmake"
-provider-name = "vcpkg"
-
 install-path = "install"
 
 dependencies = ["fmt>=11.0.2"]
 
-[tool.cppython.generator]
+[tool.cppython.generators.cmake]
 
-[tool.cppython.provider]
+[tool.cppython.providers.vcpkg]
 
 [tool.pdm]
 distribution = false

tests/unit/test_data.py

@@ -8,13 +8,16 @@
 from cppython.core.resolution import PluginBuildData
 from cppython.core.schema import (
     CPPythonLocalConfiguration,
+    GeneratorData,
     PEP621Configuration,
     ProjectConfiguration,
+    ProviderData,
 )
 from cppython.data import Data
 from cppython.test.mock.generator import MockGenerator
 from cppython.test.mock.provider import MockProvider
 from cppython.test.mock.scm import MockSCM
+from cppython.utility.utility import TypeName
 
 
 class TestData:
@@ -58,3 +61,19 @@ def test_sync(data: Data) -> None:
             data: Fixture for the mocked data class
         """
         data.sync()
+
+    @staticmethod
+    def test_named_plugin_configuration() -> None:
+        """Test that named plugin configuration is properly validated"""
+        # Test valid named configuration
+        config = CPPythonLocalConfiguration(
+            providers={TypeName('conan'): ProviderData({'some_setting': 'value'})},
+            generators={TypeName('cmake'): GeneratorData({'another_setting': True})},
+        )
+        assert config.providers == {TypeName('conan'): {'some_setting': 'value'}}
+        assert config.generators == {TypeName('cmake'): {'another_setting': True}}
+
+        # Test empty configuration is valid
+        config_empty = CPPythonLocalConfiguration()
+        assert config_empty.providers == {}
+        assert config_empty.generators == {}