Add custom indentation length support

src/alejandra/src/builder.rs

@@ -19,6 +19,7 @@ pub(crate) struct BuildCtx {
     pub pos_old:            crate::position::Position,
     pub path:               String,
     pub vertical:           bool,
+    pub indent:             String,
 }
 
 pub(crate) fn build(
@@ -96,7 +97,7 @@ fn build_step(
                 add_token(
                     builder,
                     rnix::SyntaxKind::TOKEN_WHITESPACE,
-                    &format!("{0:<1$}", "", 2 * build_ctx.indentation),
+                    &build_ctx.indent.repeat(build_ctx.indentation),
                 );
             }
         }

src/alejandra/src/format.rs

@@ -16,7 +16,7 @@ impl From<std::io::Error> for Status {
 
 /// Formats the content of `before` in-memory,
 /// and assume `path` in the displayed error messages
-pub fn in_memory(path: String, before: String) -> (Status, String) {
+pub fn in_memory(path: String, before: String, indent: String) -> (Status, String) {
     let tokens = rnix::tokenizer::Tokenizer::new(&before);
     let ast = rnix::parser::parse(tokens);
 
@@ -32,6 +32,7 @@ pub fn in_memory(path: String, before: String) -> (Status, String) {
         path,
         pos_old: crate::position::Position::default(),
         vertical: true,
+        indent,
     };
 
     let after = crate::builder::build(&mut build_ctx, ast.node().into())
@@ -47,12 +48,12 @@ pub fn in_memory(path: String, before: String) -> (Status, String) {
 
 /// Formats the file at `path`,
 /// optionally overriding it's contents if `in_place` is true.
-pub fn in_fs(path: String, in_place: bool) -> Status {
+pub fn in_fs(path: String, in_place: bool, indent: String) -> Status {
     use std::io::Write;
 
     match std::fs::read_to_string(&path) {
         Ok(before) => {
-            let (status, data) = crate::format::in_memory(path.clone(), before);
+            let (status, data) = crate::format::in_memory(path.clone(), before, indent);
 
             match status {
                 Status::Changed(changed) => {

src/alejandra/tests/fmt.rs

@@ -17,7 +17,7 @@ fn cases() {
         let path_out = format!("tests/cases/{}/out.nix", case);
         let content_in = std::fs::read_to_string(path_in.clone()).unwrap();
         let content_got =
-            alejandra::format::in_memory(path_in, content_in.clone()).1;
+            alejandra::format::in_memory(path_in, content_in.clone(), " ".repeat(2)).1;
 
         if should_update {
             std::fs::File::create(&path_out)
@@ -35,3 +35,37 @@ fn cases() {
         );
     }
 }
+
+#[test]
+fn indent() {
+    let should_update = std::env::var("UPDATE").is_ok();
+
+    let cases: std::collections::HashSet<String> =
+        std::fs::read_dir("tests/indent")
+            .unwrap()
+            .map(|entry| entry.unwrap().file_name().into_string().unwrap())
+            .collect();
+
+    for case in cases {
+        let path_in = format!("tests/indent/{}/in.nix", case);
+        let path_out = format!("tests/indent/{}/out.nix", case);
+        let content_in = std::fs::read_to_string(path_in.clone()).unwrap();
+        let content_got =
+            alejandra::format::in_memory(path_in, content_in.clone(), "\t".to_string()).1;
+
+        if should_update {
+            std::fs::File::create(&path_out)
+                .unwrap()
+                .write_all(content_got.as_bytes())
+                .unwrap();
+        }
+
+        let content_out = std::fs::read_to_string(path_out.clone()).unwrap();
+
+        assert_eq!(
+            content_out, content_got,
+            "Test case `{case}` failed; see \
+             `src/alejandra/tests/indent/{case}/`"
+        );
+    }
+}

src/alejandra/tests/indent/apply/in.nix

@@ -0,0 +1,6 @@
+{
+  foo =
+      bar:
+          baz:
+            fnbody;
+}

src/alejandra/tests/indent/apply/out.nix

@@ -0,0 +1,4 @@
+{
+	foo = bar: baz:
+		fnbody;
+}

src/alejandra/tests/indent/attr_set/in.nix

@@ -0,0 +1,11 @@
+{
+    a = rec {
+      a = {
+        a = rec {
+          a = {
+            a = rec {a = {a = rec {a = {a = rec {a = {};};};};};};
+          };
+        };
+      };
+    };
+  }

src/alejandra/tests/indent/attr_set/out.nix

@@ -0,0 +1,11 @@
+{
+	a = rec {
+		a = {
+			a = rec {
+				a = {
+					a = rec {a = {a = rec {a = {a = rec {a = {};};};};};};
+				};
+			};
+		};
+	};
+}

src/alejandra/tests/indent/list/in.nix

@@ -0,0 +1,11 @@
+[
+      # over indented
+  1
+ # under indented
+  2
+# no indentation
+    [1 2]
+    [
+    1 2 3
+    ]
+]

src/alejandra/tests/indent/list/out.nix

@@ -0,0 +1,13 @@
+[
+	# over indented
+	1
+	# under indented
+	2
+	# no indentation
+	[1 2]
+	[
+		1
+		2
+		3
+	]
+]

src/alejandra_cli/src/cli.rs

@@ -47,6 +47,25 @@ struct CLIArgs {
     /// twice to hide error messages.
     #[clap(long, short, action = ArgAction::Count)]
     quiet: u8,
+
+    /// Specifies the number of spaces/tabs to be used for each level of indentation.
+    /// Possible options: '1t', '4', '4s' (the same as '4')
+    #[clap(long, short, value_parser = parse_indent, default_value = "2s")]
+    indent: String,
+}
+
+fn parse_indent(s: &str) -> Result<String, String> {
+    let unit = match s.chars().last() {
+        Some('t') => "\t",
+        Some(c) if c == 's' || c.is_ascii_digit() => " ",
+        None => Err("empty value is not allowed")?,
+        Some(c) => Err(format!("only 't', 's' or '' are valid units, but got '{}'", c))?,
+    };
+    let count = s
+        .trim_end_matches(['t', 's'])
+        .parse::<usize>()
+        .map_err(|e| e.to_string())?;
+    Ok(unit.repeat(count))
 }
 
 #[derive(Clone)]
@@ -55,7 +74,7 @@ struct FormattedPath {
     pub status: alejandra::format::Status,
 }
 
-fn format_stdin(verbosity: Verbosity) -> FormattedPath {
+fn format_stdin(verbosity: Verbosity, indent: String) -> FormattedPath {
     let mut before = String::new();
     let path = "<anonymous file on stdin>".to_string();
 
@@ -70,7 +89,7 @@ fn format_stdin(verbosity: Verbosity) -> FormattedPath {
         .expect("Unable to read stdin.");
 
     let (status, data) =
-        alejandra::format::in_memory(path.clone(), before.clone());
+        alejandra::format::in_memory(path.clone(), before.clone(), indent);
 
     print!("{data}");
 
@@ -82,6 +101,7 @@ fn format_paths(
     in_place: bool,
     verbosity: Verbosity,
     threads: usize,
+    indent: String,
 ) -> Vec<FormattedPath> {
     let paths_len = paths.len();
 
@@ -102,8 +122,9 @@ fn format_paths(
     let futures: FuturesUnordered<RemoteHandle<FormattedPath>> = paths
         .into_iter()
         .map(|path| {
+            let indent = indent.clone();
             pool.spawn_with_handle(async move {
-                let status = alejandra::format::in_fs(path.clone(), in_place);
+                let status = alejandra::format::in_fs(path.clone(), in_place, indent);
 
                 if let alejandra::format::Status::Changed(changed) = status {
                     if changed && verbosity.allows_info() {
@@ -146,12 +167,12 @@ pub fn main() -> std::io::Result<()> {
 
     let formatted_paths = match &include[..] {
         &[] | &["-"] => {
-            vec![crate::cli::format_stdin(verbosity)]
+            vec![crate::cli::format_stdin(verbosity, args.indent)]
         }
         include => {
             let paths = crate::find::nix_files(include, &args.exclude);
 
-            crate::cli::format_paths(paths, in_place, verbosity, threads)
+            crate::cli::format_paths(paths, in_place, verbosity, threads, args.indent)
         }
     };