auxolotl/labs
22
8
Fork 4
Code Issues 1 Pull requests 3 Actions Packages Projects Releases Wiki Activity

Compare commits

base: auxolotl:feat/portable-submodules
Branches Tags
auxolotl:main
auxolotl:feat/portable-submodules
auxolotl:feat/cross
auxolotl:feat/transient-deps
auxolotl:feat/x86-64_linux
..
compare: auxolotl:main
Branches Tags
auxolotl:feat/portable-submodules
auxolotl:main
auxolotl:feat/cross
auxolotl:feat/transient-deps
auxolotl:feat/x86-64_linux

No commits in common. "feat/portable-submodules" and "main" have entirely different histories.
feat/porta ... main

2 changed files with 1 additions and 159 deletions
Show stats Expand all files Collapse all files

111
lib/src/types/default.nix
View file

@ -916,117 +916,6 @@ lib: {
}; };
}; };
}; };
## Create a type from a submodule which can be used in multiple parts of the configuration.
##
## @type { module :: Module, name? :: String, description? :: String } -> Attrs
portable =
{ name ? "PortableSubmodule"
, description ? "portable submodule"
, module
,
}:
let
normalize =
value:
if builtins.isFunction value || builtins.isList value then
value
else if value ? __modules__ then
value.__modules__
else
{ config = value; };
initial = lib.types.create {
name = "PortableSubmoduleInitial";
description = "initial portable submodule value";
check = value: builtins.isFunction value || builtins.isAttrs value || builtins.isList value;
merge =
location: definitions:
let
normalized = builtins.map (definition: lib.lists.from.any (normalize definition.value)) definitions;
in
builtins.concatLists normalized;
};
base = { config }: {
options = {
__modules__ = lib.options.create {
description = "User specified modules to be evaluated.";
type = lib.types.list.of (initial // { merge = lib.options.merge.one; });
internal = true;
default.value = [ ];
};
extend = lib.options.create {
description = "Extend the submodule configuration.";
type = lib.types.function lib.types.raw;
internal = true;
writable = false;
default.value = module:
let
normalized =
if builtins.isList module then module
else if builtins.isFunction module || module ? config then
[ module ]
else [{ config = module; }];
modules = config.__modules__ ++ normalized;
result = lib.modules.run {
modules = [
module
base
{ config.__modules__ = modules; }
] ++ modules;
};
in
result.config;
};
};
};
transform = location: value:
let
modules = lib.lists.from.any (normalize value);
result = lib.modules.run {
prefix = location;
modules = [
module
base
{ config.__modules__ = modules; }
] ++ modules;
};
in
result.config;
final = lib.types.raw // {
merge = location: definitions:
let
modules = lib.lists.flatten (
builtins.map (definition: normalize definition.value) definitions
);
result = lib.modules.run {
prefix = location;
modules = [
module
base
{ config.__modules__ = modules; }
] ++ modules;
};
in
result.config;
};
type = lib.types.coerceWithLocation initial transform final;
in
type // {
inherit name description;
children = type.children // {
inherit module base;
};
};
}; };
deferred = { deferred = {

49
lib/src/types/default.test.nix
View file

@ -1,51 +1,4 @@
let let
lib = import ./../default.nix; lib = import ./../default.nix;
in in
{ { }
"PortableSubmodule" = {
"is portable" =
let
submodule = { config }: {
options = {
primitive = lib.options.create {
type = lib.types.string;
default.value = "<default>";
};
computed = lib.options.create {
type = lib.types.string;
default.value = "computed: ${config.primitive}";
};
};
};
option = lib.options.create {
default.value = { };
type = lib.types.submodules.portable {
module = submodule;
};
};
moduleA = {
options.a = option;
};
moduleB = { config }: {
options.b = option;
config.b = config.a;
};
moduleC = {
config.b.primitive = "custom";
};
result = lib.modules.run {
modules = [
moduleA
moduleB
moduleC
];
};
in
result.config.b.computed == "computed: custom";
};
}