ilyakooo0/haskell.nix
1
0
Fork 0
mirror of https://github.com/ilyakooo0/haskell.nix.git synced 2024-08-15 18:00:50 +03:00
Code Issues Projects Releases Wiki Activity
9755ab715e
haskell.nix/build.nix

102 lines
4.7 KiB
Nix
Raw Normal View History

Use release-lib.nix for Hydra (#161) * Use release-lib.nix for Hydra jobset * Buildkite: Add a script to check Hydra evaluation
2019-06-03 06:26:28 +03:00
# This file contains the package set used by the release.nix jobset.
#
# It is separate from default.nix because that file is the public API
# of Haskell.nix, which shouldn't have tests, etc.
Expose our nixpkgs pins by restructuring default.nix (#514) * Remove unused (and broken) test files * Make default.nix expose pinned nixpkgs Also make `nixpkgs/default.nix` just an attribute set of sources. This is simpler, and consistent with what e.g. `niv` does. * Add backwards compatibility shim, and version argument to allow evolution in future * Fix some missed things * Fix and improve quickstart
2020-03-31 04:12:40 +03:00
let
haskellNix = (import ./default.nix {});
in
Add nixos-21.11 builds. (#1304) * Add nixos-21.11 builds. * Remove references to nixpkgs-20.09.
2021-12-07 02:55:20 +03:00
{ nixpkgs ? haskellNix.sources.nixpkgs-2111
Expose our nixpkgs pins by restructuring default.nix (#514) * Remove unused (and broken) test files * Make default.nix expose pinned nixpkgs Also make `nixpkgs/default.nix` just an attribute set of sources. This is simpler, and consistent with what e.g. `niv` does. * Add backwards compatibility shim, and version argument to allow evolution in future * Fix some missed things * Fix and improve quickstart
2020-03-31 04:12:40 +03:00
, nixpkgsArgs ? haskellNix.nixpkgsArgs
, pkgs ? import nixpkgs nixpkgsArgs
Add `evalSystem` and `evalPackages` project args (#1546) This adds a way to specify the `evalSystem` or `evalPackages` explicitly when calling the `project` functions. Currently if we want to make a `flake` that supports multiple systems we have few options: * Require builders for all the supported systems (even just for `nix flake show`). * Pass `--impure` so that haskell.nix can see `builtins.currentSystem` to set up `pkgs.evalPackages` to use that. Unfortunately this prevents nix from caching some of the work it does and often results in it recalculating for each supported system when it would otherwise be cached and take no time at all. * Add an overlay to replace `evalPackages`. This works, but it is not straight forward. * Materialize the nix files for the project. This change allows `evalSystem = "x86_64-linux";` to be passed telling `haskell.nix` to run `cabal` and `nix-tools` on that system. The user will have to have a builder for that system, but does not need to have builders for the others (unless building outputs for them).
2022-07-28 11:03:05 +03:00
, evalPackages ? import nixpkgs nixpkgsArgs
Fix caching of `check-hydra` script (#1340) Gets hydra from 21.05 for now
2022-01-08 13:35:26 +03:00
, nixpkgsForHydra ? haskellNix.sources.nixpkgs-2105
Add `evalSystem` and `evalPackages` project args (#1546) This adds a way to specify the `evalSystem` or `evalPackages` explicitly when calling the `project` functions. Currently if we want to make a `flake` that supports multiple systems we have few options: * Require builders for all the supported systems (even just for `nix flake show`). * Pass `--impure` so that haskell.nix can see `builtins.currentSystem` to set up `pkgs.evalPackages` to use that. Unfortunately this prevents nix from caching some of the work it does and often results in it recalculating for each supported system when it would otherwise be cached and take no time at all. * Add an overlay to replace `evalPackages`. This works, but it is not straight forward. * Materialize the nix files for the project. This change allows `evalSystem = "x86_64-linux";` to be passed telling `haskell.nix` to run `cabal` and `nix-tools` on that system. The user will have to have a builder for that system, but does not need to have builders for the others (unless building outputs for them).
2022-07-28 11:03:05 +03:00
, pkgsForHydra ? import nixpkgsForHydra (nixpkgsArgs // { inherit (pkgs) system; })
Replace collectRunComponents with haskellLib.check (#316) This change replaces `passthru.run` and `collectRunComponents` with `haskellLib.check` and `$pkg.checks`. Uses `ln -s` instead of `cp` for DLLs to avoid duplicating them. Adds features to help debugging eval issues with haskell.nix/release.nix. The ifdInputLevel can be set to limit the jobs included to control how much work is done at the eval stage when looking for issues. Reduce CI times by excluding older ghc versions from haskellNixRoots (GHC 8.6.3 and 8.6.4) Sets `preferLocalBuild=false` on `callCabalProjectToNix` and `callStackToNix` to ensure they are cached on hydra for both Linux and macOS. Fix `data-dir:` when cleaning components. `normalizeRelativeDir` adds a slash on to the end of `dataDir`. Adding another one here results in `//` and files are left out by mistake.
2019-11-29 13:28:47 +03:00
, ifdLevel ? 1000
Remove internal deps on default ghc and stackage (#738) Changes to the interface of haskell.nix (from the changelog.md file): * Removed `sources.nixpkgs-default`, use `sources.nixpkgs` instead. * Removed `./nixpkgs` directory, use `(import ./. {}).sources` or `./nix/sources.nix` instead. * Removes V1 interface for details on how to fix old code see: https://github.com/input-output-hk/haskell.nix/issues/709 * Removed defaultCompilerNixName. * cabalProject, cabalProject', hackage-project and hackage-package now require a `compiler-nix-name` argument. * `haskell-nix.tool` and `.tools` now require a `compiler-nix-name` argument. New functions `p.tool` and `p.tools` (where p is a project) do not. Like `shellFor { tools = ... }` they will use the compiler nix name from the project (including stack projects where it is derived from the resolver). * `haskell-nix.alex` and `haskell-nix.happy` have been removed. Use `p.tool "alex" "3.2.5"` or `shellFor { tools = { alex = "3.2.5"; } }`. * `haskell-nix.nix-tools` -> `haskell-nix.nix-tools.ghc883` (it includes the hpack exe now). * `haskell-nix.cabal-install` -> `p.tool "cabal" "3.2.0.0"` or `shellFor { tools = { cabal = "3.2.0.0"; } }` * `haskell-nix.haskellNixRoots` -> `haskell-nix.roots ghc883` or `p.roots` Other changes: Adds hpack executable to the nix-tools derivations. Adds a `cabal-hpack` test to make sure `hpack` works with `cabalProject`. Reduces the number of calls to `cabalProject` (particularly when checking materialization), by giving internal tools a per-compiler attribute. Uses happy 1.19.12 when building newer ghc versions. Updates cabal-install 3.2.0.0 to use the source from github that is compatible with ghc 8.10.1. Updates the docs for callCabalProjectToNix. Adds a license mapping to fix a common warning.
2020-07-08 13:54:01 +03:00
, compiler-nix-name ? throw "No `compiler-nix-name` passed to build.nix"
Use release-lib.nix for Hydra (#161) * Use release-lib.nix for Hydra jobset * Buildkite: Add a script to check Hydra evaluation
2019-06-03 06:26:28 +03:00
}:
let
Overlays (#261) The Overlays branch This is a major reorganization in how haskell.nix is used, and marks our 1.0 release. The branch doesn't build due to numerous issues that we believe to be with the CI and not this branch. We expect only very minor adjustments prior to calling this the official 1.0 release. * Move iohk-nix patches into haskell.nix This moves the customizations we did in iohk-nix into haskell.nix via overlays and config. Add bootPkgs logic this moves the nuking of bootPkgs where it belongs. This should eventually still be removed and replaced by a proper solution, that doesn't require the nuking of bootPkgs. Allow us to bootstrap binary ghcs and a cabal-install With this we can do the following: ``` $ nix repl compiler/old-ghc-nix nix-repl> :b (let pkgs = import <nixpkgs> {}; in with import ./. {}; import ./compiler/bootstrap/cabal-install.nix { inherit (pkgs) fetchurl stdenv zlib; inherit hackage ; ghc = ghc844; src = pkgs.fetchurl { url = "https://github.com/haskell/cabal/archive/Cabal-v3.0.0.0-rc3.tar.gz"; sha256 = "1zl2mgg8307ykq3v8nmafc6zdhhj1cw7w8ffpap16dsm6 5lbnx33"; }; }) ``` which wile it may look daunting, will allow us to bootstrap a cabal-install with a ghc. From that point onwards, we should be able to build any hackage package via haskell.nix. Pass through cabal-install version Better threading of arguments. Add bootstrap overlay Allow alex + happy to be built This still has a wart: we need nix-tools, and for that we use the ghc865 from nixpkgs. Ideally we'd build nix-tools against a specific ghc, but then we'd need a build expression for that. Make ghcjs work Building something like this: ``` nix build '(with import ./. { nixpkgs = ../nixpkgs; nixpkgsArgs = { crossSystem = { config = "js-unknown-ghcjs"; }; }; }; (haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; })).components.exes.hello' ``` will now work. Assuming `nixpkgs` has been appropriately patched to support the `js-unknown-ghcjs` triple. Also: this will need an additional `Cabal` patch, to make `Cabal` understand what it needs to do with: `dist/build/hello/hello: copyFile: does not exist (No such file or directory)` It needs to learn that `dist/build/hello/hello.jsexe` is what it wants to copy and that that is a directory. Luckily we do have some code in Cabal already that does this for `.exe` on windows. Build `js-unknown-ghcjs` packages with haskell.nix Using the following expression: ``` with import ./. { nixpkgs = ../nixpkgs; nixpkgsArgs = { crossSystem = { config = "js-unknown-ghcjs"; }; }; }; let Cabal = buildPackages.haskell-nix.hackage-package { name = "Cabal"; version = "2.4.1.0"; modules = [ { packages.Cabal.patches = [ ./Cabal-install-folder.diff ]; } ]; }; in (haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; modules = [ ({config, ... }:{ packages.hello.package.setup-depends = [ Cabal ]; }) ];}).components.exes.hello ``` in a `test.nix` file. And running ``` nix build -f ./test.nix ``` on it, will produce ``` ./result ├── bin │ └── hello.jsexe │ ├── all.js │ ├── all.js.externs │ ├── index.html │ ├── lib.js │ ├── manifest.webapp │ ├── out.frefs.js │ ├── out.frefs.json │ ├── out.js │ ├── out.stats │ ├── rts.js │ └── runmain.js └── share └── doc └── x86_64-linux-ghc-8.6.5 └── hello-1.0.0.2 └── LICENSE 6 directories, 12 files ```
2019-10-21 15:07:58 +03:00
haskell = pkgs.haskell-nix;
Update tools that are built on the test servers (#659) Now that we are enumerating ghc versions in ci.nix we do not need to do it in build.nix. Also adds ghcide 0.2.0 so it will be cahced. ghcide-object-code is disabled on ghc 8.10.1
2020-06-08 02:58:06 +03:00
buildHaskell = pkgs.buildPackages.haskell-nix;
tool = buildHaskell.tool;
Test setup deps issue depending on ghc and Cabal (#278) Projects like asterius and leksah that include dependencies on ghc. Sometimes the are needed by a setup.hs file (as is the case for the binaryen package used by asterius). The recent overlays merge broke this and #279 was needed to allow reinstallableLibGhc to be used to fix it. This PR adds a test case to make sure it is not inadvertently broken again. Also gives us a place to try out better ways to make this type of package work.* Test setup deps issue depending on ghc and Cabal * Uses nixpkgs 19.09 + macOS wine fix on hydra/buildkite * Enables macOS hydra tests * disables musl tests for now * Adds haskellNixRoots to tests * Uses reinstallableLibGhc to fix the new setup-depends test * Adds meta.platforms to haskell.nix components * Set meta.platforms on cabal-install * Builds some maintainer-scripts on hydra * Pins hackage index-state for ghc-extra-packages
2019-11-01 02:34:10 +03:00
in rec {
Add `evalSystem` and `evalPackages` project args (#1546) This adds a way to specify the `evalSystem` or `evalPackages` explicitly when calling the `project` functions. Currently if we want to make a `flake` that supports multiple systems we have few options: * Require builders for all the supported systems (even just for `nix flake show`). * Pass `--impure` so that haskell.nix can see `builtins.currentSystem` to set up `pkgs.evalPackages` to use that. Unfortunately this prevents nix from caching some of the work it does and often results in it recalculating for each supported system when it would otherwise be cached and take no time at all. * Add an overlay to replace `evalPackages`. This works, but it is not straight forward. * Materialize the nix files for the project. This change allows `evalSystem = "x86_64-linux";` to be passed telling `haskell.nix` to run `cabal` and `nix-tools` on that system. The user will have to have a builder for that system, but does not need to have builders for the others (unless building outputs for them).
2022-07-28 11:03:05 +03:00
tests = import ./test/default.nix { inherit pkgs evalPackages ifdLevel compiler-nix-name; };
Use release-lib.nix for Hydra (#161) * Use release-lib.nix for Hydra jobset * Buildkite: Add a script to check Hydra evaluation
2019-06-03 06:26:28 +03:00
Update tools that are built on the test servers (#659) Now that we are enumerating ghc versions in ci.nix we do not need to do it in build.nix. Also adds ghcide 0.2.0 so it will be cahced. ghcide-object-code is disabled on ghc 8.10.1
2020-06-08 02:58:06 +03:00
tools = pkgs.lib.optionalAttrs (ifdLevel >= 3) (
Add GHC 9.0.1 (#1032) Also refactors the way tests are filtered to use `meta.disabled` where possible.
2021-03-28 11:03:20 +03:00
pkgs.recurseIntoAttrs ({
Add `evalSystem` and `evalPackages` project args (#1546) This adds a way to specify the `evalSystem` or `evalPackages` explicitly when calling the `project` functions. Currently if we want to make a `flake` that supports multiple systems we have few options: * Require builders for all the supported systems (even just for `nix flake show`). * Pass `--impure` so that haskell.nix can see `builtins.currentSystem` to set up `pkgs.evalPackages` to use that. Unfortunately this prevents nix from caching some of the work it does and often results in it recalculating for each supported system when it would otherwise be cached and take no time at all. * Add an overlay to replace `evalPackages`. This works, but it is not straight forward. * Materialize the nix files for the project. This change allows `evalSystem = "x86_64-linux";` to be passed telling `haskell.nix` to run `cabal` and `nix-tools` on that system. The user will have to have a builder for that system, but does not need to have builders for the others (unless building outputs for them).
2022-07-28 11:03:05 +03:00
cabal-latest = tool compiler-nix-name "cabal" { inherit evalPackages; };
Add ghc 9.2.3 (#1491) Also: * Updates the GHC's built on CI * Use Cabal 3.6.2.0 for default Setup * Fixes haskell-language-server and hlint on CI
2022-06-01 10:33:58 +03:00
hlint-latest = tool compiler-nix-name "hlint" {
Add `evalSystem` and `evalPackages` project args (#1546) This adds a way to specify the `evalSystem` or `evalPackages` explicitly when calling the `project` functions. Currently if we want to make a `flake` that supports multiple systems we have few options: * Require builders for all the supported systems (even just for `nix flake show`). * Pass `--impure` so that haskell.nix can see `builtins.currentSystem` to set up `pkgs.evalPackages` to use that. Unfortunately this prevents nix from caching some of the work it does and often results in it recalculating for each supported system when it would otherwise be cached and take no time at all. * Add an overlay to replace `evalPackages`. This works, but it is not straight forward. * Materialize the nix files for the project. This change allows `evalSystem = "x86_64-linux";` to be passed telling `haskell.nix` to run `cabal` and `nix-tools` on that system. The user will have to have a builder for that system, but does not need to have builders for the others (unless building outputs for them).
2022-07-28 11:03:05 +03:00
inherit evalPackages;
Add ghc 9.2.3 (#1491) Also: * Updates the GHC's built on CI * Use Cabal 3.6.2.0 for default Setup * Fixes haskell-language-server and hlint on CI
2022-06-01 10:33:58 +03:00
version = {
"ghc865" = "3.2.8";
"ghc882" = "3.3.6";
"ghc883" = "3.3.6";
"ghc884" = "3.3.6";
}.compiler-nix-name or "latest";
};
Add ghc 9.2.4 (#1566)
2022-07-31 12:41:50 +03:00
} // pkgs.lib.optionalAttrs (!__elem compiler-nix-name ["ghc921" "ghc922" "ghc923" "ghc924"]) {
Add `evalSystem` and `evalPackages` project args (#1546) This adds a way to specify the `evalSystem` or `evalPackages` explicitly when calling the `project` functions. Currently if we want to make a `flake` that supports multiple systems we have few options: * Require builders for all the supported systems (even just for `nix flake show`). * Pass `--impure` so that haskell.nix can see `builtins.currentSystem` to set up `pkgs.evalPackages` to use that. Unfortunately this prevents nix from caching some of the work it does and often results in it recalculating for each supported system when it would otherwise be cached and take no time at all. * Add an overlay to replace `evalPackages`. This works, but it is not straight forward. * Materialize the nix files for the project. This change allows `evalSystem = "x86_64-linux";` to be passed telling `haskell.nix` to run `cabal` and `nix-tools` on that system. The user will have to have a builder for that system, but does not need to have builders for the others (unless building outputs for them).
2022-07-28 11:03:05 +03:00
hls-latest = tool compiler-nix-name "haskell-language-server" { inherit evalPackages; };
Add GHC 9.0.1 (#1032) Also refactors the way tests are filtered to use `meta.disabled` where possible.
2021-03-28 11:03:20 +03:00
})
Update tools that are built on the test servers (#659) Now that we are enumerating ghc versions in ci.nix we do not need to do it in build.nix. Also adds ghcide 0.2.0 so it will be cahced. ghcide-object-code is disabled on ghc 8.10.1
2020-06-08 02:58:06 +03:00
);
Make it easier to access executable components (#565) This overlay helps accessing common executable components. Typically we want to make these available in a nix-shell created with shellFor. In most cases the package name will be the same as the executable, but we have a `toolPackageName` mapping to help when it is not. ``` # To get a single tool: haskell-nix.tool "cabal" "3.2.0.0" # This does the same thing as: (haskell-nix.hackage-package { name = "cabal-install" version = "3.2.0.0" }).components.exes.cabal # To get an attr set containing multiple tools: haskell-nix.tools { cabal = "3.2.0.0"; hlint = "2.2.11"; } # To add tools to a shell: shellFor { tools = { cabal = "3.2.0.0"; hlint = "2.2.11"; }; } ``` When used in shellFor the tools will be compiled with the same version of ghc used in the shell (the build ghc in the case of cross compilation). Instead of a version string we can use an attr set containing arguments that will be passed to `cabalProject`. For instance to specify the ghc used to compile. Use: ``` haskell-nix.tool "cabal" { version = "3.2.0.0"; ghc = haskell-nix.compiler.ghc883; } ```
2020-04-29 10:10:14 +03:00
Use release-lib.nix for Hydra (#161) * Use release-lib.nix for Hydra jobset * Buildkite: Add a script to check Hydra evaluation
2019-06-03 06:26:28 +03:00
# Scripts for keeping Hackage and Stackage up to date, and CI tasks.
Test setup deps issue depending on ghc and Cabal (#278) Projects like asterius and leksah that include dependencies on ghc. Sometimes the are needed by a setup.hs file (as is the case for the binaryen package used by asterius). The recent overlays merge broke this and #279 was needed to allow reinstallableLibGhc to be used to fix it. This PR adds a test case to make sure it is not inadvertently broken again. Also gives us a place to try out better ways to make this type of package work.* Test setup deps issue depending on ghc and Cabal * Uses nixpkgs 19.09 + macOS wine fix on hydra/buildkite * Enables macOS hydra tests * disables musl tests for now * Adds haskellNixRoots to tests * Uses reinstallableLibGhc to fix the new setup-depends test * Adds meta.platforms to haskell.nix components * Set meta.platforms on cabal-install * Builds some maintainer-scripts on hydra * Pins hackage index-state for ghc-extra-packages
2019-11-01 02:34:10 +03:00
# The dontRecurseIntoAttrs prevents these from building on hydra
# as not all of them can work in restricted eval mode (as they
# are not pure).
Use release-lib.nix for Hydra (#161) * Use release-lib.nix for Hydra jobset * Buildkite: Add a script to check Hydra evaluation
2019-06-03 06:26:28 +03:00
maintainer-scripts = pkgs.dontRecurseIntoAttrs {
Remove internal deps on default ghc and stackage (#738) Changes to the interface of haskell.nix (from the changelog.md file): * Removed `sources.nixpkgs-default`, use `sources.nixpkgs` instead. * Removed `./nixpkgs` directory, use `(import ./. {}).sources` or `./nix/sources.nix` instead. * Removes V1 interface for details on how to fix old code see: https://github.com/input-output-hk/haskell.nix/issues/709 * Removed defaultCompilerNixName. * cabalProject, cabalProject', hackage-project and hackage-package now require a `compiler-nix-name` argument. * `haskell-nix.tool` and `.tools` now require a `compiler-nix-name` argument. New functions `p.tool` and `p.tools` (where p is a project) do not. Like `shellFor { tools = ... }` they will use the compiler nix name from the project (including stack projects where it is derived from the resolver). * `haskell-nix.alex` and `haskell-nix.happy` have been removed. Use `p.tool "alex" "3.2.5"` or `shellFor { tools = { alex = "3.2.5"; } }`. * `haskell-nix.nix-tools` -> `haskell-nix.nix-tools.ghc883` (it includes the hpack exe now). * `haskell-nix.cabal-install` -> `p.tool "cabal" "3.2.0.0"` or `shellFor { tools = { cabal = "3.2.0.0"; } }` * `haskell-nix.haskellNixRoots` -> `haskell-nix.roots ghc883` or `p.roots` Other changes: Adds hpack executable to the nix-tools derivations. Adds a `cabal-hpack` test to make sure `hpack` works with `cabalProject`. Reduces the number of calls to `cabalProject` (particularly when checking materialization), by giving internal tools a per-compiler attribute. Uses happy 1.19.12 when building newer ghc versions. Updates cabal-install 3.2.0.0 to use the source from github that is compatible with ghc 8.10.1. Updates the docs for callCabalProjectToNix. Adds a license mapping to fix a common warning.
2020-07-08 13:54:01 +03:00
update-hackage = import ./scripts/update-hackage.nix {
Use `pkgs.lib` instead of `stdenv.lib` (#1031) Fixes: Warning: `stdenv.lib` is deprecated and will be removed in the next release. Please use `pkgs.lib` instead. For more information see https://github.com/NixOS/nixpkgs/issues/108938
2021-02-10 15:07:16 +03:00
inherit (pkgs) stdenv lib writeScript coreutils glibc git
Flakify all inputs (#1180) * Include dependencies of haskell.nix that were tracked in `nix/sources.json` as flake inputs (`flake.lock` replaces `nix/sources.json`). * Use `flake-compat` to continue to provide a compatible interface for non flake projects. Co-authored-by: Alexander Bantyev <balsoft@balsoft.ru> Co-authored-by: Shea Levy <shea@shealevy.com>
2021-08-06 06:54:39 +03:00
openssh nixFlakes gawk bash curl findutils;
Remove internal deps on default ghc and stackage (#738) Changes to the interface of haskell.nix (from the changelog.md file): * Removed `sources.nixpkgs-default`, use `sources.nixpkgs` instead. * Removed `./nixpkgs` directory, use `(import ./. {}).sources` or `./nix/sources.nix` instead. * Removes V1 interface for details on how to fix old code see: https://github.com/input-output-hk/haskell.nix/issues/709 * Removed defaultCompilerNixName. * cabalProject, cabalProject', hackage-project and hackage-package now require a `compiler-nix-name` argument. * `haskell-nix.tool` and `.tools` now require a `compiler-nix-name` argument. New functions `p.tool` and `p.tools` (where p is a project) do not. Like `shellFor { tools = ... }` they will use the compiler nix name from the project (including stack projects where it is derived from the resolver). * `haskell-nix.alex` and `haskell-nix.happy` have been removed. Use `p.tool "alex" "3.2.5"` or `shellFor { tools = { alex = "3.2.5"; } }`. * `haskell-nix.nix-tools` -> `haskell-nix.nix-tools.ghc883` (it includes the hpack exe now). * `haskell-nix.cabal-install` -> `p.tool "cabal" "3.2.0.0"` or `shellFor { tools = { cabal = "3.2.0.0"; } }` * `haskell-nix.haskellNixRoots` -> `haskell-nix.roots ghc883` or `p.roots` Other changes: Adds hpack executable to the nix-tools derivations. Adds a `cabal-hpack` test to make sure `hpack` works with `cabalProject`. Reduces the number of calls to `cabalProject` (particularly when checking materialization), by giving internal tools a per-compiler attribute. Uses happy 1.19.12 when building newer ghc versions. Updates cabal-install 3.2.0.0 to use the source from github that is compatible with ghc 8.10.1. Updates the docs for callCabalProjectToNix. Adds a license mapping to fix a common warning.
2020-07-08 13:54:01 +03:00
# Update scripts use the internal nix-tools and cabal-install (compiled with a fixed GHC version)
nix-tools = haskell.internal-nix-tools;
cabal-install = haskell.internal-cabal-install;
inherit (haskell) update-index-state-hashes;
};
update-stackage = haskell.callPackage ./scripts/update-stackage.nix {
Use `pkgs.lib` instead of `stdenv.lib` (#1031) Fixes: Warning: `stdenv.lib` is deprecated and will be removed in the next release. Please use `pkgs.lib` instead. For more information see https://github.com/NixOS/nixpkgs/issues/108938
2021-02-10 15:07:16 +03:00
inherit (pkgs) stdenv lib writeScript coreutils glibc git
Flakify all inputs (#1180) * Include dependencies of haskell.nix that were tracked in `nix/sources.json` as flake inputs (`flake.lock` replaces `nix/sources.json`). * Use `flake-compat` to continue to provide a compatible interface for non flake projects. Co-authored-by: Alexander Bantyev <balsoft@balsoft.ru> Co-authored-by: Shea Levy <shea@shealevy.com>
2021-08-06 06:54:39 +03:00
openssh nixFlakes gawk bash curl findutils;
Remove internal deps on default ghc and stackage (#738) Changes to the interface of haskell.nix (from the changelog.md file): * Removed `sources.nixpkgs-default`, use `sources.nixpkgs` instead. * Removed `./nixpkgs` directory, use `(import ./. {}).sources` or `./nix/sources.nix` instead. * Removes V1 interface for details on how to fix old code see: https://github.com/input-output-hk/haskell.nix/issues/709 * Removed defaultCompilerNixName. * cabalProject, cabalProject', hackage-project and hackage-package now require a `compiler-nix-name` argument. * `haskell-nix.tool` and `.tools` now require a `compiler-nix-name` argument. New functions `p.tool` and `p.tools` (where p is a project) do not. Like `shellFor { tools = ... }` they will use the compiler nix name from the project (including stack projects where it is derived from the resolver). * `haskell-nix.alex` and `haskell-nix.happy` have been removed. Use `p.tool "alex" "3.2.5"` or `shellFor { tools = { alex = "3.2.5"; } }`. * `haskell-nix.nix-tools` -> `haskell-nix.nix-tools.ghc883` (it includes the hpack exe now). * `haskell-nix.cabal-install` -> `p.tool "cabal" "3.2.0.0"` or `shellFor { tools = { cabal = "3.2.0.0"; } }` * `haskell-nix.haskellNixRoots` -> `haskell-nix.roots ghc883` or `p.roots` Other changes: Adds hpack executable to the nix-tools derivations. Adds a `cabal-hpack` test to make sure `hpack` works with `cabalProject`. Reduces the number of calls to `cabalProject` (particularly when checking materialization), by giving internal tools a per-compiler attribute. Uses happy 1.19.12 when building newer ghc versions. Updates cabal-install 3.2.0.0 to use the source from github that is compatible with ghc 8.10.1. Updates the docs for callCabalProjectToNix. Adds a license mapping to fix a common warning.
2020-07-08 13:54:01 +03:00
# Update scripts use the internal nix-tools and cabal-install (compiled with a fixed GHC version)
nix-tools = haskell.internal-nix-tools;
cabal-install = haskell.internal-cabal-install;
};
Use release-lib.nix for Hydra (#161) * Use release-lib.nix for Hydra jobset * Buildkite: Add a script to check Hydra evaluation
2019-06-03 06:26:28 +03:00
update-pins = haskell.callPackage ./scripts/update-pins.nix {};
Run the cross compiled tests on wine (#317) Changes to the haskell.nix code to fix broken tests: * Add missing `then` to `call-cabal-project-to-nix.nix`. * Fix default `hsSourceDirs` so that `.` gets included for `.all` component if one of the components does not have a `hsSourceDir` set. * Fix `haskellNixRoots` so it works when cross compiling to windows. Improvements to the haskell.nix tests: * Run haskell.nix tests of nixpkgs 19.03 and 19.09. * Run haskell.nix tests cross compiled to Windows under Wine (when possible). * Add nix used as IFD inputs as tests to ensure they are cached. * Use `haskell-nix.cabal-install` instead of `nixpkgs.cabal-install` in tests.
2019-11-20 03:47:15 +03:00
update-docs = pkgs.buildPackages.callPackage ./scripts/update-docs.nix {
Update nixpkgs pins to include 20.03 (#557) * Update nixpkgs pins to include 20.03, wobble - Add 20.03 - Remove 19.03 (and old 18.09 file) - Update 19.09 to latest - Update github pin to 20.03 - Remove workarounds for 19.03 * Mark openssl as allowedInsecure * Force python3 for mkdocs
2020-04-28 17:49:36 +03:00
generatedOptions = pkgs.callPackage ./scripts/options-doc.nix { };
More documentation (#179) * docs: Fix notes about .nix-tools.cache Relates to #57 * docs: Add note about Cabal 2.4 requirement Fixes #164 * docs: Autogenerate module option reference * docs: Update library reference * Buildkite: enable docs build on branches
2019-06-15 08:11:52 +03:00
};
Replace collectRunComponents with haskellLib.check (#316) This change replaces `passthru.run` and `collectRunComponents` with `haskellLib.check` and `$pkg.checks`. Uses `ln -s` instead of `cp` for DLLs to avoid duplicating them. Adds features to help debugging eval issues with haskell.nix/release.nix. The ifdInputLevel can be set to limit the jobs included to control how much work is done at the eval stage when looking for issues. Reduce CI times by excluding older ghc versions from haskellNixRoots (GHC 8.6.3 and 8.6.4) Sets `preferLocalBuild=false` on `callCabalProjectToNix` and `callStackToNix` to ensure they are cached on hydra for both Linux and macOS. Fix `data-dir:` when cleaning components. `normalizeRelativeDir` adds a slash on to the end of `dataDir`. Adding another one here results in `//` and files are left out by mistake.
2019-11-29 13:28:47 +03:00
# Because this is going to be used to test caching on hydra, it must not
# use the darcs package from the haskell.nix we are testing. For that reason
# it uses `pkgs.buildPackages.callPackage` not `haskell.callPackage`
# (We could pull in darcs from a known good haskell.nix for hydra to
# use)
Fix caching of `check-hydra` script (#1340) Gets hydra from 21.05 for now
2022-01-08 13:35:26 +03:00
check-hydra = pkgsForHydra.buildPackages.callPackage ./scripts/check-hydra.nix {};
Run the cross compiled tests on wine (#317) Changes to the haskell.nix code to fix broken tests: * Add missing `then` to `call-cabal-project-to-nix.nix`. * Fix default `hsSourceDirs` so that `.` gets included for `.all` component if one of the components does not have a `hsSourceDir` set. * Fix `haskellNixRoots` so it works when cross compiling to windows. Improvements to the haskell.nix tests: * Run haskell.nix tests of nixpkgs 19.03 and 19.09. * Run haskell.nix tests cross compiled to Windows under Wine (when possible). * Add nix used as IFD inputs as tests to ensure they are cached. * Use `haskell-nix.cabal-install` instead of `nixpkgs.cabal-install` in tests.
2019-11-20 03:47:15 +03:00
check-closure-size = pkgs.buildPackages.callPackage ./scripts/check-closure-size.nix {
Remove internal deps on default ghc and stackage (#738) Changes to the interface of haskell.nix (from the changelog.md file): * Removed `sources.nixpkgs-default`, use `sources.nixpkgs` instead. * Removed `./nixpkgs` directory, use `(import ./. {}).sources` or `./nix/sources.nix` instead. * Removes V1 interface for details on how to fix old code see: https://github.com/input-output-hk/haskell.nix/issues/709 * Removed defaultCompilerNixName. * cabalProject, cabalProject', hackage-project and hackage-package now require a `compiler-nix-name` argument. * `haskell-nix.tool` and `.tools` now require a `compiler-nix-name` argument. New functions `p.tool` and `p.tools` (where p is a project) do not. Like `shellFor { tools = ... }` they will use the compiler nix name from the project (including stack projects where it is derived from the resolver). * `haskell-nix.alex` and `haskell-nix.happy` have been removed. Use `p.tool "alex" "3.2.5"` or `shellFor { tools = { alex = "3.2.5"; } }`. * `haskell-nix.nix-tools` -> `haskell-nix.nix-tools.ghc883` (it includes the hpack exe now). * `haskell-nix.cabal-install` -> `p.tool "cabal" "3.2.0.0"` or `shellFor { tools = { cabal = "3.2.0.0"; } }` * `haskell-nix.haskellNixRoots` -> `haskell-nix.roots ghc883` or `p.roots` Other changes: Adds hpack executable to the nix-tools derivations. Adds a `cabal-hpack` test to make sure `hpack` works with `cabalProject`. Reduces the number of calls to `cabalProject` (particularly when checking materialization), by giving internal tools a per-compiler attribute. Uses happy 1.19.12 when building newer ghc versions. Updates cabal-install 3.2.0.0 to use the source from github that is compatible with ghc 8.10.1. Updates the docs for callCabalProjectToNix. Adds a license mapping to fix a common warning.
2020-07-08 13:54:01 +03:00
# Includes cabal-install since this is commonly used.
Add cabal-install and hpack to closure size check (#645)
2020-06-02 07:45:54 +03:00
nix-tools = pkgs.linkFarm "common-tools" [
Remove internal deps on default ghc and stackage (#738) Changes to the interface of haskell.nix (from the changelog.md file): * Removed `sources.nixpkgs-default`, use `sources.nixpkgs` instead. * Removed `./nixpkgs` directory, use `(import ./. {}).sources` or `./nix/sources.nix` instead. * Removes V1 interface for details on how to fix old code see: https://github.com/input-output-hk/haskell.nix/issues/709 * Removed defaultCompilerNixName. * cabalProject, cabalProject', hackage-project and hackage-package now require a `compiler-nix-name` argument. * `haskell-nix.tool` and `.tools` now require a `compiler-nix-name` argument. New functions `p.tool` and `p.tools` (where p is a project) do not. Like `shellFor { tools = ... }` they will use the compiler nix name from the project (including stack projects where it is derived from the resolver). * `haskell-nix.alex` and `haskell-nix.happy` have been removed. Use `p.tool "alex" "3.2.5"` or `shellFor { tools = { alex = "3.2.5"; } }`. * `haskell-nix.nix-tools` -> `haskell-nix.nix-tools.ghc883` (it includes the hpack exe now). * `haskell-nix.cabal-install` -> `p.tool "cabal" "3.2.0.0"` or `shellFor { tools = { cabal = "3.2.0.0"; } }` * `haskell-nix.haskellNixRoots` -> `haskell-nix.roots ghc883` or `p.roots` Other changes: Adds hpack executable to the nix-tools derivations. Adds a `cabal-hpack` test to make sure `hpack` works with `cabalProject`. Reduces the number of calls to `cabalProject` (particularly when checking materialization), by giving internal tools a per-compiler attribute. Uses happy 1.19.12 when building newer ghc versions. Updates cabal-install 3.2.0.0 to use the source from github that is compatible with ghc 8.10.1. Updates the docs for callCabalProjectToNix. Adds a license mapping to fix a common warning.
2020-07-08 13:54:01 +03:00
{ name = "nix-tools"; path = haskell.nix-tools.${compiler-nix-name}; }
{ name = "cabal-install"; path = haskell.cabal-install.${compiler-nix-name}; }
Add cabal-install and hpack to closure size check (#645)
2020-06-02 07:45:54 +03:00
];
Run the cross compiled tests on wine (#317) Changes to the haskell.nix code to fix broken tests: * Add missing `then` to `call-cabal-project-to-nix.nix`. * Fix default `hsSourceDirs` so that `.` gets included for `.all` component if one of the components does not have a `hsSourceDir` set. * Fix `haskellNixRoots` so it works when cross compiling to windows. Improvements to the haskell.nix tests: * Run haskell.nix tests of nixpkgs 19.03 and 19.09. * Run haskell.nix tests cross compiled to Windows under Wine (when possible). * Add nix used as IFD inputs as tests to ensure they are cached. * Use `haskell-nix.cabal-install` instead of `nixpkgs.cabal-install` in tests.
2019-11-20 03:47:15 +03:00
};
Check that materialize does not limit concurrency (#699) Adding materialize call to a derivation should not prevent nix form building it concurrently with other derivations. This test makes sure that is the case.
2020-06-16 12:02:37 +03:00
check-materialization-concurrency = pkgs.buildPackages.callPackage ./scripts/check-materialization-concurrency/check.nix {};
Remove `canCleanSource` (#1409) In recent nix, builtins.path works in restricted eval mode. Therefore canCleanSource is not required anymore. follow up on #1403 * add comment on hydra overlay * throw error on outdated nix version
2022-03-25 02:57:36 +03:00
check-path-support = pkgs.buildPackages.callPackage ./scripts/check-path-support.nix {
# TODO remove this when nixpkgs-2205 is released and used for `pkgs`
# check-path-support fails unless we have nix 2.4 or newer.
inherit (import haskellNix.sources.nixpkgs-unstable {}) nix;
};
Use release-lib.nix for Hydra (#161) * Use release-lib.nix for Hydra jobset * Buildkite: Add a script to check Hydra evaluation
2019-06-03 06:26:28 +03:00
};
Test setup deps issue depending on ghc and Cabal (#278) Projects like asterius and leksah that include dependencies on ghc. Sometimes the are needed by a setup.hs file (as is the case for the binaryen package used by asterius). The recent overlays merge broke this and #279 was needed to allow reinstallableLibGhc to be used to fix it. This PR adds a test case to make sure it is not inadvertently broken again. Also gives us a place to try out better ways to make this type of package work.* Test setup deps issue depending on ghc and Cabal * Uses nixpkgs 19.09 + macOS wine fix on hydra/buildkite * Enables macOS hydra tests * disables musl tests for now * Adds haskellNixRoots to tests * Uses reinstallableLibGhc to fix the new setup-depends test * Adds meta.platforms to haskell.nix components * Set meta.platforms on cabal-install * Builds some maintainer-scripts on hydra * Pins hackage index-state for ghc-extra-packages
2019-11-01 02:34:10 +03:00
# These are pure parts of maintainer-script so they can be built by hydra
# and added to the cache to speed up buildkite.
Replace collectRunComponents with haskellLib.check (#316) This change replaces `passthru.run` and `collectRunComponents` with `haskellLib.check` and `$pkg.checks`. Uses `ln -s` instead of `cp` for DLLs to avoid duplicating them. Adds features to help debugging eval issues with haskell.nix/release.nix. The ifdInputLevel can be set to limit the jobs included to control how much work is done at the eval stage when looking for issues. Reduce CI times by excluding older ghc versions from haskellNixRoots (GHC 8.6.3 and 8.6.4) Sets `preferLocalBuild=false` on `callCabalProjectToNix` and `callStackToNix` to ensure they are cached on hydra for both Linux and macOS. Fix `data-dir:` when cleaning components. `normalizeRelativeDir` adds a slash on to the end of `dataDir`. Adding another one here results in `//` and files are left out by mistake.
2019-11-29 13:28:47 +03:00
maintainer-script-cache = pkgs.recurseIntoAttrs (
Add `evalSystem` and `evalPackages` project args (#1546) This adds a way to specify the `evalSystem` or `evalPackages` explicitly when calling the `project` functions. Currently if we want to make a `flake` that supports multiple systems we have few options: * Require builders for all the supported systems (even just for `nix flake show`). * Pass `--impure` so that haskell.nix can see `builtins.currentSystem` to set up `pkgs.evalPackages` to use that. Unfortunately this prevents nix from caching some of the work it does and often results in it recalculating for each supported system when it would otherwise be cached and take no time at all. * Add an overlay to replace `evalPackages`. This works, but it is not straight forward. * Materialize the nix files for the project. This change allows `evalSystem = "x86_64-linux";` to be passed telling `haskell.nix` to run `cabal` and `nix-tools` on that system. The user will have to have a builder for that system, but does not need to have builders for the others (unless building outputs for them).
2022-07-28 11:03:05 +03:00
(pkgs.lib.optionalAttrs (pkgsForHydra.system == "x86_64-linux") {
Replace collectRunComponents with haskellLib.check (#316) This change replaces `passthru.run` and `collectRunComponents` with `haskellLib.check` and `$pkg.checks`. Uses `ln -s` instead of `cp` for DLLs to avoid duplicating them. Adds features to help debugging eval issues with haskell.nix/release.nix. The ifdInputLevel can be set to limit the jobs included to control how much work is done at the eval stage when looking for issues. Reduce CI times by excluding older ghc versions from haskellNixRoots (GHC 8.6.3 and 8.6.4) Sets `preferLocalBuild=false` on `callCabalProjectToNix` and `callStackToNix` to ensure they are cached on hydra for both Linux and macOS. Fix `data-dir:` when cleaning components. `normalizeRelativeDir` adds a slash on to the end of `dataDir`. Adding another one here results in `//` and files are left out by mistake.
2019-11-29 13:28:47 +03:00
inherit (maintainer-scripts) check-hydra;
})
// (pkgs.lib.optionalAttrs (ifdLevel > 2) {
inherit (maintainer-scripts) update-docs check-closure-size;
# Some of the dependencies of the impure scripts so that they will
# will be in the cache too for buildkite.
inherit (pkgs.buildPackages) glibc coreutils git openssh cabal-install nix-prefetch-git;
inherit (haskell) nix-tools;
})
);
Use release-lib.nix for Hydra (#161) * Use release-lib.nix for Hydra jobset * Buildkite: Add a script to check Hydra evaluation
2019-06-03 06:26:28 +03:00
}
Reference in New Issue Copy Permalink