master..4d9cc82 · typeable/nixpkgs-stackage

git.iko.soy/typeable/nixpkgs-stackage

on 4d9cc82 help sign in

.travis.ymldeleted−17

since splitsnapshots

unifiedsplit

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

1−language: nix

2−

3−install:

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

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

6−

7−script:

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

9−

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+11−43

@@ -1,24 +1,21 @@

1−# nixpkgs-stackage

1+# Nix

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

3+Nixpgs overlay

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

5+## Packages

7−# Install

7+- Stackage LTS releases

8+- [stackage2nix][]

10+## Install

11+

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

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

11```

14```

12cd ~/.config/nixpkgs/overlays

15cd ~/.config/nixpkgs/overlays

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

16+ln -s /path/to/haskell-overlay.nix typeable-overlay.nix

14```

17```

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`

21−

22## Haskell overlay

19## Haskell overlay

24List LTS packages:

21List LTS packages:

@@ -35,39 +32,10 @@ $ nix-env -i stackage2nix

36## Update script

33## Update script

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

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

40```

37```

41−./update.sh

38+nix-shell update.nix --pure

42```

39```

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−

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

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

cache-version.txtdeleted−1

@@ -1 +0,0 @@

1−2019-05-14

default.nix+5−68

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

1−self: super:

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

3−let

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

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

5+with nixpkgs.lib;

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

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

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

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

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.nixdeleted−16

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

1−# Stackage packages with Nixpkgs pinned to specific revision

2−

3−let

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

5− inherit (nixpkgs) pkgs lib haskell;

6−

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

8−

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.nixdeleted−20

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

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

2−

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.nixdeleted−16

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

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

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

3−#

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

5−

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.nixdeleted−15

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

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

2−

3−{ overlays ? []

4−, system ? null

5−, config ? { } }:

6−

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.jsondeleted−6

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

1−{

2− "owner": "typeable",

3− "repo": "stackage2nix",

4− "rev": "8d6e70044a4bafa0f8d5bdc011ac00634549a13b",

5− "sha256": "1lcs8ii0nqlyg1lj50zjabw8z4crkk59dpfyykpxraa9whkklg4d"

6−}

haskell-overlay.nixnew file+11

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

1+self: super:

3+{

4+ haskell = super.haskell // {

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

6+ stackage = import ./stackage { inherit self; };

7+ };

8+ };

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

11+}

lib.nixdeleted−67

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

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

2−

3−rec {

4−

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

6− stdenv.mkDerivation {

7−

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

9−

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.shdeleted−10

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

1−#!/bin/sh

2−#

3−# Usage:

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

5−

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.jsondeleted−6

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

1−{

2− "owner": "NixOS",

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

4− "rev": "d6c6c7fcec6dbd2b8ab14f0b35d56c7733872baa",

5− "sha256": "1bq59575b58lmh5w8bh7pwp17c3p2nm651bz1i3q224c4zsj9294"

6−}

nixpkgs.nixdeleted−15

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

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

2−

3−{ pkgsPath ? null

4−, overlays ? []

5−, system ? null }:

6−

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.nixdeleted−49

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

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

2−, supportedReleases ? null

3−, inHydra ? true

4−, pkgs ? import <nixpkgs> {}

5−}:

6−

7−let

8− inherit (pkgs) lib;

9−

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.mdnew file+12

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

1+# Stackage

3+generate:

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:

10+```

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

12+```

stackage/default.nix+5−23

@@ -1,25 +1,7 @@

1−{ callPackage }:

1+self:

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

3+ lts-100 = import ./lts-10.0 {};

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

4+ lts-630 = import ./lts-6.30 {};

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

5+ lts-635 = import ./lts-6.35 {};

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

6+ lts-90 = import ./lts-9.0 {};

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 {};

25}

stackage/lts-10.0/configuration-common.nixnew file+8

@@ -0,0 +1,8 @@

1+{ pkgs, haskellLib }:

3+with haskellLib;

4+self: super: {

6+ warp = addBuildDepend super.warp pkgs.curl;

8+}

stackage/lts-10.0/configuration-packages.nixnew file+49

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

1+# Generated by stackage2nix 0.4.0 from "/home/dbushev/projects/fpco/lts-haskell/lts-10.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-prim" = null;

18+ "ghci" = null;

19+ "hoopl" = 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 ansi-terminal colour test-framework ansi-wl-pprint xml text test-framework-hunit test-framework-quickcheck2 async hspec-expectations hspec-meta quickcheck-io silently temporary base-compat exceptions tasty clock tasty-quickcheck tasty-hunit optparse-applicative regex-tdfa parsec hspec-discover stringbuilder

31+ "stringbuilder" = dontCheck super.stringbuilder;

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

33+ "clock" = dontCheck super.clock;

34+ "exceptions" = dontCheck super.exceptions;

35+ "base-compat" = dontCheck super.base-compat;

36+ "temporary" = dontCheck super.temporary;

37+ "silently" = dontCheck super.silently;

38+ "async" = dontCheck super.async;

39+ "text" = dontCheck super.text;

40+ "colour" = dontCheck super.colour;

41+ "nanospec" = dontCheck super.nanospec;

42+ # break cycle: scalendar SCalendar

43+ "SCalendar" = dontCheck super.SCalendar;

44+ # break cycle: http-streams snap-server

45+ "snap-server" = dontCheck super.snap-server;

46+ # break cycle: statistics monad-par mwc-random vector-algorithms

47+ "mwc-random" = dontCheck super.mwc-random;

48+

49+}

stackage/lts-10.0/default.nixnew file+12

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

1+# Generated by stackage2nix 0.4.0 from "/home/dbushev/projects/fpco/lts-haskell/lts-10.0.yaml"

2+{ nixpkgs ? import <nixpkgs> {} }:

4+with nixpkgs; let

5+ haskellLib = callPackage (nixpkgs.path + /pkgs/development/haskell-modules/lib.nix) {};

6+in callPackage (nixpkgs.path + /pkgs/development/haskell-modules) {

7+ ghc = pkgs.haskell.compiler.ghc822;

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

9+ initialPackages = import ./packages.nix;

10+ configurationCommon = if builtins.pathExists ./configuration-common.nix then import ./configuration-common.nix else args: self: super: {};

11+ inherit haskellLib;

12+}

stackage/lts-13.18/packages.nix → stackage/lts-10.0/packages.nixrenamed+18381−12894