Merge remote-tracking branch 'upstream/main' into fix/use_urls_for_ch…

…annel

examples/linking/recipe.yaml

@@ -26,5 +26,11 @@ requirements:
 
 tests:
   - script:
-      - zlink
-      - ldd $PREFIX/bin/zlink
+    - if: linux
+      then:
+        - zlink
+        - ldd $PREFIX/bin/zlink
+    - if: osx
+      then:
+        - zlink
+        - otool -L $PREFIX/bin/zlink

pixi.toml

@@ -11,6 +11,8 @@ install = "cargo install --path . --locked"
 end_to_end_test = "pytest test/end-to-end -v -s"
 test = "cargo test"
 lint = "pre-commit run --all"
+
+[feature.docs.tasks]
 build-docs = "mkdocs build --strict"
 docs = "mkdocs serve"
 deploy-latest = "mike deploy --push --update-aliases $RELEASE_VERSION latest"
@@ -30,9 +32,14 @@ pytest = "7.4.2.*"
 pyyaml = ">=6.0.1,<6.1"
 conda-package-handling = "2.2.0.*"
 
-# Documentation building
+[feature.docs.dependencies]
 mkdocs = "1.5.3.*"
 mkdocs-material = ">=9.5.16,<9.7"
 pillow = ">=9.4.0"
 cairosvg = "2.7.1.*"
 mike = "2.0.0.*"
+
+[environments]
+# Using same solve group to keep the environment consistent in versions used and improving cache hits
+default = {solve-group = "default"}
+docs = {features = ["docs"], no-default-feature = true, solve-group = "default"}

src/metadata.rs

@@ -636,7 +636,7 @@ mod test {
     use rattler_digest::{parse_digest_from_hex, Md5, Sha256};
     use url::Url;
 
-    use crate::render::resolved_dependencies::{self, DependencyInfo};
+    use crate::render::resolved_dependencies::{self, SourceDependency};
 
     use super::{Directories, Output};
 
@@ -665,9 +665,10 @@ mod test {
     #[test]
     fn test_resolved_dependencies_rendering() {
         let resolved_dependencies = resolved_dependencies::ResolvedDependencies {
-            specs: vec![DependencyInfo::Raw {
+            specs: vec![SourceDependency {
                 spec: MatchSpec::from_str("python 3.12.* h12332", ParseStrictness::Strict).unwrap(),
-            }],
+            }
+            .into()],
             resolved: vec![RepoDataRecord {
                 package_record: PackageRecord {
                     arch: Some("x86_64".into()),

src/post_process/checks.rs

@@ -4,15 +4,13 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use crate::post_process::{package_nature::PackageNature, relink};
 use crate::{
     metadata::Output,
     post_process::{package_nature::PrefixInfo, relink::RelinkError},
 };
-use crate::{
-    post_process::{package_nature::PackageNature, relink},
-    render::resolved_dependencies::DependencyInfo,
-};
 
+use crate::render::resolved_dependencies::RunExportDependency;
 use globset::{Glob, GlobSet, GlobSetBuilder};
 use rattler_conda_types::{PackageName, PrefixRecord};
 
@@ -121,7 +119,7 @@ fn resolved_run_dependencies(
         .depends
         .iter()
         .filter(|dep| {
-            if let DependencyInfo::RunExport { from, .. } = dep {
+            if let Some(RunExportDependency { from, .. }) = dep.as_run_export() {
                 from != &String::from("build")
             } else {
                 true

src/recipe/jinja.rs

@@ -7,6 +7,7 @@ use minijinja::value::Object;
 use minijinja::{Environment, Value};
 use rattler_conda_types::{PackageName, ParseStrictness, Version};
 
+use crate::render::pin::PinArgs;
 pub use crate::render::pin::{Pin, PinExpression};
 pub use crate::selectors::SelectorConfig;
 
@@ -95,9 +96,7 @@ fn jinja_pin_function(
     // we translate the compiler into a YAML string
     let mut pin_subpackage = Pin {
         name,
-        max_pin: None,
-        min_pin: None,
-        exact: false,
+        args: PinArgs::default(),
     };
 
     let pin_expr_from_value = |pin_expr: &minijinja::value::Value| {
@@ -113,16 +112,16 @@ fn jinja_pin_function(
         let max_pin = kwargs.get_attr("max_pin")?;
         if max_pin != minijinja::value::Value::UNDEFINED {
             let pin_expr = pin_expr_from_value(&max_pin)?;
-            pin_subpackage.max_pin = Some(pin_expr);
+            pin_subpackage.args.max_pin = Some(pin_expr);
         }
         let min = kwargs.get_attr("min_pin")?;
         if min != minijinja::value::Value::UNDEFINED {
             let pin_expr = pin_expr_from_value(&min)?;
-            pin_subpackage.min_pin = Some(pin_expr);
+            pin_subpackage.args.min_pin = Some(pin_expr);
         }
         let exact = kwargs.get_attr("exact")?;
         if exact != minijinja::value::Value::UNDEFINED {
-            pin_subpackage.exact = exact.is_true();
+            pin_subpackage.args.exact = exact.is_true();
         }
     }
 

src/recipe/parser/requirements.rs

@@ -538,6 +538,7 @@ mod test {
     use std::str::FromStr;
 
     use crate::recipe::jinja::PinExpression;
+    use crate::render::pin::PinArgs;
 
     use super::*;
 
@@ -569,27 +570,33 @@ mod test {
         let pin_subpackage = PinSubpackage {
             pin_subpackage: Pin {
                 name: PackageName::from_str("foo").unwrap(),
-                max_pin: Some(PinExpression::from_str("x.x").unwrap()),
-                min_pin: Some(PinExpression::from_str("x.x.x.x").unwrap()),
-                exact: false,
+                args: PinArgs {
+                    max_pin: Some(PinExpression::from_str("x.x").unwrap()),
+                    min_pin: Some(PinExpression::from_str("x.x.x.x").unwrap()),
+                    exact: false,
+                },
             },
         };
 
         let pin_compatible = PinCompatible {
             pin_compatible: Pin {
                 name: PackageName::from_str("bar").unwrap(),
-                max_pin: Some(PinExpression::from_str("x.x.x").unwrap()),
-                min_pin: Some(PinExpression::from_str("x.x").unwrap()),
-                exact: false,
+                args: PinArgs {
+                    max_pin: Some(PinExpression::from_str("x.x.x").unwrap()),
+                    min_pin: Some(PinExpression::from_str("x.x").unwrap()),
+                    exact: false,
+                },
             },
         };
 
         let pin_compatible_2 = PinCompatible {
             pin_compatible: Pin {
                 name: PackageName::from_str("bar").unwrap(),
-                max_pin: None,
-                min_pin: Some(PinExpression::from_str("x.x").unwrap()),
-                exact: true,
+                args: PinArgs {
+                    max_pin: None,
+                    min_pin: Some(PinExpression::from_str("x.x").unwrap()),
+                    exact: true,
+                },
             },
         };
 

src/recipe/parser/snapshots/rattler_build__recipe__parser__requirements__test__pin_package.snap

@@ -1,5 +1,6 @@
 ---
 source: src/recipe/parser/requirements.rs
+assertion_line: 619
 expression: "serde_yaml::to_string(&requirements).unwrap()"
 ---
 build:
@@ -8,15 +9,12 @@ build:
     name: foo
     max_pin: x.x
     min_pin: x.x.x.x
-    exact: false
 - pin_compatible:
     name: bar
     max_pin: x.x.x
     min_pin: x.x
-    exact: false
 - pin_compatible:
     name: bar
-    max_pin: null
     min_pin: x.x
     exact: true
 - compiler: gcc

src/render/pin.rs

@@ -46,14 +46,23 @@ pub struct Pin {
     /// The name of the package to pin
     pub name: PackageName,
 
+    /// The pin arguments
+    #[serde(flatten)]
+    pub args: PinArgs,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct PinArgs {
     /// A pin to a version, using `x.x.x...` as syntax
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub max_pin: Option<PinExpression>,
 
     /// A minimum pin to a version, using `x.x.x...` as syntax
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub min_pin: Option<PinExpression>,
 
     /// If an exact pin is given, we pin the exact version & hash
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
     pub exact: bool,
 }
 
@@ -73,7 +82,7 @@ impl Pin {
     /// Apply the pin to a version and hash of a resolved package. If a max_pin, min_pin or exact pin
     /// are given, the pin is applied to the version accordingly.
     pub fn apply(&self, version: &Version, hash: &str) -> Result<MatchSpec, PinError> {
-        if self.exact {
+        if self.args.exact {
             return Ok(MatchSpec::from_str(
                 &format!("{} {} {}", self.name.as_normalized(), version, hash),
                 ParseStrictness::Strict,
@@ -86,6 +95,7 @@ impl Pin {
 
         // extract same amount of digits as the pin expression (in the form of x.x.x) from version str
         let min_pin = self
+            .args
             .min_pin
             .clone()
             .unwrap_or_else(|| PinExpression("x.x.x.x.x.x".to_string()));
@@ -104,6 +114,7 @@ impl Pin {
         spec.push_str(&format!(" >={}", pin));
 
         let max_pin = self
+            .args
             .max_pin
             .clone()
             .unwrap_or_else(|| PinExpression("x".to_string()));
@@ -143,13 +154,13 @@ impl Pin {
     }
 
     pub(crate) fn internal_repr(&self) -> String {
-        let max_pin_str = if let Some(max_pin) = &self.max_pin {
+        let max_pin_str = if let Some(max_pin) = &self.args.max_pin {
             format!("{}", max_pin)
         } else {
             "".to_string()
         };
 
-        let min_pin_str = if let Some(min_pin) = &self.min_pin {
+        let min_pin_str = if let Some(min_pin) = &self.args.min_pin {
             format!("{}", min_pin)
         } else {
             "".to_string()
@@ -160,7 +171,7 @@ impl Pin {
             self.name.as_normalized(),
             max_pin_str,
             min_pin_str,
-            self.exact
+            self.args.exact
         )
     }
 
@@ -194,9 +205,11 @@ impl Pin {
             .expect("could not parse back package name from internal representation");
         Pin {
             name: package_name,
-            max_pin,
-            min_pin,
-            exact,
+            args: PinArgs {
+                max_pin,
+                min_pin,
+                exact,
+            },
         }
     }
 }
@@ -209,9 +222,11 @@ mod test {
     fn test_apply_pin() {
         let pin = Pin {
             name: PackageName::from_str("foo").unwrap(),
-            max_pin: Some(PinExpression("x.x.x".to_string())),
-            min_pin: Some(PinExpression("x.x.x".to_string())),
-            exact: false,
+            args: PinArgs {
+                max_pin: Some(PinExpression("x.x.x".to_string())),
+                min_pin: Some(PinExpression("x.x.x".to_string())),
+                exact: false,
+            },
         };
 
         let version = Version::from_str("1.2.3").unwrap();
@@ -225,19 +240,23 @@ mod test {
 
         let pin = Pin {
             name: PackageName::from_str("foo").unwrap(),
-            max_pin: Some(PinExpression("x.x.x".to_string())),
-            min_pin: None,
-            exact: false,
+            args: PinArgs {
+                max_pin: Some(PinExpression("x.x.x".to_string())),
+                min_pin: None,
+                exact: false,
+            },
         };
 
         let spec = pin.apply(&version, hash).unwrap();
         assert_eq!(spec.to_string(), "foo >=1.2.3,<1.2.4");
 
         let pin = Pin {
             name: PackageName::from_str("foo").unwrap(),
-            max_pin: None,
-            min_pin: Some(PinExpression("x.x.x".to_string())),
-            exact: false,
+            args: PinArgs {
+                max_pin: None,
+                min_pin: Some(PinExpression("x.x.x".to_string())),
+                exact: false,
+            },
         };
 
         let spec = pin.apply(&version, hash).unwrap();
@@ -248,9 +267,11 @@ mod test {
     fn test_apply_exact_pin() {
         let pin = Pin {
             name: PackageName::from_str("foo").unwrap(),
-            max_pin: Some(PinExpression("x.x.x".to_string())),
-            min_pin: Some(PinExpression("x.x.x".to_string())),
-            exact: true,
+            args: PinArgs {
+                max_pin: Some(PinExpression("x.x.x".to_string())),
+                min_pin: Some(PinExpression("x.x.x".to_string())),
+                exact: true,
+            },
         };
 
         let version = Version::from_str("1.2.3").unwrap();