commit f37ba1976518f61217dcee655412288b09441cde · pyrox.dev/nixpkgs

+23 -5

lib/options.nix

···

       254
       254
        
           else if all isInt list && all (x: x == head list) list then head list

     

       255
       255
        
           else throw "Cannot merge definitions of `${showOption loc}'. Definition values:${showDefs defs}";

     

       256
       256
        
       

     

       257
       257
       +
         /*

     

       258
       258
       +
           Require a single definition.

     

       259
       259
       +
       

     

       260
       260
       +
           WARNING: Does not perform nested checks, as this does not run the merge function!

     

       261
       261
       +
           */

     

       257
       262
        
         mergeOneOption = mergeUniqueOption { message = ""; };

     

       258
       263
        
       

     

       259
       259
       -
         mergeUniqueOption = { message }: loc: defs:

     

       260
       260
       -
           if length defs == 1

     

       261
       261
       -
           then (head defs).value

     

       262
       262
       -
           else assert length defs > 1;

     

       263
       263
       -
             throw "The option `${showOption loc}' is defined multiple times while it's expected to be unique.\n${message}\nDefinition values:${showDefs defs}\n${prioritySuggestion}";

     

       264
       264
       +
         /*

     

       265
       265
       +
           Require a single definition.

     

       266
       266
       +
       

     

       267
       267
       +
           NOTE: When the type is not checked completely by check, pass a merge function for further checking (of sub-attributes, etc).

     

       268
       268
       +
          */

     

       269
       269
       +
         mergeUniqueOption = args@{

     

       270
       270
       +
             message,

     

       271
       271
       +
             # WARNING: the default merge function assumes that the definition is a valid (option) value. You MUST pass a merge function if the return value needs to be

     

       272
       272
       +
             #   - type checked beyond what .check does (which should be very litte; only on the value head; not attribute values, etc)

     

       273
       273
       +
             #   - if you want attribute values to be checked, or list items

     

       274
       274
       +
             #   - if you want coercedTo-like behavior to work

     

       275
       275
       +
             merge ? loc: defs: (head defs).value }:

     

       276
       276
       +
           loc: defs:

     

       277
       277
       +
             if length defs == 1

     

       278
       278
       +
             then merge loc defs

     

       279
       279
       +
             else

     

       280
       280
       +
               assert length defs > 1;

     

       281
       281
       +
               throw "The option `${showOption loc}' is defined multiple times while it's expected to be unique.\n${message}\nDefinition values:${showDefs defs}\n${prioritySuggestion}";

     

       264
       282
        
       

     

       265
       283
        
         /* "Merge" option definitions by checking that they all have the same value. */

     

       266
       284
        
         mergeEqualOption = loc: defs:

+10

lib/tests/modules.sh

···

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

     

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

     

       409
       409
        
       

     

       410
       410
       +
       # types.unique

     

       411
       411
       +
       #   requires a single definition

     

       412
       412
       +
       checkConfigError 'The option .examples\.merged. is defined multiple times while it.s expected to be unique' config.examples.merged.a ./types-unique.nix

     

       413
       413
       +
       #   user message is printed

     

       414
       414
       +
       checkConfigError 'We require a single definition, because seeing the whole value at once helps us maintain critical invariants of our system.' config.examples.merged.a ./types-unique.nix

     

       415
       415
       +
       #   let the inner merge function check the values (on demand)

     

       416
       416
       +
       checkConfigError 'A definition for option .examples\.badLazyType\.a. is not of type .string.' config.examples.badLazyType.a ./types-unique.nix

     

       417
       417
       +
       #   overriding still works (unlike option uniqueness)

     

       418
       418
       +
       checkConfigOutput '^"bee"$' config.examples.override.b ./types-unique.nix

     

       419
       419
       +
       

     

       410
       420
        
       ## types.raw

     

       411
       421
        
       checkConfigOutput '^true$' config.unprocessedNestingEvaluates.success ./raw.nix

     

       412
       422
        
       checkConfigOutput "10" config.processedToplevel ./raw.nix

+27

lib/tests/modules/types-unique.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types;

     

       4
       4
       +
       in

     

       5
       5
       +
       {

     

       6
       6
       +
         options.examples = mkOption {

     

       7
       7
       +
           type = types.lazyAttrsOf

     

       8
       8
       +
             (types.unique

     

       9
       9
       +
               { message = "We require a single definition, because seeing the whole value at once helps us maintain critical invariants of our system."; }

     

       10
       10
       +
               (types.attrsOf types.str));

     

       11
       11
       +
         };

     

       12
       12
       +
         imports = [

     

       13
       13
       +
           { examples.merged = { b = "bee"; }; }

     

       14
       14
       +
           { examples.override = lib.mkForce { b = "bee"; }; }

     

       15
       15
       +
         ];

     

       16
       16
       +
         config.examples = {

     

       17
       17
       +
           merged = {

     

       18
       18
       +
             a = "aye";

     

       19
       19
       +
           };

     

       20
       20
       +
           override = {

     

       21
       21
       +
             a = "aye";

     

       22
       22
       +
           };

     

       23
       23
       +
           badLazyType = {

     

       24
       24
       +
             a = true;

     

       25
       25
       +
           };

     

       26
       26
       +
         };

     

       27
       27
       +
       }

+2 -13

lib/types.nix

···

       614
       614
        
             nestedTypes.elemType = elemType;

     

       615
       615
        
           };

     

       616
       616
        
       

     

       617
       617
       -
           # Value of given type but with no merging (i.e. `uniq list`s are not concatenated).

     

       618
       618
       -
           uniq = elemType: mkOptionType rec {

     

       619
       619
       -
             name = "uniq";

     

       620
       620
       -
             inherit (elemType) description descriptionClass check;

     

       621
       621
       -
             merge = mergeOneOption;

     

       622
       622
       -
             emptyValue = elemType.emptyValue;

     

       623
       623
       -
             getSubOptions = elemType.getSubOptions;

     

       624
       624
       -
             getSubModules = elemType.getSubModules;

     

       625
       625
       -
             substSubModules = m: uniq (elemType.substSubModules m);

     

       626
       626
       -
             functor = (defaultFunctor name) // { wrapped = elemType; };

     

       627
       627
       -
             nestedTypes.elemType = elemType;

     

       628
       628
       -
           };

     

       617
       617
       +
           uniq = unique { message = ""; };

     

       629
       618
        
       

     

       630
       619
        
           unique = { message }: type: mkOptionType rec {

     

       631
       620
        
             name = "unique";

     

       632
       621
        
             inherit (type) description descriptionClass check;

     

       633
       633
       -
             merge = mergeUniqueOption { inherit message; };

     

       622
       622
       +
             merge = mergeUniqueOption { inherit message; inherit (type) merge; };

     

       634
       623
        
             emptyValue = type.emptyValue;

     

       635
       624
        
             getSubOptions = type.getSubOptions;

     

       636
       625
        
             getSubModules = type.getSubModules;

+1 -1

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

···

       326
       326
        
       `types.uniq` *`t`*

     

       327
       327
        
       

     

       328
       328
        
       :   Ensures that type *`t`* cannot be merged. It is used to ensure option

     

       329
       329
       -
           definitions are declared only once.

     

       329
       329
       +
           definitions are provided only once.

     

       330
       330
        
       

     

       331
       331
        
       `types.unique` `{ message = m }` *`t`*

     

       332
       332