Conditional Preset Writing

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
@@ -18,40 +16,68 @@ def write_provider_preset(provider_directory: Path, data: CMakeSyncData) -> None
             provider_directory: The base directory to place the preset files
             data: The providers synchronization data
         """
-        configure_preset = ConfigurePreset(name=data.provider_name, cacheVariables=None)
-        presets = CMakePresets(configurePresets=[configure_preset])
+        generated_configure_preset = ConfigurePreset(name=data.provider_name, cacheVariables=None)
+        generated_preset = CMakePresets(configurePresets=[generated_configure_preset])
 
-        json_path = provider_directory / f'{data.provider_name}.json'
+        provider_preset_file = provider_directory / f'{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()
+
+        # Set the data
+        generated_preset.include = [relative_preset]
 
-        cppython_json_path = cppython_preset_directory / 'cppython.json'
+        cppython_preset_file = cppython_preset_directory / 'cppython.json'
 
-        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)
+        initial_preset = None
 
-        return cppython_json_path
+        # 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 +87,33 @@ 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:
+            root_preset = CMakePresets()
+
+        # 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,6 +1,5 @@
 """Builder to help resolve cmake state"""
 
-import json
 from typing import Any
 
 from cppython.core.schema import CorePluginData

cppython/plugins/cmake/schema.py

@@ -47,6 +47,9 @@ 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
     cacheVariables: dict[str, None | bool | str | CacheVariable] | None = None
 
 
@@ -57,8 +60,11 @@ class CMakePresets(CPPythonModel, extra='allow'):
     """
 
     version: Annotated[int, Field(description='The version of the JSON schema.')] = 9
+    include: Annotated[
+        list[str] | None, Field(description='The include field allows inheriting from another preset.')
+    ] = None
     configurePresets: Annotated[list[ConfigurePreset], Field(description='The list of configure presets')] = [
-        ConfigurePreset(name='default')
+        ConfigurePreset(name='default', inherits='cppython')
     ]