commit 41f219d1d988ff93078127f74b1861cb97a9ddbf · pyrox.dev/nixpkgs

+34

lib/tests/misc.nix

···

       2687
       2687
        
             checkC = false;

     

       2688
       2688
        
           };

     

       2689
       2689
        
         };

     

       2690
       2690
       +
       

     

       2691
       2691
       +
         # Check that `packagesFromDirectoryRecursive` can be used to create scopes

     

       2692
       2692
       +
         # for sub-directories

     

       2693
       2693
       +
         testPackagesFromDirectoryNestedScopes = let

     

       2694
       2694
       +
           inherit (lib) makeScope recurseIntoAttrs;

     

       2695
       2695
       +
           emptyScope = makeScope lib.callPackageWith (_: {});

     

       2696
       2696
       +
         in {

     

       2697
       2697
       +
           expr = lib.filterAttrsRecursive (name: value: !lib.elem name [ "callPackage" "newScope" "overrideScope" "packages" ]) (packagesFromDirectoryRecursive {

     

       2698
       2698
       +
             inherit (emptyScope) callPackage newScope;

     

       2699
       2699
       +
             recurseIntoDirectory = f: { newScope, ... }@args:

     

       2700
       2700
       +
               recurseIntoAttrs (makeScope newScope (self:

     

       2701
       2701
       +
                 f (args // {

     

       2702
       2702
       +
                   inherit (self) callPackage newScope;

     

       2703
       2703
       +
                 })

     

       2704
       2704
       +
               ));

     

       2705
       2705
       +
             directory = ./packages-from-directory/scope;

     

       2706
       2706
       +
           });

     

       2707
       2707
       +
           expected = lib.recurseIntoAttrs {

     

       2708
       2708
       +
             a = "a";

     

       2709
       2709
       +
             b = "b";

     

       2710
       2710
       +
             # Note: Other files/directories in `./test-data/c/` are ignored and can be

     

       2711
       2711
       +
             # used by `package.nix`.

     

       2712
       2712
       +
             c = "c";

     

       2713
       2713
       +
             my-namespace = lib.recurseIntoAttrs {

     

       2714
       2714
       +
               d = "d";

     

       2715
       2715
       +
               e = "e";

     

       2716
       2716
       +
               f = "f";

     

       2717
       2717
       +
               my-sub-namespace = lib.recurseIntoAttrs {

     

       2718
       2718
       +
                 g = "g";

     

       2719
       2719
       +
                 h = "h";

     

       2720
       2720
       +
               };

     

       2721
       2721
       +
             };

     

       2722
       2722
       +
           };

     

       2723
       2723
       +
         };

     

       2690
       2724
        
       }

+1

lib/tests/packages-from-directory/scope/a.nix

···

       1
       1
       +
       { }: "a"

+3

lib/tests/packages-from-directory/scope/b.nix

···

       1
       1
       +
       { a }:

     

       2
       2
       +
       assert a == "a";

     

       3
       3
       +
       "b"

lib/tests/packages-from-directory/scope/c/my-extra-feature.patch

This is a binary file and will not be displayed.

+1

lib/tests/packages-from-directory/scope/c/not-a-namespace/not-a-package.nix

+1

lib/tests/packages-from-directory/scope/c/package.nix

···

       1
       1
       +
       { }: "c"

+1

lib/tests/packages-from-directory/scope/c/support-definitions.nix

+5

lib/tests/packages-from-directory/scope/my-namespace/d.nix

···

       1
       1
       +
       { a, e }:

     

       2
       2
       +
       # Check we can get parameter from the parent scope(s) as well as the current one

     

       3
       3
       +
       assert a == "a";

     

       4
       4
       +
       assert e == "e";

     

       5
       5
       +
       "d"

+3

lib/tests/packages-from-directory/scope/my-namespace/e.nix

···

       1
       1
       +
       { d }:

     

       2
       2
       +
       # Check that mutual recursion is possible

     

       3
       3
       +
       "e"

+1

lib/tests/packages-from-directory/scope/my-namespace/f/package.nix

···

       1
       1
       +
       { }: "f"

+7

lib/tests/packages-from-directory/scope/my-namespace/my-sub-namespace/g.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         a,

     

       3
       3
       +
         d,

     

       4
       4
       +
         h,

     

       5
       5
       +
       }:

     

       6
       6
       +
       # Check we can get parameters from ancestral scopes (e.g. the scope's grandparent)

     

       7
       7
       +
       "g"

+1

lib/tests/packages-from-directory/scope/my-namespace/my-sub-namespace/h.nix

···

       1
       1
       +
       { }: "h"