extra

Author: zelosleone

src/cache.rs

@@ -16,7 +16,7 @@ use crate::{
     packaging::{Files, contains_prefix_binary, contains_prefix_text, rewrite_prefix_in_file},
     recipe::{
         Jinja,
-        parser::{Dependency, Requirements, Source},
+        parser::{CacheOutput, CacheRequirements, Dependency, Requirements, RunExports, Source},
     },
     render::resolved_dependencies::{
         FinalizedDependencies, RunExportsDownload, install_environments, resolve_dependencies,
@@ -26,6 +26,7 @@ use crate::{
         fetch_sources,
         patch::apply_patch_custom,
     },
+    tool_configuration::Configuration,
 };
 
 /// Check if a file contains the prefix and determine if it's binary or text
@@ -103,7 +104,7 @@ pub struct Cache {
 
     /// The run exports declared by the cache at build time (rendered form is computed later)
     #[serde(default)]
-    pub run_exports: crate::recipe::parser::RunExports,
+    pub run_exports: RunExports,
 
     /// Files (relative to prefix/work_dir) that contain the old prefix string and
     /// should be rewritten when restoring to a different location.
@@ -131,20 +132,17 @@ impl Output {
     pub fn cache_key_for(
         &self,
         cache_name: &str,
-        cache_reqs: &crate::recipe::parser::CacheRequirements,
+        cache_reqs: &CacheRequirements,
     ) -> Result<String, CacheKeyError> {
         let requirement_names: HashSet<_> = cache_reqs
             .build
             .iter()
             .chain(cache_reqs.host.iter())
             .filter_map(|dep| match dep {
-                crate::recipe::parser::Dependency::Spec(spec)
-                    if spec.version.is_none() && spec.build.is_none() =>
-                {
-                    spec.name
-                        .as_ref()
-                        .map(|name| name.as_normalized().to_string())
-                }
+                Dependency::Spec(spec) if spec.version.is_none() && spec.build.is_none() => spec
+                    .name
+                    .as_ref()
+                    .map(|name| name.as_normalized().to_string()),
                 _ => None,
             })
             .chain(
@@ -349,8 +347,8 @@ impl Output {
     /// Build or fetch a specific cache output
     pub async fn build_or_fetch_cache_output(
         mut self,
-        cache_output: &crate::recipe::parser::CacheOutput,
-        tool_configuration: &crate::tool_configuration::Configuration,
+        cache_output: &CacheOutput,
+        tool_configuration: &Configuration,
     ) -> Result<Self, miette::Error> {
         let cache_name = cache_output.name.as_normalized();
         let cache_key = self
@@ -410,12 +408,12 @@ impl Output {
             .into_diagnostic()?;
 
         // Convert CacheRequirements to Requirements
-        let requirements = crate::recipe::parser::Requirements {
+        let requirements = Requirements {
             build: cache_output.requirements.build.clone(),
             host: cache_output.requirements.host.clone(),
             run: Vec::new(),
             run_constraints: Vec::new(),
-            run_exports: crate::recipe::parser::RunExports::default(),
+            run_exports: RunExports::default(),
             ignore_run_exports: cache_output.ignore_run_exports.clone().unwrap_or_default(),
         };
 
@@ -564,7 +562,7 @@ impl Output {
     /// Note: this modifies the output in place
     pub(crate) async fn build_or_fetch_cache(
         self,
-        tool_configuration: &crate::tool_configuration::Configuration,
+        tool_configuration: &Configuration,
     ) -> Result<Self, miette::Error> {
         if let Some(synthetic_cache) = self.recipe.synthetic_cache_output() {
             // Convert to synthetic cache output
@@ -579,7 +577,7 @@ impl Output {
     #[allow(dead_code)]
     async fn build_or_fetch_cache_legacy(
         mut self,
-        tool_configuration: &crate::tool_configuration::Configuration,
+        tool_configuration: &Configuration,
     ) -> Result<Self, miette::Error> {
         if let Some(cache) = self.recipe.cache.clone() {
             // if we don't have a cache, we need to run the cache build with our current
@@ -741,7 +739,7 @@ impl Output {
                 work_dir_files: work_dir_files.copied_paths().to_vec(),
                 prefix: self.prefix().to_path_buf(),
                 work_dir: self.build_configuration.directories.work_dir.clone(),
-                run_exports: crate::recipe::parser::RunExports::default(),
+                run_exports: RunExports::default(),
                 files_with_prefix,
                 binary_files_with_prefix,
                 files_with_work_dir: Vec::new(),

src/lib.rs

@@ -67,6 +67,7 @@ use rattler_conda_types::{
 use rattler_config::config::build::PackageFormatAndCompression;
 use rattler_solve::SolveStrategy;
 use rattler_virtual_packages::VirtualPackageOverrides;
+use recipe::parser::output::resolve_cache_inheritance_with_caches;
 use recipe::parser::{Dependency, Recipe, TestType, find_outputs_from_src};
 use recipe::variable::Variable;
 use render::resolved_dependencies::RunExportsDownload;
@@ -233,7 +234,7 @@ pub async fn get_build_output(
         });
 
         let jinja = recipe::Jinja::new(selector_config.clone());
-        recipe::parser::output::resolve_cache_inheritance_with_caches(
+        resolve_cache_inheritance_with_caches(
             outputs,
             has_toplevel_cache,
             selector_config.experimental,

src/packaging/metadata.rs

@@ -14,6 +14,7 @@ use content_inspector::ContentType;
 use fs_err as fs;
 use fs_err::File;
 use itertools::Itertools;
+use memchr::memmem;
 use rattler_conda_types::{
     ChannelUrl, NoArchType, Platform,
     package::{
@@ -60,7 +61,7 @@ pub fn contains_prefix_binary(file_path: &Path, prefix: &Path) -> Result<bool, P
         let data = unsafe { memmap2::Mmap::map(&file) }?;
 
         // Check if the content contains the prefix bytes with memchr
-        let contains_prefix = memchr::memmem::find_iter(data.as_ref(), &prefix_bytes)
+        let contains_prefix = memmem::find_iter(data.as_ref(), &prefix_bytes)
             .next()
             .is_some();
 
@@ -83,7 +84,7 @@ pub fn contains_prefix_text(
     // Check if the content contains the prefix with memchr
     let prefix_string = prefix.to_string_lossy().to_string();
     let mut detected_prefix = None;
-    if memchr::memmem::find_iter(mmap.as_ref(), &prefix_string)
+    if memmem::find_iter(mmap.as_ref(), &prefix_string)
         .next()
         .is_some()
     {
@@ -99,7 +100,7 @@ pub fn contains_prefix_text(
         // to something meaningful in unix either way
         let forward_slash: Cow<'_, str> = to_forward_slash_lossy(prefix);
 
-        if memchr::memmem::find_iter(mmap.as_ref(), forward_slash.deref())
+        if memmem::find_iter(mmap.as_ref(), forward_slash.deref())
             .next()
             .is_some()
         {
@@ -186,7 +187,7 @@ fn rewrite_binary_prefix(
         let mut mmap = unsafe { memmap2::MmapOptions::new().map_mut(&file) }?;
 
         let mut search_start = 0;
-        while let Some(found) = memchr::memmem::find(&mmap[search_start..], old_prefix_bytes) {
+        while let Some(found) = memmem::find(&mmap[search_start..], old_prefix_bytes) {
             let pos = search_start + found;
             mmap[pos..pos + new_prefix_bytes.len()].copy_from_slice(new_prefix_bytes);
             let padding_range = pos + new_prefix_bytes.len()..pos + old_prefix_bytes.len();

src/recipe/parser/cache_output.rs

@@ -10,7 +10,9 @@
 use crate::{
     _partialerror,
     recipe::{
-        custom_yaml::{HasSpan, RenderedMappingNode, RenderedNode, TryConvertNode},
+        custom_yaml::{
+            HasSpan, RenderedMappingNode, RenderedNode, RenderedScalarNode, TryConvertNode,
+        },
         error::{ErrorKind, PartialParsingError},
         parser::{
             StandardTryConvert, build::VariantKeyUsage, invalid_field_error, missing_field_error,
@@ -377,7 +379,7 @@ fn parse_cache_requirements(
 }
 
 // For compatibility with Vec<CacheOutput> parsing
-impl TryConvertNode<CacheOutput> for crate::recipe::custom_yaml::RenderedScalarNode {
+impl TryConvertNode<CacheOutput> for RenderedScalarNode {
     fn try_convert(&self, _name: &str) -> Result<CacheOutput, Vec<PartialParsingError>> {
         Err(vec![_partialerror!(
             *self.span(),

src/recipe/parser/output.rs

@@ -10,7 +10,7 @@ use std::collections::{HashMap, HashSet};
 use crate::{
     _partialerror,
     recipe::{
-        ParsingError, Render,
+        Jinja, ParsingError, Render,
         custom_yaml::{HasSpan, Node, RenderedNode, TryConvertNode, parse_yaml},
         error::{ErrorKind, PartialParsingError},
     },
@@ -29,14 +29,8 @@ use super::{
 };
 
 /// Result type for resolve_cache_inheritance_with_caches function
-type CacheInheritanceResult = Result<
-    (
-        Vec<Node>,
-        Vec<crate::recipe::parser::CacheOutput>,
-        std::collections::HashMap<String, Vec<String>>,
-    ),
-    ParsingError<&'static str>,
->;
+type CacheInheritanceResult =
+    Result<(Vec<Node>, Vec<CacheOutput>, HashMap<String, Vec<String>>), ParsingError<&'static str>>;
 
 // Extract inherit information
 fn inherit_name_from(node: &Node) -> Option<String> {
@@ -517,7 +511,7 @@ fn detect_cache_inheritance_cycles(
 /// Parse a cache output from a Node using proper TryConvertNode
 fn parse_cache_output_from_node(
     output: &Node,
-) -> Result<Option<crate::recipe::parser::CacheOutput>, ParsingError<&'static str>> {
+) -> Result<Option<CacheOutput>, ParsingError<&'static str>> {
     // Convert Node to RenderedNode to use TryConvertNode
     // For now, we'll use a simplified approach since we don't have jinja context here
     // In a full implementation, we would need to render the node first
@@ -565,8 +559,8 @@ fn parse_cache_output_from_node(
 /// Parse inheritance relationships from outputs
 fn parse_inheritance_relationships(
     outputs: &[Node],
-) -> Result<std::collections::HashMap<String, Vec<String>>, ParsingError<&'static str>> {
-    let mut relationships = std::collections::HashMap::new();
+) -> Result<HashMap<String, Vec<String>>, ParsingError<&'static str>> {
+    let mut relationships = HashMap::new();
 
     for output in outputs {
         let Some(mapping) = output.as_mapping() else {
@@ -623,8 +617,8 @@ fn parse_inheritance_relationships(
 /// Parse cache outputs using proper TryConvertNode with jinja context
 fn parse_cache_outputs_with_context(
     outputs: &[Node],
-    jinja: &crate::recipe::Jinja,
-) -> Result<Vec<crate::recipe::parser::CacheOutput>, ParsingError<&'static str>> {
+    jinja: &Jinja,
+) -> Result<Vec<CacheOutput>, ParsingError<&'static str>> {
     use super::output_parser::OutputType;
     let mut cache_outputs = Vec::new();
 
@@ -747,10 +741,10 @@ fn topological_sort(inheritance: &HashMap<String, Vec<String>>) -> Vec<String> {
 
 /// Apply cache-to-cache inheritance to the cache outputs
 fn apply_cache_to_cache_inheritance(
-    cache_outputs: Vec<crate::recipe::parser::CacheOutput>,
+    cache_outputs: Vec<CacheOutput>,
     cache_inheritance_relationships: HashMap<String, Vec<String>>,
-) -> Vec<crate::recipe::parser::CacheOutput> {
-    let mut cache_map: HashMap<String, crate::recipe::parser::CacheOutput> = cache_outputs
+) -> Vec<CacheOutput> {
+    let mut cache_map: HashMap<String, CacheOutput> = cache_outputs
         .into_iter()
         .map(|cache| (cache.name.as_normalized().to_string(), cache))
         .collect();
@@ -816,7 +810,7 @@ pub fn resolve_cache_inheritance_with_caches(
     outputs: Vec<Node>,
     has_toplevel_cache: bool,
     experimental_enabled: bool,
-    jinja: &crate::recipe::Jinja,
+    jinja: &Jinja,
 ) -> CacheInheritanceResult {
     if !experimental_enabled {
         for output in &outputs {

src/recipe/parser/output_parser.rs

@@ -12,7 +12,7 @@ use serde::{Deserialize, Serialize};
 
 use super::cache_output::CacheOutput;
 use super::common_output::InheritSpec;
-use super::{About, Build, OutputPackage, Requirements, Source, TestType};
+use super::{About, Build, OutputPackage, Requirements, Source, TestType, build::VariantKeyUsage};
 
 fn duplicate_field_error(field: &str, span: Span) -> PartialParsingError {
     _partialerror!(
@@ -216,7 +216,7 @@ impl Output {
         }
 
         // Deep merge compatible build fields from cache (script is intentionally excluded)
-        let variant_is_default = |v: &super::build::VariantKeyUsage| {
+        let variant_is_default = |v: &VariantKeyUsage| {
             v.use_keys.is_empty() && v.ignore_keys.is_empty() && v.down_prioritize_variant.is_none()
         };
         if variant_is_default(&self.build.variant) && !variant_is_default(&cache.build.variant) {

src/types/build_output.rs

@@ -18,7 +18,11 @@ use std::{
 use crate::{
     NormalizedKey,
     console_utils::github_integration_enabled,
-    recipe::{Recipe, parser::Source, variable::Variable},
+    recipe::{
+        Recipe,
+        parser::{CacheOutput, Source},
+        variable::Variable,
+    },
     render::resolved_dependencies::FinalizedDependencies,
     system_tools::SystemTools,
     types::{BuildConfiguration, BuildSummary, PlatformWithVirtualPackages},
@@ -58,7 +62,7 @@ pub struct BuildOutput {
 
     /// Cache outputs that need to be built before this package output
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub cache_outputs_to_build: Vec<crate::recipe::parser::CacheOutput>,
+    pub cache_outputs_to_build: Vec<CacheOutput>,
 
     /// Summary of the build
     #[serde(skip)]