6612d52...master · typeable/nixpkgs-stackage

git.iko.soy/typeable/nixpkgs-stackage

100 files changed+803456−70587

since splitsnapshots

unifiedsplit

.travis.ymlnew file+17

@@ -0,0 +1,17 @@

1+language: nix

3+install:

4+ - mkdir -p ~/.config/nixpkgs/overlays

5+ - ln -s "$(pwd)/default.nix" ~/.config/nixpkgs/overlays/stackage-overlay.nix

7+script:

8+ - nix-build nixpkgs.nix -A stackage2nix --dry-run

10+jobs:

11+ include:

12+ - env: NIXPKGS=pinned

13+ - env: NIXPKGS=unstable

14+ before_script: nix-env -i stackage2nix --dry-run

15+ allow_failures:

16+ - env: NIXPKGS=unstable

17+

README.md+59−8

@@ -1,22 +1,73 @@

1−# Nix

1+# nixpkgs-stackage

3−Nixpgs overlay

3+[![Build Status](https://travis-ci.org/typeable/nixpkgs-stackage.svg?branch=master)](https://travis-ci.org/typeable/nixpkgs-stackage)

5−## Packages

5+Nixpkgs overlay adding Stackage Haskell packages at the `pkgs.haskell.packages.stackage`

7−- Stackage LTS releases

8−- [stackage2nix][]

7+# Install

10−## Install

9+Symlink the current `./default.nix` into the `~/.config/nixpkgs/overlays` folder.

1110

12−Symlink the current `./haskell-overlay.nix` into the `~/.config/nixpkgs/overlays` folder.

11+```

12+cd ~/.config/nixpkgs/overlays

13+ln -s /path/to/default.nix stackage-overlay.nix

14+```

15+

16+## Contents

17+

18+- Stackage LTS releases at `pkgs.haskell.packages.stackage`

19+- [stackage2nix][] at `pkgs`

20+- build utils at `pkgs.haskell.packages.stackage.lib`

1321

1422## Haskell overlay

1523

24+List LTS packages:

25+

26+```

27+nix-env -f '<nixpkgs>' -qaP -A haskell.packages.stackage.lts-100

28+```

29+

1630Install stackage2nix:

1731

1832```

19−$ nix-env -i -f ./stackage2nix

33+$ nix-env -i stackage2nix

34+```

35+

36+## Update script

37+

38+Update script will add missing lts releases to `stackage` directory:

39+

40+```

41+./update.sh

2042```

2143

44+# Examples

45+

46+Build derivation for `stackage2nix` from `stackage2nix.json` source.

47+

48+``` nix

49+let

50+ nixpkgs = import <nixpkgs> {

51+ overlays = [ (import ../default.nix) ];

52+ };

53+ inherit (nixpkgs) pkgs lib;

54+

55+ stackage2nixSrc = pkgs.fetchFromGitHub (lib.importJSON ./stackage2nix.json);

56+

57+ stackage = nixpkgs.haskell.packages.stackage.lib.callStackage2nix "stackage2nix" stackage2nixSrc {

58+ inherit nixpkgs;

59+ };

60+in

61+ stackage

62+```

63+

64+Build:

65+

66+```

67+nix-build example.nix -A stackage2nix

68+```

69+

70+See [examples](./examples) directory for more

71+

72+

2273[stackage2nix]: https://github.com/typeable/stackage2nix

cache-version.txtnew file+1

@@ -0,0 +1 @@

1+2019-05-14

default.nix+68−5

@@ -1,7 +1,70 @@

1−# Nixpkgs overlay which aggregates overlays for tools and products

1+self: super:

3−{ nixpkgs ? import <nixpkgs> {}}:

3+let

5−with nixpkgs.lib;

6−let haskellOverlay = import ./haskell-overlay.nix;

7−in fix (extends haskellOverlay (_: nixpkgs))

5+ # from pkgs/stdenv/generic/make-derivation.nix

6+ # This parameter is sometimes a string, sometimes null, and sometimes a list, yuck

7+ normalizedConfigureFlags = configureFlags: let inherit (super) lib; in

8+ (/**/ if lib.isString configureFlags then [configureFlags]

9+ else if configureFlags == null then []

10+ else configureFlags);

11+

12+ stackage2nixPackages = import ./stackage2nix/stackage-packages.nix { nixpkgs = self; };

13+

14+in {

15+ haskell = super.haskell // {

16+ packages = super.haskell.packages // {

17+ stackage = super.callPackage ./stackage {} // {

18+ lib = super.callPackage ./lib.nix {};

19+ };

20+ };

21+ };

22+

23+ stackage2nix = self.callPackage ./stackage2nix {

24+ drv = super.haskell.lib.disableSharedExecutables stackage2nixPackages.stackage2nix;

25+ };

26+

27+ stackage2nixWrapper = import ./stackage2nix/impure.nix {

28+ cacheVersion = builtins.readFile ./cache-version.txt;

29+ inherit self;

30+ };

31+

32+ stackage2nix-static = import ./stackage2nix/impure.nix {

33+ drv =

34+ let

35+ stackagePackages = import ./stackage2nix/stackage-packages.nix { nixpkgs = self; };

36+ in self.haskell.lib.overrideCabal stackagePackages.stackage2nix (drv: {

37+ enableSharedExecutables = false;

38+ enableSharedLibraries = false;

39+ configureFlags = [

40+ "--ghc-option=-optl=-static"

41+ "--ghc-option=-optl=-L${self.glibc.static}/lib"

42+ "--ghc-option=-optl=-L${self.gmp.override { withStatic = true; }}/lib"

43+ "--ghc-option=-optl=-L${self.icu-static.static}/lib"

44+ "--ghc-option=-optl=-L${self.openssl-static.static}/lib"

45+ "--ghc-option=-optl=-L${self.zlib.static}/lib"

46+ ];

47+ });

48+ cacheVersion = builtins.readFile ./cache-version.txt;

49+ inherit self;

50+ };

51+

52+ icu-static = super.icu.overrideAttrs (attrs: {

53+ dontDisableStatic = true;

54+ configureFlags = normalizedConfigureFlags attrs.configureFlags ++ [ "--enable-static" ];

55+ outputs = attrs.outputs ++ [ "static" ];

56+ postInstall = ''

57+ moveToOutput "lib/*.a" "$static"

58+ '' + (if attrs ? postInstall then attrs.postInstall else "");

59+ });

60+

61+ openssl-static = super.openssl.overrideAttrs (attrs: {

62+ dontDisableStatic = true;

63+ outputs = attrs.outputs ++ [ "static" ];

64+ postInstall = ''

65+ mkdir -p $static/lib;

66+ cp -v *.a $static/lib;

67+ '' + (if attrs ? postInstall then attrs.postInstall else "");

68+ });

69+

70+}

examples/example-override-pinned.nixnew file+16

@@ -0,0 +1,16 @@

1+# Stackage packages with Nixpkgs pinned to specific revision

3+let

4+ nixpkgs = import ./nixpkgs-pinned.nix {};

5+ inherit (nixpkgs) pkgs lib haskell;

7+ stackage2nixSrc = pkgs.fetchFromGitHub (lib.importJSON ./stackage2nix.json);

9+ stackagePackages = haskell.packages.stackage.lib.callStackage2nix "stackage2nix" stackage2nixSrc { inherit nixpkgs; };

10+ stackage = stackagePackages.override {

11+ overrides = self: super: {

12+ stackage2nix = haskell.lib.disableSharedExecutables super.stackage2nix;

13+ };

14+ };

15+in

16+ stackage

examples/example-override.nixnew file+20

@@ -0,0 +1,20 @@

1+# Stackage packages accept `overrides` like Nixpkgs `haskellPackages`

3+let

4+ _pkgs = import <nixpkgs> {};

5+ _stackageOverlay = _pkgs.fetchFromGitHub (_pkgs.lib.importJSON ./nixpkgs-stackage.json);

6+ nixpkgs = import <nixpkgs> {

7+ overlays = [ (import _stackageOverlay) ];

8+ };

9+ inherit (nixpkgs) pkgs lib haskell;

10+

11+ stackage2nixSrc = pkgs.fetchFromGitHub (lib.importJSON ./stackage2nix.json);

12+

13+ stackagePackages = haskell.packages.stackage.lib.callStackage2nix "stackage2nix" stackage2nixSrc { inherit nixpkgs; };

14+ stackage = stackagePackages.override {

15+ overrides = self: super: {

16+ stackage2nix = haskell.lib.disableSharedExecutables super.stackage2nix;

17+ };

18+ };

19+in

20+ stackage

examples/example.nixnew file+16

@@ -0,0 +1,16 @@

1+# Produces Stackage packages set with `stackage2nix` package

2+# from `${stackage2nixSrc}/stack.yaml`

3+#

4+# nix-build ./example.nix -A stackage2nix

6+let

7+ nixpkgs = import <nixpkgs> {

8+ overlays = [ (import ../default.nix) ];

9+ };

10+ inherit (nixpkgs) pkgs lib;

11+

12+ stackage2nixSrc = pkgs.fetchFromGitHub (lib.importJSON ./stackage2nix.json);

13+

14+ stackage = nixpkgs.haskell.packages.stackage.lib.callStackage2nix "stackage2nix" stackage2nixSrc;

15+in

16+ stackage

examples/nixpkgs-pinned.nixnew file+15

@@ -0,0 +1,15 @@

1+# Nixpkgs with Stackage overlay pinned to specific version set in `nixpkgs.json`

3+{ overlays ? []

4+, system ? null

5+, config ? { } }:

7+let

8+ _pkgs = import <nixpkgs> {};

9+ _pkgsPath = _pkgs.fetchFromGitHub (_pkgs.lib.importJSON ../nixpkgs.json);

10+ _stackageOverlayLocal = ../.;

11+in

12+ import _pkgsPath ({

13+ overlays = [ (import _stackageOverlayLocal) ] ++ overlays;

14+ config = config // { allowUnfree = true; };

15+ } // (if system != null then { inherit system; } else { }))

examples/stackage2nix.jsonnew file+6

@@ -0,0 +1,6 @@

1+{

2+ "owner": "typeable",

3+ "repo": "stackage2nix",

4+ "rev": "8d6e70044a4bafa0f8d5bdc011ac00634549a13b",

5+ "sha256": "1lcs8ii0nqlyg1lj50zjabw8z4crkk59dpfyykpxraa9whkklg4d"

6+}

haskell-overlay.nixdeleted−11

@@ -1,11 +0,0 @@

1−self: super:

2−

3−{

4− haskell = super.haskell // {

5− packages = super.haskell.packages // {

6− stackage = import ./stackage {};

7− };

8− };

9−

10− stackage2nix = import ./stackage2nix { nixpkgs = self; };

11−}

lib.nixnew file+67

@@ -0,0 +1,67 @@

1+{ stdenv, lib, cacert, glibcLocales, stackage2nix, stackage2nixWrapper }:

3+rec {

5+ stackage2nixGeneric = { drv, pname, installPhase, name, src }:

6+ stdenv.mkDerivation {

8+ name = "${pname}-${name}";

10+ phases = [ "installPhase" ];

11+ buildInputs = [ drv ];

12+ preferLocalBuild = true;

13+

14+ SSL_CERT_FILE="${cacert}/etc/ssl/certs/ca-bundle.crt";

15+ LANG = "en_US.UTF-8";

16+ LOCALE_ARCHIVE = lib.optionalString stdenv.isLinux "${glibcLocales}/lib/locale/locale-archive";

17+

18+ inherit installPhase;

19+ };

20+

21+ stackage2nixWrapperSrc = { name, src }: stackage2nixGeneric {

22+ drv = stackage2nixWrapper;

23+ pname = "stackage2nixWrapper";

24+ installPhase = ''

25+ export HOME="$TMP"

26+ mkdir -p $out

27+ cd $out

28+ stackage2nix "${src}"

29+ '';

30+

31+ inherit name src;

32+ };

33+

34+ stackage2nixSrc = { name, src }: stackage2nixGeneric {

35+ drv = stackage2nix;

36+ pname = "stackage2nix";

37+ installPhase = ''

38+ export HOME="$TMP"

39+ mkdir -p $out

40+ cd $out

41+ stackage2nix "${src}"

42+ '';

43+

44+ inherit name src;

45+ };

46+

47+ stackage2nixSrcArgs = { name, src, stackage-lts, all-cabal-hashes, hackage-db }: stackage2nixGeneric {

48+ drv = stackage2nix;

49+ pname = "stackage2nixArgs";

50+ installPhase = ''

51+ export HOME="$TMP"

52+ mkdir -p $out

53+ cd $out

54+ stackage2nix --all-cabal-hashes ${all-cabal-hashes} --lts-haskell ${stackage-lts} --hackage-db ${hackage-db}

55+ '';

56+

57+ inherit name src;

58+ };

59+

60+ callStackage2nix = name: src: import (stackage2nixSrc { inherit name src; });

61+

62+ callStackage2nixWrapper = name: src: import (stackage2nixWrapperSrc { inherit name src; });

63+

64+ callStackage2nixArgs = name: src: stackage-lts: all-cabal-hashes: hackage-db:

65+ import (stackage2nixSrcArgs { inherit name src stackage-lts all-cabal-hashes hackage-db; });

66+

67+}

nix-build-release.shnew file+10

@@ -0,0 +1,10 @@

1+#!/bin/sh

2+#

3+# Usage:

4+# nix-build-release.sh -A lts-100.x86_64-linux --dry-run

6+set -x

7+NIXPKGS_ALLOW_BROKEN=1 exec nix-build release.nix \

8+ --option use-binary-caches false \

9+ --arg inHydra false \

10+ $@

nixpkgs.jsonnew file+6

@@ -0,0 +1,6 @@

1+{

2+ "owner": "NixOS",

3+ "repo": "nixpkgs-channels",

4+ "rev": "d6c6c7fcec6dbd2b8ab14f0b35d56c7733872baa",

5+ "sha256": "1bq59575b58lmh5w8bh7pwp17c3p2nm651bz1i3q224c4zsj9294"

6+}

nixpkgs.nixnew file+15

@@ -0,0 +1,15 @@

1+# Nixpkgs with Stackage overlay pinned to `nixpkgs.json` revision

3+{ pkgsPath ? null

4+, overlays ? []

5+, system ? null }:

7+let

8+ _pkgs = import <nixpkgs> {};

9+ _pkgsPath = if pkgsPath != null

10+ then pkgsPath

11+ else _pkgs.fetchFromGitHub (_pkgs.lib.importJSON ./nixpkgs.json);

12+in

13+ import _pkgsPath ({

14+ overlays = [ (import ./default.nix) ] ++ overlays;

15+ } // (if system != null then { inherit system; } else {}))

release.nixnew file+49

@@ -0,0 +1,49 @@

1+{ supportedSystems ? [ "x86_64-linux" "i686-linux" ]

2+, supportedReleases ? null

3+, inHydra ? true

4+, pkgs ? import <nixpkgs> {}

5+}:

7+let

8+ inherit (pkgs) lib;

10+ release = import (pkgs.path + "/pkgs/top-level/release-lib.nix") {

11+ inherit supportedSystems;

12+ nixpkgsArgs = { overlays = [ (import ./default.nix) ]; };

13+ };

14+

15+ # supportedStackageReleases :: [StackageVersion]

16+ supportedStackageReleases =

17+ if supportedReleases == null

18+ then

19+ lib.unique

20+ (map (builtins.replaceStrings ["."] [""])

21+ (builtins.filter (x: x != "")

22+ (lib.splitString "\n"

23+ (builtins.readFile ./supported-stackage-releases.txt))))

24+ else

25+ supportedReleases;

26+

27+ # hasSupportedSystem :: System -> Derivation -> Bool

28+ hasSupportedSystem = system: pkg:

29+ # Test `isAttrs pkg` to ensure that pkg is a derivation

30+ lib.isAttrs pkg && lib.elem system pkg.meta.platforms;

31+

32+ # genJobSetFiltered :: System -> StackageVersion -> AttrSet

33+ genJobSetFiltered = system: stackage:

34+ lib.filterAttrs

35+ (_: pkg: hasSupportedSystem system pkg)

36+ (release.pkgsFor system).haskell.packages.stackage."${stackage}";

37+

38+ # genJobSetFull :: System -> StackageVersion -> AttrSet

39+ genJobSetFull = system: stackage:

40+ (release.pkgsFor system).haskell.packages.stackage."${stackage}";

41+

42+ # genJobSet :: StackageRelease -> System -> AttrSet

43+ genJobSet = if inHydra then genJobSetFull else genJobSetFiltered;

44+

45+in

46+ lib.genAttrs supportedSystems (system:

47+ lib.genAttrs supportedStackageReleases (stackage:

48+ genJobSet system stackage

49+ ))

stackage/README.mddeleted−12

@@ -1,12 +0,0 @@

1−# Stackage

2−

3−generate:

4−

5−```

6−~/.local/bin/stackage2nix --hackage-db /home/dbushev/.cabal/packages/hackage.haskell.org/01-index.tar --all-cabal-hashes /home/dbushev/projects/commercialhaskell/all-cabal-hashes --lts-haskell /home/dbushev/projects/fpco/lts-haskell --resolver lts-6.30

7−```

8−check:

9−

10−```

11−nix-env -f '<nixpkgs>' -qaP -A pkgs.haskell.packages.stackage.lts-635

12−```

stackage/default.nix+23−11

@@ -1,13 +1,25 @@

1−{ nixpkgs ? import <nixpkgs> {} }:

2−

3−# generate:

4−# ~/.local/bin/stackage2nix --hackage-db /home/dbushev/.cabal/packages/hackage.haskell.org/01-index.tar --all-cabal-hashes /home/dbushev/projects/commercialhaskell/all-cabal-hashes --lts-haskell /home/dbushev/projects/fpco/lts-haskell --resolver lts-6.30

5−# check:

6−# nix-env -f '<nixpkgs>' -qaP -A pkgs.haskell.packages.stackage.lts-635

7−

8−with nixpkgs;

1+{ callPackage }:

92{

10− lts-630 = import ./lts-6.30 { inherit nixpkgs; };

11− lts-635 = import ./lts-6.35 { inherit nixpkgs; };

12− lts-90 = import ./lts-9.0 { inherit nixpkgs; };

3+ lts-130 = callPackage ./lts-13.0 {};

4+ lts-131 = callPackage ./lts-13.1 {};

5+ lts-132 = callPackage ./lts-13.2 {};

6+ lts-133 = callPackage ./lts-13.3 {};

7+ lts-134 = callPackage ./lts-13.4 {};

8+ lts-135 = callPackage ./lts-13.5 {};

9+ lts-136 = callPackage ./lts-13.6 {};

10+ lts-137 = callPackage ./lts-13.7 {};

11+ lts-138 = callPackage ./lts-13.8 {};

12+ lts-139 = callPackage ./lts-13.9 {};

13+ lts-1310 = callPackage ./lts-13.10 {};

14+ lts-1311 = callPackage ./lts-13.11 {};

15+ lts-1312 = callPackage ./lts-13.12 {};

16+ lts-1313 = callPackage ./lts-13.13 {};

17+ lts-1314 = callPackage ./lts-13.14 {};

18+ lts-1315 = callPackage ./lts-13.15 {};

19+ lts-1316 = callPackage ./lts-13.16 {};

20+ lts-1317 = callPackage ./lts-13.17 {};

21+ lts-1318 = callPackage ./lts-13.18 {};

22+ lts-1319 = callPackage ./lts-13.19 {};

23+ lts-1320 = callPackage ./lts-13.20 {};

24+ lts-1321 = callPackage ./lts-13.21 {};

1325}

stackage/lts-13.0/configuration-packages.nixnew file+40

@@ -0,0 +1,40 @@

1+# Generated by stackage2nix 0.7.2 from "/nix/store/6nhazjk3wgalhgrzicf1my2y4sk5311z-source/lts-13.0.yaml"

2+{ pkgs, haskellLib }:

4+with haskellLib; self: super: {

6+ # core packages

7+ "array" = null;

8+ "base" = null;

9+ "binary" = null;

10+ "bytestring" = null;

11+ "containers" = null;

12+ "deepseq" = null;

13+ "directory" = null;

14+ "filepath" = null;

15+ "ghc-boot" = null;

16+ "ghc-boot-th" = null;

17+ "ghc-heap" = null;

18+ "ghc-prim" = null;

19+ "ghci" = null;

20+ "hpc" = null;

21+ "integer-gmp" = null;

22+ "pretty" = null;

23+ "process" = null;

24+ "rts" = null;

25+ "template-haskell" = null;

26+ "terminfo" = null;

27+ "time" = null;

28+ "transformers" = null;

29+ "unix" = null;

30+ # break cycle: HUnit call-stack nanospec hspec hspec-core clock tasty async hashable test-framework-hunit tasty-quickcheck tasty-hunit hspec-expectations quickcheck-io hspec-discover hspec-meta silently temporary exceptions

31+ "exceptions" = dontCheck super.exceptions;

32+ "temporary" = dontCheck super.temporary;

33+ "silently" = dontCheck super.silently;

34+ "hspec-discover" = dontCheck super.hspec-discover;

35+ "hashable" = dontCheck super.hashable;

36+ "async" = dontCheck super.async;

37+ "clock" = dontCheck super.clock;

38+ "nanospec" = dontCheck super.nanospec;

39+

40+}

stackage/lts-13.0/default.nixnew file+26

@@ -0,0 +1,26 @@

1+# Generated by stackage2nix 0.7.2 from "/nix/store/6nhazjk3wgalhgrzicf1my2y4sk5311z-source/lts-13.0.yaml"

2+{ callPackage, buildPackages, pkgs, stdenv, lib

3+, overrides ? (self: super: {})

4+, packageSetConfig ? (self: super: {})

5+}:

7+let

8+ inherit (lib) extends makeExtensible;

9+ haskellLib = pkgs.haskell.lib;

10+ inherit (haskellLib) makePackageSet;

11+

12+ haskellPackages = pkgs.callPackage makePackageSet {

13+ ghc = buildPackages.haskell.compiler.ghc863;

14+ buildHaskellPackages = buildPackages.haskell.packages.ghc863;

15+ package-set = import ./packages.nix;

16+ inherit stdenv haskellLib extensible-self;

17+ };

18+

19+ compilerConfig = import ./configuration-packages.nix { inherit pkgs haskellLib; };

20+

21+ configurationCommon = if builtins.pathExists ./configuration-common.nix then import ./configuration-common.nix { inherit pkgs haskellLib; } else self: super: {};

22+ configurationNix = import (pkgs.path + "/pkgs/development/haskell-modules/configuration-nix.nix") { inherit pkgs haskellLib; };

23+

24+ extensible-self = makeExtensible (extends overrides (extends configurationCommon (extends packageSetConfig (extends compilerConfig (extends configurationNix haskellPackages)))));

25+

26+in extensible-self

stackage/lts-6.35/packages.nix → stackage/lts-13.0/packages.nixrenamed+20785−20783