commit 7e533bab6df5dc1d065adafceda44a106e3796a4 · pyrox.dev/nixpkgs

+2 -2

lib/fileset/default.nix

···

       380
       380
        
             fileFilter (file: hasPrefix "." file.name) ./.

     

       381
       381
        
       

     

       382
       382
        
             # Include all regular files (not symlinks or others) in the current directory

     

       383
       383
       -
             fileFilter (file: file.type == "regular")

     

       383
       383
       +
             fileFilter (file: file.type == "regular") ./.

     

       384
       384
        
         */

     

       385
       385
        
         fileFilter =

     

       386
       386
        
           /*

     
···

       401
       401
        
           fileset:

     

       402
       402
        
           if ! isFunction predicate then

     

       403
       403
        
             throw ''

     

       404
       404
       -
               lib.fileset.fileFilter: First argument is of type ${typeOf predicate}, but it should be a function.''

     

       404
       404
       +
               lib.fileset.fileFilter: First argument is of type ${typeOf predicate}, but it should be a function instead.''

     

       405
       405
        
           else

     

       406
       406
        
             _fileFilter predicate

     

       407
       407
        
               (_coerce "lib.fileset.fileFilter: Second argument" fileset);

+25 -14

lib/fileset/internal.nix

···

       786
       786
        
               _differenceTree (path + "/${name}") lhsValue (rhs.${name} or null)

     

       787
       787
        
             ) (_directoryEntries path lhs);

     

       788
       788
        
       

     

       789
       789
       +
         # Filters all files in a file set based on a predicate

     

       790
       790
       +
         # Type: ({ name, type, ... } -> Bool) -> FileSet -> FileSet

     

       789
       791
        
         _fileFilter = predicate: fileset:

     

       790
       792
        
           let

     

       791
       791
       -
             recurse = path: tree:

     

       793
       793
       +
             # Check the predicate for a single file

     

       794
       794
       +
             # Type: String -> String -> filesetTree

     

       795
       795
       +
             fromFile = name: type:

     

       796
       796
       +
               if

     

       797
       797
       +
                 predicate {

     

       798
       798
       +
                   inherit name type;

     

       799
       799
       +
                   # To ensure forwards compatibility with more arguments being added in the future,

     

       800
       800
       +
                   # adding an attribute which can't be deconstructed :)

     

       801
       801
       +
                   "lib.fileset.fileFilter: The predicate function passed as the first argument must be able to handle extra attributes for future compatibility. If you're using `{ name, file }:`, use `{ name, file, ... }:` instead." = null;

     

       802
       802
       +
                 }

     

       803
       803
       +
               then

     

       804
       804
       +
                 type

     

       805
       805
       +
               else

     

       806
       806
       +
                 null;

     

       807
       807
       +
       

     

       808
       808
       +
             # Check the predicate for all files in a directory

     

       809
       809
       +
             # Type: Path -> filesetTree

     

       810
       810
       +
             fromDir = path: tree:

     

       792
       811
        
               mapAttrs (name: subtree:

     

       793
       812
        
                 if isAttrs subtree || subtree == "directory" then

     

       794
       794
       -
                   recurse (path + "/${name}") subtree

     

       795
       795
       -
                 else if

     

       796
       796
       -
                   predicate {

     

       797
       797
       -
                     inherit name;

     

       798
       798
       -
                     type = subtree;

     

       799
       799
       -
                     # To ensure forwards compatibility with more arguments being added in the future,

     

       800
       800
       -
                     # adding an attribute which can't be deconstructed :)

     

       801
       801
       -
                     "lib.fileset.fileFilter: The predicate function passed as the first argument must be able to handle extra attributes for future compatibility. If you're using `{ name, file }:`, use `{ name, file, ... }:` instead." = null;

     

       802
       802
       -
                   }

     

       803
       803
       -
                 then

     

       804
       804
       -
                   subtree

     

       813
       813
       +
                   fromDir (path + "/${name}") subtree

     

       814
       814
       +
                 else if subtree == null then

     

       815
       815
       +
                   null

     

       805
       816
        
                 else

     

       806
       806
       -
                   null

     

       817
       817
       +
                   fromFile name subtree

     

       807
       818
        
               ) (_directoryEntries path tree);

     

       808
       819
        
           in

     

       809
       820
        
           if fileset._internalIsEmptyWithoutBase then

     

       810
       821
        
             _emptyWithoutBase

     

       811
       822
        
           else

     

       812
       823
        
             _create fileset._internalBase

     

       813
       813
       -
               (recurse fileset._internalBase fileset._internalTree);

     

       824
       824
       +
               (fromDir fileset._internalBase fileset._internalTree);

     

       814
       825
        
       }

+27

lib/fileset/tests.sh

···

       810
       810
        
       

     

       811
       811
        
       ## File filter

     

       812
       812
        
       

     

       813
       813
       +
       # The first argument needs to be a function

     

       814
       814
       +
       expectFailure 'fileFilter null (abort "this is not needed")' 'lib.fileset.fileFilter: First argument is of type null, but it should be a function instead.'

     

       815
       815
       +
       

     

       816
       816
       +
       # The second argument can be a file set or an existing path

     

       817
       817
       +
       expectFailure 'fileFilter (file: abort "this is not needed") null' 'lib.fileset.fileFilter: Second argument is of type null, but it should be a file set or a path instead.'

     

       818
       818
       +
       expectFailure 'fileFilter (file: abort "this is not needed") ./a' 'lib.fileset.fileFilter: Second argument \('"$work"'/a\) is a path that does not exist.'

     

       819
       819
       +
       

     

       813
       820
        
       # The predicate is not called when there's no files

     

       814
       821
        
       tree=()

     

       815
       822
        
       checkFileset 'fileFilter (file: abort "this is not needed") ./.'

     
···

       874
       881
        
       checkFileset 'union ./c/a (fileFilter (file: assert file.name != "a"; true) ./.)'

     

       875
       882
        
       # but here we need to use ./c

     

       876
       883
        
       checkFileset 'union (fileFilter (file: assert file.name != "a"; true) ./.) ./c'

     

       884
       884
       +
       

     

       885
       885
       +
       # Also lazy, the filter isn't called on a filtered out path

     

       886
       886
       +
       tree=(

     

       887
       887
       +
           [a]=1

     

       888
       888
       +
           [b]=0

     

       889
       889
       +
           [c]=0

     

       890
       890
       +
       )

     

       891
       891
       +
       checkFileset 'fileFilter (file: assert file.name != "c"; file.name == "a") (difference ./. ./c)'

     

       892
       892
       +
       

     

       893
       893
       +
       # Make sure single files are filtered correctly

     

       894
       894
       +
       tree=(

     

       895
       895
       +
           [a]=1

     

       896
       896
       +
           [b]=0

     

       897
       897
       +
       )

     

       898
       898
       +
       checkFileset 'fileFilter (file: assert file.name == "a"; true) ./a'

     

       899
       899
       +
       tree=(

     

       900
       900
       +
           [a]=0

     

       901
       901
       +
           [b]=0

     

       902
       902
       +
       )

     

       903
       903
       +
       checkFileset 'fileFilter (file: assert file.name == "a"; false) ./a'

     

       877
       904
        
       

     

       878
       905
        
       ## Tracing

     

       879
       906