Something went wrong. Try again.
What happens if I push all of nixpkgs
Something went wrong. Try again.
Nix
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016/** <!-- This anchor is here for backwards compatibility --> []{#sec-fileset}
The [`lib.fileset`](#sec-functions-library-fileset) library allows you to work with _file sets_. A file set is a (mathematical) set of local files that can be added to the Nix store for use in Nix derivations. File sets are easy and safe to use, providing obvious and composable semantics with good error messages to prevent mistakes.
# Overview {#sec-fileset-overview}
Basics: - [Implicit coercion from paths to file sets](#sec-fileset-path-coercion)
- [`lib.fileset.maybeMissing`](#function-library-lib.fileset.maybeMissing):
Create a file set from a path that may be missing.
- [`lib.fileset.trace`](#function-library-lib.fileset.trace)/[`lib.fileset.traceVal`](#function-library-lib.fileset.trace):
Pretty-print file sets for debugging.
- [`lib.fileset.toSource`](#function-library-lib.fileset.toSource):
Add files in file sets to the store to use as derivation sources.
- [`lib.fileset.toList`](#function-library-lib.fileset.toList):
The list of files contained in a file set.
Combinators: - [`lib.fileset.union`](#function-library-lib.fileset.union)/[`lib.fileset.unions`](#function-library-lib.fileset.unions):
Create a larger file set from all the files in multiple file sets.
- [`lib.fileset.intersection`](#function-library-lib.fileset.intersection):
Create a smaller file set from only the files in both file sets.
- [`lib.fileset.difference`](#function-library-lib.fileset.difference):
Create a smaller file set containing all files that are in one file set, but not another one.
Filtering: - [`lib.fileset.fileFilter`](#function-library-lib.fileset.fileFilter):
Create a file set from all files that satisisfy a predicate in a directory.
Utilities: - [`lib.fileset.fromSource`](#function-library-lib.fileset.fromSource):
Create a file set from a `lib.sources`-based value.
- [`lib.fileset.gitTracked`](#function-library-lib.fileset.gitTracked)/[`lib.fileset.gitTrackedWith`](#function-library-lib.fileset.gitTrackedWith):
Create a file set from all tracked files in a local Git repository.
If you need more file set functions, see [this issue](https://github.com/NixOS/nixpkgs/issues/266356) to request it.
# Implicit coercion from paths to file sets {#sec-fileset-path-coercion}
All functions accepting file sets as arguments can also accept [paths](https://nixos.org/manual/nix/stable/language/values.html#type-path) as arguments. Such path arguments are implicitly coerced to file sets containing all files under that path: - A path to a file turns into a file set containing that single file. - A path to a directory turns into a file set containing all files _recursively_ in that directory.
If the path points to a non-existent location, an error is thrown.
::: {.note} Just like in Git, file sets cannot represent empty directories. Because of this, a path to a directory that contains no files (recursively) will turn into a file set containing no files. :::
:::{.note} File set coercion does _not_ add any of the files under the coerced paths to the store. Only the [`toSource`](#function-library-lib.fileset.toSource) function adds files to the Nix store, and only those files contained in the `fileset` argument. 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. :::
## Example {#sec-fileset-path-coercion-example}
Assume we are in a local directory with a file hierarchy like this: ``` ├─ a/ │ ├─ x (file) │ └─ b/ │ └─ y (file) └─ c/ └─ d/ ```
Here's a listing of which files get included when different path expressions get coerced to file sets: - `./.` as a file set contains both `a/x` and `a/b/y` (`c/` does not contain any files and is therefore omitted). - `./a` as a file set contains both `a/x` and `a/b/y`. - `./a/x` as a file set contains only `a/x`. - `./a/b` as a file set contains only `a/b/y`. - `./c` as a file set is empty, since neither `c` nor `c/d` contain any files.*/{ lib }:let
inherit (import ./internal.nix { inherit lib; }) _coerce _singleton _coerceMany _toSourceFilter _fromSourceFilter _toList _unionMany _fileFilter _printFileset _intersection _difference _fromFetchGit _fetchGitSubmodulesMinver _emptyWithoutBase ;
inherit (builtins) isBool isList isPath pathExists seq typeOf nixVersion ;
inherit (lib.lists) elemAt imap0 ;
inherit (lib.path) hasPrefix splitRoot ;
inherit (lib.strings) isStringLike versionOlder ;
inherit (lib.filesystem) pathType ;
inherit (lib.sources) cleanSourceWith ;
inherit (lib.trivial) isFunction pipe ;
in{
/** Create a file set from a path that may or may not exist: - If the path does exist, the path is [coerced to a file set](#sec-fileset-path-coercion). - If the path does not exist, a file set containing no files is returned.
# Inputs
`path`
: 1\. Function argument
# Type
``` maybeMissing :: Path -> FileSet ```
# Examples :::{.example} ## `lib.fileset.maybeMissing` usage example
```nix # All files in the current directory, but excluding main.o if it exists difference ./. (maybeMissing ./main.o) ```
::: */ maybeMissing = path: if !isPath path then if isStringLike path then throw ''lib.fileset.maybeMissing: Argument ("${toString path}") is a string-like value, but it should be a path instead.'' else throw ''lib.fileset.maybeMissing: Argument is of type ${typeOf path}, but it should be a path instead.'' else if !pathExists path then _emptyWithoutBase else _singleton path;
/** Incrementally evaluate and trace a file set in a pretty way. This function is only intended for debugging purposes. The exact tracing format is unspecified and may change.
This function takes a final argument to return. In comparison, [`traceVal`](#function-library-lib.fileset.traceVal) returns the given file set argument.
This variant is useful for tracing file sets in the Nix repl.
# Inputs
`fileset`
: The file set to trace.
This argument can also be a path, which gets [implicitly coerced to a file set](#sec-fileset-path-coercion).
`val`
: The value to return.
# Type
``` trace :: FileSet -> Any -> Any ```
# Examples :::{.example} ## `lib.fileset.trace` usage example
```nix trace (unions [ ./Makefile ./src ./tests/run.sh ]) null => trace: /home/user/src/myProject trace: - Makefile (regular) trace: - src (all files in directory) trace: - tests trace: - run.sh (regular) null ```
::: */ trace = fileset: let # "fileset" would be a better name, but that would clash with the argument name, # and we cannot change that because of https://github.com/nix-community/nixdoc/issues/76 actualFileset = _coerce "lib.fileset.trace: Argument" fileset; in seq (_printFileset actualFileset) (x: x);
/** Incrementally evaluate and trace a file set in a pretty way. This function is only intended for debugging purposes. The exact tracing format is unspecified and may change.
This function returns the given file set. In comparison, [`trace`](#function-library-lib.fileset.trace) takes another argument to return.
This variant is useful for tracing file sets passed as arguments to other functions.
# Inputs
`fileset`
: The file set to trace and return.
This argument can also be a path, which gets [implicitly coerced to a file set](#sec-fileset-path-coercion).
# Type
``` traceVal :: FileSet -> FileSet ```
# Examples :::{.example} ## `lib.fileset.traceVal` usage example
```nix toSource { root = ./.; fileset = traceVal (unions [ ./Makefile ./src ./tests/run.sh ]); } => trace: /home/user/src/myProject trace: - Makefile (regular) trace: - src (all files in directory) trace: - tests trace: - run.sh (regular) "/nix/store/...-source" ```
::: */ traceVal = fileset: let # "fileset" would be a better name, but that would clash with the argument name, # and we cannot change that because of https://github.com/nix-community/nixdoc/issues/76 actualFileset = _coerce "lib.fileset.traceVal: Argument" fileset; in seq (_printFileset actualFileset) # We could also return the original fileset argument here, # but that would then duplicate work for consumers of the fileset, because then they have to coerce it again actualFileset;
/** Add the local files contained in `fileset` to the store as a single [store path](https://nixos.org/manual/nix/stable/glossary#gloss-store-path) rooted at `root`.
The result is the store path as a string-like value, making it usable e.g. as the `src` of a derivation, or in string interpolation: ```nix stdenv.mkDerivation { src = lib.fileset.toSource { ... }; # ... } ```
The name of the store path is always `source`.
# Inputs
Takes an attribute set with the following attributes
`root` (Path; _required_)
: The local directory [path](https://nixos.org/manual/nix/stable/language/values.html#type-path) that will correspond to the root of the resulting store path. Paths in [strings](https://nixos.org/manual/nix/stable/language/values.html#type-string), including Nix store paths, cannot be passed as `root`. `root` has to be a directory.
:::{.note} Changing `root` only affects the directory structure of the resulting store path, it does not change which files are added to the store. The only way to change which files get added to the store is by changing the `fileset` attribute. :::
`fileset` (FileSet; _required_)
: The file set whose files to import into the store. File sets can be created using other functions in this library. This argument can also be a path, which gets [implicitly coerced to a file set](#sec-fileset-path-coercion).
:::{.note} If a directory does not recursively contain any file, it is omitted from the store path contents. :::
# Type
``` toSource :: { root :: Path, fileset :: FileSet, } -> SourceLike ```
# Examples :::{.example} ## `lib.fileset.toSource` usage example
```nix # Import the current directory into the store # but only include files under ./src toSource { root = ./.; fileset = ./src; } => "/nix/store/...-source"
# Import the current directory into the store # but only include ./Makefile and all files under ./src toSource { root = ./.; fileset = union ./Makefile ./src; } => "/nix/store/...-source"
# Trying to include a file outside the root will fail toSource { root = ./.; fileset = unions [ ./Makefile ./src ../LICENSE ]; } => <error>
# The root needs to point to a directory that contains all the files toSource { root = ../.; fileset = unions [ ./Makefile ./src ../LICENSE ]; } => "/nix/store/...-source"
# The root has to be a local filesystem path toSource { root = "/nix/store/...-source"; fileset = ./.; } => <error> ```
::: */ toSource = { root, fileset, }: let # We cannot rename matched attribute arguments, so let's work around it with an extra `let in` statement filesetArg = fileset; in let fileset = _coerce "lib.fileset.toSource: `fileset`" filesetArg; rootFilesystemRoot = (splitRoot root).root; filesetFilesystemRoot = (splitRoot fileset._internalBase).root; sourceFilter = _toSourceFilter fileset; in if !isPath root then if root ? _isLibCleanSourceWith then throw '' lib.fileset.toSource: `root` is a `lib.sources`-based value, but it should be a path instead. To use a `lib.sources`-based value, convert it to a file set using `lib.fileset.fromSource` and pass it as `fileset`. Note that this only works for sources created from paths.'' else if isStringLike root then throw '' lib.fileset.toSource: `root` (${toString root}) is a string-like value, but it should be a path instead. Paths in strings are not supported by `lib.fileset`, use `lib.sources` or derivations instead.'' else throw ''lib.fileset.toSource: `root` is of type ${typeOf root}, but it should be a path instead.'' # Currently all Nix paths have the same filesystem root, but this could change in the future. # See also ../path/README.md else if !fileset._internalIsEmptyWithoutBase && rootFilesystemRoot != filesetFilesystemRoot then throw '' lib.fileset.toSource: Filesystem roots are not the same for `fileset` and `root` (${toString root}): `root`: Filesystem root is "${toString rootFilesystemRoot}" `fileset`: Filesystem root is "${toString filesetFilesystemRoot}" Different filesystem roots are not supported.'' else if !pathExists root then throw ''lib.fileset.toSource: `root` (${toString root}) is a path that does not exist.'' else if pathType root != "directory" then throw '' lib.fileset.toSource: `root` (${toString root}) is a file, but it should be a directory instead. Potential solutions: - If you want to import the file into the store _without_ a containing directory, use string interpolation or `builtins.path` instead of this function. - If you want to import the file into the store _with_ a containing directory, set `root` to the containing directory, such as ${toString (dirOf root)}, and set `fileset` to the file path.'' else if !fileset._internalIsEmptyWithoutBase && !hasPrefix root fileset._internalBase then throw '' lib.fileset.toSource: `fileset` could contain files in ${toString fileset._internalBase}, which is not under the `root` (${toString root}). Potential solutions: - Set `root` to ${toString fileset._internalBase} or any directory higher up. This changes the layout of the resulting store path. - Set `fileset` to a file set that cannot contain files outside the `root` (${toString root}). This could change the files included in the result.'' else seq sourceFilter cleanSourceWith { name = "source"; src = root; filter = sourceFilter; };
/** The list of file paths contained in the given file set.
:::{.note} This function is strict in the entire file set. This is in contrast with combinators [`lib.fileset.union`](#function-library-lib.fileset.union), [`lib.fileset.intersection`](#function-library-lib.fileset.intersection) and [`lib.fileset.difference`](#function-library-lib.fileset.difference).
Thus it is recommended to call `toList` on file sets created using the combinators, instead of doing list processing on the result of `toList`. :::
The resulting list of files can be turned back into a file set using [`lib.fileset.unions`](#function-library-lib.fileset.unions).
# Inputs
`fileset`
: The file set whose file paths to return. This argument can also be a path, which gets [implicitly coerced to a file set](#sec-fileset-path-coercion).
# Type
``` toList :: FileSet -> [ Path ] ```
# Examples :::{.example} ## `lib.fileset.toList` usage example
```nix toList ./. [ ./README.md ./Makefile ./src/main.c ./src/main.h ]
toList (difference ./. ./src) [ ./README.md ./Makefile ] ```
::: */ toList = fileset: _toList (_coerce "lib.fileset.toList: Argument" fileset);
/** The file set containing all files that are in either of two given file sets. This is the same as [`unions`](#function-library-lib.fileset.unions), but takes just two file sets instead of a list. See also [Union (set theory)](https://en.wikipedia.org/wiki/Union_(set_theory)).
The given file sets are evaluated as lazily as possible, with the first argument being evaluated first if needed.
# Inputs
`fileset1`
: The first file set. This argument can also be a path, which gets [implicitly coerced to a file set](#sec-fileset-path-coercion).
`fileset2`
: The second file set. This argument can also be a path, which gets [implicitly coerced to a file set](#sec-fileset-path-coercion).
# Type
``` union :: FileSet -> FileSet -> FileSet ```
# Examples :::{.example} ## `lib.fileset.union` usage example
```nix # Create a file set containing the file `Makefile` # and all files recursively in the `src` directory union ./Makefile ./src
# Create a file set containing the file `Makefile` # and the LICENSE file from the parent directory union ./Makefile ../LICENSE ```
::: */ union = fileset1: fileset2: _unionMany ( _coerceMany "lib.fileset.union" [ { context = "First argument"; value = fileset1; } { context = "Second argument"; value = fileset2; } ] );
/** The file set containing all files that are in any of the given file sets. This is the same as [`union`](#function-library-lib.fileset.unions), but takes a list of file sets instead of just two. See also [Union (set theory)](https://en.wikipedia.org/wiki/Union_(set_theory)).
The given file sets are evaluated as lazily as possible, with earlier elements being evaluated first if needed.
# Inputs
`filesets`
: A list of file sets. The elements can also be paths, which get [implicitly coerced to file sets](#sec-fileset-path-coercion).
# Type
``` unions :: [ FileSet ] -> FileSet ```
# Examples :::{.example} ## `lib.fileset.unions` usage example
```nix # Create a file set containing selected files unions [ # Include the single file `Makefile` in the current directory # This errors if the file doesn't exist ./Makefile
# Recursively include all files in the `src/code` directory # If this directory is empty this has no effect ./src/code
# Include the files `run.sh` and `unit.c` from the `tests` directory ./tests/run.sh ./tests/unit.c
# Include the `LICENSE` file from the parent directory ../LICENSE ] ```
::: */ unions = filesets: if !isList filesets then throw ''lib.fileset.unions: Argument is of type ${typeOf filesets}, but it should be a list instead.'' else pipe filesets [ # Annotate the elements with context, used by _coerceMany for better errors (imap0 ( i: el: { context = "Element ${toString i}"; value = el; } )) (_coerceMany "lib.fileset.unions") _unionMany ];
/** The file set containing all files that are in both of two given file sets. See also [Intersection (set theory)](https://en.wikipedia.org/wiki/Intersection_(set_theory)).
The given file sets are evaluated as lazily as possible, with the first argument being evaluated first if needed.
# Inputs
`fileset1`
: The first file set. This argument can also be a path, which gets [implicitly coerced to a file set](#sec-fileset-path-coercion).
`fileset2`
: The second file set. This argument can also be a path, which gets [implicitly coerced to a file set](#sec-fileset-path-coercion).
# Type
``` intersection :: FileSet -> FileSet -> FileSet ```
# Examples :::{.example} ## `lib.fileset.intersection` usage example
```nix # Limit the selected files to the ones in ./., so only ./src and ./Makefile intersection ./. (unions [ ../LICENSE ./src ./Makefile ]) ```
::: */ intersection = fileset1: fileset2: let filesets = _coerceMany "lib.fileset.intersection" [ { context = "First argument"; value = fileset1; } { context = "Second argument"; value = fileset2; } ]; in _intersection (elemAt filesets 0) (elemAt filesets 1);
/** The file set containing all files from the first file set that are not in the second file set. See also [Difference (set theory)](https://en.wikipedia.org/wiki/Complement_(set_theory)#Relative_complement).
The given file sets are evaluated as lazily as possible, with the first argument being evaluated first if needed.
# Inputs
`positive`
: The positive file set. The result can only contain files that are also in this file set. This argument can also be a path, which gets [implicitly coerced to a file set](#sec-fileset-path-coercion).
`negative`
: The negative file set. The result will never contain files that are also in this file set. This argument can also be a path, which gets [implicitly coerced to a file set](#sec-fileset-path-coercion).
# Type
``` difference :: FileSet -> FileSet -> FileSet ```
# Examples :::{.example} ## `lib.fileset.difference` usage example
```nix # Create a file set containing all files from the current directory, # except ones under ./tests difference ./. ./tests
let # A set of Nix-related files nixFiles = unions [ ./default.nix ./nix ./tests/default.nix ]; in # Create a file set containing all files under ./tests, except ones in `nixFiles`, # meaning only without ./tests/default.nix difference ./tests nixFiles ```
::: */ difference = positive: negative: let filesets = _coerceMany "lib.fileset.difference" [ { context = "First argument (positive set)"; value = positive; } { context = "Second argument (negative set)"; value = negative; } ]; in _difference (elemAt filesets 0) (elemAt filesets 1);
/** Filter a file set to only contain files matching some predicate.
# Inputs
`predicate`
: The predicate function to call on all files contained in given file set. A file is included in the resulting file set if this function returns true for it.
This function is called with an attribute set containing these attributes:
- `name` (String): The name of the file
- `type` (String, one of `"regular"`, `"symlink"` or `"unknown"`): The type of the file. This matches result of calling [`builtins.readFileType`](https://nixos.org/manual/nix/stable/language/builtins.html#builtins-readFileType) on the file's path.
- `hasExt` (String -> Bool): Whether the file has a certain file extension. `hasExt ext` is true only if `hasSuffix ".${ext}" name`.
This also means that e.g. for a file with name `.gitignore`, `hasExt "gitignore"` is true.
Other attributes may be added in the future.
`path`
: The path whose files to filter
# Type
``` fileFilter :: ({ name :: String, type :: String, hasExt :: String -> Bool, ... } -> Bool) -> Path -> FileSet ```
# Examples :::{.example} ## `lib.fileset.fileFilter` usage example
```nix # Include all regular `default.nix` files in the current directory fileFilter (file: file.name == "default.nix") ./.
# Include all non-Nix files from the current directory fileFilter (file: ! file.hasExt "nix") ./.
# Include all files that start with a "." in the current directory fileFilter (file: hasPrefix "." file.name) ./.
# Include all regular files (not symlinks or others) in the current directory fileFilter (file: file.type == "regular") ./. ```
::: */ fileFilter = predicate: path: if !isFunction predicate then throw ''lib.fileset.fileFilter: First argument is of type ${typeOf predicate}, but it should be a function instead.'' else if !isPath path then if path._type or "" == "fileset" then throw '' lib.fileset.fileFilter: Second argument is a file set, but it should be a path instead. If you need to filter files in a file set, use `intersection fileset (fileFilter pred ./.)` instead.'' else throw ''lib.fileset.fileFilter: Second argument is of type ${typeOf path}, but it should be a path instead.'' else if !pathExists path then throw ''lib.fileset.fileFilter: Second argument (${toString path}) is a path that does not exist.'' else _fileFilter predicate path;
/** Create a file set with the same files as a `lib.sources`-based value. This does not import any of the files into the store.
This can be used to gradually migrate from `lib.sources`-based filtering to `lib.fileset`.
A file set can be turned back into a source using [`toSource`](#function-library-lib.fileset.toSource).
:::{.note} File sets cannot represent empty directories. Turning the result of this function back into a source using `toSource` will therefore not preserve empty directories. :::
# Inputs
`source`
: 1\. Function argument
# Type
``` fromSource :: SourceLike -> FileSet ```
# Examples :::{.example} ## `lib.fileset.fromSource` usage example
```nix # There's no cleanSource-like function for file sets yet, # but we can just convert cleanSource to a file set and use it that way toSource { root = ./.; fileset = fromSource (lib.sources.cleanSource ./.); }
# Keeping a previous sourceByRegex (which could be migrated to `lib.fileset.unions`), # but removing a subdirectory using file set functions difference (fromSource (lib.sources.sourceByRegex ./. [ "^README\.md$" # This regex includes everything in ./doc "^doc(/.*)?$" ]) ./doc/generated
# Use cleanSource, but limit it to only include ./Makefile and files under ./src intersection (fromSource (lib.sources.cleanSource ./.)) (unions [ ./Makefile ./src ]); ```
::: */ fromSource = source: let # This function uses `._isLibCleanSourceWith`, `.origSrc` and `.filter`, # which are technically internal to lib.sources, # but we'll allow this since both libraries are in the same code base # and this function is a bridge between them. isFiltered = source ? _isLibCleanSourceWith; path = if isFiltered then source.origSrc else source; in # We can only support sources created from paths if !isPath path then if isStringLike path then throw '' lib.fileset.fromSource: The source origin of the argument is a string-like value ("${toString path}"), but it should be a path instead. Sources created from paths in strings cannot be turned into file sets, use `lib.sources` or derivations instead.'' else throw ''lib.fileset.fromSource: The source origin of the argument is of type ${typeOf path}, but it should be a path instead.'' else if !pathExists path then throw ''lib.fileset.fromSource: The source origin (${toString path}) of the argument is a path that does not exist.'' else if isFiltered then _fromSourceFilter path source.filter else # If there's no filter, no need to run the expensive conversion, all subpaths will be included _singleton path;
/** Create a file set containing all [Git-tracked files](https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository) in a repository.
This function behaves like [`gitTrackedWith { }`](#function-library-lib.fileset.gitTrackedWith) - using the defaults.
# Inputs
`path`
: The [path](https://nixos.org/manual/nix/stable/language/values#type-path) to the working directory of a local Git repository. This directory must contain a `.git` file or subdirectory.
# Type
``` gitTracked :: Path -> FileSet ```
# Examples :::{.example} ## `lib.fileset.gitTracked` usage example
```nix # Include all files tracked by the Git repository in the current directory gitTracked ./.
# Include only files tracked by the Git repository in the parent directory # that are also in the current directory intersection ./. (gitTracked ../.) ```
::: */ gitTracked = path: _fromFetchGit "gitTracked" "argument" path { };
/** Create a file set containing all [Git-tracked files](https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository) in a repository. The first argument allows configuration with an attribute set, while the second argument is the path to the Git working tree.
`gitTrackedWith` does not perform any filtering when the path is a [Nix store path](https://nixos.org/manual/nix/stable/store/store-path.html#store-path) and not a repository. In this way, it accommodates the use case where the expression that makes the `gitTracked` call does not reside in an actual git repository anymore, and has presumably already been fetched in a way that excludes untracked files. Fetchers with such equivalent behavior include `builtins.fetchGit`, `builtins.fetchTree` (experimental), and `pkgs.fetchgit` when used without `leaveDotGit`.
If you don't need the configuration, you can use [`gitTracked`](#function-library-lib.fileset.gitTracked) instead.
This is equivalent to the result of [`unions`](#function-library-lib.fileset.unions) on all files returned by [`git ls-files`](https://git-scm.com/docs/git-ls-files) (which uses [`--cached`](https://git-scm.com/docs/git-ls-files#Documentation/git-ls-files.txt--c) by default).
:::{.warning} Currently this function is based on [`builtins.fetchGit`](https://nixos.org/manual/nix/stable/language/builtins.html#builtins-fetchGit) As such, this function causes all Git-tracked files to be unnecessarily added to the Nix store, without being re-usable by [`toSource`](#function-library-lib.fileset.toSource).
This may change in the future. :::
# Inputs
`options` (attribute set) : `recurseSubmodules` (optional, default: `false`) : Whether to recurse into [Git submodules](https://git-scm.com/book/en/v2/Git-Tools-Submodules) to also include their tracked files. If `true`, this is equivalent to passing the [--recurse-submodules](https://git-scm.com/docs/git-ls-files#Documentation/git-ls-files.txt---recurse-submodules) flag to `git ls-files`.
`path` : The [path](https://nixos.org/manual/nix/stable/language/values#type-path) to the working directory of a local Git repository. This directory must contain a `.git` file or subdirectory.
# Type
``` gitTrackedWith :: { recurseSubmodules :: Bool ? false } -> Path -> FileSet ```
# Examples :::{.example} ## `lib.fileset.gitTrackedWith` usage example
```nix # Include all files tracked by the Git repository in the current directory # and any submodules under it gitTracked { recurseSubmodules = true; } ./. ```
::: */ gitTrackedWith = { recurseSubmodules ? false, }: path: if !isBool recurseSubmodules then throw "lib.fileset.gitTrackedWith: Expected the attribute `recurseSubmodules` of the first argument to be a boolean, but it's a ${typeOf recurseSubmodules} instead." else if recurseSubmodules && versionOlder nixVersion _fetchGitSubmodulesMinver then throw "lib.fileset.gitTrackedWith: Setting the attribute `recurseSubmodules` to `true` is only supported for Nix version ${_fetchGitSubmodulesMinver} and after, but Nix version ${nixVersion} is used." else _fromFetchGit "gitTrackedWith" "second argument" path # This is the only `fetchGit` parameter that makes sense in this context. # We can't just pass `submodules = recurseSubmodules` here because # this would fail for Nix versions that don't support `submodules`. ( lib.optionalAttrs recurseSubmodules { submodules = true; } );}