Add output field to fetch blocks

Allow users to specify a custom output filename when fetching
archives through an optional "output" field in fetch blocks. This
provides control over the extracted filename, which is useful when
the original archive filename is not suitable or when consistency
across different archive sources is needed.

The implementation extends the fetch block grammar to accept both
the existing fetch specification and the new output field, updates
the extraction logic to use the custom filename when provided, and
maintains backward compatibility by falling back to the original
filename when no output is specified.

Author: PatWie

src/ast.rs

@@ -52,6 +52,7 @@ impl ModuleBlock {
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FetchBlock {
     pub spec: FetchSpec,
+    pub output: Option<String>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -186,6 +187,9 @@ impl PrettyPrint for ModuleBlock {
         if let Some(fetch) = &self.fetch {
             output.push_str("    fetch {\n");
             output.push_str(&fetch.spec.pretty_print());
+            if let Some(output_name) = &fetch.output {
+                output.push_str(&format!("        output = {}\n", output_name));
+            }
             output.push_str("    }\n");
         }
 

src/core/deps.rs

@@ -554,8 +554,14 @@ fn fetch_archive(sprout_path: &str, package: &ModuleBlock, archive: &crate::ast:
     }
     fs::create_dir_all(&source_path)?;
 
+    // Use custom output filename if specified
+    let output_filename = package.fetch.as_ref()
+        .and_then(|f| f.output.as_ref())
+        .map(|s| s.as_str())
+        .unwrap_or(original_filename);
+
     info!("Extracting {} -> {}", original_filename, source_path.display());
-    extract_archive(&cache_path, &source_path, original_filename)?;
+    extract_archive_with_output(&cache_path, &source_path, original_filename, output_filename)?;
     Ok(())
 }
 
@@ -621,7 +627,7 @@ fn compute_file_sha256(path: &Path) -> Result<String> {
     Ok(format!("{:x}", hasher.finalize()))
 }
 
-fn extract_archive(cache_path: &Path, dest: &Path, filename: &str) -> Result<()> {
+fn extract_archive_with_output(cache_path: &Path, dest: &Path, filename: &str, output_name: &str) -> Result<()> {
     use indicatif::{ProgressBar, ProgressStyle};
     use std::time::Duration;
 
@@ -654,19 +660,19 @@ fn extract_archive(cache_path: &Path, dest: &Path, filename: &str) -> Result<()>
     } else if filename.ends_with(".gz") {
         let gz_file = std::fs::File::open(cache_path)?;
         let mut decoder = flate2::read::GzDecoder::new(gz_file);
-        let output_name = filename.strip_suffix(".gz").unwrap_or(filename);
         let output_path = dest.join(output_name);
         let mut output_file = std::fs::File::create(output_path)?;
         std::io::copy(&mut decoder, &mut output_file)?;
     } else if filename.ends_with(".xz") {
         let xz_file = std::fs::File::open(cache_path)?;
         let mut decoder = xz::read::XzDecoder::new(xz_file);
-        let output_name = filename.strip_suffix(".xz").unwrap_or(filename);
         let output_path = dest.join(output_name);
         let mut output_file = std::fs::File::create(output_path)?;
         std::io::copy(&mut decoder, &mut output_file)?;
     } else {
-        return Err(anyhow!("Unsupported archive format: {}", filename));
+        // Raw file - just copy it with the specified output name
+        let output_path = dest.join(output_name);
+        std::fs::copy(cache_path, &output_path)?;
     }
 
     if let Some(pb) = pb {

src/parser/parser.rs

@@ -170,116 +170,127 @@ fn parse_module_block(pair: pest::iterators::Pair<Rule>) -> Result<ModuleBlock>
 }
 
 fn parse_fetch_block(pair: pest::iterators::Pair<Rule>) -> Result<FetchBlock> {
-    let fetch_spec = pair
+    let mut spec = None;
+    let mut output = None;
+
+    for field in pair.into_inner() {
+        match field.as_rule() {
+            Rule::fetch_field => {
+                let inner = field.into_inner().next().ok_or_else(|| anyhow!("Empty fetch field"))?;
+                match inner.as_rule() {
+                    Rule::fetch_output_field => {
+                        let value = inner.into_inner().next().ok_or_else(|| anyhow!("Missing output value"))?;
+                        output = Some(parse_value(value)?);
+                    }
+                    Rule::fetch_spec => {
+                        spec = Some(parse_fetch_spec(inner)?);
+                    }
+                    _ => {}
+                }
+            }
+            _ => {}
+        }
+    }
+
+    Ok(FetchBlock {
+        spec: spec.ok_or_else(|| anyhow!("Missing fetch spec"))?,
+        output,
+    })
+}
+
+fn parse_fetch_spec(fetch_spec: pest::iterators::Pair<Rule>) -> Result<FetchSpec> {
+    let inner_spec = fetch_spec
         .into_inner()
         .next()
-        .ok_or_else(|| anyhow!("Missing fetch spec"))?;
-    let fetch_rule = fetch_spec.as_rule(); // Store the rule before consuming
-    debug!("Parsing fetch spec with rule: {:?}", fetch_rule);
-
-    let spec = match fetch_rule {
-        Rule::fetch_spec => {
-            // Handle the fetch_spec wrapper by processing its inner content
-            let inner_spec = fetch_spec
-                .into_inner()
-                .next()
-                .ok_or_else(|| anyhow!("Missing inner fetch spec"))?;
-            let inner_rule = inner_spec.as_rule();
-            debug!("Inner fetch spec rule: {:?}", inner_rule);
-
-            match inner_rule {
-                Rule::git_spec => {
-                    let mut url = None;
-                    let mut ref_ = None;
-                    let mut recursive = false;
-
-                    for field in inner_spec.into_inner() {
-                        if field.as_rule() == Rule::git_field {
-                            let inner_field = field.into_inner().next().unwrap();
-                            match inner_field.as_rule() {
-                                Rule::git_url_field => {
-                                    let mut parts = inner_field.into_inner();
-                                    let value = parts.next().unwrap();
-                                    url = Some(parse_value(value)?);
-                                }
-                                Rule::git_ref_field => {
-                                    let mut parts = inner_field.into_inner();
-                                    let value = parts.next().unwrap();
-                                    ref_ = Some(parse_value(value)?);
-                                }
-                                Rule::git_recursive_field => {
-                                    let mut parts = inner_field.into_inner();
-                                    let value = parts.next().unwrap();
-                                    recursive = parse_value(value)? == "true";
-                                }
-                                _ => {}
-                            }
+        .ok_or_else(|| anyhow!("Missing inner fetch spec"))?;
+    let inner_rule = inner_spec.as_rule();
+    debug!("Inner fetch spec rule: {:?}", inner_rule);
+
+    match inner_rule {
+        Rule::git_spec => {
+            let mut url = None;
+            let mut ref_ = None;
+            let mut recursive = false;
+
+            for field in inner_spec.into_inner() {
+                if field.as_rule() == Rule::git_field {
+                    let inner_field = field.into_inner().next().unwrap();
+                    match inner_field.as_rule() {
+                        Rule::git_url_field => {
+                            let mut parts = inner_field.into_inner();
+                            let value = parts.next().unwrap();
+                            url = Some(parse_value(value)?);
                         }
-                    }
-
-                    FetchSpec::Git(GitSpec {
-                        url: url.ok_or_else(|| anyhow!("Git spec missing url"))?,
-                        ref_,
-                        recursive,
-                    })
-                }
-                Rule::http_spec => {
-                    let mut url = None;
-                    let mut sha256 = None;
-
-                    for field in inner_spec.into_inner() {
-                        if field.as_rule() == Rule::http_field {
-                            let inner_field = field.into_inner().next().unwrap();
-                            match inner_field.as_rule() {
-                                Rule::http_url_field => {
-                                    let mut parts = inner_field.into_inner();
-                                    let value = parts.next().unwrap();
-                                    url = Some(parse_value(value)?);
-                                }
-                                Rule::http_sha256_field => {
-                                    let mut parts = inner_field.into_inner();
-                                    let value = parts.next().unwrap();
-                                    sha256 = Some(parse_value(value)?);
-                                }
-                                _ => {}
-                            }
+                        Rule::git_ref_field => {
+                            let mut parts = inner_field.into_inner();
+                            let value = parts.next().unwrap();
+                            ref_ = Some(parse_value(value)?);
+                        }
+                        Rule::git_recursive_field => {
+                            let mut parts = inner_field.into_inner();
+                            let value = parts.next().unwrap();
+                            recursive = parse_value(value)? == "true";
                         }
+                        _ => {}
                     }
-
-                    FetchSpec::Http(HttpSpec {
-                        url: url.ok_or_else(|| anyhow!("HTTP spec missing url"))?,
-                        sha256,
-                    })
                 }
-                Rule::local_spec => {
-                    let mut path = None;
-
-                    for field in inner_spec.into_inner() {
-                        if field.as_rule() == Rule::local_field {
-                            // local_field contains: "path" ~ "=" ~ value
-                            // field.as_str() gives us the full text like "path = /some/path"
-                            // field.into_inner() gives us only the value token
-                            let value = field.into_inner().next().unwrap(); // Only the value token
-                            path = Some(parse_value(value)?);
+            }
+
+            Ok(FetchSpec::Git(GitSpec {
+                url: url.ok_or_else(|| anyhow!("Git spec missing url"))?,
+                ref_,
+                recursive,
+            }))
+        }
+        Rule::http_spec => {
+            let mut url = None;
+            let mut sha256 = None;
+
+            for field in inner_spec.into_inner() {
+                if field.as_rule() == Rule::http_field {
+                    let inner_field = field.into_inner().next().unwrap();
+                    match inner_field.as_rule() {
+                        Rule::http_url_field => {
+                            let mut parts = inner_field.into_inner();
+                            let value = parts.next().unwrap();
+                            url = Some(parse_value(value)?);
+                        }
+                        Rule::http_sha256_field => {
+                            let mut parts = inner_field.into_inner();
+                            let value = parts.next().unwrap();
+                            sha256 = Some(parse_value(value)?);
                         }
+                        _ => {}
                     }
-
-                    FetchSpec::Local(LocalSpec {
-                        path: path.ok_or_else(|| anyhow!("Local spec missing path"))?,
-                    })
-                }
-                _ => {
-                    return Err(anyhow!(
-                        "Unsupported inner fetch spec type: {:?}",
-                        inner_rule
-                    ));
                 }
             }
+
+            Ok(FetchSpec::Http(HttpSpec {
+                url: url.ok_or_else(|| anyhow!("HTTP spec missing url"))?,
+                sha256,
+            }))
         }
-        _ => return Err(anyhow!("Unsupported fetch spec type")),
-    };
+        Rule::local_spec => {
+            let mut path = None;
+
+            for field in inner_spec.into_inner() {
+                if field.as_rule() == Rule::local_field {
+                    let value = field.into_inner().next().unwrap();
+                    path = Some(parse_value(value)?);
+                }
+            }
 
-    Ok(FetchBlock { spec })
+            Ok(FetchSpec::Local(LocalSpec {
+                path: path.ok_or_else(|| anyhow!("Local spec missing path"))?,
+            }))
+        }
+        _ => {
+            Err(anyhow!(
+                "Unsupported inner fetch spec type: {:?}",
+                inner_rule
+            ))
+        }
+    }
 }
 
 fn parse_script_block(pair: pest::iterators::Pair<Rule>) -> Result<ScriptBlock> {

src/parser/sprout.pest

@@ -22,7 +22,14 @@ depends_on_field = { "depends_on" ~ "=" ~ array }
 exports_field = { "exports" ~ "=" ~ exports_map }
 
 // Fetch block
-fetch_block = { "fetch" ~ "{" ~ fetch_spec ~ "}" }
+fetch_block = { "fetch" ~ "{" ~ fetch_field* ~ "}" }
+fetch_field = {
+    fetch_spec |
+    fetch_output_field
+}
+
+fetch_output_field = { "output" ~ "=" ~ value }
+
 fetch_spec = {
     git_spec |
     http_spec |

tree-sitter-sprout/grammar.js

@@ -50,10 +50,19 @@ module.exports = grammar({
     fetch_block: $ => seq(
       'fetch',
       '{',
-      $._fetch_spec,
+      repeat(choice(
+        $._fetch_spec,
+        $.fetch_output_field
+      )),
       '}'
     ),
 
+    fetch_output_field: $ => seq(
+      alias('output', $.field_name),
+      '=',
+      $.value
+    ),
+
     _fetch_spec: $ => choice(
       $.git_spec,
       $.archive_spec,