commit 644527dd57127fd46c40de1fc90d096a6db962b4 · pyrox.dev/nixpkgs

+13 -1

lib/modules.nix

···

       1121
        
             files = map (def: def.file) res.defsFinal;

     

       1122
        
             definitionsWithLocations = res.defsFinal;

     

       1123
        
             inherit (res) isDefined;

     

       0
        
       
     

       1124
        
             # This allows options to be correctly displayed using `${options.path.to.it}`

     

       1125
        
             __toString = _: showOption loc;

     

       1126
        
           };

     
···

       1164
        
           # Type-check the remaining definitions, and merge them. Or throw if no definitions.

     

       1165
        
           mergedValue =

     

       1166
        
             if isDefined then

     

       1167
       -
               if all (def: type.check def.value) defsFinal then

     

       0
        
       
     

       0
        
       
     

       1168
        
                 type.merge loc defsFinal

     

       1169
        
               else

     

       1170
        
                 let

     
···

       1176
        
               # handling.  If changed here, please change it there too.)

     

       1177
        
               throw

     

       1178
        
                 "The option `${showOption loc}' was accessed but has no value defined. Try setting the option.";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1179
        
       

     

       1180
        
           isDefined = defsFinal != [ ];

     

       1181

···

       1121
        
             files = map (def: def.file) res.defsFinal;

     

       1122
        
             definitionsWithLocations = res.defsFinal;

     

       1123
        
             inherit (res) isDefined;

     

       1124
       +
             inherit (res.checkedAndMerged) valueMeta;

     

       1125
        
             # This allows options to be correctly displayed using `${options.path.to.it}`

     

       1126
        
             __toString = _: showOption loc;

     

       1127
        
           };

     
···

       1165
        
           # Type-check the remaining definitions, and merge them. Or throw if no definitions.

     

       1166
        
           mergedValue =

     

       1167
        
             if isDefined then

     

       1168
       +
               if type.checkAndMerge or null != null then

     

       1169
       +
                 checkedAndMerged.value

     

       1170
       +
               else if all (def: type.check def.value) defsFinal then

     

       1171
        
                 type.merge loc defsFinal

     

       1172
        
               else

     

       1173
        
                 let

     
···

       1179
        
               # handling.  If changed here, please change it there too.)

     

       1180
        
               throw

     

       1181
        
                 "The option `${showOption loc}' was accessed but has no value defined. Try setting the option.";

     

       1182
       +
       

     

       1183
       +
           checkedAndMerged =

     

       1184
       +
             if type.checkAndMerge or null != null then

     

       1185
       +
               type.checkAndMerge loc defsFinal

     

       1186
       +
             else

     

       1187
       +
               {

     

       1188
       +
                 value = mergedValue;

     

       1189
       +
                 valueMeta = { };

     

       1190
       +
               };

     

       1191
        
       

     

       1192
        
           isDefined = defsFinal != [ ];

     

       1193

+85 -44

lib/types.nix

···

       48
        
           mergeOneOption

     

       49
        
           mergeUniqueOption

     

       50
        
           showFiles

     

       0
        
       
     

       51
        
           showOption

     

       52
        
           ;

     

       53
        
         inherit (lib.strings)

     
···

       204
        
               # definition values and locations (e.g. [ { file = "/foo.nix";

     

       205
        
               # value = 1; } { file = "/bar.nix"; value = 2 } ]).

     

       206
        
               merge ? mergeDefaultOption,

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       207
        
               # Whether this type has a value representing nothingness. If it does,

     

       208
        
               # this should be a value of the form { value = <the nothing value>; }

     

       209
        
               # If it doesn't, this should be {}

     
···

       252
        
                 deprecationMessage

     

       253
        
                 nestedTypes

     

       254
        
                 descriptionClass

     

       0
        
       
     

       255
        
                 ;

     

       256
        
               functor =

     

       257
        
                 if functor ? wrappedDeprecationMessage then

     
···

       705
        
                 }";

     

       706
        
                 descriptionClass = "composite";

     

       707
        
                 check = isList;

     

       708
       -
                 merge =

     

       0
        
       
     

       709
        
                   loc: defs:

     

       710
       -
                   map (x: x.value) (

     

       711
       -
                     filter (x: x ? value) (

     

       712
        
                       concatLists (

     

       713
        
                         imap1 (

     

       714
        
                           n: def:

     
···

       719
        
                                 inherit (def) file;

     

       720
        
                                 value = def';

     

       721
        
                               }

     

       722
       -
                             ]).optionalValue

     

       723
        
                           ) def.value

     

       724
        
                         ) defs

     

       725
        
                       )

     

       726
       -
                     )

     

       727
       -
                   );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       728
        
                 emptyValue = {

     

       729
        
                   value = [ ];

     

       730
        
                 };

     
···

       740
        
             nonEmptyListOf =

     

       741
        
               elemType:

     

       742
        
               let

     

       743
       -
                 list = addCheck (types.listOf elemType) (l: l != [ ]);

     

       744
        
               in

     

       745
       -
               list

     

       746
       -
               // {

     

       747
       -
                 description = "non-empty ${optionDescriptionPhrase (class: class == "noun") list}";

     

       748
       -
                 emptyValue = { }; # no .value attr, meaning unset

     

       749
       -
                 substSubModules = m: nonEmptyListOf (elemType.substSubModules m);

     

       750
       -
               };

     

       0
        
       
     

       0
        
       
     

       751
        
       

     

       752
        
             attrsOf = elemType: attrsWith { inherit elemType; };

     

       753
        
       

     
···

       801
        
                 lazy ? false,

     

       802
        
                 placeholder ? "name",

     

       803
        
               }:

     

       804
       -
               mkOptionType {

     

       805
        
                 name = if lazy then "lazyAttrsOf" else "attrsOf";

     

       806
        
                 description =

     

       807
        
                   (if lazy then "lazy attribute set" else "attribute set")

     

       808
        
                   + " of ${optionDescriptionPhrase (class: class == "noun" || class == "composite") elemType}";

     

       809
        
                 descriptionClass = "composite";

     

       810
        
                 check = isAttrs;

     

       811
       -
                 merge =

     

       812
       -
                   if lazy then

     

       813
       -
                     (

     

       814
       -
                       # Lazy merge Function

     

       815
       -
                       loc: defs:

     

       816
       -
                       zipAttrsWith

     

       817
       -
                         (

     

       818
       -
                           name: defs:

     

       819
       -
                           let

     

       820
       -
                             merged = mergeDefinitions (loc ++ [ name ]) elemType defs;

     

       821
       -
                             # mergedValue will trigger an appropriate error when accessed

     

       822
       -
                           in

     

       823
       -
                           merged.optionalValue.value or elemType.emptyValue.value or merged.mergedValue

     

       824
       -
                         )

     

       825
       -
                         # Push down position info.

     

       826
       -
                         (pushPositions defs)

     

       827
       -
                     )

     

       828
       -
                   else

     

       829
       -
                     (

     

       830
       -
                       # Non-lazy merge Function

     

       831
       -
                       loc: defs:

     

       832
       -
                       mapAttrs (n: v: v.value) (

     

       833
       -
                         filterAttrs (n: v: v ? value) (

     

       834
       -
                           zipAttrsWith (name: defs: (mergeDefinitions (loc ++ [ name ]) elemType (defs)).optionalValue)

     

       835
       -
                             # Push down position info.

     

       836
       -
                             (pushPositions defs)

     

       837
       -
                         )

     

       838
       -
                       )

     

       839
       -
                     );

     

       840
        
                 emptyValue = {

     

       841
        
                   value = { };

     

       842
        
                 };

     
···

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

     

       1237
        
                     prefix = loc;

     

       1238
        
                   }).config;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1239
        
                 emptyValue = {

     

       1240
        
                   value = { };

     

       1241
        
                 };

     
···

       1451
        
                 nestedTypes.coercedType = coercedType;

     

       1452
        
                 nestedTypes.finalType = finalType;

     

       1453
        
               };

     

       0
        
       
     

       1454
        
             /**

     

       1455
        
               Augment the given type with an additional type check function.

     

       1456
        
       

     
···

       1459
        
               Fixing is not trivial, we appreciate any help!

     

       1460
        
               :::

     

       1461
        
             */

     

       1462
       -
             addCheck = elemType: check: elemType // { check = x: elemType.check x && check x; };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1463
        
       

     

       1464
        
           };

     

       1465

···

       48
        
           mergeOneOption

     

       49
        
           mergeUniqueOption

     

       50
        
           showFiles

     

       51
       +
           showDefs

     

       52
        
           showOption

     

       53
        
           ;

     

       54
        
         inherit (lib.strings)

     
···

       205
        
               # definition values and locations (e.g. [ { file = "/foo.nix";

     

       206
        
               # value = 1; } { file = "/bar.nix"; value = 2 } ]).

     

       207
        
               merge ? mergeDefaultOption,

     

       208
       +
               #

     

       209
       +
               # This field does not have a default implementation, so that users' changes

     

       210
       +
               # to `check` and `merge` are propagated.

     

       211
       +
               checkAndMerge ? null,

     

       212
        
               # Whether this type has a value representing nothingness. If it does,

     

       213
        
               # this should be a value of the form { value = <the nothing value>; }

     

       214
        
               # If it doesn't, this should be {}

     
···

       257
        
                 deprecationMessage

     

       258
        
                 nestedTypes

     

       259
        
                 descriptionClass

     

       260
       +
                 checkAndMerge

     

       261
        
                 ;

     

       262
        
               functor =

     

       263
        
                 if functor ? wrappedDeprecationMessage then

     
···

       711
        
                 }";

     

       712
        
                 descriptionClass = "composite";

     

       713
        
                 check = isList;

     

       714
       +
                 merge = loc: defs: (checkAndMerge loc defs).value;

     

       715
       +
                 checkAndMerge =

     

       716
        
                   loc: defs:

     

       717
       +
                   let

     

       718
       +
                     evals = filter (x: x.optionalValue ? value) (

     

       719
        
                       concatLists (

     

       720
        
                         imap1 (

     

       721
        
                           n: def:

     
···

       726
        
                                 inherit (def) file;

     

       727
        
                                 value = def';

     

       728
        
                               }

     

       729
       +
                             ])

     

       730
        
                           ) def.value

     

       731
        
                         ) defs

     

       732
        
                       )

     

       733
       +
                     );

     

       734
       +
                   in

     

       735
       +
                   {

     

       736
       +
                     value = map (x: x.optionalValue.value or x.mergedValue) evals;

     

       737
       +
                     valueMeta.list = map (v: v.checkedAndMerged.valueMeta) evals;

     

       738
       +
                   };

     

       739
        
                 emptyValue = {

     

       740
        
                   value = [ ];

     

       741
        
                 };

     
···

       751
        
             nonEmptyListOf =

     

       752
        
               elemType:

     

       753
        
               let

     

       754
       +
                 list = types.listOf elemType;

     

       755
        
               in

     

       756
       +
               addCheck (

     

       757
       +
                 list

     

       758
       +
                 // {

     

       759
       +
                   description = "non-empty ${optionDescriptionPhrase (class: class == "noun") list}";

     

       760
       +
                   emptyValue = { }; # no .value attr, meaning unset

     

       761
       +
                   substSubModules = m: nonEmptyListOf (elemType.substSubModules m);

     

       762
       +
                 }

     

       763
       +
               ) (l: l != [ ]);

     

       764
        
       

     

       765
        
             attrsOf = elemType: attrsWith { inherit elemType; };

     

       766
        
       

     
···

       814
        
                 lazy ? false,

     

       815
        
                 placeholder ? "name",

     

       816
        
               }:

     

       817
       +
               mkOptionType rec {

     

       818
        
                 name = if lazy then "lazyAttrsOf" else "attrsOf";

     

       819
        
                 description =

     

       820
        
                   (if lazy then "lazy attribute set" else "attribute set")

     

       821
        
                   + " of ${optionDescriptionPhrase (class: class == "noun" || class == "composite") elemType}";

     

       822
        
                 descriptionClass = "composite";

     

       823
        
                 check = isAttrs;

     

       824
       +
                 merge = loc: defs: (checkAndMerge loc defs).value;

     

       825
       +
                 checkAndMerge =

     

       826
       +
                   loc: defs:

     

       827
       +
                   let

     

       828
       +
                     evals =

     

       829
       +
                       if lazy then

     

       830
       +
                         zipAttrsWith (name: defs: mergeDefinitions (loc ++ [ name ]) elemType defs) (pushPositions defs)

     

       831
       +
                       else

     

       832
       +
                         # Filtering makes the merge function more strict

     

       833
       +
                         # Meaning it is less lazy

     

       834
       +
                         filterAttrs (n: v: v.optionalValue ? value) (

     

       835
       +
                           zipAttrsWith (name: defs: mergeDefinitions (loc ++ [ name ]) elemType defs) (pushPositions defs)

     

       836
       +
                         );

     

       837
       +
                   in

     

       838
       +
                   {

     

       839
       +
                     value = mapAttrs (

     

       840
       +
                       n: v:

     

       841
       +
                       if lazy then

     

       842
       +
                         v.optionalValue.value or elemType.emptyValue.value or v.mergedValue

     

       843
       +
                       else

     

       844
       +
                         v.optionalValue.value

     

       845
       +
                     ) evals;

     

       846
       +
                     valueMeta.attrs = mapAttrs (n: v: v.checkedAndMerged.valueMeta) evals;

     

       847
       +
                   };

     

       848
       +
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       849
        
                 emptyValue = {

     

       850
        
                   value = { };

     

       851
        
                 };

     
···

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

     

       1246
        
                     prefix = loc;

     

       1247
        
                   }).config;

     

       1248
       +
                 checkAndMerge =

     

       1249
       +
                   loc: defs:

     

       1250
       +
                   let

     

       1251
       +
                     configuration = base.extendModules {

     

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

     

       1253
       +
                       prefix = loc;

     

       1254
       +
                     };

     

       1255
       +
                   in

     

       1256
       +
                   {

     

       1257
       +
                     value = configuration.config;

     

       1258
       +
                     valueMeta = configuration;

     

       1259
       +
                   };

     

       1260
        
                 emptyValue = {

     

       1261
        
                   value = { };

     

       1262
        
                 };

     
···

       1472
        
                 nestedTypes.coercedType = coercedType;

     

       1473
        
                 nestedTypes.finalType = finalType;

     

       1474
        
               };

     

       1475
       +
       

     

       1476
        
             /**

     

       1477
        
               Augment the given type with an additional type check function.

     

       1478
        
       

     
···

       1481
        
               Fixing is not trivial, we appreciate any help!

     

       1482
        
               :::

     

       1483
        
             */

     

       1484
       +
             addCheck =

     

       1485
       +
               elemType: check:

     

       1486
       +
               elemType

     

       1487
       +
               // {

     

       1488
       +
                 check = x: elemType.check x && check x;

     

       1489
       +
               }

     

       1490
       +
               // (lib.optionalAttrs (elemType.checkAndMerge != null) {

     

       1491
       +
                 checkAndMerge =

     

       1492
       +
                   loc: defs:

     

       1493
       +
                   let

     

       1494
       +
                     v = (elemType.checkAndMerge loc defs);

     

       1495
       +
                   in

     

       1496
       +
                   if all (def: elemType.check def.value && check def.value) defs then

     

       1497
       +
                     v

     

       1498
       +
                   else

     

       1499
       +
                     let

     

       1500
       +
                       allInvalid = filter (def: !elemType.check def.value || !check def.value) defs;

     

       1501
       +
                     in

     

       1502
       +
                     throw "A definition for option `${showOption loc}' is not of type `${elemType.description}'. Definition values:${showDefs allInvalid}";

     

       1503
       +
               });

     

       1504
        
       

     

       1505
        
           };

     

       1506