Modular, context-aware and aspect-oriented dendritic Nix configurations.
Discussions: https://oeiuwq.zulipchat.com/join/nqp26cd4kngon6mo3ncgnuap/
den.oeiuwq.com
configurations
den
dendritic
nix
aspect
oriented
Fix recursive defaults inclusion causing duplicated values on arrays. (#42)
See #40, #42.
### Changes for fix:
Our [dependencies](https://github.com/vic/den/blob/deps/modules/aspects/dependencies.nix) system is now separate from the actual aspect [definitions](https://github.com/vic/den/blob/deps/modules/aspects/definition.nix).
Added a [test](https://github.com/vic/den/blob/deps/templates/default/modules/_example/aspects.nix#L42) that checks only [one hello package](https://github.com/vic/den/blob/deps/templates/default/modules/_example/ci.nix#L100) is contributed to the config.
Basically we have more types of context now to avoid the recursion:
`{ host }` is for Host configuration (likely nixos/darwin)
`{ host, user }` is for User config (most likely homeManager)
`{ home }` is for standalone home-manager.
`{ fromUser, toHost }` is for users contributing configuration to hosts.
`{ fromHost, toUser }` is for hosts contributing to its users.
Using these more explicit contexts instead of how we previously only used `{ host, user }` for the bi-directional dependencies. Fixed this.
So basically, contexts need to be exact, `{ host, ...}` is just `{ host }`, according to `lib.functionArgs` there's no way to tell them apart.
If you look at the definition of host/user/home aspects, they only include `den.default`.
And we have some parametric defaults that add configuration depending on context,
for example, [this one](https://github.com/vic/den/blob/deps/modules/aspects/dependencies.nix#L16) just adds the host-same-class values from `den.defaults` into a host.
our `den.default` is how dependencies work via parametric functions. So, in den the argument names (the context) of configuration providers is quite important, that's how they know what kind of configuration to produce.
Here's the output of running [my fork](https://github.com/Cybolic/nix-den-double-import-demo/pull/1) of the reproduction repository:
```console
vic@nargun ~/h/nix-den-double-import-demo> nix eval --override-input den github:vic/den/deps --refresh .#.nixosConfigurations.test-host.config.users.users.test-user.packages
warning: not writing modified lock file of flake 'git+file:///home/vic/hk/nix-den-double-import-demo':
• Updated input 'den':
'github:vic/den/04dfe099cc7d4f773f4fd50bdf0571791a2e9fad?narHash=sha256-pM0/ri%2B4LPrZUIv9c8Bh4%2BRyB2VMGyChXrxyIP4mbjs%3D' (2025-11-05) → 'github:vic/den/3dfb65c872655fe0f3853a6229ceda32cd4045ed?narHash=sha256-1UUIU8nddcNTqGr2Wz3ASVXxbBIafeU/fGSelhd1GpA%3D' (2025-11-06)
trace: [ "host" ]
trace: [ "aspect-chain" "class" ]
trace: [ "fromUser" "toHost" ]
[ «derivation /nix/store/dzgpbp0vp7lj7lgj26rjgmnjicq2wf4k-hello-2.12.2.drv» ]
```
authored by
Victor Borja
and committed by
GitHub
c1a0d345
dd929700
+299
-260
+29
-93
checkmate/tests/aspect-functor.nix
+29
-93
checkmate/tests/aspect-functor.nix
···
1
1
{ lib, inputs, ... }:
2
2
let
3
-
__functor = import "${inputs.target}/nix/aspect-functor.nix" lib;
4
-
5
-
tail = out: { includes = lib.drop 1 out.includes; };
3
+
__functor = (inputs.target.lib lib inputs).parametric true;
6
4
7
5
aspect-example = {
8
6
inherit __functor;
···
51
49
];
52
50
};
53
51
54
-
flake.tests."test provider function must be returned as is" =
55
-
let
56
-
provider =
57
-
{ class, aspect-chain }:
58
-
[
59
-
class
60
-
aspect-chain
61
-
];
62
-
x = tail (
63
-
{
64
-
inherit __functor;
65
-
includes = [ provider ];
66
-
}
67
-
{ }
68
-
);
69
-
in
70
-
{
71
-
expr = (builtins.elemAt x.includes 0) {
72
-
class = "foo";
73
-
aspect-chain = [ ];
74
-
};
75
-
expected = [
76
-
"foo"
77
-
[ ]
78
-
];
79
-
};
80
-
81
-
flake.tests."test functor first element is foo" = {
82
-
expr =
83
-
let
84
-
first = builtins.elemAt (aspect-example { }).includes 0;
85
-
in
86
-
(first {
87
-
class = "nixos";
88
-
aspect-chain = [ ];
89
-
});
90
-
expected = {
91
-
nixos.foo = 99;
92
-
};
93
-
};
94
-
95
52
flake.tests."test functor applied with empty attrs" = {
96
-
expr = tail (aspect-example { });
53
+
expr = (aspect-example { });
97
54
expected = {
98
55
includes = [
99
-
{ nixos.static = 100; }
100
-
{ } # host
101
-
{ } # host user
102
-
{ } # user
103
-
{ } # user-only
104
-
{ } # home
105
56
{ nixos.any = 10; }
106
57
];
107
58
};
108
59
};
109
60
110
61
flake.tests."test functor applied with host only" = {
111
-
expr = tail (aspect-example {
112
-
host = 2;
113
-
});
62
+
expr = (
63
+
aspect-example {
64
+
host = 2;
65
+
}
66
+
);
114
67
expected = {
115
68
includes = [
116
-
{ nixos.static = 100; }
117
69
{ nixos.host = 2; } # host
118
-
{ } # host user
119
-
{ } # user
120
-
{ } # user-only
121
-
{ } # home
122
70
{ nixos.any = 10; }
123
71
];
124
72
};
125
73
};
126
74
127
75
flake.tests."test functor applied with home only" = {
128
-
expr = tail (aspect-example {
129
-
home = 2;
130
-
});
76
+
expr = (
77
+
aspect-example {
78
+
home = 2;
79
+
}
80
+
);
131
81
expected = {
132
82
includes = [
133
-
{ nixos.static = 100; }
134
-
{ } # host
135
-
{ } # host user
136
-
{ } # user
137
-
{ } # user-only
138
83
{ nixos.home = 2; } # home
139
84
{ nixos.any = 10; }
140
85
];
···
142
87
};
143
88
144
89
flake.tests."test functor applied with home and unknown" = {
145
-
expr = tail (aspect-example {
146
-
home = 2;
147
-
unknown = 1;
148
-
});
90
+
expr = (
91
+
aspect-example {
92
+
home = 2;
93
+
unknown = 1;
94
+
}
95
+
);
149
96
expected = {
150
97
includes = [
151
-
{ nixos.static = 100; }
152
-
{ } # host
153
-
{ } # host user
154
-
{ } # user
155
-
{ } # user-only
156
-
{ } # home
157
98
{ nixos.any = 10; }
158
99
];
159
100
};
160
101
};
161
102
162
103
flake.tests."test functor applied with user only" = {
163
-
expr = tail (aspect-example {
164
-
user = 2;
165
-
});
104
+
expr = (
105
+
aspect-example {
106
+
user = 2;
107
+
}
108
+
);
166
109
expected = {
167
110
includes = [
168
-
{ nixos.static = 100; }
169
-
{ } # host
170
-
{ } # host user
171
111
{ nixos.user = 2; } # user
172
112
{ nixos.user-only = 2; } # user-only
173
-
{ } # home
174
113
{ nixos.any = 10; }
175
114
];
176
115
};
177
116
};
178
117
179
118
flake.tests."test functor applied with user and host" = {
180
-
expr = tail (aspect-example {
181
-
user = 2;
182
-
host = 1;
183
-
});
119
+
expr = (
120
+
aspect-example {
121
+
user = 2;
122
+
host = 1;
123
+
}
124
+
);
184
125
expected = {
185
126
includes = [
186
-
{ nixos.static = 100; }
187
-
{ } # host
188
127
{
189
128
nixos.host-user = [
190
129
1
191
130
2
192
131
];
193
132
} # host user
194
-
{ } # user
195
-
{ } # user-only
196
-
{ } # home
197
133
{ nixos.any = 10; }
198
134
];
199
135
};
+1
-1
checkmate/tests/function_can_take.nix
+1
-1
checkmate/tests/function_can_take.nix
+52
modules/aspects/definition.nix
+52
modules/aspects/definition.nix
···
1
+
# create aspect dependencies from hosts/users
2
+
{
3
+
lib,
4
+
den,
5
+
...
6
+
}:
7
+
let
8
+
# creates den.aspects.${home.aspect}
9
+
homeAspect = home: {
10
+
${home.aspect} = {
11
+
${home.class} = { };
12
+
includes = [ den.default ];
13
+
__functor = den.lib.parametric { inherit home; };
14
+
};
15
+
};
16
+
17
+
# creates den.aspects.${host.aspect}
18
+
hostAspect = host: {
19
+
${host.aspect} = {
20
+
${host.class} = { };
21
+
includes = [ den.default ];
22
+
__functor = den.lib.parametric { inherit host; };
23
+
};
24
+
};
25
+
26
+
# creates aspects.${user.aspect}
27
+
userAspect = user: {
28
+
${user.aspect} = {
29
+
${user.class} = { };
30
+
includes = [ den.default ];
31
+
__functor = den.lib.parametric true;
32
+
};
33
+
};
34
+
35
+
hosts = lib.flatten (map builtins.attrValues (builtins.attrValues den.hosts));
36
+
homes = lib.flatten (map builtins.attrValues (builtins.attrValues den.homes));
37
+
38
+
homeDeps = map homeAspect homes;
39
+
hostDeps = map hostAspect hosts;
40
+
userDeps = lib.pipe hosts [
41
+
(map (h: builtins.attrValues h.users))
42
+
(lib.flatten)
43
+
(lib.unique)
44
+
(map userAspect)
45
+
];
46
+
47
+
deps = hostDeps ++ userDeps ++ homeDeps;
48
+
49
+
in
50
+
{
51
+
den.aspects = lib.mkMerge (lib.flatten deps);
52
+
}
+43
-64
modules/aspects/dependencies.nix
+43
-64
modules/aspects/dependencies.nix
···
1
-
# create aspect dependencies from hosts/users
2
1
{
3
-
lib,
4
2
den,
5
3
...
6
4
}:
7
5
let
8
-
# creates den.aspects.${host.aspect}
9
-
hostAspect =
10
-
host:
11
-
{ aspects, ... }:
12
-
{
13
-
${host.aspect} = {
14
-
${host.class} = { };
15
-
includes = [
16
-
den.default
17
-
(userContribsToHost aspects)
18
-
];
19
-
__functor = den.lib.parametric { inherit host; };
20
-
};
21
-
};
6
+
inherit (den.lib) owned statics;
22
7
23
-
# creates aspects.${user.aspect}
24
-
userAspect =
25
-
user:
26
-
{ aspects, ... }:
27
-
{
28
-
${user.aspect} = {
29
-
${user.class} = { };
30
-
includes = [
31
-
den.default
32
-
(hostContribsToUser aspects)
33
-
];
34
-
__functor = den.lib.parametric true;
35
-
};
36
-
};
8
+
dependencies = [
9
+
# owned attributes: <aspect>.<class>
10
+
({ home }: owned home.class den.aspects.${home.aspect})
11
+
({ host }: owned host.class den.aspects.${host.aspect})
12
+
({ user, host }: owned user.class den.aspects.${user.aspect})
13
+
14
+
# defaults: owned from den.default.<class>
15
+
({ home }: owned home.class den.default)
16
+
({ host }: owned host.class den.default)
17
+
({ user, host }: owned user.class den.default)
18
+
19
+
# static (non-parametric) from <aspect>.includes
20
+
({ home }: statics den.aspects.${home.aspect})
21
+
({ host }: statics den.aspects.${host.aspect})
22
+
({ user, host }: statics den.aspects.${user.aspect})
23
+
24
+
# user-to-host context
25
+
({ fromUser, toHost }: owned toHost.class den.aspects.${fromUser.aspect})
26
+
# host-to-user context
27
+
({ fromHost, toUser }: owned toUser.class den.aspects.${fromHost.aspect})
28
+
29
+
# { host } => [ { fromUser, toHost } ]
30
+
(hostIncludesFromUsers)
37
31
38
-
# creates den.aspects.${home.aspect}
39
-
homeAspect = home: {
40
-
${home.aspect} = {
41
-
${home.class} = { };
42
-
includes = [ den.default ];
43
-
__functor = den.lib.parametric { inherit home; };
44
-
};
45
-
};
32
+
# { user, host } => { fromHost, toUser }
33
+
(userIncludesFromHost)
34
+
];
46
35
47
-
userContribsToHost =
48
-
aspects:
36
+
hostIncludesFromUsers =
49
37
{ host }:
50
38
{
51
39
includes =
52
40
let
53
-
users = lib.attrValues host.users;
54
-
userContribs = user: aspects.${user.aspect} { inherit host user; };
41
+
users = builtins.attrValues host.users;
42
+
context = user: {
43
+
fromUser = user;
44
+
toHost = host;
45
+
};
46
+
contrib = user: den.aspects.${user.aspect} (context user);
55
47
in
56
-
map userContribs users;
48
+
map contrib users;
57
49
};
58
50
59
-
hostContribsToUser =
60
-
aspects:
61
-
# deadnix: skip
51
+
userIncludesFromHost =
62
52
{ user, host }:
63
-
aspects.${host.aspect}
64
-
// {
65
-
__functor = den.lib.parametric { inherit user host; };
53
+
{
54
+
includes = den.aspects.${host.aspect}.includes;
55
+
__functor = den.lib.parametric {
56
+
fromHost = host;
57
+
toUser = user;
58
+
};
66
59
};
67
60
68
-
hosts = lib.flatten (map builtins.attrValues (builtins.attrValues den.hosts));
69
-
homes = lib.flatten (map builtins.attrValues (builtins.attrValues den.homes));
70
-
71
-
homeDeps = map homeAspect homes;
72
-
hostDeps = map hostAspect hosts;
73
-
userDeps = lib.pipe hosts [
74
-
(map (h: builtins.attrValues h.users))
75
-
(lib.flatten)
76
-
(lib.unique)
77
-
(map userAspect)
78
-
];
79
-
80
-
deps = hostDeps ++ userDeps ++ homeDeps;
81
-
82
61
in
83
62
{
84
-
config.den.aspects = lib.mkMerge (lib.flatten deps);
63
+
den.default.includes = dependencies;
85
64
}
+17
-14
modules/aspects/provides/define-user.nix
+17
-14
modules/aspects/provides/define-user.nix
···
22
22
host: user:
23
23
if lib.hasSuffix "darwin" host.system then "/Users/${user.userName}" else "/home/${user.userName}";
24
24
25
-
# Parametric { host, user } => aspect.
26
-
# Configures at OS and HM levels. For NixOs and Darwin.
27
-
osUser =
25
+
userToHostContext =
26
+
{ fromUser, toHost }:
27
+
{
28
+
nixos.users.users.${fromUser.userName}.isNormalUser = true;
29
+
darwin.users.users.${fromUser.userName} = {
30
+
name = fromUser.userName;
31
+
home = homeDir toHost fromUser;
32
+
};
33
+
};
34
+
35
+
userContext =
28
36
{ host, user }:
29
37
{
30
-
nixos.users.users.${user.userName}.isNormalUser = true;
31
-
darwin.users.users.${user.userName} = {
32
-
name = user.userName;
33
-
home = homeDir host user;
34
-
};
35
38
homeManager = {
36
39
home.username = user.userName;
37
40
home.homeDirectory = homeDir host user;
38
41
};
39
42
};
40
43
41
-
# Parametric { home } => aspect.
42
-
hmUser =
44
+
hmContext =
43
45
{ home }:
44
-
osUser {
46
+
userContext {
47
+
host.system = home.system;
45
48
user.userName = home.userName;
46
-
host.system = home.system;
47
49
};
48
50
in
49
51
{
50
52
den.provides.define-user = {
51
53
inherit description;
52
54
includes = [
53
-
osUser
54
-
hmUser
55
+
userToHostContext
56
+
userContext
57
+
hmContext
55
58
];
56
59
__functor = den.lib.parametric true;
57
60
};
+8
-10
modules/aspects/provides/primary-user.nix
+8
-10
modules/aspects/provides/primary-user.nix
···
13
13
14
14
'';
15
15
16
-
osConfig =
17
-
{ user, host }:
16
+
userToHostContext =
17
+
{ fromUser, toHost }:
18
18
let
19
-
on-wsl.nixos.wsl.defaultUser = user.userName;
19
+
on-wsl.nixos.wsl.defaultUser = fromUser.userName;
20
20
in
21
21
{
22
-
includes = lib.optionals (host ? wsl) [ on-wsl ];
23
-
darwin.system.primaryUser = user.userName;
24
-
nixos.users.users.${user.userName} = {
22
+
inherit description;
23
+
includes = lib.optionals (toHost ? wsl) [ on-wsl ];
24
+
darwin.system.primaryUser = fromUser.userName;
25
+
nixos.users.users.${fromUser.userName} = {
25
26
isNormalUser = true;
26
27
extraGroups = [
27
28
"wheel"
···
32
33
33
34
in
34
35
{
35
-
den.provides.primary-user = {
36
-
inherit description;
37
-
__functor = _self: osConfig;
38
-
};
36
+
den.provides.primary-user = userToHostContext;
39
37
}
+43
-27
modules/aspects/provides/user-shell.nix
+43
-27
modules/aspects/provides/user-shell.nix
···
1
-
{
2
-
den.provides.user-shell = {
3
-
description = ''
4
-
Sets a user default shell, enables the shell at OS and Home level.
1
+
{ den, ... }:
2
+
let
5
3
6
-
Usage:
4
+
description = ''
5
+
Sets a user default shell, enables the shell at OS and Home level.
7
6
8
-
den.aspects.vic.includes = [
9
-
# will always love red snappers.
10
-
(den._.user-shell "fish")
11
-
];
12
-
'';
7
+
Usage:
13
8
14
-
__functor =
15
-
_: shell:
16
-
# deadnix: skip
17
-
{ user, host }:
18
-
let
19
-
homeManager.programs.${shell}.enable = true;
20
-
nixos =
21
-
{ pkgs, ... }:
22
-
{
23
-
programs.${shell}.enable = true;
24
-
users.users.${user.userName}.shell = pkgs.${shell};
25
-
};
26
-
darwin = nixos;
27
-
in
28
-
{
29
-
inherit nixos darwin homeManager;
30
-
};
9
+
den.aspects.vic.includes = [
10
+
# will always love red snappers.
11
+
(den._.user-shell "fish")
12
+
];
13
+
'';
14
+
15
+
userContext =
16
+
{ shell }:
17
+
{ host }:
18
+
{
19
+
homeManager.programs.${shell}.enable = true;
20
+
};
21
+
22
+
userToHostContext =
23
+
{ shell }:
24
+
{ fromUser, toHost }:
25
+
let
26
+
nixos =
27
+
{ pkgs, ... }:
28
+
{
29
+
programs.${shell}.enable = true;
30
+
users.users.${fromUser.userName}.shell = pkgs.${shell};
31
+
};
32
+
darwin = nixos;
33
+
in
34
+
{
35
+
inherit nixos darwin;
36
+
};
37
+
38
+
in
39
+
{
40
+
den.provides.user-shell = shell: {
41
+
inherit description;
42
+
__functor = den.lib.parametric true;
43
+
includes = map (f: f { inherit shell; }) [
44
+
userContext
45
+
userToHostContext
46
+
];
31
47
};
32
48
}
-37
nix/aspect-functor.nix
-37
nix/aspect-functor.nix
···
1
-
lib:
2
-
let
3
-
is-fn = f: (builtins.isFunction f) || (f ? __functor);
4
-
can-take = import ./fn-can-take.nix lib;
5
-
apply =
6
-
param: f:
7
-
if !is-fn f then
8
-
f
9
-
else if can-take param f then
10
-
f param
11
-
else if
12
-
can-take {
13
-
class = null;
14
-
aspect-chain = [ ];
15
-
} f
16
-
then
17
-
f
18
-
else
19
-
{ };
20
-
21
-
static = aspect: {
22
-
__functor =
23
-
_:
24
-
# deadnix: skip
25
-
{ class, aspect-chain }:
26
-
{
27
-
${class} = aspect.${class} or { };
28
-
};
29
-
};
30
-
31
-
parametric = aspect: param: map (apply param) aspect.includes;
32
-
33
-
__functor = aspect: param: {
34
-
includes = [ (static aspect) ] ++ (parametric aspect param);
35
-
};
36
-
in
37
-
__functor
+55
-4
nix/lib.nix
+55
-4
nix/lib.nix
···
1
1
lib: inputs:
2
2
let
3
+
isFn = f: (builtins.isFunction f) || (f ? __functor);
4
+
canTake = import ./fn-can-take.nix lib;
5
+
inCtx = ctx: f: isFn f && canTake ctx f;
6
+
7
+
isAspect = canTake {
8
+
class = "";
9
+
aspect-chain = [ ];
10
+
};
11
+
12
+
# creates an aspect that inherits class from fromAspect.
13
+
owned = class: fromAspect: { ${class} = fromAspect.${class} or { }; };
14
+
15
+
# only static includes from an aspect.
16
+
statics =
17
+
aspect:
18
+
# deadnix: skip
19
+
{ class, aspect-chain }:
20
+
{
21
+
includes =
22
+
let
23
+
include =
24
+
f:
25
+
if !isFn f then
26
+
f
27
+
else if isAspect f then
28
+
f { inherit class aspect-chain; }
29
+
else
30
+
{ };
31
+
in
32
+
map include aspect.includes;
33
+
};
34
+
3
35
# "Just Give 'Em One of These" - Moe Szyslak
4
-
funk = import ./aspect-functor.nix lib;
36
+
# a __functor that **only** considers parametric includes
37
+
# that **exactly** match the given context.
38
+
funk =
39
+
aspect: ctx:
40
+
let
41
+
fns = builtins.filter (inCtx ctx) aspect.includes;
42
+
includes = map (f: f ctx) fns;
43
+
in
44
+
{
45
+
inherit includes;
46
+
};
5
47
6
48
parametric =
7
49
param: aspect:
···
25
67
(path: lib.getAttrFromPath path den-ns)
26
68
];
27
69
70
+
den-lib = {
71
+
inherit
72
+
parametric
73
+
aspects
74
+
angleBrackets
75
+
statics
76
+
owned
77
+
isFn
78
+
canTake
79
+
;
80
+
};
28
81
in
29
-
{
30
-
inherit parametric aspects angleBrackets;
31
-
}
82
+
den-lib
+3
-3
templates/default/flake.lock
+3
-3
templates/default/flake.lock
···
22
22
},
23
23
"den": {
24
24
"locked": {
25
-
"lastModified": 1762315133,
26
-
"narHash": "sha256-pM0/ri+4LPrZUIv9c8Bh4+RyB2VMGyChXrxyIP4mbjs=",
25
+
"lastModified": 1762465155,
26
+
"narHash": "sha256-BDeDTRBFoonBU3XpnhWXH9Mo5fTad/mXfwDQAbs7XSQ=",
27
27
"owner": "vic",
28
28
"repo": "den",
29
-
"rev": "04dfe099cc7d4f773f4fd50bdf0571791a2e9fad",
29
+
"rev": "dd929700c71b997941c7045a1ac77c8ae052a93b",
30
30
"type": "github"
31
31
},
32
32
"original": {
+36
-6
templates/default/modules/_example/aspects.nix
+36
-6
templates/default/modules/_example/aspects.nix
···
31
31
${host.class}.networking.hostName = host.name;
32
32
};
33
33
34
-
# Example: configuration that depends on both host and user. provides to both.
35
-
host-conditional =
36
-
{ host, user }:
37
-
if user.userName == "alice" && !lib.hasSuffix "darwin" host.system then
34
+
# Example: installed on den.defaults for each user contribute into host.
35
+
one-hello-package-for-each-user =
36
+
{ fromUser, toHost }:
37
+
{
38
+
${toHost.class} =
39
+
{ pkgs, ... }:
40
+
{
41
+
users.users.${fromUser.userName}.packages = [ pkgs.hello ];
42
+
};
43
+
};
44
+
45
+
# Example: configuration that depends on both host and user. provides to the host.
46
+
user-to-host-conditional =
47
+
{ fromUser, toHost }:
48
+
if fromUser.userName == "alice" && !lib.hasSuffix "darwin" toHost.system then
38
49
{
39
50
nixos.programs.tmux.enable = true;
51
+
}
52
+
else
53
+
{ };
54
+
55
+
# Example: configuration that depends on both host and user. provides to the host.
56
+
host-to-user-conditional =
57
+
{ fromHost, toUser }:
58
+
if toUser.userName == "alice" && !lib.hasSuffix "darwin" fromHost.system then
59
+
{
40
60
homeManager.programs.git.enable = true;
41
61
}
42
62
else
···
59
79
den.default.includes = [
60
80
# Example: static aspect
61
81
vm-bootable
82
+
62
83
# Example: parametric { host } aspect
63
84
set-host-name
64
-
# Example: parametric over { home } or { host, user } aspect.
85
+
86
+
# Example: parametric { fromUser, toHost } aspect.
87
+
one-hello-package-for-each-user
88
+
89
+
# Example: parametric over many contexts: { home }, { host, user }, { fromUser, toHost }
65
90
den.provides.define-user
66
91
];
67
92
···
91
116
den._.primary-user
92
117
];
93
118
119
+
# Example: host provides parametric user configuration.
120
+
den.aspects.rockhopper.includes = [
121
+
host-to-user-conditional
122
+
];
123
+
94
124
# Example: user provides parametric host configuration.
95
125
den.aspects.alice.includes = [
96
-
host-conditional
126
+
user-to-host-conditional
97
127
# alice is always admin in all its hosts
98
128
den._.primary-user
99
129
];
+11
templates/default/modules/_example/ci.nix
+11
templates/default/modules/_example/ci.nix
···
92
92
luke.config.programs.bat.enable
93
93
);
94
94
95
+
alice-hello-enabled-by-default = checkCond "added hello at user packages" (
96
+
let
97
+
progs = rockhopper.config.users.users.alice.packages;
98
+
expr.len = lib.length progs;
99
+
expr.name = lib.getName (lib.head progs);
100
+
expected.len = 1;
101
+
expected.name = "hello";
102
+
in
103
+
expr == expected
104
+
);
105
+
95
106
};
96
107
97
108
checks.aarch64-darwin = {