commit 526d604670a456e59a3d20b657d864f85bb52839 · pyrox.dev/nixpkgs

+1 -1

lib/attrsets.nix

···

       145
       145
        
         foldAttrs = op: nul: list_of_attrs:

     

       146
       146
        
           fold (n: a:

     

       147
       147
        
               fold (name: o:

     

       148
       148
       -
                 o // (listToAttrs [{inherit name; value = op n.${name} (a.${name} or nul); }])

     

       148
       148
       +
                 o // { ${name} = op n.${name} (a.${name} or nul); }

     

       149
       149
        
               ) a (attrNames n)

     

       150
       150
        
           ) {} list_of_attrs;

     

       151
       151

+45 -21

lib/modules.nix

···

       192
       192
        
             (concatMap (m: map (config: { inherit (m) file; inherit config; }) (pushDownProperties m.config)) modules);

     

       193
       193
        
       

     

       194
       194
        
         mergeModules' = prefix: options: configs:

     

       195
       195
       -
           listToAttrs (map (name: {

     

       195
       195
       +
           let

     

       196
       196
       +
            /* byName is like foldAttrs, but will look for attributes to merge in the

     

       197
       197
       +
               specified attribute name.

     

       198
       198
       +
       

     

       199
       199
       +
               byName "foo" (module: value: ["module.hidden=${module.hidden},value=${value}"])

     

       200
       200
       +
               [

     

       201
       201
       +
                 {

     

       202
       202
       +
                   hidden="baz";

     

       203
       203
       +
                   foo={qux="bar"; gla="flop";};

     

       204
       204
       +
                 }

     

       205
       205
       +
                 {

     

       206
       206
       +
                   hidden="fli";

     

       207
       207
       +
                   foo={qux="gne"; gli="flip";};

     

       208
       208
       +
                 }

     

       209
       209
       +
               ]

     

       210
       210
       +
               ===>

     

       211
       211
       +
               {

     

       212
       212
       +
                 gla = [ "module.hidden=baz,value=flop" ];

     

       213
       213
       +
                 gli = [ "module.hidden=fli,value=flip" ];

     

       214
       214
       +
                 qux = [ "module.hidden=baz,value=bar" "module.hidden=fli,value=gne" ];

     

       215
       215
       +
               }

     

       216
       216
       +
             */

     

       217
       217
       +
             byName = attr: f: modules: foldl' (acc: module:

     

       218
       218
       +
               foldl' (inner: name:

     

       219
       219
       +
                 inner // { ${name} = (acc.${name} or []) ++ (f module module.${attr}.${name}); }

     

       220
       220
       +
                 ) acc (attrNames module.${attr})

     

       221
       221
       +
               ) {} modules;

     

       222
       222
       +
             # an attrset 'name' => list of submodules that declare ‘name’.

     

       223
       223
       +
             declsByName = byName "options"

     

       224
       224
       +
               (module: option: [{ inherit (module) file; options = option; }])

     

       225
       225
       +
               options;

     

       226
       226
       +
             # an attrset 'name' => list of submodules that define ‘name’.

     

       227
       227
       +
             defnsByName = byName "config" (module: value:

     

       228
       228
       +
               map (config: { inherit (module) file; inherit config; }) (pushDownProperties value)

     

       229
       229
       +
               ) configs;

     

       230
       230
       +
             # extract the definitions for each loc

     

       231
       231
       +
             defnsByName' = byName "config"

     

       232
       232
       +
               (module: value: [{ inherit (module) file; inherit value; }])

     

       233
       233
       +
               configs;

     

       234
       234
       +
           in

     

       235
       235
       +
           (flip mapAttrs declsByName (name: decls:

     

       196
       236
        
             # We're descending into attribute ‘name’.

     

       197
       197
       -
             inherit name;

     

       198
       198
       -
             value =

     

       199
       237
        
               let

     

       200
       238
        
                 loc = prefix ++ [name];

     

       201
       201
       -
                 # Get all submodules that declare ‘name’.

     

       202
       202
       -
                 decls = concatMap (m:

     

       203
       203
       -
                   if m.options ? ${name}

     

       204
       204
       -
                     then [ { inherit (m) file; options = m.options.${name}; } ]

     

       205
       205
       -
                     else []

     

       206
       206
       -
                   ) options;

     

       207
       207
       -
                 # Get all submodules that define ‘name’.

     

       208
       208
       -
                 defns = concatMap (m:

     

       209
       209
       -
                   if m.config ? ${name}

     

       210
       210
       -
                     then map (config: { inherit (m) file; inherit config; })

     

       211
       211
       -
                       (pushDownProperties m.config.${name})

     

       212
       212
       -
                     else []

     

       213
       213
       -
                   ) configs;

     

       239
       239
       +
                 defns = defnsByName.${name} or [];

     

       240
       240
       +
                 defns' = defnsByName'.${name} or [];

     

       214
       241
        
                 nrOptions = count (m: isOption m.options) decls;

     

       215
       215
       -
                 # Extract the definitions for this loc

     

       216
       216
       -
                 defns' = map (m: { inherit (m) file; value = m.config.${name}; })

     

       217
       217
       -
                   (filter (m: m.config ? ${name}) configs);

     

       218
       242
        
               in

     

       219
       243
        
                 if nrOptions == length decls then

     

       220
       244
        
                   let opt = fixupOptionType loc (mergeOptionDecls loc decls);

     
···

       226
       250
        
                   in

     

       227
       251
        
                     throw "The option `${showOption loc}' in `${firstOption.file}' is a prefix of options in `${firstNonOption.file}'."

     

       228
       252
        
                 else

     

       229
       229
       -
                   mergeModules' loc decls defns;

     

       230
       230
       -
           }) (concatMap (m: attrNames m.options) options))

     

       253
       253
       +
                   mergeModules' loc decls defns

     

       254
       254
       +
             ))

     

       231
       255
        
           // { _definedNames = map (m: { inherit (m) file; names = attrNames m.config; }) configs; };

     

       232
       256
        
       

     

       233
       257
        
         /* Merge multiple option declarations into a single declaration.  In