commit c0491d5fd2561bd367e27c137beded4b51bd1678 · pyrox.dev/nixpkgs

+17 -17

doc/builders/fetchers.chapter.md

···

       14
       14
        
       ```nix

     

       15
       15
        
       fetchurl {

     

       16
       16
        
         url = "http://www.example.org/hello-1.0.tar.gz";

     

       17
       17
       -
         sha256 = "0v6r3wwnsk5pdjr188nip3pjgn1jrn5pc5ajpcfy6had6b3v4dwm";

     

       17
       17
       +
         hash = "sha256-lTeyxzJNQeMdu1IVdovNMtgn77jRIhSybLdMbTkf2Ww=";

     

       18
       18
        
       };

     

       19
       19
        
       ```

     

       20
       20
        
       

     
···

       23
       23
        
       ```nix

     

       24
       24
        
       fetchurl {

     

       25
       25
        
         url = "http://www.example.org/hello-1.1.tar.gz";

     

       26
       26
       -
         sha256 = "0v6r3wwnsk5pdjr188nip3pjgn1jrn5pc5ajpcfy6had6b3v4dwm";

     

       26
       26
       +
         hash = "sha256-lTeyxzJNQeMdu1IVdovNMtgn77jRIhSybLdMbTkf2Ww=";

     

       27
       27
        
       };

     

       28
       28
        
       ```

     

       29
       29
        
       

     

       30
       30
        
       **This will reuse the old contents**.

     

       31
       31
       -
       Remember to invalidate the hash argument, in this case by setting the `sha256` attribute to an empty string.

     

       31
       31
       +
       Remember to invalidate the hash argument, in this case by setting the `hash` attribute to an empty string.

     

       32
       32
        
       

     

       33
       33
        
       ```nix

     

       34
       34
        
       fetchurl {

     

       35
       35
        
         url = "http://www.example.org/hello-1.1.tar.gz";

     

       36
       36
       -
         sha256 = "";

     

       36
       36
       +
         hash = "";

     

       37
       37
        
       };

     

       38
       38
        
       ```

     

       39
       39
        
       

     
···

       42
       42
        
       ```

     

       43
       43
        
       error: hash mismatch in fixed-output derivation '/path/to/my.drv':

     

       44
       44
        
                specified: sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=

     

       45
       45
       -
                   got:    sha256-RApQUm78dswhBLC/rfU9y0u6pSAzHceIJqgmetRD24E=

     

       45
       45
       +
                   got:    sha256-lTeyxzJNQeMdu1IVdovNMtgn77jRIhSybLdMbTkf2Ww=

     

       46
       46
        
       ```

     

       47
       47
        
       

     

       48
       48
        
       A similar problem arises while testing changes to a fetcher's implementation. If the output of the derivation already exists in the Nix store, test failures can go undetected. The [`invalidateFetcherByDrvHash`](#tester-invalidateFetcherByDrvHash) function helps prevent reusing cached derivations.

     

       49
       49
        
       

     

       50
       50
        
       ## `fetchurl` and `fetchzip` {#fetchurl}

     

       51
       51
        
       

     

       52
       52
       -
       Two basic fetchers are `fetchurl` and `fetchzip`. Both of these have two required arguments, a URL and a hash. The hash is typically `sha256`, although many more hash algorithms are supported. Nixpkgs contributors are currently recommended to use `sha256`. This hash will be used by Nix to identify your source. A typical usage of `fetchurl` is provided below.

     

       52
       52
       +
       Two basic fetchers are `fetchurl` and `fetchzip`. Both of these have two required arguments, a URL and a hash. The hash is typically `hash`, although many more hash algorithms are supported. Nixpkgs contributors are currently recommended to use `hash`. This hash will be used by Nix to identify your source. A typical usage of `fetchurl` is provided below.

     

       53
       53
        
       

     

       54
       54
        
       ```nix

     

       55
       55
        
       { stdenv, fetchurl }:

     
···

       58
       58
        
         name = "hello";

     

       59
       59
        
         src = fetchurl {

     

       60
       60
        
           url = "http://www.example.org/hello.tar.gz";

     

       61
       61
       -
           sha256 = "1111111111111111111111111111111111111111111111111111";

     

       61
       61
       +
           hash = "sha256-BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB=";

     

       62
       62
        
         };

     

       63
       63
        
       }

     

       64
       64
        
       ```

     
···

       76
       76
        
       - `includes`: Include only files matching these patterns (applies after the above arguments).

     

       77
       77
        
       - `revert`: Revert the patch.

     

       78
       78
        
       

     

       79
       79
       -
       Note that because the checksum is computed after applying these effects, using or modifying these arguments will have no effect unless the `sha256` argument is changed as well.

     

       79
       79
       +
       Note that because the checksum is computed after applying these effects, using or modifying these arguments will have no effect unless the `hash` argument is changed as well.

     

       80
       80
        
       

     

       81
       81
        
       

     

       82
       82
        
       Most other fetchers return a directory rather than a single file.

     

       83
       83
        
       

     

       84
       84
        
       ## `fetchsvn` {#fetchsvn}

     

       85
       85
        
       

     

       86
       86
       -
       Used with Subversion. Expects `url` to a Subversion directory, `rev`, and `sha256`.

     

       86
       86
       +
       Used with Subversion. Expects `url` to a Subversion directory, `rev`, and `hash`.

     

       87
       87
        
       

     

       88
       88
        
       ## `fetchgit` {#fetchgit}

     

       89
       89
        
       

     

       90
       90
       -
       Used with Git. Expects `url` to a Git repo, `rev`, and `sha256`. `rev` in this case can be full the git commit id (SHA1 hash) or a tag name like `refs/tags/v1.0`.

     

       90
       90
       +
       Used with Git. Expects `url` to a Git repo, `rev`, and `hash`. `rev` in this case can be full the git commit id (SHA1 hash) or a tag name like `refs/tags/v1.0`.

     

       91
       91
        
       

     

       92
       92
        
       Additionally, the following optional arguments can be given: `fetchSubmodules = true` makes `fetchgit` also fetch the submodules of a repository. If `deepClone` is set to true, the entire repository is cloned as opposing to just creating a shallow clone. `deepClone = true` also implies `leaveDotGit = true` which means that the `.git` directory of the clone won't be removed after checkout.

     

       93
       93
        
       

     
···

       104
       104
        
             "directory/to/be/included"

     

       105
       105
        
             "another/directory"

     

       106
       106
        
           ];

     

       107
       107
       -
           sha256 = "0000000000000000000000000000000000000000000000000000";

     

       107
       107
       +
           hash = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";

     

       108
       108
        
         };

     

       109
       109
        
       }

     

       110
       110
        
       ```

     

       111
       111
        
       

     

       112
       112
        
       ## `fetchfossil` {#fetchfossil}

     

       113
       113
        
       

     

       114
       114
       -
       Used with Fossil. Expects `url` to a Fossil archive, `rev`, and `sha256`.

     

       114
       114
       +
       Used with Fossil. Expects `url` to a Fossil archive, `rev`, and `hash`.

     

       115
       115
        
       

     

       116
       116
        
       ## `fetchcvs` {#fetchcvs}

     

       117
       117
        
       

     

       118
       118
       -
       Used with CVS. Expects `cvsRoot`, `tag`, and `sha256`.

     

       118
       118
       +
       Used with CVS. Expects `cvsRoot`, `tag`, and `hash`.

     

       119
       119
        
       

     

       120
       120
        
       ## `fetchhg` {#fetchhg}

     

       121
       121
        
       

     

       122
       122
       -
       Used with Mercurial. Expects `url`, `rev`, and `sha256`.

     

       122
       122
       +
       Used with Mercurial. Expects `url`, `rev`, and `hash`.

     

       123
       123
        
       

     

       124
       124
        
       A number of fetcher functions wrap part of `fetchurl` and `fetchzip`. They are mainly convenience functions intended for commonly used destinations of source code in Nixpkgs. These wrapper fetchers are listed below.

     

       125
       125
        
       

     

       126
       126
        
       ## `fetchFromGitea` {#fetchfromgitea}

     

       127
       127
        
       

     

       128
       128
       -
       `fetchFromGitea` expects five arguments. `domain` is the gitea server name. `owner` is a string corresponding to the Gitea user or organization that controls this repository. `repo` corresponds to the name of the software repository. These are located at the top of every Gitea HTML page as `owner`/`repo`. `rev` corresponds to the Git commit hash or tag (e.g `v1.0`) that will be downloaded from Git. Finally, `sha256` corresponds to the hash of the extracted directory. Again, other hash algorithms are also available but `sha256` is currently preferred.

     

       128
       128
       +
       `fetchFromGitea` expects five arguments. `domain` is the gitea server name. `owner` is a string corresponding to the Gitea user or organization that controls this repository. `repo` corresponds to the name of the software repository. These are located at the top of every Gitea HTML page as `owner`/`repo`. `rev` corresponds to the Git commit hash or tag (e.g `v1.0`) that will be downloaded from Git. Finally, `hash` corresponds to the hash of the extracted directory. Again, other hash algorithms are also available but `hash` is currently preferred.

     

       129
       129
        
       

     

       130
       130
        
       ## `fetchFromGitHub` {#fetchfromgithub}

     

       131
       131
        
       

     

       132
       132
       -
       `fetchFromGitHub` expects four arguments. `owner` is a string corresponding to the GitHub user or organization that controls this repository. `repo` corresponds to the name of the software repository. These are located at the top of every GitHub HTML page as `owner`/`repo`. `rev` corresponds to the Git commit hash or tag (e.g `v1.0`) that will be downloaded from Git. Finally, `sha256` corresponds to the hash of the extracted directory. Again, other hash algorithms are also available, but `sha256` is currently preferred.

     

       132
       132
       +
       `fetchFromGitHub` expects four arguments. `owner` is a string corresponding to the GitHub user or organization that controls this repository. `repo` corresponds to the name of the software repository. These are located at the top of every GitHub HTML page as `owner`/`repo`. `rev` corresponds to the Git commit hash or tag (e.g `v1.0`) that will be downloaded from Git. Finally, `hash` corresponds to the hash of the extracted directory. Again, other hash algorithms are also available, but `hash` is currently preferred.

     

       133
       133
        
       

     

       134
       134
        
       `fetchFromGitHub` uses `fetchzip` to download the source archive generated by GitHub for the specified revision. If `leaveDotGit`, `deepClone` or `fetchSubmodules` are set to `true`, `fetchFromGitHub` will use `fetchgit` instead. Refer to its section for documentation of these options.

     

       135
       135
        
       

     
···

       156
       156
        
       ## `fetchFromSourcehut` {#fetchfromsourcehut}

     

       157
       157
        
       

     

       158
       158
        
       This is used with sourcehut repositories. Similar to `fetchFromGitHub` above,

     

       159
       159
       -
       it expects `owner`, `repo`, `rev` and `sha256`, but don't forget the tilde (~)

     

       159
       159
       +
       it expects `owner`, `repo`, `rev` and `hash`, but don't forget the tilde (~)

     

       160
       160
        
       in front of the username! Expected arguments also include `vc` ("git" (default)

     

       161
       161
        
       or "hg"), `domain` and `fetchSubmodules`.

     

       162
       162

+1 -1

doc/builders/images/appimagetools.section.md

···

       35
       35
        
         name = "patchwork";

     

       36
       36
        
         src = fetchurl {

     

       37
       37
        
           url = "https://github.com/ssbc/patchwork/releases/download/v3.11.4/Patchwork-3.11.4-linux-x86_64.AppImage";

     

       38
       38
       -
           sha256 = "1blsprpkvm0ws9b96gb36f0rbf8f5jgmw4x6dsb1kswr4ysf591s";

     

       38
       38
       +
           hash = "sha256-OqTitCeZ6xmWbqYTXp8sDrmVgTNjPZNW0hzUPW++mq4=";

     

       39
       39
        
         };

     

       40
       40
        
         extraPkgs = pkgs: with pkgs; [ ];

     

       41
       41
        
       }

+3 -3

doc/builders/images/dockertools.section.md

···

       245
       245
        
       pullImage {

     

       246
       246
        
         imageName = "nixos/nix";

     

       247
       247
        
         imageDigest =

     

       248
       248
       -
           "sha256:20d9485b25ecfd89204e843a962c1bd70e9cc6858d65d7f5fadc340246e2116b";

     

       248
       248
       +
           "sha256:473a2b527958665554806aea24d0131bacec46d23af09fef4598eeab331850fa";

     

       249
       249
        
         finalImageName = "nix";

     

       250
       250
       -
         finalImageTag = "1.11";

     

       251
       251
       -
         sha256 = "0mqjy3zq2v6rrhizgb9nvhczl87lcfphq9601wcprdika2jz7qh8";

     

       250
       250
       +
         finalImageTag = "2.11.1";

     

       251
       251
       +
         sha256 = "sha256-qvhj+Hlmviz+KEBVmsyPIzTB3QlVAFzwAY1zDPIBGxc=";

     

       252
       252
        
         os = "linux";

     

       253
       253
        
         arch = "x86_64";

     

       254
       254
        
       }

+1 -1

doc/builders/packages/cataclysm-dda.section.md

···

       103
       103
        
               owner = "Someone";

     

       104
       104
        
               repo = "AwesomeMod";

     

       105
       105
        
               rev = "...";

     

       106
       106
       -
               sha256 = "...";

     

       106
       106
       +
               hash = "...";

     

       107
       107
        
             };

     

       108
       108
        
             # Path to be installed in the unpacked source (default: ".")

     

       109
       109
        
             modRoot = "contents/under/this/path/will/be/installed";

+3 -3

doc/builders/packages/eclipse.section.md

···

       43
       43
        
               name = "myplugin1-1.0";

     

       44
       44
        
               srcFeature = fetchurl {

     

       45
       45
        
                 url = "http://…/features/myplugin1.jar";

     

       46
       46
       -
                 sha256 = "123…";

     

       46
       46
       +
                 hash = "sha256-123…";

     

       47
       47
        
               };

     

       48
       48
        
               srcPlugin = fetchurl {

     

       49
       49
        
                 url = "http://…/plugins/myplugin1.jar";

     

       50
       50
       -
                 sha256 = "123…";

     

       50
       50
       +
                 hash = "sha256-123…";

     

       51
       51
        
               };

     

       52
       52
        
             });

     

       53
       53
        
             (plugins.buildEclipseUpdateSite {

     
···

       55
       55
        
               src = fetchurl {

     

       56
       56
        
                 stripRoot = false;

     

       57
       57
        
                 url = "http://…/myplugin2.zip";

     

       58
       58
       -
                 sha256 = "123…";

     

       58
       58
       +
                 hash = "sha256-123…";

     

       59
       59
        
               };

     

       60
       60
        
             });

     

       61
       61
        
           ];

+1 -1

doc/builders/packages/firefox.section.md

···

       12
       12
        
             (fetchFirefoxAddon {

     

       13
       13
        
               name = "ublock"; # Has to be unique!

     

       14
       14
        
               url = "https://addons.mozilla.org/firefox/downloads/file/3679754/ublock_origin-1.31.0-an+fx.xpi";

     

       15
       15
       -
               sha256 = "1h768ljlh3pi23l27qp961v1hd0nbj2vasgy11bmcrlqp40zgvnr";

     

       15
       15
       +
               hash = "sha256-2e73AbmYZlZXCP5ptYVcFjQYdjDp4iPoEPEOSCVF5sA=";

     

       16
       16
        
             })

     

       17
       17
        
           ];

     

       18
       18

+1 -1

doc/builders/packages/weechat.section.md

···

       73
       73
        
         name = "exemplary-weechat-script";

     

       74
       74
        
         src = fetchurl {

     

       75
       75
        
           url = "https://scripts.tld/your-scripts.tar.gz";

     

       76
       76
       -
           sha256 = "...";

     

       76
       76
       +
           hash = "...";

     

       77
       77
        
         };

     

       78
       78
        
         passthru.scripts = [ "foo.py" "bar.lua" ];

     

       79
       79
        
         installPhase = ''

+1 -1

doc/builders/testers.chapter.md

···

       147
       147
        
         name = "nix-source";

     

       148
       148
        
         url = "https://github.com/NixOS/nix";

     

       149
       149
        
         rev = "9d9dbe6ed05854e03811c361a3380e09183f4f4a";

     

       150
       150
       -
         sha256 = "sha256-7DszvbCNTjpzGRmpIVAWXk20P0/XTrWZ79KSOGLrUWY=";

     

       150
       150
       +
         hash = "sha256-7DszvbCNTjpzGRmpIVAWXk20P0/XTrWZ79KSOGLrUWY=";

     

       151
       151
        
       };

     

       152
       152
        
       ```

     

       153
       153

+6 -5

doc/contributing/coding-conventions.chapter.md

···

       426
       426
        
       

     

       427
       427
        
         ```nix

     

       428
       428
        
         src = fetchgit {

     

       429
       429
       +
           url = "git@github.com:NixOS/nix.git"

     

       429
       430
        
           url = "git://github.com/NixOS/nix.git";

     

       430
       431
        
           rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";

     

       431
       431
       -
           sha256 = "1cw5fszffl5pkpa6s6wjnkiv6lm5k618s32sp60kvmvpy7a2v9kg";

     

       432
       432
       +
           hash = "sha256-7D4m+saJjbSFP5hOwpQq2FGR2rr+psQMTcyb1ZvtXsQ=";

     

       432
       433
        
         }

     

       433
       434
        
         ```

     

       434
       435
        
       

     
···

       438
       439
        
         src = fetchgit {

     

       439
       440
        
           url = "https://github.com/NixOS/nix.git";

     

       440
       441
        
           rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";

     

       441
       441
       -
           sha256 = "1cw5fszffl5pkpa6s6wjnkiv6lm5k618s32sp60kvmvpy7a2v9kg";

     

       442
       442
       +
           hash = "sha256-7D4m+saJjbSFP5hOwpQq2FGR2rr+psQMTcyb1ZvtXsQ=";

     

       442
       443
        
         }

     

       443
       444
        
         ```

     

       444
       445
        
       

     
···

       449
       450
        
           owner = "NixOS";

     

       450
       451
        
           repo = "nix";

     

       451
       452
        
           rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";

     

       452
       452
       -
           sha256 = "1i2yxndxb6yc9l6c99pypbd92lfq5aac4klq7y2v93c9qvx2cgpc";

     

       453
       453
       +
           hash = "ha256-7D4m+saJjbSFP5hOwpQq2FGR2rr+psQMTcyb1ZvtXsQ=;

     

       453
       454
        
         }

     

       454
       455
        
         ```

     

       455
       456
        
       

     

       456
       457
        
       When fetching from GitHub, commits must always be referenced by their full commit hash. This is because GitHub shares commit hashes among all forks and returns `404 Not Found` when a short commit hash is ambiguous. It already happens for some short, 6-character commit hashes in `nixpkgs`.

     

       457
       458
        
       It is a practical vector for a denial-of-service attack by pushing large amounts of auto generated commits into forks and was already [demonstrated against GitHub Actions Beta](https://blog.teddykatz.com/2019/11/12/github-actions-dos.html).

     

       458
       459
        
       

     

       459
       459
       -
       Find the value to put as `sha256` by running `nix-shell -p nix-prefetch-github --run "nix-prefetch-github --rev 1f795f9f44607cc5bec70d1300150bfefcef2aae NixOS nix"`. 

     

       460
       460
       +
       Find the value to put as `hash` by running `nix-shell -p nix-prefetch-github --run "nix-prefetch-github --rev 1f795f9f44607cc5bec70d1300150bfefcef2aae NixOS nix"`.

     

       460
       461
        
       

     

       461
       462
        
       ## Obtaining source hash {#sec-source-hashes}

     

       462
       463
        
       

     
···

       519
       520
        
         (fetchpatch {

     

       520
       521
        
           name = "fix-check-for-using-shared-freetype-lib.patch";

     

       521
       522
        
           url = "http://git.ghostscript.com/?p=ghostpdl.git;a=patch;h=8f5d285";

     

       522
       522
       -
           sha256 = "1f0k043rng7f0rfl9hhb89qzvvksqmkrikmm38p61yfx51l325xr";

     

       523
       523
       +
           hash = "sha256-uRcxaCjd+WAuGrXOmGfFeu79cUILwkRdBu48mwcBE7g=";

     

       523
       524
        
         })

     

       524
       525
        
       ];

     

       525
       526
        
       ```

+1 -1

doc/contributing/submitting-changes.chapter.md

···

       76
       76
        
         (fetchpatch {

     

       77
       77
        
           name = "CVE-2019-11068.patch";

     

       78
       78
        
           url = "https://gitlab.gnome.org/GNOME/libxslt/commit/e03553605b45c88f0b4b2980adfbbb8f6fca2fd6.patch";

     

       79
       79
       -
           sha256 = "0pkpb4837km15zgg6h57bncp66d5lwrlvkr73h0lanywq7zrwhj8";

     

       79
       79
       +
           hash = "sha256-SEKe/8HcW0UBHCfPTTOnpRlzmV2nQPPeL6HOMxBZd14=";

     

       80
       80
        
         })

     

       81
       81
        
         ```

     

       82
       82

+2 -2

doc/languages-frameworks/agda.section.md

···

       52
       52
        
             repo = "agda-stdlib";

     

       53
       53
        
             owner = "agda";

     

       54
       54
        
             rev = "v1.5";

     

       55
       55
       -
             sha256 = "16fcb7ssj6kj687a042afaa2gq48rc8abihpm14k684ncihb2k4w";

     

       55
       55
       +
             hash = "sha256-nEyxYGSWIDNJqBfGpRDLiOAnlHJKEKAOMnIaqfVZzJk=";

     

       56
       56
        
           };

     

       57
       57
        
         }))

     

       58
       58
        
       ])

     
···

       83
       83
        
             owner = "owner";

     

       84
       84
        
             version = "...";

     

       85
       85
        
             rev = "...";

     

       86
       86
       -
             sha256 = "...";

     

       86
       86
       +
             hash = "...";

     

       87
       87
        
           };

     

       88
       88
        
         })

     

       89
       89
        
       ])

+8 -8

doc/languages-frameworks/beam.section.md

···

       115
       115
        
                 owner = "elixir-libraries";

     

       116
       116
        
                 repo = "prometheus.ex";

     

       117
       117
        
                 rev = "a4e9beb3c1c479d14b352fd9d6dd7b1f6d7deee5";

     

       118
       118
       -
                 sha256 = "1v0q4bi7sb253i8q016l7gwlv5562wk5zy3l2sa446csvsacnpjk";

     

       118
       118
       +
                 hash = "sha256-U17LlN6aGUKUFnT4XyYXppRN+TvUBIBRHEUsfeIiGOw=";

     

       119
       119
        
               };

     

       120
       120
        
               # you can re-use the same beamDeps argument as generated

     

       121
       121
        
               beamDeps = with final; [ prometheus ];

     
···

       124
       124
        
       };

     

       125
       125
        
       ```

     

       126
       126
        
       

     

       127
       127
       -
       You will need to run the build process once to fix the sha256 to correspond to your new git src.

     

       127
       127
       +
       You will need to run the build process once to fix the hash to correspond to your new git src.

     

       128
       128
        
       

     

       129
       129
        
       ###### FOD {#fixed-output-derivation}

     

       130
       130
        
       

     
···

       138
       138
        
         mixFodDeps = fetchMixDeps {

     

       139
       139
        
           pname = "mix-deps-${pname}";

     

       140
       140
        
           inherit src version;

     

       141
       141
       -
           sha256 = lib.fakeSha256;

     

       141
       141
       +
           hash = lib.fakeHash;

     

       142
       142
        
         };

     

       143
       143
        
       ```

     

       144
       144
        
       

     

       145
       145
       -
       The first build will complain about the sha256 value, you can replace with the suggested value after that.

     

       145
       145
       +
       The first build will complain about the hash value, you can replace with the suggested value after that.

     

       146
       146
        
       

     

       147
       147
       -
       Note that if after you've replaced the value, nix suggests another sha256, then mix is not fetching the dependencies reproducibly. An FOD will not work in that case and you will have to use mix2nix.

     

       147
       147
       +
       Note that if after you've replaced the value, nix suggests another hash, then mix is not fetching the dependencies reproducibly. An FOD will not work in that case and you will have to use mix2nix.

     

       148
       148
        
       

     

       149
       149
        
       ##### mixRelease - example {#mix-release-example}

     

       150
       150
        
       

     
···

       170
       170
        
           pname = "mix-deps-${pname}";

     

       171
       171
        
           inherit src version;

     

       172
       172
        
           # nix will complain and tell you the right value to replace this with

     

       173
       173
       -
           sha256 = lib.fakeSha256;

     

       173
       173
       +
           hash = lib.fakeHash;

     

       174
       174
        
           # if you have build time environment variables add them here

     

       175
       175
        
           MY_ENV_VAR="my_value";

     

       176
       176
        
         };

     
···

       282
       282
        
       

     

       283
       283
        
       ### Using an overlay

     

       284
       284
        
       

     

       285
       285
       -
       If you need to use an overlay to change some attributes of a derivation, e.g. if you need a bugfix from a version that is not yet available in nixpkgs, you can override attributes such as `version` (and the corresponding `sha256`) and then use this overlay in your development environment:

     

       285
       285
       +
       If you need to use an overlay to change some attributes of a derivation, e.g. if you need a bugfix from a version that is not yet available in nixpkgs, you can override attributes such as `version` (and the corresponding `hash`) and then use this overlay in your development environment:

     

       286
       286
        
       

     

       287
       287
        
       #### `shell.nix`

     

       288
       288
        
       

     
···

       291
       291
        
         elixir_1_13_1_overlay = (self: super: {

     

       292
       292
        
             elixir_1_13 = super.elixir_1_13.override {

     

       293
       293
        
               version = "1.13.1";

     

       294
       294
       -
               sha256 = "0z0b1w2vvw4vsnb99779c2jgn9bgslg7b1pmd9vlbv02nza9qj5p";

     

       294
       294
       +
               sha256 = "sha256-t0ic1LcC7EV3avWGdR7VbyX7pGDpnJSW1ZvwvQUPC3w=";

     

       295
       295
        
             };

     

       296
       296
        
           });

     

       297
       297
        
         pkgs = import <nixpkgs> { overlays = [ elixir_1_13_1_overlay ]; };

+1 -1

doc/languages-frameworks/coq.section.md

···

       24
       24
        
         * if it is a string of the form `"#N"`, and the domain is github, then it tries to download the current head of the pull request `#N` from github,

     

       25
       25
        
       * `defaultVersion` (optional). Coq libraries may be compatible with some specific versions of Coq only. The `defaultVersion` attribute is used when no `version` is provided (or if `version = null`) to select the version of the library to use by default, depending on the context. This selection will mainly depend on a `coq` version number but also possibly on other packages versions (e.g. `mathcomp`). If its value ends up to be `null`, the package is marked for removal in end-user `coqPackages` attribute set.

     

       26
       26
        
       * `release` (optional, defaults to `{}`), lists all the known releases of the library and for each of them provides an attribute set with at least a `sha256` attribute (you may put the empty string `""` in order to automatically insert a fake sha256, this will trigger an error which will allow you to find the correct sha256), each attribute set of the list of releases also takes optional overloading arguments for the fetcher as below (i.e.`domain`, `owner`, `repo`, `rev` assuming the default fetcher is used) and optional overrides for the result of the fetcher (i.e. `version` and `src`).

     

       27
       27
       -
       * `fetcher` (optional, defaults to a generic fetching mechanism supporting github or gitlab based infrastructures), is a function that takes at least an `owner`, a `repo`, a `rev`, and a `sha256` and returns an attribute set with a `version` and `src`.

     

       27
       27
       +
       * `fetcher` (optional, defaults to a generic fetching mechanism supporting github or gitlab based infrastructures), is a function that takes at least an `owner`, a `repo`, a `rev`, and a `hash` and returns an attribute set with a `version` and `src`.

     

       28
       28
        
       * `repo` (optional, defaults to the value of `pname`),

     

       29
       29
        
       * `owner` (optional, defaults to `"coq-community"`).

     

       30
       30
        
       * `domain` (optional, defaults to `"github.com"`), domains including the strings `"github"` or `"gitlab"` in their names are automatically supported, otherwise, one must change the `fetcher` argument to support them (cf `pkgs/development/coq-modules/heq/default.nix` for an example),

+2 -2

doc/languages-frameworks/crystal.section.md

···

       27
       27
        
           owner = "mint-lang";

     

       28
       28
        
           repo = "mint";

     

       29
       29
        
           rev = version;

     

       30
       30
       -
           sha256 = "0vxbx38c390rd2ysvbwgh89v2232sh5rbsp3nk9wzb70jybpslvl";

     

       30
       30
       +
           hash = "sha256-dFN9l5fgrM/TtOPqlQvUYgixE4KPr629aBmkwdDoq28=";

     

       31
       31
        
         };

     

       32
       32
        
       

     

       33
       33
        
         # Insert the path to your shards.nix file here

     
···

       62
       62
        
           owner = "mint-lang";

     

       63
       63
        
           repo = "mint";

     

       64
       64
        
           rev = version;

     

       65
       65
       -
           sha256 = "0vxbx38c390rd2ysvbwgh89v2232sh5rbsp3nk9wzb70jybpslvl";

     

       65
       65
       +
           hash = "sha256-dFN9l5fgrM/TtOPqlQvUYgixE4KPr629aBmkwdDoq28=";

     

       66
       66
        
         };

     

       67
       67
        
       

     

       68
       68
        
         shardsFile = ./shards.nix;

+3 -3

doc/languages-frameworks/dhall.section.md

···

       91
       91
        
       let

     

       92
       92
        
         nixpkgs = builtins.fetchTarball {

     

       93
       93
        
           url    = "https://github.com/NixOS/nixpkgs/archive/94b2848559b12a8ed1fe433084686b2a81123c99.tar.gz";

     

       94
       94
       -
           sha256 = "1pbl4c2dsaz2lximgd31m96jwbps6apn3anx8cvvhk1gl9rkg107";

     

       94
       94
       +
           sha256 = "sha256-B4Q3c6IvTLg3Q92qYa8y+i4uTaphtFdjp+Ir3QQjdN0=";

     

       95
       95
        
         };

     

       96
       96
        
       

     

       97
       97
        
         dhallOverlay = self: super: {

     
···

       295
       295
        
       * `document`: Set to `true` to generate documentation for the package

     

       296
       296
        
       

     

       297
       297
        
       Additionally, `buildDhallGitHubPackage` accepts the same arguments as

     

       298
       298
       -
       `fetchFromGitHub`, such as `sha256` or `fetchSubmodules`.

     

       298
       298
       +
       `fetchFromGitHub`, such as `hash` or `fetchSubmodules`.

     

       299
       299
        
       

     

       300
       300
        
       ## `dhall-to-nixpkgs` {#ssec-dhall-dhall-to-nixpkgs}

     

       301
       301
        
       

     
···

       316
       316
        
           repo = "dhall-semver";

     

       317
       317
        
           rev = "2d44ae605302ce5dc6c657a1216887fbb96392a4";

     

       318
       318
        
           fetchSubmodules = false;

     

       319
       319
       -
           sha256 = "0y8shvp8srzbjjpmnsvz9c12ciihnx1szs0yzyi9ashmrjvd0jcz";

     

       319
       319
       +
           hash = "sha256-n0nQtswVapWi/x7or0O3MEYmAkt/a1uvlOtnje6GGnk=";

     

       320
       320
        
           directory = "";

     

       321
       321
        
           file = "package.dhall";

     

       322
       322
        
           source = false;

+1 -1

doc/languages-frameworks/emscripten.section.md

···

       121
       121
        
             src = pkgs.fetchgit {

     

       122
       122
        
               url = "https://gitlab.com/odfplugfest/xmlmirror.git";

     

       123
       123
        
               rev = "4fd7e86f7c9526b8f4c1733e5c8b45175860a8fd";

     

       124
       124
       -
               sha256 = "1jasdqnbdnb83wbcnyrp32f36w3xwhwp0wq8lwwmhqagxrij1r4b";

     

       124
       124
       +
               hash = "sha256-i+QgY+5PYVg5pwhzcDnkfXAznBg3e8sWH2jZtixuWsk=";

     

       125
       125
        
             };

     

       126
       126
        
       

     

       127
       127
        
             configurePhase = ''

+5 -5

doc/languages-frameworks/go.section.md

···

       23
       23
        
           owner = "knqyf263";

     

       24
       24
        
           repo = "pet";

     

       25
       25
        
           rev = "v${version}";

     

       26
       26
       -
           sha256 = "0m2fzpqxk7hrbxsgqplkg7h2p7gv6s1miymv3gvw0cz039skag0s";

     

       26
       26
       +
           hash = "sha256-Gjw1dRrgM8D3G7v6WIM2+50r4HmTXvx0Xxme2fH9TlQ=";

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
        
         vendorHash = "sha256-ciBIR+a1oaYH+H1PcC8cD8ncfJczk1IiJ8iYNM+R6aA=";

     
···

       59
       59
        
           owner = "deis";

     

       60
       60
        
           repo = "deis";

     

       61
       61
        
           rev = "v${version}";

     

       62
       62
       -
           sha256 = "1qv9lxqx7m18029lj8cw3k7jngvxs4iciwrypdy0gd2nnghc68sw";

     

       62
       62
       +
           hash = "sha256-XCPD4LNWtAd8uz7zyCLRfT8rzxycIUmTACjU03GnaeM=";

     

       63
       63
        
         };

     

       64
       64
        
       

     

       65
       65
        
         goDeps = ./deps.nix;

     
···

       76
       76
        
           goPackagePath = "gopkg.in/yaml.v2";

     

       77
       77
        
           fetch = {

     

       78
       78
        
             # `fetch type` that needs to be used to get package source.

     

       79
       79
       -
             # If `git` is used there should be `url`, `rev` and `sha256` defined next to it.

     

       79
       79
       +
             # If `git` is used there should be `url`, `rev` and `hash` defined next to it.

     

       80
       80
        
             type = "git";

     

       81
       81
        
             url = "https://gopkg.in/yaml.v2";

     

       82
       82
        
             rev = "a83829b6f1293c91addabc89d0571c246397bbf4";

     

       83
       83
       -
             sha256 = "1m4dsmk90sbi17571h6pld44zxz7jc4lrnl4f27dpd1l8g5xvjhh";

     

       83
       83
       +
             hash = "sha256-EMrdy0M0tNuOcITaTAmT5/dPSKPXwHDKCXFpkGbVjdQ=";

     

       84
       84
        
           };

     

       85
       85
        
         }

     

       86
       86
        
         {

     
···

       89
       89
        
             type = "git";

     

       90
       90
        
             url = "https://github.com/docopt/docopt-go";

     

       91
       91
        
             rev = "784ddc588536785e7299f7272f39101f7faccc3f";

     

       92
       92
       -
             sha256 = "0wwz48jl9fvl1iknvn9dqr4gfy1qs03gxaikrxxp9gry6773v3sj";

     

       92
       92
       +
             hash = "sha256-Uo89zjE+v3R7zzOq/gbQOHj3SMYt2W1nDHS7RCUin3M=";

     

       93
       93
        
           };

     

       94
       94
        
         }

     

       95
       95
        
       ]

+1 -1

doc/languages-frameworks/idris.section.md

···

       90
       90
        
           owner = "Heather";

     

       91
       91
        
           repo = "Idris.Yaml";

     

       92
       92
        
           rev = "5afa51ffc839844862b8316faba3bafa15656db4";

     

       93
       93
       -
           sha256 = "1g4pi0swmg214kndj85hj50ccmckni7piprsxfdzdfhg87s0avw7";

     

       93
       93
       +
           hash = "sha256-h28F9EEPuvab6zrfeE+0k1XGQJGwINnsJEG8yjWIl7w=";

     

       94
       94
        
         };

     

       95
       95
        
       

     

       96
       96
        
         meta = with lib; {

+1 -1

doc/languages-frameworks/javascript.section.md

···

       242
       242
        
       ```nix

     

       243
       243
        
       offlineCache = fetchYarnDeps {

     

       244
       244
        
         yarnLock = src + "/yarn.lock";

     

       245
       245
       -
         sha256 = "....";

     

       245
       245
       +
         hash = "....";

     

       246
       246
        
       };

     

       247
       247
        
       ```

     

       248
       248

+1 -1

doc/languages-frameworks/lua.section.md

···

       183
       183
        
       

     

       184
       184
        
         src = fetchurl {

     

       185
       185
        
           url    = "https://raw.githubusercontent.com/rocks-moonscript-org/moonrocks-mirror/master/luaposix-34.0.4-1.src.rock";

     

       186
       186
       -
           sha256 = "0yrm5cn2iyd0zjd4liyj27srphvy0gjrjx572swar6zqr4dwjqp2";

     

       186
       186
       +
           hash = "sha256-4mLJG8n4m6y4Fqd0meUDfsOb9RHSR0qa/KD5KCwrNXs=";

     

       187
       187
        
         };

     

       188
       188
        
         disabled = (luaOlder "5.1") || (luaAtLeast "5.4");

     

       189
       189
        
         propagatedBuildInputs = [ bit32 lua std_normalize ];

+2 -2

doc/languages-frameworks/nim.section.md

···

       25
       25
        
       

     

       26
       26
        
         src = fetchurl {

     

       27
       27
        
           url = "https://git.sr.ht/~ehmry/hottext/archive/v${version}.tar.gz";

     

       28
       28
       -
           sha256 = "sha256-hIUofi81zowSMbt1lUsxCnVzfJGN3FEiTtN8CEFpwzY=";

     

       28
       28
       +
           hash = "sha256-hIUofi81zowSMbt1lUsxCnVzfJGN3FEiTtN8CEFpwzY=";

     

       29
       29
        
         };

     

       30
       30
        
       

     

       31
       31
        
         buildInputs = with nimPackages; [

     
···

       65
       65
        
         version = "2.0.4";

     

       66
       66
        
         src = fetchNimble {

     

       67
       67
        
           inherit pname version;

     

       68
       68
       -
           hash = "sha256-Vtcj8goI4zZPQs2TbFoBFlcR5UqDtOldaXSH/+/xULk=";

     

       68
       68
       +
           hash = "sha256-qDtVSnf+7rTq36WAxgsUZ8XoUk4sKwHyt8EJcY5WP+o=";

     

       69
       69
        
         };

     

       70
       70
        
         propagatedBuildInputs = [ SDL2 ];

     

       71
       71
        
       }

+2 -2

doc/languages-frameworks/ocaml.section.md

···

       79
       79
        
           owner  = "inhabitedtype";

     

       80
       80
        
           repo   = pname;

     

       81
       81
        
           rev    = version;

     

       82
       82
       -
           sha256 = "1hmrkdcdlkwy7rxhngf3cv3sa61cznnd9p5lmqhx20664gx2ibrh";

     

       82
       82
       +
           hash   = "sha256-MK8o+iPGANEhrrTc1Kz9LBilx2bDPQt7Pp5P2libucI=";

     

       83
       83
        
         };

     

       84
       84
        
       

     

       85
       85
        
         checkInputs = [ alcotest ppx_let ];

     
···

       110
       110
        
       

     

       111
       111
        
         src = fetchurl {

     

       112
       112
        
           url = "https://github.com/flowtype/ocaml-${pname}/releases/download/v${version}/${pname}-v${version}.tbz";

     

       113
       113
       -
           sha256 = "09ygcxxd5warkdzz17rgpidrd0pg14cy2svvnvy1hna080lzg7vp";

     

       113
       113
       +
           hash = "sha256-d5/3KUBAWRj8tntr4RkJ74KWW7wvn/B/m1nx0npnzyc=";

     

       114
       114
        
         };

     

       115
       115
        
       

     

       116
       116
        
         meta = with lib; {

+7 -7

doc/languages-frameworks/perl.section.md

···

       39
       39
        
         version = "0.21";

     

       40
       40
        
         src = fetchurl {

     

       41
       41
        
           url = "mirror://cpan/authors/id/F/FL/FLORA/${pname}-${version}.tar.gz";

     

       42
       42
       -
           sha256 = "1bl8z095y4js66pwxnm7s853pi9czala4sqc743fdlnk27kq94gz";

     

       42
       42
       +
           hash = "sha256-/5GE5xHT0uYGOQxroqj6LMU7CtKn2s6vMVoSXxL4iK4=";

     

       43
       43
        
         };

     

       44
       44
        
       };

     

       45
       45
        
       ```

     
···

       78
       78
        
       

     

       79
       79
        
         src = fetchurl {

     

       80
       80
        
           url = "mirror://cpan/authors/id/P/PM/PMQS/${pname}-${version}.tar.gz";

     

       81
       81
       -
           sha256 = "07xf50riarb60l1h6m2dqmql8q5dij619712fsgw7ach04d8g3z1";

     

       81
       81
       +
           hash = "sha256-4Y+HGgGQqcOfdiKcFIyMrWBEccVNVAMDBWZlFTMorh8=";

     

       82
       82
        
         };

     

       83
       83
        
       

     

       84
       84
        
         preConfigure = ''

     
···

       96
       96
        
         version = "1.0004";

     

       97
       97
        
         src = fetchurl {

     

       98
       98
        
           url = "mirror://cpan/authors/id/A/AS/ASH/${pname}-${version}.tar.gz";

     

       99
       99
       -
           sha256 = "0xql73jkcdbq4q9m0b0rnca6nrlvf5hyzy8is0crdk65bynvs8q1";

     

       99
       99
       +
           hash = "sha256-ASO9rV/FzJYZ0BH572Fxm2ZrFLMZLFATJng1NuU4FHc=";

     

       100
       100
        
         };

     

       101
       101
        
         propagatedBuildInputs = [

     

       102
       102
        
           ClassC3 ClassInspector TestException MROCompat

     
···

       111
       111
        
       

     

       112
       112
        
       ImageExifTool = buildPerlPackage {

     

       113
       113
        
         pname = "Image-ExifTool";

     

       114
       114
       -
         version = "11.50";

     

       114
       114
       +
         version = "12.50";

     

       115
       115
        
       

     

       116
       116
        
         src = fetchurl {

     

       117
       117
       -
           url = "https://www.sno.phy.queensu.ca/~phil/exiftool/${pname}-${version}.tar.gz";

     

       118
       118
       -
           sha256 = "0d8v48y94z8maxkmw1rv7v9m0jg2dc8xbp581njb6yhr7abwqdv3";

     

       117
       117
       +
           url = "https://exiftool.org/${pname}-${version}.tar.gz";

     

       118
       118
       +
           hash = "sha256-vOhB/FwQMC8PPvdnjDvxRpU6jAZcC6GMQfc0AH4uwKg=";

     

       119
       119
        
         };

     

       120
       120
        
       

     

       121
       121
        
         buildInputs = lib.optional stdenv.isDarwin shortenPerlShebang;

     
···

       146
       146
        
           version = "2.22";

     

       147
       147
        
           src = fetchurl {

     

       148
       148
        
             url = "mirror://cpan/authors/id/G/GR/GRANTM/XML-Simple-2.22.tar.gz";

     

       149
       149
       -
             sha256 = "b9450ef22ea9644ae5d6ada086dc4300fa105be050a2030ebd4efd28c198eb49";

     

       149
       149
       +
             hash = "sha256-uUUO8i6pZErl1q2ghtxDAPoQW+BQogMOvU79KMGY60k=";

     

       150
       150
        
           };

     

       151
       151
        
           propagatedBuildInputs = [ XMLNamespaceSupport XMLSAX XMLSAXExpat ];

     

       152
       152
        
           meta = {

+13 -13

doc/languages-frameworks/python.section.md

···

       356
       356
        
       

     

       357
       357
        
         src = fetchPypi {

     

       358
       358
        
           inherit pname version;

     

       359
       359
       -
           sha256 = "08fdd5ef7c96480ad11c12d472de21acd32359996f69a5259299b540feba4560";

     

       359
       359
       +
           hash = "sha256-CP3V73yWSArRHBLUct4hrNMjWZlvaaUlkpm1QP66RWA=";

     

       360
       360
        
         };

     

       361
       361
        
       

     

       362
       362
        
         doCheck = false;

     
···

       401
       401
        
       

     

       402
       402
        
             src = python39.pkgs.fetchPypi {

     

       403
       403
        
               inherit pname version;

     

       404
       404
       -
               sha256 = "08fdd5ef7c96480ad11c12d472de21acd32359996f69a5259299b540feba4560";

     

       404
       404
       +
               hash = "sha256-CP3V73yWSArRHBLUct4hrNMjWZlvaaUlkpm1QP66RWA=";

     

       405
       405
        
             };

     

       406
       406
        
       

     

       407
       407
        
             doCheck = false;

     
···

       450
       450
        
       

     

       451
       451
        
         src = fetchPypi {

     

       452
       452
        
           inherit pname version;

     

       453
       453
       -
           sha256 = "14b2ef766d4c9652ab813182e866f493475e65e558bed0822e38bf07bba1a278";

     

       453
       453
       +
           hash = "sha256-FLLvdm1MllKrgTGC6Gb0k0deZeVYvtCCLji/B7uhong=";

     

       454
       454
        
         };

     

       455
       455
        
       

     

       456
       456
        
         checkInputs = [ pytest ];

     
···

       484
       484
        
       

     

       485
       485
        
         src = fetchPypi {

     

       486
       486
        
           inherit pname version;

     

       487
       487
       -
           sha256 = "16a0fa97hym9ysdk3rmqz32xdjqmy4w34ld3rm3jf5viqjx65lxk";

     

       487
       487
       +
           hash = "sha256-s9NiusRxFydHzaNRMjjxFcvWxfi45jGb9ql6eJJyQJk=";

     

       488
       488
        
         };

     

       489
       489
        
       

     

       490
       490
        
         buildInputs = [ pkgs.libxml2 pkgs.libxslt ];

     
···

       517
       517
        
       

     

       518
       518
        
         src = fetchPypi {

     

       519
       519
        
           inherit pname version;

     

       520
       520
       -
           sha256 = "f6bbb6afa93085409ab24885a1a3cdb8909f095a142f4d49e346f2bd1b789074";

     

       520
       520
       +
           hash = "sha256-9ru2r6kwhUCaskiFoaPNuJCfCVoUL01J40byvRt4kHQ=";

     

       521
       521
        
         };

     

       522
       522
        
       

     

       523
       523
        
         buildInputs = [ pkgs.fftw pkgs.fftwFloat pkgs.fftwLongDouble];

     
···

       855
       855
        
       

     

       856
       856
        
         src = fetchPypi {

     

       857
       857
        
           inherit pname version;

     

       858
       858
       -
           sha256 = "08fdd5ef7c96480ad11c12d472de21acd32359996f69a5259299b540feba4560";

     

       858
       858
       +
           hash = "sha256-CP3V73yWSArRHBLUct4hrNMjWZlvaaUlkpm1QP66RWA=";

     

       859
       859
        
         };

     

       860
       860
        
       

     

       861
       861
        
         meta = with lib; {

     
···

       988
       988
        
       

     

       989
       989
        
         src = fetchPypi {

     

       990
       990
        
           inherit pname version;

     

       991
       991
       -
           sha256 = "cf8436dc59d8695346fcd3ab296de46425ecab00d64096cebe79fb51ecb2eb93";

     

       991
       991
       +
           hash = "sha256-z4Q23FnYaVNG/NOrKW3kZCXsqwDWQJbOvnn7Ueyy65M=";

     

       992
       992
        
         };

     

       993
       993
        
       

     

       994
       994
        
         postPatch = ''

     
···

       1098
       1098
        
               src =  super.fetchPypi {

     

       1099
       1099
        
                 pname = "pandas";

     

       1100
       1100
        
                 inherit version;

     

       1101
       1101
       -
                 sha256 = "08blshqj9zj1wyjhhw3kl2vas75vhhicvv72flvf1z3jvapgw295";

     

       1101
       1101
       +
                 hash = "sha256-JQn+rtpy/OA2deLszSKEuxyttqBzcAil50H+JDHUdCE=";

     

       1102
       1102
        
               };

     

       1103
       1103
        
             });

     

       1104
       1104
        
           };

     
···

       1158
       1158
        
       

     

       1159
       1159
        
         src = python3.pkgs.fetchPypi {

     

       1160
       1160
        
           inherit pname version;

     

       1161
       1161
       -
           sha256 = "035w8gqql36zlan0xjrzz9j4lh9hs0qrsgnbyw07qs7lnkvbdv9x";

     

       1161
       1161
       +
           hash  = "sha256-Pe229rT0aHwA98s+nTHQMEFKZPo/yw6sot8MivFDvAw=";

     

       1162
       1162
        
         };

     

       1163
       1163
        
       

     

       1164
       1164
        
         propagatedBuildInputs = with python3.pkgs; [ tornado python-daemon ];

     
···

       1674
       1674
        
             packageOverrides = python-self: python-super: {

     

       1675
       1675
        
               twisted = python-super.twisted.overridePythonAttrs (oldAttrs: {

     

       1676
       1676
        
                 src = super.fetchPypi {

     

       1677
       1677
       -
                   pname = "twisted";

     

       1677
       1677
       +
                   pname = "Twisted";

     

       1678
       1678
        
                   version = "19.10.0";

     

       1679
       1679
       -
                   sha256 = "7394ba7f272ae722a74f3d969dcf599bc4ef093bc392038748a490f1724a515d";

     

       1679
       1679
       +
                   hash = "sha256-c5S6fycq5yKnTz2Wnc9Zm8TvCTvDkgOHSKSQ8XJKUV0=";

     

       1680
       1680
        
                   extension = "tar.bz2";

     

       1681
       1681
        
                 };

     

       1682
       1682
        
               });

     
···

       1712
       1712
        
           packageOverrides = python-self: python-super: {

     

       1713
       1713
        
             twisted = python-super.twisted.overrideAttrs (oldAttrs: {

     

       1714
       1714
        
               src = super.fetchPypi {

     

       1715
       1715
       -
                 pname = "twisted";

     

       1715
       1715
       +
                 pname = "Twisted";

     

       1716
       1716
        
                 version = "19.10.0";

     

       1717
       1717
       -
                 sha256 = "7394ba7f272ae722a74f3d969dcf599bc4ef093bc392038748a490f1724a515d";

     

       1717
       1717
       +
                 hash = "sha256-c5S6fycq5yKnTz2Wnc9Zm8TvCTvDkgOHSKSQ8XJKUV0=";

     

       1718
       1718
        
                 extension = "tar.bz2";

     

       1719
       1719
        
               };

     

       1720
       1720
        
             });

+11 -11

doc/languages-frameworks/rust.section.md

···

       30
       30
        
           owner = "BurntSushi";

     

       31
       31
        
           repo = pname;

     

       32
       32
        
           rev = version;

     

       33
       33
       -
           sha256 = "1hqps7l5qrjh9f914r5i6kmcz6f1yb951nv4lby0cjnp5l253kps";

     

       33
       33
       +
           hash = "sha256-+s5RBC3XSgb8omTbUNLywZnP6jSxZBKSS1BmXOjRF8M=";

     

       34
       34
        
         };

     

       35
       35
        
       

     

       36
       36
       -
         cargoSha256 = "03wf9r2csi6jpa7v5sw5lpxkrk4wfzwmzx7k3991q3bdjzcwnnwp";

     

       36
       36
       +
         cargoHash = "sha256-jtBw4ahSl88L0iuCXxQgZVm1EcboWRJMNtjxLVTtzts=";

     

       37
       37
        
       

     

       38
       38
        
         meta = with lib; {

     

       39
       39
        
           description = "A fast line-oriented regex search tool, similar to ag and ack";

     
···

       97
       97
        
       

     

       98
       98
        
         src = fetchCrate {

     

       99
       99
        
           inherit pname version;

     

       100
       100
       -
           sha256 = "1mqaynrqaas82f5957lx31x80v74zwmwmjxxlbywajb61vh00d38";

     

       100
       100
       +
           sha256 = "sha256-aDQA4A5mScX9or3Lyiv/5GyAehidnpKKE0grhbP1Ctc=";

     

       101
       101
        
         };

     

       102
       102
        
       

     

       103
       103
       -
         cargoHash = "sha256-JmBZcDVYJaK1cK05cxx5BrnGWp4t8ca6FLUbvIot67s=";

     

       103
       103
       +
         cargoHash = "sha256-tbrTbutUs5aPSV+yE0IBUZAAytgmZV7Eqxia7g+9zRs=";

     

       104
       104
        
         cargoDepsName = pname;

     

       105
       105
        
       

     

       106
       106
        
         # ...

     
···

       417
       417
        
       ```

     

       418
       418
        
       

     

       419
       419
        
       The `src` attribute is required, as well as a hash specified through

     

       420
       420
       -
       one of the `sha256` or `hash` attributes. The following optional

     

       421
       421
       -
       attributes can also be used:

     

       420
       420
       +
       one of the `hash` attribute. The following optional attributes can

     

       421
       421
       +
       also be used:

     

       422
       422
        
       

     

       423
       423
        
       * `name`: the name that is used for the dependencies tarball.  If

     

       424
       424
        
         `name` is not specified, then the name `cargo-deps` will be used.

     
···

       531
       531
        
         cargoDeps = rustPlatform.fetchCargoTarball {

     

       532
       532
        
           inherit src sourceRoot;

     

       533
       533
        
           name = "${pname}-${version}";

     

       534
       534
       -
           hash = "sha256-BoHIN/519Top1NUBjpB/oEMqi86Omt3zTQcXFWqrek0=";

     

       534
       534
       +
           hash = "sha256-miW//pnOmww2i6SOGbkrAIdc/JMDT4FJLqdMFojZeoY=";

     

       535
       535
        
         };

     

       536
       536
        
       

     

       537
       537
        
         sourceRoot = "source/bindings/python";

     
···

       568
       568
        
       

     

       569
       569
        
         src = fetchPypi {

     

       570
       570
        
           inherit pname version;

     

       571
       571
       -
           sha256 = "1i1mx5y9hkyfi9jrrkcw804hmkcglxi6rmf7vin7jfnbr2bf4q64";

     

       571
       571
       +
           hash = "sha256-xGDilsjLOnls3MfVbGKnj80KCUCczZxlis5PmHzpNcQ=";

     

       572
       572
        
         };

     

       573
       573
        
       

     

       574
       574
        
         cargoDeps = rustPlatform.fetchCargoTarball {

     
···

       608
       608
        
           owner = "Qiskit";

     

       609
       609
        
           repo = "retworkx";

     

       610
       610
        
           rev = version;

     

       611
       611
       -
           sha256 = "11n30ldg3y3y6qxg3hbj837pnbwjkqw3nxq6frds647mmmprrd20";

     

       611
       611
       +
           hash = "sha256-11n30ldg3y3y6qxg3hbj837pnbwjkqw3nxq6frds647mmmprrd20=";

     

       612
       612
        
         };

     

       613
       613
        
       

     

       614
       614
        
         cargoDeps = rustPlatform.fetchCargoTarball {

     
···

       682
       682
        
             repo = "nixpkgs-mozilla";

     

       683
       683
        
             # commit from: 2019-05-15

     

       684
       684
        
             rev = "9f35c4b09fd44a77227e79ff0c1b4b6a69dff533";

     

       685
       685
       -
             sha256 = "18h0nvh55b5an4gmlgfbvwbyqj91bklf1zymis6lbdh75571qaz0";

     

       685
       685
       +
             hash = "sha256-18h0nvh55b5an4gmlgfbvwbyqj91bklf1zymis6lbdh75571qaz0=";

     

       686
       686
        
          };

     

       687
       687
        
       in

     

       688
       688
        
       with import "${src.out}/rust-overlay.nix" pkgs pkgs;

     
···

       773
       773
        
           owner = "BurntSushi";

     

       774
       774
        
           repo = "ripgrep";

     

       775
       775
        
           rev = version;

     

       776
       776
       -
           sha256 = "1hqps7l5qrjh9f914r5i6kmcz6f1yb951nv4lby0cjnp5l253kps";

     

       776
       776
       +
           hash = "sha256-1hqps7l5qrjh9f914r5i6kmcz6f1yb951nv4lby0cjnp5l253kps=";

     

       777
       777
        
         };

     

       778
       778
        
       

     

       779
       779
        
         cargoSha256 = "03wf9r2csi6jpa7v5sw5lpxkrk4wfzwmzx7k3991q3bdjzcwnnwp";

+2 -2

doc/languages-frameworks/texlive.section.md

···

       55
       55
        
           srcs = [

     

       56
       56
        
             (fetchurl {

     

       57
       57
        
               url = "http://mirrors.ctan.org/macros/latex/contrib/foiltex/foiltex.dtx";

     

       58
       58
       -
               sha256 = "07frz0krpz7kkcwlayrwrj2a2pixmv0icbngyw92srp9fp23cqpz";

     

       58
       58
       +
               hash = "sha256-/2I2xHXpZi0S988uFsGuPV6hhMw8e0U5m/P8myf42R0=";

     

       59
       59
        
             })

     

       60
       60
        
             (fetchurl {

     

       61
       61
        
               url = "http://mirrors.ctan.org/macros/latex/contrib/foiltex/foiltex.ins";

     

       62
       62
       -
               sha256 = "09wkyidxk3n3zvqxfs61wlypmbhi1pxmjdi1kns9n2ky8ykbff99";

     

       62
       62
       +
               hash = "sha256-KTm3pkd+Cpu0nSE2WfsNEa56PeXBaNfx/sOO2Vv0kyc=";

     

       63
       63
        
             })

     

       64
       64
        
           ];

     

       65
       65

+1 -1

doc/languages-frameworks/vim.section.md

···

       131
       131
        
             owner = "dkprice";

     

       132
       132
        
             repo = "vim-easygrep";

     

       133
       133
        
             rev = "d0c36a77cc63c22648e792796b1815b44164653a";

     

       134
       134
       -
             sha256 = "0y2p5mz0d5fhg6n68lhfhl8p4mlwkb82q337c22djs4w5zyzggbc";

     

       134
       134
       +
             hash = "sha256-bL33/S+caNmEYGcMLNCanFZyEYUOUmSsedCVBn4tV3g=";

     

       135
       135
        
           };

     

       136
       136
        
         };

     

       137
       137
        
       in

+4 -4

doc/old/cross.txt

···

       61
       61
        
         builder = ./builder.sh;

     

       62
       62
        
         src = fetchurl {

     

       63
       63
        
           url = "http://ftp.nluug.nl/gnu/binutils/binutils-2.16.1.tar.bz2";

     

       64
       64
       -
           sha256 = "1ian3kwh2vg6hr3ymrv48s04gijs539vzrq62xr76bxbhbwnz2np";

     

       64
       64
       +
           hash = "sha256-14pv+YKrL3NyFwbnv9MoWsZHgEZk5+pHhuZtAfkcVsU=";

     

       65
       65
        
         };

     

       66
       66
        
         inherit noSysDirs;

     

       67
       67
        
         configureFlags = [ "--target=arm-linux" ];

     
···

       85
       85
        
         builder = ./builder.sh;

     

       86
       86
        
         src = fetchurl {

     

       87
       87
        
           url = "http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.13.1.tar.bz2";

     

       88
       88
       -
           sha256 = "12qxmc827fjhaz53kjy7vyrzsaqcg78amiqsb3qm20z26w705lma";

     

       88
       88
       +
           hash = "sha256-qtICDjfiA1HxWBrHqtB5DCv9s9/HyznKV1C6IxCrHYs=";

     

       89
       89
        
         };

     

       90
       90
        
       }

     

       91
       91
        
       ---

     
···

       151
       151
        
         name = "gcc-4.0.2-arm";

     

       152
       152
        
         builder = ./builder.sh;

     

       153
       153
        
         src = fetchurl {

     

       154
       154
       -
           url = ftp://ftp.nluug.nl/pub/gnu/gcc/gcc-4.0.2/gcc-core-4.0.2.tar.bz2;

     

       155
       155
       -
           sha256 = "02fxh0asflm8825w23l2jq1wvs7hbnam0jayrivg7zdv2ifnc0rc";

     

       154
       154
       +
           url = "ftp://ftp.nluug.nl/pub/gnu/gcc/gcc-4.0.2/gcc-core-4.0.2.tar.bz2";

     

       155
       155
       +
           hash = "sha256-LANmXRS7/fN2zF5JUJVd8OjNA5aCDsGLQKhSpxWA3Qk=";

     

       156
       156
        
         };

     

       157
       157
        
         # !!! apply only if noSysDirs is set

     

       158
       158
        
         patches = [./no-sys-dirs.patch ./gcc-inhibit.patch];

+2 -2

doc/stdenv/stdenv.chapter.md

···

       11
       11
        
         name = "libfoo-1.2.3";

     

       12
       12
        
         src = fetchurl {

     

       13
       13
        
           url = "http://example.org/libfoo-1.2.3.tar.bz2";

     

       14
       14
       -
           sha256 = "0x2g1jqygyr5wiwg4ma1nd7w4ydpy82z9gkcv8vh2v8dn3y58v5m";

     

       14
       14
       +
           hash = "sha256-tWxU/LANbQE32my+9AXyt3nCT7NBVfJ45CX757EMT3Q=";

     

       15
       15
        
         };

     

       16
       16
        
       }

     

       17
       17
        
       ```

     
···

       24
       24
        
         version = "1.2.3";

     

       25
       25
        
         src = fetchurl {

     

       26
       26
        
           url = "http://example.org/libfoo-source-${version}.tar.bz2";

     

       27
       27
       -
           sha256 = "0x2g1jqygyr5wiwg4ma1nd7w4ydpy82z9gkcv8vh2v8dn3y58v5m";

     

       27
       27
       +
           hash = "sha256-tWxU/LANbQE32my+9AXyt3nCT7NBVfJ45CX757EMT3Q=";

     

       28
       28
        
         };

     

       29
       29
        
       }

     

       30
       30
        
       ```

+2 -2

doc/using/overrides.chapter.md

···

       74
       74
        
       mySed = pkgs.gnused.overrideDerivation (oldAttrs: {

     

       75
       75
        
         name = "sed-4.2.2-pre";

     

       76
       76
        
         src = fetchurl {

     

       77
       77
       -
           url = ftp://alpha.gnu.org/gnu/sed/sed-4.2.2-pre.tar.bz2;

     

       78
       78
       -
           sha256 = "11nq06d131y4wmf3drm0yk502d2xc6n5qy82cg88rb9nqd2lj41k";

     

       77
       77
       +
           url = "ftp://alpha.gnu.org/gnu/sed/sed-4.2.2-pre.tar.bz2";

     

       78
       78
       +
           hash = "sha256-MxBJRcM2rYzQYwJ5XKxhXTQByvSg5jZc5cSHEZoB2IY=";

     

       79
       79
        
         };

     

       80
       80
        
         patches = [];

     

       81
       81
        
       });