commit b78ba9bc68b003288d56bab62693ea28e2cdfd76 · pyrox.dev/nixpkgs

+28 -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@{ message, merge ? null }:

     

       270
       270
       +
           let

     

       271
       271
       +
             notUnique = loc: defs:

     

       272
       272
       +
               assert length defs > 1;

     

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

     

       274
       274
       +
           in

     

       275
       275
       +
           if merge == null

     

       276
       276
       +
           # The inner conditional could be factored out, but this way we take advantage of partial application.

     

       277
       277
       +
           then

     

       278
       278
       +
             loc: defs:

     

       279
       279
       +
               if length defs == 1

     

       280
       280
       +
               then (head defs).value

     

       281
       281
       +
               else notUnique loc defs

     

       282
       282
       +
           else

     

       283
       283
       +
             loc: defs:

     

       284
       284
       +
               if length defs == 1

     

       285
       285
       +
               then merge loc defs

     

       286
       286
       +
               else notUnique loc defs;

     

       264
       287
        
       

     

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

     

       266
       289
        
         mergeEqualOption = loc: defs:

+10

lib/tests/modules.sh

···

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

     

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

     

       408
       408
        
       

     

       409
       409
       +
       # types.unique

     

       410
       410
       +
       #   requires a single definition

     

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

     

       412
       412
       +
       #   user message is printed

     

       413
       413
       +
       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

     

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

     

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

     

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

     

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

     

       418
       418
       +
       

     

       409
       419
        
       ## types.raw

     

       410
       420
        
       checkConfigOutput '^true$' config.unprocessedNestingEvaluates.success ./raw.nix

     

       411
       421
        
       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
       +
       }

+1 -1

lib/types.nix

···

       629
       629
        
           unique = { message }: type: mkOptionType rec {

     

       630
       630
        
             name = "unique";

     

       631
       631
        
             inherit (type) description descriptionClass check;

     

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

     

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

     

       633
       633
        
             emptyValue = type.emptyValue;

     

       634
       634
        
             getSubOptions = type.getSubOptions;

     

       635
       635
        
             getSubModules = type.getSubModules;