Apply nixfmt on many files

modules/lib/dag.nix

@@ -13,13 +13,11 @@ with lib;
 
 rec {
 
-  emptyDag = {};
+  emptyDag = { };
 
   isDag = dag:
-    let
-      isEntry = e: (e ? data) && (e ? after) && (e ? before);
-    in
-      builtins.isAttrs dag && all (x: x) (mapAttrsToList (n: isEntry) dag);
+    let isEntry = e: (e ? data) && (e ? after) && (e ? before);
+    in builtins.isAttrs dag && all (x: x) (mapAttrsToList (n: isEntry) dag);
 
   # Takes an attribute set containing entries built by
   # dagEntryAnywhere, dagEntryAfter, and dagEntryBefore to a
@@ -80,22 +78,19 @@ rec {
   dagTopoSort = dag:
     let
       dagBefore = dag: name:
-        mapAttrsToList (n: v: n) (
-          filterAttrs (n: v: any (a: a == name) v.before) dag
-        );
-      normalizedDag =
-        mapAttrs (n: v: {
-          name = n;
-          data = v.data;
-          after = v.after ++ dagBefore dag n;
-        }) dag;
+        mapAttrsToList (n: v: n)
+        (filterAttrs (n: v: any (a: a == name) v.before) dag);
+      normalizedDag = mapAttrs (n: v: {
+        name = n;
+        data = v.data;
+        after = v.after ++ dagBefore dag n;
+      }) dag;
       before = a: b: any (c: a.name == c) b.after;
       sorted = toposort before (mapAttrsToList (n: v: v) normalizedDag);
-    in
-      if sorted ? result then
-        { result = map (v: { inherit (v) name data; }) sorted.result; }
-      else
-        sorted;
+    in if sorted ? result then {
+      result = map (v: { inherit (v) name data; }) sorted.result;
+    } else
+      sorted;
 
   # Applies a function to each element of the given DAG.
   dagMap = f: dag: mapAttrs (n: v: v // { data = f n v.data; }) dag;
@@ -103,22 +98,20 @@ rec {
   # Create a DAG entry with no particular dependency information.
   dagEntryAnywhere = data: {
     inherit data;
-    before = [];
-    after = [];
+    before = [ ];
+    after = [ ];
   };
 
-  dagEntryBetween = before: after: data: {
-    inherit data before after;
-  };
+  dagEntryBetween = before: after: data: { inherit data before after; };
 
   dagEntryAfter = after: data: {
     inherit data after;
-    before = [];
+    before = [ ];
   };
 
   dagEntryBefore = before: data: {
     inherit data before;
-    after = [];
+    after = [ ];
   };
 
 }

modules/lib/shell.nix

@@ -2,7 +2,7 @@
 
 rec {
   # Produces a Bourne shell like variable export statement.
-  export = n: v: "export ${n}=\"${toString v}\"";
+  export = n: v: ''export ${n}="${toString v}"'';
 
   # Given an attribute set containing shell variable names and their
   # assignment, this function produces a string containing an export

modules/lib/stdlib-extended.nix

@@ -3,9 +3,5 @@
 
 nixpkgsLib:
 
-let
-  mkHmLib = import ./.;
-in
-  nixpkgsLib.extend (self: super: {
-    hm = mkHmLib { lib = super; };
-  })
+let mkHmLib = import ./.;
+in nixpkgsLib.extend (self: super: { hm = mkHmLib { lib = super; }; })

modules/lib/strings.nix

@@ -9,19 +9,14 @@ with lib;
       # All characters that are considered safe. Note "-" is not
       # included to avoid "-" followed by digit being interpreted as a
       # version.
-      safeChars =
-        [ "+" "." "_" "?" "=" ]
-        ++ lowerChars
-        ++ upperChars
+      safeChars = [ "+" "." "_" "?" "=" ] ++ lowerChars ++ upperChars
         ++ stringToCharacters "0123456789";
 
       empties = l: genList (x: "") (length l);
 
-      unsafeInName = stringToCharacters (
-        replaceStrings safeChars (empties safeChars) path
-      );
+      unsafeInName =
+        stringToCharacters (replaceStrings safeChars (empties safeChars) path);
 
       safeName = replaceStrings unsafeInName (empties unsafeInName) path;
-    in
-      "hm_" + safeName;
+    in "hm_" + safeName;
 }

modules/lib/types-dag.nix

@@ -6,41 +6,34 @@ let
 
   isDagEntry = e: isAttrs e && (e ? data) && (e ? after) && (e ? before);
 
-  dagContentType = elemType: types.submodule {
-    options = {
-      data = mkOption { type = elemType; };
-      after = mkOption { type = with types; uniq (listOf str); };
-      before = mkOption { type = with types; uniq (listOf str); };
+  dagContentType = elemType:
+    types.submodule {
+      options = {
+        data = mkOption { type = elemType; };
+        after = mkOption { type = with types; uniq (listOf str); };
+        before = mkOption { type = with types; uniq (listOf str); };
+      };
     };
-  };
 
-in
-
-{
+in {
   # A directed acyclic graph of some inner type.
   dagOf = elemType:
     let
-      convertAllToDags =
-        let
-          maybeConvert = n: v:
-            if isDagEntry v
-            then v
-            else dag.entryAnywhere v;
-        in
-          map (def: def // { value = mapAttrs maybeConvert def.value; });
+      convertAllToDags = let
+        maybeConvert = n: v: if isDagEntry v then v else dag.entryAnywhere v;
+      in map (def: def // { value = mapAttrs maybeConvert def.value; });
 
       attrEquivalent = types.attrsOf (dagContentType elemType);
-    in
-      mkOptionType rec {
-        name = "dagOf";
-        description = "DAG of ${elemType.description}s";
-        check = isAttrs;
-        merge = loc: defs: attrEquivalent.merge loc (convertAllToDags defs);
-        getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["<name>"]);
-        getSubModules = elemType.getSubModules;
-        substSubModules = m: dagOf (elemType.substSubModules m);
-        functor = (defaultFunctor name) // { wrapped = elemType; };
-      };
+    in mkOptionType rec {
+      name = "dagOf";
+      description = "DAG of ${elemType.description}s";
+      check = isAttrs;
+      merge = loc: defs: attrEquivalent.merge loc (convertAllToDags defs);
+      getSubOptions = prefix: elemType.getSubOptions (prefix ++ [ "<name>" ]);
+      getSubModules = elemType.getSubModules;
+      substSubModules = m: dagOf (elemType.substSubModules m);
+      functor = (defaultFunctor name) // { wrapped = elemType; };
+    };
 
   # A directed acyclic graph of some inner type OR a list of that
   # inner type. This is a temporary hack for use by the
@@ -55,42 +48,37 @@ in
   listOrDagOf = elemType:
     let
       paddedIndexStr = list: i:
-        let
-          padWidth = stringLength (toString (length list));
-        in
-          fixedWidthNumber padWidth i;
+        let padWidth = stringLength (toString (length list));
+        in fixedWidthNumber padWidth i;
 
       convertAllToDags = defs:
         let
           convertAttrValue = n: v:
-            if isDagEntry v then v
-            else dag.entryAnywhere v;
+            if isDagEntry v then v else dag.entryAnywhere v;
 
           convertListValue = namePrefix: vs:
             let
               pad = paddedIndexStr vs;
               makeEntry = i: v:
                 nameValuePair "${namePrefix}.${pad i}" (dag.entryAnywhere v);
-            in
-              listToAttrs (imap1 makeEntry vs);
+            in listToAttrs (imap1 makeEntry vs);
 
           convertValue = i: value:
-            if isList value
-            then convertListValue "unnamed-${paddedIndexStr defs i}" value
-            else mapAttrs convertAttrValue value;
-        in
-          imap1 (i: def: def // { value = convertValue i def.value; }) defs;
+            if isList value then
+              convertListValue "unnamed-${paddedIndexStr defs i}" value
+            else
+              mapAttrs convertAttrValue value;
+        in imap1 (i: def: def // { value = convertValue i def.value; }) defs;
 
       attrEquivalent = types.attrsOf (dagContentType elemType);
-    in
-      mkOptionType rec {
-        name = "dagOf";
-        description = "DAG of ${elemType.description}s";
-        check = x: isAttrs x || isList x;
-        merge = loc: defs: attrEquivalent.merge loc (convertAllToDags defs);
-        getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["<name>"]);
-        getSubModules = elemType.getSubModules;
-        substSubModules = m: dagOf (elemType.substSubModules m);
-        functor = (defaultFunctor name) // { wrapped = elemType; };
-      };
+    in mkOptionType rec {
+      name = "dagOf";
+      description = "DAG of ${elemType.description}s";
+      check = x: isAttrs x || isList x;
+      merge = loc: defs: attrEquivalent.merge loc (convertAllToDags defs);
+      getSubOptions = prefix: elemType.getSubOptions (prefix ++ [ "<name>" ]);
+      getSubModules = elemType.getSubModules;
+      substSubModules = m: dagOf (elemType.substSubModules m);
+      functor = (defaultFunctor name) // { wrapped = elemType; };
+    };
 }

modules/lib/zsh.nix

@@ -2,13 +2,15 @@
 
 rec {
   # Produces a Zsh shell like value
-  toZshValue = v: if builtins.isBool v then
-                    if v then "true" else "false"
-                  else if builtins.isString v then
-                    "\"${v}\""
-                  else if builtins.isList v then
-                    "(${lib.concatStringsSep " " (map toZshValue v)})"
-                  else "\"${toString v}\"";
+  toZshValue = v:
+    if builtins.isBool v then
+      if v then "true" else "false"
+    else if builtins.isString v then
+      ''"${v}"''
+    else if builtins.isList v then
+      "(${lib.concatStringsSep " " (map toZshValue v)})"
+    else
+      ''"${toString v}"'';
 
   # Produces a Zsh shell like definition statement
   define = n: v: "${n}=${toZshValue v}";