diff options
Diffstat (limited to 'pkgs/populate/lib/default.nix')
| -rw-r--r-- | pkgs/populate/lib/default.nix | 78 |
1 files changed, 78 insertions, 0 deletions
diff --git a/pkgs/populate/lib/default.nix b/pkgs/populate/lib/default.nix new file mode 100644 index 0000000..e9155c5 --- /dev/null +++ b/pkgs/populate/lib/default.nix @@ -0,0 +1,78 @@ +# populate's Nix library: the types of sources, which describe how to write +# them in Nix, and evalSource, which turns sources written so into the +# sources populate reads as JSON. lib is nixpkgs' lib. +{ lib ? import <nixpkgs/lib> }: + +let + # nixpkgs' lib, with what the types use besides. + lib' = lib // { + test = re: x: lib.isString x && lib.match re x != null; + types = lib.types // types; + }; + + types = + import ./types/posix.nix { lib = lib'; } // + import ./types/populate.nix { lib = lib'; }; + +in rec { + + inherit types; + + # The sources, a list of attribute sets of sources by name, or one, with + # shorthands expanded and defaults filled in, and without settings that + # are null, as populate reads them, e.g. with builtins.toJSON. + evalSource = let + eval = source: lib.evalModules { + modules = lib.singleton { + _file = toString ./.; + imports = map (source: { inherit source; }) (lib.toList source); + options.source = lib.mkOption { + default = {}; + type = lib.types.attrsOf types.source; + }; + }; + }; + sanitize = x: lib.getAttr (lib.typeOf x) { + bool = x; + list = map sanitize x; + set = lib.mapAttrs + (lib.const sanitize) + (lib.filterAttrs + (name: value: name != "_module" && value != null) x); + string = x; + }; + in + source: sanitize (eval source).config.source; + + # Inputs a source draws from other sources, as list of attribute sets like + # { path = [ "stockholm" "nixpkgs" ]; source = "nixpkgs"; }. + flakeFollows = source: let + flatten = prefix: inputs: lib.concatLists (lib.mapAttrsToList + (name: input: + lib.optional (input.follows or null != null) { + path = prefix ++ [ name ]; + source = input.follows; + } ++ + flatten (prefix ++ [ name ]) (input.inputs or {})) + inputs); + in + flatten [] (source.${source.type}.inputs or {}); + + # Tells whether a source's inputs get drawn from other sources by a + # generated flake in .populate/flakes, instead of by rewriting the lock + # file of the flake in the source. Symlink sources point at other + # sources, whose lock files stay as they are. + hasGeneratedFlake = source: + flakeFollows source != [] && + (source.type == "symlink" || !(source.${source.type}.rewriteLock or true)); + + # Tells whether a flake or flake-input source gets delivered as a copy, + # which gets patched, gets its lock file rewritten, or is materialized. + derivesFlake = source: let + source' = source.${source.type}; + in + lib.elem source.type [ "flake" "flake-input" ] && + (source'.materialize or false || source'.patches or [] != [] || + (source'.rewriteLock or true && flakeFollows source != [])); + +} |
