From a7690e35d05e82cd2cd0e0175ccc3655807f102a Mon Sep 17 00:00:00 2001
From: DavHau <hsngrmpf+github@gmail.com>
Date: Sun, 5 Nov 2023 10:20:09 +0700
Subject: [PATCH] flake-compat: vendor + customize

modified to fix laziness issue in defaultNix
---
 default.nix                |  11 +-
 dev-flake/default.nix      |  10 +-
 dev-flake/flake-compat.nix | 291 +++++++++++++++++++++++++++++++++++++
 3 files changed, 293 insertions(+), 19 deletions(-)
 create mode 100644 dev-flake/flake-compat.nix

diff --git a/default.nix b/default.nix
index d5145f2a..e1863b65 100644
--- a/default.nix
+++ b/default.nix
@@ -2,15 +2,7 @@
 let
   flake =
     import
-    (
-      let
-        lock = builtins.fromJSON (builtins.readFile ./dev-flake/flake.lock);
-      in
-        fetchTarball {
-          url = "https://github.com/edolstra/flake-compat/archive/${lock.nodes.flake-compat.locked.rev}.tar.gz";
-          sha256 = lock.nodes.flake-compat.locked.narHash;
-        }
-    )
+    ./dev-flake/flake-compat.nix
     {src = ./.;};
 in
   flake.defaultNix
@@ -18,4 +10,3 @@ in
   // {
     __functor = defaultNix: inputs: defaultNix.overrideInputs inputs;
   }
-
diff --git a/dev-flake/default.nix b/dev-flake/default.nix
index 3fc972bc..88e84d09 100644
--- a/dev-flake/default.nix
+++ b/dev-flake/default.nix
@@ -2,15 +2,7 @@
 let
   flake =
     import
-    (
-      let
-        lock = builtins.fromJSON (builtins.readFile ./flake.lock);
-      in
-        fetchTarball {
-          url = "https://github.com/edolstra/flake-compat/archive/${lock.nodes.flake-compat.locked.rev}.tar.gz";
-          sha256 = lock.nodes.flake-compat.locked.narHash;
-        }
-    )
+    ./flake-compat.nix
     {src = ./.;};
 in
   flake.defaultNix
diff --git a/dev-flake/flake-compat.nix b/dev-flake/flake-compat.nix
new file mode 100644
index 00000000..40e1a59a
--- /dev/null
+++ b/dev-flake/flake-compat.nix
@@ -0,0 +1,291 @@
+# copied from github:nix-community/flake-compat/pull/4/head
+# + modified to fix laziness issue in defaultNix
+# Compatibility function to allow flakes to be used by
+# non-flake-enabled Nix versions. Given a source tree containing a
+# 'flake.nix' and 'flake.lock' file, it fetches the flake inputs and
+# calls the flake's 'outputs' function. It then returns an attrset
+# containing 'defaultNix' (to be used in 'default.nix'), 'shellNix'
+# (to be used in 'shell.nix').
+{
+  src,
+  system ? builtins.currentSystem or "unknown-system",
+}: let
+  makeFlakeCompat = impureOverrides: let
+    id = x: x;
+    overrideWrap' = fn: set: set // {overrideInputs = ov: fn (makeFlakeCompat ov);};
+    overrideWrap = overrideWrap' id;
+    lockFilePath = src + "/flake.lock";
+
+    lockFile = builtins.fromJSON (builtins.readFile lockFilePath);
+
+    fetchTree = info:
+      if info.type == "github"
+      then {
+        outPath =
+          fetchTarball
+          (
+            {url = "https://api.${info.host or "github.com"}/repos/${info.owner}/${info.repo}/tarball/${info.rev}";}
+            // (
+              if info ? narHash
+              then {sha256 = info.narHash;}
+              else {}
+            )
+          );
+        rev = info.rev;
+        shortRev = builtins.substring 0 7 info.rev;
+        lastModified = info.lastModified;
+        lastModifiedDate = formatSecondsSinceEpoch info.lastModified;
+        narHash = info.narHash;
+      }
+      else if info.type == "git"
+      then
+        {
+          outPath =
+            builtins.fetchGit
+            (
+              {url = info.url;}
+              // (
+                if info ? rev
+                then {inherit (info) rev;}
+                else {}
+              )
+              // (
+                if info ? ref
+                then {inherit (info) ref;}
+                else {}
+              )
+              // (
+                if info ? submodules
+                then {inherit (info) submodules;}
+                else {}
+              )
+            );
+          lastModified = info.lastModified;
+          lastModifiedDate = formatSecondsSinceEpoch info.lastModified;
+          narHash = info.narHash;
+        }
+        // (
+          if info ? rev
+          then {
+            rev = info.rev;
+            shortRev = builtins.substring 0 7 info.rev;
+          }
+          else {}
+        )
+      else if info.type == "path"
+      then {
+        outPath = builtins.path {
+          path =
+            if builtins.substring 0 1 info.path != "/"
+            then src + ("/" + info.path)
+            else info.path;
+        };
+        narHash = info.narHash;
+      }
+      else if info.type == "tarball"
+      then {
+        outPath =
+          fetchTarball
+          (
+            {inherit (info) url;}
+            // (
+              if info ? narHash
+              then {sha256 = info.narHash;}
+              else {}
+            )
+          );
+      }
+      else if info.type == "gitlab"
+      then {
+        inherit (info) rev narHash lastModified;
+        outPath =
+          fetchTarball
+          (
+            {url = "https://${info.host or "gitlab.com"}/api/v4/projects/${info.owner}%2F${info.repo}/repository/archive.tar.gz?sha=${info.rev}";}
+            // (
+              if info ? narHash
+              then {sha256 = info.narHash;}
+              else {}
+            )
+          );
+        shortRev = builtins.substring 0 7 info.rev;
+      }
+      else
+        # FIXME: add Mercurial, tarball inputs.
+        throw "flake input has unsupported input type '${info.type}'";
+
+    callLocklessFlake = flakeSrc: let
+      flake = import (flakeSrc + "/flake.nix");
+      outputs = flakeSrc // (flake.outputs {self = outputs;});
+    in
+      outputs;
+
+    rootSrc = let
+      # Try to clean the source tree by using fetchGit, if this source
+      # tree is a valid git repository.
+      tryFetchGit = src:
+        if isGit && !isShallow
+        then let
+          res = builtins.fetchGit src;
+        in
+          if res.rev == "0000000000000000000000000000000000000000"
+          then removeAttrs res ["rev" "shortRev"]
+          else res
+        else {outPath = src;};
+      # NB git worktrees have a file for .git, so we don't check the type of .git
+      isGit = builtins.pathExists (src + "/.git");
+      isShallow = builtins.pathExists (src + "/.git/shallow");
+    in
+      {
+        lastModified = 0;
+        lastModifiedDate = formatSecondsSinceEpoch 0;
+      }
+      // (
+        if src ? outPath
+        then src
+        else tryFetchGit src
+      );
+
+    nameValuePair = name: value: {inherit name value;};
+    mapAttrs' =
+      # A function, given an attribute's name and value, returns a new `nameValuePair`.
+      f:
+      # Attribute set to map over.
+      set:
+        builtins.listToAttrs (map (attr: f attr set.${attr}) (builtins.attrNames set));
+
+    # Format number of seconds in the Unix epoch as %Y%m%d%H%M%S.
+    formatSecondsSinceEpoch = t: let
+      rem = x: y: x - x / y * y;
+      days = t / 86400;
+      secondsInDay = rem t 86400;
+      hours = secondsInDay / 3600;
+      minutes = (rem secondsInDay 3600) / 60;
+      seconds = rem t 60;
+
+      # Courtesy of https://stackoverflow.com/a/32158604.
+      z = days + 719468;
+      era =
+        (
+          if z >= 0
+          then z
+          else z - 146096
+        )
+        / 146097;
+      doe = z - era * 146097;
+      yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
+      y = yoe + era * 400;
+      doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+      mp = (5 * doy + 2) / 153;
+      d = doy - (153 * mp + 2) / 5 + 1;
+      m =
+        mp
+        + (
+          if mp < 10
+          then 3
+          else -9
+        );
+      y' =
+        y
+        + (
+          if m <= 2
+          then 1
+          else 0
+        );
+
+      pad = s:
+        if builtins.stringLength s < 2
+        then "0" + s
+        else s;
+    in "${toString y'}${pad (toString m)}${pad (toString d)}${pad (toString hours)}${pad (toString minutes)}${pad (toString seconds)}";
+
+    rootOverrides =
+      mapAttrs'
+      (input: lockKey: nameValuePair lockKey (impureOverrides.${input} or null))
+      lockFile.nodes.${lockFile.root}.inputs;
+
+    allNodes =
+      builtins.mapAttrs
+      (
+        key: node: let
+          sourceInfo =
+            if key == lockFile.root
+            then rootSrc
+            else if rootOverrides.${key} or null != null
+            then {
+              type = "path";
+              outPath = rootOverrides.${key};
+              narHash = throw "narHash unimplemented for impureOverride";
+            }
+            else fetchTree (node.info or {} // removeAttrs node.locked ["dir"]);
+
+          subdir =
+            if key == lockFile.root
+            then ""
+            else node.locked.dir or "";
+
+          flake = import (sourceInfo
+            + (
+              if subdir != ""
+              then "/"
+              else ""
+            )
+            + subdir
+            + "/flake.nix");
+
+          inputs =
+            builtins.mapAttrs
+            (_inputName: inputSpec: allNodes.${resolveInput inputSpec})
+            (node.inputs or {});
+
+          # Resolve a input spec into a node name. An input spec is
+          # either a node name, or a 'follows' path from the root
+          # node.
+          resolveInput = inputSpec:
+            if builtins.isList inputSpec
+            then getInputByPath lockFile.root inputSpec
+            else inputSpec;
+
+          # Follow an input path (e.g. ["dwarffs" "nixpkgs"]) from the
+          # root node, returning the final node.
+          getInputByPath = nodeName: path:
+            if path == []
+            then nodeName
+            else
+              getInputByPath
+              # Since this could be a 'follows' input, call resolveInput.
+              (resolveInput lockFile.nodes.${nodeName}.inputs.${builtins.head path})
+              (builtins.tail path);
+
+          outputs = flake.outputs (inputs // {self = result;});
+
+          result =
+            outputs
+            // sourceInfo
+            // {
+              inherit inputs;
+              inherit outputs;
+              inherit sourceInfo;
+              _type = "flake";
+            };
+        in
+          if node.flake or true
+          then assert builtins.isFunction flake.outputs; result
+          else sourceInfo
+      )
+      lockFile.nodes;
+
+    result =
+      if !(builtins.pathExists lockFilePath)
+      then callLocklessFlake rootSrc
+      else if lockFile.version >= 5 && lockFile.version <= 7
+      then allNodes.${lockFile.root}
+      else throw "lock file '${lockFilePath}' has unsupported version ${toString lockFile.version}";
+  in
+    builtins.mapAttrs (key: attr: overrideWrap' (res: res.${key}) attr)
+    {
+      defaultNix =
+        builtins.removeAttrs result ["__functor"];
+    };
+in
+  makeFlakeCompat {}