add setting no-cd

Author: hans-d

README.md

@@ -950,6 +950,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 := '…'`:
 
@@ -1043,6 +1049,7 @@ foo:
 | `ignore-comments` | boolean | `false` | Ignore recipe lines beginning with `#`. |
 | `no-exit-message`<sup>1.39.0</sup> | boolean | `false` | Don't print exit messages if recipes fail. |
 | `lazy`<sup>1.47.0</sup> | boolean | `false` | Don't evaluate unused variables. |
+| `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

@@ -417,6 +417,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

@@ -262,6 +262,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()
+      ),
       OptionNameContainsEqualSign { parameter } => {
         write!(
           f,

src/compile_error_kind.rs

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

src/evaluator.rs

@@ -86,6 +86,9 @@ impl<'src, 'run> Evaluator<'src, 'run> {
         Setting::Lazy(value) => {
           settings.lazy = value;
         }
+        Setting::NoCd(value) => {
+          settings.no_cd = value;
+        }
         Setting::NoExitMessage(value) => {
           settings.no_exit_message = value;
         }

src/execution_context.rs

@@ -41,15 +41,20 @@ 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
+      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()
     };
 
     if let Some(setting) = &self.module.settings.working_directory {
       base.join(setting)
     } else {
-      base.into()
+      base
     }
   }
 }

src/keyword.rs

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

src/node.rs

@@ -283,6 +283,7 @@ impl<'src> Node<'src> for Set<'src> {
       | Setting::Guards(value)
       | Setting::IgnoreComments(value)
       | Setting::Lazy(value)
+      | Setting::NoCd(value)
       | Setting::NoExitMessage(value)
       | Setting::PositionalArguments(value)
       | Setting::Quiet(value)

src/parser.rs

@@ -1416,6 +1416,7 @@ impl<'run, 'src> Parser<'run, 'src> {
       Keyword::Guards => Some(Setting::Guards(self.parse_set_bool()?)),
       Keyword::IgnoreComments => Some(Setting::IgnoreComments(self.parse_set_bool()?)),
       Keyword::Lazy => Some(Setting::Lazy(self.parse_set_bool()?)),
+      Keyword::NoCd => Some(Setting::NoCd(self.parse_set_bool()?)),
       Keyword::NoExitMessage => Some(Setting::NoExitMessage(self.parse_set_bool()?)),
       Keyword::PositionalArguments => Some(Setting::PositionalArguments(self.parse_set_bool()?)),
       Keyword::Quiet => Some(Setting::Quiet(self.parse_set_bool()?)),
@@ -2650,6 +2651,12 @@ mod tests {
     tree: (justfile (set quiet false)),
   }
 
+  test! {
+    name: set_no_cd,
+    text: "set no-cd := true",
+    tree: (justfile (set no_cd true)),
+  }
+
   test! {
     name: set_positional_arguments_false,
     text: "set positional-arguments := false",

src/recipe.rs

@@ -169,8 +169,19 @@ impl<'src> Recipe<'src> {
         .contains(AttributeDiscriminant::PositionalArguments)
   }
 
-  pub(crate) fn change_directory(&self) -> bool {
-    !self.attributes.contains(AttributeDiscriminant::NoCd)
+  pub(crate) fn change_directory(&self, settings: &Settings) -> bool {
+    if self
+      .attributes
+      .contains(AttributeDiscriminant::WorkingDirectory)
+    {
+      return true;
+    }
+
+    if self.attributes.contains(AttributeDiscriminant::NoCd) {
+      return false;
+    }
+
+    !settings.no_cd
   }
 
   fn print_exit_message(&self, settings: &Settings) -> bool {
@@ -185,20 +196,20 @@ impl<'src> Recipe<'src> {
     }
   }
 
-  fn working_directory<'a>(&'a self, context: &'a ExecutionContext) -> Option<PathBuf> {
-    if !self.change_directory() {
-      return None;
-    }
-
-    let working_directory = context.working_directory();
+  pub(crate) fn working_directory<'a>(&'a self, context: &'a ExecutionContext) -> Option<PathBuf> {
+    let module_working_directory = context.working_directory();
 
     for attribute in &self.attributes {
       if let Attribute::WorkingDirectory(dir) = attribute {
-        return Some(working_directory.join(&dir.cooked));
+        return Some(module_working_directory.join(&dir.cooked));
       }
     }
 
-    Some(working_directory)
+    if !self.change_directory(&context.module.settings) {
+      return None;
+    }
+
+    Some(module_working_directory)
   }
 
   fn no_quiet(&self) -> bool {