trivionomicon/flake: rewrite broken implementation of mkSystemFlake

doctrine/default.nix

@@ -1,12 +1,16 @@
 {
+  lib ? pkgs.lib,
   pkgs,
-  namespace,
+  prefix ? "trivium",
+  namespace ? null,
 }: let
-  doctrine = {
+  doctrine =
+    {
       lib = import ./lib {inherit lib pkgs doctrine;};
-    prefix = "trivium";
+      inherit namespace prefix;
-    inherit namespace;
+    }
+    // lib.optionalAttrs (pkgs != null) {
+      inherit pkgs;
     };
-  inherit (pkgs) lib;
 in
   doctrine

doctrine/lib/default.nix

@@ -13,8 +13,11 @@
 
   closeLib = close {inherit lib;};
   closeFull = close {inherit lib pkgs doctrine;};
-in {
+in
+  {
     inherit close;
     importAll = closeLib ./import-all.nix;
+  }
+  // lib.optionalAttrs (doctrine.namespace != null) {
     mkModule = closeFull ./mk-module.nix;
-}
+  }

doctrine/lib/mk-module.nix

@@ -11,14 +11,17 @@
   requires ? [],
   prefix ? doctrine.prefix,
   namespace ? doctrine.namespace,
+  passthru ? {},
 }: let
-  optionsSet = import options {
+  optionsSet = import options (passthru
+    // {
       inherit config lib pkgs cfg name doctrine;
-  };
+    });
 
-  configSet = import configFiles.${namespace} {
+  configSet = import configFiles.${namespace} (passthru
+    // {
       inherit config lib pkgs doctrine cfg;
-  };
+    });
 
   configFiles = lib.filterAttrs (k: v: v != null) {
     inherit sys hm;

flake.nix

@@ -16,15 +16,24 @@
         "${namespace}" = builtins.removeAttrs overlayPkgs ["override"];
       }
       // (overlayPkgs.override or {});
+
+    doctrineNoPkgs = self.lib.mkDoctrine {
+      lib = nixpkgs.lib;
+      pkgs = null;
+    };
   in
-    flake-utils.lib.eachDefaultSystem (system: {
+    flake-utils.lib.eachDefaultSystem (system: let
-      formatter = (import nixpkgs {inherit system;}).alejandra;
+      pkgs = import nixpkgs {inherit system;};
+    in {
+      formatter = pkgs.alejandra;
 
       packages =
         (import nixpkgs {
           inherit system;
-          overlays = [(mapOverlayOverride "local" (import ./pkgs))];
+          overlays = [(mapOverlayOverride doctrineNoPkgs.prefix (import ./pkgs))];
-        }).local;
+        }).${
+          doctrineNoPkgs.prefix
+        };
     })
     // {
       templates = let
@@ -39,33 +48,37 @@
       };
 
       overlays = let
-        overlay = mapOverlayOverride "trivium" (import ./pkgs);
+        overlay = mapOverlayOverride doctrineNoPkgs.prefix (import ./pkgs);
       in {
         default = overlay;
-        trivium = overlay;
+        ${doctrineNoPkgs.prefix} = overlay;
       };
 
       homeManagerModules.default = ./modules;
       nixosModules.default = ./modules;
 
       lib = {
+        mkDoctrine = import ./doctrine;
+
         mkSystemFlake = {
           flakes,
           system,
+          doctrinePrefix ? null,
           formatter ? "alejandra",
-          localOverlayPath ? /. + "${flakes.self}" + /pkgs,
+          paths ? {},
-          nixpkgsConfigPath ? localOverlayPath + /config,
-          nixosSourcePath ? /. + "${flakes.self}" + /sys,
-          nixosPlatformsPath ?
-            if nixosSourcePath != null
-            then nixosSourcePath + /platform
-            else null,
-          hmSourcePath ? /. + "${flakes.self}" + /home,
-          hmPlatformsPath ?
-            if hmSourcePath != null
-            then hmSourcePath + /platform
-            else null,
         }: let
+          mkDoctrine = args:
+            self.lib.mkDoctrine
+            (args
+              // optionalAttrs (doctrinePrefix != null) {
+                prefix = doctrinePrefix;
+              });
+
+          doctrineNoPkgs = mkDoctrine {
+            lib = nixpkgs.lib;
+            pkgs = null;
+          };
+
           optionalFlake = name:
             if flakes ? "${name}"
             then flakes.${name}
@@ -74,7 +87,7 @@
           requireFlake = name:
             if flakes ? "${name}"
             then flakes.${name}
-            else throw "Required flake input '${name}' is required but was not provided";
+            else throw "Required flake input '${name}' is missing";
 
           nur = optionalFlake "nur";
           nixpkgs = requireFlake "nixpkgs";
@@ -85,13 +98,21 @@
             then requireFlake "home-manager"
             else null;
 
+          pathFromSelf = path: builtins.toPath "${flakes.self}" + "/${path}";
+
+          localOverlayPath = pathFromSelf paths.localOverlay;
+          nixpkgsConfigPath = pathFromSelf paths.nixpkgsConfig;
+          nixosSourcePath = pathFromSelf paths.nixosSource;
+          nixosPlatformsPath = pathFromSelf paths.nixosPlatforms;
+          hmSourcePath = pathFromSelf paths.hmSource;
+          hmPlatformsPath = pathFromSelf paths.hmPlatforms;
+
           pkgs = importPkgs nixpkgs;
 
           importPkgs = flake:
             import flake ({
                 inherit system;
 
-                config = import ./pkgs/config nixpkgs.lib;
                 overlays = let
                   conditions = [
                     {
@@ -100,7 +121,7 @@
                     }
                     # NB: Preserve the relative order
                     {
-                      overlay = self.overlays.trivium;
+                      overlay = self.overlays.default;
                       condition = true;
                     }
                     {
@@ -111,17 +132,15 @@
                 in
                   builtins.map (cond: cond.overlay) (builtins.filter (cond: cond.condition) conditions);
               }
-              // (
+              // optionalAttrs (paths ? nixpkgsConfig) {
-                if nixpkgsConfigPath != null
-                then {
                 config = import nixpkgsConfigPath {inherit (nixpkgs) lib;};
-                }
+              });
-                else {}
-              ));
 
-          inherit (pkgs.trivium.lib) importAll;
+          inherit (pkgs) lib;
+          inherit (nixpkgs.lib) optionalAttrs; # Prevents infinite recursion
+          inherit (doctrineNoPkgs) prefix;
+          inherit (doctrineNoPkgs.lib) importAll;
         in
-          with pkgs.lib;
           {
             formatter.${system} =
               if formatter == "alejandra"
@@ -130,27 +149,32 @@
               then pkgs.nixpkgs-fmt
               else throw "Unknown formatter: '${formatter}'";
 
-              packages.${system} = pkgs.local;
+            packages.${system} = pkgs.${prefix};
 
             overlays.default = final: prev: let
               overlay =
-                  if localOverlayPath != null
+                if paths ? localOverlay
                 then import localOverlayPath
                 else (final: prev: {});
             in
-                mapOverlayOverride "local" overlay final prev
+              mapOverlayOverride prefix overlay final prev
               // optionalAttrs (unstable != null) {
                 unstable = importPkgs unstable;
               };
           }
-            // optionalAttrs (nixosSourcePath != null) {
+          // optionalAttrs (paths ? nixosSource) {
             nixosConfigurations = let
               nixosSystem = {modules}:
-                  makeOverridable nixpkgs.lib.nixosSystem {
+                lib.makeOverridable nixpkgs.lib.nixosSystem {
                   inherit modules pkgs system;
 
                   specialArgs = {
                     inherit flakes;
+
+                    doctrine = mkDoctrine {
+                      inherit pkgs;
+                      namespace = "sys";
+                    };
                   };
                 };
 
@@ -163,34 +187,31 @@
                   ];
                 };
             in
-                mapAttrs (_: hostConfig) (importAll {root = nixosPlatformsPath;});
+              lib.mapAttrs (_: hostConfig) (importAll {root = nixosPlatformsPath;});
           }
-            // optionalAttrs (hmSourcePath != null) {
+          // optionalAttrs (paths ? hmSource) {
             homeConfigurations = let
-                registry = {...}: {
-                  config.nix.registry =
-                    mapAttrs
-                    (_: value: {flake = value;})
-                    flakes;
-                };
-
               home = name: platform:
                 home-manager.lib.homeManagerConfiguration {
                   inherit pkgs;
 
                   extraSpecialArgs = {
                     inherit flakes;
+
+                    doctrine = mkDoctrine {
+                      inherit pkgs;
+                      namespace = "hm";
+                    };
                   };
 
                   modules = [
                     self.homeManagerModules.default
                     hmSourcePath
                     platform
-                      registry
                   ];
                 };
             in
-                mapAttrs home (importAll {root = hmPlatformsPath;});
+              lib.mapAttrs home (importAll {root = hmPlatformsPath;});
           };
       };
     };

modules/nix-registry/default.nix

@@ -0,0 +1,16 @@
+{
+  config,
+  lib,
+  pkgs,
+  doctrine,
+  flakes,
+  ...
+}:
+doctrine.lib.mkModule {
+  inherit config;
+  name = "nix-registry";
+  hm = ./hm.nix;
+  options = ./options.nix;
+
+  passthru = {inherit flakes;};
+}

modules/nix-registry/hm.nix

@@ -0,0 +1,23 @@
+{
+  pkgs,
+  lib,
+  cfg,
+  flakes,
+  ...
+}: let
+  registryName = name:
+    if name == "self"
+    then cfg.renameSelf
+    else name;
+
+  registryFilter = {
+    nixpkgs = true;
+    unstable = true;
+    self = cfg.renameSelf != null;
+  };
+in {
+  nix.registry =
+    lib.mapAttrs'
+    (name: value: lib.nameValuePair (registryName name) {flake = value;})
+    (lib.filterAttrs (name: _: registryFilter.${name} or cfg.allInputs) flakes);
+}

modules/nix-registry/options.nix

@@ -0,0 +1,19 @@
+{lib, ...}:
+with lib.types; {
+  hm = {
+    allInputs = mkOption {
+      type = bool;
+      default = default;
+      description = ''
+        Include all flake inputs. If false, only 'nixpkgs' and 'unstable'
+        (if available) will be added to the flake registry by default.
+      '';
+    };
+
+    renameSelf = mkOption {
+      type = nullOr str;
+      default = "self";
+      description = "Registry name to use for the 'self' input";
+    };
+  };
+}