style: Switch to nixfmt from nixpkgs-fmt

Most of the ecosystem has moved to this formatter,
and many people configured their editors to autoformat it with this formatter.

Closes: https://git.snix.dev/snix/snix/issues/62
Change-Id: Icf39e7836c91fc2ae49fbe22a40a639105bfb0bd
Reviewed-on: https://cl.snix.dev/c/snix/+/30671
Reviewed-by: Florian Klink <flokli@flokli.de>
Tested-by: besadii
Autosubmit: Ilan Joselevich <personal@ilanjoselevich.com>

nix/readTree/tests/default.nix

@@ -1,18 +1,26 @@
-{ depot, lib, pkgs, ... }:
+{
+  depot,
+  lib,
+  pkgs,
+  ...
+}:
 
 let
   inherit (lib) partition optionalAttrs any;
   inherit (builtins) tryEval;
 
-  it = msg: asserts:
+  it =
+    msg: asserts:
     let
       results = partition (a: a.ok) asserts;
     in
     {
       _it = msg;
-    } // optionalAttrs (results.right != [ ]) {
+    }
+    // optionalAttrs (results.right != [ ]) {
       passes = map (result: result.test) results.right;
-    } // optionalAttrs (results.wrong != [ ]) {
+    }
+    // optionalAttrs (results.wrong != [ ]) {
       fails = map (result: result.test) results.wrong;
     };
 
@@ -21,16 +29,18 @@ let
     ok = a == b;
   };
 
-  assertThrows = test: value:
+  assertThrows =
+    test: value:
     let
       value' = tryEval value;
     in
     {
       inherit test;
-      ok = ! value'.success;
+      ok = !value'.success;
     };
 
-  runTestsuite = name: its:
+  runTestsuite =
+    name: its:
     let
       fails = any (it': it' ? fails) its;
     in
@@ -42,11 +52,14 @@ let
         inherit its;
       }
       (
-        if fails then ''
-          jq '.its' < .attrs.json
-        '' else ''
-          jq '.its' < .attrs.json > $out
-        ''
+        if fails then
+          ''
+            jq '.its' < .attrs.json
+          ''
+        else
+          ''
+            jq '.its' < .attrs.json > $out
+          ''
       );
 
   tree-ex = depot.nix.readTree {
@@ -55,25 +68,14 @@ let
   };
 
   example = it "corresponds to the README example" [
-    (assertEq "third_party attrset"
-      (lib.isAttrs tree-ex.third_party
-        && (! lib.isDerivation tree-ex.third_party))
-      true)
-    (assertEq "third_party attrset other attribute"
-      tree-ex.third_party.favouriteColour
-      "orange")
-    (assertEq "rustpkgs attrset aho-corasick"
-      tree-ex.third_party.rustpkgs.aho-corasick
-      "aho-corasick")
-    (assertEq "rustpkgs attrset serde"
-      tree-ex.third_party.rustpkgs.serde
-      "serde")
-    (assertEq "tools cheddear"
-      "cheddar"
-      tree-ex.tools.cheddar)
-    (assertEq "tools roquefort"
-      tree-ex.tools.roquefort
-      "roquefort")
+    (assertEq "third_party attrset" (
+      lib.isAttrs tree-ex.third_party && (!lib.isDerivation tree-ex.third_party)
+    ) true)
+    (assertEq "third_party attrset other attribute" tree-ex.third_party.favouriteColour "orange")
+    (assertEq "rustpkgs attrset aho-corasick" tree-ex.third_party.rustpkgs.aho-corasick "aho-corasick")
+    (assertEq "rustpkgs attrset serde" tree-ex.third_party.rustpkgs.serde "serde")
+    (assertEq "tools cheddear" "cheddar" tree-ex.tools.cheddar)
+    (assertEq "tools roquefort" tree-ex.tools.roquefort "roquefort")
   ];
 
   tree-tl = depot.nix.readTree {
@@ -82,65 +84,64 @@ let
   };
 
   traversal-logic = it "corresponds to the traversal logic in the README" [
-    (assertEq "skip-tree/a is read"
-      tree-tl.skip-tree.a
-      "a is read normally")
-    (assertEq "skip-tree does not contain b"
-      (builtins.attrNames tree-tl.skip-tree)
-      [ "__readTree" "__readTreeChildren" "a" ])
-    (assertEq "skip-tree children list does not contain b"
-      tree-tl.skip-tree.__readTreeChildren
-      [ "a" ])
+    (assertEq "skip-tree/a is read" tree-tl.skip-tree.a "a is read normally")
+    (assertEq "skip-tree does not contain b" (builtins.attrNames tree-tl.skip-tree) [
+      "__readTree"
+      "__readTreeChildren"
+      "a"
+    ])
+    (assertEq "skip-tree children list does not contain b" tree-tl.skip-tree.__readTreeChildren [ "a" ])
 
-    (assertEq "skip subtree default.nix is read"
-      tree-tl.skip-subtree.but
-      "the default.nix is still read")
-    (assertEq "skip subtree a/default.nix is skipped"
-      (tree-tl.skip-subtree ? a)
-      false)
-    (assertEq "skip subtree b/c.nix is skipped"
-      (tree-tl.skip-subtree ? b)
-      false)
+    (assertEq "skip subtree default.nix is read" tree-tl.skip-subtree.but
+      "the default.nix is still read"
+    )
+    (assertEq "skip subtree a/default.nix is skipped" (tree-tl.skip-subtree ? a) false)
+    (assertEq "skip subtree b/c.nix is skipped" (tree-tl.skip-subtree ? b) false)
     (assertEq "skip subtree a/default.nix would be read without .skip-subtree"
       (tree-tl.no-skip-subtree.a)
-      "am I subtree yet?")
-    (assertEq "skip subtree b/c.nix would be read without .skip-subtree"
-      (tree-tl.no-skip-subtree.b.c)
-      "cool")
+      "am I subtree yet?"
+    )
+    (assertEq "skip subtree b/c.nix would be read without .skip-subtree" (tree-tl.no-skip-subtree.b.c
+    ) "cool")
 
-    (assertEq "default.nix attrset is merged with siblings"
-      tree-tl.default-nix.no
-      "siblings should be read")
-    (assertEq "default.nix means sibling isn’t read"
-      (tree-tl.default-nix ? sibling)
-      false)
+    (assertEq "default.nix attrset is merged with siblings" tree-tl.default-nix.no
+      "siblings should be read"
+    )
+    (assertEq "default.nix means sibling isn’t read" (tree-tl.default-nix ? sibling) false)
     (assertEq "default.nix means subdirs are still read and merged into default.nix"
       (tree-tl.default-nix.subdir.a)
-      "but I’m picked up")
+      "but I’m picked up"
+    )
 
-    (assertEq "default.nix can be not an attrset"
-      tree-tl.default-nix.no-merge
-      "I’m not merged with any children")
-    (assertEq "default.nix is not an attrset -> children are not merged"
-      (tree-tl.default-nix.no-merge ? subdir)
-      false)
+    (assertEq "default.nix can be not an attrset" tree-tl.default-nix.no-merge
+      "I’m not merged with any children"
+    )
+    (assertEq "default.nix is not an attrset -> children are not merged" (
+      tree-tl.default-nix.no-merge ? subdir
+    ) false)
 
-    (assertEq "default.nix can contain a derivation"
-      (lib.isDerivation tree-tl.default-nix.can-be-drv)
-      true)
+    (assertEq "default.nix can contain a derivation" (lib.isDerivation tree-tl.default-nix.can-be-drv)
+      true
+    )
     (assertEq "Even if default.nix is a derivation, children are traversed and merged"
       tree-tl.default-nix.can-be-drv.subdir.a
-      "Picked up through the drv")
-    (assertEq "default.nix drv is not changed by readTree"
-      tree-tl.default-nix.can-be-drv
-      (import ./test-tree-traversal/default-nix/can-be-drv/default.nix { }))
+      "Picked up through the drv"
+    )
+    (assertEq "default.nix drv is not changed by readTree" tree-tl.default-nix.can-be-drv (
+      import ./test-tree-traversal/default-nix/can-be-drv/default.nix { }
+    ))
     (assertEq "`here` argument represents the attrset a given file is part of"
-      (builtins.removeAttrs tree-tl.here-arg [ "__readTree" "__readTreeChildren" "subdir" ])
+      (builtins.removeAttrs tree-tl.here-arg [
+        "__readTree"
+        "__readTreeChildren"
+        "subdir"
+      ])
       {
         attr1 = "foo";
         attr2 = "foo";
         attr3 = "sibl1";
-      })
+      }
+    )
   ];
 
   # these each call readTree themselves because the throws have to happen inside assertThrows
@@ -149,7 +150,8 @@ let
       (depot.nix.readTree {
         path = ./test-wrong-not-a-function;
         args = { };
-      }).not-a-function)
+      }).not-a-function
+    )
     # can’t test for that, assertThrows can’t catch this error
     # (assertThrows "this file is a function but doesn’t have dots"
     #   (depot.nix.readTree {} ./test-wrong-no-dots).no-dots-in-function)
@@ -160,22 +162,36 @@ let
     args = { };
   };
 
-  assertMarkerByPath = path:
+  assertMarkerByPath =
+    path:
     assertEq "${lib.concatStringsSep "." path} is marked correctly"
       (lib.getAttrFromPath path read-markers).__readTree
       path;
 
   markers = it "marks nodes correctly" [
     (assertMarkerByPath [ "directory-marked" ])
-    (assertMarkerByPath [ "directory-marked" "nested" ])
-    (assertMarkerByPath [ "file-children" "one" ])
-    (assertMarkerByPath [ "file-children" "two" ])
-    (assertEq "nix file children are marked correctly"
-      read-markers.file-children.__readTreeChildren [ "one" "two" ])
-    (assertEq "directory children are marked correctly"
-      read-markers.directory-marked.__readTreeChildren [ "nested" ])
-    (assertEq "absence of children is marked"
-      read-markers.directory-marked.nested.__readTreeChildren [ ])
+    (assertMarkerByPath [
+      "directory-marked"
+      "nested"
+    ])
+    (assertMarkerByPath [
+      "file-children"
+      "one"
+    ])
+    (assertMarkerByPath [
+      "file-children"
+      "two"
+    ])
+    (assertEq "nix file children are marked correctly" read-markers.file-children.__readTreeChildren [
+      "one"
+      "two"
+    ])
+    (assertEq "directory children are marked correctly" read-markers.directory-marked.__readTreeChildren
+      [ "nested" ]
+    )
+    (assertEq "absence of children is marked" read-markers.directory-marked.nested.__readTreeChildren
+      [ ]
+    )
   ];
 
 in

nix/readTree/tests/test-marker/directory-marked/default.nix

@@ -1,3 +1,4 @@
 { ... }:
 
-{ }
+{
+}

nix/readTree/tests/test-marker/directory-marked/nested/default.nix

@@ -1,3 +1,4 @@
 { ... }:
 
-{ }
+{
+}

nix/readTree/tests/test-marker/file-children/one.nix

@@ -1,3 +1,4 @@
 { ... }:
 
-{ }
+{
+}

nix/readTree/tests/test-marker/file-children/two.nix

@@ -1,3 +1,4 @@
 { ... }:
 
-{ }
+{
+}

nix/readTree/tests/test-tree-traversal/default-nix/can-be-drv/default.nix

@@ -3,5 +3,8 @@ derivation {
   name = "im-a-drv";
   system = builtins.currentSystem;
   builder = "/bin/sh";
-  args = [ "-c" ''echo "" > $out'' ];
+  args = [
+    "-c"
+    ''echo "" > $out''
+  ];
 }

nix/readTree/tests/test-tree-traversal/here-arg/default.nix

@@ -1,4 +1,5 @@
-{ here, ... }: {
+{ here, ... }:
+{
   attr1 = "foo";
   attr2 = here.attr1;
 

nix/readTree/tests/test-tree-traversal/here-arg/subdir/sibl2.nix

@@ -1,2 +1 @@
-{ here, ... }:
-here.sibl1
+{ here, ... }: here.sibl1

nix/readTree/tests/test-wrong-no-dots/no-dots-in-function.nix

@@ -1,3 +1,3 @@
-{}:
+{ }:
 
 "This is a function, but readTree wants to pass a bunch of arguments, and not having dots means we depend on exactly which arguments."