commit 090b929b8ab9b7df11825554828f0cb51e9eab9b · pyrox.dev/nixpkgs

+2 -1

lib/default.nix

···

       120
       120
        
           inherit (self.meta) addMetaAttrs dontDistribute setName updateName

     

       121
       121
        
             appendToName mapDerivationAttrset setPrio lowPrio lowPrioSet hiPrio

     

       122
       122
        
             hiPrioSet getLicenseFromSpdxId getExe getExe';

     

       123
       123
       -
           inherit (self.filesystem) pathType pathIsDirectory pathIsRegularFile;

     

       123
       123
       +
           inherit (self.filesystem) pathType pathIsDirectory pathIsRegularFile

     

       124
       124
       +
             packagesFromDirectoryRecursive;

     

       124
       125
        
           inherit (self.sources) cleanSourceFilter

     

       125
       126
        
             cleanSource sourceByRegex sourceFilesBySuffices

     

       126
       127
        
             commitIdFromGitRepo cleanSourceWith pathHasContext

+154

lib/filesystem.nix

···

       9
       9
        
         inherit (builtins)

     

       10
       10
        
           readDir

     

       11
       11
        
           pathExists

     

       12
       12
       +
           toString

     

       13
       13
       +
           ;

     

       14
       14
       +
       

     

       15
       15
       +
         inherit (lib.attrsets)

     

       16
       16
       +
           mapAttrs'

     

       17
       17
       +
           filterAttrs

     

       12
       18
        
           ;

     

       13
       19
        
       

     

       14
       20
        
         inherit (lib.filesystem)

     

       15
       21
        
           pathType

     

       22
       22
       +
           ;

     

       23
       23
       +
       

     

       24
       24
       +
         inherit (lib.strings)

     

       25
       25
       +
           hasSuffix

     

       26
       26
       +
           removeSuffix

     

       16
       27
        
           ;

     

       17
       28
        
       in

     

       18
       29
        
       

     
···

       154
       165
        
             dir + "/${name}"

     

       155
       166
        
         ) (builtins.readDir dir));

     

       156
       167
        
       

     

       168
       168
       +
         /*

     

       169
       169
       +
           Transform a directory tree containing package files suitable for

     

       170
       170
       +
           `callPackage` into a matching nested attribute set of derivations.

     

       171
       171
       +
       

     

       172
       172
       +
           For a directory tree like this:

     

       173
       173
       +
       

     

       174
       174
       +
           ```

     

       175
       175
       +
           my-packages

     

       176
       176
       +
           ├── a.nix

     

       177
       177
       +
           ├── b.nix

     

       178
       178
       +
           ├── c

     

       179
       179
       +
           │  ├── my-extra-feature.patch

     

       180
       180
       +
           │  ├── package.nix

     

       181
       181
       +
           │  └── support-definitions.nix

     

       182
       182
       +
           └── my-namespace

     

       183
       183
       +
              ├── d.nix

     

       184
       184
       +
              ├── e.nix

     

       185
       185
       +
              └── f

     

       186
       186
       +
                 └── package.nix

     

       187
       187
       +
           ```

     

       188
       188
       +
       

     

       189
       189
       +
           `packagesFromDirectoryRecursive` will produce an attribute set like this:

     

       190
       190
       +
       

     

       191
       191
       +
           ```nix

     

       192
       192
       +
           # packagesFromDirectoryRecursive {

     

       193
       193
       +
           #   callPackage = pkgs.callPackage;

     

       194
       194
       +
           #   directory = ./my-packages;

     

       195
       195
       +
           # }

     

       196
       196
       +
           {

     

       197
       197
       +
             a = pkgs.callPackage ./my-packages/a.nix { };

     

       198
       198
       +
             b = pkgs.callPackage ./my-packages/b.nix { };

     

       199
       199
       +
             c = pkgs.callPackage ./my-packages/c/package.nix { };

     

       200
       200
       +
             my-namespace = {

     

       201
       201
       +
               d = pkgs.callPackage ./my-packages/my-namespace/d.nix { };

     

       202
       202
       +
               e = pkgs.callPackage ./my-packages/my-namespace/e.nix { };

     

       203
       203
       +
               f = pkgs.callPackage ./my-packages/my-namespace/f/package.nix { };

     

       204
       204
       +
             };

     

       205
       205
       +
           }

     

       206
       206
       +
           ```

     

       207
       207
       +
       

     

       208
       208
       +
           In particular:

     

       209
       209
       +
           - If the input directory contains a `package.nix` file, then

     

       210
       210
       +
             `callPackage <directory>/package.nix { }` is returned.

     

       211
       211
       +
           - Otherwise, the input directory's contents are listed and transformed into

     

       212
       212
       +
             an attribute set.

     

       213
       213
       +
             - If a file name has the `.nix` extension, it is turned into attribute

     

       214
       214
       +
               where:

     

       215
       215
       +
               - The attribute name is the file name without the `.nix` extension

     

       216
       216
       +
               - The attribute value is `callPackage <file path> { }`

     

       217
       217
       +
             - Other files are ignored.

     

       218
       218
       +
             - Directories are turned into an attribute where:

     

       219
       219
       +
               - The attribute name is the name of the directory

     

       220
       220
       +
               - The attribute value is the result of calling

     

       221
       221
       +
                 `packagesFromDirectoryRecursive { ... }` on the directory.

     

       222
       222
       +
       

     

       223
       223
       +
               As a result, directories with no `.nix` files (including empty

     

       224
       224
       +
               directories) will be transformed into empty attribute sets.

     

       225
       225
       +
       

     

       226
       226
       +
           Example:

     

       227
       227
       +
             packagesFromDirectoryRecursive {

     

       228
       228
       +
               inherit (pkgs) callPackage;

     

       229
       229
       +
               directory = ./my-packages;

     

       230
       230
       +
             }

     

       231
       231
       +
             => { ... }

     

       232
       232
       +
       

     

       233
       233
       +
             lib.makeScope pkgs.newScope (

     

       234
       234
       +
               self: packagesFromDirectoryRecursive {

     

       235
       235
       +
                 callPackage = self.callPackage;

     

       236
       236
       +
                 directory = ./my-packages;

     

       237
       237
       +
               }

     

       238
       238
       +
             )

     

       239
       239
       +
             => { ... }

     

       240
       240
       +
       

     

       241
       241
       +
           Type:

     

       242
       242
       +
             packagesFromDirectoryRecursive :: AttrSet -> AttrSet

     

       243
       243
       +
         */

     

       244
       244
       +
         packagesFromDirectoryRecursive =

     

       245
       245
       +
           # Options.

     

       246
       246
       +
           {

     

       247
       247
       +
             /*

     

       248
       248
       +
               `pkgs.callPackage`

     

       249
       249
       +
       

     

       250
       250
       +
               Type:

     

       251
       251
       +
                 Path -> AttrSet -> a

     

       252
       252
       +
             */

     

       253
       253
       +
             callPackage,

     

       254
       254
       +
             /*

     

       255
       255
       +
               The directory to read package files from

     

       256
       256
       +
       

     

       257
       257
       +
               Type:

     

       258
       258
       +
                 Path

     

       259
       259
       +
             */

     

       260
       260
       +
             directory,

     

       261
       261
       +
             ...

     

       262
       262
       +
           }:

     

       263
       263
       +
           let

     

       264
       264
       +
             # Determine if a directory entry from `readDir` indicates a package or

     

       265
       265
       +
             # directory of packages.

     

       266
       266
       +
             directoryEntryIsPackage = basename: type:

     

       267
       267
       +
               type == "directory" || hasSuffix ".nix" basename;

     

       268
       268
       +
       

     

       269
       269
       +
             # List directory entries that indicate packages in the given `path`.

     

       270
       270
       +
             packageDirectoryEntries = path:

     

       271
       271
       +
               filterAttrs directoryEntryIsPackage (readDir path);

     

       272
       272
       +
       

     

       273
       273
       +
             # Transform a directory entry (a `basename` and `type` pair) into a

     

       274
       274
       +
             # package.

     

       275
       275
       +
             directoryEntryToAttrPair = subdirectory: basename: type:

     

       276
       276
       +
               let

     

       277
       277
       +
                 path = subdirectory + "/${basename}";

     

       278
       278
       +
               in

     

       279
       279
       +
               if type == "regular"

     

       280
       280
       +
               then

     

       281
       281
       +
               {

     

       282
       282
       +
                 name = removeSuffix ".nix" basename;

     

       283
       283
       +
                 value = callPackage path { };

     

       284
       284
       +
               }

     

       285
       285
       +
               else

     

       286
       286
       +
               if type == "directory"

     

       287
       287
       +
               then

     

       288
       288
       +
               {

     

       289
       289
       +
                 name = basename;

     

       290
       290
       +
                 value = packagesFromDirectory path;

     

       291
       291
       +
               }

     

       292
       292
       +
               else

     

       293
       293
       +
               throw

     

       294
       294
       +
                 ''

     

       295
       295
       +
                   lib.filesystem.packagesFromDirectoryRecursive: Unsupported file type ${type} at path ${toString subdirectory}

     

       296
       296
       +
                 '';

     

       297
       297
       +
       

     

       298
       298
       +
             # Transform a directory into a package (if there's a `package.nix`) or

     

       299
       299
       +
             # set of packages (otherwise).

     

       300
       300
       +
             packagesFromDirectory = path:

     

       301
       301
       +
               let

     

       302
       302
       +
                 defaultPackagePath = path + "/package.nix";

     

       303
       303
       +
               in

     

       304
       304
       +
               if pathExists defaultPackagePath

     

       305
       305
       +
               then callPackage defaultPackagePath { }

     

       306
       306
       +
               else mapAttrs'

     

       307
       307
       +
                 (directoryEntryToAttrPair path)

     

       308
       308
       +
                 (packageDirectoryEntries path);

     

       309
       309
       +
           in

     

       310
       310
       +
           packagesFromDirectory directory;

     

       157
       311
        
       }

+33

lib/tests/misc.nix

···

       1988
       1988
        
           expr = meta.platformMatch { } "x86_64-linux";

     

       1989
       1989
        
           expected = false;

     

       1990
       1990
        
         };

     

       1991
       1991
       +
       

     

       1992
       1992
       +
         testPackagesFromDirectoryRecursive = {

     

       1993
       1993
       +
           expr = packagesFromDirectoryRecursive {

     

       1994
       1994
       +
             callPackage = path: overrides: import path overrides;

     

       1995
       1995
       +
             directory = ./packages-from-directory;

     

       1996
       1996
       +
           };

     

       1997
       1997
       +
           expected = {

     

       1998
       1998
       +
             a = "a";

     

       1999
       1999
       +
             b = "b";

     

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

     

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

     

       2002
       2002
       +
             c = "c";

     

       2003
       2003
       +
             my-namespace = {

     

       2004
       2004
       +
               d = "d";

     

       2005
       2005
       +
               e = "e";

     

       2006
       2006
       +
               f = "f";

     

       2007
       2007
       +
               my-sub-namespace = {

     

       2008
       2008
       +
                 g = "g";

     

       2009
       2009
       +
                 h = "h";

     

       2010
       2010
       +
               };

     

       2011
       2011
       +
             };

     

       2012
       2012
       +
           };

     

       2013
       2013
       +
         };

     

       2014
       2014
       +
       

     

       2015
       2015
       +
         # Check that `packagesFromDirectoryRecursive` can process a directory with a

     

       2016
       2016
       +
         # top-level `package.nix` file into a single package.

     

       2017
       2017
       +
         testPackagesFromDirectoryRecursiveTopLevelPackageNix = {

     

       2018
       2018
       +
           expr = packagesFromDirectoryRecursive {

     

       2019
       2019
       +
             callPackage = path: overrides: import path overrides;

     

       2020
       2020
       +
             directory = ./packages-from-directory/c;

     

       2021
       2021
       +
           };

     

       2022
       2022
       +
           expected = "c";

     

       2023
       2023
       +
         };

     

       1991
       2024
        
       }

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

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

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

This is a binary file and will not be displayed.

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

This is a binary file and will not be displayed.

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

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

This is a binary file and will not be displayed.

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

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

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

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

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