diff --git a/flake.nix b/flake.nix
index d6c5150..bb64e1c 100644
--- a/flake.nix
+++ b/flake.nix
@@ -3,6 +3,7 @@
description = "NixOS Configuration";
inputs = {
+ # {{{
nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.11";
# ^^^^^^^^^^^^^ this part is optional
nixpkgs-unstable.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
@@ -103,7 +104,7 @@
inputs.nixpkgs.follows = "nixpkgs";
inputs.systems.follows = "systems";
};
- };
+ }; # }}}
outputs = {
self,
@@ -116,6 +117,7 @@
self,
config,
lib,
+ nixfiles-lib,
...
} @ flakeArgs: {
# flake-parts imports
@@ -129,12 +131,86 @@
# flake-parts systems (still uses nix-systems)
systems = import inputs.systems;
+ # expose vars to nix repl
debug = lib.mkDefault true;
+ nixfiles = {
+ vars = {
+ ### Configuration
+ # My username
+ username = "nullbite";
+ # My current timezone for any mobile devices (i.e., my laptop)
+ mobileTimeZone = "America/New_York";
+ };
+
+ common.overlays = let
+ nix-minecraft-patched-overlay = let
+ normal = inputs.nix-minecraft-upstream.overlays.default;
+ quilt = inputs.nix-minecraft.overlays.default;
+ in
+ lib.composeExtensions
+ normal
+ (final: prev: let
+ x = quilt final prev;
+ in {
+ inherit (x) quiltServers quilt-server;
+ minecraftServers = prev.minecraftServers // x.quiltServers;
+ });
+
+ packagesOverlay = final: prev: let
+ packages = import ./pkgs {inherit (prev) pkgs;};
+ in {
+ inherit (packages) mopidy-autoplay google-fonts;
+ atool-wrapped = packages.atool;
+ };
+ in [
+ packagesOverlay
+ # various temporary fixes that automatically revert
+ self.overlays.mitigations
+
+ # auto backports from nixpkgs unstable
+ self.overlays.backports
+
+ # modpacks (keeps modpack version in sync between hosts so i can reverse
+ # proxy create track map because it's broken)
+ self.overlays.modpacks
+
+ inputs.hyprwm-contrib.overlays.default
+ inputs.rust-overlay.overlays.default
+ inputs.nixfiles-assets.overlays.default
+ nix-minecraft-patched-overlay
+ ];
+
+ systems = {
+ slab.system = "x86_64-linux";
+ nullbox.system = "x86_64-linux";
+ rpi4.system = "aarch64-linux";
+
+ nixos-wsl = {
+ system = "x86_64-linux";
+ wsl = true;
+ };
+
+ # for eval testing
+ rpi4-x86_64 = {
+ system = "x86_64-linux";
+ name = "rpi4";
+ modules = [
+ {
+ nixpkgs.hostPlatform = "x86_64-linux";
+ }
+ ];
+ };
+ }; # end systems
+ };
+
flake = let
# {{{
+ inherit (nixfiles-lib.flake-legacy) mkSystem mkWSLSystem mkISOSystem mkHome;
inherit (inputs) nixpkgs nixpkgs-unstable;
inherit (self) outputs;
+ inherit (config.nixfiles.vars) username mobileTimeZone;
+
# inputs is already defined
lib = nixpkgs.lib;
systems = ["x86_64-linux" "aarch64-linux"];
@@ -176,260 +252,14 @@
nix-minecraft-patched-overlay
];
- ### Configuration
- # My username
- username = "nullbite";
- # My current timezone for any mobile devices (i.e., my laptop)
- mobileTimeZone = "Europe/Amsterdam";
-
- # Variables to be passed to NixOS modules in the vars attrset
- vars = {
- inherit username mobileTimeZone self;
- };
-
- # funciton to generate packages for each system
+ # function to generate packages for each system
eachSystem = lib.genAttrs (import inputs.systems);
- # This function produces a module that adds the home-manager module to the
- # system and configures the given module to the user's Home Manager
- # configuration
- homeManagerInit = let
- _username = username;
- _nixpkgs = nixpkgs;
- in
- {
- system,
- nixpkgs ? _nixpkgs, # this is so modules can know which flake the system is using
- home-manager ? inputs.home-manager,
- username ? _username,
- module ? _: {},
- rootModule ? (import ./home/root.nix),
- userModules ? {
- ${username} = [module];
- root = [rootModule];
- },
- stateVersion,
- }: {
- config,
- lib,
- pkgs,
- ...
- }: let
- mapUserModules = lib.attrsets.mapAttrs (user: modules: {...}: {
- imports =
- [
- ./home
- ]
- ++ modules;
- config = {
- home = {inherit stateVersion;};
- };
- });
- users = mapUserModules userModules;
- in {
- imports = [
- home-manager.nixosModules.home-manager
- ];
-
- home-manager = {
- useGlobalPkgs = true;
- useUserPackages = true;
- backupFileExtension = "hm.bak";
- inherit users;
- extraSpecialArgs = {
- inherit inputs outputs vars nixpkgs home-manager;
- };
- };
- };
-
- # TODO rewrite this so it follows the same wrapper pattern as
- # mkHome This function produces a nixosSystem which imports
- # configuration.nix and a Home Manager home.nix for the given user
- # from ./hosts/${hostname}/
- #
- # nevermind i am migrating everything to flake-parts, i'm glad i
- # never got around to this. i think the module system takes care of
- # whatever the fuck godforsaken use-case i had for rewriting this
- # (more ergonomic and/or default arguments or something).
- mkSystemN = let
- _username = username;
- _overlays = overlays;
- in
- {
- nixpkgs ? inputs.nixpkgs,
- home-manager ? inputs.home-manager,
- username ? _username,
- entrypoint ? ./system,
- modules ? [],
- stateVersion ? null,
- config ? {},
- overlays ? _overlays,
- system,
- ...
- } @ args: let
- _modules =
- [entrypoint config]
- ++ modules
- ++ [
- {
- nixpkgs.config = {
- inherit overlays;
- allowUnfree = true;
- };
- }
- ]
- ++ lib.optional (args ? stateVersion) {config.system.stateVersion = stateVersion;};
- in
- nixpkgs.lib.nixosSystem {
- };
- mkSystem = let
- _username = username;
- _overlays = overlays;
- _nixpkgs = nixpkgs;
- in
- {
- system,
- nixpkgs ? _nixpkgs,
- home-manager ? inputs.home-manager,
- overlays ? _overlays,
- hostname,
- username ? _username,
- stateVersion,
- extraModules ? [],
- }:
- nixpkgs.lib.nixosSystem {
- inherit system;
- modules =
- [
- ./system
- ({
- pkgs,
- config,
- lib,
- ...
- } @ args: {
- # Values for every single system that would not conceivably need
- # to be made modular
- system.stateVersion = stateVersion;
- nixpkgs = {
- inherit overlays;
- config = {
- # not having the freedom to install unfree programs is unfree
- allowUnfree = true;
- };
- };
- nix.settings.experimental-features = ["nix-command" "flakes"];
- })
- ./hosts/${hostname}/configuration.nix
- (homeManagerInit {
- inherit nixpkgs home-manager;
- module = import ./hosts/${hostname}/home.nix;
- inherit username system stateVersion;
- })
- ]
- ++ extraModules;
- specialArgs = {
- inherit inputs outputs vars nixpkgs home-manager;
- };
- };
-
- mkWSLSystem = let
- _username = username;
- in
- {
- username ? _username,
- extraModules ? [],
- ...
- } @ args: let
- WSLModule = {...}: {
- imports = [
- inputs.nix-wsl.nixosModules.wsl
- ];
- wsl.enable = true;
- wsl.defaultUser = username;
- };
- override = {extraModules = extraModules ++ [WSLModule];};
- in
- mkSystem (args // override);
-
- mkISOSystem = system:
- inputs.nixpkgs-unstable.lib.nixosSystem {
- inherit system;
- modules = [
- "${inputs.nixpkgs-unstable}/nixos/modules/installer/cd-dvd/installation-cd-minimal-new-kernel-no-zfs.nix"
- ({
- config,
- pkgs,
- lib,
- ...
- }: {
- environment.systemPackages = with pkgs; [
- neovim
- gparted
- ];
- })
- ];
- };
-
# values to be passed to nixosModules and homeManagerModules wrappers
moduleInputs = {
};
-
- # Make a home-manager standalone configuration. This implementation is
- # better than mkSystem because it extends homeManagerConfiguration.
- mkHome = let
- _home-manager = inputs.home-manager;
- _nixpkgs = inputs.nixpkgs;
- _username = username;
- in
- {
- home-manager ? _home-manager,
- nixpkgs ? _nixpkgs,
- username ? _username,
- homeDirectory ? "/home/${username}",
- entrypoint ? ./home/standalone.nix,
- modules ? [],
- stateVersion ? null,
- config ? {},
- system,
- ...
- } @ args: let
- _modules =
- [entrypoint]
- ++ modules
- ++ [config]
- ++ [
- {
- config = {
- home = {
- inherit username homeDirectory;
- };
- nixpkgs.config = {
- allowUnfree = true;
- };
- };
- }
- ]
- ++ lib.optional (args ? stateVersion) {config.home.stateVersion = stateVersion;};
- in
- home-manager.lib.homeManagerConfiguration ({
- modules = _modules;
- pkgs = import nixpkgs {inherit system overlays;};
-
- extraSpecialArgs = {
- inherit inputs outputs vars nixpkgs home-manager;
-
- # this is needed because modules don't use the default arg for some reason???
- osConfig = {};
- };
- }
- // builtins.removeAttrs args
- ["system" "nixpkgs" "home-manager" "modules" "username" "homeDirectory" "stateVersion" "entrypoint" "config"]);
# }}}
in {
- # for repl debugging via :lf .
- inherit inputs vars;
-
devShells = eachSystem (system: let
pkgs = import nixpkgs-unstable {inherit system;};
in {
@@ -471,51 +301,6 @@
nixosConfigurations = {
iso = mkISOSystem "x86_64-linux";
- slab = mkSystem {
- nixpkgs = inputs.nixpkgs-unstable;
- home-manager = inputs.home-manager-unstable;
- system = "x86_64-linux";
- hostname = "slab";
- stateVersion = "23.11";
- };
-
- nullbox = mkSystem {
- nixpkgs = inputs.nixpkgs-unstable;
- home-manager = inputs.home-manager-unstable;
- system = "x86_64-linux";
- hostname = "nullbox";
- stateVersion = "23.11";
- };
-
- nixos-wsl = mkWSLSystem {
- nixpkgs = inputs.nixpkgs-unstable;
- home-manager = inputs.home-manager-unstable;
- system = "x86_64-linux";
- stateVersion = "23.11";
- hostname = "nixos-wsl";
- };
-
- # for eval testing
- rpi4-x86_64 = mkSystem {
- nixpkgs = inputs.nixpkgs-unstable;
- home-manager = inputs.home-manager-unstable;
- system = "x86_64-linux";
- stateVersion = "24.11";
- hostname = "rpi4";
- extraModules = [
- {
- nixpkgs.hostPlatform = "x86_64-linux";
- }
- ];
- };
-
- rpi4 = mkSystem {
- nixpkgs = inputs.nixpkgs-unstable;
- home-manager = inputs.home-manager-unstable;
- system = "aarch64-linux";
- stateVersion = "24.11";
- hostname = "rpi4";
- };
}; # end nixosConfigurations
homeConfigurations = {
diff --git a/flake/default.nix b/flake/default.nix
index 07448e1..b99bc33 100644
--- a/flake/default.nix
+++ b/flake/default.nix
@@ -1,6 +1,9 @@
-{ ... }:
-{
+{...}: {
imports = [
./packages.nix
+ ./home.nix
+ ./system.nix
+ ./meta.nix
+ ./overlays.nix
];
}
diff --git a/flake/home.nix b/flake/home.nix
new file mode 100644
index 0000000..c915eb0
--- /dev/null
+++ b/flake/home.nix
@@ -0,0 +1 @@
+{ ... }: { }
diff --git a/flake/meta.nix b/flake/meta.nix
new file mode 100644
index 0000000..3293185
--- /dev/null
+++ b/flake/meta.nix
@@ -0,0 +1,11 @@
+{
+ config,
+ lib,
+ ...
+}: {
+ options.nixfiles.vars = lib.mkOption {
+ description = "Global variables";
+ type = lib.types.attrs;
+ default = {};
+ };
+}
diff --git a/flake/overlays.nix b/flake/overlays.nix
new file mode 100644
index 0000000..1f38b80
--- /dev/null
+++ b/flake/overlays.nix
@@ -0,0 +1,19 @@
+{
+ config,
+ lib,
+ inputs,
+ ...
+}: let
+ overlayType = lib.mkOptionType {
+ name = "nixpkgs-overlay";
+ description = "nixpkgs overlay";
+ check = lib.isFunction;
+ merge = lib.mergeOneOption;
+ };
+in {
+ options.nixfiles.common.overlays = lib.mkOption {
+ description = "List of overlays shared between various parts of the flake.";
+ type = lib.types.listOf overlayType;
+ default = [];
+ };
+}
diff --git a/flake/system.nix b/flake/system.nix
new file mode 100644
index 0000000..5507855
--- /dev/null
+++ b/flake/system.nix
@@ -0,0 +1,248 @@
+{
+ config,
+ options,
+ lib,
+ nixfiles-lib,
+ inputs,
+ self,
+ ...
+}: let
+ cfg = config.nixfiles.systems;
+ inherit
+ (lib)
+ types
+ mkOption
+ mkIf
+ filterAttrs
+ mapAttrs
+ ;
+
+ inherit (builtins) attrNames isNull;
+
+ inherit (nixfiles-lib.flake-legacy) mkSystem mkHome mkWSLSystem mkISOSystem homeManagerInit;
+ inherit (nixfiles-lib.types) mkCheckedType;
+
+ mkConfigurationOption = systemType:
+ mkOption {
+ description = "${systemType} configuration type";
+ type = with types; nullOr mkCheckedType "configuration";
+ default = null;
+ };
+in {
+ options.nixfiles.systems = let
+ systemModule = let
+ outerConfig = config;
+ outerOptions = options;
+ in
+ {
+ name,
+ config,
+ ...
+ }: {
+ options = {
+ enable =
+ lib.mkEnableOption ""
+ // {
+ description = ''
+ Whether to install this configuration into the flake outputs.
+ '';
+ default = true;
+ };
+
+ nixpkgs = mkOption {
+ description = "nixpkgs input to build system with";
+ type = nixfiles-lib.types.flake;
+ default = inputs.nixpkgs-unstable;
+ };
+
+ extraConfig = mkOption {
+ description = ''
+ Arguments to pass to nixpkgs.lib.nixosSystem
+ '';
+ type = types.attrs;
+ default = {};
+ };
+
+ system = mkOption {
+ description = "Nix system value";
+ type = types.str;
+ example = "x86_64-linux";
+ };
+
+ modules = mkOption {
+ description = "Extra NixOS configuration modules.";
+ type = with types; listOf deferredModule;
+ default = [];
+ };
+
+ name = mkOption {
+ description = ''
+ Name of NixOS configuration. This influences the default
+ directory to load configuration from. This does *not* modify the
+ system's hostname, but should probably be set to the same value.
+ '';
+ type = lib.types.str;
+ default = name;
+ };
+
+ configRoot = mkOption {
+ description = "Path to directory containing system and home configuration modules.";
+ type = lib.types.path;
+ default = self + "/hosts/${config.name}";
+ };
+
+ configuration = mkOption {
+ description = "Path/module of main NixOS configuration.";
+ type = with types; nullOr deferredModule;
+ default = config.configRoot + "/configuration.nix";
+ };
+
+ home-manager = {
+ enable =
+ lib.mkEnableOption ""
+ // {
+ description = ''
+ Whether to enable home-manager for this configuration.
+ '';
+ default = true;
+ };
+
+ input = mkOption {
+ description = "home-manager input";
+ type = nixfiles-lib.types.flake;
+ default = inputs.home-manager-unstable;
+ };
+
+ configuration = mkOption {
+ description = "Path/module of main home-manager configuration.";
+ type = with types; nullOr deferredModule;
+ default = config.configRoot + "/home.nix";
+ };
+
+ modules = mkOption {
+ description = "Extra home-manager modules";
+ type = with types; listOf deferredModule;
+ };
+ };
+
+ wsl =
+ lib.mkEnableOption ""
+ // {
+ description = ''
+ Whether to import WSL related configuration
+ '';
+ };
+
+ result = lib.mkOption {
+ description = "Resulting system configuration";
+ type = with types; nullOr (mkCheckedType "configuration");
+ };
+ };
+
+ config = {
+ home-manager.input = lib.mkIf (config.nixpkgs == inputs.nixpkgs) (lib.mkDefault inputs.home-manager);
+
+ modules = let
+ nixfilesModule = self + "/system";
+ defaultsModule = {...}: {
+ # Values for every single system that would not conceivably need
+ # to be made modular
+
+ # this should be set in the system config
+ # system.stateVersion = stateVersion;
+ nixpkgs = {
+ inherit (outerConfig.nixfiles.common) overlays;
+ config = {
+ # not having the freedom to install unfree programs is unfree
+ allowUnfree = true;
+ };
+ };
+ # this should be on by default and there is no reason to turn it
+ # off because this flake will literally stop working otheriwse
+ nix.settings.experimental-features = ["nix-command" "flakes"];
+ };
+ wslModule = {...}: {
+ imports = [
+ inputs.nix-wsl.nixosModules.wsl
+ ];
+ wsl.enable = true;
+ wsl.defaultUser = outerConfig.nixfiles.vars.username;
+ };
+
+ homeManagerModule = let
+ homeManagerModuleInner = homeManagerInit {
+ inherit (config) nixpkgs system;
+ inherit (outerConfig.nixfiles.vars) username;
+ home-manager = config.home-manager.input;
+ module =
+ if (isNull config.home-manager.configuration)
+ then {}
+ else config.home-manager.configuration;
+ };
+ in
+ {
+ config,
+ pkgs,
+ lib,
+ ...
+ }: let
+ inheritStateVersionModule = {lib, ...}: {
+ config = {
+ home.stateVersion = lib.mkDefault config.system.stateVersion;
+ };
+ };
+ in {
+ imports = [
+ # TODO placeholder using old function
+ homeManagerModuleInner
+ ];
+
+ # previously, home-manager inherited stateVersion from nixos in
+ # a really hacky way that depended on the wrapper function.
+ # this should preserve that behavior in a much safer way by
+ # directly setting it in a module. ideally, it should probably
+ # be set manually, but I want to maintain backwards
+ # compatibility for now
+ options.home-manager.users = lib.mkOption {
+ type = with lib.types; attrsOf (submodule inheritStateVersionModule);
+ };
+ };
+ in
+ [
+ nixfilesModule
+ defaultsModule
+ ]
+ ++ lib.optional (!(isNull config.configuration)) config.configuration
+ ++ lib.optional config.home-manager.enable homeManagerModule
+ ++ lib.optional config.wsl wslModule;
+ extraConfig = {
+ inherit (config) system modules;
+ # TODO get rid of specialArgs and pass things as a module
+ specialArgs = let
+ inherit (self) outputs;
+ in {
+ inherit inputs outputs;
+ inherit (outerConfig.nixfiles) vars;
+ inherit (config) nixpkgs;
+ inherit (config.home-manager) input;
+ };
+ };
+ result = config.nixpkgs.lib.nixosSystem config.extraConfig;
+ };
+ };
+ in
+ lib.mkOption {
+ description = ''
+ NixOS system configurations
+ '';
+ type = with types; attrsOf (submodule systemModule);
+ default = {};
+ };
+
+ config = {
+ flake.nixosConfigurations = let
+ enabledSystems = filterAttrs (n: v: v.enable) cfg;
+ in
+ mapAttrs (_: v: v.result) enabledSystems;
+ };
+}
diff --git a/hosts/nixos-wsl/configuration.nix b/hosts/nixos-wsl/configuration.nix
index b9f59cd..228e40f 100644
--- a/hosts/nixos-wsl/configuration.nix
+++ b/hosts/nixos-wsl/configuration.nix
@@ -47,5 +47,8 @@
device = "/";
options = [ "bind" ];
};
+
+ # standard disclaimer don't change this for any reason whatsoever
+ system.stateVersion = "23.11";
};
}
diff --git a/lib/nixfiles/default.nix b/lib/nixfiles/default.nix
index 70a6430..89d2efd 100644
--- a/lib/nixfiles/default.nix
+++ b/lib/nixfiles/default.nix
@@ -25,3 +25,7 @@ in
// lib.optionalAttrs (attrs ? pkgs) {
minecraft = (import ./minecraft.nix) attrs';
}
+ # modules that rely on `self` (flake)
+ // lib.optionalAttrs (attrs ? self) {
+ flake-legacy = (import ./flake-legacy.nix) attrs';
+ }
diff --git a/lib/nixfiles/flake-legacy.nix b/lib/nixfiles/flake-legacy.nix
new file mode 100644
index 0000000..3d2a3e2
--- /dev/null
+++ b/lib/nixfiles/flake-legacy.nix
@@ -0,0 +1,259 @@
+{
+ self,
+ lib,
+ moduleAttrs,
+ ...
+}: let
+ inherit (moduleAttrs.config.nixfiles.common) overlays;
+
+ ### Configuration
+ # My username
+ username = "nullbite";
+ # My current timezone for any mobile devices (i.e., my laptop)
+ mobileTimeZone = "Europe/Amsterdam";
+
+ # Variables to be passed to NixOS modules in the vars attrset
+ vars = {
+ inherit username mobileTimeZone self;
+ };
+
+ # funciton to generate packages for each system
+ eachSystem = lib.genAttrs (import inputs.systems);
+
+ # values to be passed to nixosModules and homeManagerModules wrappers
+ moduleInputs = {
+ };
+ inherit (self) inputs outputs;
+ inherit (inputs) nixpkgs nixpkgs-unstable home-manager home-manager-unstable;
+in rec {
+ # This function produces a module that adds the home-manager module to the
+ # system and configures the given module to the user's Home Manager
+ # configuration
+ homeManagerInit = let
+ _username = username;
+ _nixpkgs = nixpkgs;
+ in
+ {
+ system,
+ nixpkgs ? _nixpkgs, # this is so modules can know which flake the system is using
+ home-manager ? inputs.home-manager,
+ username ? _username,
+ module ? _: {},
+ rootModule ? (import (self + "/home/root.nix")),
+ userModules ? {
+ ${username} = [module];
+ root = [rootModule];
+ },
+ stateVersion ? null,
+ }: {
+ config,
+ lib,
+ pkgs,
+ ...
+ }: let
+ mapUserModules = lib.attrsets.mapAttrs (user: modules: {lib, ...}: {
+ imports =
+ [
+ (self + "/home")
+ ]
+ ++ modules;
+ config = {
+ home = lib.mkIf (!(builtins.isNull stateVersion)) {inherit stateVersion;};
+ };
+ });
+ users = mapUserModules userModules;
+ in {
+ imports = [
+ home-manager.nixosModules.home-manager
+ ];
+
+ home-manager = {
+ useGlobalPkgs = true;
+ useUserPackages = true;
+ backupFileExtension = "hm.bak";
+ inherit users;
+ extraSpecialArgs = {
+ inherit inputs outputs vars nixpkgs home-manager;
+ };
+ };
+ };
+
+ # TODO rewrite this so it follows the same wrapper pattern as
+ # mkHome This function produces a nixosSystem which imports
+ # configuration.nix and a Home Manager home.nix for the given user
+ # from ./hosts/${hostname}/
+ #
+ # nevermind i am migrating everything to flake-parts, i'm glad i
+ # never got around to this. i think the module system takes care of
+ # whatever the fuck godforsaken use-case i had for rewriting this
+ # (more ergonomic and/or default arguments or something).
+ mkSystemN = let
+ _username = username;
+ _overlays = overlays;
+ in
+ {
+ nixpkgs ? inputs.nixpkgs,
+ home-manager ? inputs.home-manager,
+ username ? _username,
+ entrypoint ? (self + "/system"),
+ modules ? [],
+ stateVersion ? null,
+ config ? {},
+ overlays ? _overlays,
+ system,
+ ...
+ } @ args: let
+ _modules =
+ [entrypoint config]
+ ++ modules
+ ++ [
+ {
+ nixpkgs.config = {
+ inherit overlays;
+ allowUnfree = true;
+ };
+ }
+ ]
+ ++ lib.optional (args ? stateVersion) {config.system.stateVersion = stateVersion;};
+ in
+ nixpkgs.lib.nixosSystem {
+ };
+ mkSystem = let
+ _username = username;
+ _overlays = overlays;
+ _nixpkgs = nixpkgs;
+ in
+ {
+ system,
+ nixpkgs ? _nixpkgs,
+ home-manager ? inputs.home-manager,
+ overlays ? _overlays,
+ hostname,
+ username ? _username,
+ stateVersion,
+ extraModules ? [],
+ }:
+ nixpkgs.lib.nixosSystem {
+ inherit system;
+ modules =
+ [
+ (self + "/system")
+ ({
+ pkgs,
+ config,
+ lib,
+ ...
+ } @ args: {
+ # Values for every single system that would not conceivably need
+ # to be made modular
+ system.stateVersion = stateVersion;
+ nixpkgs = {
+ inherit overlays;
+ config = {
+ # not having the freedom to install unfree programs is unfree
+ allowUnfree = true;
+ };
+ };
+ nix.settings.experimental-features = ["nix-command" "flakes"];
+ })
+ (self + "/hosts/${hostname}/configuration.nix")
+ (homeManagerInit {
+ inherit nixpkgs home-manager;
+ module = import (self + "/hosts/${hostname}/home.nix");
+ inherit username system stateVersion;
+ })
+ ]
+ ++ extraModules;
+ specialArgs = {
+ inherit inputs outputs vars nixpkgs home-manager;
+ };
+ };
+
+ mkWSLSystem = let
+ _username = username;
+ in
+ {
+ username ? _username,
+ extraModules ? [],
+ ...
+ } @ args: let
+ WSLModule = {...}: {
+ imports = [
+ inputs.nix-wsl.nixosModules.wsl
+ ];
+ wsl.enable = true;
+ wsl.defaultUser = username;
+ };
+ override = {extraModules = extraModules ++ [WSLModule];};
+ in
+ mkSystem (args // override);
+
+ mkISOSystem = system:
+ inputs.nixpkgs-unstable.lib.nixosSystem {
+ inherit system;
+ modules = [
+ "${inputs.nixpkgs-unstable}/nixos/modules/installer/cd-dvd/installation-cd-minimal-new-kernel-no-zfs.nix"
+ ({
+ config,
+ pkgs,
+ lib,
+ ...
+ }: {
+ environment.systemPackages = with pkgs; [
+ neovim
+ gparted
+ ];
+ })
+ ];
+ };
+ # Make a home-manager standalone configuration. This implementation is
+ # better than mkSystem because it extends homeManagerConfiguration.
+ mkHome = let
+ _home-manager = inputs.home-manager;
+ _nixpkgs = inputs.nixpkgs;
+ _username = username;
+ in
+ {
+ home-manager ? _home-manager,
+ nixpkgs ? _nixpkgs,
+ username ? _username,
+ homeDirectory ? "/home/${username}",
+ entrypoint ? (self + "/home/standalone.nix"),
+ modules ? [],
+ stateVersion ? null,
+ config ? {},
+ system,
+ ...
+ } @ args: let
+ _modules =
+ [entrypoint]
+ ++ modules
+ ++ [config]
+ ++ [
+ {
+ config = {
+ home = {
+ inherit username homeDirectory;
+ };
+ nixpkgs.config = {
+ allowUnfree = true;
+ };
+ };
+ }
+ ]
+ ++ lib.optional (args ? stateVersion) {config.home.stateVersion = stateVersion;};
+ in
+ home-manager.lib.homeManagerConfiguration ({
+ modules = _modules;
+ pkgs = import nixpkgs {inherit system overlays;};
+
+ extraSpecialArgs = {
+ inherit inputs outputs vars nixpkgs home-manager;
+
+ # this is needed because modules don't use the default arg for some reason???
+ osConfig = {};
+ };
+ }
+ // builtins.removeAttrs args
+ ["system" "nixpkgs" "home-manager" "modules" "username" "homeDirectory" "stateVersion" "entrypoint" "config"]);
+}
diff --git a/lib/nixfiles/module.nix b/lib/nixfiles/module.nix
index 0734491..131f450 100644
--- a/lib/nixfiles/module.nix
+++ b/lib/nixfiles/module.nix
@@ -1,6 +1,10 @@
-{lib, ...}: let
+{
+ lib,
+ self,
+ ...
+} @ moduleAttrs: let
inherit (lib) types;
- nixfiles-lib = (import ./.) {inherit lib;};
+ nixfiles-lib = (import ./.) {inherit lib self moduleAttrs;};
in {
options.nixfiles.lib = lib.mkOption {
description = "nixfiles library";
diff --git a/lib/nixfiles/types.nix b/lib/nixfiles/types.nix
index b81e3bd..04f5aa8 100644
--- a/lib/nixfiles/types.nix
+++ b/lib/nixfiles/types.nix
@@ -1,13 +1,21 @@
-{ pkgs, ... }:
-let
+{pkgs, ...}: let
inherit (pkgs) lib;
inherit (lib.types) mkOptionType;
inherit (lib.options) mergeEqualOption;
-in
-{
+in {
+ mkCheckedType = type:
+ mkOptionType {
+ name = "${type}";
+ description = "Attribute set of type ${type}";
+ descriptionClass = "noun";
+ merge = mergeEqualOption;
+ check = value: value._type or "" == "${type}";
+ };
flake = mkOptionType {
- name="flake";
- description="Nix flake";
+ name = "flake";
+ description = "Nix flake";
descriptionClass = "noun";
- merge = mergeEqualOption; check = (value: value._type or "" == "flake"); };
+ merge = mergeEqualOption;
+ check = value: value._type or "" == "flake";
+ };
}