populate flake-input: deliver the inputs the input's own lock file pins

A flake-input source delivers an input as its own flake, which
evaluating it uses with its own lock file.  Populate, however, took the
input's inputs from the parent flake's lock file: on the target, by
walking the lock file, and on the deploying machine, from the parent's
nix flake archive.  That had several consequences:

- An empty follows path, which removes an input, or two inputs following
  each other made the walk loop forever.
- Copying left out inputs that follow other inputs, and rejected names
  through them, e.g. dep/inner where dep's inner follows another input.
- Inputs given by relative paths, e.g. path:./lib, which have no lock
  entry of their own to fetch, broke fetching on the target and
  flake-input sources.
- Where the parent overrides an input's inputs, the input's own lock file
  pins other versions than the delivered ones.

Populate now resolves the name through the parent's lock file, follows
included and guarded against cycles, to what to fetch: a locked
reference, or the flake itself, which inputs given by relative paths are
part of.  It fetches that, on the deploying machine or on the target, and
then the inputs the input's own lock file pins, using nix flake archive.
An input without a lock file comes without its inputs.

New edge cases cover lock files with empty and cyclic follows, names
through follows, the delivered closure, and relative path inputs.

1 files changed, 69 insertions, 0 deletions

diff --git a/tests/fixtures.sh b/tests/fixtures.sh
index 9608fcd..9813c8f 100755
--- a/tests/fixtures.sh
+++ b/tests/fixtures.sh
@@ -147,6 +147,75 @@ cat > /fixtures/uselocal/flake.nix <<'NIX'
 NIX
 (cd /fixtures/uselocal && nix flake lock)
 
+# follow: a flake whose input dep draws its input inner from the flake's own
+# input inner, which is inner2, so the lock file records a follows path, and
+# dep's own lock file pins another inner than the flake's.
+mkdir /fixtures/www/src/inner2
+cat > /fixtures/www/src/inner2/flake.nix <<'NIX'
+{ outputs = _: { who = "inner2"; }; }
+NIX
+tarball inner2
+mkdir /fixtures/follow
+cat > /fixtures/follow/flake.nix <<NIX
+{
+  inputs.inner.url = "$url/inner2.tar.gz";
+  inputs.dep.url = "$url/dep.tar.gz";
+  inputs.dep.inputs.inner.follows = "inner";
+  outputs = { dep, ... }: { msg = "follow:\${dep.greeting}"; };
+}
+NIX
+(cd /fixtures/follow && nix flake lock)
+
+# nofollow: a flake that removes an input of its input, so the lock file
+# records an empty follows path.
+mkdir /fixtures/nofollow
+cat > /fixtures/nofollow/flake.nix <<NIX
+{
+  inputs.dep.url = "$url/dep.tar.gz";
+  inputs.dep.inputs.inner.follows = "";
+  outputs = _: { msg = "nofollow"; };
+}
+NIX
+(cd /fixtures/nofollow && nix flake lock)
+
+# cyc: a flake whose inputs cyca and cycb follow each other.
+for name in cyca cycb; do
+  other=$(test $name = cyca && echo cycb || echo cyca)
+  mkdir /fixtures/www/src/$name
+  cat > /fixtures/www/src/$name/flake.nix <<NIX
+{
+  inputs.other.url = "$url/$other.tar.gz";
+  outputs = _: { who = "$name"; };
+}
+NIX
+  tarball $name
+done
+mkdir /fixtures/cyc
+cat > /fixtures/cyc/flake.nix <<NIX
+{
+  inputs.a.url = "$url/cyca.tar.gz";
+  inputs.b.url = "$url/cycb.tar.gz";
+  inputs.a.inputs.other.follows = "b";
+  inputs.b.inputs.other.follows = "a";
+  outputs = { a, b, ... }: { msg = "cyc:\${a.who},\${b.who}"; };
+}
+NIX
+(cd /fixtures/cyc && nix flake lock)
+
+# rel: a flake in a Git work tree with an input in a subdirectory, referred
+# to by a relative path.
+mkdir -p /fixtures/rel/lib
+cat > /fixtures/rel/lib/flake.nix <<'NIX'
+{ outputs = _: { who = "lib"; }; }
+NIX
+cat > /fixtures/rel/flake.nix <<'NIX'
+{
+  inputs.lib.url = "path:./lib";
+  outputs = { lib, ... }: { msg = "rel:${lib.who}"; };
+}
+NIX
+(cd /fixtures/rel && nix flake lock && git init -q && commit rel)
+
 # noflake: a directory without flake.nix.
 mkdir /fixtures/noflake
 echo noflake > /fixtures/noflake/README