commit 228df50ff927e3b715ebfb54992432c4a91bd847 · pyrox.dev/nixpkgs

-1

doc/functions.md

···

       8
       8
        
       functions/debug.section.md

     

       9
       9
        
       functions/prefer-remote-fetch.section.md

     

       10
       10
        
       functions/nix-gitignore.section.md

     

       11
       11
       -
       functions/fileset.section.md

     

       12
       11
        
       ```

-48

doc/functions/fileset.section.md

···

       1
       1
       -
       <!-- TODO: Render this document in front of function documentation in case https://github.com/nix-community/nixdoc/issues/19 is ever supported -->

     

       2
       2
       -
       

     

       3
       3
       -
       # File sets {#sec-fileset}

     

       4
       4
       -
       

     

       5
       5
       -
       The [`lib.fileset`](#sec-functions-library-fileset) library allows you to work with _file sets_.

     

       6
       6
       -
       A file set is a mathematical set of local files that can be added to the Nix store for use in Nix derivations.

     

       7
       7
       -
       File sets are easy and safe to use, providing obvious and composable semantics with good error messages to prevent mistakes.

     

       8
       8
       -
       

     

       9
       9
       -
       See the [function reference](#sec-functions-library-fileset) for function-specific documentation.

     

       10
       10
       -
       

     

       11
       11
       -
       ## Implicit coercion from paths to file sets {#sec-fileset-path-coercion}

     

       12
       12
       -
       

     

       13
       13
       -
       All functions accepting file sets as arguments can also accept [paths](https://nixos.org/manual/nix/stable/language/values.html#type-path) as arguments.

     

       14
       14
       -
       Such path arguments are implicitly coerced to file sets containing all files under that path:

     

       15
       15
       -
       - A path to a file turns into a file set containing that single file.

     

       16
       16
       -
       - A path to a directory turns into a file set containing all files _recursively_ in that directory.

     

       17
       17
       -
       

     

       18
       18
       -
       If the path points to a non-existent location, an error is thrown.

     

       19
       19
       -
       

     

       20
       20
       -
       ::: {.note}

     

       21
       21
       -
       Just like in Git, file sets cannot represent empty directories.

     

       22
       22
       -
       Because of this, a path to a directory that contains no files (recursively) will turn into a file set containing no files.

     

       23
       23
       -
       :::

     

       24
       24
       -
       

     

       25
       25
       -
       :::{.note}

     

       26
       26
       -
       File set coercion does _not_ add any of the files under the coerced paths to the store.

     

       27
       27
       -
       Only the [`toSource`](#function-library-lib.fileset.toSource) function adds files to the Nix store, and only those files contained in the `fileset` argument.

     

       28
       28
       -
       This is in contrast to using [paths in string interpolation](https://nixos.org/manual/nix/stable/language/values.html#type-path), which does add the entire referenced path to the store.

     

       29
       29
       -
       :::

     

       30
       30
       -
       

     

       31
       31
       -
       ### Example {#sec-fileset-path-coercion-example}

     

       32
       32
       -
       

     

       33
       33
       -
       Assume we are in a local directory with a file hierarchy like this:

     

       34
       34
       -
       ```

     

       35
       35
       -
       ├─ a/

     

       36
       36
       -
       │  ├─ x (file)

     

       37
       37
       -
       │  └─ b/

     

       38
       38
       -
       │     └─ y (file)

     

       39
       39
       -
       └─ c/

     

       40
       40
       -
          └─ d/

     

       41
       41
       -
       ```

     

       42
       42
       -
       

     

       43
       43
       -
       Here's a listing of which files get included when different path expressions get coerced to file sets:

     

       44
       44
       -
       - `./.` as a file set contains both `a/x` and `a/b/y` (`c/` does not contain any files and is therefore omitted).

     

       45
       45
       -
       - `./a` as a file set contains both `a/x` and `a/b/y`.

     

       46
       46
       -
       - `./a/x` as a file set contains only `a/x`.

     

       47
       47
       -
       - `./a/b` as a file set contains only `a/b/y`.

     

       48
       48
       -
       - `./c` as a file set is empty, since neither `c` nor `c/d` contain any files.

+49

lib/fileset/default.nix

···

       1
       1
       +
       /*

     

       2
       2
       +
         <!-- This anchor is here for backwards compatibity -->

     

       3
       3
       +
         []{#sec-fileset}

     

       4
       4
       +
       

     

       5
       5
       +
         The [`lib.fileset`](#sec-functions-library-fileset) library allows you to work with _file sets_.

     

       6
       6
       +
         A file set is a mathematical set of local files that can be added to the Nix store for use in Nix derivations.

     

       7
       7
       +
         File sets are easy and safe to use, providing obvious and composable semantics with good error messages to prevent mistakes.

     

       8
       8
       +
       

     

       9
       9
       +
         See the [function reference](#sec-functions-library-fileset) for function-specific documentation.

     

       10
       10
       +
       

     

       11
       11
       +
         ## Implicit coercion from paths to file sets {#sec-fileset-path-coercion}

     

       12
       12
       +
       

     

       13
       13
       +
         All functions accepting file sets as arguments can also accept [paths](https://nixos.org/manual/nix/stable/language/values.html#type-path) as arguments.

     

       14
       14
       +
         Such path arguments are implicitly coerced to file sets containing all files under that path:

     

       15
       15
       +
         - A path to a file turns into a file set containing that single file.

     

       16
       16
       +
         - A path to a directory turns into a file set containing all files _recursively_ in that directory.

     

       17
       17
       +
       

     

       18
       18
       +
         If the path points to a non-existent location, an error is thrown.

     

       19
       19
       +
       

     

       20
       20
       +
         ::: {.note}

     

       21
       21
       +
         Just like in Git, file sets cannot represent empty directories.

     

       22
       22
       +
         Because of this, a path to a directory that contains no files (recursively) will turn into a file set containing no files.

     

       23
       23
       +
         :::

     

       24
       24
       +
       

     

       25
       25
       +
         :::{.note}

     

       26
       26
       +
         File set coercion does _not_ add any of the files under the coerced paths to the store.

     

       27
       27
       +
         Only the [`toSource`](#function-library-lib.fileset.toSource) function adds files to the Nix store, and only those files contained in the `fileset` argument.

     

       28
       28
       +
         This is in contrast to using [paths in string interpolation](https://nixos.org/manual/nix/stable/language/values.html#type-path), which does add the entire referenced path to the store.

     

       29
       29
       +
         :::

     

       30
       30
       +
       

     

       31
       31
       +
         ### Example {#sec-fileset-path-coercion-example}

     

       32
       32
       +
       

     

       33
       33
       +
         Assume we are in a local directory with a file hierarchy like this:

     

       34
       34
       +
         ```

     

       35
       35
       +
         ├─ a/

     

       36
       36
       +
         │  ├─ x (file)

     

       37
       37
       +
         │  └─ b/

     

       38
       38
       +
         │     └─ y (file)

     

       39
       39
       +
         └─ c/

     

       40
       40
       +
            └─ d/

     

       41
       41
       +
         ```

     

       42
       42
       +
       

     

       43
       43
       +
         Here's a listing of which files get included when different path expressions get coerced to file sets:

     

       44
       44
       +
         - `./.` as a file set contains both `a/x` and `a/b/y` (`c/` does not contain any files and is therefore omitted).

     

       45
       45
       +
         - `./a` as a file set contains both `a/x` and `a/b/y`.

     

       46
       46
       +
         - `./a/x` as a file set contains only `a/x`.

     

       47
       47
       +
         - `./a/b` as a file set contains only `a/b/y`.

     

       48
       48
       +
         - `./c` as a file set is empty, since neither `c` nor `c/d` contain any files.

     

       49
       49
       +
       */

     

       1
       50
        
       { lib }:

     

       2
       51
        
       let

     

       3
       52