Update evalArgs to match the new planned api

This commit is contained in:
Pacman99 2021-04-11 20:01:13 -07:00
parent 658cd2bb08
commit b7bcaea497

View File

@ -1,150 +1,229 @@
{ self, dev, nixos, inputs, ... }: { self, dev, nixos, inputs, utils, ... }:
{ args }: { args }:
let let
argOpts = with nixos.lib; { config, options, ... }: argOpts = with nixos.lib; { config, ... }:
let let
inherit (dev) os; inherit (dev) os;
inherit (config) self; inherit (config) self;
inputAttrs = with types; functionTo attrs; maybeImport = obj:
if (builtins.typeOf obj == "path") || (builtins.typeOf obj == "string") then
import obj
else
obj;
/* Custom types needed for arguments */
moduleType = with types; anything // { moduleType = with types; anything // {
inherit (submodule { }) check; inherit (submodule { }) check;
description = "valid module"; description = "valid module";
}; };
overlayType = types.anything // {
check = builtins.isFunction;
description = "valid Nixpkgs overlay";
};
systemType = types.enum (builtins.attrValues config.supportedSystems);
flakeType = with types; (addCheck attrs nixos.lib.isStorePath) // {
description = "nix flake";
};
# Applys maybeImport during merge and before check
# To simplify apply keys and improve type checking
pathTo = elemType: mkOptionType {
name = "pathTo";
description = "path that evaluates to a(n) ${elemType.name}";
check = x: elemType.check (maybeImport x);
merge = loc: defs:
(mergeDefinitions loc elemType (map
(x: {
inherit (x) file;
value = maybeImport x.value;
})
defs)).mergedValue;
getSubOptions = elemType.getSubOptions;
getSubModules = elemType.getSubModules;
substSubModules = m: pathTo (elemType.substSubModules m);
};
/* Submodules needed for API containers */
channelsModule = {
options = with types; {
input = mkOption {
type = flakeType;
default = inputs.nixos;
description = ''
nixpkgs flake input to use for this channel
'';
};
overlays = mkOption {
type = pathTo (listOf overlayType);
default = [ ];
description = ''
overlays to apply to this channel
these will get exported under the 'overlays' flake output as <channel>/<name>
'';
};
externalOverlays = mkOption {
type = pathTo (listOf overlayType);
default = [ ];
description = ''
overlays to apply to the channel that don't get exported to the flake output
useful to include overlays from inputs
'';
};
config = mkOption {
type = pathTo attrs;
default = { };
description = ''
nixpkgs config for this channel
'';
};
};
};
configModule = { name, ... }: {
options = with types; {
system = mkOption {
type = systemType;
default = "x86_64-linux";
description = ''
system for this config
'';
};
channelName = mkOption {
type = types.enum (builtins.attrValues self.channels);
default = "nixpkgs";
description = ''
Channel this config should follow
'';
};
modules = mkOption {
type = pathTo moduleType;
default = [ ];
description = ''
The configuration for this config
'';
};
externalmodules = mkOption {
type = pathTo moduleType;
default = [ ];
description = ''
The configuration for this config
'';
};
};
};
# Home-manager's configs get exported automatically from nixos.hosts
# So there is no need for a config options in the home namespace
# This is only needed for nixos
includeConfigsModule = {
options = with types; {
configDefaults = mkOption {
type = submodule configModule;
default = { };
description = ''
defaults for all configs
'';
};
configs = mkOption {
type = pathTo (attrsOf (submodule configModule));
default = { };
description = ''
configurations to include in the ${name}Configurations output
'';
};
};
};
# Options to import: modules, profiles, suites
importsModule = { name, ... }: {
options = with types; {
modules = mkOption {
type = pathTo (listOf moduleType);
default = [ ];
apply = dev.pathsToImportedAttrs;
description = ''
list of modules to include in confgurations and export in '${name}Modules' output
'';
};
externalModules = mkOption {
type = pathTo (listOf moduleType);
default = [ ];
apply = dev.pathsToImportedAttrs;
description = ''
list of modules to include in confguration but these are not exported to the '${name}Modules' output
'';
};
profiles = mkOption {
type = path;
default = "${self}/profiles";
defaultText = "\${self}/profiles";
apply = x: os.mkProfileAttrs (toString x);
description = "path to profiles folder that can be collected into suites";
};
suites = mkOption {
type = pathTo (functionTo attrs);
default = _: { };
apply = suites: os.mkSuites {
inherit suites;
inherit (config) profiles;
};
description = ''
Function with the input of 'profiles' that returns an attribute set
with the suites for this config system.
These can be accessed through the 'suites' special argument.
'';
};
};
};
in in
{ {
options = with types; { options = with types; {
self = mkOption { self = mkOption {
type = addCheck attrs nixos.lib.isStorePath; type = flakeType;
description = "The flake to create the devos outputs for"; description = "The flake to create the devos outputs for";
}; };
hosts = mkOption { supportedSystems = mkOption {
type = path; type = listOf str;
default = "${self}/hosts"; default = utils.lib.defaultSystems;
defaultText = "\${self}/hosts";
apply = toString;
description = '' description = ''
Path to directory containing host configurations that will be exported The systems supported by this flake
to the 'nixosConfigurations' output.
''; '';
}; };
packages = mkOption { channels =
# functionTo changes arg names which breaks flake check
type = types.anything // {
check = builtins.isFunction;
description = "Nixpkgs overlay";
};
default = (final: prev: { });
defaultText = "(final: prev: {})";
description = ''
Overlay for custom packages that will be included in treewide 'pkgs'.
This should follow the standard nixpkgs overlay format - two argument function
that returns an attrset.
These packages will be exported to the 'packages' and 'legacyPackages' outputs.
'';
};
modules = mkOption {
type = listOf moduleType;
default = [ ];
apply = dev.pathsToImportedAttrs;
description = ''
list of modules to include in confgurations and export in 'nixosModules' output
'';
};
userModules = mkOption {
type = listOf moduleType;
default = [ ];
apply = dev.pathsToImportedAttrs;
description = ''
list of modules to include in home-manager configurations and export in
'homeModules' output
'';
};
profiles = mkOption {
type = path;
default = "${self}/profiles";
defaultText = "\${self}/profiles";
apply = x: os.mkProfileAttrs (toString x);
description = "path to profiles folder that can be collected into suites";
};
userProfiles = mkOption {
type = path;
default = "${self}/users/profiles";
defaultText = "\${self}/users/profiles";
apply = x: os.mkProfileAttrs (toString x);
description = "path to user profiles folder that can be collected into userSuites";
};
suites =
let let
defaults = { user = { }; system = { }; }; default = {
in nixpkgs = {
mkOption { input = inputs.nixos;
type = inputAttrs; };
default = { ... }: defaults;
defaultText = "{ user = {}; system = {}; }";
apply = suites: defaults // os.mkSuites {
inherit suites;
inherit (config) profiles users userProfiles;
};
description = ''
Function with inputs 'users' and 'profiles' that returns attribute set
with user and system suites. The former for Home Manager and the latter
for nixos configurations.
These can be accessed through the 'suites' specialArg in each config system.
'';
};
users = mkOption {
type = path;
default = "${self}/users";
defaultText = "\${self}/users";
apply = x: os.mkProfileAttrs (toString x);
description = ''
path to folder containing profiles that define system users
'';
};
extern =
let
defaults = {
modules = [ ];
overlays = [ ];
specialArgs = { };
userModules = [ ];
userSpecialArgs = { };
}; };
in in
mkOption { mkOption {
type = inputAttrs; type = attrsOf (submodule channelsModule);
default = { ... }: defaults; inherit default;
defaultText = '' apply = x: default // x;
{ modules = []; overlays = []; specialArgs = []; userModules = []; userSpecialArgs = []; }
'';
# So unneeded extern attributes can safely be deleted
apply = x: defaults // (x { inputs = inputs // self.inputs; });
description = '' description = ''
Function with argument 'inputs' that contains all devos and ''${self}'s inputs. nixpkgs channels to create
The function should return an attribute set with modules, overlays, and
specialArgs to be included across nixos and home manager configurations.
Only attributes that are used should be returned.
''; '';
}; };
overlays = mkOption { nixos = mkOption {
type = path; type = submodule [ includeConfigsModule importsModule ];
default = "${self}/overlays"; default = { };
defaultText = "\${self}/overlays";
apply = x: dev.pathsToImportedAttrs (dev.pathsIn (toString x));
description = '' description = ''
path to folder containing overlays which will be applied to pkgs and exported in hosts, modules, suites, and profiles for nixos
the 'overlays' output
''; '';
}; };
overrides = mkOption rec { home = mkOption {
type = attrs; type = submodule importsModule;
default = { modules = [ ]; disabledModules = [ ]; packages = _: _: _: { }; }; default = { };
defaultText = "{ modules = []; disabledModules = []; packages = {}; }"; description = ''
apply = x: default // x; hosts, modules, suites, and profiles for home-manager
description = "attrset of packages and modules that will be pulled from nixpkgs master"; '';
}; };
}; };
}; };