···

       
315
       
315
       
 
       
  */

     

       
316
       
316
       
 
       
  escapeNixString = s: escape ["$"] (builtins.toJSON s);

     

       
317
       
317
       
 
       


     

       
318
       
318
       
+
       
  /* Turn a string into an exact regular expression

     

       
319
       
319
       
+
       


     

       
320
       
320
       
+
       
     Type: string -> string

     

       
321
       
321
       
+
       


     

       
322
       
322
       
+
       
     Example:

     

       
323
       
323
       
+
       
       escapeRegex "[^a-z]*"

     

       
324
       
324
       
+
       
       => "\\[\\^a-z]\\*"

     

       
325
       
325
       
+
       
  */

     

       
326
       
326
       
+
       
  escapeRegex = escape (stringToCharacters "\\[{()^$?*+|.");

     

       
327
       
327
       
+
       


     

       
318
       
328
       
 
       
  /* Quotes a string if it can't be used as an identifier directly.

     

       
319
       
329
       
 
       


     

       
320
       
330
       
 
       
     Type: string -> string

     
···

       
386
       
396
       
 
       
  /* Cut a string with a separator and produces a list of strings which

     

       
387
       
397
       
 
       
     were separated by this separator.

     

       
388
       
398
       
 
       


     

       
389
       
389
       
-
       
     NOTE: this function is not performant and should never be used.

     

       
390
       
390
       
-
       


     

       
391
       
399
       
 
       
     Example:

     

       
392
       
400
       
 
       
       splitString "." "foo.bar.baz"

     

       
393
       
401
       
 
       
       => [ "foo" "bar" "baz" ]

     
···

       
396
       
404
       
 
       
  */

     

       
397
       
405
       
 
       
  splitString = _sep: _s:

     

       
398
       
406
       
 
       
    let

     

       
399
       
399
       
-
       
      sep = addContextFrom _s _sep;

     

       
400
       
400
       
-
       
      s = addContextFrom _sep _s;

     

       
401
       
401
       
-
       
      sepLen = stringLength sep;

     

       
402
       
402
       
-
       
      sLen = stringLength s;

     

       
403
       
403
       
-
       
      lastSearch = sLen - sepLen;

     

       
404
       
404
       
-
       
      startWithSep = startAt:

     

       
405
       
405
       
-
       
        substring startAt sepLen s == sep;

     

       
406
       
406
       
-
       


     

       
407
       
407
       
-
       
      recurse = index: startAt:

     

       
408
       
408
       
-
       
        let cutUntil = i: [(substring startAt (i - startAt) s)]; in

     

       
409
       
409
       
-
       
        if index <= lastSearch then

     

       
410
       
410
       
-
       
          if startWithSep index then

     

       
411
       
411
       
-
       
            let restartAt = index + sepLen; in

     

       
412
       
412
       
-
       
            cutUntil index ++ recurse restartAt restartAt

     

       
413
       
413
       
-
       
          else

     

       
414
       
414
       
-
       
            recurse (index + 1) startAt

     

       
415
       
415
       
-
       
        else

     

       
416
       
416
       
-
       
          cutUntil sLen;

     

       
407
       
407
       
+
       
      sep = builtins.unsafeDiscardStringContext _sep;

     

       
408
       
408
       
+
       
      s = builtins.unsafeDiscardStringContext _s;

     

       
409
       
409
       
+
       
      splits = builtins.filter builtins.isString (builtins.split (escapeRegex sep) s);

     

       
417
       
410
       
 
       
    in

     

       
418
       
418
       
-
       
      recurse 0 0;

     

       
411
       
411
       
+
       
      map (v: addContextFrom _sep (addContextFrom _s v)) splits;

     

       
419
       
412
       
 
       


     

       
420
       
413
       
 
       
  /* Return a string without the specified prefix, if the prefix matches.

     

       
421
       
414
       
 
       


     

···

       
154
       
154
       
 
       
    expected = [ "2001" "db8" "0" "0042" "" "8a2e" "370" "" ];

     

       
155
       
155
       
 
       
  };

     

       
156
       
156
       
 
       


     

       
157
       
157
       
+
       
  testSplitStringsRegex = {

     

       
158
       
158
       
+
       
    expr = strings.splitString "\\[{}]()^$?*+|." "A\\[{}]()^$?*+|.B";

     

       
159
       
159
       
+
       
    expected = [ "A" "B" ];

     

       
160
       
160
       
+
       
  };

     

       
161
       
161
       
+
       


     

       
162
       
162
       
+
       
  testSplitStringsDerivation = {

     

       
163
       
163
       
+
       
    expr = take 3  (strings.splitString "/" (derivation {

     

       
164
       
164
       
+
       
      name = "name";

     

       
165
       
165
       
+
       
      builder = "builder";

     

       
166
       
166
       
+
       
      system = "system";

     

       
167
       
167
       
+
       
    }));

     

       
168
       
168
       
+
       
    expected = ["" "nix" "store"];

     

       
169
       
169
       
+
       
  };

     

       
170
       
170
       
+
       


     

       
157
       
171
       
 
       
  testSplitVersionSingle = {

     

       
158
       
172
       
 
       
    expr = versions.splitVersion "1";

     

       
159
       
173
       
 
       
    expected = [ "1" ];