Introduce file inputs and a whole dev env/tests

lf- · lf- · commit a37fe3ab2000 · 2025-03-20T12:36:42.000-07:00
The goal here is that we have an ability to develop flake-compat and actually have tests and be able to validate it is correct. This also imports the file input stuff originally written by matthewbauer here: NixOS/flake-compat#44 This bore fruit already in the form of finding a years old bug lying around in Lix: https://git.lix.systems/lix-project/lix/issues/750
diff --git a/.envrc b/.envrc
@@ -0,0 +1,2 @@
+source_env_if_exists .envrc.local
+use flake ./dev#
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,2 @@
+# generated by nix
+.pre-commit-config.yaml
diff --git a/default.nix b/default.nix
@@ -16,6 +16,51 @@ let
 
   lockFile = builtins.fromJSON (builtins.readFile lockFilePath);
 
+  # Using custom fetchurl function here so that we can specify outputHashMode.
+  # The hash we get from the lock file is using recursive ingestion even though
+  # it’s not unpacked. So builtins.fetchurl and import <nix/fetchurl.nix> are
+  # insufficient.
+  # Note that this will be a derivation and not a path as fetchTarball is,
+  # causing the hash of this input to be different on flake and non-flake evaluation.
+  #
+  # Note: there are a bunch of related bugs and it seems like this being
+  # recursive-hashed to begin with was a mistake:
+  # https://git.lix.systems/lix-project/lix/issues/750
+  fetchurl =
+    { url, sha256 }:
+    derivation {
+      builder = "builtin:fetchurl";
+
+      name = "source";
+      inherit url;
+
+      outputHash = sha256;
+      outputHashAlgo = "sha256";
+      outputHashMode = "recursive";
+      executable = false;
+      unpack = false;
+
+      system = "builtin";
+
+      # No need to double the amount of network traffic
+      preferLocalBuild = true;
+
+      impureEnvVars = [
+        # We borrow these environment variables from the caller to allow
+        # easy proxy configuration.  This is impure, but a fixed-output
+        # derivation like fetchurl is allowed to do so since its result is
+        # by definition pure.
+        "http_proxy"
+        "https_proxy"
+        "ftp_proxy"
+        "all_proxy"
+        "no_proxy"
+      ];
+
+      # To make "nix-prefetch-url" work.
+      urls = [ url ];
+    };
+
   fetchTree =
     info:
     if info.type == "github" then
@@ -58,14 +103,16 @@ let
       )
     else if info.type == "path" then
       {
-        outPath = builtins.path { path = info.path; };
-        narHash = info.narHash;
+        outPath = builtins.path (
+          { path = info.path; } // (if info ? narHash then { sha256 = info.narHash; } else { })
+        );
       }
     else if info.type == "tarball" then
       {
         outPath = fetchTarball (
           { inherit (info) url; } // (if info ? narHash then { sha256 = info.narHash; } else { })
         );
+        narHash = info.narHash;
       }
     else if info.type == "gitlab" then
       {
@@ -89,6 +136,24 @@ let
         );
         shortRev = builtins.substring 0 7 info.rev;
       }
+    else if info.type == "file" then
+      {
+        outPath =
+          if
+            builtins.substring 0 7 info.url == "http://" || builtins.substring 0 8 info.url == "https://"
+          then
+            fetchurl ({ inherit (info) url; } // (if info ? narHash then { sha256 = info.narHash; } else { }))
+          else if builtins.substring 0 7 info.url == "file://" then
+            builtins.path (
+              {
+                path = builtins.substring 7 (-1) info.url;
+              }
+              // (if info ? narHash then { sha256 = info.narHash; } else { })
+            )
+          else
+            throw "can't support url scheme of flake input with url '${info.url}'";
+        narHash = info.narHash;
+      }
     else
       # FIXME: add Mercurial inputs.
       throw "flake input has unsupported input type '${info.type}'";
diff --git a/dev/flake.lock b/dev/flake.lock
diff --git a/dev/flake.nix b/dev/flake.nix
@@ -0,0 +1,63 @@
+# Separate flake for validation, since we don't want to make these visible to users
+{
+  inputs.nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+  inputs.flake-utils.url = "github:numtide/flake-utils";
+  inputs.pre-commit-hooks = {
+    url = "github:cachix/git-hooks.nix";
+    flake = false;
+  };
+
+  outputs =
+    {
+      self,
+      nixpkgs,
+      flake-utils,
+      pre-commit-hooks,
+    }:
+    (flake-utils.lib.eachDefaultSystem (
+      system:
+      let
+        pkgs = import nixpkgs { inherit system; };
+        checks = self.checks.${system};
+      in
+      {
+        devShells.default = pkgs.mkShell {
+          shellHook = ''
+            ${nixpkgs.lib.optionalString (checks.pre-commit ? shellHook) checks.pre-commit.shellHook}
+          '';
+          nativeBuildInputs = with pkgs.buildPackages; [
+            treefmt
+            nixfmt-rfc-style
+            ruff
+
+            python3
+            python3Packages.pytest
+          ];
+        };
+
+        checks.pre-commit =
+          let
+            # Avoid an unnecessary reimport of nixpkgs
+            tools = import (pre-commit-hooks + "/nix/call-tools.nix") pkgs;
+            pre-commit-run = pkgs.callPackage (pre-commit-hooks + "/nix/run.nix") {
+              inherit tools;
+              isFlakes = true;
+              # unused!
+              gitignore-nix-src = builtins.throw "gitignore-nix-src is unused";
+            };
+          in
+          pre-commit-run {
+            src = ../.;
+            hooks = {
+              treefmt = {
+                enable = true;
+                settings.formatters = with pkgs.buildPackages; [
+                  ruff
+                  nixfmt-rfc-style
+                ];
+              };
+            };
+          };
+      }
+    ));
+}
diff --git a/flake.nix b/flake.nix
@@ -1,5 +1,5 @@
 {
-  description = "Allow flakes to be used with Nix < 2.4";
+  description = "Allow flakes to be evaluated from non-flake contexts";
 
   outputs =
     { self }:
diff --git a/pyproject.toml b/pyproject.toml
@@ -0,0 +1,6 @@
+[project]
+name = "flake-compat"
+version = "0.0.0"
+dependencies = [
+    "pytest",
+]
diff --git a/tests/__init__.py b/tests/__init__.py
diff --git a/tests/file_input/__init__.py b/tests/file_input/__init__.py
diff --git a/tests/file_input/default.nix b/tests/file_input/default.nix
@@ -0,0 +1,6 @@
+{
+  flake-compat ? ../../default.nix,
+}:
+(import flake-compat {
+  src = ./.;
+}).defaultNix
diff --git a/tests/file_input/flake.lock b/tests/file_input/flake.lock
diff --git a/tests/file_input/flake.nix b/tests/file_input/flake.nix
@@ -0,0 +1,15 @@
+{
+  inputs.lix-manifest = {
+    type = "file";
+    # I can't get a file URL to work, idk, probably a bug in flakes lol
+    # This was chosen since it's a tiny file that is likely to remain there
+    # immutable ~forever
+    url = "https://releases.lix.systems/lix/lix-2.90.0/manifest.nix";
+    flake = false;
+  };
+  outputs =
+    { lix-manifest, ... }:
+    {
+      inherit lix-manifest;
+    };
+}
diff --git a/tests/file_input/test_file_input.py b/tests/file_input/test_file_input.py
@@ -0,0 +1,19 @@
+from pathlib import Path
+from tests.testlib import copy_fixture, nix, flake_compat_arg
+
+
+# May fail randomly due to: https://git.lix.systems/lix-project/lix/issues/750
+def test_file_input(tmpdir: Path):
+    copy_fixture("file_input", tmpdir)
+    compat = nix(
+        "eval",
+        "--json",
+        *flake_compat_arg,
+        "-f",
+        "default.nix",
+        "lix-manifest",
+        work_dir=tmpdir,
+    ).json()
+    native = nix("eval", "--json", ".#lix-manifest", work_dir=tmpdir).json()
+
+    assert native == compat
diff --git a/tests/testlib.py b/tests/testlib.py
@@ -0,0 +1,57 @@
+from pathlib import Path
+import dataclasses
+import subprocess
+import shutil
+import json
+import os
+
+src = Path(__file__).parent
+
+flake_compat_arg = ("--arg", "flake-compat", str(src / "../default.nix"))
+
+
+def copy_fixture(name: str, to: Path):
+    print(f"copying {name} to {to}")
+    shutil.copytree(src / name, to, dirs_exist_ok=True)
+
+
+def format_nix_config(vals: dict[str, str]) -> str:
+    return "\n".join(f"{name} = {value}" for (name, value) in vals.items())
+
+
+@dataclasses.dataclass
+class NixResult:
+    proc: subprocess.CompletedProcess[bytes]
+
+    def ok(self):
+        self.proc.check_returncode()
+
+    def json(self):
+        return json.loads(self.proc.stdout)
+
+
+def nix(
+    *args: str,
+    work_dir: Path | None = None,
+    command: str = "nix",
+    experimental_features: set[str] = {"nix-command", "flakes"},
+) -> NixResult:
+    # FIXME(jade): maybe should copy or reference the lix functional2 test suite?
+    config = {"experimental-features": " ".join(experimental_features)}
+    new_env = os.environ.copy()
+    new_env["NIX_CONFIG"] = (
+        new_env.get("NIX_CONFIG", "") + "\n" + format_nix_config(config)
+    )
+    print(f"$ {command}", " ".join(args))
+    res = NixResult(
+        subprocess.run(
+            [command] + list(args), env=new_env, cwd=work_dir, stdout=subprocess.PIPE
+        )
+    )
+    print(res.proc.stdout.decode())
+    return res
+
+
+def write_file(path: Path, content: str):
+    with open(path, "w") as handle:
+        handle.write(content)
diff --git a/treefmt.toml b/treefmt.toml
@@ -0,0 +1,8 @@
+[formatter.nix]
+command = "nixfmt"
+includes = ["*.nix"]
+
+[formatter.python]
+command = "ruff"
+options = ["format"]
+includes = ["*.py"]

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+source_env_if_exists .envrc.local`
	`2`	`+use flake ./dev#`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+# generated by nix`
	`2`	`+.pre-commit-config.yaml`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`{`
`2`		`- description = "Allow flakes to be used with Nix < 2.4";`
	`2`	`+ description = "Allow flakes to be evaluated from non-flake contexts";`
`3`	`3`
`4`	`4`	`outputs =`
`5`	`5`	`{ self }:`