commit 6177c4ad724f155e05c15e686cc9f27eecd3682b · 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);

+2 -2

lib/fileset/default.nix

···

       947
       947
        
           `gitTrackedWith` does not perform any filtering when the path is a [Nix store path](https://nixos.org/manual/nix/stable/store/store-path.html#store-path) and not a repository.

     

       948
       948
        
           In this way, it accommodates the use case where the expression that makes the `gitTracked` call does not reside in an actual git repository anymore,

     

       949
       949
        
           and has presumably already been fetched in a way that excludes untracked files.

     

       950
       950
       -
           Fetchers with such equivalent behavior include `builtins.fetchGit`, `builtins.fetchTree` (experimental), and `pkgs.fetchgit` when used without `leaveDotGit`.

     

       950
       950
       +
           Fetchers with such equivalent behavior include `fetchGit`, `fetchTree` (experimental), and `pkgs.fetchgit` when used without `leaveDotGit`.

     

       951
       951
        
       

     

       952
       952
        
           If you don't need the configuration,

     

       953
       953
        
           you can use [`gitTracked`](#function-library-lib.fileset.gitTracked) instead.

     
···

       956
       956
        
           (which uses [`--cached`](https://git-scm.com/docs/git-ls-files#Documentation/git-ls-files.txt--c) by default).

     

       957
       957
        
       

     

       958
       958
        
           :::{.warning}

     

       959
       959
       -
           Currently this function is based on [`builtins.fetchGit`](https://nixos.org/manual/nix/stable/language/builtins.html#builtins-fetchGit)

     

       959
       959
       +
           Currently this function is based on [`fetchGit`](https://nixos.org/manual/nix/stable/language/builtins.html#builtins-fetchGit)

     

       960
       960
        
           As such, this function causes all Git-tracked files to be unnecessarily added to the Nix store,

     

       961
       961
        
           without being re-usable by [`toSource`](#function-library-lib.fileset.toSource).

     

       962
       962

+4 -4

lib/fileset/internal.nix

···

       932
       932
        
                 throw ''

     

       933
       933
        
                   lib.fileset.${function}: The ${argument} (${toString path}) is a store path within a working tree of a Git repository.

     

       934
       934
        
                       This indicates that a source directory was imported into the store using a method such as `import "''${./.}"` or `path:.`.

     

       935
       935
       -
                       This function currently does not support such a use case, since it currently relies on `builtins.fetchGit`.

     

       935
       935
       +
                       This function currently does not support such a use case, since it currently relies on `fetchGit`.

     

       936
       936
        
                       You could make this work by using a fetcher such as `fetchGit` instead of copying the whole repository.

     

       937
       937
        
                       If you can't avoid copying the repo to the store, see https://github.com/NixOS/nix/issues/9292.''

     

       938
       938
        
               else

     

       939
       939
        
                 # Otherwise we're going to assume that the path was a Git directory originally,

     

       940
       940
        
                 # but it was fetched using a method that already removed files not tracked by Git,

     

       941
       941
       -
                 # such as `builtins.fetchGit`, `pkgs.fetchgit` or others.

     

       941
       941
       +
                 # such as `fetchGit`, `pkgs.fetchgit` or others.

     

       942
       942
        
                 # So we can just import the path in its entirety.

     

       943
       943
        
                 _singleton path;

     

       944
       944
        
       

     
···

       946
       946
        
             tryFetchGit =

     

       947
       947
        
               let

     

       948
       948
        
                 # This imports the files unnecessarily, which currently can't be avoided

     

       949
       949
       -
                 # because `builtins.fetchGit` is the only function exposing which files are tracked by Git.

     

       949
       949
       +
                 # because `fetchGit` is the only function exposing which files are tracked by Git.

     

       950
       950
        
                 # With the [lazy trees PR](https://github.com/NixOS/nix/pull/6530),

     

       951
       951
        
                 # the unnecessarily import could be avoided.

     

       952
       952
        
                 # However a simpler alternative still would be [a builtins.gitLsFiles](https://github.com/NixOS/nix/issues/2944).

     
···

       960
       960
        
               in

     

       961
       961
        
               # We can identify local working directories by checking for .git,

     

       962
       962
        
               # see https://git-scm.com/docs/gitrepository-layout#_description.

     

       963
       963
       -
               # Note that `builtins.fetchGit` _does_ work for bare repositories (where there's no `.git`),

     

       963
       963
       +
               # Note that `fetchGit` _does_ work for bare repositories (where there's no `.git`),

     

       964
       964
        
               # even though `git ls-files` wouldn't return any files in that case.

     

       965
       965
        
               if !pathExists (path + "/.git") then

     

       966
       966
        
                 throw "lib.fileset.${function}: Expected the ${argument} (${toString path}) to point to a local working tree of a Git repository, but it's not."

+9 -9

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 "${./.}")

     

       1416
       1416
        
       expectFailure 'import "${./.}" { fs = lib.fileset; }' 'lib.fileset.gitTracked: The argument \(.*\) is a store path within a working tree of a Git repository.

     

       1417
       1417
        
       [[:blank:]]*This indicates that a source directory was imported into the store using a method such as `import "\$\{./.\}"` or `path:.`.

     

       1418
       1418
       -
       [[:blank:]]*This function currently does not support such a use case, since it currently relies on `builtins.fetchGit`.

     

       1418
       1418
       +
       [[:blank:]]*This function currently does not support such a use case, since it currently relies on `fetchGit`.

     

       1419
       1419
        
       [[:blank:]]*You could make this work by using a fetcher such as `fetchGit` instead of copying the whole repository.

     

       1420
       1420
        
       [[:blank:]]*If you can'\''t avoid copying the repo to the store, see https://github.com/NixOS/nix/issues/9292.'

     

       1421
       1421
        
       

     
···

       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 "${./.}")

     

       1442
       1442
        
       expectFailure 'import "${./.}" { fs = lib.fileset; }' 'lib.fileset.gitTrackedWith: The second argument \(.*\) is a store path within a working tree of a Git repository.

     

       1443
       1443
        
       [[:blank:]]*This indicates that a source directory was imported into the store using a method such as `import "\$\{./.\}"` or `path:.`.

     

       1444
       1444
       -
       [[:blank:]]*This function currently does not support such a use case, since it currently relies on `builtins.fetchGit`.

     

       1444
       1444
       +
       [[:blank:]]*This function currently does not support such a use case, since it currently relies on `fetchGit`.

     

       1445
       1445
        
       [[:blank:]]*You could make this work by using a fetcher such as `fetchGit` instead of copying the whole repository.

     

       1446
       1446
        
       [[:blank:]]*If you can'\''t avoid copying the repo to the store, see https://github.com/NixOS/nix/issues/9292.'

     

       1447
       1447
        
       expectFailure 'import "${./.}/sub" { fs = lib.fileset; }' 'lib.fileset.gitTracked: The argument \(.*/sub\) is a store path within a working tree of a Git repository.

     

       1448
       1448
        
       [[:blank:]]*This indicates that a source directory was imported into the store using a method such as `import "\$\{./.\}"` or `path:.`.

     

       1449
       1449
       -
       [[:blank:]]*This function currently does not support such a use case, since it currently relies on `builtins.fetchGit`.

     

       1449
       1449
       +
       [[:blank:]]*This function currently does not support such a use case, since it currently relies on `fetchGit`.

     

       1450
       1450
        
       [[:blank:]]*You could make this work by using a fetcher such as `fetchGit` instead of copying the whole repository.

     

       1451
       1451
        
       [[:blank:]]*If you can'\''t avoid copying the repo to the store, see https://github.com/NixOS/nix/issues/9292.'

     

       1452
       1452
        
       rm -rf -- *

+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/path/README.md

···

       102
       102
        
       - (-) `./.` is rather long.

     

       103
       103
        
         - (-) We don't require users to type this though, as it's only output by the library.

     

       104
       104
        
           As inputs all three variants are supported for subpaths (and we can't do anything about absolute paths)

     

       105
       105
       -
       - (-) `builtins.dirOf "foo" == "."`, so `.` would be consistent with that.

     

       105
       105
       +
       - (-) `dirOf "foo" == "."`, so `.` would be consistent with that.

     

       106
       106
        
       - (+) `./.` is consistent with the [decision to have leading `./`][leading-dots].

     

       107
       107
        
       - (+) `./.` is a valid Nix path expression, although this property does not hold for every relative path or subpath.

     

       108
       108

+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 = {

+2 -2

lib/tests/misc.nix

···

       4487
       4487
        
         testPackagesFromDirectoryRecursiveStringDirectory = {

     

       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;

     

       4490
       4490
       +
             # Do NOT remove the `toString` call here!!!

     

       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