+58 -509

checkmate/modules/tests.nix

··· 1 1 - { inputs, ... }: 2 2 - { 3 3 - perSystem = 4 4 - { lib, ... }: 5 5 - let 6 6 - transpose = import ../../nix { inherit lib; }; 1 1 + { inputs, lib, ... }: 2 2 + let 3 3 + targetNix = "${inputs.target}/nix"; 4 4 + targetLib = "${inputs.target}/nix/lib.nix"; 5 5 + targetMod = "${inputs.target}/nix/flakeModule.nix"; 7 6 8 8 - mkFlake = 9 9 - mod: 10 10 - inputs.flake-parts.lib.mkFlake 11 11 - { 12 12 - inputs.self = [ ]; 13 13 - } 14 14 - { 15 15 - systems = [ ]; 16 16 - imports = [ 17 17 - ../../nix/flakeModule.nix 18 18 - inputs.flake-parts.flakeModules.modules 19 19 - mod 20 20 - (fooMod "aspectOne") 21 21 - (fooMod "aspectTwo") 22 22 - (fooMod "aspectThree") 23 23 - ]; 24 24 - }; 7 7 + transpose = import targetNix { inherit lib; }; 25 8 26 26 - fooMod = aspect: { 9 9 + mkFlake = 10 10 + mod: 11 11 + inputs.flake-parts.lib.mkFlake 12 12 + { 13 13 + inputs.self = [ ]; 14 14 + } 15 15 + { 16 16 + systems = [ ]; 27 17 imports = [ 28 28 - { flake.modules.classOne.${aspect}.imports = [ fooOpt ]; } 29 29 - { flake.modules.classTwo.${aspect}.imports = [ fooOpt ]; } 30 30 - { flake.modules.classThree.${aspect}.imports = [ fooOpt ]; } 18 18 + targetMod 19 19 + inputs.flake-parts.flakeModules.modules 20 20 + mod 21 21 + (fooMod "aspectOne") 22 22 + (fooMod "aspectTwo") 23 23 + (fooMod "aspectThree") 31 24 ]; 32 25 }; 33 26 34 34 - fooOpt = { 35 35 - options.foo = lib.mkOption { 36 36 - type = lib.types.str; 37 37 - default = "<unset>"; 38 38 - }; 39 39 - options.bar = lib.mkOption { 40 40 - type = lib.types.listOf lib.types.str; 41 41 - default = [ ]; 42 42 - }; 43 43 - options.baz = lib.mkOption { 44 44 - type = lib.types.lazyAttrsOf lib.types.str; 45 45 - default = { }; 46 46 - }; 47 47 - }; 48 48 - 49 49 - evalMod = 50 50 - class: mod: 51 51 - (lib.evalModules { 52 52 - inherit class; 53 53 - modules = [ mod ]; 54 54 - }).config; 55 55 - in 56 56 - { 57 57 - nix-unit.tests = { 58 58 - transpose."test swaps parent and child attrNames" = { 59 59 - expr = transpose { a.b.c = 1; }; 60 60 - expected = { 61 61 - b.a.c = 1; 62 62 - }; 63 63 - }; 64 64 - 65 65 - transpose."test common childs become one parent" = { 66 66 - expr = transpose { 67 67 - a.b = 1; 68 68 - c.b = 2; 69 69 - }; 70 70 - expected.b = { 71 71 - a = 1; 72 72 - c = 2; 73 73 - }; 74 74 - }; 75 75 - 76 76 - new-scope."test usage without flakes" = 77 77 - let 78 78 - flake-aspects-lib = import ../../nix/lib.nix lib; 79 79 - # first eval is like evaling the flake. 80 80 - first = lib.evalModules { 81 81 - modules = [ 82 82 - (flake-aspects-lib.new-scope "hello") 83 83 - { 84 84 - hello.aspects = 85 85 - { aspects, ... }: 86 86 - { 87 87 - a.b.c = [ "world" ]; 88 88 - a.includes = [ aspects.x ]; 89 89 - x.b = 90 90 - { lib, ... }: 91 91 - { 92 92 - c = lib.splitString " " "mundo cruel"; 93 93 - }; 94 94 - }; 95 95 - } 96 96 - ]; 97 97 - }; 98 98 - # second eval is like evaling its nixosConfiguration 99 99 - second = lib.evalModules { 100 100 - modules = [ 101 101 - { options.c = lib.mkOption { type = lib.types.listOf lib.types.str; }; } 102 102 - first.config.hello.modules.b.a 103 103 - ]; 104 104 - }; 105 105 - expr = lib.sort (a: b: a < b) second.config.c; 106 106 - expected = [ 107 107 - "cruel" 108 108 - "mundo" 109 109 - "world" 110 110 - ]; 111 111 - in 112 112 - { 113 113 - inherit expr expected; 114 114 - }; 115 115 - 116 116 - aspects."test provides default" = 117 117 - let 118 118 - flake = 119 119 - inputs.flake-parts.lib.mkFlake 120 120 - { 121 121 - inputs.self = [ ]; 122 122 - moduleLocation = builtins.toString ./.; 123 123 - } 124 124 - { 125 125 - systems = [ ]; 126 126 - imports = [ 127 127 - ../../nix/flakeModule.nix 128 128 - inputs.flake-parts.flakeModules.modules 129 129 - ]; 130 130 - }; 131 131 - expr = flake.modules; 132 132 - expected = { }; 133 133 - in 134 134 - { 135 135 - inherit expr expected; 136 136 - }; 137 137 - 138 138 - aspects."test transposes to flake.modules" = 139 139 - let 140 140 - flake = mkFlake { 141 141 - flake.aspects.aspectOne = { 142 142 - classOne.foo = "niri"; 143 143 - classTwo.foo = "paper.spoon"; 144 144 - }; 145 145 - }; 146 146 - expr = { 147 147 - classOne = (evalMod "classOne" flake.modules.classOne.aspectOne).foo; 148 148 - classTwo = (evalMod "classTwo" flake.modules.classTwo.aspectOne).foo; 149 149 - }; 150 150 - expected = { 151 151 - classOne = "niri"; 152 152 - classTwo = "paper.spoon"; 153 153 - }; 154 154 - in 155 155 - { 156 156 - inherit expr expected; 157 157 - }; 158 158 - 159 159 - aspects."test dependencies on aspects" = 160 160 - let 161 161 - flake = mkFlake { 162 162 - flake.aspects = 163 163 - { aspects, ... }: 164 164 - { 165 165 - aspectOne = { 166 166 - description = "os config"; 167 167 - includes = with aspects; [ aspectTwo ]; 168 168 - classOne.bar = [ "os" ]; 169 169 - }; 170 170 - 171 171 - aspectTwo = { 172 172 - description = "user config at os level"; 173 173 - classOne.bar = [ "user" ]; 174 174 - }; 175 175 - }; 176 176 - }; 177 177 - expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 178 178 - expected = [ 179 179 - "os" 180 180 - "user" 181 181 - ]; 182 182 - in 183 183 - { 184 184 - inherit expr expected; 185 185 - }; 186 186 - 187 187 - aspects."test resolve aspect-chain" = 188 188 - let 189 189 - flake = mkFlake { 190 190 - flake.aspects = 191 191 - { aspects, ... }: 192 192 - { 193 193 - aspectOne = { 194 194 - name = "one"; 195 195 - includes = [ aspects.aspectOne.provides.dos ]; 196 196 - classOne.bar = [ "zzz" ]; 197 197 - provides.dos = 198 198 - { aspect-chain, ... }: 199 199 - { 200 200 - name = "dos"; 201 201 - includes = [ aspects.aspectOne.provides.tres ]; 202 202 - classOne.bar = map (x: x.name) aspect-chain; 203 203 - }; 27 27 + fooMod = aspect: { 28 28 + imports = [ 29 29 + { flake.modules.classOne.${aspect}.imports = [ fooOpt ]; } 30 30 + { flake.modules.classTwo.${aspect}.imports = [ fooOpt ]; } 31 31 + { flake.modules.classThree.${aspect}.imports = [ fooOpt ]; } 32 32 + ]; 33 33 + }; 204 34 205 205 - provides.tres = 206 206 - { aspect-chain, ... }: 207 207 - { 208 208 - name = "tres"; 209 209 - classOne.bar = [ (lib.last aspect-chain).name ]; 210 210 - }; 211 211 - }; 212 212 - }; 213 213 - }; 214 214 - mod = { 215 215 - imports = [ 216 216 - fooOpt 217 217 - (flake.aspects.aspectOne.resolve { class = "classOne"; }) 218 218 - ]; 219 219 - }; 220 220 - expr = lib.sort (a: b: a < b) (evalMod "classOne" mod).bar; 221 221 - expected = [ 222 222 - "dos" 223 223 - "one" 224 224 - "zzz" 225 225 - ]; 226 226 - in 227 227 - { 228 228 - inherit expr expected; 229 229 - }; 35 35 + fooOpt = { 36 36 + options.foo = lib.mkOption { 37 37 + type = lib.types.str; 38 38 + default = "<unset>"; 39 39 + }; 40 40 + options.bar = lib.mkOption { 41 41 + type = lib.types.listOf lib.types.str; 42 42 + default = [ ]; 43 43 + }; 44 44 + options.baz = lib.mkOption { 45 45 + type = lib.types.lazyAttrsOf lib.types.str; 46 46 + default = { }; 47 47 + }; 48 48 + }; 230 49 231 231 - aspects."test modules resolved" = 232 232 - let 233 233 - flake = mkFlake { 234 234 - flake.aspects = 235 235 - { aspects, ... }: 236 236 - { 237 237 - aspectOne = { 238 238 - name = "one"; 239 239 - includes = [ aspects.aspectOne.provides.dos ]; 240 240 - classOne.bar = [ "zzz" ]; 241 241 - provides.dos = 242 242 - { aspect-chain, ... }: 243 243 - { 244 244 - name = "dos"; 245 245 - includes = [ aspects.aspectOne.provides.tres ]; 246 246 - classOne.bar = map (x: x.name) aspect-chain; 247 247 - }; 248 248 - 249 249 - provides.tres = 250 250 - { aspect-chain, ... }: 251 251 - { 252 252 - name = "tres"; 253 253 - classOne.bar = [ (lib.last aspect-chain).name ]; 254 254 - }; 255 255 - }; 256 256 - }; 257 257 - }; 258 258 - mod = { 259 259 - imports = [ 260 260 - fooOpt 261 261 - (flake.aspects.aspectOne.modules.classOne) 262 262 - ]; 263 263 - }; 264 264 - expr = lib.sort (a: b: a < b) (evalMod "classOne" mod).bar; 265 265 - expected = [ 266 266 - "dos" 267 267 - "one" 268 268 - "zzz" 269 269 - ]; 270 270 - in 271 271 - { 272 272 - inherit expr expected; 273 273 - }; 274 274 - 275 275 - aspects."test provides" = 276 276 - let 277 277 - flake = mkFlake { 278 278 - flake.aspects = 279 279 - { aspects, ... }: 280 280 - { 281 281 - aspectOne.includes = with aspects.aspectTwo.provides; [ 282 282 - foo 283 283 - bar 284 284 - ]; 285 285 - aspectOne.classOne = { }; # must be present for mixing dependencies. 286 286 - aspectTwo = { 287 287 - classOne.bar = [ "class one not included" ]; 288 288 - classTwo.bar = [ "class two not included" ]; 289 289 - provides.foo = 290 290 - { class, aspect-chain }: 291 291 - { 292 292 - name = "aspectTwo.foo"; 293 293 - description = "aspectTwo foo provided"; 294 294 - includes = [ 295 295 - aspects.aspectThree.provides.moo 296 296 - aspects.aspectTwo.provides.baz 297 297 - ]; 298 298 - classOne.bar = [ "two:${class}:${lib.concatStringsSep "/" (lib.map (x: x.name) aspect-chain)}" ]; 299 299 - classTwo.bar = [ "foo class two not included" ]; 300 300 - }; 301 301 - # a provider can be immediately an aspect object. 302 302 - provides.bar = { 303 303 - # classOne is missing on bar 304 304 - classTwo.bar = [ "bar class two not included" ]; 305 305 - }; 306 306 - # _ is an shortcut alias of provides. 307 307 - _.baz = { 308 308 - # classOne is missing on bar 309 309 - classTwo.bar = [ "baz" ]; 310 310 - }; 311 311 - }; 312 312 - aspectThree.provides.moo = 313 313 - { aspect-chain, class }: 314 314 - { 315 315 - classOne.bar = [ "three:${class}:${lib.concatStringsSep "/" (lib.map (x: x.name) aspect-chain)}" ]; 316 316 - }; 317 317 - }; 318 318 - }; 319 319 - expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 320 320 - expected = [ 321 321 - "three:classOne:aspectOne/aspectTwo.foo" 322 322 - "two:classOne:aspectOne" 323 323 - ]; 324 324 - in 325 325 - { 326 326 - inherit expr expected; 327 327 - }; 328 328 - 329 329 - aspects."test provides using fixpoints" = 330 330 - let 331 331 - flake = mkFlake { 332 332 - flake.aspects = 333 333 - { aspects, ... }: 334 334 - { 335 335 - aspectOne = { 336 336 - classOne.bar = [ "1" ]; 337 337 - includes = [ 338 338 - aspects.aspectTwo 339 339 - ]; 340 340 - }; 341 341 - 342 342 - aspectTwo = { 343 343 - classOne.bar = [ "2" ]; 344 344 - includes = [ aspects.aspectTwo.provides.three-and-four-and-five ]; 345 345 - provides = 346 346 - { provides, ... }: 347 347 - { 348 348 - three-and-four-and-five = { 349 349 - classOne.bar = [ "3" ]; 350 350 - includes = [ 351 351 - provides.four 352 352 - aspects.five 353 353 - ]; 354 354 - }; 355 355 - four = { 356 356 - classOne.bar = [ "4" ]; 357 357 - }; 358 358 - }; 359 359 - }; 360 360 - 361 361 - five.classOne.bar = [ "5" ]; 362 362 - }; 363 363 - }; 364 364 - 365 365 - expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 366 366 - expected = [ 367 367 - "1" 368 368 - "2" 369 369 - "3" 370 370 - "4" 371 371 - "5" 372 372 - ]; 373 373 - in 374 374 - { 375 375 - inherit expr expected; 376 376 - }; 377 377 - 378 378 - aspects."test provides parametrized modules" = 379 379 - let 380 380 - flake = mkFlake { 381 381 - flake.aspects = 382 382 - { aspects, ... }: 383 383 - { 384 384 - aspectOne.includes = [ (aspects.aspectTwo.provides.hello "mundo") ]; 385 385 - aspectOne.classOne.bar = [ "1" ]; 386 386 - 387 387 - aspectTwo.provides.hello = world: { 388 388 - classOne.bar = [ world ]; 389 389 - }; 390 390 - }; 391 391 - }; 392 392 - 393 393 - expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 394 394 - expected = [ 395 395 - "1" 396 396 - "mundo" 397 397 - ]; 398 398 - in 399 399 - { 400 400 - inherit expr expected; 401 401 - }; 402 402 - 403 403 - aspects."test override default provider" = 404 404 - let 405 405 - flake = mkFlake { 406 406 - flake.aspects = 407 407 - { aspects, ... }: 408 408 - { 409 409 - aspectOne = 410 410 - { aspect, ... }: 411 411 - { 412 412 - includes = [ (aspects.aspectTwo { message = "hello ${aspect.name}"; }) ]; 413 413 - classOne = { }; # required for propagation 414 414 - }; 415 415 - 416 416 - aspectTwo.__functor = 417 417 - _: 418 418 - { message }: # args must be always named 419 419 - { class, aspect-chain }: 420 420 - { aspect, ... }: 421 421 - { 422 422 - classOne.bar = [ 423 423 - "foo" 424 424 - aspect.name 425 425 - message 426 426 - class 427 427 - ] 428 428 - ++ (lib.map (x: x.name) aspect-chain); 429 429 - }; 430 430 - aspectTwo.classOne.bar = [ "itself not included" ]; 431 431 - }; 432 432 - }; 433 433 - 434 434 - expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 435 435 - expected = [ 436 436 - "foo" 437 437 - "<function body>" 438 438 - "hello aspectOne" 439 439 - "classOne" 440 440 - "aspectOne" 441 441 - ]; 442 442 - in 443 443 - { 444 444 - inherit expr expected; 445 445 - }; 446 446 - 447 447 - aspects."test override default provider includes" = 448 448 - let 449 449 - flake = mkFlake { 450 450 - flake.aspects = 451 451 - { aspects, ... }: 452 452 - { 453 453 - aspectOne = { 454 454 - classOne.bar = [ "should-not-be-present" ]; 455 455 - includes = [ aspects.aspectTwo ]; 456 456 - __functor = aspect: { 457 457 - includes = [ 458 458 - { classOne.bar = [ "from-functor" ]; } 459 459 - ] 460 460 - ++ map (f: f { message = "hello"; }) aspect.includes; 461 461 - }; 462 462 - }; 463 463 - aspectTwo.__functor = 464 464 - _aspect: 465 465 - { message }: 466 466 - { 467 467 - classOne.bar = [ message ]; 468 468 - }; 469 469 - }; 470 470 - }; 471 471 - 472 472 - expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 473 473 - expected = [ 474 474 - "hello" 475 475 - "from-functor" 476 476 - ]; 477 477 - in 478 478 - { 479 479 - inherit expr expected; 480 480 - }; 481 481 - 482 482 - aspects."test define top-level context-aware aspect" = 483 483 - let 484 484 - flake = mkFlake { 485 485 - flake.aspects = 486 486 - { aspects, ... }: 487 487 - { 488 488 - aspectOne = { 489 489 - classOne.bar = [ "should-not-be-present" ]; 490 490 - includes = [ aspects.aspectTwo ]; 491 491 - __functor = aspect: { 492 492 - includes = [ 493 493 - { classOne.bar = [ "from-functor" ]; } 494 494 - ] 495 495 - ++ map (f: f { message = "hello"; }) aspect.includes; 496 496 - }; 497 497 - }; 498 498 - aspectTwo = 499 499 - { message }: 500 500 - { 501 501 - classOne.bar = [ message ]; 502 502 - }; 503 503 - }; 504 504 - }; 505 505 - 506 506 - expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 507 507 - expected = [ 508 508 - "hello" 509 509 - "from-functor" 510 510 - ]; 511 511 - in 512 512 - { 513 513 - inherit expr expected; 514 514 - }; 515 515 - }; 516 516 - 517 517 - }; 50 50 + evalMod = 51 51 + class: mod: 52 52 + (lib.evalModules { 53 53 + inherit class; 54 54 + modules = [ mod ]; 55 55 + }).config; 56 56 + in 57 57 + { 58 58 + _module.args = { 59 59 + inherit 60 60 + transpose 61 61 + targetLib 62 62 + targetMod 63 63 + targetNix 64 64 + ; 65 65 + inherit mkFlake evalMod fooOpt; 66 66 + }; 518 67 }

+53

checkmate/modules/tests/aspect_chain.nix

··· 1 1 + { 2 2 + lib, 3 3 + mkFlake, 4 4 + evalMod, 5 5 + fooOpt, 6 6 + ... 7 7 + }: 8 8 + { 9 9 + 10 10 + flake.tests."test resolve aspect-chain" = 11 11 + let 12 12 + flake = mkFlake { 13 13 + flake.aspects = 14 14 + { aspects, ... }: 15 15 + { 16 16 + aspectOne = { 17 17 + name = "one"; 18 18 + includes = [ aspects.aspectOne.provides.dos ]; 19 19 + classOne.bar = [ "zzz" ]; 20 20 + provides.dos = 21 21 + { aspect-chain, ... }: 22 22 + { 23 23 + name = "dos"; 24 24 + includes = [ aspects.aspectOne.provides.tres ]; 25 25 + classOne.bar = map (x: x.name) aspect-chain; 26 26 + }; 27 27 + 28 28 + provides.tres = 29 29 + { aspect-chain, ... }: 30 30 + { 31 31 + name = "tres"; 32 32 + classOne.bar = [ (lib.last aspect-chain).name ]; 33 33 + }; 34 34 + }; 35 35 + }; 36 36 + }; 37 37 + mod = { 38 38 + imports = [ 39 39 + fooOpt 40 40 + (flake.aspects.aspectOne.resolve { class = "classOne"; }) 41 41 + ]; 42 42 + }; 43 43 + expr = lib.sort (a: b: a < b) (evalMod "classOne" mod).bar; 44 44 + expected = [ 45 45 + "dos" 46 46 + "one" 47 47 + "zzz" 48 48 + ]; 49 49 + in 50 50 + { 51 51 + inherit expr expected; 52 52 + }; 53 53 + }

+53

checkmate/modules/tests/aspect_default_provider_functor.nix

··· 1 1 + { 2 2 + mkFlake, 3 3 + evalMod, 4 4 + lib, 5 5 + ... 6 6 + }: 7 7 + { 8 8 + 9 9 + flake.tests."test override default provider" = 10 10 + let 11 11 + flake = mkFlake { 12 12 + flake.aspects = 13 13 + { aspects, ... }: 14 14 + { 15 15 + aspectOne = 16 16 + { aspect, ... }: 17 17 + { 18 18 + includes = [ (aspects.aspectTwo { message = "hello ${aspect.name}"; }) ]; 19 19 + classOne = { }; # required for propagation 20 20 + }; 21 21 + 22 22 + aspectTwo.__functor = 23 23 + _: 24 24 + { message }: # args must be always named 25 25 + { class, aspect-chain }: 26 26 + { aspect, ... }: 27 27 + { 28 28 + classOne.bar = [ 29 29 + "foo" 30 30 + aspect.name 31 31 + message 32 32 + class 33 33 + ] 34 34 + ++ (lib.map (x: x.name) aspect-chain); 35 35 + }; 36 36 + aspectTwo.classOne.bar = [ "itself not included" ]; 37 37 + }; 38 38 + }; 39 39 + 40 40 + expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 41 41 + expected = [ 42 42 + "foo" 43 43 + "<function body>" 44 44 + "hello aspectOne" 45 45 + "classOne" 46 46 + "aspectOne" 47 47 + ]; 48 48 + in 49 49 + { 50 50 + inherit expr expected; 51 51 + }; 52 52 + 53 53 + }

+42

checkmate/modules/tests/aspect_default_provider_override.nix

··· 1 1 + { 2 2 + mkFlake, 3 3 + evalMod, 4 4 + ... 5 5 + }: 6 6 + { 7 7 + 8 8 + flake.tests."test override default provider includes" = 9 9 + let 10 10 + flake = mkFlake { 11 11 + flake.aspects = 12 12 + { aspects, ... }: 13 13 + { 14 14 + aspectOne = { 15 15 + classOne.bar = [ "should-not-be-present" ]; 16 16 + includes = [ aspects.aspectTwo ]; 17 17 + __functor = aspect: { 18 18 + includes = [ 19 19 + { classOne.bar = [ "from-functor" ]; } 20 20 + ] 21 21 + ++ map (f: f { message = "hello"; }) aspect.includes; 22 22 + }; 23 23 + }; 24 24 + aspectTwo.__functor = 25 25 + _aspect: 26 26 + { message }: 27 27 + { 28 28 + classOne.bar = [ message ]; 29 29 + }; 30 30 + }; 31 31 + }; 32 32 + 33 33 + expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 34 34 + expected = [ 35 35 + "hello" 36 36 + "from-functor" 37 37 + ]; 38 38 + in 39 39 + { 40 40 + inherit expr expected; 41 41 + }; 42 42 + }

+37

checkmate/modules/tests/aspect_dependencies.nix

··· 1 1 + { 2 2 + mkFlake, 3 3 + evalMod, 4 4 + lib, 5 5 + ... 6 6 + }: 7 7 + { 8 8 + 9 9 + flake.tests."test dependencies on aspects" = 10 10 + let 11 11 + flake = mkFlake { 12 12 + flake.aspects = 13 13 + { aspects, ... }: 14 14 + { 15 15 + aspectOne = { 16 16 + description = "os config"; 17 17 + includes = with aspects; [ aspectTwo ]; 18 18 + classOne.bar = [ "os" ]; 19 19 + }; 20 20 + 21 21 + aspectTwo = { 22 22 + description = "user config at os level"; 23 23 + classOne.bar = [ "user" ]; 24 24 + }; 25 25 + }; 26 26 + }; 27 27 + expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 28 28 + expected = [ 29 29 + "os" 30 30 + "user" 31 31 + ]; 32 32 + in 33 33 + { 34 34 + inherit expr expected; 35 35 + }; 36 36 + 37 37 + }

+58

checkmate/modules/tests/aspect_fixpoint.nix

··· 1 1 + { 2 2 + lib, 3 3 + mkFlake, 4 4 + evalMod, 5 5 + ... 6 6 + }: 7 7 + { 8 8 + 9 9 + flake.tests."test provides using fixpoints" = 10 10 + let 11 11 + flake = mkFlake { 12 12 + flake.aspects = 13 13 + { aspects, ... }@top: 14 14 + { 15 15 + aspectOne = { 16 16 + classOne.bar = [ "1" ]; 17 17 + includes = [ 18 18 + aspects.aspectTwo 19 19 + ]; 20 20 + }; 21 21 + 22 22 + aspectTwo = { 23 23 + classOne.bar = [ "2" ]; 24 24 + includes = [ aspects.aspectTwo.provides.three-and-four-and-five ]; 25 25 + provides = 26 26 + { aspects, ... }: 27 27 + { 28 28 + three-and-four-and-five = { 29 29 + classOne.bar = [ "3" ]; 30 30 + includes = [ 31 31 + aspects.four 32 32 + top.aspects.five 33 33 + ]; 34 34 + }; 35 35 + four = { 36 36 + classOne.bar = [ "4" ]; 37 37 + }; 38 38 + }; 39 39 + }; 40 40 + 41 41 + five.classOne.bar = [ "5" ]; 42 42 + }; 43 43 + }; 44 44 + 45 45 + expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 46 46 + expected = [ 47 47 + "1" 48 48 + "2" 49 49 + "3" 50 50 + "4" 51 51 + "5" 52 52 + ]; 53 53 + in 54 54 + { 55 55 + inherit expr expected; 56 56 + }; 57 57 + 58 58 + }

+54

checkmate/modules/tests/aspect_modules_resolved.nix

··· 1 1 + { 2 2 + lib, 3 3 + mkFlake, 4 4 + evalMod, 5 5 + fooOpt, 6 6 + ... 7 7 + }: 8 8 + { 9 9 + 10 10 + flake.tests."test modules resolved" = 11 11 + let 12 12 + flake = mkFlake { 13 13 + flake.aspects = 14 14 + { aspects, ... }: 15 15 + { 16 16 + aspectOne = { 17 17 + name = "one"; 18 18 + includes = [ aspects.aspectOne.provides.dos ]; 19 19 + classOne.bar = [ "zzz" ]; 20 20 + provides.dos = 21 21 + { aspect-chain, ... }: 22 22 + { 23 23 + name = "dos"; 24 24 + includes = [ aspects.aspectOne.provides.tres ]; 25 25 + classOne.bar = map (x: x.name) aspect-chain; 26 26 + }; 27 27 + 28 28 + provides.tres = 29 29 + { aspect-chain, ... }: 30 30 + { 31 31 + name = "tres"; 32 32 + classOne.bar = [ (lib.last aspect-chain).name ]; 33 33 + }; 34 34 + }; 35 35 + }; 36 36 + }; 37 37 + mod = { 38 38 + imports = [ 39 39 + fooOpt 40 40 + (flake.aspects.aspectOne.modules.classOne) 41 41 + ]; 42 42 + }; 43 43 + expr = lib.sort (a: b: a < b) (evalMod "classOne" mod).bar; 44 44 + expected = [ 45 45 + "dos" 46 46 + "one" 47 47 + "zzz" 48 48 + ]; 49 49 + in 50 50 + { 51 51 + inherit expr expected; 52 52 + }; 53 53 + 54 54 + }

+34

checkmate/modules/tests/aspect_parametric.nix

··· 1 1 + { 2 2 + mkFlake, 3 3 + evalMod, 4 4 + lib, 5 5 + ... 6 6 + }: 7 7 + { 8 8 + 9 9 + flake.tests."test provides parametrized modules" = 10 10 + let 11 11 + flake = mkFlake { 12 12 + flake.aspects = 13 13 + { aspects, ... }: 14 14 + { 15 15 + aspectOne.includes = [ (aspects.aspectTwo.provides.hello "mundo") ]; 16 16 + aspectOne.classOne.bar = [ "1" ]; 17 17 + 18 18 + aspectTwo.provides.hello = world: { 19 19 + classOne.bar = [ world ]; 20 20 + }; 21 21 + }; 22 22 + }; 23 23 + 24 24 + expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 25 25 + expected = [ 26 26 + "1" 27 27 + "mundo" 28 28 + ]; 29 29 + in 30 30 + { 31 31 + inherit expr expected; 32 32 + }; 33 33 + 34 34 + }

+63

checkmate/modules/tests/aspect_provides.nix

··· 1 1 + { 2 2 + lib, 3 3 + mkFlake, 4 4 + evalMod, 5 5 + ... 6 6 + }: 7 7 + { 8 8 + 9 9 + flake.tests."test provides" = 10 10 + let 11 11 + flake = mkFlake { 12 12 + flake.aspects = 13 13 + { aspects, ... }: 14 14 + { 15 15 + aspectOne.includes = with aspects.aspectTwo.provides; [ 16 16 + foo 17 17 + bar 18 18 + ]; 19 19 + aspectOne.classOne = { }; # must be present for mixing dependencies. 20 20 + aspectTwo = { 21 21 + classOne.bar = [ "class one not included" ]; 22 22 + classTwo.bar = [ "class two not included" ]; 23 23 + provides.foo = 24 24 + { class, aspect-chain }: 25 25 + { 26 26 + name = "aspectTwo.foo"; 27 27 + description = "aspectTwo foo provided"; 28 28 + includes = [ 29 29 + aspects.aspectThree.provides.moo 30 30 + aspects.aspectTwo.provides.baz 31 31 + ]; 32 32 + classOne.bar = [ "two:${class}:${lib.concatStringsSep "/" (lib.map (x: x.name) aspect-chain)}" ]; 33 33 + classTwo.bar = [ "foo class two not included" ]; 34 34 + }; 35 35 + # a provider can be immediately an aspect object. 36 36 + provides.bar = { 37 37 + # classOne is missing on bar 38 38 + classTwo.bar = [ "bar class two not included" ]; 39 39 + }; 40 40 + # _ is an shortcut alias of provides. 41 41 + _.baz = { 42 42 + # classOne is missing on bar 43 43 + classTwo.bar = [ "baz" ]; 44 44 + }; 45 45 + }; 46 46 + aspectThree.provides.moo = 47 47 + { aspect-chain, class }: 48 48 + { 49 49 + classOne.bar = [ "three:${class}:${lib.concatStringsSep "/" (lib.map (x: x.name) aspect-chain)}" ]; 50 50 + }; 51 51 + }; 52 52 + }; 53 53 + expr = lib.sort (a: b: a < b) (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 54 54 + expected = [ 55 55 + "three:classOne:aspectOne/aspectTwo.foo" 56 56 + "two:classOne:aspectOne" 57 57 + ]; 58 58 + in 59 59 + { 60 60 + inherit expr expected; 61 61 + }; 62 62 + 63 63 + }

+41

checkmate/modules/tests/aspect_toplevel_parametric.nix

··· 1 1 + { 2 2 + mkFlake, 3 3 + evalMod, 4 4 + ... 5 5 + }: 6 6 + { 7 7 + 8 8 + flake.tests."test define top-level context-aware aspect" = 9 9 + let 10 10 + flake = mkFlake { 11 11 + flake.aspects = 12 12 + { aspects, ... }: 13 13 + { 14 14 + aspectOne = { 15 15 + classOne.bar = [ "should-not-be-present" ]; 16 16 + includes = [ aspects.aspectTwo ]; 17 17 + __functor = aspect: { 18 18 + includes = [ 19 19 + { classOne.bar = [ "from-functor" ]; } 20 20 + ] 21 21 + ++ map (f: f { message = "hello"; }) aspect.includes; 22 22 + }; 23 23 + }; 24 24 + aspectTwo = 25 25 + { message }: 26 26 + { 27 27 + classOne.bar = [ message ]; 28 28 + }; 29 29 + }; 30 30 + }; 31 31 + 32 32 + expr = (evalMod "classOne" flake.modules.classOne.aspectOne).bar; 33 33 + expected = [ 34 34 + "hello" 35 35 + "from-functor" 36 36 + ]; 37 37 + in 38 38 + { 39 39 + inherit expr expected; 40 40 + }; 41 41 + }

+29

checkmate/modules/tests/default_empty.nix

··· 1 1 + { 2 2 + inputs, 3 3 + targetMod, 4 4 + ... 5 5 + }: 6 6 + { 7 7 + 8 8 + flake.tests."test provides default" = 9 9 + let 10 10 + flake = 11 11 + inputs.flake-parts.lib.mkFlake 12 12 + { 13 13 + inputs.self = [ ]; 14 14 + moduleLocation = builtins.toString ./.; 15 15 + } 16 16 + { 17 17 + systems = [ ]; 18 18 + imports = [ 19 19 + targetMod 20 20 + inputs.flake-parts.flakeModules.modules 21 21 + ]; 22 22 + }; 23 23 + expr = flake.modules; 24 24 + expected = { }; 25 25 + in 26 26 + { 27 27 + inherit expr expected; 28 28 + }; 29 29 + }

+28

checkmate/modules/tests/tranpose_flake_modules.nix

··· 1 1 + { 2 2 + mkFlake, 3 3 + evalMod, 4 4 + ... 5 5 + }: 6 6 + { 7 7 + 8 8 + flake.tests."test transposes to flake.modules" = 9 9 + let 10 10 + flake = mkFlake { 11 11 + flake.aspects.aspectOne = { 12 12 + classOne.foo = "niri"; 13 13 + classTwo.foo = "paper.spoon"; 14 14 + }; 15 15 + }; 16 16 + expr = { 17 17 + classOne = (evalMod "classOne" flake.modules.classOne.aspectOne).foo; 18 18 + classTwo = (evalMod "classTwo" flake.modules.classTwo.aspectOne).foo; 19 19 + }; 20 20 + expected = { 21 21 + classOne = "niri"; 22 22 + classTwo = "paper.spoon"; 23 23 + }; 24 24 + in 25 25 + { 26 26 + inherit expr expected; 27 27 + }; 28 28 + }

+15

checkmate/modules/tests/transpose_common.nix

··· 1 1 + { transpose, ... }: 2 2 + { 3 3 + 4 4 + flake.tests."test transpose common childs become one parent" = { 5 5 + expr = transpose { 6 6 + a.b = 1; 7 7 + c.b = 2; 8 8 + }; 9 9 + expected.b = { 10 10 + a = 1; 11 11 + c = 2; 12 12 + }; 13 13 + }; 14 14 + 15 15 + }

+10

checkmate/modules/tests/transpose_swap.nix

··· 1 1 + { transpose, ... }: 2 2 + { 3 3 + 4 4 + flake.tests."test transpose swaps parent and child attrNames" = { 5 5 + expr = transpose { a.b.c = 1; }; 6 6 + expected = { 7 7 + b.a.c = 1; 8 8 + }; 9 9 + }; 10 10 + }

+44

checkmate/modules/tests/without_flakes.nix

··· 1 1 + { lib, targetLib, ... }: 2 2 + { 3 3 + 4 4 + flake.tests."test usage without flakes" = 5 5 + let 6 6 + flake-aspects-lib = import targetLib lib; 7 7 + # first eval is like evaling the flake. 8 8 + first = lib.evalModules { 9 9 + modules = [ 10 10 + (flake-aspects-lib.new-scope "hello") 11 11 + { 12 12 + hello.aspects = 13 13 + { aspects, ... }: 14 14 + { 15 15 + a.b.c = [ "world" ]; 16 16 + a.includes = [ aspects.x ]; 17 17 + x.b = 18 18 + { lib, ... }: 19 19 + { 20 20 + c = lib.splitString " " "mundo cruel"; 21 21 + }; 22 22 + }; 23 23 + } 24 24 + ]; 25 25 + }; 26 26 + # second eval is like evaling its nixosConfiguration 27 27 + second = lib.evalModules { 28 28 + modules = [ 29 29 + { options.c = lib.mkOption { type = lib.types.listOf lib.types.str; }; } 30 30 + first.config.hello.modules.b.a 31 31 + ]; 32 32 + }; 33 33 + expr = lib.sort (a: b: a < b) second.config.c; 34 34 + expected = [ 35 35 + "cruel" 36 36 + "mundo" 37 37 + "world" 38 38 + ]; 39 39 + in 40 40 + { 41 41 + inherit expr expected; 42 42 + }; 43 43 + 44 44 + }

+3 -9

nix/types.nix

··· 5 5 aspectsType = lib.types.submodule ( 6 6 { config, ... }: 7 7 { 8 8 - freeformType = lib.types.attrsOf (lib.types.either aspectSubmoduleAttrs providerType); 8 8 + freeformType = lib.types.attrsOf providerType; 9 9 config._module.args.aspects = config; 10 10 } 11 11 ); ··· 30 30 ); 31 31 32 32 functionProviderType = lib.types.either functionToAspect (lib.types.functionTo providerType); 33 33 - providerType = lib.types.either functionProviderType aspectSubmodule; 33 33 + providerType = lib.types.either aspectSubmoduleAttrs functionProviderType; 34 34 35 35 aspectSubmoduleAttrs = lib.types.addCheck aspectSubmodule ( 36 36 m: (!builtins.isFunction m) || (isAspectSubmoduleFn m) ··· 78 78 options.provides = lib.mkOption { 79 79 description = "Providers of aspect for other aspects"; 80 80 default = { }; 81 81 - type = lib.types.submodule ( 82 82 - { config, ... }: 83 83 - { 84 84 - freeformType = lib.types.attrsOf providerType; 85 85 - config._module.args.provides = config; 86 86 - } 87 87 - ); 81 81 + type = aspectsType; 88 82 }; 89 83 options.__functor = lib.mkOption { 90 84 internal = true;