Add indentation setting

GRAMMAR.md

@@ -84,6 +84,7 @@ setting       : 'allow-duplicate-recipes' boolean?
               | 'fallback' boolean?
               | 'guards' boolean?
               | 'ignore-comments' boolean?
+              | 'indentation' ':=' string
               | 'lazy' boolean?
               | 'lists' boolean?
               | 'minimum-version' ':=' string

README.md

@@ -4502,6 +4502,14 @@ stdout.
 Note that formatting is not covered by any backwards compatibility guarantee
 and is subject to change from time to time.
 
+Recipe bodies are indented with four spaces by default. This can be changed
+with the `--indentation` command-line option, the `JUST_INDENTATION`
+environment variable, or the `indentation` setting:
+
+```just
+set indentation := "  "
+```
+
 Invoking `just --fmt --check` runs `--fmt` in check mode. Instead of
 overwriting the `justfile`, `just` will exit with an exit code of 0 if it is
 formatted correctly, and will exit with 1 and print a diff if it is not.
@@ -4794,6 +4802,7 @@ foo:
 | `fallback` | boolean | `false` | Search for `justfile` in parent directory if the first recipe on the command line is not found. |
 | `guards`<sup>1.47.0</sup> | boolean | `false` | Enable the `?` guard sigil on recipe lines. See [sigils](#sigils). |
 | `ignore-comments` | boolean | `false` | Ignore recipe lines beginning with `#`. |
+| `indentation`<sup>master</sup> | string | - | Set recipe body indentation used when formatting with `--fmt` or `--dump`. |
 | `lazy`<sup>1.47.0</sup> | boolean | `false` | Don't evaluate unused variables. |
 | `lists`<sup>1.53.0</sup> | boolean | `false` | Values may be lists of strings instead of strings. Currently unstable. |
 | `minimum-version`<sup>1.55.0</sup> | string | - | Error if `just` is older than `minimum-version`. Accepts a string of the form `MAJOR.MINOR.PATCH`, e.g., `"1.55.0"`. |

src/arguments.rs

@@ -186,12 +186,11 @@ pub struct Arguments {
   )]
   pub(crate) highlight: bool,
   #[arg(
-    default_value = "    ",
     env = "JUST_INDENTATION",
     help = "Indent recipes bodies with <INDENTATION>",
     long
   )]
-  pub(crate) indentation: Indentation,
+  pub(crate) indentation: Option<Indentation>,
   #[arg(
     add = ArgValueCompleter::new(PathCompleter::file()),
     env = "JUST_JUSTFILE",

src/ast.rs

@@ -13,6 +13,20 @@ pub(crate) struct Ast<'src> {
   pub(crate) working_directory: PathBuf,
 }
 
+impl Ast<'_> {
+  pub(crate) fn indentation(&self) -> Option<Indentation> {
+    self.items.iter().find_map(|item| {
+      if let Item::Setting(set) = item
+        && let Setting::Indentation(_, indentation) = set.value
+      {
+        Some(indentation)
+      } else {
+        None
+      }
+    })
+  }
+}
+
 impl ColorDisplay for Ast<'_> {
   fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {
     let mut newlines = 0;

src/color.rs

@@ -175,7 +175,14 @@ impl Color {
     }
   }
 
-  pub(crate) fn use_color(self, use_color: UseColor) -> Self {
+  pub(crate) fn with_use_color(self, use_color: UseColor) -> Self {
     Self { use_color, ..self }
   }
+
+  pub(crate) fn with_indentation(self, indentation: Indentation) -> Self {
+    Self {
+      indentation,
+      ..self
+    }
+  }
 }

src/compile_error.rs

@@ -278,6 +278,9 @@ impl Display for CompileError<'_> {
         "shell recipe `{recipe}` has script recipe attribute `{}`",
         attribute.name(),
       ),
+      InvalidIndentation { message } => {
+        write!(f, "{message}")
+      }
       InvalidMinimumVersion { source, version } => {
         write!(
           f,
@@ -305,12 +308,6 @@ impl Display for CompileError<'_> {
         f,
         "justfile requires just {minimum} or later, but using {current}",
       ),
-      MinimumVersionExpression => {
-        write!(
-          f,
-          "`minimum-version` setting must be a plain string literal"
-        )
-      }
       MismatchedClosingDelimiter {
         open,
         open_line,
@@ -372,6 +369,9 @@ impl Display for CompileError<'_> {
         f,
         "recipe `{recipe}` has both `[script]` and `[shell]` attributes"
       ),
+      SettingExpression { setting } => {
+        write!(f, "`{setting}` setting must be a plain string literal")
+      }
       ShellExpansion { err } => write!(f, "shell expansion failed: {err}"),
       ShortOptionWithMultipleCharacters { parameter } => {
         write!(

src/compile_error_kind.rs

@@ -139,6 +139,9 @@ pub(crate) enum CompileErrorKind<'src> {
   InvalidEscapeSequence {
     character: char,
   },
+  InvalidIndentation {
+    message: &'static str,
+  },
   InvalidMinimumVersion {
     source: &'static str,
     version: String,
@@ -158,7 +161,6 @@ pub(crate) enum CompileErrorKind<'src> {
     current: Version,
     minimum: Version,
   },
-  MinimumVersionExpression,
   MismatchedClosingDelimiter {
     close: Delimiter,
     open: Delimiter,
@@ -192,6 +194,9 @@ pub(crate) enum CompileErrorKind<'src> {
   ScriptAndShellAttribute {
     recipe: &'src str,
   },
+  SettingExpression {
+    setting: Keyword,
+  },
   ShellExpansion {
     err: shellexpand::LookupError<env::VarError>,
   },

src/config.rs

@@ -18,6 +18,7 @@ pub(crate) struct Config {
   pub(crate) explain: bool,
   pub(crate) groups: Vec<String>,
   pub(crate) highlight: bool,
+  pub(crate) indentation: Option<Indentation>,
   pub(crate) invocation_directory: PathBuf,
   pub(crate) justfile_names: Option<Vec<String>>,
   pub(crate) list_heading: String,
@@ -63,6 +64,7 @@ impl Config {
       explain: false,
       groups: Vec::new(),
       highlight: true,
+      indentation: None,
       invocation_directory: env::current_dir().context(config_error::CurrentDir)?,
       justfile_names: None,
       list_heading: Arguments::DEFAULT_LIST_HEADING.into(),
@@ -315,7 +317,7 @@ impl Config {
     }
 
     let unstable = arguments.unstable || subcommand == Subcommand::Summary;
-    let color = Color::new(arguments.indentation, arguments.color);
+    let color = Color::new(arguments.indentation.unwrap_or_default(), arguments.color);
 
     let invocation_directory = env::current_dir().context(config_error::CurrentDir)?;
 
@@ -338,6 +340,7 @@ impl Config {
       explain: arguments.explain,
       groups: arguments.group,
       highlight: !arguments.no_highlight,
+      indentation: arguments.indentation,
       invocation_directory,
       justfile_names: arguments.justfile_names,
       list_heading: arguments.list_heading,

src/evaluator.rs

@@ -107,6 +107,9 @@ impl<'src, 'run> Evaluator<'src, 'run> {
         Setting::IgnoreComments(value) => {
           settings.ignore_comments = value;
         }
+        Setting::Indentation(_, indentation) => {
+          settings.indentation = Some(indentation);
+        }
         Setting::Lazy(value) => {
           settings.lazy = value;
         }

src/indentation.rs

@@ -24,6 +24,15 @@ impl Display for Indentation {
   }
 }
 
+impl Serialize for Indentation {
+  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+  where
+    S: Serializer,
+  {
+    serializer.collect_str(self)
+  }
+}
+
 impl FromStr for Indentation {
   type Err = &'static str;
 

src/keyword.rs

@@ -25,6 +25,7 @@ pub(crate) enum Keyword {
   If,
   IgnoreComments,
   Import,
+  Indentation,
   Lazy,
   Lists,
   MinimumVersion,

src/node.rs

@@ -318,11 +318,13 @@ impl<'src> Node<'src> for Set<'src> {
       Setting::DotenvCommand(value)
       | Setting::DotenvFilename(value)
       | Setting::DotenvPath(value)
-      | Setting::MinimumVersion(value)
       | Setting::Tempdir(value)
       | Setting::WorkingDirectory(value) => {
         set.push_mut(value.tree());
       }
+      Setting::Indentation(value, _) | Setting::MinimumVersion(value) => {
+        set.push_mut(Tree::string(&value.cooked));
+      }
       Setting::ScriptInterpreter(Interpreter { command, arguments })
       | Setting::Shell(Interpreter { command, arguments })
       | Setting::WindowsShell(Interpreter { command, arguments }) => {

src/parser.rs

@@ -1614,15 +1614,37 @@ impl<'run, 'src> Parser<'run, 'src> {
       Keyword::DotenvCommand => Some(Setting::DotenvCommand(self.parse_expression()?)),
       Keyword::DotenvFilename => Some(Setting::DotenvFilename(self.parse_expression()?)),
       Keyword::DotenvPath => Some(Setting::DotenvPath(self.parse_expression()?)),
+      Keyword::Indentation => {
+        let expression = self.parse_expression()?;
+
+        let Expression::StringLiteral { string_literal } = expression else {
+          return Err(name.error(CompileErrorKind::SettingExpression { setting: keyword }));
+        };
+
+        if string_literal.expand || string_literal.kind.indented || string_literal.part.is_some() {
+          return Err(name.error(CompileErrorKind::SettingExpression { setting: keyword }));
+        }
+
+        let indentation = string_literal
+          .cooked
+          .parse::<Indentation>()
+          .map_err(|message| {
+            string_literal
+              .token
+              .error(CompileErrorKind::InvalidIndentation { message })
+          })?;
+
+        Some(Setting::Indentation(string_literal, indentation))
+      }
       Keyword::MinimumVersion => {
         let expression = self.parse_expression()?;
 
-        let Expression::StringLiteral { string_literal } = &expression else {
-          return Err(name.error(CompileErrorKind::MinimumVersionExpression));
+        let Expression::StringLiteral { string_literal } = expression else {
+          return Err(name.error(CompileErrorKind::SettingExpression { setting: keyword }));
         };
 
         if string_literal.expand || string_literal.kind.indented || string_literal.part.is_some() {
-          return Err(name.error(CompileErrorKind::MinimumVersionExpression));
+          return Err(name.error(CompileErrorKind::SettingExpression { setting: keyword }));
         }
 
         let minimum = string_literal.cooked.parse::<Version>().map_err(|source| {
@@ -1643,7 +1665,7 @@ impl<'run, 'src> Parser<'run, 'src> {
           );
         }
 
-        Some(Setting::MinimumVersion(expression))
+        Some(Setting::MinimumVersion(string_literal))
       }
       Keyword::ScriptInterpreter => Some(Setting::ScriptInterpreter(self.parse_interpreter()?)),
       Keyword::Shell => Some(Setting::Shell(self.parse_interpreter()?)),

src/setting.rs

@@ -16,9 +16,10 @@ pub(crate) enum Setting<'src> {
   Fallback(bool),
   Guards(bool),
   IgnoreComments(bool),
+  Indentation(StringLiteral<'src>, Indentation),
   Lazy(bool),
   Lists(bool),
-  MinimumVersion(Expression<'src>),
+  MinimumVersion(StringLiteral<'src>),
   NoCd(bool),
   NoExitMessage(bool),
   PositionalArguments(bool),
@@ -57,9 +58,9 @@ impl<'src> Setting<'src> {
       Self::DotenvCommand(_value)
       | Self::DotenvFilename(_value)
       | Self::DotenvPath(_value)
-      | Self::MinimumVersion(_value)
       | Self::Tempdir(_value)
       | Self::WorkingDirectory(_value) => false,
+      Self::Indentation(..) | Self::MinimumVersion(_) => false,
       Self::ScriptInterpreter(_value) | Self::Shell(_value) | Self::WindowsShell(_value) => false,
     }
   }
@@ -131,11 +132,11 @@ impl Display for Setting<'_> {
       Self::DotenvCommand(value)
       | Self::DotenvFilename(value)
       | Self::DotenvPath(value)
-      | Self::MinimumVersion(value)
       | Self::Tempdir(value)
       | Self::WorkingDirectory(value) => {
         write!(f, "{value}")
       }
+      Self::Indentation(value, _) | Self::MinimumVersion(value) => write!(f, "{value}"),
       Self::ScriptInterpreter(value) | Self::Shell(value) | Self::WindowsShell(value) => {
         write!(f, "[{value}]")
       }

src/settings.rs

@@ -34,6 +34,7 @@ pub(crate) struct Settings {
   pub(crate) fallback: bool,
   pub(crate) guards: bool,
   pub(crate) ignore_comments: bool,
+  pub(crate) indentation: Option<Indentation>,
   pub(crate) lazy: bool,
   pub(crate) lists: bool,
   pub(crate) no_cd: bool,

src/subcommand.rs

@@ -431,12 +431,22 @@ impl Subcommand {
           .map_err(|source| Error::DumpJson { source })?;
         println!();
       }
-      DumpFormat::Just => print!(
-        "{}",
-        compilation
-          .root_ast()
-          .color_display(config.color.use_color(UseColor::Never))
-      ),
+      DumpFormat::Just => {
+        print!(
+          "{}",
+          compilation.root_ast().color_display(
+            config
+              .color
+              .with_use_color(UseColor::Never)
+              .with_indentation(
+                config
+                  .indentation
+                  .or(compilation.justfile.settings.indentation)
+                  .unwrap_or_default()
+              )
+          )
+        );
+      }
     }
     Ok(())
   }
@@ -476,7 +486,12 @@ impl Subcommand {
     )?;
 
     let formatted = ast
-      .color_display(config.color.use_color(UseColor::Never))
+      .color_display(
+        config
+          .color
+          .with_use_color(UseColor::Never)
+          .with_indentation(config.indentation.or(ast.indentation()).unwrap_or_default()),
+      )
       .to_string();
 
     if config.check {
@@ -516,7 +531,7 @@ impl Subcommand {
         })?;
 
         if config.verbosity.loud() {
-          eprintln!("Wrote justfile to `{}`", search.justfile.display());
+          eprintln!("wrote justfile to `{}`", search.justfile.display());
         }
       }
 
@@ -541,7 +556,7 @@ impl Subcommand {
     }
 
     if config.verbosity.loud() {
-      eprintln!("Wrote justfile to `{}`", search.justfile.display());
+      eprintln!("wrote justfile to `{}`", search.justfile.display());
     }
 
     Ok(())

tests/ceiling.rs

@@ -76,9 +76,9 @@ fn justfile_init_search_stops_at_ceiling_dir() {
     .current_dir("foo/bar")
     .args(["--init", "--ceiling", ceiling.to_str().unwrap()])
     .stderr_regex(if cfg!(windows) {
-      r"Wrote justfile to `.*\\foo\\bar\\justfile`\n"
+      r"wrote justfile to `.*\\foo\\bar\\justfile`\n"
     } else {
-      "Wrote justfile to `.*/foo/bar/justfile`\n"
+      "wrote justfile to `.*/foo/bar/justfile`\n"
     })
     .success();