aboutsummaryrefslogtreecommitdiffstats
path: root/pkgs/populate/lib/default.nix
diff options
context:
space:
mode:
Diffstat (limited to 'pkgs/populate/lib/default.nix')
-rw-r--r--pkgs/populate/lib/default.nix78
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 != []));
+
+}