style: format entire depot with nixpkgs-fmt

This CL can be used to compare the style of nixpkgs-fmt against other
formatters (nixpkgs, alejandra).

Change-Id: I87c6abff6bcb546b02ead15ad0405f81e01b6d9e
Reviewed-on: https://cl.tvl.fyi/c/depot/+/4397
Tested-by: BuildkiteCI
Reviewed-by: sterni <sternenseemann@systemli.org>
Reviewed-by: lukegb <lukegb@tvl.fyi>
Reviewed-by: wpcarro <wpcarro@gmail.com>
Reviewed-by: Profpatsch <mail@profpatsch.de>
Reviewed-by: kanepyork <rikingcoding@gmail.com>
Reviewed-by: tazjin <tazjin@tvl.su>
Reviewed-by: cynthia <cynthia@tvl.fyi>
Reviewed-by: edef <edef@edef.eu>
Reviewed-by: eta <tvl@eta.st>
Reviewed-by: grfn <grfn@gws.fyi>

nix/utils/default.nix

@@ -34,14 +34,14 @@ let
         basename = builtins.unsafeDiscardStringContext
           (builtins.baseNameOf strPath);
       in
-        # If p is a direct child of storeDir, we need to remove
+      # If p is a direct child of storeDir, we need to remove
         # the leading hash as well to make sure that:
         # `storePathName drv == storePathName (toString drv)`.
-        if noStoreDir == basename
-        then builtins.substring 33 (-1) basename
-        else basename
+      if noStoreDir == basename
+      then builtins.substring 33 (-1) basename
+      else basename
     else builtins.throw "Don't know how to get (base)name of "
-      + lib.generators.toPretty {} p;
+      + lib.generators.toPretty { } p;
 
   /* Query the type of a path exposing the same information as would be by
      `builtins.readDir`, but for a single, specific target path.
@@ -106,7 +106,7 @@ let
       # We need to call toString to prevent unsafeDiscardStringContext
       # from importing a path into store which messes with base- and
       # dirname of course.
-      path'= builtins.unsafeDiscardStringContext (toString path);
+      path' = builtins.unsafeDiscardStringContext (toString path);
       # To read the containing directory we absolutely need
       # to keep the string context, otherwise a derivation
       # would not be realized before our check (at eval time)
@@ -120,20 +120,22 @@ let
       # directory. If not, either the target doesn't exist or is a regular file.
       # TODO(sterni): is there a way to check reliably if the symlink target exists?
       isSymlinkDir = builtins.pathExists (path' + "/.");
-    in {
+    in
+    {
       ${thisPathType} =
-        /**/ if thisPathType != "symlink" then true
-        else if isSymlinkDir              then "directory"
-        else                                   "regular-or-missing";
+        /**/
+        if thisPathType != "symlink" then true
+        else if isSymlinkDir then "directory"
+        else "regular-or-missing";
     };
 
   pathType' = path:
     let
       p = pathType path;
     in
-      if p ? missing
-      then builtins.throw "${lib.generators.toPretty {} path} does not exist"
-      else p;
+    if p ? missing
+    then builtins.throw "${lib.generators.toPretty {} path} does not exist"
+    else p;
 
   /* Check whether the given path is a directory.
      Throws if the path in question doesn't exist.
@@ -151,9 +153,11 @@ let
 
      Type: path(-like) -> bool
   */
-  realPathIsDirectory = path: let
-    pt = pathType' path;
-  in pt ? directory || pt.symlink or null == "directory";
+  realPathIsDirectory = path:
+    let
+      pt = pathType' path;
+    in
+    pt ? directory || pt.symlink or null == "directory";
 
   /* Check whether the given path is a regular file.
      Throws if the path in question doesn't exist.
@@ -169,7 +173,8 @@ let
   */
   isSymlink = path: pathType' path ? symlink;
 
-in {
+in
+{
   inherit
     storePathName
     pathType

nix/utils/tests/default.nix

@@ -26,38 +26,53 @@ let
   pathPredicates = it "judges paths correctly" (lib.flatten [
     # isDirectory
     (assertUtilsPred "directory isDirectory"
-      (isDirectory ./directory) true)
+      (isDirectory ./directory)
+      true)
     (assertUtilsPred "symlink not isDirectory"
-      (isDirectory ./symlink-directory) false)
+      (isDirectory ./symlink-directory)
+      false)
     (assertUtilsPred "file not isDirectory"
-      (isDirectory ./directory/file) false)
+      (isDirectory ./directory/file)
+      false)
     # realPathIsDirectory
     (assertUtilsPred "directory realPathIsDirectory"
-      (realPathIsDirectory ./directory) true)
+      (realPathIsDirectory ./directory)
+      true)
     (assertUtilsPred "symlink to directory realPathIsDirectory"
-      (realPathIsDirectory ./symlink-directory) true)
+      (realPathIsDirectory ./symlink-directory)
+      true)
     (assertUtilsPred "realPathIsDirectory resolves chained symlinks"
-      (realPathIsDirectory ./symlink-symlink-directory) true)
+      (realPathIsDirectory ./symlink-symlink-directory)
+      true)
     # isRegularFile
     (assertUtilsPred "file isRegularFile"
-      (isRegularFile ./directory/file) true)
+      (isRegularFile ./directory/file)
+      true)
     (assertUtilsPred "symlink not isRegularFile"
-      (isRegularFile ./symlink-file) false)
+      (isRegularFile ./symlink-file)
+      false)
     (assertUtilsPred "directory not isRegularFile"
-      (isRegularFile ./directory) false)
+      (isRegularFile ./directory)
+      false)
     # isSymlink
     (assertUtilsPred "symlink to file isSymlink"
-      (isSymlink ./symlink-file) true)
+      (isSymlink ./symlink-file)
+      true)
     (assertUtilsPred "symlink to directory isSymlink"
-      (isSymlink ./symlink-directory) true)
+      (isSymlink ./symlink-directory)
+      true)
     (assertUtilsPred "symlink to symlink isSymlink"
-      (isSymlink ./symlink-symlink-file) true)
+      (isSymlink ./symlink-symlink-file)
+      true)
     (assertUtilsPred "symlink to missing file isSymlink"
-      (isSymlink ./missing) true)
+      (isSymlink ./missing)
+      true)
     (assertUtilsPred "directory not isSymlink"
-      (isSymlink ./directory) false)
+      (isSymlink ./directory)
+      false)
     (assertUtilsPred "file not isSymlink"
-      (isSymlink ./directory/file) false)
+      (isSymlink ./directory/file)
+      false)
     # missing files throw
     (assertThrows "isDirectory throws on missing file"
       (isDirectory ./does-not-exist))
@@ -89,15 +104,18 @@ let
 
   storePathNameTests = it "correctly gets the basename of a store path" [
     (assertEq "base name of a derivation"
-      (storePathName depot.tools.cheddar) depot.tools.cheddar.name)
+      (storePathName depot.tools.cheddar)
+      depot.tools.cheddar.name)
     (assertEq "base name of a store path string"
-      (storePathName cheddarStorePath) depot.tools.cheddar.name)
+      (storePathName cheddarStorePath)
+      depot.tools.cheddar.name)
     (assertEq "base name of a path within a store path"
       (storePathName "${cheddarStorePath}/bin/cheddar") "cheddar")
     (assertEq "base name of a path"
       (storePathName ../default.nix) "default.nix")
     (assertEq "base name of a cleanSourced path"
-      (storePathName cleanedSource) cleanedSource.name)
+      (storePathName cleanedSource)
+      cleanedSource.name)
   ];
 in