commit b97742c66ca497272c9fcbf1135a9f49155cc289 · pyrox.dev/nixpkgs

+62 -12

lib/modules.nix

···

       9
       9
        
           catAttrs

     

       10
       10
        
           concatLists

     

       11
       11
        
           concatMap

     

       12
       12
       -
           count

     

       12
       12
       +
           concatStringsSep

     

       13
       13
        
           elem

     

       14
       14
        
           filter

     

       15
       15
        
           findFirst

     
···

       47
       47
        
           showOption

     

       48
       48
        
           unknownModule

     

       49
       49
        
           ;

     

       50
       50
       +
       

     

       51
       51
       +
         showDeclPrefix = loc: decl: prefix:

     

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

     

       53
       53
       +
         showRawDecls = loc: decls:

     

       54
       54
       +
           concatStringsSep "\n"

     

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

     

       56
       56
       +
               (concatMap

     

       57
       57
       +
                 (decl: map

     

       58
       58
       +
                   (showDeclPrefix loc decl)

     

       59
       59
       +
                   (attrNames decl.options)

     

       60
       60
       +
                 )

     

       61
       61
       +
                 decls

     

       62
       62
       +
             ));

     

       63
       63
       +
       

     

       50
       64
        
       in

     

       51
       65
        
       

     

       52
       66
        
       rec {

     
···

       474
       488
        
                 [{ inherit (module) file; inherit value; }]

     

       475
       489
        
               ) configs;

     

       476
       490
        
       

     

       491
       491
       +
             # Convert an option tree decl to a submodule option decl

     

       492
       492
       +
             optionTreeToOption = decl:

     

       493
       493
       +
               if isOption decl.options

     

       494
       494
       +
               then decl

     

       495
       495
       +
               else decl // {

     

       496
       496
       +
                   options = mkOption {

     

       497
       497
       +
                     type = types.submoduleWith {

     

       498
       498
       +
                       modules = [ { options = decl.options; } ];

     

       499
       499
       +
                       # `null` is not intended for use by modules. It is an internal

     

       500
       500
       +
                       # value that means "whatever the user has declared elsewhere".

     

       501
       501
       +
                       # This might become obsolete with https://github.com/NixOS/nixpkgs/issues/162398

     

       502
       502
       +
                       shorthandOnlyDefinesConfig = null;

     

       503
       503
       +
                     };

     

       504
       504
       +
                   };

     

       505
       505
       +
                 };

     

       506
       506
       +
       

     

       477
       507
        
             resultsByName = mapAttrs (name: decls:

     

       478
       508
        
               # We're descending into attribute ‘name’.

     

       479
       509
        
               let

     

       480
       510
        
                 loc = prefix ++ [name];

     

       481
       511
        
                 defns = defnsByName.${name} or [];

     

       482
       512
        
                 defns' = defnsByName'.${name} or [];

     

       483
       483
       -
                 nrOptions = count (m: isOption m.options) decls;

     

       513
       513
       +
                 optionDecls = filter (m: isOption m.options) decls;

     

       484
       514
        
               in

     

       485
       485
       -
                 if nrOptions == length decls then

     

       515
       515
       +
                 if length optionDecls == length decls then

     

       486
       516
        
                   let opt = fixupOptionType loc (mergeOptionDecls loc decls);

     

       487
       517
        
                   in {

     

       488
       518
        
                     matchedOptions = evalOptionValue loc opt defns';

     

       489
       519
        
                     unmatchedDefns = [];

     

       490
       520
        
                   }

     

       491
       491
       -
                 else if nrOptions != 0 then

     

       492
       492
       -
                   let

     

       493
       493
       -
                     firstOption = findFirst (m: isOption m.options) "" decls;

     

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

     

       495
       495
       -
                   in

     

       496
       496
       -
                     throw "The option `${showOption loc}' in `${firstOption._file}' is a prefix of options in `${firstNonOption._file}'."

     

       521
       521
       +
                 else if optionDecls != [] then

     

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

     

       523
       523
       +
                     # Raw options can only be merged into submodules. Merging into

     

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

     

       525
       525
       +
                     # attrset as a `attrsOf submodule`. User declares option

     

       526
       526
       +
                     # attrset.foo.bar, this could mean:

     

       527
       527
       +
                     #  a. option `bar` is only available in `attrset.foo`

     

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

     

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

     

       530
       530
       +
                     #  d. magically combine (a) and (c).

     

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

     

       532
       532
       +
                     then

     

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

     

       534
       534
       +
                       in {

     

       535
       535
       +
                         matchedOptions = evalOptionValue loc opt defns';

     

       536
       536
       +
                         unmatchedDefns = [];

     

       537
       537
       +
                       }

     

       538
       538
       +
                     else

     

       539
       539
       +
                       let

     

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

     

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

     

       542
       542
       +
                       in

     

       543
       543
       +
                       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${

     

       544
       544
       +
                         showRawDecls loc nonOptions

     

       545
       545
       +
                       }"

     

       497
       546
        
                 else

     

       498
       547
        
                   mergeModules' loc decls defns) declsByName;

     

       499
       548
        
       

     
···

       753
       802
        
             compare = a: b: (a.priority or 1000) < (b.priority or 1000);

     

       754
       803
        
           in sort compare defs';

     

       755
       804
        
       

     

       756
       756
       -
         /* Hack for backward compatibility: convert options of type

     

       757
       757
       -
            optionSet to options of type submodule.  FIXME: remove

     

       758
       758
       -
            eventually. */

     

       759
       805
        
         fixupOptionType = loc: opt:

     

       760
       806
        
           let

     

       761
       807
        
             options = opt.options or

     

       762
       808
        
               (throw "Option `${showOption loc}' has type optionSet but has no option attribute, in ${showFiles opt.declarations}.");

     

       809
       809
       +
       

     

       810
       810
       +
             # Hack for backward compatibility: convert options of type

     

       811
       811
       +
             # optionSet to options of type submodule.  FIXME: remove

     

       812
       812
       +
             # eventually.

     

       763
       813
        
             f = tp:

     

       764
       814
        
               if tp.name == "option set" || tp.name == "submodule" then

     

       765
       815
        
                 throw "The option ${showOption loc} uses submodules without a wrapping type, in ${showFiles opt.declarations}."

+13

lib/tests/modules.sh

···

       62
       62
        
       checkConfigOutput '^false$' config.enable ./declare-enable.nix

     

       63
       63
        
       checkConfigError 'The option .* does not exist. Definition values:\n\s*- In .*: true' config.enable ./define-enable.nix

     

       64
       64
        
       

     

       65
       65
       +
       checkConfigOutput '^1$' config.bare-submodule.nested ./declare-bare-submodule.nix ./declare-bare-submodule-nested-option.nix

     

       66
       66
       +
       checkConfigOutput '^2$' config.bare-submodule.deep ./declare-bare-submodule.nix ./declare-bare-submodule-deep-option.nix

     

       67
       67
       +
       checkConfigOutput '^42$' config.bare-submodule.nested ./declare-bare-submodule.nix ./declare-bare-submodule-nested-option.nix ./declare-bare-submodule-deep-option.nix ./define-bare-submodule-values.nix

     

       68
       68
       +
       checkConfigOutput '^420$' config.bare-submodule.deep ./declare-bare-submodule.nix ./declare-bare-submodule-nested-option.nix ./declare-bare-submodule-deep-option.nix ./define-bare-submodule-values.nix

     

       69
       69
       +
       checkConfigOutput '^2$' config.bare-submodule.deep ./declare-bare-submodule.nix ./declare-bare-submodule-deep-option.nix ./define-shorthandOnlyDefinesConfig-true.nix

     

       70
       70
       +
       checkConfigError 'The option .bare-submodule.deep. in .*/declare-bare-submodule-deep-option.nix. is already declared in .*/declare-bare-submodule-deep-option-duplicate.nix' config.bare-submodule.deep ./declare-bare-submodule.nix ./declare-bare-submodule-deep-option.nix  ./declare-bare-submodule-deep-option-duplicate.nix

     

       71
       71
       +
       

     

       65
       72
        
       # Check integer types.

     

       66
       73
        
       # unsigned

     

       67
       74
        
       checkConfigOutput '^42$' config.value ./declare-int-unsigned-value.nix ./define-value-int-positive.nix

     
···

       303
       310
        
       checkConfigOutput "10" config.processedToplevel ./raw.nix

     

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

     

       305
       312
        
       checkConfigOutput "bar" config.priorities ./raw.nix

     

       313
       313
       +
       

     

       314
       314
       +
       ## Option collision

     

       315
       315
       +
       checkConfigError \

     

       316
       316
       +
         '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.' \

     

       317
       317
       +
         config.set \

     

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

     

       306
       319
        
       

     

       307
       320
        
       # Test that types.optionType merges types correctly

     

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

+10

lib/tests/modules/declare-bare-submodule-deep-option-duplicate.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types;

     

       4
       4
       +
       in

     

       5
       5
       +
       {

     

       6
       6
       +
         options.bare-submodule.deep = mkOption {

     

       7
       7
       +
           type = types.int;

     

       8
       8
       +
           default = 2;

     

       9
       9
       +
         };

     

       10
       10
       +
       }

+10

lib/tests/modules/declare-bare-submodule-deep-option.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types;

     

       4
       4
       +
       in

     

       5
       5
       +
       {

     

       6
       6
       +
         options.bare-submodule.deep = mkOption {

     

       7
       7
       +
           type = types.int;

     

       8
       8
       +
           default = 2;

     

       9
       9
       +
         };

     

       10
       10
       +
       }

+19

lib/tests/modules/declare-bare-submodule-nested-option.nix

···

       1
       1
       +
       { config, lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types;

     

       4
       4
       +
       in

     

       5
       5
       +
       {

     

       6
       6
       +
         options.bare-submodule = mkOption {

     

       7
       7
       +
           type = types.submoduleWith {

     

       8
       8
       +
             shorthandOnlyDefinesConfig = config.shorthandOnlyDefinesConfig;

     

       9
       9
       +
             modules = [

     

       10
       10
       +
               {

     

       11
       11
       +
                 options.nested = mkOption {

     

       12
       12
       +
                   type = types.int;

     

       13
       13
       +
                   default = 1;

     

       14
       14
       +
                 };

     

       15
       15
       +
               }

     

       16
       16
       +
             ];

     

       17
       17
       +
           };

     

       18
       18
       +
         };

     

       19
       19
       +
       }

+18

lib/tests/modules/declare-bare-submodule.nix

···

       1
       1
       +
       { config, lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types;

     

       4
       4
       +
       in

     

       5
       5
       +
       {

     

       6
       6
       +
         options.bare-submodule = mkOption {

     

       7
       7
       +
           type = types.submoduleWith {

     

       8
       8
       +
             modules = [ ];

     

       9
       9
       +
             shorthandOnlyDefinesConfig = config.shorthandOnlyDefinesConfig;

     

       10
       10
       +
           };

     

       11
       11
       +
           default = {};

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         # config-dependent options: won't recommend, but useful for making this test parameterized

     

       15
       15
       +
         options.shorthandOnlyDefinesConfig = mkOption {

     

       16
       16
       +
           default = false;

     

       17
       17
       +
         };

     

       18
       18
       +
       }

+12

lib/tests/modules/declare-set.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       {

     

       4
       4
       +
         options.set = lib.mkOption {

     

       5
       5
       +
           default = { };

     

       6
       6
       +
           example = { a = 1; };

     

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

     

       8
       8
       +
           description = ''

     

       9
       9
       +
             Some descriptive text

     

       10
       10
       +
           '';

     

       11
       11
       +
         };

     

       12
       12
       +
       }

+4

lib/tests/modules/define-bare-submodule-values.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         bare-submodule.nested = 42;

     

       3
       3
       +
         bare-submodule.deep = 420;

     

       4
       4
       +
       }

+1

lib/tests/modules/define-shorthandOnlyDefinesConfig-true.nix

···

       1
       1
       +
       { shorthandOnlyDefinesConfig = true; }

+15 -7

lib/types.nix

···

       572
       572
        
             let

     

       573
       573
        
               inherit (lib.modules) evalModules;

     

       574
       574
        
       

     

       575
       575
       -
               coerce = unify: value: if isFunction value

     

       576
       576
       -
                 then setFunctionArgs (args: unify (value args)) (functionArgs value)

     

       577
       577
       -
                 else unify (if shorthandOnlyDefinesConfig then { config = value; } else value);

     

       575
       575
       +
               shorthandToModule = if shorthandOnlyDefinesConfig == false

     

       576
       576
       +
                 then value: value

     

       577
       577
       +
                 else value: { config = value; };

     

       578
       578
        
       

     

       579
       579
        
               allModules = defs: imap1 (n: { value, file }:

     

       580
       580
       -
                 if isAttrs value || isFunction value then

     

       581
       581
       -
                   # Annotate the value with the location of its definition for better error messages

     

       582
       582
       -
                   coerce (lib.modules.unifyModuleSyntax file "${toString file}-${toString n}") value

     

       580
       580
       +
                 if isFunction value

     

       581
       581
       +
                 then setFunctionArgs

     

       582
       582
       +
                       (args: lib.modules.unifyModuleSyntax file "${toString file}-${toString n}" (value args))

     

       583
       583
       +
                       (functionArgs value)

     

       584
       584
       +
                 else if isAttrs value

     

       585
       585
       +
                 then

     

       586
       586
       +
                   lib.modules.unifyModuleSyntax file "${toString file}-${toString n}" (shorthandToModule value)

     

       583
       587
        
                 else value

     

       584
       588
        
               ) defs;

     

       585
       589
        
       

     
···

       647
       651
        
                     then lhs.specialArgs // rhs.specialArgs

     

       648
       652
        
                     else throw "A submoduleWith option is declared multiple times with the same specialArgs \"${toString (attrNames intersecting)}\"";

     

       649
       653
        
                   shorthandOnlyDefinesConfig =

     

       650
       650
       -
                     if lhs.shorthandOnlyDefinesConfig == rhs.shorthandOnlyDefinesConfig

     

       654
       654
       +
                     if lhs.shorthandOnlyDefinesConfig == null

     

       655
       655
       +
                     then rhs.shorthandOnlyDefinesConfig

     

       656
       656
       +
                     else if rhs.shorthandOnlyDefinesConfig == null

     

       657
       657
       +
                     then lhs.shorthandOnlyDefinesConfig

     

       658
       658
       +
                     else if lhs.shorthandOnlyDefinesConfig == rhs.shorthandOnlyDefinesConfig

     

       651
       659
        
                     then lhs.shorthandOnlyDefinesConfig

     

       652
       660
        
                     else throw "A submoduleWith option is declared multiple times with conflicting shorthandOnlyDefinesConfig values";

     

       653
       661
        
                 };