commit bc4ce318bf6aa52031ad891675c573ce31308c8d · pyrox.dev/nixpkgs

+1 -1

lib/default.nix

···

       103
       103
        
             getName getVersion

     

       104
       104
        
             nameFromURL enableFeature enableFeatureAs withFeature

     

       105
       105
        
             withFeatureAs fixedWidthString fixedWidthNumber isStorePath

     

       106
       106
       -
             toInt readPathsFromFile fileContents;

     

       106
       106
       +
             toInt toIntBase10 readPathsFromFile fileContents;

     

       107
       107
        
           inherit (self.stringsWithDeps) textClosureList textClosureMap

     

       108
       108
        
             noDepEntry fullDepEntry packEntry stringAfter;

     

       109
       109
        
           inherit (self.customisation) overrideDerivation makeOverridable

+87 -6

lib/strings.nix

···

       783
       783
        
           else

     

       784
       784
        
             false;

     

       785
       785
        
       

     

       786
       786
       -
         /* Parse a string as an int.

     

       786
       786
       +
         /* Parse a string as an int. Does not support parsing of integers with preceding zero due to

     

       787
       787
       +
         ambiguity between zero-padded and octal numbers. See toIntBase10.

     

       787
       788
        
       

     

       788
       789
        
            Type: string -> int

     

       789
       790
        
       

     

       790
       791
        
            Example:

     

       792
       792
       +
       

     

       791
       793
        
              toInt "1337"

     

       792
       794
        
              => 1337

     

       795
       795
       +
       

     

       793
       796
        
              toInt "-4"

     

       794
       797
        
              => -4

     

       798
       798
       +
       

     

       799
       799
       +
              toInt " 123 "

     

       800
       800
       +
              => 123

     

       801
       801
       +
       

     

       802
       802
       +
              toInt "00024"

     

       803
       803
       +
              => error: Ambiguity in interpretation of 00024 between octal and zero padded integer.

     

       804
       804
       +
       

     

       795
       805
        
              toInt "3.14"

     

       796
       806
        
              => error: floating point JSON numbers are not supported

     

       797
       807
        
         */

     

       798
       798
       -
         # Obviously, it is a bit hacky to use fromJSON this way.

     

       799
       808
        
         toInt = str:

     

       800
       800
       -
           let may_be_int = fromJSON str; in

     

       801
       801
       -
           if isInt may_be_int

     

       802
       802
       -
           then may_be_int

     

       803
       803
       -
           else throw "Could not convert ${str} to int.";

     

       809
       809
       +
           let

     

       810
       810
       +
             # RegEx: Match any leading whitespace, then any digits, and finally match any trailing

     

       811
       811
       +
             # whitespace.

     

       812
       812
       +
             strippedInput = match "[[:space:]]*([[:digit:]]+)[[:space:]]*" str;

     

       813
       813
       +
       

     

       814
       814
       +
             # RegEx: Match a leading '0' then one or more digits.

     

       815
       815
       +
             isLeadingZero = match "0[[:digit:]]+" (head strippedInput) == [];

     

       816
       816
       +
       

     

       817
       817
       +
             # Attempt to parse input

     

       818
       818
       +
             parsedInput = fromJSON (head strippedInput);

     

       819
       819
       +
       

     

       820
       820
       +
             generalError = "toInt: Could not convert ${escapeNixString str} to int.";

     

       821
       821
       +
       

     

       822
       822
       +
             octalAmbigError = "toInt: Ambiguity in interpretation of ${escapeNixString str}"

     

       823
       823
       +
             + " between octal and zero padded integer.";

     

       824
       824
       +
       

     

       825
       825
       +
           in

     

       826
       826
       +
             # Error on presence of non digit characters.

     

       827
       827
       +
             if strippedInput == null

     

       828
       828
       +
             then throw generalError

     

       829
       829
       +
             # Error on presence of leading zero/octal ambiguity.

     

       830
       830
       +
             else if isLeadingZero

     

       831
       831
       +
             then throw octalAmbigError

     

       832
       832
       +
             # Error if parse function fails.

     

       833
       833
       +
             else if !isInt parsedInput

     

       834
       834
       +
             then throw generalError

     

       835
       835
       +
             # Return result.

     

       836
       836
       +
             else parsedInput;

     

       837
       837
       +
       

     

       838
       838
       +
       

     

       839
       839
       +
         /* Parse a string as a base 10 int. This supports parsing of zero-padded integers.

     

       840
       840
       +
       

     

       841
       841
       +
            Type: string -> int

     

       842
       842
       +
       

     

       843
       843
       +
            Example:

     

       844
       844
       +
              toIntBase10 "1337"

     

       845
       845
       +
              => 1337

     

       846
       846
       +
       

     

       847
       847
       +
              toIntBase10 "-4"

     

       848
       848
       +
              => -4

     

       849
       849
       +
       

     

       850
       850
       +
              toIntBase10 " 123 "

     

       851
       851
       +
              => 123

     

       852
       852
       +
       

     

       853
       853
       +
              toIntBase10 "00024"

     

       854
       854
       +
              => 24

     

       855
       855
       +
       

     

       856
       856
       +
              toIntBase10 "3.14"

     

       857
       857
       +
              => error: floating point JSON numbers are not supported

     

       858
       858
       +
         */

     

       859
       859
       +
         toIntBase10 = str:

     

       860
       860
       +
           let

     

       861
       861
       +
             # RegEx: Match any leading whitespace, then match any zero padding, capture any remaining

     

       862
       862
       +
             # digits after that, and finally match any trailing whitespace.

     

       863
       863
       +
             strippedInput = match "[[:space:]]*0*([[:digit:]]+)[[:space:]]*" str;

     

       864
       864
       +
       

     

       865
       865
       +
             # RegEx: Match at least one '0'.

     

       866
       866
       +
             isZero = match "0+" (head strippedInput) == [];

     

       867
       867
       +
       

     

       868
       868
       +
             # Attempt to parse input

     

       869
       869
       +
             parsedInput = fromJSON (head strippedInput);

     

       870
       870
       +
       

     

       871
       871
       +
             generalError = "toIntBase10: Could not convert ${escapeNixString str} to int.";

     

       872
       872
       +
       

     

       873
       873
       +
           in

     

       874
       874
       +
             # Error on presence of non digit characters.

     

       875
       875
       +
             if strippedInput == null

     

       876
       876
       +
             then throw generalError

     

       877
       877
       +
             # In the special case zero-padded zero (00000), return early.

     

       878
       878
       +
             else if isZero

     

       879
       879
       +
             then 0

     

       880
       880
       +
             # Error if parse function fails.

     

       881
       881
       +
             else if !isInt parsedInput

     

       882
       882
       +
             then throw generalError

     

       883
       883
       +
             # Return result.

     

       884
       884
       +
             else parsedInput;

     

       804
       885
        
       

     

       805
       886
        
         /* Read a list of paths from `file`, relative to the `rootPath`.

     

       806
       887
        
            Lines beginning with `#` are treated as comments and ignored.

+71

lib/tests/misc.nix

···

       327
       327
        
           expected = "Hello\\x20World";

     

       328
       328
        
         };

     

       329
       329
        
       

     

       330
       330
       +
         testToInt = testAllTrue [

     

       331
       331
       +
           # Naive

     

       332
       332
       +
           (123 == toInt "123")

     

       333
       333
       +
           (0 == toInt "0")

     

       334
       334
       +
           # Whitespace Padding

     

       335
       335
       +
           (123 == toInt " 123")

     

       336
       336
       +
           (123 == toInt "123 ")

     

       337
       337
       +
           (123 == toInt " 123 ")

     

       338
       338
       +
           (123 == toInt "   123   ")

     

       339
       339
       +
           (0 == toInt " 0")

     

       340
       340
       +
           (0 == toInt "0 ")

     

       341
       341
       +
           (0 == toInt " 0 ")

     

       342
       342
       +
         ];

     

       343
       343
       +
       

     

       344
       344
       +
         testToIntFails = testAllTrue [

     

       345
       345
       +
           ( builtins.tryEval (toInt "") == { success = false; value = false; } )

     

       346
       346
       +
           ( builtins.tryEval (toInt "123 123") == { success = false; value = false; } )

     

       347
       347
       +
           ( builtins.tryEval (toInt "0 123") == { success = false; value = false; } )

     

       348
       348
       +
           ( builtins.tryEval (toInt " 0d ") == { success = false; value = false; } )

     

       349
       349
       +
           ( builtins.tryEval (toInt " 1d ") == { success = false; value = false; } )

     

       350
       350
       +
           ( builtins.tryEval (toInt " d0 ") == { success = false; value = false; } )

     

       351
       351
       +
           ( builtins.tryEval (toInt "00") == { success = false; value = false; } )

     

       352
       352
       +
           ( builtins.tryEval (toInt "01") == { success = false; value = false; } )

     

       353
       353
       +
           ( builtins.tryEval (toInt "002") == { success = false; value = false; } )

     

       354
       354
       +
           ( builtins.tryEval (toInt " 002 ") == { success = false; value = false; } )

     

       355
       355
       +
           ( builtins.tryEval (toInt " foo ") == { success = false; value = false; } )

     

       356
       356
       +
           ( builtins.tryEval (toInt " foo 123 ") == { success = false; value = false; } )

     

       357
       357
       +
           ( builtins.tryEval (toInt " foo123 ") == { success = false; value = false; } )

     

       358
       358
       +
         ];

     

       359
       359
       +
       

     

       360
       360
       +
         testToIntBase10 = testAllTrue [

     

       361
       361
       +
           # Naive

     

       362
       362
       +
           (123 == toIntBase10 "123")

     

       363
       363
       +
           (0 == toIntBase10 "0")

     

       364
       364
       +
           # Whitespace Padding

     

       365
       365
       +
           (123 == toIntBase10 " 123")

     

       366
       366
       +
           (123 == toIntBase10 "123 ")

     

       367
       367
       +
           (123 == toIntBase10 " 123 ")

     

       368
       368
       +
           (123 == toIntBase10 "   123   ")

     

       369
       369
       +
           (0 == toIntBase10 " 0")

     

       370
       370
       +
           (0 == toIntBase10 "0 ")

     

       371
       371
       +
           (0 == toIntBase10 " 0 ")

     

       372
       372
       +
           # Zero Padding

     

       373
       373
       +
           (123 == toIntBase10 "0123")

     

       374
       374
       +
           (123 == toIntBase10 "0000123")

     

       375
       375
       +
           (0 == toIntBase10 "000000")

     

       376
       376
       +
           # Whitespace and Zero Padding

     

       377
       377
       +
           (123 == toIntBase10 " 0123")

     

       378
       378
       +
           (123 == toIntBase10 "0123 ")

     

       379
       379
       +
           (123 == toIntBase10 " 0123 ")

     

       380
       380
       +
           (123 == toIntBase10 " 0000123")

     

       381
       381
       +
           (123 == toIntBase10 "0000123 ")

     

       382
       382
       +
           (123 == toIntBase10 " 0000123 ")

     

       383
       383
       +
           (0 == toIntBase10 " 000000")

     

       384
       384
       +
           (0 == toIntBase10 "000000 ")

     

       385
       385
       +
           (0 == toIntBase10 " 000000 ")

     

       386
       386
       +
         ];

     

       387
       387
       +
       

     

       388
       388
       +
         testToIntBase10Fails = testAllTrue [

     

       389
       389
       +
           ( builtins.tryEval (toIntBase10 "") == { success = false; value = false; } )

     

       390
       390
       +
           ( builtins.tryEval (toIntBase10 "123 123") == { success = false; value = false; } )

     

       391
       391
       +
           ( builtins.tryEval (toIntBase10 "0 123") == { success = false; value = false; } )

     

       392
       392
       +
           ( builtins.tryEval (toIntBase10 " 0d ") == { success = false; value = false; } )

     

       393
       393
       +
           ( builtins.tryEval (toIntBase10 " 1d ") == { success = false; value = false; } )

     

       394
       394
       +
           ( builtins.tryEval (toIntBase10 " d0 ") == { success = false; value = false; } )

     

       395
       395
       +
           ( builtins.tryEval (toIntBase10 " foo ") == { success = false; value = false; } )

     

       396
       396
       +
           ( builtins.tryEval (toIntBase10 " foo 123 ") == { success = false; value = false; } )

     

       397
       397
       +
           ( builtins.tryEval (toIntBase10 " foo 00123 ") == { success = false; value = false; } )

     

       398
       398
       +
           ( builtins.tryEval (toIntBase10 " foo00123 ") == { success = false; value = false; } )

     

       399
       399
       +
         ];

     

       400
       400
       +
       

     

       330
       401
        
       # LISTS

     

       331
       402
        
       

     

       332
       403
        
         testFilter = {

+1 -1

lib/tests/modules.sh

···

       162
       162
        
       # Check coerced value with unsound coercion

     

       163
       163
        
       checkConfigOutput '^12$' config.value ./declare-coerced-value-unsound.nix

     

       164
       164
        
       checkConfigError 'A definition for option .* is not of type .*. Definition values:\n\s*- In .*: "1000"' config.value ./declare-coerced-value-unsound.nix ./define-value-string-bigint.nix

     

       165
       165
       -
       checkConfigError 'json.exception.parse_error' config.value ./declare-coerced-value-unsound.nix ./define-value-string-arbitrary.nix

     

       165
       165
       +
       checkConfigError 'toInt: Could not convert .* to int' config.value ./declare-coerced-value-unsound.nix ./define-value-string-arbitrary.nix

     

       166
       166
        
       

     

       167
       167
        
       # Check mkAliasOptionModule.

     

       168
       168
        
       checkConfigOutput '^true$' config.enable ./alias-with-priority.nix