commit 665344f14839ea286a7aeb329fbf4f44da268ce4 · pyrox.dev/nixpkgs

+6

lib/tests/modules.sh

···

       293
       293
        
       checkConfigError 'The option .int.a. is used but not defined' config.int.a ./emptyValues.nix

     

       294
       294
        
       checkConfigError 'The option .nonEmptyList.a. is used but not defined' config.nonEmptyList.a ./emptyValues.nix

     

       295
       295
        
       

     

       296
       296
       +
       ## types.raw

     

       297
       297
       +
       checkConfigOutput "{ foo = <CODE>; }" config.unprocessedNesting ./raw.nix

     

       298
       298
       +
       checkConfigOutput "10" config.processedToplevel ./raw.nix

     

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

     

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

     

       301
       301
       +
       

     

       296
       302
        
       cat <<EOF

     

       297
       303
        
       ====== module tests ======

     

       298
       304
        
       $pass Pass

+30

lib/tests/modules/raw.nix

···

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

     

       2
       2
       +
       

     

       3
       3
       +
         options = {

     

       4
       4
       +
           processedToplevel = lib.mkOption {

     

       5
       5
       +
             type = lib.types.raw;

     

       6
       6
       +
           };

     

       7
       7
       +
           unprocessedNesting = lib.mkOption {

     

       8
       8
       +
             type = lib.types.raw;

     

       9
       9
       +
           };

     

       10
       10
       +
           multiple = lib.mkOption {

     

       11
       11
       +
             type = lib.types.raw;

     

       12
       12
       +
           };

     

       13
       13
       +
           priorities = lib.mkOption {

     

       14
       14
       +
             type = lib.types.raw;

     

       15
       15
       +
           };

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         config = {

     

       19
       19
       +
           processedToplevel = lib.mkIf true 10;

     

       20
       20
       +
           unprocessedNesting.foo = throw "foo";

     

       21
       21
       +
           multiple = lib.mkMerge [

     

       22
       22
       +
             "foo"

     

       23
       23
       +
             "foo"

     

       24
       24
       +
           ];

     

       25
       25
       +
           priorities = lib.mkMerge [

     

       26
       26
       +
             "foo"

     

       27
       27
       +
             (lib.mkForce "bar")

     

       28
       28
       +
           ];

     

       29
       29
       +
         };

     

       30
       30
       +
       }

+7

lib/types.nix

···

       162
       162
        
         # nixos/doc/manual/development/option-types.xml!

     

       163
       163
        
         types = rec {

     

       164
       164
        
       

     

       165
       165
       +
           raw = mkOptionType rec {

     

       166
       166
       +
             name = "raw";

     

       167
       167
       +
             description = "raw value";

     

       168
       168
       +
             check = value: true;

     

       169
       169
       +
             merge = mergeOneOption;

     

       170
       170
       +
           };

     

       171
       171
       +
       

     

       165
       172
        
           anything = mkOptionType {

     

       166
       173
        
             name = "anything";

     

       167
       174
        
             description = "anything";

+11

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

···

       63
       63
        
           ```

     

       64
       64
        
           :::

     

       65
       65
        
       

     

       66
       66
       +
       `types.raw`

     

       67
       67
       +
       

     

       68
       68
       +
       :   A type which doesn't do any checking, merging or nested evaluation. It

     

       69
       69
       +
           accepts a single arbitrary value that is not recursed into, making it

     

       70
       70
       +
           useful for values coming from outside the module system, such as package

     

       71
       71
       +
           sets or arbitrary data. Options of this type are still evaluated according

     

       72
       72
       +
           to priorities and conditionals, so `mkForce`, `mkIf` and co. still work on

     

       73
       73
       +
           the option value itself, but not for any value nested within it. This type

     

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

     

       75
       75
       +
           desirable.

     

       76
       76
       +
       

     

       66
       77
        
       `types.attrs`

     

       67
       78
        
       

     

       68
       79
        
       :   A free-form attribute set.

+19

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

···

       94
       94
        
             </varlistentry>

     

       95
       95
        
             <varlistentry>

     

       96
       96
        
               <term>

     

       97
       97
       +
                 <literal>types.raw</literal>

     

       98
       98
       +
               </term>

     

       99
       99
       +
               <listitem>

     

       100
       100
       +
                 <para>

     

       101
       101
       +
                   A type which doesn’t do any checking, merging or nested

     

       102
       102
       +
                   evaluation. It accepts a single arbitrary value that is not

     

       103
       103
       +
                   recursed into, making it useful for values coming from

     

       104
       104
       +
                   outside the module system, such as package sets or arbitrary

     

       105
       105
       +
                   data. Options of this type are still evaluated according to

     

       106
       106
       +
                   priorities and conditionals, so <literal>mkForce</literal>,

     

       107
       107
       +
                   <literal>mkIf</literal> and co. still work on the option

     

       108
       108
       +
                   value itself, but not for any value nested within it. This

     

       109
       109
       +
                   type should only be used when checking, merging and nested

     

       110
       110
       +
                   evaluation are not desirable.

     

       111
       111
       +
                 </para>

     

       112
       112
       +
               </listitem>

     

       113
       113
       +
             </varlistentry>

     

       114
       114
       +
             <varlistentry>

     

       115
       115
       +
               <term>

     

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

     

       98
       117
        
               </term>

     

       99
       118
        
               <listitem>