Add env attribute to set environment variables for recipes

The env attribute accepts two arguments (env_var_name, value) and can be used
multiple times per recipe to set environment variables:

    [env('API_KEY', 'secret')]
    [env('LOG_LEVEL', 'debug')]
    deploy:
      ./deploy.sh

Author: neunenak

README.md

@@ -2112,6 +2112,7 @@ change their behavior.
 | `[confirm(PROMPT)]`<sup>1.23.0</sup> | recipe | Require confirmation prior to executing recipe with a custom prompt. |
 | `[default]`<sup>1.43.0</sup> | recipe | Use recipe as module's default recipe. |
 | `[doc(DOC)]`<sup>1.27.0</sup> | module, recipe | Set recipe or module's [documentation comment](#documentation-comments) to `DOC`. |
+| `[env(ENV_VAR, VALUE)]` <sup>1.44</sup> | recipe | Set env vars that apply only to this recipe. |
 | `[extension(EXT)]`<sup>1.32.0</sup> | recipe | Set shebang recipe script's file extension to `EXT`. `EXT` should include a period if one is desired. |
 | `[group(NAME)]`<sup>1.27.0</sup> | module, recipe | Put recipe or module in in [group](#groups) `NAME`. |
 | `[linux]`<sup>1.8.0</sup> | recipe | Enable recipe on Linux. |
@@ -2494,6 +2495,17 @@ test $RUST_BACKTRACE="1":
   cargo test
 ```
 
+Or you can use the `[env(env_var, value)]` attribute to set environment variables that
+apply only to this recipe:
+
+```just
+
+[env("RUST_BACKTRACE", "1")]
+test:
+  # will print a stack trace if it crashes
+  cargo test
+```
+
 Exported variables and parameters are not exported to backticks in the same scope.
 
 ```just

src/attribute.rs

@@ -12,6 +12,7 @@ pub(crate) enum Attribute<'src> {
   Confirm(Option<StringLiteral<'src>>),
   Default,
   Doc(Option<StringLiteral<'src>>),
+  Env(StringLiteral<'src>, StringLiteral<'src>),
   ExitMessage,
   Extension(StringLiteral<'src>),
   Group(StringLiteral<'src>),
@@ -49,6 +50,7 @@ impl AttributeDiscriminant {
       | Self::Unix
       | Self::Windows => 0..=0,
       Self::Extension | Self::Group | Self::WorkingDirectory => 1..=1,
+      Self::Env => 2..=2,
       Self::Metadata => 1..=usize::MAX,
       Self::Script => 0..=usize::MAX,
     }
@@ -87,6 +89,20 @@ impl<'src> Attribute<'src> {
       AttributeDiscriminant::Confirm => Self::Confirm(arguments.into_iter().next()),
       AttributeDiscriminant::Default => Self::Default,
       AttributeDiscriminant::Doc => Self::Doc(arguments.into_iter().next()),
+      AttributeDiscriminant::Env => {
+        let [key, value]: [StringLiteral; 2] =
+          arguments
+            .try_into()
+            .map_err(|arguments: Vec<StringLiteral>| {
+              name.error(CompileErrorKind::AttributeArgumentCountMismatch {
+                attribute: name.lexeme(),
+                found: arguments.len(),
+                min: 2,
+                max: 2,
+              })
+            })?;
+        Self::Env(key, value)
+      }
       AttributeDiscriminant::ExitMessage => Self::ExitMessage,
       AttributeDiscriminant::Extension => Self::Extension(arguments.into_iter().next().unwrap()),
       AttributeDiscriminant::Group => Self::Group(arguments.into_iter().next().unwrap()),
@@ -124,7 +140,10 @@ impl<'src> Attribute<'src> {
   }
 
   pub(crate) fn repeatable(&self) -> bool {
-    matches!(self, Attribute::Group(_) | Attribute::Metadata(_))
+    matches!(
+      self,
+      Attribute::Env(_, _) | Attribute::Group(_) | Attribute::Metadata(_)
+    )
   }
 }
 
@@ -154,6 +173,7 @@ impl Display for Attribute<'_> {
       | Self::Extension(argument)
       | Self::Group(argument)
       | Self::WorkingDirectory(argument) => write!(f, "({argument})")?,
+      Self::Env(key, value) => write!(f, "({key}, {value})")?,
       Self::Metadata(arguments) => {
         write!(f, "(")?;
         for (i, argument) in arguments.iter().enumerate() {

src/recipe.rs

@@ -314,6 +314,12 @@ impl<'src, D> Recipe<'src, D> {
         cmd.stdout(Stdio::null());
       }
 
+      for attribute in &self.attributes {
+        if let Attribute::Env(key, value) = attribute {
+          cmd.env(&key.cooked, &value.cooked);
+        }
+      }
+
       cmd.export(
         &context.module.settings,
         context.dotenv,
@@ -445,6 +451,12 @@ impl<'src, D> Recipe<'src, D> {
       command.args(positional);
     }
 
+    for attribute in &self.attributes {
+      if let Attribute::Env(key, value) = attribute {
+        command.env(&key.cooked, &value.cooked);
+      }
+    }
+
     command.export(
       &context.module.settings,
       context.dotenv,

tests/attributes.rs

@@ -311,3 +311,80 @@ fn duplicate_non_repeatable_attributes_are_forbidden() {
     .status(EXIT_FAILURE)
     .run();
 }
+
+#[test]
+fn env_attribute_single() {
+  Test::new()
+    .justfile(
+      "
+        [env('MY_VAR', 'my_value')]
+        foo:
+          echo $MY_VAR
+      ",
+    )
+    .stdout("my_value\n")
+    .stderr("echo $MY_VAR\n")
+    .run();
+}
+
+#[test]
+fn env_attribute_multiple() {
+  Test::new()
+    .justfile(
+      "
+        [env('VAR1', 'value1')]
+        [env('VAR2', 'value 2')]
+        foo:
+          echo $VAR1 $VAR2
+      ",
+    )
+    .stdout("value1 value 2\n")
+    .stderr("echo $VAR1 $VAR2\n")
+    .run();
+}
+
+#[test]
+fn env_attribute_1_arg() {
+  Test::new()
+    .justfile(
+      "
+        [env('MY_VAR')]
+        foo:
+          echo bar
+      ",
+    )
+    .stderr(
+      "
+  error: Attribute `env` got 1 argument but takes 2 arguments
+   ——▶ justfile:1:2
+    │
+  1 │ [env('MY_VAR')]
+    │  ^^^
+",
+    )
+    .status(EXIT_FAILURE)
+    .run();
+}
+
+#[test]
+fn env_attribute_3_args() {
+  Test::new()
+    .justfile(
+      "
+        [env('A', 'B', 'C')]
+        foo:
+          echo bar
+      ",
+    )
+    .stderr(
+      "
+  error: Attribute `env` got 3 arguments but takes 2 arguments
+   ——▶ justfile:1:2
+    │
+  1 │ [env('A', 'B', 'C')]
+    │  ^^^
+",
+    )
+    .status(EXIT_FAILURE)
+    .run();
+}