diff options
Diffstat (limited to 'nix/utils')
-rw-r--r-- | nix/utils/default.nix | 39 | ||||
-rw-r--r-- | nix/utils/tests/default.nix | 54 |
2 files changed, 58 insertions, 35 deletions
diff --git a/nix/utils/default.nix b/nix/utils/default.nix index 258e372a2a2d..cabea5bbeeb3 100644 --- a/nix/utils/default.nix +++ b/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 diff --git a/nix/utils/tests/default.nix b/nix/utils/tests/default.nix index 8a078684f3aa..52b7ca41d215 100644 --- a/nix/utils/tests/default.nix +++ b/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 |