Support using env attribute in recipe params

Author: neunenak

src/evaluator.rs

@@ -3,6 +3,7 @@ use super::*;
 pub(crate) struct Evaluator<'src: 'run, 'run> {
   assignments: Option<&'run Table<'src, Assignment<'src>>>,
   context: Option<ExecutionContext<'src, 'run>>,
+  env_vars: BTreeMap<String, String>,
   is_dependency: bool,
   non_const_assignments: Table<'src, Name<'src>>,
   scope: Scope<'src, 'run>,
@@ -53,6 +54,7 @@ impl<'src, 'run> Evaluator<'src, 'run> {
     let mut evaluator = Self {
       assignments: Some(assignments),
       context: None,
+      env_vars: BTreeMap::new(),
       is_dependency: false,
       non_const_assignments: Table::new(),
       scope,
@@ -201,6 +203,7 @@ impl<'src, 'run> Evaluator<'src, 'run> {
     let mut evaluator = Self {
       assignments: Some(&module.assignments),
       context: Some(context),
+      env_vars: BTreeMap::new(),
       is_dependency: false,
       non_const_assignments: Table::new(),
       scope,
@@ -273,12 +276,12 @@ impl<'src, 'run> Evaluator<'src, 'run> {
           return Ok(format!("`{contents}`"));
         }
 
-        Self::run_command(context, &self.scope, contents, &[]).map_err(|output_error| {
-          Error::Backtick {
+        Self::run_command(context, &self.env_vars, &self.scope, contents, &[]).map_err(
+          |output_error| Error::Backtick {
             token: *token,
             output_error,
-          }
-        })
+          },
+        )
       }
       Expression::Call { thunk } => {
         use Thunk::*;
@@ -436,6 +439,7 @@ impl<'src, 'run> Evaluator<'src, 'run> {
 
   pub(crate) fn run_command(
     context: &ExecutionContext,
+    env_vars: &BTreeMap<String, String>,
     scope: &Scope,
     command: &str,
     args: &[&str],
@@ -460,6 +464,10 @@ impl<'src, 'run> Evaluator<'src, 'run> {
       })
       .stdout(Stdio::piped());
 
+    for (key, value) in env_vars {
+      cmd.env(key, value);
+    }
+
     cmd.output_guard_stdout()
   }
 
@@ -498,7 +506,13 @@ impl<'src, 'run> Evaluator<'src, 'run> {
     recipe: &Recipe<'src>,
     scope: &'run Scope<'src, 'run>,
   ) -> RunResult<'src, (Scope<'src, 'run>, Vec<String>)> {
-    let mut evaluator = Self::new(context, is_dependency, scope);
+    let mut env_vars = BTreeMap::new();
+    for attribute in &recipe.attributes {
+      if let Attribute::Env(key, value) = attribute {
+        env_vars.insert(key.cooked.clone(), value.cooked.clone());
+      }
+    }
+    let mut evaluator = Self::new(context, env_vars, is_dependency, scope);
 
     let mut positional = Vec::new();
 
@@ -550,12 +564,14 @@ impl<'src, 'run> Evaluator<'src, 'run> {
 
   pub(crate) fn new(
     context: &ExecutionContext<'src, 'run>,
+    env_vars: BTreeMap<String, String>,
     is_dependency: bool,
     scope: &'run Scope<'src, 'run>,
   ) -> Self {
     Self {
       assignments: None,
       context: Some(*context),
+      env_vars,
       is_dependency,
       non_const_assignments: Table::new(),
       scope: scope.child(),

src/function.rs

@@ -544,8 +544,14 @@ fn shell(context: Context, command: &str, args: &[String]) -> FunctionResult {
     .chain(args.iter().map(String::as_str))
     .collect::<Vec<&str>>();
 
-  Evaluator::run_command(context.execution_context, context.scope, command, &args)
-    .map_err(|output_error| output_error.to_string())
+  Evaluator::run_command(
+    context.execution_context,
+    &BTreeMap::new(),
+    context.scope,
+    command,
+    &args,
+  )
+  .map_err(|output_error| output_error.to_string())
 }
 
 fn shoutykebabcase(_context: Context, s: &str) -> FunctionResult {

src/justfile.rs

@@ -304,7 +304,7 @@ impl<'src> Justfile<'src> {
 
     let scope = outer.child();
 
-    let mut evaluator = Evaluator::new(&context, true, &scope);
+    let mut evaluator = Evaluator::new(&context, BTreeMap::new(), true, &scope);
 
     Self::run_dependencies(
       config,

src/recipe.rs

@@ -222,7 +222,7 @@ impl<'src, D> Recipe<'src, D> {
       }
     }
 
-    let evaluator = Evaluator::new(context, is_dependency, scope);
+    let evaluator = Evaluator::new(context, BTreeMap::new(), is_dependency, scope);
 
     if self.is_script() {
       self.run_script(context, scope, positional, evaluator)

tests/attributes.rs

@@ -342,6 +342,20 @@ fn env_attribute_multiple() {
     .run();
 }
 
+#[test]
+fn env_attribute_in_recipe_params() {
+  Test::new()
+    .justfile(
+      r#"
+[env("foo", "bar")]
+baz x=`echo ${foo}.txt`:
+    @echo {{x}}
+"#,
+    )
+    .stdout("bar.txt\n")
+    .run();
+}
+
 #[test]
 fn env_attribute_too_few_arguments() {
   Test::new()