commit ed91474e9b94f06a44b7aa5bda9911292f709f54 · pyrox.dev/nixpkgs

+11 -7

lib/modules.nix

···

       250
       250
        
             # Add in the default value for this option, if any.

     

       251
       251
        
             defs' = (optional (opt ? default)

     

       252
       252
        
               { file = head opt.declarations; value = mkOptionDefault opt.default; }) ++ defs;

     

       253
       253
       +
       

     

       253
       254
        
             # Handle properties, check types, and merge everything together

     

       254
       254
       -
             inherit (mergeDefinitions loc opt.type defs') defsFinal mergedValue;

     

       255
       255
       +
             inherit (mergeDefinitions loc opt.type defs') isDefined defsFinal mergedValue;

     

       255
       256
        
             files = map (def: def.file) defsFinal;

     

       256
       257
        
             merged =

     

       257
       257
       -
               if defsFinal == [] then

     

       258
       258
       -
                 throw "The option `${showOption loc}' is used but not defined."

     

       259
       259
       -
               else

     

       260
       260
       -
                 mergedValue;

     

       258
       258
       +
               if isDefined then mergedValue

     

       259
       259
       +
               else throw "The option `${showOption loc}' is used but not defined.";

     

       260
       260
       +
       

     

       261
       261
        
             # Finally, apply the ‘apply’ function to the merged

     

       262
       262
        
             # value.  This allows options to yield a value computed

     

       263
       263
        
             # from the definitions.

     
···

       265
       265
        
           in opt //

     

       266
       266
        
             { value = addErrorContext "while evaluating the option `${showOption loc}':" value;

     

       267
       267
        
               definitions = map (def: def.value) defsFinal;

     

       268
       268
       -
               isDefined = defsFinal != [];

     

       269
       269
       -
               inherit files;

     

       268
       268
       +
               inherit isDefined files;

     

       270
       269
        
             };

     

       271
       270
        
       

     

       272
       271
        
           # Merge definitions of a value of a given type

     
···

       295
       294
        
                 if type.check def.value then res

     

       296
       295
        
                 else throw "The option value `${showOption loc}' in `${def.file}' is not a ${type.name}.")

     

       297
       296
        
                 (type.merge loc defsFinal) defsFinal;

     

       297
       297
       +
       

     

       298
       298
       +
               isDefined = defsFinal != [];

     

       299
       299
       +
               optionalValue =

     

       300
       300
       +
                 if isDefined then { value = mergedValue; }

     

       301
       301
       +
                 else {};

     

       298
       302
        
           };

     

       299
       303
        
       

     

       300
       304
        
         /* Given a config set, expand mkMerge properties, and push down the

+10 -12

lib/types.nix

···

       6
       6
        
       with import ./options.nix;

     

       7
       7
        
       with import ./trivial.nix;

     

       8
       8
        
       with import ./strings.nix;

     

       9
       9
       +
       with {inherit (import ./modules.nix) mergeDefinitions; };

     

       9
       10
        
       

     

       10
       10
       -
       let

     

       11
       11
       -
         inherit (import ./modules.nix) mergeDefinitions;

     

       12
       12
       -
       in rec {

     

       11
       11
       +
       rec {

     

       13
       12
        
       

     

       14
       13
        
         isType = type: x: (x._type or "") == type;

     

       15
       14
        
       

     
···

       114
       113
        
             check = isList;

     

       115
       114
        
             merge = loc: defs:

     

       116
       115
        
               map (x: x.value) (filter (x: x ? value) (concatLists (imap (n: def: imap (m: def':

     

       117
       117
       -
                 let

     

       118
       118
       -
                   inherit (mergeDefinitions (loc ++ ["[definition ${toString n}-entry ${toString m}]"])

     

       119
       119
       -
                     elemType [{ inherit (def) file; value = def'; }]

     

       120
       120
       -
                   ) defsFinal mergedValue;

     

       121
       121
       -
                 in if defsFinal == [] then {} else { value = mergedValue; }) def.value) defs)));

     

       116
       116
       +
                   (mergeDefinitions

     

       117
       117
       +
                     (loc ++ ["[definition ${toString n}-entry ${toString m}]"])

     

       118
       118
       +
                     elemType

     

       119
       119
       +
                     [{ inherit (def) file; value = def'; }]

     

       120
       120
       +
                   ).optionalValue

     

       121
       121
       +
                 ) def.value) defs)));

     

       122
       122
        
             getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["*"]);

     

       123
       123
        
             getSubModules = elemType.getSubModules;

     

       124
       124
        
             substSubModules = m: listOf (elemType.substSubModules m);

     
···

       129
       129
        
             check = isAttrs;

     

       130
       130
        
             merge = loc: defs:

     

       131
       131
        
               mapAttrs (n: v: v.value) (filterAttrs (n: v: v ? value) (zipAttrsWith (name: defs:

     

       132
       132
       -
                 let

     

       133
       133
       -
                   inherit (mergeDefinitions (loc ++ [name]) elemType defs)

     

       134
       134
       -
                     defsFinal mergedValue;

     

       135
       135
       -
                 in if defsFinal == [] then {} else { value = mergedValue; })

     

       132
       132
       +
                   (mergeDefinitions (loc ++ [name]) elemType defs).optionalValue

     

       133
       133
       +
                 )

     

       136
       134
        
                 # Push down position info.

     

       137
       135
        
                 (map (def: listToAttrs (mapAttrsToList (n: def':

     

       138
       136
        
                   { name = n; value = { inherit (def) file; value = def'; }; }) def.value)) defs)));