add setting no-cd

Author: hans-d

README.md

@@ -935,6 +935,12 @@ $ just bar
 /subdir
 ```
 
+To apply the same behavior to every recipe in a module, use `set no-cd := true`.
+This setting is module-local, so imported modules choose their own default, and
+it can't appear alongside `set working-directory` in the same `justfile`.
+Recipe-level attributes still take precedence: `[working-directory(...)]`
+overrides both, and `[no-cd]` on a recipe overrides `set working-directory`.
+
 You can override the working directory for all recipes with
 `set working-directory := '…'`:
 
@@ -1026,6 +1032,7 @@ foo:
 | `export` | boolean | `false` | Export all variables as environment variables. |
 | `fallback` | boolean | `false` | Search `justfile` in parent directory if the first recipe on the command line is not found. |
 | `ignore-comments` | boolean | `false` | Ignore recipe lines beginning with `#`. |
+| `no-cd` | boolean | `false` | Don't change directory before executing recipes and evaluating backticks, unless overridden by recipe attributes. |
 | `positional-arguments` | boolean | `false` | Pass positional arguments. |
 | `quiet` | boolean | `false` | Disable echoing recipe lines before executing. |
 | `script-interpreter`<sup>1.33.0</sup> | `[COMMAND, ARGS…]` | `['sh', '-eu']` | Set command used to invoke recipes with empty `[script]` attribute. |

src/analyzer.rs

@@ -311,6 +311,30 @@ impl<'run, 'src> Analyzer<'run, 'src> {
       }));
     }
 
+    if let Some(keyword) = Keyword::from_lexeme(set.name.lexeme()) {
+      match keyword {
+        Keyword::NoCd => {
+          if let Some(conflict) = self.sets.get(Keyword::WorkingDirectory.lexeme()) {
+            return Err(set.name.error(NoCdAndWorkingDirectorySetting {
+              first: Keyword::WorkingDirectory,
+              first_line: conflict.name.line,
+              second: keyword,
+            }));
+          }
+        }
+        Keyword::WorkingDirectory => {
+          if let Some(conflict) = self.sets.get(Keyword::NoCd.lexeme()) {
+            return Err(set.name.error(NoCdAndWorkingDirectorySetting {
+              first: Keyword::NoCd,
+              first_line: conflict.name.line,
+              second: keyword,
+            }));
+          }
+        }
+        _ => {}
+      }
+    }
+
     Ok(())
   }
 

src/compile_error.rs

@@ -212,6 +212,17 @@ impl Display for CompileError<'_> {
         f,
         "Recipe `{recipe}` has both `[no-cd]` and `[working-directory]` attributes"
       ),
+      NoCdAndWorkingDirectorySetting {
+        first,
+        first_line,
+        second,
+      } => write!(
+        f,
+        "Setting `{}` first set on line {} is incompatible with setting `{}`",
+        first.lexeme(),
+        first_line.ordinal(),
+        second.lexeme()
+      ),
       ParameterFollowsVariadicParameter { parameter } => {
         write!(f, "Parameter `{parameter}` follows variadic parameter")
       }

src/compile_error_kind.rs

@@ -90,6 +90,11 @@ pub(crate) enum CompileErrorKind<'src> {
   NoCdAndWorkingDirectoryAttribute {
     recipe: &'src str,
   },
+  NoCdAndWorkingDirectorySetting {
+    first: Keyword,
+    first_line: usize,
+    second: Keyword,
+  },
   ParameterFollowsVariadicParameter {
     parameter: &'src str,
   },

src/evaluator.rs

@@ -1,13 +1,25 @@
-use super::*;
+use {super::*, std::path::Path};
 
 pub(crate) struct Evaluator<'src: 'run, 'run> {
   pub(crate) assignments: Option<&'run Table<'src, Assignment<'src>>>,
   pub(crate) context: ExecutionContext<'src, 'run>,
   pub(crate) is_dependency: bool,
   pub(crate) scope: Scope<'src, 'run>,
+  pub(crate) working_directory: Option<PathBuf>,
 }
 
 impl<'src, 'run> Evaluator<'src, 'run> {
+  pub(crate) fn working_directory(&self) -> Option<&Path> {
+    self.working_directory.as_deref()
+  }
+
+  pub(crate) fn working_directory_or_invocation(&self) -> PathBuf {
+    self
+      .working_directory
+      .clone()
+      .unwrap_or_else(|| self.context.config.invocation_directory.clone())
+  }
+
   pub(crate) fn evaluate_assignments(
     config: &'run Config,
     dotenv: &'run BTreeMap<String, String>,
@@ -55,6 +67,7 @@ impl<'src, 'run> Evaluator<'src, 'run> {
       assignments: Some(&module.assignments),
       scope,
       is_dependency: false,
+      working_directory: context.module_default_working_directory(),
     };
 
     for assignment in module.assignments.values() {
@@ -273,10 +286,13 @@ impl<'src, 'run> Evaluator<'src, 'run> {
       .settings
       .shell_command(self.context.config);
 
+    cmd.arg(command).args(args);
+
+    if let Some(working_directory) = self.working_directory() {
+      cmd.current_dir(working_directory);
+    }
+
     cmd
-      .arg(command)
-      .args(args)
-      .current_dir(self.context.working_directory())
       .export(
         &self.context.module.settings,
         self.context.dotenv,
@@ -325,8 +341,9 @@ impl<'src, 'run> Evaluator<'src, 'run> {
     arguments: &[String],
     parameters: &[Parameter<'src>],
     scope: &'run Scope<'src, 'run>,
+    working_directory: Option<PathBuf>,
   ) -> RunResult<'src, (Scope<'src, 'run>, Vec<String>)> {
-    let mut evaluator = Self::new(context, is_dependency, scope);
+    let mut evaluator = Self::new(context, is_dependency, scope, working_directory);
 
     let mut positional = Vec::new();
 
@@ -374,12 +391,14 @@ impl<'src, 'run> Evaluator<'src, 'run> {
     context: &ExecutionContext<'src, 'run>,
     is_dependency: bool,
     scope: &'run Scope<'src, 'run>,
+    working_directory: Option<PathBuf>,
   ) -> Self {
     Self {
       assignments: None,
       context: *context,
       is_dependency,
       scope: scope.child(),
+      working_directory: working_directory.or_else(|| context.module_default_working_directory()),
     }
   }
 }

src/execution_context.rs

@@ -39,17 +39,34 @@ impl<'src: 'run, 'run> ExecutionContext<'src, 'run> {
     })
   }
 
-  pub(crate) fn working_directory(&self) -> PathBuf {
-    let base = if self.module.is_submodule() {
-      &self.module.working_directory
+  pub(crate) fn module_base_directory(&self) -> PathBuf {
+    if self.module.is_submodule() {
+      self
+        .module
+        .source
+        .parent()
+        .map(Path::to_path_buf)
+        .unwrap_or_else(|| self.search.working_directory.clone())
     } else {
-      &self.search.working_directory
-    };
+      self.search.working_directory.clone()
+    }
+  }
+
+  pub(crate) fn module_working_directory(&self) -> PathBuf {
+    let base = self.module_base_directory();
 
     if let Some(setting) = &self.module.settings.working_directory {
       base.join(setting)
     } else {
-      base.into()
+      base
+    }
+  }
+
+  pub(crate) fn module_default_working_directory(&self) -> Option<PathBuf> {
+    if self.module.settings.no_cd {
+      None
+    } else {
+      Some(self.module_working_directory())
     }
   }
 }

src/function.rs

@@ -134,17 +134,13 @@ impl Function {
 }
 
 fn absolute_path(context: Context, path: &str) -> FunctionResult {
-  let abs_path_unchecked = context
-    .evaluator
-    .context
-    .working_directory()
-    .join(path)
-    .lexiclean();
+  let working_directory = context.evaluator.working_directory_or_invocation();
+  let abs_path_unchecked = working_directory.join(path).lexiclean();
   match abs_path_unchecked.to_str() {
     Some(absolute_path) => Ok(absolute_path.to_owned()),
     None => Err(format!(
       "Working directory is not valid unicode: {}",
-      context.evaluator.context.search.working_directory.display()
+      working_directory.display()
     )),
   }
 }
@@ -167,7 +163,10 @@ fn blake3(_context: Context, s: &str) -> FunctionResult {
 }
 
 fn blake3_file(context: Context, path: &str) -> FunctionResult {
-  let path = context.evaluator.context.working_directory().join(path);
+  let path = context
+    .evaluator
+    .working_directory_or_invocation()
+    .join(path);
   let mut hasher = blake3::Hasher::new();
   hasher
     .update_mmap_rayon(&path)
@@ -176,8 +175,13 @@ fn blake3_file(context: Context, path: &str) -> FunctionResult {
 }
 
 fn canonicalize(context: Context, path: &str) -> FunctionResult {
-  let canonical = std::fs::canonicalize(context.evaluator.context.working_directory().join(path))
-    .map_err(|err| format!("I/O error canonicalizing path: {err}"))?;
+  let canonical = std::fs::canonicalize(
+    context
+      .evaluator
+      .working_directory_or_invocation()
+      .join(path),
+  )
+  .map_err(|err| format!("I/O error canonicalizing path: {err}"))?;
 
   canonical.to_str().map(str::to_string).ok_or_else(|| {
     format!(
@@ -495,8 +499,7 @@ fn path_exists(context: Context, path: &str) -> FunctionResult {
   Ok(
     context
       .evaluator
-      .context
-      .working_directory()
+      .working_directory_or_invocation()
       .join(path)
       .exists()
       .to_string(),
@@ -508,8 +511,13 @@ fn quote(_context: Context, s: &str) -> FunctionResult {
 }
 
 fn read(context: Context, filename: &str) -> FunctionResult {
-  fs::read_to_string(context.evaluator.context.working_directory().join(filename))
-    .map_err(|err| format!("I/O error reading `{filename}`: {err}"))
+  fs::read_to_string(
+    context
+      .evaluator
+      .working_directory_or_invocation()
+      .join(filename),
+  )
+  .map_err(|err| format!("I/O error reading `{filename}`: {err}"))
 }
 
 fn replace(_context: Context, s: &str, from: &str, to: &str) -> FunctionResult {
@@ -539,7 +547,10 @@ fn sha256(_context: Context, s: &str) -> FunctionResult {
 
 fn sha256_file(context: Context, path: &str) -> FunctionResult {
   use sha2::{Digest, Sha256};
-  let path = context.evaluator.context.working_directory().join(path);
+  let path = context
+    .evaluator
+    .working_directory_or_invocation()
+    .join(path);
   let mut hasher = Sha256::new();
   let mut file =
     fs::File::open(&path).map_err(|err| format!("Failed to open `{}`: {err}", path.display()))?;

src/justfile.rs

@@ -343,17 +343,20 @@ impl<'src> Justfile<'src> {
       search,
     };
 
+    let recipe_working_directory = recipe.working_directory(&context);
+
     let (outer, positional) = Evaluator::evaluate_parameters(
       &context,
       is_dependency,
       arguments,
       &recipe.parameters,
       scope,
+      recipe_working_directory.clone(),
     )?;
 
     let scope = outer.child();
 
-    let mut evaluator = Evaluator::new(&context, true, &scope);
+    let mut evaluator = Evaluator::new(&context, true, &scope, recipe_working_directory.clone());
 
     Self::run_dependencies(
       config,

src/keyword.rs

@@ -20,6 +20,7 @@ pub(crate) enum Keyword {
   IgnoreComments,
   Import,
   Mod,
+  NoCd,
   NoExitMessage,
   PositionalArguments,
   Quiet,

src/node.rs

@@ -307,6 +307,7 @@ impl<'src> Node<'src> for Set<'src> {
       | Setting::DotenvRequired(value)
       | Setting::Export(value)
       | Setting::Fallback(value)
+      | Setting::NoCd(value)
       | Setting::NoExitMessage(value)
       | Setting::PositionalArguments(value)
       | Setting::Quiet(value)