feat: expose common functionality (#92)

This deduplicates a bunch of code :)

Author: nichmor

crates/pixi-build-backend/src/common/configuration.rs

@@ -0,0 +1,67 @@
+use std::collections::BTreeMap;
+
+use miette::IntoDiagnostic;
+use pixi_build_types::PlatformAndVirtualPackages;
+use rattler_build::{
+    metadata::{Directories, PlatformWithVirtualPackages},
+    recipe::variable::Variable,
+    NormalizedKey,
+};
+use rattler_conda_types::ChannelUrl;
+use rattler_virtual_packages::VirtualPackageOverrides;
+use url::Url;
+
+/// Returns the [`BuildConfigurationParams`] that will be used to construct a BuildConfiguration
+pub fn build_configuration(
+    channels: Vec<Url>,
+    build_platform: Option<PlatformAndVirtualPackages>,
+    host_platform: Option<PlatformAndVirtualPackages>,
+    variant: BTreeMap<NormalizedKey, Variable>,
+    directories: Directories,
+) -> miette::Result<BuildConfigurationParams> {
+    let build_platform = build_platform.map(|p| PlatformWithVirtualPackages {
+        platform: p.platform,
+        virtual_packages: p.virtual_packages.unwrap_or_default(),
+    });
+
+    let host_platform = host_platform.map(|p| PlatformWithVirtualPackages {
+        platform: p.platform,
+        virtual_packages: p.virtual_packages.unwrap_or_default(),
+    });
+
+    let (build_platform, host_platform) = match (build_platform, host_platform) {
+        (Some(build_platform), Some(host_platform)) => (build_platform, host_platform),
+        (build_platform, host_platform) => {
+            let current_platform = rattler_build::metadata::PlatformWithVirtualPackages::detect(
+                &VirtualPackageOverrides::from_env(),
+            )
+            .into_diagnostic()?;
+            (
+                build_platform.unwrap_or_else(|| current_platform.clone()),
+                host_platform.unwrap_or(current_platform),
+            )
+        }
+    };
+
+    let channels = channels.into_iter().map(Into::into).collect();
+
+    let params = BuildConfigurationParams {
+        channels,
+        build_platform,
+        host_platform,
+        variant,
+        directories,
+    };
+
+    Ok(params)
+}
+
+/// The parameters used to construct a BuildConfiguration
+#[derive(Debug)]
+pub struct BuildConfigurationParams {
+    pub channels: Vec<ChannelUrl>,
+    pub build_platform: PlatformWithVirtualPackages,
+    pub host_platform: PlatformWithVirtualPackages,
+    pub variant: BTreeMap<NormalizedKey, Variable>,
+    pub directories: Directories,
+}

crates/pixi-build-backend/src/common/mod.rs

@@ -0,0 +1,8 @@
+//! Common utilities that are shared between the different build backends.
+mod configuration;
+mod requirements;
+mod variants;
+
+pub use configuration::{build_configuration, BuildConfigurationParams};
+pub use requirements::requirements;
+pub use variants::compute_variants;

crates/pixi-build-backend/src/common/requirements.rs

@@ -0,0 +1,25 @@
+use std::collections::BTreeMap;
+
+use rattler_build::{
+    recipe::{parser::Requirements, variable::Variable},
+    NormalizedKey,
+};
+use rattler_conda_types::ChannelConfig;
+
+use crate::{dependencies::extract_dependencies, traits::Dependencies, ProjectModel, Targets};
+
+/// Return requirements for the given project model
+pub fn requirements<P: ProjectModel>(
+    dependencies: Dependencies<<P::Targets as Targets>::Spec>,
+    channel_config: &ChannelConfig,
+    variant: &BTreeMap<NormalizedKey, Variable>,
+) -> miette::Result<Requirements> {
+    // Extract dependencies into requirements
+    let requirements = Requirements {
+        build: extract_dependencies(channel_config, dependencies.build, variant)?,
+        host: extract_dependencies(channel_config, dependencies.host, variant)?,
+        run: extract_dependencies(channel_config, dependencies.run, variant)?,
+        ..Default::default()
+    };
+    Ok(requirements)
+}

crates/pixi-build-backend/src/common/variants.rs

@@ -0,0 +1,31 @@
+//! Variants trait
+//!
+use std::collections::BTreeMap;
+
+use miette::IntoDiagnostic;
+use rattler_build::{recipe::variable::Variable, variant_config::VariantConfig, NormalizedKey};
+use rattler_conda_types::Platform;
+
+use crate::ProjectModel;
+
+/// Return variants for the given project model
+pub fn compute_variants<P: ProjectModel>(
+    project_model: &P,
+    input_variant_configuration: Option<BTreeMap<NormalizedKey, Vec<Variable>>>,
+    host_platform: Platform,
+) -> miette::Result<Vec<BTreeMap<NormalizedKey, Variable>>> {
+    // Create a variant config from the variant configuration in the parameters.
+    let variant_config = VariantConfig {
+        variants: input_variant_configuration.unwrap_or_default(),
+        pin_run_as_build: None,
+        zip_keys: None,
+    };
+
+    // Determine the variant keys that are used in the recipe.
+    let used_variants = project_model.used_variants(Some(host_platform));
+
+    // Determine the combinations of the used variants.
+    variant_config
+        .combinations(&used_variants, None)
+        .into_diagnostic()
+}

crates/pixi-build-backend/src/lib.rs

@@ -2,6 +2,7 @@ pub mod cli;
 pub mod protocol;
 pub mod server;
 
+pub mod common;
 mod consts;
 pub mod dependencies;
 pub mod project;

crates/pixi-build-backend/src/traits/project.rs

@@ -11,7 +11,7 @@ use pixi_build_types::{self as pbt};
 use rattler_build::NormalizedKey;
 use rattler_conda_types::{Platform, Version};
 
-use super::{targets::Targets, PackageSpec};
+use super::{targets::Targets, Dependencies, PackageSpec};
 
 /// A trait that defines the project model interface
 pub trait ProjectModel {
@@ -21,6 +21,16 @@ pub trait ProjectModel {
     /// Return the targets of the project model
     fn targets(&self) -> Option<&Self::Targets>;
 
+    /// Return the dependencies of the project model
+    fn dependencies(
+        &self,
+        platform: Option<Platform>,
+    ) -> Dependencies<<<Self as ProjectModel>::Targets as Targets>::Spec> {
+        self.targets()
+            .map(|t| t.dependencies(platform))
+            .unwrap_or_default()
+    }
+
     /// Return the used variants of the project model
     fn used_variants(&self, platform: Option<Platform>) -> HashSet<NormalizedKey>;