Add [cache(environment)] to add and remove variables from cache key

src/attribute.rs

@@ -38,6 +38,7 @@ pub(crate) enum Attribute<'src> {
     value: Option<Expression<'src>>,
   },
   Cache {
+    environment: Option<Expression<'src>>,
     extra: Option<Expression<'src>>,
     inputs: Option<Expression<'src>>,
     outputs: Option<Expression<'src>>,
@@ -228,6 +229,8 @@ impl<'src> Attribute<'src> {
       AttributeKind::Arg => Self::new_arg(name, arguments, &mut keyword_arguments)?,
       AttributeKind::Android => Self::Android,
       AttributeKind::Cache => Self::Cache {
+        environment: Self::remove_required(&mut keyword_arguments, "environment")?
+          .map(|(_key, expression)| expression),
         extra: Self::remove_required(&mut keyword_arguments, "extra")?
           .map(|(_key, expression)| expression),
         inputs: Self::remove_required(&mut keyword_arguments, "inputs")?
@@ -602,11 +605,15 @@ impl Display for Attribute<'_> {
       | Self::Unix
       | Self::Windows => {}
       Self::Cache {
+        environment,
         extra,
         inputs,
         outputs,
       } => {
         let mut arguments = Vec::new();
+        if let Some(environment) = environment {
+          arguments.push(format!("environment={environment}"));
+        }
         if let Some(extra) = extra {
           arguments.push(format!("extra={extra}"));
         }

src/cache_key.rs

@@ -3,7 +3,7 @@ use super::*;
 #[derive(Serialize)]
 pub(crate) struct CacheKey<'a> {
   pub(crate) body: &'a [String],
-  pub(crate) environment: &'a Environment,
+  pub(crate) environment: BTreeMap<String, Option<String>>,
   pub(crate) executor: &'a Executor<'a>,
   pub(crate) extension: Option<&'a str>,
   pub(crate) extra: Option<Value>,

src/error.rs

@@ -145,6 +145,10 @@ pub(crate) enum Error<'src> {
     parameter: &'src str,
     recipe: &'src str,
   },
+  EnvVarUnicode {
+    name: String,
+    value: OsString,
+  },
   EvalUnknownSubmodule {
     component: String,
     suggestion: Option<Suggestion<'src>>,
@@ -772,6 +776,13 @@ impl ColorDisplay for Error<'_> {
         let editor = editor.to_string_lossy();
         write!(f, "editor `{editor}` failed: {status}")?;
       }
+      EnvVarUnicode { name, value } => {
+        write!(
+          f,
+          "environment variable `{name}` not unicode: `{}`",
+          value.to_string_lossy(),
+        )?;
+      }
       EmptyListArgument { parameter, recipe } => {
         write!(
           f,

src/recipe.rs

@@ -568,6 +568,7 @@ impl<'src> Recipe<'src> {
 
     let (cache_lock, outputs) = if !config.no_cache
       && let Some(Attribute::Cache {
+        environment: environment_attribute,
         extra,
         inputs,
         outputs,
@@ -578,6 +579,35 @@ impl<'src> Recipe<'src> {
         None => env::current_dir().map_err(|source| Error::CurrentDirectory { source })?,
       };
 
+      let environment_attribute = environment_attribute
+        .as_ref()
+        .map(|environment| evaluator.evaluate_value(environment))
+        .transpose()?;
+
+      let environment = if let Some(names) = environment_attribute {
+        let mut variables = BTreeMap::new();
+
+        for name in names {
+          let value = if let Some(value) = environment.variables.get(&name) {
+            value.clone()
+          } else {
+            match env::var(&name) {
+              Err(env::VarError::NotPresent) => None,
+              Err(env::VarError::NotUnicode(value)) => {
+                return Err(Error::EnvVarUnicode { name, value });
+              }
+              Ok(value) => Some(value),
+            }
+          };
+
+          variables.insert(name, value);
+        }
+
+        variables
+      } else {
+        environment.variables.clone()
+      };
+
       let extra = extra
         .as_ref()
         .map(|extra| evaluator.evaluate_value(extra))
@@ -608,7 +638,7 @@ impl<'src> Recipe<'src> {
 
       let key = CacheKey {
         body: &evaluated_lines,
-        environment: &environment,
+        environment,
         executor: &executor,
         extension,
         extra,

src/unresolved_recipe.rs

@@ -75,10 +75,18 @@ impl<'src> UnresolvedRecipe<'src> {
             }
           }
           Attribute::Cache {
+            environment,
             extra,
             inputs,
             outputs,
           } => {
+            if let Some(environment) = environment {
+              variable_resolver.resolve_expression(
+                environment,
+                &parameters,
+                &mut variable_references,
+              )?;
+            }
             if let Some(extra) = extra {
               variable_resolver.resolve_expression(extra, &parameters, &mut variable_references)?;
             }

tests/cache.rs

@@ -180,12 +180,12 @@ fn environment_invalidates_cache() {
       ",
     )
     .unstable()
-    .args(["value=bar", "foo"])
+    .arg("value=bar")
     .stdout("bar\n")
     .success()
     .test()
     .unstable()
-    .args(["value=baz", "foo"])
+    .arg("value=baz")
     .stdout("baz\n")
     .success();
 }
@@ -204,12 +204,84 @@ fn unexported_variable_does_not_invalidate_cache() {
       ",
     )
     .unstable()
-    .args(["value=bar", "foo"])
+    .arg("value=bar")
     .stdout("bar\n")
     .success()
     .test()
     .unstable()
-    .args(["value=baz", "foo"])
+    .arg("value=baz")
+    .success();
+}
+
+#[test]
+fn environment_variables_may_be_removed_from_cache_key() {
+  Test::new()
+    .justfile(
+      "
+        set lists
+
+        export value := 'default'
+
+        [cache(environment=[])]
+        [script]
+        foo:
+          echo $value
+      ",
+    )
+    .unstable()
+    .arg("value=bar")
+    .stdout("bar\n")
+    .success()
+    .test()
+    .unstable()
+    .arg("value=baz")
+    .success();
+}
+
+#[test]
+fn environment_variables_may_be_added_to_cache_key() {
+  Test::new()
+    .justfile(
+      "
+        set lists
+        [cache(environment=['value'])]
+        [script]
+        foo:
+          echo $value
+      ",
+    )
+    .unstable()
+    .env("value", "bar")
+    .stdout("bar\n")
+    .success()
+    .test()
+    .unstable()
+    .env("value", "baz")
+    .stdout("baz\n")
+    .success();
+}
+
+#[test]
+fn environment_may_be_expression() {
+  Test::new()
+    .justfile(
+      "
+        set lists
+        name := 'value'
+        [cache(environment=[name])]
+        [script]
+        foo:
+          echo $value
+      ",
+    )
+    .unstable()
+    .env("value", "bar")
+    .stdout("bar\n")
+    .success()
+    .test()
+    .unstable()
+    .env("value", "baz")
+    .stdout("baz\n")
     .success();
 }
 
@@ -321,16 +393,16 @@ fn extra_invalidates_cache() {
       ",
     )
     .unstable()
-    .args(["value=a", "foo"])
+    .arg("value=a")
     .stdout("bar\n")
     .success()
     .test()
     .unstable()
-    .args(["value=a", "foo"])
+    .arg("value=a")
     .success()
     .test()
     .unstable()
-    .args(["value=b", "foo"])
+    .arg("value=b")
     .stdout("bar\n")
     .success();
 }
@@ -1131,6 +1203,30 @@ fn prints_cache_key() {
     .success();
 }
 
+#[test]
+fn cache_environment_variables_are_resolved() {
+  Test::new()
+    .justfile(
+      "
+        [cache(environment = undefined)]
+        [script('sh')]
+        foo:
+          echo bar
+      ",
+    )
+    .unstable()
+    .stderr(
+      "
+        error: variable `undefined` not defined
+         ——▶ justfile:1:22
+          │
+        1 │ [cache(environment = undefined)]
+          │                      ^^^^^^^^^
+      ",
+    )
+    .failure();
+}
+
 #[test]
 fn cache_extra_variables_are_resolved() {
   Test::new()