commit 44998896c6a811fcc4021e8ca75243b5d53e605b · pyrox.dev/nixpkgs

+1 -1

lib/asserts.nix

···

       47
       47
        
           :::

     

       48
       48
        
         */

     

       49
       49
        
         # TODO(Profpatsch): add tests that check stderr

     

       50
       50
       -
         assertMsg = pred: msg: pred || builtins.throw msg;

     

       50
       50
       +
         assertMsg = pred: msg: pred || throw msg;

     

       51
       51
        
       

     

       52
       52
        
         /**

     

       53
       53
        
           Specialized `assertMsg` for checking if `val` is one of the elements

+2 -2

lib/attrsets.nix

···

       2149
       2149
        
           chooseDevOutputs :: [Derivation] -> [Derivation]

     

       2150
       2150
        
           ```

     

       2151
       2151
        
         */

     

       2152
       2152
       -
         chooseDevOutputs = builtins.map getDev;

     

       2152
       2152
       +
         chooseDevOutputs = map getDev;

     

       2153
       2153
        
       

     

       2154
       2154
        
         /**

     

       2155
       2155
        
           Make various Nix tools consider the contents of the resulting

     
···

       2230
       2230
        
             intersection = builtins.intersectAttrs x y;

     

       2231
       2231
        
             collisions = lib.concatStringsSep " " (builtins.attrNames intersection);

     

       2232
       2232
        
             mask = builtins.mapAttrs (

     

       2233
       2233
       -
               name: value: builtins.throw "unionOfDisjoint: collision on ${name}; complete list: ${collisions}"

     

       2233
       2233
       +
               name: value: throw "unionOfDisjoint: collision on ${name}; complete list: ${collisions}"

     

       2234
       2234
        
             ) intersection;

     

       2235
       2235
        
           in

     

       2236
       2236
        
           (x // y) // mask;

+2 -2

lib/deprecated/misc.nix

···

       250
       250
        
         # See https://github.com/NixOS/nixpkgs/pull/194391 for details.

     

       251
       251
        
         closePropagationFast =

     

       252
       252
        
           list:

     

       253
       253
       -
           builtins.map (x: x.val) (

     

       253
       253
       +
           map (x: x.val) (

     

       254
       254
        
             builtins.genericClosure {

     

       255
       255
       -
               startSet = builtins.map (x: {

     

       255
       255
       +
               startSet = map (x: {

     

       256
       256
        
                 key = x.outPath;

     

       257
       257
        
                 val = x;

     

       258
       258
        
               }) (builtins.filter (x: x != null) list);

+6 -6

lib/fileset/tests.sh

···

       1406
       1406
        
       git add .

     

       1407
       1407
        
       

     

       1408
       1408
        
       ## We can evaluate it locally just fine, `fetchGit` is used underneath to filter git-tracked files

     

       1409
       1409
       -
       expectEqual '(import ./. { fs = lib.fileset; }).outPath' '(builtins.fetchGit ./.).outPath'

     

       1409
       1409
       +
       expectEqual '(import ./. { fs = lib.fileset; }).outPath' '(fetchGit ./.).outPath'

     

       1410
       1410
        
       

     

       1411
       1411
        
       ## We can also evaluate when importing from fetched store paths

     

       1412
       1412
       -
       storePath=$(expectStorePath 'builtins.fetchGit ./.')

     

       1412
       1412
       +
       storePath=$(expectStorePath 'fetchGit ./.')

     

       1413
       1413
        
       expectEqual '(import '"$storePath"' { fs = lib.fileset; }).outPath' \""$storePath"\"

     

       1414
       1414
        
       

     

       1415
       1415
        
       ## But it fails if the path is imported with a fetcher that doesn't remove .git (like just using "${./.}")

     
···

       1429
       1429
        
       git -C sub add .

     

       1430
       1430
        
       

     

       1431
       1431
        
       ## We can evaluate it locally just fine, `fetchGit` is used underneath to filter git-tracked files

     

       1432
       1432
       -
       expectEqual '(import ./. { fs = lib.fileset; }).outPath' '(builtins.fetchGit { url = ./.; submodules = true; }).outPath'

     

       1433
       1433
       -
       expectEqual '(import ./sub { fs = lib.fileset; }).outPath' '(builtins.fetchGit ./sub).outPath'

     

       1432
       1432
       +
       expectEqual '(import ./. { fs = lib.fileset; }).outPath' '(fetchGit { url = ./.; submodules = true; }).outPath'

     

       1433
       1433
       +
       expectEqual '(import ./sub { fs = lib.fileset; }).outPath' '(fetchGit ./sub).outPath'

     

       1434
       1434
        
       

     

       1435
       1435
        
       ## We can also evaluate when importing from fetched store paths

     

       1436
       1436
       -
       storePathWithSub=$(expectStorePath 'builtins.fetchGit { url = ./.; submodules = true; }')

     

       1436
       1436
       +
       storePathWithSub=$(expectStorePath 'fetchGit { url = ./.; submodules = true; }')

     

       1437
       1437
        
       expectEqual '(import '"$storePathWithSub"' { fs = lib.fileset; }).outPath' \""$storePathWithSub"\"

     

       1438
       1438
       -
       storePathSub=$(expectStorePath 'builtins.fetchGit ./sub')

     

       1438
       1438
       +
       storePathSub=$(expectStorePath 'fetchGit ./sub')

     

       1439
       1439
        
       expectEqual '(import '"$storePathSub"' { fs = lib.fileset; }).outPath' \""$storePathSub"\"

     

       1440
       1440
        
       

     

       1441
       1441
        
       ## But it fails if the path is imported with a fetcher that doesn't remove .git (like just using "${./.}")

+1 -1

lib/gvariant.nix

···

       150
       150
        
               ) intConstructors;

     

       151
       151
        
             in

     

       152
       152
        
             throw ''

     

       153
       153
       -
               The GVariant type for number “${builtins.toString v}” is unclear.

     

       153
       153
       +
               The GVariant type for number “${toString v}” is unclear.

     

       154
       154
        
               Please wrap the value with one of the following, depending on the value type in GSettings schema:

     

       155
       155
        
       

     

       156
       156
        
               ${lib.concatMapStringsSep "\n" (

+1 -1

lib/meta.nix

···

       399
       399
        
           => true

     

       400
       400
        
           lib.getLicenseFromSpdxIdOr "MY LICENSE" null

     

       401
       401
        
           => null

     

       402
       402
       -
           lib.getLicenseFromSpdxIdOr "MY LICENSE" (builtins.throw "No SPDX ID matches MY LICENSE")

     

       402
       402
       +
           lib.getLicenseFromSpdxIdOr "MY LICENSE" (throw "No SPDX ID matches MY LICENSE")

     

       403
       403
        
           => error: No SPDX ID matches MY LICENSE

     

       404
       404
        
           ```

     

       405
       405
        
           :::

+1 -1

lib/strings.nix

···

       1135
       1135
        
               "."

     

       1136
       1136
        
               "~"

     

       1137
       1137
        
             ];

     

       1138
       1138
       -
             toEscape = builtins.removeAttrs asciiTable unreserved;

     

       1138
       1138
       +
             toEscape = removeAttrs asciiTable unreserved;

     

       1139
       1139
        
           in

     

       1140
       1140
        
           replaceStrings (builtins.attrNames toEscape) (

     

       1141
       1141
        
             lib.mapAttrsToList (_: c: "%${fixedWidthString 2 "0" (lib.toHexString c)}") toEscape

+1 -1

lib/systems/default.nix

···

       75
       75
        
       

     

       76
       76
        
             # Those two will always be derived from "config", if given, so they should NOT

     

       77
       77
        
             # be overridden further down with "// args".

     

       78
       78
       -
             args = builtins.removeAttrs allArgs [

     

       78
       78
       +
             args = removeAttrs allArgs [

     

       79
       79
        
               "parsed"

     

       80
       80
        
               "system"

     

       81
       81
        
             ];

+1 -1

lib/tests/checkAndMergeCompat.nix

···

       326
       326
        
         coerce_str_to_int_coercer_ouput = getMatrix {

     

       327
       327
        
           outerTypeName = "coercedTo";

     

       328
       328
        
           innerTypeName = "int->str";

     

       329
       329
       -
           getType = a: b: a.coercedTo b.int builtins.toString a.str;

     

       329
       329
       +
           getType = a: b: a.coercedTo b.int toString a.str;

     

       330
       330
        
           value = [ ];

     

       331
       331
        
           testAttrs = {

     

       332
       332
        
             expectedError = {

+1 -1

lib/tests/misc.nix

···

       4488
       4488
        
           expr = packagesFromDirectoryRecursive {

     

       4489
       4489
        
             callPackage = path: overrides: import path overrides;

     

       4490
       4490
        
             # Do NOT remove the `builtins.toString` call here!!!

     

       4491
       4491
       -
             directory = builtins.toString ./packages-from-directory/plain;

     

       4491
       4491
       +
             directory = toString ./packages-from-directory/plain;

     

       4492
       4492
        
           };

     

       4493
       4493
        
           expected = {

     

       4494
       4494
        
             a = "a";

+1 -1

lib/tests/modules/declare-coerced-value-no-default.nix

···

       3
       3
        
       {

     

       4
       4
        
         options = {

     

       5
       5
        
           value = lib.mkOption {

     

       6
       6
       -
             type = lib.types.coercedTo lib.types.int builtins.toString lib.types.str;

     

       6
       6
       +
             type = lib.types.coercedTo lib.types.int toString lib.types.str;

     

       7
       7
        
           };

     

       8
       8
        
         };

     

       9
       9
        
       }

+1 -1

lib/tests/modules/declare-coerced-value.nix

···

       4
       4
        
         options = {

     

       5
       5
        
           value = lib.mkOption {

     

       6
       6
        
             default = 42;

     

       7
       7
       -
             type = lib.types.coercedTo lib.types.int builtins.toString lib.types.str;

     

       7
       7
       +
             type = lib.types.coercedTo lib.types.int toString lib.types.str;

     

       8
       8
        
           };

     

       9
       9
        
         };

     

       10
       10
        
       }

+1 -1

lib/tests/modules/define-freeform-keywords-shorthand.nix

···

       9
       9
        
       

     

       10
       10
        
         _module.args.result =

     

       11
       11
        
           let

     

       12
       12
       -
             r = builtins.removeAttrs config [ "_module" ];

     

       12
       12
       +
             r = removeAttrs config [ "_module" ];

     

       13
       13
        
           in

     

       14
       14
        
           builtins.trace (builtins.deepSeq r r) (

     

       15
       15
        
             r == {

+4 -4

lib/trivial.nix

···

       769
       769
        
           importTOML :: path -> any

     

       770
       770
        
           ```

     

       771
       771
        
         */

     

       772
       772
       -
         importTOML = path: builtins.fromTOML (builtins.readFile path);

     

       772
       772
       +
         importTOML = path: fromTOML (builtins.readFile path);

     

       773
       773
        
       

     

       774
       774
        
         /**

     

       775
       775
        
           `warn` *`message`* *`value`*

     
···

       975
       975
        
             unexpected = lib.subtractLists valid given;

     

       976
       976
        
           in

     

       977
       977
        
           lib.throwIfNot (unexpected == [ ])

     

       978
       978
       -
             "${msg}: ${builtins.concatStringsSep ", " (builtins.map builtins.toString unexpected)} unexpected; valid ones: ${builtins.concatStringsSep ", " (builtins.map builtins.toString valid)}";

     

       978
       978
       +
             "${msg}: ${builtins.concatStringsSep ", " (map toString unexpected)} unexpected; valid ones: ${builtins.concatStringsSep ", " (map toString valid)}";

     

       979
       979
        
       

     

       980
       980
        
         info = msg: builtins.trace "INFO: ${msg}";

     

       981
       981
        
       

     
···

       1144
       1144
        
             match = builtins.match "(0x)?([0-7]?[0-9A-Fa-f]{1,15})" str;

     

       1145
       1145
        
           in

     

       1146
       1146
        
           if match != null then

     

       1147
       1147
       -
             (builtins.fromTOML "v=0x${builtins.elemAt match 1}").v

     

       1147
       1147
       +
             (fromTOML "v=0x${builtins.elemAt match 1}").v

     

       1148
       1148
        
           else

     

       1149
       1149
        
             # TODO: Turn this into a `throw` in 26.05.

     

       1150
       1150
        
             assert lib.warn "fromHexString: ${

     
···

       1153
       1153
        
             let

     

       1154
       1154
        
               noPrefix = lib.strings.removePrefix "0x" (lib.strings.toLower str);

     

       1155
       1155
        
             in

     

       1156
       1156
       -
             (builtins.fromTOML "v=0x${noPrefix}").v;

     

       1156
       1156
       +
             (fromTOML "v=0x${noPrefix}").v;

     

       1157
       1157
        
       

     

       1158
       1158
        
         /**

     

       1159
       1159
        
           Convert the given positive integer to a string of its hexadecimal

+1 -1

lib/types.nix

···

       1373
       1373
        
                   if builtins.isString v then

     

       1374
       1374
        
                     ''"${v}"''

     

       1375
       1375
        
                   else if builtins.isInt v then

     

       1376
       1376
       -
                     builtins.toString v

     

       1376
       1376
       +
                     toString v

     

       1377
       1377
        
                   else if builtins.isBool v then

     

       1378
       1378
        
                     boolToString v

     

       1379
       1379
        
                   else