init

lib/attrs.nix

@@ -0,0 +1,25 @@
+{lib, ...}: let
+  inherit (lib.lists) any count;
+  inherit (lib.attrsets) filterAttrs listToAttrs mapAttrs' mapAttrsToList;
+in rec {
+  # attrsToList
+  attrsToList = attrs:
+    mapAttrsToList (name: value: {inherit name value;}) attrs;
+
+  # mapFilterAttrs ::
+  #   (name -> value -> bool)
+  #   (name -> value -> { name = any; value = any; })
+  #   attrs
+  mapFilterAttrs = pred: f: attrs: filterAttrs pred (mapAttrs' f attrs);
+
+  # Generate an attribute set by mapping a function over a list of values.
+  genAttrs' = values: f: listToAttrs (map f values);
+
+  # anyAttrs :: (name -> value -> bool) attrs
+  anyAttrs = pred: attrs:
+    any (attr: pred attr.name attr.value) (attrsToList attrs);
+
+  # countAttrs :: (name -> value -> bool) attrs
+  countAttrs = pred: attrs:
+    count (attr: pred attr.name attr.value) (attrsToList attrs);
+}

lib/default.nix

@@ -0,0 +1,20 @@
+{ inputs, lib, pkgs, ... }:
+
+  let
+    inherit (lib.attrsets) attrValues;
+    inherit (lib.fixedPoints) makeExtensible;
+    inherit (lib.lists) foldr;
+    inherit (modules) mapModules;
+
+    modules = import ./modules.nix {
+      inherit lib;
+      self.attrs = import ./attrs.nix {
+      	inherit lib;
+      	self = {};
+      };
+    };
+    mylib =
+      makeExtensible (self:
+        mapModules ./. (file: import file {inherit self lib pkgs inputs;}));
+  in 
+    mylib.extend (self: super: foldr (a: b: a // b) {} (attrValues super))

lib/modules.nix

@@ -0,0 +1,43 @@
+{
+  lib,
+  self,
+  ...
+}: let
+  inherit (builtins) attrValues readDir pathExists concatLists;
+  inherit (lib.attrsets) mapAttrsToList filterAttrs nameValuePair;
+  inherit (lib.strings) hasPrefix hasSuffix removeSuffix;
+  inherit (lib.trivial) id;
+  inherit (self.attrs) mapFilterAttrs;
+in rec {
+  mapModules = dir: fn:
+    mapFilterAttrs (n: v: v != null && !(hasPrefix "_" n)) (n: v: let
+      path = "${toString dir}/${n}";
+    in
+      if v == "directory" && pathExists "${path}/default.nix"
+      then nameValuePair n (fn path)
+      else if v == "regular" && n != "default.nix" && hasSuffix ".nix" n
+      then nameValuePair (removeSuffix ".nix" n) (fn path)
+      else nameValuePair "" null) (readDir dir);
+
+  mapModules' = dir: fn: attrValues (mapModules dir fn);
+
+  mapModulesRec = dir: fn:
+    mapFilterAttrs (n: v: v != null && !(hasPrefix "_" n)) (n: v: let
+      path = "${toString dir}/${n}";
+    in
+      if v == "directory"
+      then nameValuePair n (mapModulesRec path fn)
+      else if v == "regular" && n != "default.nix" && hasSuffix ".nix" n
+      then nameValuePair (removeSuffix ".nix" n) (fn path)
+      else nameValuePair "" null) (readDir dir);
+
+  mapModulesRec' = dir: fn: let
+    dirs =
+      mapAttrsToList (k: _: "${dir}/${k}")
+      (filterAttrs (n: v: v == "directory" && !(hasPrefix "_" n))
+        (readDir dir));
+    files = attrValues (mapModules dir id);
+    paths = files ++ concatLists (map (d: mapModulesRec' d id) dirs);
+  in
+    map fn paths;
+}

lib/nixos.nix

@@ -0,0 +1,35 @@
+{
+  inputs,
+  lib,
+  pkgs,
+  self,
+  ...
+}: let
+  inherit (inputs.nixpkgs.lib) nixosSystem;
+  inherit (builtins) baseNameOf elem;
+  inherit (lib.attrsets) filterAttrs;
+  inherit (lib.modules) mkDefault;
+  inherit (lib.strings) removeSuffix;
+  inherit (self.modules) mapModules;
+in rec {
+  mkHost = path: attrs @ {system ? "x86_64-linux", ...}:
+    nixosSystem {
+      inherit system;
+
+      specialArgs = {inherit lib inputs system;};
+
+      modules = [
+        {
+          nixpkgs.pkgs = pkgs;
+          networking.hostName =
+            mkDefault (removeSuffix ".nix" (baseNameOf path));
+        }
+        (filterAttrs (n: v: !elem n ["system"]) attrs)
+        ../. # /default.nix
+        (import path)
+      ];
+    };
+
+  mapHosts = dir: attrs @ {system ? system, ...}:
+    mapModules dir (hostPath: mkHost hostPath attrs);
+}