feat: implement package.build.configuration parsing (#3115)

Author: wolfv

crates/pixi_build_frontend/src/protocols/builders/pixi.rs

@@ -80,12 +80,17 @@ impl ProtocolBuilder {
         workspace_manifest: WorkspaceManifest,
         package_manifest: PackageManifest,
     ) -> Self {
+        let configuration = package_manifest.build.configuration.clone().map(|v| {
+            v.deserialize_into()
+                .expect("Configuration dictionary should be serializable to JSON")
+        });
+
         Self {
             source_dir,
             manifest_path,
             workspace_manifest,
             package_manifest,
-            configuration: None,
+            configuration,
             backend_override: None,
             channel_config: None,
             cache_dir: None,

crates/pixi_manifest/src/build_system.rs

@@ -20,6 +20,9 @@ pub struct PackageBuild {
     /// The channels to use for fetching build tools. If this is `None` the
     /// channels from the containing workspace should be used.
     pub channels: Option<Vec<NamedChannelOrUrl>>,
+
+    /// Additional configuration for the build backend.
+    pub configuration: Option<serde_value::Value>,
 }
 
 #[derive(Debug, Clone)]

crates/pixi_manifest/src/toml/build_system.rs

@@ -1,8 +1,10 @@
+use std::collections::BTreeMap;
+
 use itertools::Either;
 use pixi_spec::TomlSpec;
 use pixi_toml::{TomlFromStr, TomlWith};
 use rattler_conda_types::NamedChannelOrUrl;
-use toml_span::{de_helpers::TableHelper, DeserError, Spanned, Value};
+use toml_span::{de_helpers::TableHelper, value::ValueInner, DeserError, Spanned, Value};
 
 use crate::{
     build_system::BuildBackend,
@@ -16,6 +18,7 @@ pub struct TomlPackageBuild {
     pub backend: PixiSpanned<TomlBuildBackend>,
     pub channels: Option<PixiSpanned<Vec<NamedChannelOrUrl>>>,
     pub additional_dependencies: UniquePackageMap,
+    pub configuration: Option<serde_value::Value>,
 }
 
 #[derive(Debug)]
@@ -74,10 +77,37 @@ impl TomlPackageBuild {
             },
             additional_dependencies,
             channels: self.channels.map(|channels| channels.value),
+            configuration: self.configuration,
         })
     }
 }
 
+fn convert_toml_to_serde(value: &mut Value) -> Result<serde_value::Value, DeserError> {
+    Ok(match value.take() {
+        ValueInner::String(s) => serde_value::Value::String(s.to_string()),
+        ValueInner::Integer(i) => serde_value::Value::I64(i),
+        ValueInner::Float(f) => serde_value::Value::F64(f),
+        ValueInner::Boolean(b) => serde_value::Value::Bool(b),
+        ValueInner::Array(mut arr) => {
+            let mut json_arr = Vec::new();
+            for item in &mut arr {
+                json_arr.push(convert_toml_to_serde(item)?);
+            }
+            serde_value::Value::Seq(json_arr)
+        }
+        ValueInner::Table(table) => {
+            let mut map = BTreeMap::new();
+            for (key, mut val) in table {
+                map.insert(
+                    serde_value::Value::String(key.to_string()),
+                    convert_toml_to_serde(&mut val)?,
+                );
+            }
+            serde_value::Value::Map(map)
+        }
+    })
+}
+
 impl<'de> toml_span::Deserialize<'de> for TomlBuildBackend {
     fn deserialize(value: &mut Value<'de>) -> Result<Self, DeserError> {
         let mut th = TableHelper::new(value)?;
@@ -107,11 +137,18 @@ impl<'de> toml_span::Deserialize<'de> for TomlPackageBuild {
                 span: Some(s.span.start..s.span.end),
             });
         let additional_dependencies = th.optional("additional-dependencies").unwrap_or_default();
+
+        let configuration = th
+            .take("configuration")
+            .map(|(_, mut value)| convert_toml_to_serde(&mut value))
+            .transpose()?;
+
         th.finalize(None)?;
         Ok(Self {
             backend: build_backend,
             channels,
             additional_dependencies,
+            configuration,
         })
     }
 }
@@ -131,6 +168,18 @@ mod test {
         format_parse_error(pixi_toml, parse_error)
     }
 
+    #[test]
+    fn test_configuration_parsing() {
+        let toml = r#"
+            backend = { name = "foobar", version = "*" }
+            configuration = { key = "value", other = ["foo", "bar"], integer = 1234, nested = { abc = "def" } }
+        "#;
+        let parsed = <TomlPackageBuild as crate::toml::FromTomlStr>::from_toml_str(toml)
+            .expect("parsing should succeed");
+
+        insta::assert_debug_snapshot!(parsed);
+    }
+
     #[test]
     fn test_disallow_source() {
         assert_snapshot!(expect_parse_failure(

crates/pixi_manifest/src/toml/snapshots/pixi_manifest__toml__build_system__test__additional_keys.snap

@@ -2,7 +2,7 @@
 source: crates/pixi_manifest/src/toml/build_system.rs
 expression: "expect_parse_failure(r#\"\n            backend = { name = \"foobar\", version = \"*\" }\n            additional = \"key\"\n        \"#)"
 ---
-  × Unexpected keys, expected only 'backend', 'channels', 'additional-dependencies'
+  × Unexpected keys, expected only 'backend', 'channels', 'additional-dependencies', 'configuration'
    ╭─[pixi.toml:3:13]
  2 │             backend = { name = "foobar", version = "*" }
  3 │             additional = "key"

crates/pixi_manifest/src/toml/snapshots/pixi_manifest__toml__build_system__test__configuration_parsing.snap

@@ -0,0 +1,86 @@
+---
+source: crates/pixi_manifest/src/toml/build_system.rs
+expression: parsed
+---
+TomlPackageBuild {
+    backend: PixiSpanned {
+        span: Some(
+            23..57,
+        ),
+        value: TomlBuildBackend {
+            name: PixiSpanned {
+                span: Some(
+                    33..39,
+                ),
+                value: PackageName {
+                    normalized: None,
+                    source: "foobar",
+                },
+            },
+            spec: TomlSpec {
+                version: Some(
+                    Any,
+                ),
+                url: None,
+                git: None,
+                path: None,
+                branch: None,
+                rev: None,
+                tag: None,
+                subdirectory: None,
+                build: None,
+                build_number: None,
+                file_name: None,
+                channel: None,
+                subdir: None,
+                md5: None,
+                sha256: None,
+            },
+        },
+    },
+    channels: None,
+    additional_dependencies: UniquePackageMap {
+        specs: {},
+        name_spans: {},
+        value_spans: {},
+    },
+    configuration: Some(
+        Map(
+            {
+                String(
+                    "integer",
+                ): I64(
+                    1234,
+                ),
+                String(
+                    "key",
+                ): String(
+                    "value",
+                ),
+                String(
+                    "nested",
+                ): Map(
+                    {
+                        String(
+                            "abc",
+                        ): String(
+                            "def",
+                        ),
+                    },
+                ),
+                String(
+                    "other",
+                ): Seq(
+                    [
+                        String(
+                            "foo",
+                        ),
+                        String(
+                            "bar",
+                        ),
+                    ],
+                ),
+            },
+        ),
+    ),
+}

schema/model.py

@@ -601,6 +601,9 @@ class Build(StrictBaseModel):
     additional_dependencies: Dependencies = Field(
         None, description="Additional dependencies to install alongside the build backend"
     )
+    configuration: dict[str, Any] = Field(
+        None, description="The configuration of the build backend"
+    )
 
 
 class BuildBackend(MatchspecTable):

schema/schema.json

@@ -295,6 +295,11 @@
               }
             ]
           }
+        },
+        "configuration": {
+          "title": "Configuration",
+          "description": "The configuration of the build backend",
+          "type": "object"
         }
       }
     },