commit 5cbeddfde486ca5524baeaf3da6e8944075cf463 · pyrox.dev/nixpkgs

+7

lib/tests/modules.sh

···

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

     

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

     

       301
       301
        
       

     

       302
       302
       +
       # Test that types.optionType merges types correctly

     

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

     

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

     

       305
       305
       +
       

     

       306
       306
       +
       # Test that types.optionType correctly annotates option locations

     

       307
       307
       +
       checkConfigError 'The option .theOption.nested. in .other.nix. is already declared in .optionTypeFile.nix.' config.theOption.nested ./optionTypeFile.nix

     

       308
       308
       +
       

     

       302
       309
        
       cat <<EOF

     

       303
       310
        
       ====== module tests ======

     

       304
       311
        
       $pass Pass

+28

lib/tests/modules/optionTypeFile.nix

···

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

     

       2
       2
       +
       

     

       3
       3
       +
         _file = "optionTypeFile.nix";

     

       4
       4
       +
       

     

       5
       5
       +
         options.theType = lib.mkOption {

     

       6
       6
       +
           type = lib.types.optionType;

     

       7
       7
       +
         };

     

       8
       8
       +
       

     

       9
       9
       +
         options.theOption = lib.mkOption {

     

       10
       10
       +
           type = config.theType;

     

       11
       11
       +
           default = {};

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         config.theType = lib.mkMerge [

     

       15
       15
       +
           (lib.types.submodule {

     

       16
       16
       +
             options.nested = lib.mkOption {

     

       17
       17
       +
               type = lib.types.int;

     

       18
       18
       +
             };

     

       19
       19
       +
           })

     

       20
       20
       +
           (lib.types.submodule {

     

       21
       21
       +
             _file = "other.nix";

     

       22
       22
       +
             options.nested = lib.mkOption {

     

       23
       23
       +
               type = lib.types.str;

     

       24
       24
       +
             };

     

       25
       25
       +
           })

     

       26
       26
       +
         ];

     

       27
       27
       +
       

     

       28
       28
       +
       }

+27

lib/tests/modules/optionTypeMerging.nix

···

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

     

       2
       2
       +
       

     

       3
       3
       +
         options.theType = lib.mkOption {

     

       4
       4
       +
           type = lib.types.optionType;

     

       5
       5
       +
         };

     

       6
       6
       +
       

     

       7
       7
       +
         options.theOption = lib.mkOption {

     

       8
       8
       +
           type = config.theType;

     

       9
       9
       +
         };

     

       10
       10
       +
       

     

       11
       11
       +
         config.theType = lib.mkMerge [

     

       12
       12
       +
           (lib.types.submodule {

     

       13
       13
       +
             options.int = lib.mkOption {

     

       14
       14
       +
               type = lib.types.int;

     

       15
       15
       +
               default = 10;

     

       16
       16
       +
             };

     

       17
       17
       +
           })

     

       18
       18
       +
           (lib.types.submodule {

     

       19
       19
       +
             options.str = lib.mkOption {

     

       20
       20
       +
               type = lib.types.str;

     

       21
       21
       +
             };

     

       22
       22
       +
           })

     

       23
       23
       +
         ];

     

       24
       24
       +
       

     

       25
       25
       +
         config.theOption.str = "hello";

     

       26
       26
       +
       

     

       27
       27
       +
       }

+30 -1

lib/types.nix

···

       61
       61
        
           boolToString

     

       62
       62
        
           ;

     

       63
       63
        
       

     

       64
       64
       -
         inherit (lib.modules) mergeDefinitions;

     

       64
       64
       +
         inherit (lib.modules)

     

       65
       65
       +
           mergeDefinitions

     

       66
       66
       +
           fixupOptionType

     

       67
       67
       +
           mergeOptionDecls

     

       68
       68
       +
           ;

     

       65
       69
        
         outer_types =

     

       66
       70
        
       rec {

     

       67
       71
        
         isType = type: x: (x._type or "") == type;

     
···

       523
       527
        
           submodule = modules: submoduleWith {

     

       524
       528
        
             shorthandOnlyDefinesConfig = true;

     

       525
       529
        
             modules = toList modules;

     

       530
       530
       +
           };

     

       531
       531
       +
       

     

       532
       532
       +
           # The type of a type!

     

       533
       533
       +
           optionType = mkOptionType {

     

       534
       534
       +
             name = "optionType";

     

       535
       535
       +
             description = "optionType";

     

       536
       536
       +
             check = value: value._type or null == "option-type";

     

       537
       537
       +
             merge = loc: defs:

     

       538
       538
       +
               let

     

       539
       539
       +
                 # Prepares the type definitions for mergeOptionDecls, which

     

       540
       540
       +
                 # annotates submodules types with file locations

     

       541
       541
       +
                 optionModules = map ({ value, file }:

     

       542
       542
       +
                   {

     

       543
       543
       +
                     _file = file;

     

       544
       544
       +
                     # There's no way to merge types directly from the module system,

     

       545
       545
       +
                     # but we can cheat a bit by just declaring an option with the type

     

       546
       546
       +
                     options = lib.mkOption {

     

       547
       547
       +
                       type = value;

     

       548
       548
       +
                     };

     

       549
       549
       +
                   }

     

       550
       550
       +
                 ) defs;

     

       551
       551
       +
                 # Merges all the types into a single one, including submodule merging.

     

       552
       552
       +
                 # This also propagates file information to all submodules

     

       553
       553
       +
                 mergedOption = fixupOptionType loc (mergeOptionDecls loc optionModules);

     

       554
       554
       +
               in mergedOption.type;

     

       526
       555
        
           };

     

       527
       556
        
       

     

       528
       557
        
           submoduleWith =

+7

nixos/doc/manual/development/option-types.section.md

···

       74
       74
        
           should only be used when checking, merging and nested evaluation are not

     

       75
       75
        
           desirable.

     

       76
       76
        
       

     

       77
       77
       +
       `types.optionType`

     

       78
       78
       +
       

     

       79
       79
       +
       :   The type of an option's type. Its merging operation ensures that nested

     

       80
       80
       +
           options have the correct file location annotated, and that if possible,

     

       81
       81
       +
           multiple option definitions are correctly merged together. The main use

     

       82
       82
       +
           case is as the type of the `_module.freeformType` option.

     

       83
       83
       +
       

     

       77
       84
        
       `types.attrs`

     

       78
       85
        
       

     

       79
       86
        
       :   A free-form attribute set.

+14

nixos/doc/manual/from_md/development/option-types.section.xml

···

       113
       113
        
             </varlistentry>

     

       114
       114
        
             <varlistentry>

     

       115
       115
        
               <term>

     

       116
       116
       +
                 <literal>types.optionType</literal>

     

       117
       117
       +
               </term>

     

       118
       118
       +
               <listitem>

     

       119
       119
       +
                 <para>

     

       120
       120
       +
                   The type of an option’s type. Its merging operation ensures

     

       121
       121
       +
                   that nested options have the correct file location

     

       122
       122
       +
                   annotated, and that if possible, multiple option definitions

     

       123
       123
       +
                   are correctly merged together. The main use case is as the

     

       124
       124
       +
                   type of the <literal>_module.freeformType</literal> option.

     

       125
       125
       +
                 </para>

     

       126
       126
       +
               </listitem>

     

       127
       127
       +
             </varlistentry>

     

       128
       128
       +
             <varlistentry>

     

       129
       129
       +
               <term>

     

       116
       130
        
                 <literal>types.attrs</literal>

     

       117
       131
        
               </term>

     

       118
       132
        
               <listitem>