aboutsummaryrefslogtreecommitdiffstats
path: root/pkgs/populate
diff options
context:
space:
mode:
Diffstat (limited to 'pkgs/populate')
-rw-r--r--pkgs/populate/checks.nix66
-rw-r--r--pkgs/populate/default.nix106
-rw-r--r--pkgs/populate/docs/design.md59
-rw-r--r--pkgs/populate/lib/default.nix78
-rw-r--r--pkgs/populate/lib/types/populate.nix323
-rw-r--r--pkgs/populate/lib/types/posix.nix54
-rw-r--r--pkgs/populate/program.nix25
7 files changed, 510 insertions, 201 deletions
diff --git a/pkgs/populate/checks.nix b/pkgs/populate/checks.nix
deleted file mode 100644
index 22b45c9..0000000
--- a/pkgs/populate/checks.nix
+++ /dev/null
@@ -1,66 +0,0 @@
-# Checks of populate's arguments during evaluation. Each returns true, or
-# throws an error naming what's wrong.
-with import ../../lib;
-
-{
- # Populate replaces and removes what's at the target paths of sources, so
- # it refuses names that lead out of the target directory, to the directory
- # itself, or to its own state. The remaining names are portable file
- # names, which mean themselves to shells, find, and in URLs, and which the
- # names of the scripts populating the sources may contain.
- checkSourceName = name:
- if elem name [ "." ".." ".populate" ] ||
- builtins.match "[0-9A-Za-z._][0-9A-Za-z._-]*" name == null then
- throw "krops: source name ${toJSON name} can't be used: it must consist of letters, digits, and the characters ._-, not start with -, and be neither ., .., nor .populate"
- else
- true;
-
- # Populate removes what it finds in the target directory, so it refuses
- # paths that aren't absolute, that are the root directory, or that the
- # target would resolve to another directory than the one they name.
- checkTargetPath = path: let
- components = filter (x: x != "" && x != ".") (splitString "/" path);
- in
- if !isString path || substring 0 1 path != "/" then
- throw "krops: target path ${toJSON path} can't be used: it must be absolute"
- else if components == [] then
- throw "krops: target path ${toJSON path} can't be used: it must not be the root directory"
- else if elem ".." components ||
- builtins.match "[^[:cntrl:]]+" path == null then
- throw "krops: target path ${toJSON path} can't be used: it must not contain .. or control characters"
- else
- true;
-
- # Inputs get drawn from other sources, so they must exist, and drawing
- # must not go round in circles.
- checkInputs = source: let
- drawnFrom = name: map (x: x.source) (flakeFollows source.${name});
- check = name: from:
- if from == name then
- throw "krops: source ${name} draws inputs from itself"
- else if !(source ? ${from}) then
- throw "krops: source ${name} draws inputs from missing source ${from}"
- else
- true;
- sorted = toposort (a: b: elem a (drawnFrom b)) (attrNames source);
- in
- all (name: all (check name) (drawnFrom name)) (attrNames source) &&
- (if sorted ? cycle then
- throw "krops: sources draw inputs from each other: ${toString sorted.cycle}"
- else
- true);
-
- # nix copy logs in as the target's user, so populate can't copy flakes to
- # remote targets using sudo, which flake and flake-input sources without
- # fetchOnTarget do.
- checkCopyingWithSudo = target: source: let
- copies = name: let s = source.${name}; in
- elem s.type [ "flake" "flake-input" ] &&
- !(s.${s.type}.fetchOnTarget or false);
- name = findFirst copies null (attrNames source);
- in
- if name != null && target.sudo or false && !isLocalTarget target then
- throw "krops: source ${target.path}/${name}: copying flakes to targets with sudo is not supported"
- else
- true;
-}
diff --git a/pkgs/populate/default.nix b/pkgs/populate/default.nix
index bd8e772..0c98b28 100644
--- a/pkgs/populate/default.nix
+++ b/pkgs/populate/default.nix
@@ -1,86 +1,28 @@
-# Populate, which delivers sources to a target directory. Given populate's
-# arguments, it checks them, and returns a script running the program in
-# this directory with them, the sources as JSON. rustProgram is that program, e.g. one
-# built with cargo during development.
-{ coreutils, findutils, git, nix, openssh, pass, passage, rsync, writers
-, rustPlatform ? null
-, rustProgram ? import ./program.nix { inherit rustPlatform; }
-, ...
-}@args:
-
-with import ../../lib;
+# populate, built from the crate in this directory: nix-build here, or
+# callPackage.
+{ rustPlatform ? (import <nixpkgs> {}).rustPlatform }:
let
- checks = import ./checks.nix;
-
- # Arguments populate doesn't use, which overrides written for krops 1 may
- # set. They come through ..., because callPackage would set named ones.
- unused = filter (name: args ? ${name}) [ "dash" "implementation" "jq" ];
- unexpected = attrNames (removeAttrs args ([
- "coreutils" "findutils" "git" "nix" "openssh" "pass" "passage" "rsync"
- "writers" "rustPlatform" "rustProgram"
- ] ++ unused));
-
- # The parts of a target string, like mkTarget parses it, without its
- # defaults, which populate fills in when it runs.
- parseTarget = s: let
- parts = match "(([^@]*)@)?(([^:/]+))?(:([^/]+))?(/.*)?" s;
- in
- if parts == null then throw "krops: invalid target ${toJSON s}"
- else { host = elemAt parts 3; path = elemAt parts 6; };
-
- populate =
- { backup ? false, force ? false, prune ? false, source, target }:
- let
- # A target string goes to populate as it is, so populate decides what
- # it leaves out when it runs. An attribute set, as mkTarget returns
- # it, goes part by part, with whether it's local decided now, like the
- # other functions of krops do.
- parsed = parseTarget target;
- path = if isString target then (if parsed.path != null then parsed.path else "/var/src") else target.path;
- host = if isString target then (if parsed.host != null then parsed.host else "localhost") else target.host;
- targetArgs =
- if isString target then [ target ]
- else [
- "--user" (if target.user or null == null then "" else target.user)
- "--host" target.host
- "--path" target.path
- ] ++ optionals (target.port or null != null) [
- "--port" (toString target.port)
- ] ++ optional (target.sudo or false) "--sudo"
- ++ concatMap (arg: [ "--ssh-arg" arg ]) (flatten (target.extraOptions or []))
- ++ [ (if isLocalTarget target then "--local" else "--remote") ];
- in
- assert checks.checkTargetPath path;
- assert all checks.checkSourceName (attrNames source);
- assert checks.checkInputs source;
- assert isString target || checks.checkCopyingWithSudo target source;
- writers.writeDash "populate.${host}" /* sh */ ''
- set -efu
- echo + "$0" >&2
- PATH=${makeBinPath [
- coreutils findutils git nix openssh pass passage rsync
- ]}''${PATH:+:$PATH}
- export PATH
- # The sources on a file descriptor of their own, so the commands
- # populate runs keep standard input. Store paths in them stay
- # dependencies of this script, so building it builds them. The JSON is
- # a single line, which can't be the delimiter.
- exec ${rustProgram}/bin/populate ${escapeShellArgs (
- optional backup "--backup" ++
- optional force "--force" ++
- optional prune "--prune"
- )} /dev/fd/3 ${escapeShellArgs targetArgs} 3<<'EOF'
- ${toJSON source}
- EOF
- '';
-
+ cargoToml = builtins.fromTOML (builtins.readFile ./Cargo.toml);
in
-if unexpected != [] then
- throw "krops: populate called with unexpected argument ${head unexpected}"
-else
- foldr
- (name: warn "krops: populate's argument ${name} is unused")
- populate
- unused
+rustPlatform.buildRustPackage {
+ pname = cargoToml.package.name;
+ inherit (cargoToml.package) version;
+ # Without what cargo doesn't build from, so changes to the Nix files, the
+ # docs, or the tests don't rebuild the program. By names, not by paths
+ # relative to this directory: the paths the filter gets needn't start
+ # with toString ./., e.g. if a symlink leads to this directory.
+ src = builtins.path {
+ name = "populate-src";
+ path = ./.;
+ filter = path: type: let
+ name = baseNameOf path;
+ in
+ !(builtins.elem name [
+ ".gitignore" "README.md" "docs" "lib" "target" "tests"
+ ] ||
+ builtins.match ".*\\.nix" name != null);
+ };
+ cargoLock.lockFile = ./Cargo.lock;
+}
diff --git a/pkgs/populate/docs/design.md b/pkgs/populate/docs/design.md
index cf9d356..940ab5f 100644
--- a/pkgs/populate/docs/design.md
+++ b/pkgs/populate/docs/design.md
@@ -1,15 +1,16 @@
# Populate's design
-Populate delivers sources to a target directory. It consists of two parts:
+Populate delivers sources to a target directory. It consists of:
-- Nix code, which turns populate's arguments into a command line: the
- sources as `evalSource` returns them, as JSON, the target, and the
- options. It checks the arguments during evaluation, so mistakes show
- early.
-- A program, which reads the sources and delivers them to the target its
- command line names. It knows nothing about Nix expressions: whatever
- produces sources as JSON can drive it.
+- A program, which reads the sources as JSON and delivers them to the
+ target its command line names. It knows nothing about Nix expressions:
+ whatever produces sources as JSON can drive it.
+- A Nix library, `lib`, with the types of sources, which describe how to
+ write them in Nix, and `evalSource`, which turns sources written so into
+ the JSON the program reads.
+krops uses both: its `pkgs.populate` turns populate's arguments into a
+command line, and checks them during evaluation, so mistakes show early.
So there is one program for each version of populate, instead of a script
for each set of arguments, and the program can be written in any language.
This directory holds the program in Rust. Another implementation, e.g. in
@@ -18,20 +19,22 @@ the same tests.
## Nix side
-`default.nix` is `pkgs.populate`. Given populate's arguments, `{ backup ?
-false, force ? false, prune ? false, source, target }`, it checks them with
-`checks.nix`, and returns a script running the program with the sources as
-JSON on file descriptor 3, so the commands populate runs keep standard
-input. A target string goes to the program as it is. A target attribute
-set, as `mkTarget` returns it, goes part by part, as options, with
-`--local` or `--remote` as krops' lib's `isLocalTarget` decides during
-evaluation, like the other functions of krops. The script puts the tools
-populate runs in front of `PATH`, and depends on the store paths in the
-sources, so building it builds them. `rustProgram` is the program, by
-default built by `program.nix`.
+`default.nix` builds the program: `nix-build` in this directory, or
+`callPackage`, as krops' `pkgs.populate-unwrapped`. `lib/default.nix` is
+the Nix library, taking nixpkgs' lib.
-`writeDeploy` and the other functions of `pkgs.krops` use `pkgs.populate`,
-so their arguments stay as they are.
+krops' `pkgs.populate`, in its `pkgs/krops/populate.nix`, is populate's Nix
+API there. Given populate's arguments, `{ backup ? false, force ? false,
+prune ? false, source, target }`, it checks them with krops'
+`pkgs/krops/checks.nix`, and returns a script running the program with the
+sources as JSON on file descriptor 3, so the commands populate runs keep
+standard input. A target string goes to the program as it is. A target
+attribute set, as `mkTarget` returns it, goes part by part, as options,
+with `--local` or `--remote` as krops' lib's `isLocalTarget` decides
+during evaluation, like the other functions of krops. The script puts the
+tools populate runs in front of `PATH`, and depends on the store paths in
+the sources, so building it builds them. krops' `writeDeploy` and its
+other functions use `pkgs.populate`, so their arguments stay as they are.
## Invocation
@@ -99,13 +102,13 @@ doesn't go unnoticed. The sources carry no version: this is version 0, and
a later version of populate that reads them differently will mark them.
Store paths in the sources, e.g. of a `file` source that is a derivation,
-must exist when the program runs. The script `default.nix` writes depends
-on them. Something producing sources at run time has to build them first.
+must exist when the program runs. The script krops' `pkgs.populate`
+writes depends on them. Something producing sources at run time has to build them first.
## Checks
-The program checks the sources and the target as `checks.nix` does, with
-the same messages:
+The program checks the sources and the target as krops' `checks.nix` does
+during evaluation, with the same messages:
- The target's host isn't empty, and neither it nor its user starts with
`-`, so ssh can't take them for options. `checks.nix` doesn't check
@@ -122,9 +125,9 @@ the same messages:
since `evalSource` checks the types.
Checks that depend on whether the target is local come on top, e.g.
-refusing to copy flakes to remote targets using sudo. `checks.nix` does
-that during evaluation too, where `default.nix` decides whether the target
-is local.
+refusing to copy flakes to remote targets using sudo. krops' `checks.nix`
+does that during evaluation too, where `pkgs.populate` decides whether the
+target is local.
## Output
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 != []));
+
+}
diff --git a/pkgs/populate/lib/types/populate.nix b/pkgs/populate/lib/types/populate.nix
new file mode 100644
index 0000000..56b0292
--- /dev/null
+++ b/pkgs/populate/lib/types/populate.nix
@@ -0,0 +1,323 @@
+{ lib }: rec {
+
+ source = lib.types.submodule ({ config, ... }: {
+ options = {
+ type = let
+ known-types = lib.attrNames source-types;
+ type-candidates = lib.filter (k: config.${k} != null) known-types;
+ in lib.mkOption {
+ default = if lib.length type-candidates == 1
+ then lib.head type-candidates
+ else throw "cannot determine type";
+ type = lib.types.enum known-types;
+ };
+ derivation = lib.mkOption {
+ apply = x:
+ if lib.types.str.check x
+ then { text = x; }
+ else x;
+ default = null;
+ type = lib.types.nullOr (lib.types.either lib.types.str source-types.derivation);
+ };
+ file = lib.mkOption {
+ apply = x:
+ if lib.types.absolute-pathname.check x || lib.types.package.check x
+ then { path = x; }
+ else x;
+ default = null;
+ type = lib.types.nullOr (lib.types.oneOf [
+ lib.types.absolute-pathname
+ lib.types.package
+ source-types.file
+ ]);
+ };
+ flake = lib.mkOption {
+ apply = x:
+ if lib.types.str.check x
+ then { url = x; }
+ else x;
+ default = null;
+ type = lib.types.nullOr (lib.types.either lib.types.str source-types.flake);
+ };
+ flake-input = lib.mkOption {
+ default = null;
+ type = lib.types.nullOr source-types.flake-input;
+ };
+ git = lib.mkOption {
+ default = null;
+ type = lib.types.nullOr source-types.git;
+ };
+ pass = lib.mkOption {
+ default = null;
+ type = lib.types.nullOr source-types.pass;
+ };
+ passage = lib.mkOption {
+ apply = x:
+ if lib.types.pathname.check x
+ then { dir = x; }
+ else x;
+ default = null;
+ type = lib.types.nullOr (lib.types.oneOf [
+ lib.types.pathname
+ source-types.passage
+ ]);
+ };
+ pipe = lib.mkOption {
+ apply = x:
+ if lib.types.absolute-pathname.check x
+ then { command = x; }
+ else x;
+ default = null;
+ type = lib.types.nullOr (lib.types.either lib.types.absolute-pathname source-types.pipe);
+ };
+ symlink = lib.mkOption {
+ apply = x:
+ if lib.types.pathname.check x
+ then { target = x; }
+ else x;
+ default = null;
+ type = lib.types.nullOr (lib.types.either lib.types.pathname source-types.symlink);
+ };
+ };
+ });
+
+ # Inputs of the flake in a source that get drawn from other sources, in the
+ # style of flake.nix, e.g. { nixpkgs.follows = "nixpkgs"; }.
+ flake-inputs = lib.types.attrsOf (lib.types.submodule {
+ options = {
+ follows = lib.mkOption {
+ default = null;
+ type = lib.types.nullOr lib.types.str; # TODO lib.types.label
+ };
+ inputs = lib.mkOption {
+ default = {};
+ type = flake-inputs;
+ };
+ };
+ });
+
+ filter = lib.types.submodule {
+ options = {
+ type = lib.mkOption {
+ type = lib.types.enum ["include" "exclude"];
+ default = "exclude";
+ };
+ pattern = lib.mkOption {
+ type = lib.types.str;
+ };
+ };
+ };
+
+ source-types = {
+ derivation = lib.types.submodule {
+ options = {
+ text = lib.mkOption {
+ type = lib.types.str;
+ };
+ };
+ };
+ file = lib.types.submodule {
+ options = {
+ inputs = lib.mkOption {
+ default = {};
+ type = flake-inputs;
+ };
+ path = lib.mkOption {
+ type = lib.types.absolute-pathname;
+ };
+ rewriteLock = lib.mkOption {
+ default = true;
+ type = lib.types.bool;
+ };
+ useChecksum = lib.mkOption {
+ default = false;
+ type = lib.types.bool;
+ };
+ exclude = lib.mkOption {
+ apply = x:
+ if x != [] then
+ lib.warn
+ "file.*.exclude is deprecated in favor of file.*.filters"
+ x
+ else
+ x;
+ description = ''
+ DEPRECATED, use `filters`.
+ '';
+ type = lib.types.listOf lib.types.str;
+ default = [];
+ example = [".git"];
+ };
+ filters = lib.mkOption {
+ type = lib.types.listOf filter;
+ default = [];
+ example = [
+ {
+ type = "include";
+ pattern = "*.nix";
+ }
+ {
+ type = "include";
+ pattern = "*/";
+ }
+ {
+ type = "exclude";
+ pattern = "*";
+ }
+ ];
+ };
+ deleteExcluded = lib.mkOption {
+ default = true;
+ type = lib.types.bool;
+ };
+ insecureLinks = lib.mkOption {
+ default = null;
+ type = lib.types.nullOr lib.types.bool;
+ };
+ };
+ };
+ flake = lib.types.submodule {
+ options = {
+ fetchOnTarget = lib.mkOption {
+ default = false;
+ type = lib.types.bool;
+ };
+ url = lib.mkOption {
+ type = lib.types.str; # TODO lib.types.flake-ref
+ };
+ inputs = lib.mkOption {
+ default = {};
+ type = flake-inputs;
+ };
+ materialize = lib.mkOption {
+ default = false;
+ type = lib.types.bool;
+ };
+ patches = lib.mkOption {
+ apply = map toString;
+ default = [];
+ type = lib.types.listOf lib.types.path;
+ };
+ rewriteLock = lib.mkOption {
+ default = true;
+ type = lib.types.bool;
+ };
+ };
+ };
+ flake-input = lib.types.submodule {
+ options = {
+ fetchOnTarget = lib.mkOption {
+ default = false;
+ type = lib.types.bool;
+ };
+ url = lib.mkOption {
+ type = lib.types.str; # TODO lib.types.flake-ref
+ };
+ inputs = lib.mkOption {
+ default = {};
+ type = flake-inputs;
+ };
+ materialize = lib.mkOption {
+ default = false;
+ type = lib.types.bool;
+ };
+ patches = lib.mkOption {
+ apply = map toString;
+ default = [];
+ type = lib.types.listOf lib.types.path;
+ };
+ rewriteLock = lib.mkOption {
+ default = true;
+ type = lib.types.bool;
+ };
+ name = lib.mkOption {
+ type = lib.types.str;
+ };
+ requireInputs = lib.mkOption {
+ default = true;
+ type = lib.types.bool;
+ };
+ };
+ };
+ git = lib.types.submodule {
+ options = {
+ clean = {
+ exclude = lib.mkOption {
+ default = [];
+ type = lib.types.listOf lib.types.str;
+ };
+ };
+ fetchAlways = lib.mkOption {
+ type = lib.types.bool;
+ default = false;
+ };
+ inputs = lib.mkOption {
+ default = {};
+ type = flake-inputs;
+ };
+ ref = lib.mkOption {
+ type = lib.types.str; # TODO lib.types.git.ref
+ };
+ reclone = lib.mkOption {
+ default = false;
+ type = lib.types.bool;
+ };
+ rewriteLock = lib.mkOption {
+ default = true;
+ type = lib.types.bool;
+ };
+ url = lib.mkOption {
+ type = lib.types.str; # TODO lib.types.git.url
+ };
+ shallow = lib.mkOption {
+ default = false;
+ type = lib.types.bool;
+ };
+ };
+ };
+ pass = lib.types.submodule {
+ options = {
+ dir = lib.mkOption {
+ type = lib.types.absolute-pathname;
+ };
+ name = lib.mkOption {
+ type = lib.types.pathname; # TODO relative-pathname
+ };
+ };
+ };
+ passage = lib.types.submodule {
+ options = {
+ age = lib.mkOption {
+ default = "age";
+ type = lib.types.pathname;
+ };
+ dir = lib.mkOption {
+ type = lib.types.pathname;
+ };
+ identities_file = lib.mkOption {
+ default = toString ~/.passage/identities;
+ type = lib.types.pathname;
+ };
+ };
+ };
+ pipe = lib.types.submodule {
+ options = {
+ command = lib.mkOption {
+ type = lib.types.absolute-pathname;
+ };
+ };
+ };
+ symlink = lib.types.submodule {
+ options = {
+ inputs = lib.mkOption {
+ default = {};
+ type = flake-inputs;
+ };
+ target = lib.mkOption {
+ type = lib.types.pathname; # TODO relative-pathname
+ };
+ };
+ };
+ };
+
+}
diff --git a/pkgs/populate/lib/types/posix.nix b/pkgs/populate/lib/types/posix.nix
new file mode 100644
index 0000000..e8f464e
--- /dev/null
+++ b/pkgs/populate/lib/types/posix.nix
@@ -0,0 +1,54 @@
+{ lib }: rec {
+
+ # RFC952, B. Lexical grammar, <hname>
+ hostname = lib.mkOptionType {
+ name = "hostname";
+ check = x: lib.isString x && lib.all label.check (lib.splitString "." x);
+ merge = lib.mergeOneOption;
+ };
+
+ # RFC952, B. Lexical grammar, <name>
+ # RFC1123, 2.1 Host Names and Numbers
+ label = lib.mkOptionType {
+ name = "label";
+ # TODO case-insensitive labels
+ check = lib.test "[0-9A-Za-z]([0-9A-Za-z-]*[0-9A-Za-z])?";
+ merge = lib.mergeOneOption;
+ };
+
+ # POSIX.1‐2013, 3.278 Portable Filename Character Set
+ filename = lib.mkOptionType {
+ name = "POSIX filename";
+ check = lib.test "([0-9A-Za-z._])[0-9A-Za-z._-]*";
+ merge = lib.mergeOneOption;
+ };
+
+ # POSIX.1‐2013, 3.2 Absolute Pathname
+ absolute-pathname = lib.mkOptionType {
+ name = "POSIX absolute pathname";
+ check = x: lib.isString x && lib.substring 0 1 x == "/" && pathname.check x;
+ merge = lib.mergeOneOption;
+ };
+
+ # POSIX.1‐2013, 3.267 Pathname
+ pathname = lib.mkOptionType {
+ name = "POSIX pathname";
+ check = x:
+ let
+ # The filter is used to normalize paths, i.e. to remove duplicated and
+ # trailing slashes. It also removes leading slashes, thus we have to
+ # check for "/" explicitly below.
+ xs = lib.filter (s: lib.stringLength s > 0) (lib.splitString "/" x);
+ in
+ lib.isString x && (x == "/" || (lib.length xs > 0 && lib.all filename.check xs));
+ merge = lib.mergeOneOption;
+ };
+
+ # POSIX.1-2013, 3.431 User Name
+ username = lib.mkOptionType {
+ name = "POSIX username";
+ check = filename.check;
+ merge = lib.mergeOneOption;
+ };
+
+}
diff --git a/pkgs/populate/program.nix b/pkgs/populate/program.nix
deleted file mode 100644
index fbb364c..0000000
--- a/pkgs/populate/program.nix
+++ /dev/null
@@ -1,25 +0,0 @@
-# The program delivering sources, built from the crate in this directory.
-{ rustPlatform }:
-
-let
- cargoToml = builtins.fromTOML (builtins.readFile ./Cargo.toml);
-in
-
-rustPlatform.buildRustPackage {
- pname = cargoToml.package.name;
- inherit (cargoToml.package) version;
- # Without what cargo doesn't build from, so changes to the Nix files or
- # the docs don't rebuild the program. By names, not by paths relative to
- # this directory: the paths the filter gets needn't start with
- # toString ./., e.g. if a symlink leads to this directory.
- src = builtins.path {
- name = "populate-src";
- path = ./.;
- filter = path: type: let
- name = baseNameOf path;
- in
- !(builtins.elem name [ ".gitignore" "docs" "target" ] ||
- builtins.match ".*\\.nix" name != null);
- };
- cargoLock.lockFile = ./Cargo.lock;
-}