···

       
9
       
 
       
    catAttrs

     

       
10
       
 
       
    concatLists

     

       
11
       
 
       
    concatMap

     

       
0
       
 
       

     

       
12
       
 
       
    elem

     

       
13
       
 
       
    filter

     

       
14
       
 
       
    findFirst

     
···

       
46
       
 
       
    showOption

     

       
47
       
 
       
    unknownModule

     

       
48
       
 
       
    ;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
49
       
 
       
in

     

       
50
       
 
       


     

       
51
       
 
       
rec {

     
···

       
500
       
 
       
              unmatchedDefns = [];

     

       
501
       
 
       
            }

     

       
502
       
 
       
          else if optionDecls != [] then

     

       
503
       
-
       
              if (lib.head optionDecls).options.type.name == "submodule"

     

       
504
       
 
       
              # Raw options can only be merged into submodules. Merging into

     

       
505
       
 
       
              # attrsets might be nice, but ambiguous. Suppose we have

     

       
506
       
 
       
              # attrset as a `attrsOf submodule`. User declares option

     
···

       
509
       
 
       
              #  b. option `foo.bar` is available in all `attrset.*`

     

       
510
       
 
       
              #  c. reject and require "<name>" as a reminder that it behaves like (b).

     

       
511
       
 
       
              #  d. magically combine (a) and (c).

     

       
512
       
-
       
              # All options are merely syntax sugar though.

     

       
513
       
 
       
              then

     

       
514
       
 
       
                let opt = fixupOptionType loc (mergeOptionDecls loc (map optionTreeToOption decls));

     

       
515
       
 
       
                in {

     
···

       
519
       
 
       
              else

     

       
520
       
 
       
                let

     

       
521
       
 
       
                  firstNonOption = findFirst (m: !isOption m.options) "" decls;

     

       
0
       
 
       

     

       
522
       
 
       
                in

     

       
523
       
-
       
                throw "The option `${showOption loc}' in `${(lib.head optionDecls)._file}' is a prefix of options in `${firstNonOption._file}'."

     

       
0
       
 
       

     

       
0
       
 
       

     

       
524
       
 
       
          else

     

       
525
       
 
       
            mergeModules' loc decls defns) declsByName;

     

       
526
       
 
       


     

···

       
9
       
 
       
    catAttrs

     

       
10
       
 
       
    concatLists

     

       
11
       
 
       
    concatMap

     

       
12
       
+
       
    concatStringsSep

     

       
13
       
 
       
    elem

     

       
14
       
 
       
    filter

     

       
15
       
 
       
    findFirst

     
···

       
47
       
 
       
    showOption

     

       
48
       
 
       
    unknownModule

     

       
49
       
 
       
    ;

     

       
50
       
+
       


     

       
51
       
+
       
  showDeclPrefix = loc: decl: prefix:

     

       
52
       
+
       
    " - option(s) with prefix `${showOption (loc ++ [prefix])}' in module `${decl._file}'";

     

       
53
       
+
       
  showRawDecls = loc: decls:

     

       
54
       
+
       
    concatStringsSep "\n"

     

       
55
       
+
       
      (sort (a: b: a < b)

     

       
56
       
+
       
        (concatMap

     

       
57
       
+
       
          (decl: map

     

       
58
       
+
       
            (showDeclPrefix loc decl)

     

       
59
       
+
       
            (attrNames decl.options)

     

       
60
       
+
       
          )

     

       
61
       
+
       
          decls

     

       
62
       
+
       
      ));

     

       
63
       
+
       


     

       
64
       
 
       
in

     

       
65
       
 
       


     

       
66
       
 
       
rec {

     
···

       
515
       
 
       
              unmatchedDefns = [];

     

       
516
       
 
       
            }

     

       
517
       
 
       
          else if optionDecls != [] then

     

       
518
       
+
       
              if all (x: x.options.type.name == "submodule") optionDecls

     

       
519
       
 
       
              # Raw options can only be merged into submodules. Merging into

     

       
520
       
 
       
              # attrsets might be nice, but ambiguous. Suppose we have

     

       
521
       
 
       
              # attrset as a `attrsOf submodule`. User declares option

     
···

       
524
       
 
       
              #  b. option `foo.bar` is available in all `attrset.*`

     

       
525
       
 
       
              #  c. reject and require "<name>" as a reminder that it behaves like (b).

     

       
526
       
 
       
              #  d. magically combine (a) and (c).

     

       
527
       
+
       
              # All of the above are merely syntax sugar though.

     

       
528
       
 
       
              then

     

       
529
       
 
       
                let opt = fixupOptionType loc (mergeOptionDecls loc (map optionTreeToOption decls));

     

       
530
       
 
       
                in {

     
···

       
534
       
 
       
              else

     

       
535
       
 
       
                let

     

       
536
       
 
       
                  firstNonOption = findFirst (m: !isOption m.options) "" decls;

     

       
537
       
+
       
                  nonOptions = filter (m: !isOption m.options) decls;

     

       
538
       
 
       
                in

     

       
539
       
+
       
                throw "The option `${showOption loc}' in module `${(lib.head optionDecls)._file}' would be a parent of the following options, but its type `${(lib.head optionDecls).options.type.description or "<no description>"}' does not support nested options.\n${

     

       
540
       
+
       
                  showRawDecls loc nonOptions

     

       
541
       
+
       
                }"

     

       
542
       
 
       
          else

     

       
543
       
 
       
            mergeModules' loc decls defns) declsByName;

     

       
544
       
 
       


     

···

       
309
       
 
       
checkConfigError "The option .multiple. is defined multiple times" config.multiple ./raw.nix

     

       
310
       
 
       
checkConfigOutput "bar" config.priorities ./raw.nix

     

       
311
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
312
       
 
       
# Test that types.optionType merges types correctly

     

       
313
       
 
       
checkConfigOutput '^10$' config.theOption.int ./optionTypeMerging.nix

     

       
314
       
 
       
checkConfigOutput '^"hello"$' config.theOption.str ./optionTypeMerging.nix

     

···

       
309
       
 
       
checkConfigError "The option .multiple. is defined multiple times" config.multiple ./raw.nix

     

       
310
       
 
       
checkConfigOutput "bar" config.priorities ./raw.nix

     

       
311
       
 
       


     

       
312
       
+
       
## Option collision

     

       
313
       
+
       
checkConfigError \

     

       
314
       
+
       
  'The option .set. in module .*/declare-set.nix. would be a parent of the following options, but its type .attribute set of signed integers. does not support nested options.\n\s*- option[(]s[)] with prefix .set.enable. in module .*/declare-enable-nested.nix.' \

     

       
315
       
+
       
  config.set \

     

       
316
       
+
       
  ./declare-set.nix ./declare-enable-nested.nix

     

       
317
       
+
       


     

       
318
       
 
       
# Test that types.optionType merges types correctly

     

       
319
       
 
       
checkConfigOutput '^10$' config.theOption.int ./optionTypeMerging.nix

     

       
320
       
 
       
checkConfigOutput '^"hello"$' config.theOption.str ./optionTypeMerging.nix

     

···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
{ lib, ... }:

     

       
2
       
+
       


     

       
3
       
+
       
{

     

       
4
       
+
       
  options.set = lib.mkOption {

     

       
5
       
+
       
    default = { };

     

       
6
       
+
       
    example = { a = 1; };

     

       
7
       
+
       
    type = lib.types.attrsOf lib.types.int;

     

       
8
       
+
       
    description = ''

     

       
9
       
+
       
      Some descriptive text

     

       
10
       
+
       
    '';

     

       
11
       
+
       
  };

     

       
12
       
+
       
}