commit dece37b83a46d488787859332e18286727b96cc4 · pyrox.dev/nixpkgs

+22 -5

lib/modules.nix

···

       60
       60
        
            it is to transparently move a set of modules to be a submodule of another

     

       61
       61
        
            config (as the proper arguments need to be replicated at each call to

     

       62
       62
        
            evalModules) and the less declarative the module set is. */

     

       63
       63
       -
         evalModules = { modules

     

       63
       63
       +
         evalModules = evalModulesArgs@

     

       64
       64
       +
                       { modules

     

       64
       65
        
                       , prefix ? []

     

       65
       66
        
                       , # This should only be used for special arguments that need to be evaluated

     

       66
       67
        
                         # when resolving module structure (like in imports). For everything else,

     
···

       183
       184
        
                   else throw baseMsg

     

       184
       185
        
               else null;

     

       185
       186
        
       

     

       186
       186
       -
             result = builtins.seq checkUnmatched {

     

       187
       187
       -
               inherit options;

     

       188
       188
       -
               config = removeAttrs config [ "_module" ];

     

       189
       189
       -
               inherit (config) _module;

     

       187
       187
       +
             checked = builtins.seq checkUnmatched;

     

       188
       188
       +
       

     

       189
       189
       +
             result = {

     

       190
       190
       +
               options = checked options;

     

       191
       191
       +
               config = checked (removeAttrs config [ "_module" ]);

     

       192
       192
       +
               _module = checked (config._module);

     

       193
       193
       +
       

     

       194
       194
       +
               extendModules = extendArgs@{

     

       195
       195
       +
                 modules ? [],

     

       196
       196
       +
                 specialArgs ? {},

     

       197
       197
       +
                 prefix ? [],

     

       198
       198
       +
                 }:

     

       199
       199
       +
                   evalModules (evalModulesArgs // {

     

       200
       200
       +
                     modules = evalModulesArgs.modules ++ modules;

     

       201
       201
       +
                     specialArgs = evalModulesArgs.specialArgs or {} // specialArgs;

     

       202
       202
       +
                     prefix = extendArgs.prefix or evalModulesArgs.prefix;

     

       203
       203
       +
                   });

     

       204
       204
       +
               type = lib.types.submoduleWith {

     

       205
       205
       +
                 inherit modules specialArgs;

     

       206
       206
       +
               };

     

       190
       207
        
             };

     

       191
       208
        
           in result;

     

       192
       209

lib/tests/modules.sh

···

       179
       179
        
       # which evaluates all the modules defined by the type)

     

       180
       180
        
       checkConfigOutput "submodule" options.submodule.type.description ./declare-submoduleWith-modules.nix

     

       181
       181
        
       

     

       182
       182
       +
       ## submodules can be declared using (evalModules {...}).type

     

       183
       183
       +
       checkConfigOutput "true" config.submodule.inner ./declare-submodule-via-evalModules.nix

     

       184
       184
       +
       checkConfigOutput "true" config.submodule.outer ./declare-submodule-via-evalModules.nix

     

       185
       185
       +
       # Should also be able to evaluate the type name (which evaluates freeformType,

     

       186
       186
       +
       # which evaluates all the modules defined by the type)

     

       187
       187
       +
       checkConfigOutput "submodule" options.submodule.type.description ./declare-submodule-via-evalModules.nix

     

       188
       188
       +
       

     

       182
       189
        
       ## Paths should be allowed as values and work as expected

     

       183
       190
        
       checkConfigOutput "true" config.submodule.enable ./declare-submoduleWith-path.nix

     

       184
       191

+28

lib/tests/modules/declare-submodule-via-evalModules.nix

···

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

     

       2
       2
       +
         options.submodule = lib.mkOption {

     

       3
       3
       +
           inherit (lib.evalModules {

     

       4
       4
       +
             modules = [

     

       5
       5
       +
               {

     

       6
       6
       +
                 options.inner = lib.mkOption {

     

       7
       7
       +
                   type = lib.types.bool;

     

       8
       8
       +
                   default = false;

     

       9
       9
       +
                 };

     

       10
       10
       +
               }

     

       11
       11
       +
             ];

     

       12
       12
       +
           }) type;

     

       13
       13
       +
           default = {};

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         config.submodule = lib.mkMerge [

     

       17
       17
       +
           ({ lib, ... }: {

     

       18
       18
       +
             options.outer = lib.mkOption {

     

       19
       19
       +
               type = lib.types.bool;

     

       20
       20
       +
               default = false;

     

       21
       21
       +
             };

     

       22
       22
       +
           })

     

       23
       23
       +
           {

     

       24
       24
       +
             inner = true;

     

       25
       25
       +
             outer = true;

     

       26
       26
       +
           }

     

       27
       27
       +
         ];

     

       28
       28
       +
       }

+28 -28

lib/types.nix

···

       505
       505
        
                 then setFunctionArgs (args: unify (value args)) (functionArgs value)

     

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

     

       507
       507
        
       

     

       508
       508
       -
               allModules = defs: modules ++ imap1 (n: { value, file }:

     

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

     

       509
       509
        
                 if isAttrs value || isFunction value then

     

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

     

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

     

       512
       512
        
                 else value

     

       513
       513
        
               ) defs;

     

       514
       514
        
       

     

       515
       515
       -
               freeformType = (evalModules {

     

       516
       516
       -
                 inherit modules specialArgs;

     

       517
       517
       -
                 args.name = "‹name›";

     

       518
       518
       -
               })._module.freeformType;

     

       515
       515
       +
               base = evalModules {

     

       516
       516
       +
                 inherit specialArgs;

     

       517
       517
       +
                 modules = [{

     

       518
       518
       +
                   # This is a work-around for the fact that some sub-modules,

     

       519
       519
       +
                   # such as the one included in an attribute set, expects an "args"

     

       520
       520
       +
                   # attribute to be given to the sub-module. As the option

     

       521
       521
       +
                   # evaluation does not have any specific attribute name yet, we

     

       522
       522
       +
                   # provide a default for the documentation and the freeform type.

     

       523
       523
       +
                   #

     

       524
       524
       +
                   # This is necessary as some option declaration might use the

     

       525
       525
       +
                   # "name" attribute given as argument of the submodule and use it

     

       526
       526
       +
                   # as the default of option declarations.

     

       527
       527
       +
                   #

     

       528
       528
       +
                   # We use lookalike unicode single angle quotation marks because

     

       529
       529
       +
                   # of the docbook transformation the options receive. In all uses

     

       530
       530
       +
                   # &gt; and &lt; wouldn't be encoded correctly so the encoded values

     

       531
       531
       +
                   # would be used, and use of `<` and `>` would break the XML document.

     

       532
       532
       +
                   # It shouldn't cause an issue since this is cosmetic for the manual.

     

       533
       533
       +
                   _module.args.name = lib.mkOptionDefault "‹name›";

     

       534
       534
       +
                 }] ++ modules;

     

       535
       535
       +
               };

     

       536
       536
       +
       

     

       537
       537
       +
               freeformType = base._module.freeformType;

     

       519
       538
        
       

     

       520
       539
        
             in

     

       521
       540
        
             mkOptionType rec {

     
···

       523
       542
        
               description = freeformType.description or name;

     

       524
       543
        
               check = x: isAttrs x || isFunction x || path.check x;

     

       525
       544
        
               merge = loc: defs:

     

       526
       526
       -
                 (evalModules {

     

       527
       527
       -
                   modules = allModules defs;

     

       528
       528
       -
                   inherit specialArgs;

     

       529
       529
       -
                   args.name = last loc;

     

       545
       545
       +
                 (base.extendModules {

     

       546
       546
       +
                   modules = [ { _module.args.name = last loc; } ] ++ allModules defs;

     

       530
       547
        
                   prefix = loc;

     

       531
       548
        
                 }).config;

     

       532
       549
        
               emptyValue = { value = {}; };

     

       533
       533
       -
               getSubOptions = prefix: (evalModules

     

       534
       534
       -
                 { inherit modules prefix specialArgs;

     

       535
       535
       -
                   # This is a work-around due to the fact that some sub-modules,

     

       536
       536
       -
                   # such as the one included in an attribute set, expects a "args"

     

       537
       537
       -
                   # attribute to be given to the sub-module. As the option

     

       538
       538
       -
                   # evaluation does not have any specific attribute name, we

     

       539
       539
       -
                   # provide a default one for the documentation.

     

       540
       540
       -
                   #

     

       541
       541
       -
                   # This is mandatory as some option declaration might use the

     

       542
       542
       -
                   # "name" attribute given as argument of the submodule and use it

     

       543
       543
       -
                   # as the default of option declarations.

     

       544
       544
       -
                   #

     

       545
       545
       -
                   # Using lookalike unicode single angle quotation marks because

     

       546
       546
       -
                   # of the docbook transformation the options receive. In all uses

     

       547
       547
       -
                   # &gt; and &lt; wouldn't be encoded correctly so the encoded values

     

       548
       548
       -
                   # would be used, and use of `<` and `>` would break the XML document.

     

       549
       549
       -
                   # It shouldn't cause an issue since this is cosmetic for the manual.

     

       550
       550
       -
                   args.name = "‹name›";

     

       551
       551
       -
                 }).options // optionalAttrs (freeformType != null) {

     

       550
       550
       +
               getSubOptions = prefix: (base.extendModules

     

       551
       551
       +
                 { inherit prefix; }).options // optionalAttrs (freeformType != null) {

     

       552
       552
        
                   # Expose the sub options of the freeform type. Note that the option

     

       553
       553
        
                   # discovery doesn't care about the attribute name used here, so this

     

       554
       554
        
                   # is just to avoid conflicts with potential options from the submodule