commit 118bdf25a6c572dd2fd29d10b1ae2e4d9a95b907 · pyrox.dev/nixpkgs

+29 -5

lib/modules.nix

···

       21
       21
        
           isBool

     

       22
       22
        
           isFunction

     

       23
       23
        
           isList

     

       24
       24
       +
           isPath

     

       24
       25
        
           isString

     

       25
       26
        
           length

     

       26
       27
        
           mapAttrs

     
···

       44
       45
        
           showFiles

     

       45
       46
        
           showOption

     

       46
       47
        
           unknownModule

     

       48
       48
       +
           ;

     

       49
       49
       +
         inherit (lib.strings)

     

       50
       50
       +
           isConvertibleWithToString

     

       47
       51
        
           ;

     

       48
       52
        
       

     

       49
       53
        
         showDeclPrefix = loc: decl: prefix:

     
···

       403
       407
        
                   key = module.key;

     

       404
       408
        
                   module = module;

     

       405
       409
        
                   modules = collectedImports.modules;

     

       406
       406
       -
                   disabled = module.disabledModules ++ collectedImports.disabled;

     

       410
       410
       +
                   disabled = (if module.disabledModules != [] then [{ file = module._file; disabled = module.disabledModules; }] else []) ++ collectedImports.disabled;

     

       407
       411
        
                 }) initialModules);

     

       408
       412
        
       

     

       409
       413
        
             # filterModules :: String -> { disabled, modules } -> [ Module ]

     
···

       412
       416
        
             # modules recursively. It returns the final list of unique-by-key modules

     

       413
       417
        
             filterModules = modulesPath: { disabled, modules }:

     

       414
       418
        
               let

     

       415
       415
       -
                 moduleKey = m: if isString m && (builtins.substring 0 1 m != "/")

     

       416
       416
       -
                   then toString modulesPath + "/" + m

     

       417
       417
       -
                   else toString m;

     

       418
       418
       -
                 disabledKeys = map moduleKey disabled;

     

       419
       419
       +
                 moduleKey = file: m:

     

       420
       420
       +
                   if isString m

     

       421
       421
       +
                   then

     

       422
       422
       +
                     if builtins.substring 0 1 m == "/"

     

       423
       423
       +
                     then m

     

       424
       424
       +
                     else toString modulesPath + "/" + m

     

       425
       425
       +
       

     

       426
       426
       +
                   else if isConvertibleWithToString m

     

       427
       427
       +
                   then

     

       428
       428
       +
                     if m?key && m.key != toString m

     

       429
       429
       +
                     then

     

       430
       430
       +
                       throw "Module `${file}` contains a disabledModules item that is an attribute set that can be converted to a string (${toString m}) but also has a `.key` attribute (${m.key}) with a different value. This makes it ambiguous which module should be disabled."

     

       431
       431
       +
                     else

     

       432
       432
       +
                       toString m

     

       433
       433
       +
       

     

       434
       434
       +
                   else if m?key

     

       435
       435
       +
                   then

     

       436
       436
       +
                     m.key

     

       437
       437
       +
       

     

       438
       438
       +
                   else if isAttrs m

     

       439
       439
       +
                   then throw "Module `${file}` contains a disabledModules item that is an attribute set, presumably a module, that does not have a `key` attribute. This means that the module system doesn't have any means to identify the module that should be disabled. Make sure that you've put the correct value in disabledModules: a string path relative to modulesPath, a path value, or an attribute set with a `key` attribute."

     

       440
       440
       +
                   else throw "Each disabledModules item must be a path, string, or a attribute set with a key attribute, or a value supported by toString. However, one of the disabledModules items in `${toString file}` is none of that, but is of type ${builtins.typeOf m}.";

     

       441
       441
       +
       

     

       442
       442
       +
                 disabledKeys = concatMap ({ file, disabled }: map (moduleKey file) disabled) disabled;

     

       419
       443
        
                 keyFilter = filter (attrs: ! elem attrs.key disabledKeys);

     

       420
       444
        
               in map (attrs: attrs.module) (builtins.genericClosure {

     

       421
       445
        
                 startSet = keyFilter modules;

+12

lib/tests/modules.sh

···

       141
       141
        
       checkConfigError "attribute .*enable.* in selection path .*config.enable.* not found" "$@" ./disable-define-enable.nix ./disable-declare-enable.nix

     

       142
       142
        
       checkConfigError "attribute .*enable.* in selection path .*config.enable.* not found" "$@" ./disable-enable-modules.nix

     

       143
       143
        
       

     

       144
       144
       +
       checkConfigOutput '^true$' 'config.positive.enable' ./disable-module-with-key.nix

     

       145
       145
       +
       checkConfigOutput '^false$' 'config.negative.enable' ./disable-module-with-key.nix

     

       146
       146
       +
       checkConfigError 'Module ..*disable-module-bad-key.nix. contains a disabledModules item that is an attribute set, presumably a module, that does not have a .key. attribute. .*' 'config.enable' ./disable-module-bad-key.nix

     

       147
       147
       +
       

     

       148
       148
       +
       # Not sure if we want to keep supporting module keys that aren't strings, paths or v?key, but we shouldn't remove support accidentally.

     

       149
       149
       +
       checkConfigOutput '^true$' 'config.positive.enable' ./disable-module-with-toString-key.nix

     

       150
       150
       +
       checkConfigOutput '^false$' 'config.negative.enable' ./disable-module-with-toString-key.nix

     

       151
       151
       +
       

     

       144
       152
        
       # Check _module.args.

     

       145
       153
        
       set -- config.enable ./declare-enable.nix ./define-enable-with-custom-arg.nix

     

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

     
···

       357
       365
        
       checkConfigOutput '^"The option `a\.b. defined in `.*/doRename-warnings\.nix. has been renamed to `c\.d\.e.\."$' \

     

       358
       366
        
         config.result \

     

       359
       367
        
         ./doRename-warnings.nix

     

       368
       368
       +
       

     

       369
       369
       +
       # Anonymous modules get deduplicated by key

     

       370
       370
       +
       checkConfigOutput '^"pear"$' config.once.raw ./merge-module-with-key.nix

     

       371
       371
       +
       checkConfigOutput '^"pear\\npear"$' config.twice.raw ./merge-module-with-key.nix

     

       360
       372
        
       

     

       361
       373
        
       cat <<EOF

     

       362
       374
        
       ====== module tests ======

+16

lib/tests/modules/disable-module-bad-key.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types;

     

       4
       4
       +
       

     

       5
       5
       +
         moduleWithKey = { config, ... }: {

     

       6
       6
       +
           config = {

     

       7
       7
       +
             enable = true;

     

       8
       8
       +
           };

     

       9
       9
       +
         };

     

       10
       10
       +
       in

     

       11
       11
       +
       {

     

       12
       12
       +
         imports = [

     

       13
       13
       +
           ./declare-enable.nix

     

       14
       14
       +
         ];

     

       15
       15
       +
         disabledModules = [ { } ];

     

       16
       16
       +
       }

+34

lib/tests/modules/disable-module-with-key.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types;

     

       4
       4
       +
       

     

       5
       5
       +
         moduleWithKey = {

     

       6
       6
       +
           key = "disable-module-with-key.nix#moduleWithKey";

     

       7
       7
       +
           config = {

     

       8
       8
       +
             enable = true;

     

       9
       9
       +
           };

     

       10
       10
       +
         };

     

       11
       11
       +
       in

     

       12
       12
       +
       {

     

       13
       13
       +
         options = {

     

       14
       14
       +
           positive = mkOption {

     

       15
       15
       +
             type = types.submodule {

     

       16
       16
       +
               imports = [

     

       17
       17
       +
                 ./declare-enable.nix

     

       18
       18
       +
                 moduleWithKey

     

       19
       19
       +
               ];

     

       20
       20
       +
             };

     

       21
       21
       +
             default = {};

     

       22
       22
       +
           };

     

       23
       23
       +
           negative = mkOption {

     

       24
       24
       +
             type = types.submodule {

     

       25
       25
       +
               imports = [

     

       26
       26
       +
                 ./declare-enable.nix

     

       27
       27
       +
                 moduleWithKey

     

       28
       28
       +
               ];

     

       29
       29
       +
               disabledModules = [ moduleWithKey ];

     

       30
       30
       +
             };

     

       31
       31
       +
             default = {};

     

       32
       32
       +
           };

     

       33
       33
       +
         };

     

       34
       34
       +
       }

+34

lib/tests/modules/disable-module-with-toString-key.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types;

     

       4
       4
       +
       

     

       5
       5
       +
         moduleWithKey = {

     

       6
       6
       +
           key = 123;

     

       7
       7
       +
           config = {

     

       8
       8
       +
             enable = true;

     

       9
       9
       +
           };

     

       10
       10
       +
         };

     

       11
       11
       +
       in

     

       12
       12
       +
       {

     

       13
       13
       +
         options = {

     

       14
       14
       +
           positive = mkOption {

     

       15
       15
       +
             type = types.submodule {

     

       16
       16
       +
               imports = [

     

       17
       17
       +
                 ./declare-enable.nix

     

       18
       18
       +
                 moduleWithKey

     

       19
       19
       +
               ];

     

       20
       20
       +
             };

     

       21
       21
       +
             default = {};

     

       22
       22
       +
           };

     

       23
       23
       +
           negative = mkOption {

     

       24
       24
       +
             type = types.submodule {

     

       25
       25
       +
               imports = [

     

       26
       26
       +
                 ./declare-enable.nix

     

       27
       27
       +
                 moduleWithKey

     

       28
       28
       +
               ];

     

       29
       29
       +
               disabledModules = [ 123 ];

     

       30
       30
       +
             };

     

       31
       31
       +
             default = {};

     

       32
       32
       +
           };

     

       33
       33
       +
         };

     

       34
       34
       +
       }

+49

lib/tests/modules/merge-module-with-key.nix

···

       1
       1
       +
       { lib, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkOption types;

     

       4
       4
       +
       

     

       5
       5
       +
         moduleWithoutKey = {

     

       6
       6
       +
           config = {

     

       7
       7
       +
             raw = "pear";

     

       8
       8
       +
           };

     

       9
       9
       +
         };

     

       10
       10
       +
       

     

       11
       11
       +
         moduleWithKey = {

     

       12
       12
       +
           key = __curPos.file + "#moduleWithKey";

     

       13
       13
       +
           config = {

     

       14
       14
       +
             raw = "pear";

     

       15
       15
       +
           };

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         decl = {

     

       19
       19
       +
           options = {

     

       20
       20
       +
             raw = mkOption {

     

       21
       21
       +
               type = types.lines;

     

       22
       22
       +
             };

     

       23
       23
       +
           };

     

       24
       24
       +
         };

     

       25
       25
       +
       in

     

       26
       26
       +
       {

     

       27
       27
       +
         options = {

     

       28
       28
       +
           once = mkOption {

     

       29
       29
       +
             type = types.submodule {

     

       30
       30
       +
               imports = [

     

       31
       31
       +
                 decl

     

       32
       32
       +
                 moduleWithKey

     

       33
       33
       +
                 moduleWithKey

     

       34
       34
       +
               ];

     

       35
       35
       +
             };

     

       36
       36
       +
             default = {};

     

       37
       37
       +
           };

     

       38
       38
       +
           twice = mkOption {

     

       39
       39
       +
             type = types.submodule {

     

       40
       40
       +
               imports = [

     

       41
       41
       +
                 decl

     

       42
       42
       +
                 moduleWithoutKey

     

       43
       43
       +
                 moduleWithoutKey

     

       44
       44
       +
               ];

     

       45
       45
       +
             };

     

       46
       46
       +
             default = {};

     

       47
       47
       +
           };

     

       48
       48
       +
         };

     

       49
       49
       +
       }

+9 -2

nixos/doc/manual/development/replace-modules.section.md

···

       8
       8
        
       

     

       9
       9
        
       `disabledModules` is a top level attribute like `imports`, `options` and

     

       10
       10
        
       `config`. It contains a list of modules that will be disabled. This can

     

       11
       11
       -
       either be the full path to the module or a string with the filename

     

       12
       12
       -
       relative to the modules path (eg. \<nixpkgs/nixos/modules> for nixos).

     

       11
       11
       +
       either be:

     

       12
       12
       +
        - the full path to the module,

     

       13
       13
       +
        - or a string with the filename relative to the modules path (eg. \<nixpkgs/nixos/modules> for nixos),

     

       14
       14
       +
        - or an attribute set containing a specific `key` attribute.

     

       15
       15
       +
       

     

       16
       16
       +
       The latter allows some modules to be disabled, despite them being distributed

     

       17
       17
       +
       via attributes instead of file paths. The `key` should be globally unique, so

     

       18
       18
       +
       it is recommended to include a file path in it, or rely on a framework to do it

     

       19
       19
       +
       for you.

     

       13
       20
        
       

     

       14
       21
        
       This example will replace the existing postgresql module with the

     

       15
       22
        
       version defined in the nixos-unstable channel while keeping the rest of