commit 814f067760d029f532f990974a6df240d4320105 · pyrox.dev/nixpkgs

+53

lib/path/default.nix

···

       20
       20
        
           concatMap

     

       21
       21
        
           foldl'

     

       22
       22
        
           take

     

       23
       23
       +
           drop

     

       23
       24
        
           ;

     

       24
       25
        
       

     

       25
       26
        
         inherit (lib.strings)

     
···

       217
       218
        
                     second argument: "${toString path2}" with root "${toString path2Deconstructed.root}"'';

     

       218
       219
        
               take (length path1Deconstructed.components) path2Deconstructed.components == path1Deconstructed.components;

     

       219
       220
        
       

     

       221
       221
       +
         /*

     

       222
       222
       +
         Remove the first path as a component-wise prefix from the second path.

     

       223
       223
       +
         The result is a normalised subpath string, see `lib.path.subpath.normalise`.

     

       224
       224
       +
       

     

       225
       225
       +
         Laws:

     

       226
       226
       +
       

     

       227
       227
       +
         - Inverts `append` for normalised subpaths:

     

       228
       228
       +
       

     

       229
       229
       +
               removePrefix p (append p s) == subpath.normalise s

     

       230
       230
       +
       

     

       231
       231
       +
         Type:

     

       232
       232
       +
           removePrefix :: Path -> Path -> String

     

       233
       233
       +
       

     

       234
       234
       +
         Example:

     

       235
       235
       +
           removePrefix /foo /foo/bar/baz

     

       236
       236
       +
           => "./bar/baz"

     

       237
       237
       +
           removePrefix /foo /foo

     

       238
       238
       +
           => "./."

     

       239
       239
       +
           removePrefix /foo/bar /foo

     

       240
       240
       +
           => <error>

     

       241
       241
       +
           removePrefix /. /foo

     

       242
       242
       +
           => "./foo"

     

       243
       243
       +
         */

     

       244
       244
       +
         removePrefix =

     

       245
       245
       +
           path1:

     

       246
       246
       +
           assert assertMsg

     

       247
       247
       +
             (isPath path1)

     

       248
       248
       +
             "lib.path.removePrefix: First argument is of type ${typeOf path1}, but a path was expected.";

     

       249
       249
       +
           let

     

       250
       250
       +
             path1Deconstructed = deconstructPath path1;

     

       251
       251
       +
             path1Length = length path1Deconstructed.components;

     

       252
       252
       +
           in

     

       253
       253
       +
             path2:

     

       254
       254
       +
             assert assertMsg

     

       255
       255
       +
               (isPath path2)

     

       256
       256
       +
               "lib.path.removePrefix: Second argument is of type ${typeOf path2}, but a path was expected.";

     

       257
       257
       +
             let

     

       258
       258
       +
               path2Deconstructed = deconstructPath path2;

     

       259
       259
       +
               success = take path1Length path2Deconstructed.components == path1Deconstructed.components;

     

       260
       260
       +
               components =

     

       261
       261
       +
                 if success then

     

       262
       262
       +
                   drop path1Length path2Deconstructed.components

     

       263
       263
       +
                 else

     

       264
       264
       +
                   throw ''

     

       265
       265
       +
                     lib.path.removePrefix: The first path argument "${toString path1}" is not a component-wise prefix of the second path argument "${toString path2}".'';

     

       266
       266
       +
             in

     

       267
       267
       +
               assert assertMsg

     

       268
       268
       +
               (path1Deconstructed.root == path2Deconstructed.root) ''

     

       269
       269
       +
                 lib.path.removePrefix: Filesystem roots must be the same for both paths, but paths with different roots were given:

     

       270
       270
       +
                     first argument: "${toString path1}" with root "${toString path1Deconstructed.root}"

     

       271
       271
       +
                     second argument: "${toString path2}" with root "${toString path2Deconstructed.root}"'';

     

       272
       272
       +
               joinRelPath components;

     

       220
       273
        
       

     

       221
       274
        
         /* Whether a value is a valid subpath string.

     

       222
       275

+18 -1

lib/path/tests/unit.nix

···

       3
       3
        
       { libpath }:

     

       4
       4
        
       let

     

       5
       5
        
         lib = import libpath;

     

       6
       6
       -
         inherit (lib.path) hasPrefix append subpath;

     

       6
       6
       +
         inherit (lib.path) hasPrefix removePrefix append subpath;

     

       7
       7
        
       

     

       8
       8
        
         cases = lib.runTests {

     

       9
       9
        
           # Test examples from the lib.path.append documentation

     
···

       55
       55
        
           testHasPrefixExample4 = {

     

       56
       56
        
             expr = hasPrefix /. /foo;

     

       57
       57
        
             expected = true;

     

       58
       58
       +
           };

     

       59
       59
       +
       

     

       60
       60
       +
           testRemovePrefixExample1 = {

     

       61
       61
       +
             expr = removePrefix /foo /foo/bar/baz;

     

       62
       62
       +
             expected = "./bar/baz";

     

       63
       63
       +
           };

     

       64
       64
       +
           testRemovePrefixExample2 = {

     

       65
       65
       +
             expr = removePrefix /foo /foo;

     

       66
       66
       +
             expected = "./.";

     

       67
       67
       +
           };

     

       68
       68
       +
           testRemovePrefixExample3 = {

     

       69
       69
       +
             expr = (builtins.tryEval (removePrefix /foo/bar /foo)).success;

     

       70
       70
       +
             expected = false;

     

       71
       71
       +
           };

     

       72
       72
       +
           testRemovePrefixExample4 = {

     

       73
       73
       +
             expr = removePrefix /. /foo;

     

       74
       74
       +
             expected = "./foo";

     

       58
       75
        
           };

     

       59
       76
        
       

     

       60
       77
        
           # Test examples from the lib.path.subpath.isValid documentation