lib.filesystem: filesystem functions

Functions for querying information about the filesystem without copying any files to the Nix store.

lib.filesystem.pathType

The type of a path. The path needs to exist and be accessible. The result is either "directory" for a directory, "regular" for a regular file, "symlink" for a symlink, or "unknown" for anything else.

Inputs

path

: The path to query

Type

pathType :: Path -> String

Examples

lib.filesystem.pathType usage example

pathType /.
=> "directory"

pathType /some/file.nix
=> "regular"

Located at lib/filesystem.nix:62 in <nixpkgs>.

lib.filesystem.pathIsDirectory

Whether a path exists and is a directory.

Inputs

path

: 1. Function argument

Type

pathIsDirectory :: Path -> Bool

Examples

lib.filesystem.pathIsDirectory usage example

pathIsDirectory /.
=> true

pathIsDirectory /this/does/not/exist
=> false

pathIsDirectory /some/file.nix
=> false

Located at lib/filesystem.nix:111 in <nixpkgs>.

lib.filesystem.pathIsRegularFile

Whether a path exists and is a regular file, meaning not a symlink or any other special file type.

Inputs

path

: 1. Function argument

Type

pathIsRegularFile :: Path -> Bool

Examples

lib.filesystem.pathIsRegularFile usage example

pathIsRegularFile /.
=> false

pathIsRegularFile /this/does/not/exist
=> false

pathIsRegularFile /some/file.nix
=> true

Located at lib/filesystem.nix:147 in <nixpkgs>.

lib.filesystem.haskellPathsInDir

A map of all haskell packages defined in the given path, identified by having a cabal file with the same name as the directory itself.

Inputs

root

: The directory within to search

Type

Path -> Map String Path

Located at lib/filesystem.nix:168 in <nixpkgs>.

lib.filesystem.locateDominatingFile

Find the first directory containing a file matching 'pattern' upward from a given 'file'. Returns 'null' if no directories contain a file matching 'pattern'.

Inputs

pattern

: The pattern to search for

file

: The file to start searching upward from

Type

RegExp -> Path -> Nullable { path : Path; matches : [ MatchResults ]; }

Located at lib/filesystem.nix:205 in <nixpkgs>.

lib.filesystem.listFilesRecursive

Given a directory, return a flattened list of all files within it recursively.

Inputs

dir

: The path to recursively list

Type

Path -> [ Path ]

Located at lib/filesystem.nix:242 in <nixpkgs>.

lib.filesystem.packagesFromDirectoryRecursive

Transform a directory tree containing package files suitable for callPackage into a matching nested attribute set of derivations.

For a directory tree like this:

my-packages
├── a.nix
├── b.nix
├── c
│  ├── my-extra-feature.patch
│  ├── package.nix
│  └── support-definitions.nix
└── my-namespace
   ├── d.nix
   ├── e.nix
   └── f
      └── package.nix

packagesFromDirectoryRecursive will produce an attribute set like this:

# packagesFromDirectoryRecursive {
#   callPackage = pkgs.callPackage;
#   directory = ./my-packages;
# }
{
  a = pkgs.callPackage ./my-packages/a.nix { };
  b = pkgs.callPackage ./my-packages/b.nix { };
  c = pkgs.callPackage ./my-packages/c/package.nix { };
  my-namespace = {
    d = pkgs.callPackage ./my-packages/my-namespace/d.nix { };
    e = pkgs.callPackage ./my-packages/my-namespace/e.nix { };
    f = pkgs.callPackage ./my-packages/my-namespace/f/package.nix { };
  };
}

In particular: - If the input directory contains a package.nix file, then callPackage <directory>/package.nix { } is returned. - Otherwise, the input directory's contents are listed and transformed into an attribute set. - If a file name has the .nix extension, it is turned into attribute where: - The attribute name is the file name without the .nix extension - The attribute value is callPackage <file path> { } - Other files are ignored. - Directories are turned into an attribute where: - The attribute name is the name of the directory - The attribute value is the result of calling packagesFromDirectoryRecursive { ... } on the directory.

As a result, directories with no `.nix` files (including empty
directories) will be transformed into empty attribute sets.

Inputs

Structured function argument

: Attribute set containing the following attributes. Additional attributes are ignored.

callPackage

: pkgs.callPackage

Type: `Path -> AttrSet -> a`

directory

: The directory to read package files from

Type: `Path`

Type

packagesFromDirectoryRecursive :: AttrSet -> AttrSet

Examples

lib.filesystem.packagesFromDirectoryRecursive usage example

packagesFromDirectoryRecursive {
  inherit (pkgs) callPackage;
  directory = ./my-packages;
}
=> { ... }

lib.makeScope pkgs.newScope (
  self: packagesFromDirectoryRecursive {
    callPackage = self.callPackage;
    directory = ./my-packages;
  }
)
=> { ... }

Located at lib/filesystem.nix:357 in <nixpkgs>.