commit a6b455bbaecb42679e5d1ade51433d62ee21bd03 · pyrox.dev/nixpkgs

+14 -5

lib/modules.nix

···

       91
       91
        
           let

     

       92
       92
        
             toClosureList = file: parentKey: imap (n: x:

     

       93
       93
        
               if isAttrs x || isFunction x then

     

       94
       94
       -
                 unifyModuleSyntax file "${parentKey}:anon-${toString n}" (unpackSubmodule applyIfFunction x args)

     

       94
       94
       +
                 let key = "${parentKey}:anon-${toString n}"; in

     

       95
       95
       +
                 unifyModuleSyntax file key (unpackSubmodule (applyIfFunction key) x args)

     

       95
       96
        
               else

     

       96
       96
       -
                 unifyModuleSyntax (toString x) (toString x) (applyIfFunction (import x) args));

     

       97
       97
       +
                 let file = toString x; key = toString x; in

     

       98
       98
       +
                 unifyModuleSyntax file key (applyIfFunction key (import x) args));

     

       97
       99
        
           in

     

       98
       100
        
             builtins.genericClosure {

     

       99
       101
        
               startSet = toClosureList unknownModule "" modules;

     
···

       122
       124
        
               config = removeAttrs m ["key" "_file" "require" "imports"];

     

       123
       125
        
             };

     

       124
       126
        
       

     

       125
       125
       -
         applyIfFunction = f: arg@{ config, options, lib, ... }: if isFunction f then

     

       127
       127
       +
         applyIfFunction = key: f: args@{ config, options, lib, ... }: if isFunction f then

     

       126
       128
        
           let

     

       127
       129
        
             # Module arguments are resolved in a strict manner when attribute set

     

       128
       130
        
             # deconstruction is used.  As the arguments are now defined with the

     
···

       137
       139
        
             # not their values.  The values are forwarding the result of the

     

       138
       140
        
             # evaluation of the option.

     

       139
       141
        
             requiredArgs = builtins.attrNames (builtins.functionArgs f);

     

       142
       142
       +
             context = name: ''while evaluating the module argument `${name}' in "${key}":'';

     

       140
       143
        
             extraArgs = builtins.listToAttrs (map (name: {

     

       141
       144
        
               inherit name;

     

       142
       142
       -
               value = config._module.args.${name};

     

       145
       145
       +
               value = addErrorContext (context name)

     

       146
       146
       +
                 (args.${name} or config._module.args.${name});

     

       143
       147
        
             }) requiredArgs);

     

       144
       144
       -
           in f (extraArgs // arg)

     

       148
       148
       +
       

     

       149
       149
       +
             # Note: we append in the opposite order such that we can add an error

     

       150
       150
       +
             # context on the explicited arguments of "args" too. This update

     

       151
       151
       +
             # operator is used to make the "args@{ ... }: with args.lib;" notation

     

       152
       152
       +
             # works.

     

       153
       153
       +
           in f (args // extraArgs)

     

       145
       154
        
         else

     

       146
       155
        
           f;

     

       147
       156

+10 -2

lib/tests/modules.sh

···

       12
       12
        
           local attr=$1

     

       13
       13
        
           shift;

     

       14
       14
        
           local script="import ./default.nix { modules = [ $@ ];}"

     

       15
       15
       -
           nix-instantiate --timeout 1 -E "$script" -A "$attr" --eval-only

     

       15
       15
       +
           nix-instantiate --timeout 1 -E "$script" -A "$attr" --eval-only --show-trace

     

       16
       16
        
       }

     

       17
       17
        
       

     

       18
       18
        
       reportFailure() {

     
···

       100
       100
        
       checkConfigOutput 'true' "$@" ./define-enable.nix ./define-loaOfSub-foo-enable-if.nix

     

       101
       101
        
       

     

       102
       102
        
       # Check _module.args.

     

       103
       103
       -
       checkConfigOutput "true" config.enable ./declare-enable.nix ./custom-arg-define-enable.nix

     

       103
       103
       +
       set -- config.enable ./declare-enable.nix ./define-enable-with-custom-arg.nix

     

       104
       104
       +
       checkConfigError 'while evaluating the module argument .*custom.* in .*define-enable-with-custom-arg.nix.*:' "$@"

     

       105
       105
       +
       checkConfigOutput "true" "$@" ./define-_module-args-custom.nix

     

       106
       106
       +
       

     

       107
       107
       +
       # Check that using _module.args on imports cause infinite recursions, with

     

       108
       108
       +
       # the proper error context.

     

       109
       109
       +
       set -- "$@" ./define-_module-args-custom.nix ./import-custom-arg.nix

     

       110
       110
       +
       checkConfigError 'while evaluating the module argument .*custom.* in .*import-custom-arg.nix.*:' "$@"

     

       111
       111
       +
       checkConfigError 'infinite recursion encountered' "$@"

     

       104
       112
        
       

     

       105
       113
        
       # Check _module.check.

     

       106
       114
        
       set -- config.enable ./declare-enable.nix ./define-enable.nix ./define-loaOfSub-foo.nix

-1

lib/tests/modules/custom-arg-define-enable.nix lib/tests/modules/define-enable-with-custom-arg.nix

···

       2
       2
        
       

     

       3
       3
        
       {

     

       4
       4
        
         config = {

     

       5
       5
       -
           _module.args.custom = true;

     

       6
       5
        
           enable = custom;

     

       7
       6
        
         };

     

       8
       7
        
       }

+7

lib/tests/modules/define-_module-args-custom.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       {

     

       4
       4
       +
         config = {

     

       5
       5
       +
           _module.args.custom = true;

     

       6
       6
       +
         };

     

       7
       7
       +
       }

+6

lib/tests/modules/import-custom-arg.nix

···

       1
       1
       +
       { lib, custom, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       {

     

       4
       4
       +
         imports = []

     

       5
       5
       +
         ++ lib.optional custom ./define-enable-force.nix;

     

       6
       6
       +
       }