commit 7c8a4efb688b4bf3e8dbf71a43e8b963d8fe3bca · pyrox.dev/nixpkgs

+2

lib/default.nix

···

       433
       433
        
               pathHasContext

     

       434
       434
        
               canCleanSource

     

       435
       435
        
               pathIsGitRepo

     

       436
       436
       +
               revOrTag

     

       437
       437
       +
               repoRevToName

     

       436
       438
        
               ;

     

       437
       439
        
             inherit (self.modules)

     

       438
       440
        
               evalModules

+101 -1

lib/sources.nix

···

       3
       3
        
       

     

       4
       4
        
       # Tested in lib/tests/sources.sh

     

       5
       5
        
       let

     

       6
       6
       -
         inherit (builtins)

     

       6
       6
       +
         inherit (lib.strings)

     

       7
       7
        
           match

     

       8
       8
        
           split

     

       9
       9
        
           storeDir

     
···

       403
       403
        
             };

     

       404
       404
        
           };

     

       405
       405
        
       

     

       406
       406
       +
         # urlToName : (URL | Path | String) -> String

     

       407
       407
       +
         #

     

       408
       408
       +
         # Transform a URL (or path, or string) into a clean package name.

     

       409
       409
       +
         urlToName =

     

       410
       410
       +
           url:

     

       411
       411
       +
           let

     

       412
       412
       +
             inherit (lib.strings) stringLength;

     

       413
       413
       +
             base = baseNameOf (lib.removeSuffix "/" (lib.last (lib.splitString ":" (toString url))));

     

       414
       414
       +
             # chop away one git or archive-related extension

     

       415
       415
       +
             removeExt =

     

       416
       416
       +
               name:

     

       417
       417
       +
               let

     

       418
       418
       +
                 matchExt = match "(.*)\\.(git|tar|zip|gz|tgz|bz|tbz|bz2|tbz2|lzma|txz|xz|zstd)$" name;

     

       419
       419
       +
               in

     

       420
       420
       +
               if matchExt != null then lib.head matchExt else name;

     

       421
       421
       +
             # apply function f to string x while the result shrinks

     

       422
       422
       +
             shrink =

     

       423
       423
       +
               f: x:

     

       424
       424
       +
               let

     

       425
       425
       +
                 v = f x;

     

       426
       426
       +
               in

     

       427
       427
       +
               if stringLength v < stringLength x then shrink f v else x;

     

       428
       428
       +
           in

     

       429
       429
       +
           shrink removeExt base;

     

       430
       430
       +
       

     

       431
       431
       +
         # shortRev : (String | Integer) -> String

     

       432
       432
       +
         #

     

       433
       433
       +
         # Given a package revision (like "refs/tags/v12.0"), produce a short revision ("12.0").

     

       434
       434
       +
         shortRev =

     

       435
       435
       +
           rev:

     

       436
       436
       +
           let

     

       437
       437
       +
             baseRev = baseNameOf (toString rev);

     

       438
       438
       +
             matchHash = match "[a-f0-9]+" baseRev;

     

       439
       439
       +
             matchVer = match "([A-Za-z]+[-_. ]?)*(v)?([0-9.]+.*)" baseRev;

     

       440
       440
       +
           in

     

       441
       441
       +
           if matchHash != null then

     

       442
       442
       +
             builtins.substring 0 7 baseRev

     

       443
       443
       +
           else if matchVer != null then

     

       444
       444
       +
             lib.last matchVer

     

       445
       445
       +
           else

     

       446
       446
       +
             baseRev;

     

       447
       447
       +
       

     

       448
       448
       +
         # revOrTag : String -> String -> String

     

       449
       449
       +
         #

     

       450
       450
       +
         # Turn git `rev` and `tag` pair into a revision usable in `repoRevToName*`.

     

       451
       451
       +
         revOrTag =

     

       452
       452
       +
           rev: tag:

     

       453
       453
       +
           if tag != null then

     

       454
       454
       +
             tag

     

       455
       455
       +
           else if rev != null then

     

       456
       456
       +
             rev

     

       457
       457
       +
           else

     

       458
       458
       +
             "HEAD";

     

       459
       459
       +
       

     

       460
       460
       +
         # repoRevToNameFull : (URL | Path | String) -> (String | Integer | null) -> (String | null) -> String

     

       461
       461
       +
         #

     

       462
       462
       +
         # See `repoRevToName` below.

     

       463
       463
       +
         repoRevToNameFull =

     

       464
       464
       +
           repo_: rev_: suffix_:

     

       465
       465
       +
           let

     

       466
       466
       +
             repo = urlToName repo_;

     

       467
       467
       +
             rev = if rev_ != null then "-${shortRev rev_}" else "";

     

       468
       468
       +
             suffix = if suffix_ != null then "-${suffix_}" else "";

     

       469
       469
       +
           in

     

       470
       470
       +
           "${repo}${rev}${suffix}-source";

     

       471
       471
       +
       

     

       472
       472
       +
         # repoRevToName : String -> (URL | Path | String) -> (String | Integer | null) -> String -> String

     

       473
       473
       +
         #

     

       474
       474
       +
         # Produce derivation.name attribute for a given repository URL/path/name and (optionally) its revision/version tag.

     

       475
       475
       +
         #

     

       476
       476
       +
         # This is used by fetch(zip|git|FromGitHub|hg|svn|etc) to generate discoverable

     

       477
       477
       +
         # /nix/store paths.

     

       478
       478
       +
         #

     

       479
       479
       +
         # This uses a different implementation depending on the `pretty` argument:

     

       480
       480
       +
         #  "source" -> name everything as "source"

     

       481
       481
       +
         #  "versioned" -> name everything as "${repo}-${rev}-source"

     

       482
       482
       +
         #  "full" -> name everything as "${repo}-${rev}-${fetcher}-source"

     

       483
       483
       +
         repoRevToName =

     

       484
       484
       +
           kind:

     

       485
       485
       +
           # match on `kind` first to minimize the thunk

     

       486
       486
       +
           if kind == "source" then

     

       487
       487
       +
             (

     

       488
       488
       +
               repo: rev: suffix:

     

       489
       489
       +
               "source"

     

       490
       490
       +
             )

     

       491
       491
       +
           else if kind == "versioned" then

     

       492
       492
       +
             (

     

       493
       493
       +
               repo: rev: suffix:

     

       494
       494
       +
               repoRevToNameFull repo rev null

     

       495
       495
       +
             )

     

       496
       496
       +
           else if kind == "full" then

     

       497
       497
       +
             repoRevToNameFull

     

       498
       498
       +
           else

     

       499
       499
       +
             throw "repoRevToName: invalid kind";

     

       500
       500
       +
       

     

       406
       501
        
       in

     

       407
       502
        
       {

     

       408
       503
        
       

     
···

       430
       525
        
           cleanSourceFilter

     

       431
       526
        
           pathHasContext

     

       432
       527
        
           canCleanSource

     

       528
       528
       +
       

     

       529
       529
       +
           urlToName

     

       530
       530
       +
           shortRev

     

       531
       531
       +
           revOrTag

     

       532
       532
       +
           repoRevToName

     

       433
       533
        
       

     

       434
       534
        
           sourceByRegex

     

       435
       535
        
           sourceFilesBySuffices

+6 -2

pkgs/build-support/fetchbitbucket/default.nix

···

       1
       1
       -
       { fetchzip, lib }:

     

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         repoRevToNameMaybe,

     

       4
       4
       +
         fetchzip,

     

       5
       5
       +
       }:

     

       2
       6
        
       

     

       3
       7
        
       lib.makeOverridable (

     

       4
       8
        
         {

     

       5
       9
        
           owner,

     

       6
       10
        
           repo,

     

       7
       11
        
           rev,

     

       8
       8
       -
           name ? "source",

     

       12
       12
       +
           name ? repoRevToNameMaybe repo rev "bitbucket",

     

       9
       13
        
           ... # For hash agility

     

       10
       14
        
         }@args:

     

       11
       15
        
         fetchzip (

+8 -12

pkgs/build-support/fetchgit/default.nix

···

       5
       5
        
         git-lfs,

     

       6
       6
        
         cacert,

     

       7
       7
        
       }:

     

       8
       8
       +
       

     

       8
       9
        
       let

     

       9
       10
        
         urlToName =

     

       10
       11
        
           url: rev:

     

       11
       12
        
           let

     

       12
       12
       -
             inherit (lib) removeSuffix splitString last;

     

       13
       13
       -
             base = last (splitString ":" (baseNameOf (removeSuffix "/" url)));

     

       14
       14
       -
       

     

       15
       15
       -
             matched = builtins.match "(.*)\\.git" base;

     

       16
       16
       -
       

     

       17
       17
       -
             short = builtins.substring 0 7 rev;

     

       18
       18
       -
       

     

       19
       19
       -
             appendShort = lib.optionalString ((builtins.match "[a-f0-9]*" rev) != null) "-${short}";

     

       13
       13
       +
             shortRev = lib.sources.shortRev rev;

     

       14
       14
       +
             appendShort = lib.optionalString ((builtins.match "[a-f0-9]*" rev) != null) "-${shortRev}";

     

       20
       15
        
           in

     

       21
       21
       -
           "${if matched == null then base else builtins.head matched}${appendShort}";

     

       16
       16
       +
           "${lib.sources.urlToName url}${appendShort}";

     

       22
       17
        
       in

     

       18
       18
       +
       

     

       23
       19
        
       lib.makeOverridable (

     

       24
       20
        
         lib.fetchers.withNormalizedHash { } (

     

       25
       21
        
           # NOTE Please document parameter additions or changes in

     

       26
       26
       -
           #   doc/build-helpers/fetchers.chapter.md

     

       22
       22
       +
           #   ../../../doc/build-helpers/fetchers.chapter.md

     

       27
       23
        
           {

     

       28
       24
        
             url,

     

       29
       25
        
             tag ? null,

     

       30
       26
        
             rev ? null,

     

       27
       27
       +
             name ? urlToName url (lib.revOrTag rev tag),

     

       31
       28
        
             leaveDotGit ? deepClone || fetchTags,

     

       32
       29
        
             outputHash ? lib.fakeHash,

     

       33
       30
        
             outputHashAlgo ? null,

     
···

       36
       33
        
             branchName ? null,

     

       37
       34
        
             sparseCheckout ? [ ],

     

       38
       35
        
             nonConeMode ? false,

     

       39
       39
       -
             name ? null,

     

       40
       36
        
             nativeBuildInputs ? [ ],

     

       41
       37
        
             # Shell code executed before the file has been fetched.  This, in

     

       42
       38
        
             # particular, can do things like set NIX_PREFETCH_GIT_CHECKOUT_HOOK to

     
···

       108
       104
        
               "Please provide directories/patterns for sparse checkout as a list of strings. Passing a (multi-line) string is not supported any more."

     

       109
       105
        
           else

     

       110
       106
        
             stdenvNoCC.mkDerivation {

     

       111
       111
       -
               name = if name != null then name else urlToName url revWithTag;

     

       107
       107
       +
               inherit name;

     

       112
       108
        
       

     

       113
       109
        
               builder = ./builder.sh;

     

       114
       110
        
               fetcher = ./nix-prefetch-git;

+2 -1

pkgs/build-support/fetchgithub/default.nix

···

       1
       1
        
       {

     

       2
       2
        
         lib,

     

       3
       3
       +
         repoRevToNameMaybe,

     

       3
       4
        
         fetchgit,

     

       4
       5
        
         fetchzip,

     

       5
       6
        
       }:

     
···

       10
       11
        
           repo,

     

       11
       12
        
           tag ? null,

     

       12
       13
        
           rev ? null,

     

       13
       13
       -
           name ? "source",

     

       14
       14
       +
           name ? repoRevToNameMaybe repo (lib.revOrTag rev tag) "github",

     

       14
       15
        
           fetchSubmodules ? false,

     

       15
       16
        
           leaveDotGit ? null,

     

       16
       17
        
           deepClone ? false,

+6 -2

pkgs/build-support/fetchgitiles/default.nix

···

       1
       1
       -
       { fetchzip, lib }:

     

       1
       1
       +
       {

     

       2
       2
       +
         fetchzip,

     

       3
       3
       +
         repoRevToNameMaybe,

     

       4
       4
       +
         lib,

     

       5
       5
       +
       }:

     

       2
       6
        
       

     

       3
       7
        
       lib.makeOverridable (

     

       4
       8
        
         {

     

       5
       9
        
           url,

     

       6
       10
        
           rev ? null,

     

       7
       11
        
           tag ? null,

     

       8
       8
       -
           name ? "source",

     

       12
       12
       +
           name ? repoRevToNameMaybe url (lib.revOrTag rev tag) "gitiles",

     

       9
       13
        
           ...

     

       10
       14
        
         }@args:

     

       11
       15

+2 -1

pkgs/build-support/fetchgitlab/default.nix

···

       1
       1
        
       {

     

       2
       2
        
         lib,

     

       3
       3
       +
         repoRevToNameMaybe,

     

       3
       4
        
         fetchgit,

     

       4
       5
        
         fetchzip,

     

       5
       6
        
       }:

     
···

       11
       12
        
           repo,

     

       12
       13
        
           rev ? null,

     

       13
       14
        
           tag ? null,

     

       15
       15
       +
           name ? repoRevToNameMaybe repo (lib.revOrTag rev tag) "gitlab",

     

       14
       16
        
           protocol ? "https",

     

       15
       17
        
           domain ? "gitlab.com",

     

       16
       16
       -
           name ? "source",

     

       17
       18
        
           group ? null,

     

       18
       19
        
           fetchSubmodules ? false,

     

       19
       20
        
           leaveDotGit ? false,

+6 -2

pkgs/build-support/fetchrepoorcz/default.nix

···

       1
       1
       -
       { fetchzip }:

     

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         repoRevToNameMaybe,

     

       4
       4
       +
         fetchzip,

     

       5
       5
       +
       }:

     

       2
       6
        
       

     

       3
       7
        
       # gitweb example, snapshot support is optional in gitweb

     

       4
       8
        
       {

     

       5
       9
        
         repo,

     

       6
       10
        
         rev,

     

       7
       7
       -
         name ? "source",

     

       11
       11
       +
         name ? repoRevToNameMaybe repo rev "repoorcz",

     

       8
       12
        
         ... # For hash agility

     

       9
       13
        
       }@args:

     

       10
       14
        
       fetchzip (

+6 -2

pkgs/build-support/fetchsavannah/default.nix

···

       1
       1
       -
       { fetchzip, lib }:

     

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         repoRevToNameMaybe,

     

       4
       4
       +
         fetchzip,

     

       5
       5
       +
       }:

     

       2
       6
        
       

     

       3
       7
        
       lib.makeOverridable (

     

       4
       8
        
         # cgit example, snapshot support is optional in cgit

     

       5
       9
        
         {

     

       6
       10
        
           repo,

     

       7
       11
        
           rev,

     

       8
       8
       -
           name ? "source",

     

       12
       12
       +
           name ? repoRevToNameMaybe repo rev "savannah",

     

       9
       13
        
           ... # For hash agility

     

       10
       14
        
         }@args:

     

       11
       15
        
         fetchzip (

+3 -2

pkgs/build-support/fetchsourcehut/default.nix

···

       1
       1
        
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         repoRevToNameMaybe,

     

       2
       4
        
         fetchgit,

     

       3
       5
        
         fetchhg,

     

       4
       6
        
         fetchzip,

     

       5
       5
       -
         lib,

     

       6
       7
        
       }:

     

       7
       8
        
       

     

       8
       9
        
       let

     
···

       18
       19
        
           owner,

     

       19
       20
        
           repo,

     

       20
       21
        
           rev,

     

       22
       22
       +
           name ? repoRevToNameMaybe repo rev "sourcehut",

     

       21
       23
        
           domain ? "sr.ht",

     

       22
       24
        
           vc ? "git",

     

       23
       23
       -
           name ? "source",

     

       24
       25
        
           fetchSubmodules ? false,

     

       25
       26
        
           ... # For hash agility

     

       26
       27
        
         }@args:

+2 -1

pkgs/build-support/fetchzip/default.nix

···

       7
       7
        
       

     

       8
       8
        
       {

     

       9
       9
        
         lib,

     

       10
       10
       +
         repoRevToNameMaybe,

     

       10
       11
        
         fetchurl,

     

       11
       12
        
         withUnzip ? true,

     

       12
       13
        
         unzip,

     
···

       14
       15
        
       }:

     

       15
       16
        
       

     

       16
       17
        
       {

     

       17
       17
       -
         name ? "source",

     

       18
       18
        
         url ? "",

     

       19
       19
        
         urls ? [ ],

     

       20
       20
       +
         name ? repoRevToNameMaybe (if url != "" then url else builtins.head urls) null "unpacked",

     

       20
       21
        
         nativeBuildInputs ? [ ],

     

       21
       22
        
         postFetch ? "",

     

       22
       23
        
         extraPostFetch ? "",

+3

pkgs/top-level/all-packages.nix

···

       574
       574
        
           stdenv = if stdenv.hostPlatform.isDarwin then llvmPackages_18.stdenv else stdenv;

     

       575
       575
        
         };

     

       576
       576
        
       

     

       577
       577
       +
         # this is used by most `fetch*` functions

     

       578
       578
       +
         repoRevToNameMaybe = lib.repoRevToName config.fetchedSourceNameDefault;

     

       579
       579
       +
       

     

       577
       580
        
         fetchpatch =

     

       578
       581
        
           callPackage ../build-support/fetchpatch {

     

       579
       582
        
             # 0.3.4 would change hashes: https://github.com/NixOS/nixpkgs/issues/25154

+46

pkgs/top-level/config.nix

···

       59
       59
        
             default = false;

     

       60
       60
        
           };

     

       61
       61
        
       

     

       62
       62
       +
           fetchedSourceNameDefault = mkOption {

     

       63
       63
       +
             type = types.uniq (

     

       64
       64
       +
               types.enum [

     

       65
       65
       +
                 "source"

     

       66
       66
       +
                 "versioned"

     

       67
       67
       +
                 "full"

     

       68
       68
       +
               ]

     

       69
       69
       +
             );

     

       70
       70
       +
             default = "source";

     

       71
       71
       +
             description = ''

     

       72
       72
       +
               This controls the default derivation `name` attribute set by the

     

       73
       73
       +
               `fetch*` (`fetchzip`, `fetchFromGitHub`, etc) functions.

     

       74
       74
       +
       

     

       75
       75
       +
               Possible values and the resulting `.name`:

     

       76
       76
       +
       

     

       77
       77
       +
               - `"source"` -> `"source"`

     

       78
       78
       +
               - `"versioned"` -> `"''${repo}-''${rev}-source"`

     

       79
       79
       +
               - `"full"` -> `"''${repo}-''${rev}-''${fetcherName}-source"`

     

       80
       80
       +
       

     

       81
       81
       +
               The default `"source"` is the best choice for minimal rebuilds, it

     

       82
       82
       +
               will ignore any non-hash changes (like branches being renamed, source

     

       83
       83
       +
               URLs changing, etc) at the cost of `/nix/store` being easily

     

       84
       84
       +
               cache-poisoned (see [NixOS/nix#969](https://github.com/NixOS/nix/issues/969)).

     

       85
       85
       +
       

     

       86
       86
       +
               Setting this to `"versioned"` greatly helps with discoverability of

     

       87
       87
       +
               sources in `/nix/store` and makes cache-poisoning of `/nix/store` much

     

       88
       88
       +
               harder, at the cost of a single mass-rebuild for all `src`

     

       89
       89
       +
               derivations, and an occasional rebuild when a source changes some of

     

       90
       90
       +
               its non-hash attributes.

     

       91
       91
       +
       

     

       92
       92
       +
               Setting this to `"full"` is similar to setting it to `"versioned"`,

     

       93
       93
       +
               but the use of `fetcherName` in the derivation name will force a

     

       94
       94
       +
               rebuild when `src` switches between `fetch*` functions, thus forcing

     

       95
       95
       +
               `nix` to check new derivation's `outputHash`, which is useful for

     

       96
       96
       +
               debugging.

     

       97
       97
       +
       

     

       98
       98
       +
               Also, `"full"` is useful for easy collection and tracking of

     

       99
       99
       +
               statistics of where the packages you use are hosted.

     

       100
       100
       +
       

     

       101
       101
       +
               If you are a developer, you should probably set this to at

     

       102
       102
       +
               least`"versioned"`.

     

       103
       103
       +
       

     

       104
       104
       +
               Changing the default will cause a mass rebuild.

     

       105
       105
       +
             '';

     

       106
       106
       +
           };

     

       107
       107
       +
       

     

       62
       108
        
           doCheckByDefault = mkMassRebuild {

     

       63
       109
        
             feature = "run `checkPhase` by default";

     

       64
       110
        
           };