commit bd353d322c6fe384a98d7f0f5b473ce768a02efc · pyrox.dev/nixpkgs

+4 -2

lib/tests/modules.sh

···

       386
       386
        
       checkConfigOutput '^false$' config.conditionalWorks ./declare-lazyAttrsOf.nix ./attrsOf-conditional-check.nix

     

       387
       387
        
       checkConfigOutput '^"empty"$' config.value.foo ./declare-lazyAttrsOf.nix ./attrsOf-conditional-check.nix

     

       388
       388
        
       

     

       389
       389
       +
       # Check attrsWith type merging

     

       390
       390
       +
       checkConfigError 'The option `mergedLazyNonLazy'\'' in `.*'\'' is already declared in `.*'\''\.' options.mergedLazyNonLazy ./lazy-attrsWith.nix

     

       391
       391
       +
       checkConfigOutput '^11$' config.lazyResult ./lazy-attrsWith.nix

     

       392
       392
       +
       checkConfigError 'infinite recursion encountered' config.nonLazyResult ./lazy-attrsWith.nix

     

       389
       393
        
       

     

       390
       394
        
       # Even with multiple assignments, a type error should be thrown if any of them aren't valid

     

       391
       395
        
       checkConfigError 'A definition for option .* is not of type .*' \

     
···

       575
       579
        
       # nested options work

     

       576
       580
        
       checkConfigOutput '^34$' options.nested.nestedLine34.declarationPositions.0.line ./declaration-positions.nix

     

       577
       581
        
       

     

       578
       578
       -
       # AttrsWith tests

     

       579
       579
       -
       checkConfigOutput '^11$' config.result ./lazy-attrsWith.nix

     

       580
       582
        
       

     

       581
       583
        
       cat <<EOF

     

       582
       584
        
       ====== module tests ======

+29 -17

lib/tests/modules/lazy-attrsWith.nix

···

       2
       2
        
       { lib, ... }:

     

       3
       3
        
       let

     

       4
       4
        
         inherit (lib) types mkOption;

     

       5
       5
       +
       

     

       6
       6
       +
         lazyAttrsOf = mkOption {

     

       7
       7
       +
           # Same as lazyAttrsOf

     

       8
       8
       +
           type = types.attrsWith {

     

       9
       9
       +
             lazy = true;

     

       10
       10
       +
             elemType = types.int;

     

       11
       11
       +
           };

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         attrsOf = mkOption {

     

       15
       15
       +
           # Same as lazyAttrsOf

     

       16
       16
       +
           type = types.attrsWith {

     

       17
       17
       +
             elemType = types.int;

     

       18
       18
       +
           };

     

       19
       19
       +
         };

     

       5
       20
        
       in

     

       6
       21
        
       {

     

       7
       22
        
         imports = [

     
···

       9
       24
        
           (

     

       10
       25
        
             { ... }:

     

       11
       26
        
             {

     

       12
       12
       -
               options.mergedLazy = mkOption {

     

       13
       13
       -
                 # Same as lazyAttrsOf

     

       14
       14
       -
                 type = types.attrsWith {

     

       15
       15
       -
                   lazy = true;

     

       16
       16
       -
                   elemType = types.int;

     

       17
       17
       -
                 };

     

       18
       18
       -
               };

     

       27
       27
       +
               options.mergedLazyLazy = lazyAttrsOf;

     

       28
       28
       +
               options.mergedLazyNonLazy = lazyAttrsOf;

     

       29
       29
       +
               options.mergedNonLazyNonLazy = attrsOf;

     

       19
       30
        
             }

     

       20
       31
        
           )

     

       21
       32
        
           # Module B

     

       22
       33
        
           (

     

       23
       34
        
             { ... }:

     

       24
       35
        
             {

     

       25
       25
       -
               options.mergedLazy = lib.mkOption {

     

       26
       26
       -
                 # Same as lazyAttrsOf

     

       27
       27
       -
                 type = types.attrsWith {

     

       28
       28
       -
                   lazy = true;

     

       29
       29
       -
                   elemType = types.int;

     

       30
       30
       -
                 };

     

       31
       31
       -
               };

     

       36
       36
       +
               options.mergedLazyLazy = lazyAttrsOf;

     

       37
       37
       +
               options.mergedLazyNonLazy = attrsOf;

     

       38
       38
       +
               options.mergedNonLazyNonLazy = attrsOf;

     

       32
       39
        
             }

     

       33
       40
        
           )

     

       34
       41
        
           # Result

     
···

       36
       43
        
             { config, ... }:

     

       37
       44
        
             {

     

       38
       45
        
               # Can only evaluate if lazy

     

       39
       39
       -
               config.mergedLazy.bar = config.mergedLazy.baz + 1;

     

       40
       40
       -
               config.mergedLazy.baz = 10;

     

       41
       41
       -
               options.result = mkOption { default = config.mergedLazy.bar; };

     

       46
       46
       +
               config.mergedLazyLazy.bar = config.mergedLazyLazy.baz + 1;

     

       47
       47
       +
               config.mergedLazyLazy.baz = 10;

     

       48
       48
       +
               options.lazyResult = mkOption { default = config.mergedLazyLazy.bar; };

     

       49
       49
       +
       

     

       50
       50
       +
               # Can not only evaluate if not lazy

     

       51
       51
       +
               config.mergedNonLazyNonLazy.bar = config.mergedNonLazyNonLazy.baz + 1;

     

       52
       52
       +
               config.mergedNonLazyNonLazy.baz = 10;

     

       53
       53
       +
               options.nonLazyResult = mkOption { default = config.mergedNonLazyNonLazy.bar; };

     

       42
       54
        
             }

     

       43
       55
        
           )

     

       44
       56
        
         ];

+2 -1

lib/types.nix

···

       630
       630
        
             getSubModules = elemType.getSubModules;

     

       631
       631
        
             substSubModules = m: attrsWith { elemType = elemType.substSubModules m; inherit lazy; };

     

       632
       632
        
             functor = defaultFunctor "attrsWith" // {

     

       633
       633
       -
               wrapped = elemType;

     

       633
       633
       +
               # TODO: This breaks stuff

     

       634
       634
       +
               # wrapped = elemType;

     

       634
       635
        
               payload = {

     

       635
       636
        
                 # Important!: Add new function attributes here in case of future changes

     

       636
       637
        
                 inherit elemType lazy;