bb7aec6..master · typeable/cabal2nix

.travis.yml+137−79

@@ -1,103 +1,161 @@

1# This Travis job script has been generated by a script via

2#

3−# runghc make_travis_yml_2.hs '--doctest' '--doctest-options=-i ../dist-newstyle/build/*/*/cabal2nix-*/build/autogen' '--hlint' '-o' '.travis.yml' 'cabal2nix.cabal'

3+# haskell-ci '--installed=+all -Cabal' '--hlint' '--doctest' '--doctest-options=-i ../dist-newstyle/build/*/*/cabal2nix-*/build/autogen' '-o' '.travis.yml' 'cabal2nix.cabal' '--head-hackage' '--head-hackage-jobs' '> 8.8'

4#

5−# For more information, see https://github.com/hvr/multi-ghc-travis

5+# For more information, see https://github.com/haskell-CI/haskell-ci

6#

7+# version: 0.9.20200306

8+#

9+version: ~> 1.0

7language: c

10language: c

8−sudo: false

11+os: linux

9−

12+dist: xenial

10git:

13git:

11− submodules: false # whether to recursively clone submodules

14+ # whether to recursively clone submodules

12−

15+ submodules: false

13cache:

16cache:

14 directories:

17 directories:

15 - $HOME/.cabal/packages

18 - $HOME/.cabal/packages

16 - $HOME/.cabal/store

19 - $HOME/.cabal/store

17−

20+ - $HOME/.hlint

18before_cache:

21before_cache:

19− - rm -fv $HOME/.cabal/packages/hackage.haskell.org/build-reports.log

22+ - rm -fv $CABALHOME/packages/hackage.haskell.org/build-reports.log

20 # remove files that are regenerated by 'cabal update'

23 # remove files that are regenerated by 'cabal update'

21− - rm -fv $HOME/.cabal/packages/hackage.haskell.org/00-index.*

24+ - rm -fv $CABALHOME/packages/hackage.haskell.org/00-index.*

22− - rm -fv $HOME/.cabal/packages/hackage.haskell.org/*.json

25+ - rm -fv $CABALHOME/packages/hackage.haskell.org/*.json

23− - rm -fv $HOME/.cabal/packages/hackage.haskell.org/01-index.cache

26+ - rm -fv $CABALHOME/packages/hackage.haskell.org/01-index.cache

24− - rm -fv $HOME/.cabal/packages/hackage.haskell.org/01-index.tar

27+ - rm -fv $CABALHOME/packages/hackage.haskell.org/01-index.tar

25− - rm -fv $HOME/.cabal/packages/hackage.haskell.org/01-index.tar.idx

28+ - rm -fv $CABALHOME/packages/hackage.haskell.org/01-index.tar.idx

26−

27− - rm -rfv $HOME/.cabal/packages/head.hackage

29+ - rm -rfv $CABALHOME/packages/head.hackage

28−

30+jobs:

29−matrix:

30 include:

31 include:

31− - compiler: "ghc-8.2.2"

32+ - compiler: ghc-8.10.1

32− # env: TEST=--disable-tests BENCH=--disable-benchmarks

33+ addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-8.10.1","cabal-install-3.2"]}}

33− addons: {apt: {packages: [ghc-ppa-tools,cabal-install-head,ghc-8.2.2], sources: [hvr-ghc]}}

34+ os: linux

34−

35+ - compiler: ghc-8.8.3

36+ addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-8.8.3","cabal-install-3.0"]}}

37+ os: linux

38+ - compiler: ghc-8.6.5

39+ addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-8.6.5","cabal-install-3.0"]}}

40+ os: linux

41+ allow_failures:

42+ - compiler: ghc-8.8.3

43+ - compiler: ghc-8.10.1

35before_install:

44before_install:

36− - HC=${CC}

45+ - HC=$(echo "/opt/$CC/bin/ghc" | sed 's/-/\//')

46+ - WITHCOMPILER="-w $HC"

47+ - HADDOCK=$(echo "/opt/$CC/bin/haddock" | sed 's/-/\//')

37− - HCPKG=${HC/ghc/ghc-pkg}

48+ - HCPKG="$HC-pkg"

38 - unset CC

49 - unset CC

39− - ROOTDIR=$(pwd)

50+ - CABAL=/opt/ghc/bin/cabal

40− - mkdir -p $HOME/.local/bin

51+ - CABALHOME=$HOME/.cabal

41− - "PATH=/opt/ghc/bin:/opt/ghc-ppa-tools/bin:$HOME/local/bin:$PATH"

52+ - export PATH="$CABALHOME/bin:$PATH"

53+ - TOP=$(pwd)

42− - HCNUMVER=$(( $(${HC} --numeric-version|sed -E 's/([0-9]+)\.([0-9]+)\.([0-9]+).*/\1 * 10000 + \2 * 100 + \3/') ))

54+ - "HCNUMVER=$(${HC} --numeric-version|perl -ne '/^(\\d+)\\.(\\d+)\\.(\\d+)(\\.(\\d+))?$/; print(10000 * $1 + 100 * $2 + ($3 == 0 ? $5 != 1 : $3))')"

43 - echo $HCNUMVER

55 - echo $HCNUMVER

44−

56+ - CABAL="$CABAL -vnormal+nowrap"

57+ - set -o pipefail

58+ - TEST=--enable-tests

59+ - BENCH=--enable-benchmarks

60+ - HEADHACKAGE=false

61+ - if [ $HCNUMVER -ge 80800 ] ; then HEADHACKAGE=true ; fi

62+ - rm -f $CABALHOME/config

63+ - |

64+ echo "verbose: normal +nowrap +markoutput" >> $CABALHOME/config

65+ echo "remote-build-reporting: anonymous" >> $CABALHOME/config

66+ echo "write-ghc-environment-files: always" >> $CABALHOME/config

67+ echo "remote-repo-cache: $CABALHOME/packages" >> $CABALHOME/config

68+ echo "logs-dir: $CABALHOME/logs" >> $CABALHOME/config

69+ echo "world-file: $CABALHOME/world" >> $CABALHOME/config

70+ echo "extra-prog-path: $CABALHOME/bin" >> $CABALHOME/config

71+ echo "symlink-bindir: $CABALHOME/bin" >> $CABALHOME/config

72+ echo "installdir: $CABALHOME/bin" >> $CABALHOME/config

73+ echo "build-summary: $CABALHOME/logs/build.log" >> $CABALHOME/config

74+ echo "store-dir: $CABALHOME/store" >> $CABALHOME/config

75+ echo "install-dirs user" >> $CABALHOME/config

76+ echo " prefix: $CABALHOME" >> $CABALHOME/config

77+ echo "repository hackage.haskell.org" >> $CABALHOME/config

78+ echo " url: http://hackage.haskell.org/" >> $CABALHOME/config

79+ - |

80+ if $HEADHACKAGE; then

81+ echo "allow-newer: $($HCPKG list --simple-output | sed -E 's/([a-zA-Z-]+)-[0-9.]+/*:\1/g')" >> $CABALHOME/config

82+ echo "repository head.hackage.ghc.haskell.org" >> $CABALHOME/config

83+ echo " url: https://ghc.gitlab.haskell.org/head.hackage/" >> $CABALHOME/config

84+ echo " secure: True" >> $CABALHOME/config

85+ echo " root-keys: 7541f32a4ccca4f97aea3b22f5e593ba2c0267546016b992dfadcd2fe944e55d" >> $CABALHOME/config

86+ echo " 26021a13b401500c8eb2761ca95c61f2d625bfef951b939a8124ed12ecf07329" >> $CABALHOME/config

87+ echo " f76d08be13e9a61a377a85e2fb63f4c5435d40f8feb3e12eb05905edb8cdea89" >> $CABALHOME/config

88+ echo " key-threshold: 3" >> $CABALHOME/config

89+ fi

45install:

90install:

46− - cabal --version

91+ - ${CABAL} --version

47 - echo "$(${HC} --version) [$(${HC} --print-project-git-commit-id 2> /dev/null || echo '?')]"

92 - echo "$(${HC} --version) [$(${HC} --print-project-git-commit-id 2> /dev/null || echo '?')]"

48− - BENCH=${BENCH---enable-benchmarks}

93+ - |

49− - TEST=${TEST---enable-tests}

94+ echo "program-default-options" >> $CABALHOME/config

50− - HADDOCK=${HADDOCK-true}

95+ echo " ghc-options: $GHCJOBS +RTS -M6G -RTS" >> $CABALHOME/config

51− - INSTALLED=${INSTALLED-true}

96+ - cat $CABALHOME/config

52− - GHCHEAD=${GHCHEAD-false}

97+ - rm -fv cabal.project cabal.project.local cabal.project.freeze

53− - travis_retry cabal update -v

98+ - travis_retry ${CABAL} v2-update -v

54− - "sed -i.bak 's/^jobs:/-- jobs:/' ${HOME}/.cabal/config"

99+ - (cd /tmp && ${CABAL} v2-install $WITHCOMPILER -j2 doctest --constraint='doctest ==0.16.2.*')

55− - rm -fv cabal.project cabal.project.local

100+ - if [ $HCNUMVER -lt 80800 ] ; then HLINTVER=$(cd /tmp && (${CABAL} v2-install -v $WITHCOMPILER --dry-run hlint --constraint='hlint ==2.2.*' | perl -ne 'if (/\bhlint-(\d+(\.\d+)*)\b/) { print "$1"; last; }')); echo "HLint version $HLINTVER" ; fi

56− - grep -Ev -- '^\s*--' ${HOME}/.cabal/config | grep -Ev '^\s*$'

101+ - "if [ $HCNUMVER -lt 80800 ] ; then if [ ! -e $HOME/.hlint/hlint-$HLINTVER/hlint ]; then echo \"Downloading HLint version $HLINTVER\"; mkdir -p $HOME/.hlint; curl --write-out 'Status Code: %{http_code} Redirects: %{num_redirects} Total time: %{time_total} Total Dsize: %{size_download}\\n' --silent --location --output $HOME/.hlint/hlint-$HLINTVER.tar.gz \"https://github.com/ndmitchell/hlint/releases/download/v$HLINTVER/hlint-$HLINTVER-x86_64-linux.tar.gz\"; tar -xzv -f $HOME/.hlint/hlint-$HLINTVER.tar.gz -C $HOME/.hlint; fi ; fi"

57− - if [ $HCNUMVER -ge 80000 ]; then cabal new-install -w ${HC} --symlink-bindir=$HOME/.local/bin doctest --constraint='doctest ==0.13.*'; fi

102+ - if [ $HCNUMVER -lt 80800 ] ; then mkdir -p $CABALHOME/bin && ln -sf "$HOME/.hlint/hlint-$HLINTVER/hlint" $CABALHOME/bin/hlint ; fi

58− - if [ $HCNUMVER -eq 80202 ]; then cabal new-install -w ${HC} --symlink-bindir=$HOME/.local/bin hlint --constraint='hlint ==2.0.*'; fi

103+ - if [ $HCNUMVER -lt 80800 ] ; then hlint --version ; fi

59− - "printf 'packages: \".\"\\n' > cabal.project"

104+ # Generate cabal.project

105+ - rm -rf cabal.project cabal.project.local cabal.project.freeze

106+ - touch cabal.project

107+ - |

108+ echo "packages: ." >> cabal.project

109+ - |

110+ - "for pkg in $($HCPKG list --simple-output); do echo $pkg | sed 's/-[^-]*$//' | (grep -vE -- '^(Cabal|cabal2nix)$' || true) | sed 's/^/constraints: /' | sed 's/$/ installed/' >> cabal.project.local; done"

111+ - cat cabal.project || true

60− - cat cabal.project

112+ - cat cabal.project.local || true

61− - if [ -f "./configure.ac" ]; then

113+ - if [ -f "./configure.ac" ]; then (cd "." && autoreconf -i); fi

62− (cd "." && autoreconf -i);

114+ - ${CABAL} v2-freeze $WITHCOMPILER ${TEST} ${BENCH}

63− fi

115+ - "cat cabal.project.freeze | sed -E 's/^(constraints: *| *)//' | sed 's/any.//'"

64− - rm -f cabal.project.freeze

116+ - rm cabal.project.freeze

65− - cabal new-build -w ${HC} ${TEST} ${BENCH} --project-file="cabal.project" --dep -j2 all

117+ - travis_wait 40 ${CABAL} v2-build $WITHCOMPILER ${TEST} ${BENCH} --dep -j2 all

66− - cabal new-build -w ${HC} --disable-tests --disable-benchmarks --project-file="cabal.project" --dep -j2 all

118+ - travis_wait 40 ${CABAL} v2-build $WITHCOMPILER --disable-tests --disable-benchmarks --dep -j2 all

67− - rm -rf "."/.ghc.environment.* "."/dist

68− - DISTDIR=$(mktemp -d /tmp/dist-test.XXXX)

69−

70−# Here starts the actual work to be performed for the package under test;

71−# any command which exits with a non-zero exit code causes the build to fail.

72script:

119script:

73− # test that source-distributions can be generated

120+ - DISTDIR=$(mktemp -d /tmp/dist-test.XXXX)

74− - (cd "." && cabal sdist)

121+ # Packaging...

122+ - ${CABAL} v2-sdist all

123+ # Unpacking...

75− - mv "."/dist/cabal2nix-*.tar.gz ${DISTDIR}/

124+ - mv dist-newstyle/sdist/*.tar.gz ${DISTDIR}/

76 - cd ${DISTDIR} || false

125 - cd ${DISTDIR} || false

77− - find . -maxdepth 1 -name '*.tar.gz' -exec tar -xvf '{}' \;

126+ - find . -maxdepth 1 -type f -name '*.tar.gz' -exec tar -xvf '{}' \;

78− - "printf 'packages: cabal2nix-*/*.cabal\\n' > cabal.project"

127+ - find . -maxdepth 1 -type f -name '*.tar.gz' -exec rm '{}' \;

128+ - PKGDIR_cabal2nix="$(find . -maxdepth 1 -type d -regex '.*/cabal2nix-[0-9.]*')"

129+ # Generate cabal.project

130+ - rm -rf cabal.project cabal.project.local cabal.project.freeze

131+ - touch cabal.project

132+ - |

133+ echo "packages: ${PKGDIR_cabal2nix}" >> cabal.project

134+ - |

135+ - "for pkg in $($HCPKG list --simple-output); do echo $pkg | sed 's/-[^-]*$//' | (grep -vE -- '^(Cabal|cabal2nix)$' || true) | sed 's/^/constraints: /' | sed 's/$/ installed/' >> cabal.project.local; done"

79− - cat cabal.project

136+ - cat cabal.project || true

137+ - cat cabal.project.local || true

138+ # Building...

80 # this builds all libraries and executables (without tests/benchmarks)

139 # this builds all libraries and executables (without tests/benchmarks)

81− - cabal new-build -w ${HC} --disable-tests --disable-benchmarks all

140+ - ${CABAL} v2-build $WITHCOMPILER --disable-tests --disable-benchmarks all

82−

141+ # Building with tests and benchmarks...

83− # Build with installed constraints for packages in global-db

84− - if $INSTALLED; then echo cabal new-build -w ${HC} --disable-tests --disable-benchmarks $(${HCPKG} list --global --simple-output --names-only | sed 's/$[a-zA-Z0-9-]\{1,\}$ */--constraint="\1 installed" /g') all | sh; else echo "Not building with installed constraints"; fi

85−

86 # build & run tests, build benchmarks

142 # build & run tests, build benchmarks

87− - cabal new-build -w ${HC} ${TEST} ${BENCH} all

143+ - ${CABAL} v2-build $WITHCOMPILER ${TEST} ${BENCH} all

88−

144+ # Testing...

89− # doctest

145+ - ${CABAL} v2-test $WITHCOMPILER ${TEST} ${BENCH} all

146+ # Doctest...

90− - if [ $HCNUMVER -ge 80000 ]; then (cd cabal2nix-* && doctest -i ../dist-newstyle/build/*/*/cabal2nix-*/build/autogen src); fi

147+ - (cd ${PKGDIR_cabal2nix} && doctest -i ../dist-newstyle/build/*/*/cabal2nix-*/build/autogen src)

91−

148+ # HLint..

92− # hlint

149+ - if [ $HCNUMVER -lt 80800 ] ; then (cd ${PKGDIR_cabal2nix} && hlint src) ; fi

150+ - if [ $HCNUMVER -lt 80800 ] ; then (cd ${PKGDIR_cabal2nix} && hlint hackage2nix) ; fi

93− - if [ $HCNUMVER -eq 80202 ]; then (cd cabal2nix-* && hlint src); fi

151+ - if [ $HCNUMVER -lt 80800 ] ; then (cd ${PKGDIR_cabal2nix} && hlint cabal2nix) ; fi

94−

95− # cabal check

152+ # cabal check...

96− - (cd cabal2nix-* && cabal check)

153+ - (cd ${PKGDIR_cabal2nix} && ${CABAL} -vnormal check)

97−

98− # haddock

154+ # haddock...

99− - rm -rf ./dist-newstyle

155+ - ${CABAL} v2-haddock $WITHCOMPILER --with-haddock $HADDOCK ${TEST} ${BENCH} all

100− - if $HADDOCK; then cabal new-haddock -w ${HC} ${TEST} ${BENCH} all; else echo "Skipping haddock generation";fi

156+ # Building without installed constraints for packages in global-db...

157+ - rm -f cabal.project.local

158+ - ${CABAL} v2-build $WITHCOMPILER --disable-tests --disable-benchmarks all

101

159

102−# REGENDATA ["--doctest","--doctest-options=-i ../dist-newstyle/build/*/*/cabal2nix-*/build/autogen","--hlint","-o",".travis.yml","cabal2nix.cabal"]

160+# REGENDATA ("0.9.20200306",["--installed=+all -Cabal","--hlint","--doctest","--doctest-options=-i ../dist-newstyle/build/*/*/cabal2nix-*/build/autogen","-o",".travis.yml","cabal2nix.cabal","--head-hackage","--head-hackage-jobs","> 8.8"])

103# EOF

161# EOF

README.md+12−7

@@ -1,6 +1,11 @@

1Cabal2nix

2=========

3

4+[![hackage release](https://img.shields.io/hackage/v/cabal2nix.svg?label=hackage)](http://hackage.haskell.org/package/cabal2nix)

5+[![stackage LTS package](http://stackage.org/package/cabal2nix/badge/lts)](http://stackage.org/lts/package/cabal2nix)

6+[![stackage Nightly package](http://stackage.org/package/cabal2nix/badge/nightly)](http://stackage.org/nightly/package/cabal2nix)

7+[![travis build status](https://img.shields.io/travis/NixOS/cabal2nix/master.svg?label=travis+build)](https://travis-ci.org/NixOS/cabal2nix)

8+

4`cabal2nix` converts a single Cabal file into a single Nix build expression.

9`cabal2nix` converts a single Cabal file into a single Nix build expression.

5For example:

10For example:

6

11

@@ -22,16 +27,16 @@ direct `http://host/path/pkg.cabal` URL can be provided, as well as a

22`file:///local/path/pkg.cabal` URI that doesn't depend on network access.

27`file:///local/path/pkg.cabal` URI that doesn't depend on network access.

23However, if the source hash is not already in `cabal2nix`'s cache or provided

28However, if the source hash is not already in `cabal2nix`'s cache or provided

24using the `--sha256` option, `cabal2nix` still needs to download the source

29using the `--sha256` option, `cabal2nix` still needs to download the source

25−code to compute the hash, which obviously still causes network traffic. Run the

30+code to compute the hash, which still causes network traffic. Run the utility

26−utility with `--help` to see the complete list of supported command line flags.

31+with `--help` to see the complete list of supported command-line flags.

27

32

28−Detailed instructions how to use those generated files with Nix can be found at

33+Detailed instructions on how to use those generated files with Nix can be found at

29−http://nixos.org/nixpkgs/manual/#users-guide-to-the-haskell-infrastructure.

34+https://nixos.org/nixpkgs/manual/#how-to-create-nix-builds-for-your-own-private-haskell-packages.

30

35

31`cabal2nix` can also build derivations for projects from other sources than

36`cabal2nix` can also build derivations for projects from other sources than

32−hackage. You only need to provide an URI that points to a cabal project. The

37+Hackage. You only need to provide a URI that points to a cabal project. The

33−most common usecase for this is probably to generate a derivation for a project

38+most common use-case for this is probably to generate a derivation for a

34−on the local file system:

39+project on the local file system:

35

40

36 $ cabal get mtl-2.2.1 && cd mtl-2.2.1

41 $ cabal get mtl-2.2.1 && cd mtl-2.2.1

37 $ cabal2nix .

42 $ cabal2nix .

cabal2nix.cabal+138−179

@@ -1,193 +1,152 @@

1−name: cabal2nix

1+name: cabal2nix

2−version: 2.8.1

2+version: 2.15.1

3−synopsis: Convert Cabal files into Nix build instructions.

3+synopsis: Convert Cabal files into Nix build instructions.

4−category: Distribution, Nix

5−stability: stable

6−homepage: https://github.com/nixos/cabal2nix#readme

7−bug-reports: https://github.com/nixos/cabal2nix/issues

8−author: Peter Simons,

9− Andres Loeh,

10− Benno Fünfstück,

11− Mateusz Kowalczyk,

12− Michael Alan Dorman,

13− Tom Smalley,

14− Mathijs Kwik,

15− Shea Levy,

16− Dmitry Malikov,

17− Eric Seidel,

18− Jacob Mitchell,

19− Graham Christensen,

20− Hamish Mackenzie,

21− Nikolay Amiantov,

22− Aycan iRiCAN,

23− Bryan Gardiner,

24− Joe Hermaszewski,

25− John Wiegley,

26− Philipp Hausmann,

27− Spencer Janssen,

28− Tom Hunger,

29− William Casarin,

30− koral,

31− ksaric,

32− Adam Vogt,

33− Alexey Shmalko,

34− Corey O'Connor,

35− Cray Elliott,

36− David Johnson,

37− Dmitry Bushev,

38− Domen Kožar,

39− Felix Kunzmann,

40− Gabriel Ebner,

41− Gergely Risko,

42− Joachim Fasting,

43− John Albietz,

44− John Chee,

45− Jussi Maki,

46− Lisanna Dettwyler,

47− Mark Laws,

48− Mark Wotton,

49− Matthew Pickering,

50− Matthew Stewart,

51− Matvey Aksenov,

52− Nicholas Clarke,

53− Nicolas Rolland,

54− Oliver Charles,

55− Pascal Wittmann,

56− Patrick John Wheeler,

57− Phil de Joux,

58− Piotr Bogdan,

59− Profpatsch,

60− Raymond Gauthier,

61− Renzo Carbonara,

62− Rodney Lorrimar,

63− Sibi,

64− Sukant Hajra,

65− Tanner Doshier,

66− Vaibhav Sagar,

67− Viktar Basharymau,

68− danbst,

69− karsten gebbert,

70− laMudri,

71− Александр Цамутали

72−maintainer: Peter Simons <simons@cryp.to>

73−license: BSD3

74−license-file: LICENSE

75−tested-with: GHC == 8.2.2

76−build-type: Simple

77−cabal-version: 1.24

78−

79description:

4description:

80− Convert Cabal files into Nix build instructions. Users of Nix can install the

5+ Convert Cabal files into Nix build instructions. Users of Nix can install the latest

81− latest version by running:

6+ version by running:

82 .

7 .

83 > nix-env -i cabal2nix

8 > nix-env -i cabal2nix

84−

9+license: BSD3

10+license-file: LICENSE

11+author: Peter Simons, Andres Loeh, Benno Fünfstück, Mateusz Kowalczyk,

12+ Michael Alan Dorman, Tom Smalley, Mathijs Kwik, Shea Levy, Dmitry

13+ Malikov, Eric Seidel, Jacob Mitchell, Graham Christensen,

14+ Hamish Mackenzie, Nikolay Amiantov, Aycan iRiCAN, Bryan

15+ Gardiner, Joe Hermaszewski, John Wiegley, Philipp Hausmann,

16+ Spencer Janssen, Tom Hunger, William Casarin, koral,

17+ ksaric, Adam Vogt, Alexey Shmalko, Corey O'Connor, Cray

18+ Elliott, David Johnson, Dmitry Bushev, Domen Kožar, Felix

19+ Kunzmann, Gabriel Ebner, Gergely Risko, Joachim Fasting,

20+ John Albietz, John Chee, Jussi Maki, Lisanna Dettwyler,

21+ Mark Laws, Mark Wotton, Matthew Pickering, Matthew Stewart,

22+ Matvey Aksenov, Nicholas Clarke, Nicolas Rolland, Oliver

23+ Charles, Pascal Wittmann, Patrick John Wheeler, Phil de

24+ Joux, Piotr Bogdan, Profpatsch, Raymond Gauthier, Renzo

25+ Carbonara, Rodney Lorrimar, Sibi, Sukant Hajra, Tanner

26+ Doshier, Vaibhav Sagar, Viktar Basharymau, danbst, karsten

27+ gebbert, laMudri, Александр Цамутали

28+maintainer: Peter Simons <simons@cryp.to>

29+stability: stable

30+tested-with: GHC == 8.6.5, GHC == 8.8.3, GHC == 8.10.1

31+category: Distribution, Nix

32+homepage: https://github.com/nixos/cabal2nix#readme

33+bug-reports: https://github.com/nixos/cabal2nix/issues

34+build-type: Simple

85−extra-source-files:

35+extra-source-files: README.md

86− README.md

87− test/golden-test-cases/*.cabal

36+ test/golden-test-cases/*.cabal

88− test/golden-test-cases/*.nix.golden

37+ test/golden-test-cases/*.nix.golden

38+cabal-version: 1.24

89

39

90source-repository head

40source-repository head

91− type: git

41+ type: git

92 location: https://github.com/nixos/cabal2nix

42 location: https://github.com/nixos/cabal2nix

93

43

94library

44library

45+ exposed-modules: Cabal2nix

46+ Distribution.Nixpkgs.Fetch

47+ Distribution.Nixpkgs.Haskell

48+ Distribution.Nixpkgs.Haskell.BuildInfo

49+ Distribution.Nixpkgs.Haskell.Constraint

50+ Distribution.Nixpkgs.Haskell.Derivation

51+ Distribution.Nixpkgs.Haskell.FromCabal

52+ Distribution.Nixpkgs.Haskell.FromCabal.Configuration

53+ Distribution.Nixpkgs.Haskell.FromCabal.Flags

54+ Distribution.Nixpkgs.Haskell.FromCabal.License

55+ Distribution.Nixpkgs.Haskell.FromCabal.Name

56+ Distribution.Nixpkgs.Haskell.FromCabal.Normalize

57+ Distribution.Nixpkgs.Haskell.FromCabal.PostProcess

58+ Distribution.Nixpkgs.Haskell.Hackage

59+ Distribution.Nixpkgs.Haskell.OrphanInstances

60+ Distribution.Nixpkgs.Haskell.PackageSourceSpec

61+ other-modules: Paths_cabal2nix

95− hs-source-dirs:

62+ hs-source-dirs: src

96− src

97− other-extensions: CPP DeriveGeneric FlexibleInstances MultiParamTypeClasses OverloadedStrings RecordWildCards ScopedTypeVariables StandaloneDeriving TemplateHaskell

98− ghc-options: -Wall

99− build-depends:

63+ build-depends: base > 4.11

100− Cabal >2

64+ , Cabal == 3.0.*

101− , aeson

65+ , aeson > 1

102− , ansi-wl-pprint

66+ , ansi-wl-pprint

103− , base <5

104− , bytestring

67+ , bytestring

105− , containers

68+ , containers >= 0.5.9

106− , deepseq >=1.4

69+ , deepseq >= 1.4

107− , directory

70+ , directory

108− , distribution-nixpkgs >=1.1

71+ , distribution-nixpkgs >= 1.3.1

109− , filepath

72+ , filepath

110− , hackage-db >2

73+ , hackage-db >= 2.0.1

111− , hopenssl >=2

74+ , hopenssl >= 2

112− , hpack >= 0.26

75+ , hpack >= 0.29.6

113− , language-nix

76+ , language-nix

114− , lens

77+ , lens

115− , optparse-applicative

78+ , optparse-applicative

116− , pretty >=1.1.2

79+ , pretty >= 1.1.2

117− , process

80+ , process

118− , split

81+ , split

119− , text

82+ , text

120− , time

83+ , time

121− , transformers

84+ , transformers

122− , yaml

85+ , yaml

123− exposed-modules:

124− Cabal2nix

125− Distribution.Nixpkgs.Fetch

126− Distribution.Nixpkgs.Haskell

127− Distribution.Nixpkgs.Haskell.BuildInfo

128− Distribution.Nixpkgs.Haskell.Constraint

129− Distribution.Nixpkgs.Haskell.Derivation

130− Distribution.Nixpkgs.Haskell.FromCabal

131− Distribution.Nixpkgs.Haskell.FromCabal.Configuration

132− Distribution.Nixpkgs.Haskell.FromCabal.Flags

133− Distribution.Nixpkgs.Haskell.FromCabal.License

134− Distribution.Nixpkgs.Haskell.FromCabal.Name

135− Distribution.Nixpkgs.Haskell.FromCabal.Normalize

136− Distribution.Nixpkgs.Haskell.FromCabal.PostProcess

137− Distribution.Nixpkgs.Haskell.Hackage

138− Distribution.Nixpkgs.Haskell.OrphanInstances

139− Distribution.Nixpkgs.Haskell.PackageSourceSpec

140− other-modules:

141− Paths_cabal2nix

142− default-language: Haskell2010

86+ default-language: Haskell2010

87+ other-extensions: MultiParamTypeClasses

88+ ScopedTypeVariables

89+ FlexibleInstances

90+ CPP

91+ TemplateHaskell

92+ StandaloneDeriving

93+ RecordWildCards

94+ OverloadedStrings

95+ DeriveGeneric

96+ ghc-options: -Wall -Wcompat -Wincomplete-uni-patterns -Wincomplete-record-updates

97+ -Wredundant-constraints

143

98

144executable cabal2nix

99executable cabal2nix

145− main-is: Main.hs

100+ main-is: Main.hs

146− hs-source-dirs: cabal2nix

101+ hs-source-dirs: cabal2nix

147− ghc-options: -Wall

148− build-depends: base, cabal2nix

102+ build-depends: base, cabal2nix

149− default-language: Haskell2010

103+ default-language: Haskell2010

104+ ghc-options: -Wall -Wcompat -Wincomplete-uni-patterns -Wincomplete-record-updates

105+ -Wredundant-constraints

150

106

151executable hackage2nix

107executable hackage2nix

152− main-is: Main.hs

108+ main-is: Main.hs

109+ other-modules: HackageGit

110+ Paths_cabal2nix

153− hs-source-dirs: hackage2nix

111+ hs-source-dirs: hackage2nix

154− ghc-options: -Wall -threaded -rtsopts -with-rtsopts=-N

155− build-depends:

112+ build-depends: base < 5

156− Cabal >2

113+ , Cabal

157− , aeson

114+ , aeson

158− , base <5

159− , bytestring

115+ , bytestring

160− , cabal2nix

116+ , cabal2nix

161− , containers

117+ , containers

162− , directory

118+ , directory

163− , distribution-nixpkgs >=1.1

119+ , distribution-nixpkgs >= 1.2

164− , filepath

120+ , filepath

165− , hopenssl >=2

121+ , hopenssl >= 2

166− , language-nix

122+ , language-nix

167− , lens

123+ , lens

168− , monad-par

124+ , monad-par

169− , monad-par-extras

125+ , monad-par-extras

170− , mtl

126+ , mtl

171− , optparse-applicative

127+ , optparse-applicative

172− , pretty >=1.1.2

128+ , pretty >= 1.1.2

173− , utf8-string

174− other-modules:

175− Paths_cabal2nix

176− HackageGit

177− default-language: Haskell2010

129+ default-language: Haskell2010

130+ ghc-options: -Wall -Wcompat -Wincomplete-uni-patterns -Wincomplete-record-updates

131+ -Wredundant-constraints -threaded -rtsopts -with-rtsopts=-maxN16

178

132

179test-suite regression-test

133test-suite regression-test

180− type: exitcode-stdio-1.0

134+ type: exitcode-stdio-1.0

181− main-is: Main.hs

135+ main-is: Main.hs

182− hs-source-dirs: test

136+ hs-source-dirs: test

183− build-depends: base

137+ build-depends: base

184− , Cabal > 2

138+ , Cabal

185− , cabal2nix

139+ , cabal2nix

140+ , containers

141+ , directory

186− , filepath

142+ , filepath

187− , language-nix

143+ , language-nix

188− , lens

144+ , lens

189− , pretty

145+ , pretty

146+ , process > 1.2

190− , tasty

147+ , tasty

191− , tasty-golden

148+ , tasty-golden

192− ghc-options: -Wall

149+ default-language: Haskell2010

193− default-language: Haskell2010

150+ build-tools: cabal2nix

151+ ghc-options: -Wall -Wcompat -Wincomplete-uni-patterns -Wincomplete-record-updates

152+ -Wredundant-constraints -threaded -with-rtsopts=-K64K

doc/01-use-function-application-to-escape-override-hell.md+1−1

@@ -116,7 +116,7 @@ reflection. Nixpkgs defines the Haskell package set recursively as a function

116produce and then uses that information to the produce the attribute set it's

117already received as an argument. It's a mind-boggling way to define a recursive

118attribute set `rec { ... }` without actually using the `rec` keyword. Every

119−computable function of this kind has a fixed point: a value `x` that satifies

119+computable function of this kind has a fixed point: a value `x` that satisfies

120`f x = x`. That `x` is the result we actually want --- it's an ordinary

121attribute set with all the `self`-references resolved and replaced by actual

122values. The details of fixed points aren't important, though. What's important

doc/hal8.md+1−1

@@ -190,7 +190,7 @@ Haskell Platform later, so one doesn't have to worry that every single install

190is going to be that expensive.

191

192In its last step, `nix-env` creates a "user environment" at

193−`$HOME/.nix-profile`, which simplies use of the installed packages a lot. That

193+`$HOME/.nix-profile`, which simplifies use of the installed packages a lot. That

194environment uses symlinks to create a view of the Nix store that combines those

195packages that have been installed into a single hierarchy. For example, the

196path `~/.nix-profile/bin/ghc` will be a symlink to

hackage2nix/HackageGit.hs+4−9

@@ -10,17 +10,15 @@ module HackageGit

10import Control.Lens hiding ( (<.>) )

11import Control.Monad

12import Data.Aeson

13−import Data.ByteString.Char8 ( ByteString )

14import qualified Data.ByteString.Char8 as BS

13import qualified Data.ByteString.Char8 as BS

15import Data.Map as Map

14import Data.Map as Map

16import Data.Set as Set

15import Data.Set as Set

17import Data.String

16import Data.String

18−import Data.String.UTF8 ( toString, fromRep )

19import Distribution.Nixpkgs.Hashes

17import Distribution.Nixpkgs.Hashes

20import Distribution.Nixpkgs.Haskell.OrphanInstances ( )

18import Distribution.Nixpkgs.Haskell.OrphanInstances ( )

21import Distribution.Package

19import Distribution.Package

22import Distribution.PackageDescription

20import Distribution.PackageDescription

23−import Distribution.PackageDescription.Parse ( parseGenericPackageDescription, ParseResult(..) )

21+import Distribution.PackageDescription.Parsec ( parseGenericPackageDescriptionMaybe )

24import Distribution.Text

22import Distribution.Text

25import Distribution.Version

23import Distribution.Version

26import OpenSSL.Digest ( digest, digestByName )

24import OpenSSL.Digest ( digest, digestByName )

@@ -42,18 +40,15 @@ getSubDirs path = do

42 let isDirectory p = doesDirectoryExist (path </> p)

40 let isDirectory p = doesDirectoryExist (path </> p)

43 getDirectoryContents path >>= filterM isDirectory . Prelude.filter (\x -> head x /= '.')

41 getDirectoryContents path >>= filterM isDirectory . Prelude.filter (\x -> head x /= '.')

44

42

45−decodeUTF8 :: ByteString -> String

46−decodeUTF8 = toString . fromRep

47−

48type SHA256Hash = String

43type SHA256Hash = String

49

44

50readPackage :: FilePath -> PackageIdentifier -> IO (GenericPackageDescription, SHA256Hash)

45readPackage :: FilePath -> PackageIdentifier -> IO (GenericPackageDescription, SHA256Hash)

51readPackage dirPrefix (PackageIdentifier name version) = do

46readPackage dirPrefix (PackageIdentifier name version) = do

52 let cabalFile = dirPrefix </> unPackageName name </> display version </> unPackageName name <.> "cabal"

47 let cabalFile = dirPrefix </> unPackageName name </> display version </> unPackageName name <.> "cabal"

53 buf <- BS.readFile cabalFile

48 buf <- BS.readFile cabalFile

54− cabal <- case parseGenericPackageDescription (decodeUTF8 buf) of

49+ cabal <- case parseGenericPackageDescriptionMaybe buf of

55− ParseOk _ a -> return a

50+ Just a -> return a

56− ParseFailed err -> fail (cabalFile ++ ": " ++ show err)

51+ Nothing -> fail ("cannot parse cabal file " ++ cabalFile)

57 return (cabal, printSHA256 (digest (digestByName "sha256") buf))

52 return (cabal, printSHA256 (digest (digestByName "sha256") buf))

58

53

59declareLenses [d|

54declareLenses [d|

hackage2nix/Main.hs+30−19

@@ -10,11 +10,10 @@ import Control.Monad

10import Control.Monad.Par.Combinator

11import Control.Monad.Par.IO

12import Control.Monad.Trans ( liftIO )

13−import Data.List

13+import Data.List ( intercalate )

14import Data.Map.Strict ( Map )

15import qualified Data.Map.Strict as Map

16import Data.Maybe

17−import Data.Monoid

18import Data.Set ( Set )

17import Data.Set ( Set )

19import qualified Data.Set as Set

18import qualified Data.Set as Set

20import Data.String

19import Data.String

@@ -24,10 +23,11 @@ import Distribution.Nixpkgs.Haskell.Constraint

24import Distribution.Nixpkgs.Haskell.FromCabal

23import Distribution.Nixpkgs.Haskell.FromCabal

25import Distribution.Nixpkgs.Haskell.FromCabal.Configuration as Config

24import Distribution.Nixpkgs.Haskell.FromCabal.Configuration as Config

26import Distribution.Nixpkgs.Haskell.FromCabal.Flags

25import Distribution.Nixpkgs.Haskell.FromCabal.Flags

26+import Distribution.Nixpkgs.Haskell.OrphanInstances ( )

27import Distribution.Nixpkgs.Meta

28import Distribution.Nixpkgs.PackageMap

29import Distribution.Package

30−import Distribution.PackageDescription hiding ( options, buildDepends, extraLibs, buildTools )

30+import Distribution.PackageDescription hiding ( options, extraLibs, buildTools, homepage )

31import Distribution.System

32import Distribution.Text

33import Distribution.Version

@@ -63,7 +63,7 @@ main = do

63 pinfo :: ParserInfo CLI

64 pinfo = info

65 ( helper

66− <*> infoOption ("hackage2nix " ++ display Main.version) (long "version" <> help "Show version number")

66+ <*> infoOption ("hackage2nix " ++ prettyShow Main.version) (long "version" <> help "Show version number")

67 <*> cliOptions

68 )

69 ( fullDesc

@@ -72,15 +72,15 @@ main = do

72 CLI {..} <- execParser pinfo

73

74 config <- readConfiguration (nixpkgsRepository </> configFile)

75− nixpkgs <- readNixpkgPackageMap nixpkgsRepository Nothing

75+ nixpkgs <- readNixpkgPackageMap ["-f", nixpkgsRepository, "--arg", "config", "{ allowAliases = false; }"]

76 preferredVersions <- readPreferredVersions (fromMaybe (hackageRepository </> "preferred-versions") preferredVersionsFile)

77 let fixup = Map.delete "acme-everything" -- TODO: https://github.com/NixOS/cabal2nix/issues/164

78 . Map.delete "som" -- TODO: https://github.com/NixOS/cabal2nix/issues/164

79 . Map.delete "type" -- TODO: https://github.com/NixOS/cabal2nix/issues/163

80 . Map.delete "control-invariants" -- TODO: depends on "assert"

81+ . Map.delete "with" -- TODO: https://github.com/NixOS/cabal2nix/issues/164

82+ . Map.delete "telega" -- TODO: depends on "with"

81− . over (at ("hermes")) ((fmap (set (contains "1.3.4.3") False))) -- TODO: https://github.com/haskell/hackage-server/issues/436

83+ . over (at "hermes") (fmap (set (contains "1.3.4.3") False)) -- TODO: https://github.com/haskell/hackage-server/issues/436

82− . over (at ("gogol-admin-reports")) ((fmap (set (contains "0.2.0") False))) -- TODO: https://github.com/commercialhaskell/all-cabal-hashes/issues/11

83− . over (at ("wai-middleware-prometheus")) ((fmap (set (contains "0.2.0") False))) -- TODO: https://github.com/commercialhaskell/all-cabal-hashes/issues/15

84 hackage <- fixup <$> readHackage hackageRepository

85 let

86 hackagePackagesFile :: FilePath

@@ -93,7 +93,7 @@ main = do

93 latestVersionSet = Map.map Set.findMax (Map.filter (not . Set.null) (Map.mapWithKey (enforcePreferredVersions preferredVersions) hackage))

94

95 defaultPackageOverridesSet :: PackageSet

96− defaultPackageOverridesSet = Map.fromList [ (name, resolveConstraint c hackage) | c@(Dependency name _) <- defaultPackageOverrides config ]

96+ defaultPackageOverridesSet = Map.fromList [ (name, resolveConstraint c hackage) | c@(Dependency name _ _) <- defaultPackageOverrides config ]

97

98 generatedDefaultPackageSet :: PackageSet

99 generatedDefaultPackageSet = (defaultPackageOverridesSet `Map.union` latestVersionSet) `Map.difference` corePackageSet

@@ -106,7 +106,7 @@ main = do

106

107 extraPackageSet :: PackageMultiSet

108 extraPackageSet = Map.unionsWith Set.union

109− [ Map.singleton name (Set.singleton (resolveConstraint c hackage)) | c@(Dependency name _) <- extraPackages config ]

109+ [ Map.singleton name (Set.singleton (resolveConstraint c hackage)) | c@(Dependency name _ _) <- extraPackages config ]

110

111 db :: PackageMultiSet

112 db = Map.unionsWith Set.union [ Map.map Set.singleton generatedDefaultPackageSet

@@ -116,7 +116,7 @@ main = do

116 ]

117

118 haskellResolver :: Dependency -> Bool

119− haskellResolver (Dependency name vrange)

119+ haskellResolver (Dependency name vrange _)

120 | Just v <- Map.lookup name corePackageSet = v `withinRange` vrange

121 | Just v <- Map.lookup name generatedDefaultPackageSet = v `withinRange` vrange

122 | otherwise = False

@@ -135,8 +135,13 @@ main = do

135 (descr, cabalSHA256) <- readPackage hackageRepository pkgId

136 meta <- readPackageMeta hackageRepository pkgId

137

138− let isInDefaultPackageSet :: Bool

138+ let isInDefaultPackageSet, isHydraEnabled, isBroken :: Bool

139− isInDefaultPackageSet = maybe False (== v) (Map.lookup name generatedDefaultPackageSet)

139+ isInDefaultPackageSet = (== Just v) (Map.lookup name generatedDefaultPackageSet)

140+ isHydraEnabled = isInDefaultPackageSet && not (isBroken || name `Set.member` dontDistributePackages config)

141+ isBroken = any (withinRange v) [ vr | Dependency pn vr _ <- brokenPackages config, pn == name ]

142+

143+ droppedPlatforms :: Set Platform

144+ droppedPlatforms = Map.findWithDefault mempty name (unsupportedPlatforms config)

140

145

141 tarballSHA256 :: SHA256Hash

146 tarballSHA256 :: SHA256Hash

142 tarballSHA256 = fromMaybe (error (display pkgId ++ ": meta data has no hash for the tarball"))

147 tarballSHA256 = fromMaybe (error (display pkgId ++ ": meta data has no hash for the tarball"))

@@ -150,14 +155,17 @@ main = do

150

155

151 drv :: Derivation

156 drv :: Derivation

152 drv = fromGenericPackageDescription haskellResolver nixpkgsResolver targetPlatform (compilerInfo config) flagAssignment [] descr

157 drv = fromGenericPackageDescription haskellResolver nixpkgsResolver targetPlatform (compilerInfo config) flagAssignment [] descr

153− & src .~ DerivationSource "url" ("mirror://hackage/" ++ display pkgId ++ ".tar.gz") "" tarballSHA256

158+ & src .~ urlDerivationSource ("mirror://hackage/" ++ display pkgId ++ ".tar.gz") tarballSHA256

154 & editedCabalFile .~ cabalSHA256

159 & editedCabalFile .~ cabalSHA256

155− & metaSection.hydraPlatforms %~ (`Set.difference` Map.findWithDefault Set.empty name (dontDistributePackages config))

160+ & metaSection.platforms %~ (`Set.difference` Map.findWithDefault Set.empty name (unsupportedPlatforms config))

161+ & metaSection.hydraPlatforms %~ (if Set.null droppedPlatforms then id else (`Set.difference` droppedPlatforms))

162+ & metaSection.hydraPlatforms %~ (if isHydraEnabled then id else const Set.empty)

163+ & metaSection.broken ||~ isBroken

156 & metaSection.maintainers .~ Map.findWithDefault Set.empty name globalPackageMaintainers

164 & metaSection.maintainers .~ Map.findWithDefault Set.empty name globalPackageMaintainers

157− & metaSection.hydraPlatforms %~ (if isInDefaultPackageSet then id else const Set.empty)

165+ & metaSection.homepage .~ ""

158

166

159 overrides :: Doc

167 overrides :: Doc

160− overrides = fcat $ punctuate space [ disp b <> semi | b <- Set.toList ((view (dependencies . each) drv) `Set.union` view extraFunctionArgs drv), not (isFromHackage b) ]

168+ overrides = fcat $ punctuate space [ pPrint b <> semi | b <- Set.toList (view (dependencies . each) drv `Set.union` view extraFunctionArgs drv), not (isFromHackage b) ]

161 return $ render $ nest 2 $

169 return $ render $ nest 2 $

162 hang (doubleQuotes (text attr) <+> equals <+> text "callPackage") 2 (parens (pPrint drv)) <+> (braces overrides <> semi)

170 hang (doubleQuotes (text attr) <+> equals <+> text "callPackage") 2 (parens (pPrint drv)) <+> (braces overrides <> semi)

163

171

@@ -191,10 +199,13 @@ enforcePreferredVersions cs pkg = Set.filter (\v -> PackageIdentifier pkg v `sat

191

199

192resolveConstraint :: Constraint -> Hackage -> Version

200resolveConstraint :: Constraint -> Hackage -> Version

193resolveConstraint c = fromMaybe (error msg) . resolveConstraint' c

201resolveConstraint c = fromMaybe (error msg) . resolveConstraint' c

194− where msg = "constraint " ++ display c ++ " cannot be resolved in Hackage"

202+ where msg = unlines [ "constraint " ++ display c ++ " cannot be resolved in Hackage"

203+ , "This could be due the package being missing in the hackage directory"

204+ , "or the file system not being case sensitive."

205+ ]

195

206

196resolveConstraint' :: Constraint -> Hackage -> Maybe Version

207resolveConstraint' :: Constraint -> Hackage -> Maybe Version

197−resolveConstraint' (Dependency name vrange) hackage

208+resolveConstraint' (Dependency name vrange _) hackage

198 | Just vset' <- Map.lookup name hackage

209 | Just vset' <- Map.lookup name hackage

199 , vset <- Set.filter (`withinRange` vrange) vset'

210 , vset <- Set.filter (`withinRange` vrange) vset'

200 , not (Set.null vset) = Just (Set.findMax vset)

211 , not (Set.null vset) = Just (Set.findMax vset)

hackage2nix/README.md+3

@@ -15,6 +15,9 @@ and we want to check that hackage-packages.nix will be updated correctly.

15On macOS you can use [this](https://gist.github.com/dixson3/8360571) to create one

16(you can replace 60g with 4g as that should be plenty).

17

18+There is a [video on YouTube](https://www.youtube.com/watch?v=qX0mgtSm360)

19+that gives a thorough walk-through of these steps.

20+

18#### Setup

21#### Setup

19Replace `git@github.com:NixOS/nixpkgs.git` with a fork you have access to.

22Replace `git@github.com:NixOS/nixpkgs.git` with a fork you have access to.

20```

23```

src/Cabal2nix.hs+98−46

@@ -1,51 +1,54 @@

1−{-# LANGUAGE RecordWildCards #-}

1+{-# LANGUAGE LambdaCase #-}

2{-# LANGUAGE OverloadedStrings #-}

3+{-# LANGUAGE RecordWildCards #-}

3

4

4module Cabal2nix

5module Cabal2nix

5− ( main, cabal2nix, cabal2nix', cabal2nixWithDB

6+ ( main, cabal2nix, cabal2nix', cabal2nixWithDB, parseArgs

7+ , Options(..)

6 )

8 )

7 where

9 where

8

10

9import Control.Exception ( bracket )

11import Control.Exception ( bracket )

10import Control.Lens

12import Control.Lens

11−import Control.Monad ( when )

13+import Control.Monad

14+import Data.List ( intercalate, isPrefixOf )

15+import Data.List.Split

12−import Data.Maybe ( fromMaybe, isJust )

16+import Data.Maybe ( fromMaybe, isJust, listToMaybe )

13−import Data.Monoid ( (<>) )

14import qualified Data.Set as Set

17import qualified Data.Set as Set

15import Data.String

18import Data.String

16import Data.Time

19import Data.Time

17−import qualified Distribution.Compat.ReadP as P

18import Distribution.Compiler

20import Distribution.Compiler

19import Distribution.Nixpkgs.Fetch

21import Distribution.Nixpkgs.Fetch

20import Distribution.Nixpkgs.Haskell

22import Distribution.Nixpkgs.Haskell

21import Distribution.Nixpkgs.Haskell.FromCabal

23import Distribution.Nixpkgs.Haskell.FromCabal

22−import Distribution.Nixpkgs.Haskell.FromCabal.Normalize ( normalizeCabalFlags )

23import Distribution.Nixpkgs.Haskell.FromCabal.Flags

24import Distribution.Nixpkgs.Haskell.FromCabal.Flags

24import qualified Distribution.Nixpkgs.Haskell.FromCabal.PostProcess as PP (pkg)

25import qualified Distribution.Nixpkgs.Haskell.FromCabal.PostProcess as PP (pkg)

25import qualified Distribution.Nixpkgs.Haskell.Hackage as DB

26import qualified Distribution.Nixpkgs.Haskell.Hackage as DB

27+import Distribution.Nixpkgs.Haskell.OrphanInstances ( )

26import Distribution.Nixpkgs.Haskell.PackageSourceSpec

28import Distribution.Nixpkgs.Haskell.PackageSourceSpec

27import Distribution.Nixpkgs.Meta

29import Distribution.Nixpkgs.Meta

28−import Distribution.PackageDescription ( mkFlagName, FlagAssignment )

29import Distribution.Package ( packageId )

30import Distribution.Package ( packageId )

31+import Distribution.PackageDescription ( mkFlagName, mkFlagAssignment, FlagAssignment )

32+import Distribution.Parsec as P

30import Distribution.Simple.Utils ( lowercase )

33import Distribution.Simple.Utils ( lowercase )

31import Distribution.System

34import Distribution.System

32−import Distribution.Text

33import Language.Nix

35import Language.Nix

34import Options.Applicative

36import Options.Applicative

35import Paths_cabal2nix ( version )

37import Paths_cabal2nix ( version )

36import System.Environment ( getArgs )

38import System.Environment ( getArgs )

37import System.IO ( hFlush, hPutStrLn, stdout, stderr )

39import System.IO ( hFlush, hPutStrLn, stdout, stderr )

38import qualified Text.PrettyPrint.ANSI.Leijen as P2

40import qualified Text.PrettyPrint.ANSI.Leijen as P2

39−import Text.PrettyPrint.HughesPJClass ( Doc, Pretty(..), text, vcat, hcat, semi )

41+import Text.PrettyPrint.HughesPJClass ( Doc, Pretty(..), text, vcat, hcat, semi, render, prettyShow )

40

42

41data Options = Options

43data Options = Options

42 { optSha256 :: Maybe String

44 { optSha256 :: Maybe String

43 , optMaintainer :: [String]

45 , optMaintainer :: [String]

44--, optPlatform :: [String] -- TODO: fix command line handling of platforms

46--, optPlatform :: [String] -- TODO: fix command line handling of platforms

45 , optHaddock :: Bool

47 , optHaddock :: Bool

46− , optHpack :: Bool

48+ , optHpack :: HpackUse

47 , optDoCheck :: Bool

49 , optDoCheck :: Bool

48 , optJailbreak :: Bool

50 , optJailbreak :: Bool

51+ , optDoBenchmark :: Bool

49 , optRevision :: Maybe String

52 , optRevision :: Maybe String

50 , optHyperlinkSource :: Bool

53 , optHyperlinkSource :: Bool

51 , optEnableLibraryProfiling :: Bool

54 , optEnableLibraryProfiling :: Bool

@@ -59,9 +62,10 @@ data Options = Options

59 , optSystem :: Platform

62 , optSystem :: Platform

60 , optSubpath :: Maybe FilePath

63 , optSubpath :: Maybe FilePath

61 , optHackageSnapshot :: Maybe UTCTime

64 , optHackageSnapshot :: Maybe UTCTime

65+ , optNixpkgsIdentifier :: NixpkgsResolver

62 , optUrl :: String

66 , optUrl :: String

67+ , optFetchSubmodules :: Bool

63 }

68 }

64− deriving (Show)

65

69

66options :: Parser Options

70options :: Parser Options

67options = Options

71options = Options

@@ -69,9 +73,17 @@ options = Options

69 <*> many (strOption $ long "maintainer" <> metavar "MAINTAINER" <> help "maintainer of this package (may be specified multiple times)")

73 <*> many (strOption $ long "maintainer" <> metavar "MAINTAINER" <> help "maintainer of this package (may be specified multiple times)")

70-- <*> many (strOption $ long "platform" <> metavar "PLATFORM" <> help "supported build platforms (may be specified multiple times)")

74-- <*> many (strOption $ long "platform" <> metavar "PLATFORM" <> help "supported build platforms (may be specified multiple times)")

71 <*> flag True False (long "no-haddock" <> help "don't run Haddock when building this package")

75 <*> flag True False (long "no-haddock" <> help "don't run Haddock when building this package")

76+ <*>

77+ (

72− <*> switch (long "hpack" <> help "run hpack before configuring this package (only non-hackage packages)")

78+ flag' ForceHpack (long "hpack" <> help "run hpack before configuring this package (only non-hackage packages)")

79+ <|>

80+ flag' NoHpack (long "no-hpack" <> help "disable hpack run and use only cabal disregarding package.yaml existence")

81+ <|>

82+ pure PackageYamlHpack

83+ )

73 <*> flag True False (long "no-check" <> help "don't run regression test suites of this package")

84 <*> flag True False (long "no-check" <> help "don't run regression test suites of this package")

74 <*> switch (long "jailbreak" <> help "disregard version restrictions on build inputs")

85 <*> switch (long "jailbreak" <> help "disregard version restrictions on build inputs")

86+ <*> switch (long "benchmark" <> help "enable benchmarks for this package")

75 <*> optional (strOption $ long "revision" <> help "revision to use when fetching from VCS")

87 <*> optional (strOption $ long "revision" <> help "revision to use when fetching from VCS")

76 <*> flag True False (long "no-hyperlink-source" <> help "don't generate pretty-printed source code for the documentation")

88 <*> flag True False (long "no-hyperlink-source" <> help "don't generate pretty-printed source code for the documentation")

77 <*> switch (long "enable-library-profiling" <> help "enable library profiling in the generated build")

89 <*> switch (long "enable-library-profiling" <> help "enable library profiling in the generated build")

@@ -81,11 +93,13 @@ options = Options

81 <*> optional (strOption $ long "hackage-db" <> metavar "PATH" <> help "path to the local hackage db in tar format")

93 <*> optional (strOption $ long "hackage-db" <> metavar "PATH" <> help "path to the local hackage db in tar format")

82 <*> switch (long "shell" <> help "generate output suitable for nix-shell")

94 <*> switch (long "shell" <> help "generate output suitable for nix-shell")

83 <*> many (strOption $ short 'f' <> long "flag" <> help "Cabal flag (may be specified multiple times)")

95 <*> many (strOption $ short 'f' <> long "flag" <> help "Cabal flag (may be specified multiple times)")

84− <*> option (readP parse) (long "compiler" <> help "compiler to use when evaluating the Cabal file" <> value buildCompilerId <> showDefaultWith display)

96+ <*> option parseCabal (long "compiler" <> help "compiler to use when evaluating the Cabal file" <> value buildCompilerId <> showDefaultWith prettyShow)

85− <*> option (readP parsePlatform) (long "system" <> help "target system to use when evaluating the Cabal file" <> value buildPlatform <> showDefaultWith display)

97+ <*> option (maybeReader parsePlatform) (long "system" <> help "host system (in either short Nix format or full LLVM style) to use when evaluating the Cabal file" <> value buildPlatform <> showDefaultWith prettyShow)

86 <*> optional (strOption $ long "subpath" <> metavar "PATH" <> help "Path to Cabal file's directory relative to the URI (default is root directory)")

98 <*> optional (strOption $ long "subpath" <> metavar "PATH" <> help "Path to Cabal file's directory relative to the URI (default is root directory)")

87 <*> optional (option utcTimeReader (long "hackage-snapshot" <> help "hackage snapshot time, ISO format"))

99 <*> optional (option utcTimeReader (long "hackage-snapshot" <> help "hackage snapshot time, ISO format"))

100+ <*> pure (\i -> Just (binding # (i, path # [ident # "pkgs", i])))

88 <*> strArgument (metavar "URI")

101 <*> strArgument (metavar "URI")

102+ <*> flag True False (long "dont-fetch-submodules" <> help "do not fetch git submodules from git sources")

89

103

90-- | A parser for the date. Hackage updates happen maybe once or twice a month.

104-- | A parser for the date. Hackage updates happen maybe once or twice a month.

91-- Example: parseTime defaultTimeLocale "%FT%T%QZ" "2017-11-20T12:18:35Z" :: Maybe UTCTime

105-- Example: parseTime defaultTimeLocale "%FT%T%QZ" "2017-11-20T12:18:35Z" :: Maybe UTCTime

@@ -95,21 +109,60 @@ utcTimeReader = eitherReader $ \arg ->

95 Nothing -> Left $ "Cannot parse date, ISO format used ('2017-11-20T12:18:35Z'): " ++ arg

109 Nothing -> Left $ "Cannot parse date, ISO format used ('2017-11-20T12:18:35Z'): " ++ arg

96 Just utcTime -> Right utcTime

110 Just utcTime -> Right utcTime

97

111

98−readP :: P.ReadP a a -> ReadM a

112+parseCabal :: Parsec a => ReadM a

99−readP p = eitherReader $ \s -> case [ r' | (r',"") <- P.readP_to_S p s ] of

113+parseCabal = eitherReader eitherParsec

100− (r:_) -> Right r

114+

101− _ -> Left ("invalid value " ++ show s)

115+-- | Replicate the normalization performed by GHC_CONVERT_CPU in GHC's aclocal.m4

116+-- since the output of that is what Cabal parses.

117+ghcConvertArch :: String -> String

118+ghcConvertArch arch = case arch of

119+ "i486" -> "i386"

120+ "i586" -> "i386"

121+ "i686" -> "i386"

122+ "amd64" -> "x86_64"

123+ _ -> fromMaybe arch $ listToMaybe

124+ [prefix | prefix <- archPrefixes, prefix `isPrefixOf` arch]

125+ where archPrefixes =

126+ [ "aarch64", "alpha", "arm", "hppa1_1", "hppa", "m68k", "mipseb"

127+ , "mipsel", "mips", "powerpc64le", "powerpc64", "powerpc", "s390x"

128+ , "sparc64", "sparc"

129+ ]

130+

131+-- | Replicate the normalization performed by GHC_CONVERT_OS in GHC's aclocal.m4

132+-- since the output of that is what Cabal parses.

133+ghcConvertOS :: String -> String

134+ghcConvertOS os = case os of

135+ "watchos" -> "ios"

136+ "tvos" -> "ios"

137+ "linux-android" -> "linux-android"

138+ "linux-androideabi" -> "linux-androideabi"

139+ _ | "linux-" `isPrefixOf` os -> "linux"

140+ _ -> fromMaybe os $ listToMaybe

141+ [prefix | prefix <- osPrefixes, prefix `isPrefixOf` os]

142+ where osPrefixes =

143+ [ "gnu", "openbsd", "aix", "darwin", "solaris2", "freebsd", "nto-qnx"]

144+

145+parseArch :: String -> Arch

146+parseArch = classifyArch Permissive . ghcConvertArch

147+

148+parseOS :: String -> OS

149+parseOS = classifyOS Permissive . ghcConvertOS

102

150

103−parsePlatform :: P.ReadP r Platform

151+parsePlatform :: String -> Maybe Platform

104−parsePlatform = do arch <- P.choice [P.string "i686" >> return I386, P.string "x86_64" >> return X86_64]

152+parsePlatform = parsePlatformParts . splitOn "-"

105− _ <- P.char '-'

153+

106− os <- P.choice [P.string "linux" >> return Linux, P.string "darwin" >> return OSX]

154+parsePlatformParts :: [String] -> Maybe Platform

107− return (Platform arch os)

155+parsePlatformParts = \case

156+ [arch, os] ->

157+ Just $ Platform (parseArch arch) (parseOS os)

158+ (arch : _ : osParts) ->

159+ Just $ Platform (parseArch arch) $ parseOS $ intercalate "-" osParts

160+ _ -> Nothing

108

161

109pinfo :: ParserInfo Options

162pinfo :: ParserInfo Options

110pinfo = info

163pinfo = info

111 ( helper

164 ( helper

112− <*> infoOption ("cabal2nix " ++ display version) (long "version" <> help "Show version number")

165+ <*> infoOption ("cabal2nix " ++ prettyShow version) (long "version" <> help "Show version number")

113 <*> options

166 <*> options

114 )

167 )

115 ( fullDesc

168 ( fullDesc

@@ -138,23 +191,21 @@ main = bracket (return ()) (\() -> hFlush stdout >> hFlush stderr) $ \() ->

138 cabal2nix =<< getArgs

191 cabal2nix =<< getArgs

139

192

140hpackOverrides :: Derivation -> Derivation

193hpackOverrides :: Derivation -> Derivation

141−hpackOverrides = over phaseOverrides (++ "preConfigure = \"hpack\";")

194+hpackOverrides = over phaseOverrides (++ "prePatch = \"hpack\";")

142 . set (libraryDepends . tool . contains (PP.pkg "hpack")) True

195 . set (libraryDepends . tool . contains (PP.pkg "hpack")) True

143

196

144−cabal2nix' :: [String] -> IO (Either Doc Derivation)

197+cabal2nix' :: Options -> IO (Either Doc Derivation)

145−cabal2nix' args = do

198+cabal2nix' opts@Options{..} = do

146− opts@Options {..} <- handleParseResult $ execParserPure defaultPrefs pinfo args

199+ pkg <- getPackage optHpack optFetchSubmodules optHackageDb optHackageSnapshot $

147−

148− pkg <- getPackage optHpack optHackageDb optHackageSnapshot $ Source optUrl (fromMaybe "" optRevision) (maybe UnknownHash Guess optSha256) (fromMaybe "" optSubpath)

200+ Source optUrl (fromMaybe "" optRevision) (maybe UnknownHash Guess optSha256) (fromMaybe "" optSubpath)

149 processPackage opts pkg

201 processPackage opts pkg

150

202

151−cabal2nixWithDB :: DB.HackageDB -> [String] -> IO (Either Doc Derivation)

203+cabal2nixWithDB :: DB.HackageDB -> Options -> IO (Either Doc Derivation)

152−cabal2nixWithDB db args = do

204+cabal2nixWithDB db opts@Options{..} = do

153− opts@Options {..} <- handleParseResult $ execParserPure defaultPrefs pinfo args

154 when (isJust optHackageDb) $ hPutStrLn stderr "WARN: HackageDB provided directly; ignoring --hackage-db"

205 when (isJust optHackageDb) $ hPutStrLn stderr "WARN: HackageDB provided directly; ignoring --hackage-db"

155 when (isJust optHackageSnapshot) $ hPutStrLn stderr "WARN: HackageDB provided directly; ignoring --hackage-snapshot"

206 when (isJust optHackageSnapshot) $ hPutStrLn stderr "WARN: HackageDB provided directly; ignoring --hackage-snapshot"

156−

207+ pkg <- getPackage' optHpack optFetchSubmodules (return db) $

157− pkg <- getPackage' optHpack (return db) $ Source optUrl (fromMaybe "" optRevision) (maybe UnknownHash Guess optSha256) (fromMaybe "" optSubpath)

208+ Source optUrl (fromMaybe "" optRevision) (maybe UnknownHash Guess optSha256) (fromMaybe "" optSubpath)

158 processPackage opts pkg

209 processPackage opts pkg

159

210

160processPackage :: Options -> Package -> IO (Either Doc Derivation)

211processPackage :: Options -> Package -> IO (Either Doc Derivation)

@@ -164,12 +215,11 @@ processPackage Options{..} pkg = do

164 withHpackOverrides = if pkgRanHpack pkg then hpackOverrides else id

215 withHpackOverrides = if pkgRanHpack pkg then hpackOverrides else id

165

216

166 flags :: FlagAssignment

217 flags :: FlagAssignment

167− flags = normalizeCabalFlags $

168− configureCabalFlags (packageId (pkgCabal pkg)) ++ readFlagList optFlags

218+ flags = configureCabalFlags (packageId (pkgCabal pkg)) `mappend` readFlagList optFlags

169

219

170 deriv :: Derivation

220 deriv :: Derivation

171 deriv = withHpackOverrides $ fromGenericPackageDescription (const True)

221 deriv = withHpackOverrides $ fromGenericPackageDescription (const True)

172− (\i -> Just (binding # (i, path # [i])))

222+ optNixpkgsIdentifier

173 optSystem

223 optSystem

174 (unknownCompilerInfo optCompiler NoAbiTag)

224 (unknownCompilerInfo optCompiler NoAbiTag)

175 flags

225 flags

@@ -177,7 +227,7 @@ processPackage Options{..} pkg = do

177 (pkgCabal pkg)

227 (pkgCabal pkg)

178 & src .~ pkgSource pkg

228 & src .~ pkgSource pkg

179 & subpath .~ fromMaybe "." optSubpath

229 & subpath .~ fromMaybe "." optSubpath

180− & runHaddock .~ optHaddock

230+ & runHaddock %~ (optHaddock &&)

181 & jailbreak .~ optJailbreak

231 & jailbreak .~ optJailbreak

182 & hyperlinkSource .~ optHyperlinkSource

232 & hyperlinkSource .~ optHyperlinkSource

183 & enableLibraryProfiling .~ (fromMaybe False optEnableProfiling || optEnableLibraryProfiling)

233 & enableLibraryProfiling .~ (fromMaybe False optEnableProfiling || optEnableLibraryProfiling)

@@ -185,6 +235,7 @@ processPackage Options{..} pkg = do

185 & metaSection.maintainers .~ Set.fromList (map (review ident) optMaintainer)

235 & metaSection.maintainers .~ Set.fromList (map (review ident) optMaintainer)

186-- & metaSection.platforms .~ Set.fromList optPlatform

236-- & metaSection.platforms .~ Set.fromList optPlatform

187 & doCheck &&~ optDoCheck

237 & doCheck &&~ optDoCheck

238+ & doBenchmark ||~ optDoBenchmark

188 & extraFunctionArgs %~ Set.union (Set.fromList ("inherit stdenv":map (fromString . ("inherit " ++)) optExtraArgs))

239 & extraFunctionArgs %~ Set.union (Set.fromList ("inherit stdenv":map (fromString . ("inherit " ++)) optExtraArgs))

189

240

190 shell :: Doc

241 shell :: Doc

@@ -212,13 +263,14 @@ processPackage Options{..} pkg = do

212 pure $ if optNixShellOutput then Left shell else Right deriv

263 pure $ if optNixShellOutput then Left shell else Right deriv

213

264

214cabal2nix :: [String] -> IO ()

265cabal2nix :: [String] -> IO ()

215−cabal2nix args = do

266+cabal2nix = parseArgs >=> cabal2nix' >=> putStrLn . either render prettyShow

216− v <- cabal2nix' args

267+

217− print $ case v of

268+parseArgs :: [String] -> IO Options

218− Left shell -> shell

269+parseArgs = handleParseResult . execParserPure defaultPrefs pinfo

219− Right d -> pPrint d

270+

271+-- Utils

220

272

221readFlagList :: [String] -> FlagAssignment

273readFlagList :: [String] -> FlagAssignment

222−readFlagList = map tagWithValue

274+readFlagList = mkFlagAssignment . map tagWithValue

223 where tagWithValue ('-':fname) = (mkFlagName (lowercase fname), False)

275 where tagWithValue ('-':fname) = (mkFlagName (lowercase fname), False)

224 tagWithValue fname = (mkFlagName (lowercase fname), True)

276 tagWithValue fname = (mkFlagName (lowercase fname), True)

src/Distribution/Nixpkgs/Fetch.hs+47−9

@@ -6,7 +6,7 @@

6module Distribution.Nixpkgs.Fetch

7 ( Source(..)

8 , Hash(..)

9− , DerivationSource(..), fromDerivationSource

9+ , DerivationSource(..), fromDerivationSource, urlDerivationSource

10 , fetch

11 , fetchWith

12 ) where

@@ -18,7 +18,10 @@ import Control.Monad.IO.Class

18import Control.Monad.Trans.Maybe

19import Data.Aeson

20import qualified Data.ByteString.Lazy.Char8 as BS

21+import qualified Data.List as L

22+import Data.Maybe

21import GHC.Generics ( Generic )

23import GHC.Generics ( Generic )

24+import Language.Nix.PrettyPrinting as PP

22import System.Directory

25import System.Directory

23import System.Environment

26import System.Environment

24import System.Exit

27import System.Exit

@@ -56,6 +59,7 @@ data DerivationSource = DerivationSource

56 , derivUrl :: String -- ^ URL to fetch from.

59 , derivUrl :: String -- ^ URL to fetch from.

57 , derivRevision :: String -- ^ Revision to use. Leave empty if the fetcher doesn't support revisions.

60 , derivRevision :: String -- ^ Revision to use. Leave empty if the fetcher doesn't support revisions.

58 , derivHash :: String -- ^ The hash of the source.

61 , derivHash :: String -- ^ The hash of the source.

62+ , derivSubmodule :: Maybe Bool -- ^ The fetchSubmodule setting (if any)

59 }

63 }

60 deriving (Show, Eq, Ord, Generic)

64 deriving (Show, Eq, Ord, Generic)

61

65

@@ -66,22 +70,46 @@ instance FromJSON DerivationSource where

66 <$> o .: "url"

70 <$> o .: "url"

67 <*> o .: "rev"

71 <*> o .: "rev"

68 <*> o .: "sha256"

72 <*> o .: "sha256"

73+ <*> o .: "fetchSubmodules"

69 parseJSON _ = error "invalid DerivationSource"

74 parseJSON _ = error "invalid DerivationSource"

70

75

76+instance PP.Pretty DerivationSource where

77+ pPrint DerivationSource {..} =

78+ let isHackagePackage = "mirror://hackage/" `L.isPrefixOf` derivUrl

79+ fetched = derivKind /= ""

80+ in if isHackagePackage then attr "sha256" $ string derivHash

81+ else if not fetched then attr "src" $ text derivUrl

82+ else vcat

83+ [ text "src" <+> equals <+> text ("fetch" ++ derivKind) <+> lbrace

84+ , nest 2 $ vcat

85+ [ attr "url" $ string derivUrl

86+ , attr "sha256" $ string derivHash

87+ , if derivRevision /= "" then attr "rev" (string derivRevision) else PP.empty

88+ , boolattr "fetchSubmodules" (isJust derivSubmodule) (fromJust derivSubmodule)

89+ ]

90+ , rbrace PP.<> semi

91+ ]

92+

93+

94+urlDerivationSource :: String -> String -> DerivationSource

95+urlDerivationSource url hash = DerivationSource "url" url "" hash Nothing

96+

71fromDerivationSource :: DerivationSource -> Source

97fromDerivationSource :: DerivationSource -> Source

72fromDerivationSource DerivationSource{..} = Source derivUrl derivRevision (Certain derivHash) "."

98fromDerivationSource DerivationSource{..} = Source derivUrl derivRevision (Certain derivHash) "."

73

99

74-- | Fetch a source, trying any of the various nix-prefetch-* scripts.

100-- | Fetch a source, trying any of the various nix-prefetch-* scripts.

101+fetch :: forall a.

102+ Bool -- ^ If True, fetch submodules when the source is a git repository

75−fetch :: forall a. (String -> MaybeT IO a) -- ^ This function is passed the output path name as an argument.

103+ -> (String -> MaybeT IO a) -- ^ This function is passed the output path name as an argument.

76 -- It should return 'Nothing' if the file doesn't match the expected format.

104 -- It should return 'Nothing' if the file doesn't match the expected format.

77 -- This is required, because we cannot always check if a download succeeded otherwise.

105 -- This is required, because we cannot always check if a download succeeded otherwise.

78 -> Source -- ^ The source to fetch from.

106 -> Source -- ^ The source to fetch from.

79 -> IO (Maybe (DerivationSource, a)) -- ^ The derivation source and the result of the processing function. Returns Nothing if the download failed.

107 -> IO (Maybe (DerivationSource, a)) -- ^ The derivation source and the result of the processing function. Returns Nothing if the download failed.

80−fetch f = runMaybeT . fetchers where

108+fetch optSubModules f = runMaybeT . fetchers where

81 fetchers :: Source -> MaybeT IO (DerivationSource, a)

109 fetchers :: Source -> MaybeT IO (DerivationSource, a)

82 fetchers source = msum . (fetchLocal source :) $ map (\fetcher -> fetchWith fetcher source >>= process)

110 fetchers source = msum . (fetchLocal source :) $ map (\fetcher -> fetchWith fetcher source >>= process)

83 [ (False, "url", [])

111 [ (False, "url", [])

84− , (True, "git", ["--fetch-submodules"])

112+ , (True, "git", ["--fetch-submodules" | optSubModules ])

85 , (True, "hg", [])

113 , (True, "hg", [])

86 , (True, "svn", [])

114 , (True, "svn", [])

87 , (True, "bzr", [])

115 , (True, "bzr", [])

@@ -100,17 +128,19 @@ fetch f = runMaybeT . fetchers where

100 guard $ existsDir || existsFile

128 guard $ existsDir || existsFile

101 let path' | '/' `elem` path = path

129 let path' | '/' `elem` path = path

102 | otherwise = "./" ++ path

130 | otherwise = "./" ++ path

103− process (DerivationSource "" path' "" "", path') <|> localArchive path'

131+ process (localDerivationSource path', path') <|> localArchive path'

104

132

105 localArchive :: FilePath -> MaybeT IO (DerivationSource, a)

133 localArchive :: FilePath -> MaybeT IO (DerivationSource, a)

106 localArchive path = do

134 localArchive path = do

107 absolutePath <- liftIO $ canonicalizePath path

135 absolutePath <- liftIO $ canonicalizePath path

108− unpacked <- snd <$> fetchWith (False, "zip", []) (Source ("file://" ++ absolutePath) "" UnknownHash ".")

136+ unpacked <- snd <$> fetchWith (False, "url", ["--unpack"]) (Source ("file://" ++ absolutePath) "" UnknownHash ".")

109− process (DerivationSource "" absolutePath "" "", unpacked)

137+ process (localDerivationSource absolutePath, unpacked)

110

138

111 process :: (DerivationSource, FilePath) -> MaybeT IO (DerivationSource, a)

139 process :: (DerivationSource, FilePath) -> MaybeT IO (DerivationSource, a)

112 process (derivSource, file) = (,) derivSource <$> f file

140 process (derivSource, file) = (,) derivSource <$> f file

113

141

142+ localDerivationSource p = DerivationSource "" p "" "" Nothing

143+

114-- | Like 'fetch', but allows to specify which script to use.

144-- | Like 'fetch', but allows to specify which script to use.

115fetchWith :: (Bool, String, [String]) -> Source -> MaybeT IO (DerivationSource, FilePath)

145fetchWith :: (Bool, String, [String]) -> Source -> MaybeT IO (DerivationSource, FilePath)

116fetchWith (supportsRev, kind, addArgs) source = do

146fetchWith (supportsRev, kind, addArgs) source = do

@@ -131,11 +161,19 @@ fetchWith (supportsRev, kind, addArgs) source = do

131 ExitFailure _ -> return Nothing

161 ExitFailure _ -> return Nothing

132 ExitSuccess -> do

162 ExitSuccess -> do

133 buf <- BS.hGetContents stdoutH

163 buf <- BS.hGetContents stdoutH

134− let (l:ls) = reverse (BS.lines buf)

164+ let (l,ls) = case reverse (BS.lines buf) of

165+ [] -> error "This can't happen, but GHC doesn't know that."

166+ (x:xs) -> (x,xs)

135 buf' = BS.unlines (reverse ls)

167 buf' = BS.unlines (reverse ls)

136 case length ls of

168 case length ls of

137 0 -> return Nothing

169 0 -> return Nothing

138− 1 -> return (Just (DerivationSource kind (sourceUrl source) "" (BS.unpack (head ls)) , sourceUrl source))

170+ 1 -> return (Just (DerivationSource { derivKind = kind

171+ , derivUrl = sourceUrl source

172+ , derivRevision = ""

173+ , derivHash = BS.unpack (head ls)

174+ , derivSubmodule = Nothing

175+ }

176+ , sourceUrl source))

139 _ -> case eitherDecode buf' of

177 _ -> case eitherDecode buf' of

140 Left err -> error ("invalid JSON: " ++ err ++ " in " ++ show buf')

178 Left err -> error ("invalid JSON: " ++ err ++ " in " ++ show buf')

141 Right ds -> return (Just (ds { derivKind = kind }, BS.unpack l))

179 Right ds -> return (Just (ds { derivKind = kind }, BS.unpack l))

src/Distribution/Nixpkgs/Haskell/BuildInfo.hs+3−3

@@ -11,7 +11,7 @@ module Distribution.Nixpkgs.Haskell.BuildInfo

11

12import Control.DeepSeq

13import Control.Lens

14−import Data.Semigroup

14+import Data.Semigroup as Sem

15import Data.Set ( Set )

16import Data.Set.Lens

17import GHC.Generics ( Generic )

@@ -31,13 +31,13 @@ makeLenses ''BuildInfo

31instance Each BuildInfo BuildInfo (Set Binding) (Set Binding) where

32 each f (BuildInfo a b c d) = BuildInfo <$> f a <*> f b <*> f c <*> f d

33

34−instance Semigroup BuildInfo where

34+instance Sem.Semigroup BuildInfo where

35 BuildInfo w1 x1 y1 z1 <> BuildInfo w2 x2 y2 z2 =

36 BuildInfo (w1 <> w2) (x1 <> x2) (y1 <> y2) (z1 <> z2)

37

38instance Monoid BuildInfo where

39 mempty = BuildInfo mempty mempty mempty mempty

40− mappend = (<>)

40+ mappend = (Sem.<>)

41

42instance NFData BuildInfo

43

src/Distribution/Nixpkgs/Haskell/Constraint.hs+1−1

@@ -9,7 +9,7 @@ import Distribution.Nixpkgs.Haskell.OrphanInstances ( )

9type Constraint = Dependency

10

11satisfiesConstraint :: PackageIdentifier -> Constraint -> Bool

12−satisfiesConstraint (PackageIdentifier pn v) (Dependency cn vr) = (pn /= cn) || (v `withinRange` vr)

12+satisfiesConstraint (PackageIdentifier pn v) (Dependency cn vr _) = (pn /= cn) || (v `withinRange` vr)

13

14satisfiesConstraints :: PackageIdentifier -> [Constraint] -> Bool

15satisfiesConstraints p = all (satisfiesConstraint p)

src/Distribution/Nixpkgs/Haskell/Derivation.hs+15−19

@@ -1,3 +1,4 @@

1+{-# LANGUAGE CPP #-}

1{-# LANGUAGE DeriveGeneric #-}

2{-# LANGUAGE DeriveGeneric #-}

2{-# LANGUAGE RecordWildCards #-}

3{-# LANGUAGE RecordWildCards #-}

3{-# LANGUAGE TemplateHaskell #-}

4{-# LANGUAGE TemplateHaskell #-}

@@ -6,7 +7,7 @@

6module Distribution.Nixpkgs.Haskell.Derivation

7module Distribution.Nixpkgs.Haskell.Derivation

7 ( Derivation, nullDerivation, pkgid, revision, src, subpath, isLibrary, isExecutable

8 ( Derivation, nullDerivation, pkgid, revision, src, subpath, isLibrary, isExecutable

8 , extraFunctionArgs, libraryDepends, executableDepends, testDepends, configureFlags

9 , extraFunctionArgs, libraryDepends, executableDepends, testDepends, configureFlags

9− , cabalFlags, runHaddock, jailbreak, doCheck, testTarget, hyperlinkSource, enableSplitObjs

10+ , cabalFlags, runHaddock, jailbreak, doCheck, doBenchmark, testTarget, hyperlinkSource, enableSplitObjs

10 , enableLibraryProfiling, enableExecutableProfiling, phaseOverrides, editedCabalFile, metaSection

11 , enableLibraryProfiling, enableExecutableProfiling, phaseOverrides, editedCabalFile, metaSection

11 , dependencies, setupDepends, benchmarkDepends, enableSeparateDataOutput

12 , dependencies, setupDepends, benchmarkDepends, enableSeparateDataOutput

12 )

13 )

@@ -14,7 +15,7 @@ module Distribution.Nixpkgs.Haskell.Derivation

14

15

15import Control.DeepSeq

16import Control.DeepSeq

16import Control.Lens

17import Control.Lens

17−import Data.List

18+import Data.List ( isPrefixOf )

18import Data.Set ( Set )

19import Data.Set ( Set )

19import qualified Data.Set as Set

20import qualified Data.Set as Set

20import Data.Set.Lens

21import Data.Set.Lens

@@ -23,11 +24,15 @@ import Distribution.Nixpkgs.Haskell.BuildInfo

23import Distribution.Nixpkgs.Haskell.OrphanInstances ( )

24import Distribution.Nixpkgs.Haskell.OrphanInstances ( )

24import Distribution.Nixpkgs.Meta

25import Distribution.Nixpkgs.Meta

25import Distribution.Package

26import Distribution.Package

26−import Distribution.PackageDescription ( FlagAssignment, unFlagName )

27+import Distribution.PackageDescription ( FlagAssignment, unFlagName, unFlagAssignment )

27import GHC.Generics ( Generic )

28import GHC.Generics ( Generic )

28import Language.Nix

29import Language.Nix

29import Language.Nix.PrettyPrinting

30import Language.Nix.PrettyPrinting

30

31

32+#if MIN_VERSION_base(4,11,0)

33+import Prelude hiding ((<>))

34+#endif

35+

31-- | A represtation of Nix expressions for building Haskell packages.

36-- | A represtation of Nix expressions for building Haskell packages.

32-- The data type correspond closely to the definition of

37-- The data type correspond closely to the definition of

33-- 'PackageDescription' from Cabal.

38-- 'PackageDescription' from Cabal.

@@ -50,6 +55,7 @@ data Derivation = MkDerivation

50 , _runHaddock :: Bool

55 , _runHaddock :: Bool

51 , _jailbreak :: Bool

56 , _jailbreak :: Bool

52 , _doCheck :: Bool

57 , _doCheck :: Bool

58+ , _doBenchmark :: Bool

53 , _testTarget :: String

59 , _testTarget :: String

54 , _hyperlinkSource :: Bool

60 , _hyperlinkSource :: Bool

55 , _enableLibraryProfiling :: Bool

61 , _enableLibraryProfiling :: Bool

@@ -81,6 +87,7 @@ nullDerivation = MkDerivation

81 , _runHaddock = error "undefined Derivation.runHaddock"

87 , _runHaddock = error "undefined Derivation.runHaddock"

82 , _jailbreak = error "undefined Derivation.jailbreak"

88 , _jailbreak = error "undefined Derivation.jailbreak"

83 , _doCheck = error "undefined Derivation.doCheck"

89 , _doCheck = error "undefined Derivation.doCheck"

90+ , _doBenchmark = error "undefined Derivation.doBenchmark"

84 , _testTarget = error "undefined Derivation.testTarget"

91 , _testTarget = error "undefined Derivation.testTarget"

85 , _hyperlinkSource = error "undefined Derivation.hyperlinkSource"

92 , _hyperlinkSource = error "undefined Derivation.hyperlinkSource"

86 , _enableLibraryProfiling = error "undefined Derivation.enableLibraryProfiling"

93 , _enableLibraryProfiling = error "undefined Derivation.enableLibraryProfiling"

@@ -105,9 +112,9 @@ instance Pretty Derivation where

105 pPrint drv@MkDerivation {..} = funargs (map text ("mkDerivation" : toAscList inputs)) $$ vcat

112 pPrint drv@MkDerivation {..} = funargs (map text ("mkDerivation" : toAscList inputs)) $$ vcat

106 [ text "mkDerivation" <+> lbrace

113 [ text "mkDerivation" <+> lbrace

107 , nest 2 $ vcat

114 , nest 2 $ vcat

108− [ attr "pname" $ doubleQuotes $ disp (packageName _pkgid)

115+ [ attr "pname" $ doubleQuotes $ pPrint (packageName _pkgid)

109− , attr "version" $ doubleQuotes $ disp (packageVersion _pkgid)

116+ , attr "version" $ doubleQuotes $ pPrint (packageVersion _pkgid)

110− , sourceAttr _src

117+ , pPrint _src

111 , onlyIf (_subpath /= ".") $ attr "postUnpack" postUnpack

118 , onlyIf (_subpath /= ".") $ attr "postUnpack" postUnpack

112 , onlyIf (_revision > 0) $ attr "revision" $ doubleQuotes $ int _revision

119 , onlyIf (_revision > 0) $ attr "revision" $ doubleQuotes $ int _revision

113 , onlyIf (not (null _editedCabalFile) && _revision > 0) $ attr "editedCabalFile" $ string _editedCabalFile

120 , onlyIf (not (null _editedCabalFile) && _revision > 0) $ attr "editedCabalFile" $ string _editedCabalFile

@@ -126,6 +133,7 @@ instance Pretty Derivation where

126 , boolattr "doHaddock" (not _runHaddock) _runHaddock

133 , boolattr "doHaddock" (not _runHaddock) _runHaddock

127 , boolattr "jailbreak" _jailbreak _jailbreak

134 , boolattr "jailbreak" _jailbreak _jailbreak

128 , boolattr "doCheck" (not _doCheck) _doCheck

135 , boolattr "doCheck" (not _doCheck) _doCheck

136+ , boolattr "doBenchmark" _doBenchmark _doBenchmark

129 , onlyIf (not (null _testTarget)) $ attr "testTarget" $ string _testTarget

137 , onlyIf (not (null _testTarget)) $ attr "testTarget" $ string _testTarget

130 , boolattr "hyperlinkSource" (not _hyperlinkSource) _hyperlinkSource

138 , boolattr "hyperlinkSource" (not _hyperlinkSource) _hyperlinkSource

131 , onlyIf (not (null _phaseOverrides)) $ vcat ((map text . lines) _phaseOverrides)

139 , onlyIf (not (null _phaseOverrides)) $ vcat ((map text . lines) _phaseOverrides)

@@ -140,20 +148,8 @@ instance Pretty Derivation where

140 , Set.fromList ["fetch" ++ derivKind _src | derivKind _src /= "" && not isHackagePackage]

148 , Set.fromList ["fetch" ++ derivKind _src | derivKind _src /= "" && not isHackagePackage]

141 ]

149 ]

142

150

143− renderedFlags = [ text "-f" <> (if enable then empty else char '-') <> text (unFlagName f) | (f, enable) <- _cabalFlags ]

151+ renderedFlags = [ text "-f" <> (if enable then empty else char '-') <> text (unFlagName f) | (f, enable) <- unFlagAssignment _cabalFlags ]

144 ++ map text (toAscList _configureFlags)

152 ++ map text (toAscList _configureFlags)

145 isHackagePackage = "mirror://hackage/" `isPrefixOf` derivUrl _src

153 isHackagePackage = "mirror://hackage/" `isPrefixOf` derivUrl _src

146− sourceAttr DerivationSource {..}

147− | isHackagePackage = attr "sha256" $ string derivHash

148− | derivKind /= "" = vcat

149− [ text "src" <+> equals <+> text ("fetch" ++ derivKind) <+> lbrace

150− , nest 2 $ vcat

151− [ attr "url" $ string derivUrl

152− , attr "sha256" $ string derivHash

153− , if derivRevision /= "" then attr "rev" (string derivRevision) else empty

154− ]

155− , rbrace <> semi

156− ]

157− | otherwise = attr "src" $ text derivUrl

158

154

159 postUnpack = string $ "sourceRoot+=/" ++ _subpath ++ "; echo source root reset to $sourceRoot"

155 postUnpack = string $ "sourceRoot+=/" ++ _subpath ++ "; echo source root reset to $sourceRoot"

src/Distribution/Nixpkgs/Haskell/FromCabal.hs+30−14

@@ -52,20 +52,20 @@ finalizeGenericPackageDescription haskellResolver arch compiler flags constraint

52 finalize resolver = finalizePD flags requestedComponents resolver arch compiler constraints genDesc

53

54 requestedComponents :: ComponentRequestedSpec

55− requestedComponents = defaultComponentRequestedSpec

55+ requestedComponents = ComponentRequestedSpec

56 { testsRequested = True

57 , benchmarksRequested = True

58 }

59

60 jailbroken :: HaskellResolver -> HaskellResolver

61− jailbroken resolver (Dependency pkg _) = resolver (Dependency pkg anyVersion)

61+ jailbroken resolver (Dependency pkg _ _) = resolver (Dependency pkg anyVersion mempty)

62

63 withInternalLibs :: HaskellResolver -> HaskellResolver

64 withInternalLibs resolver d = depPkgName d `elem` internalNames || resolver d

65

66 internalNames :: [PackageName]

67 internalNames = [ unqualComponentNameToPackageName n | (n,_) <- condSubLibraries genDesc ]

68− ++ [ unqualComponentNameToPackageName n | Just n <- libName <$> subLibraries (packageDescription genDesc) ]

68+ ++ [ unqualComponentNameToPackageName n | LSubLibName n <- libName <$> subLibraries (packageDescription genDesc) ]

69

70 in case finalize (jailbroken (withInternalLibs haskellResolver)) of

71 Left m -> case finalize (const True) of

@@ -88,9 +88,10 @@ fromPackageDescription haskellResolver nixpkgsResolver missingDeps flags Package

88 & Nix.setupDepends .~ maybe mempty convertSetupBuildInfo setupBuildInfo

89 & configureFlags .~ mempty

90 & cabalFlags .~ flags

91− & runHaddock .~ maybe True (not . null . exposedModules) library

91+ & runHaddock .~ doHaddockPhase

92 & jailbreak .~ False

93 & doCheck .~ True

94+ & doBenchmark .~ False

94 & testTarget .~ mempty

95 & testTarget .~ mempty

95 & hyperlinkSource .~ True

96 & hyperlinkSource .~ True

96 & enableSplitObjs .~ True

97 & enableSplitObjs .~ True

@@ -107,7 +108,7 @@ fromPackageDescription haskellResolver nixpkgsResolver missingDeps flags Package

107 & Nix.description .~ synopsis

108 & Nix.description .~ synopsis

108 & Nix.license .~ nixLicense

109 & Nix.license .~ nixLicense

109 & Nix.platforms .~ Nix.allKnownPlatforms

110 & Nix.platforms .~ Nix.allKnownPlatforms

110− & Nix.hydraPlatforms .~ (if nixLicense == Nix.Known "stdenv.lib.licenses.unfree" then Set.empty else Nix.allKnownPlatforms)

111+ & Nix.hydraPlatforms .~ (if isFreeLicense nixLicense then Nix.allKnownPlatforms else Set.empty)

111 & Nix.maintainers .~ mempty

112 & Nix.maintainers .~ mempty

112 & Nix.broken .~ not (null missingDeps)

113 & Nix.broken .~ not (null missingDeps)

113 )

114 )

@@ -115,34 +116,49 @@ fromPackageDescription haskellResolver nixpkgsResolver missingDeps flags Package

115 xrev = maybe 0 read (lookup "x-revision" customFieldsPD)

116 xrev = maybe 0 read (lookup "x-revision" customFieldsPD)

116

117

117 nixLicense :: Nix.License

118 nixLicense :: Nix.License

118− nixLicense = fromCabalLicense license

119+ nixLicense = either fromSPDXLicense fromCabalLicense licenseRaw

119

120

120 resolveInHackage :: Identifier -> Binding

121 resolveInHackage :: Identifier -> Binding

121− resolveInHackage i | (i^.ident) `elem` [ unPackageName n | (Dependency n _) <- missingDeps ] = bindNull i

122+ resolveInHackage i | (i^.ident) `elem` [ unPackageName n | (Dependency n _ _) <- missingDeps ] = bindNull i

122 | otherwise = binding # (i, path # ["self",i]) -- TODO: "self" shouldn't be hardcoded.

123 | otherwise = binding # (i, path # ["self",i]) -- TODO: "self" shouldn't be hardcoded.

123

124

125+ -- TODO: This is all very confusing. Haskell packages refer to the Nixpkgs

126+ -- derivation 'foo' as 'pkgs.foo', because they live in the 'haskellPackages'

127+ -- name space -- not on the top level. Therefore, we built our Nixpkgs lookup

128+ -- function so that top level names are returned as 'pkgs.foo'. As a result, we

129+ -- end up pre-pending that path to all kinds of names all over the place. I

130+ -- suppose the correct approach would be to assume that the lookup function

131+ -- returns names that live in the top-level and to adapt the code in

132+ -- PostProcess.hs et all to that fact.

124 goodScopes :: Set [Identifier]

133 goodScopes :: Set [Identifier]

125 goodScopes = Set.fromList (map ("pkgs":) [[], ["xorg"], ["xlibs"], ["gnome2"], ["gnome"], ["gnome3"], ["kde4"]])

134 goodScopes = Set.fromList (map ("pkgs":) [[], ["xorg"], ["xlibs"], ["gnome2"], ["gnome"], ["gnome3"], ["kde4"]])

126

135

127 resolveInNixpkgs :: Identifier -> Binding

136 resolveInNixpkgs :: Identifier -> Binding

128 resolveInNixpkgs i

137 resolveInNixpkgs i

129 | i `elem` ["clang","lldb","llvm"] = binding # (i, path # ["self","llvmPackages",i]) -- TODO: evil!

138 | i `elem` ["clang","lldb","llvm"] = binding # (i, path # ["self","llvmPackages",i]) -- TODO: evil!

130− | i == "gtk2" = binding # (i, path # ["pkgs","gnome2","gtk"])

139+ | i == "gtk2" = binding # (i, path # ["pkgs","gtk2"]) -- TODO: these cases should not be necessary

131− | i == "gtk3" = binding # (i, path # ["pkgs","gnome3","gtk"])

140+ | i == "gtk3" = binding # (i, path # ["pkgs","gtk3"])

132− | i == "gtksourceview3" = binding # (i, path # ["pkgs","gnome3","gtksourceview"])

141+ | i == "gtksourceview3" = binding # (i, path # ["pkgs","gtksourceview3"])

142+ | i == "vte_291" = binding # (i, path # ["pkgs","vte"])

133 | Just p <- nixpkgsResolver i, init (view (reference . path) p) `Set.member` goodScopes = p

143 | Just p <- nixpkgsResolver i, init (view (reference . path) p) `Set.member` goodScopes = p

134 | otherwise = bindNull i

144 | otherwise = bindNull i

135

145

136 resolveInHackageThenNixpkgs :: Identifier -> Binding

146 resolveInHackageThenNixpkgs :: Identifier -> Binding

137− resolveInHackageThenNixpkgs i | haskellResolver (Dependency (mkPackageName (i^.ident)) anyVersion) = resolveInHackage i

147+ resolveInHackageThenNixpkgs i | haskellResolver (Dependency (mkPackageName (i^.ident)) anyVersion mempty) = resolveInHackage i

138 | otherwise = resolveInNixpkgs i

148 | otherwise = resolveInNixpkgs i

139

149

140 internalLibNames :: [PackageName]

150 internalLibNames :: [PackageName]

141− internalLibNames = fmap unqualComponentNameToPackageName . catMaybes $ libName <$> subLibraries

151+ internalLibNames = [ unqualComponentNameToPackageName n | LSubLibName n <- libName <$> subLibraries ]

152+

153+ doHaddockPhase :: Bool

154+ doHaddockPhase | not (null internalLibNames) = False

155+ | Just l <- library = not (null (exposedModules l))

156+ | otherwise = True

142

157

143 convertBuildInfo :: Cabal.BuildInfo -> Nix.BuildInfo

158 convertBuildInfo :: Cabal.BuildInfo -> Nix.BuildInfo

159+ convertBuildInfo Cabal.BuildInfo {..} | not buildable = mempty

144 convertBuildInfo Cabal.BuildInfo {..} = mempty

160 convertBuildInfo Cabal.BuildInfo {..} = mempty

145− & haskell .~ Set.fromList [ resolveInHackage (toNixName x) | (Dependency x _) <- targetBuildDepends, x `notElem` internalLibNames ]

161+ & haskell .~ Set.fromList [ resolveInHackage (toNixName x) | (Dependency x _ _) <- targetBuildDepends, x `notElem` internalLibNames ]

146 & system .~ Set.fromList [ resolveInNixpkgs y | x <- extraLibs, y <- libNixName x ]

162 & system .~ Set.fromList [ resolveInNixpkgs y | x <- extraLibs, y <- libNixName x ]

147 & pkgconfig .~ Set.fromList [ resolveInNixpkgs y | PkgconfigDependency x _ <- pkgconfigDepends, y <- libNixName (unPkgconfigName x) ]

163 & pkgconfig .~ Set.fromList [ resolveInNixpkgs y | PkgconfigDependency x _ <- pkgconfigDepends, y <- libNixName (unPkgconfigName x) ]

148 & tool .~ Set.fromList (map resolveInHackageThenNixpkgs . concatMap buildToolNixName

164 & tool .~ Set.fromList (map resolveInHackageThenNixpkgs . concatMap buildToolNixName

@@ -150,7 +166,7 @@ fromPackageDescription haskellResolver nixpkgsResolver missingDeps flags Package

150

166

151 convertSetupBuildInfo :: Cabal.SetupBuildInfo -> Nix.BuildInfo

167 convertSetupBuildInfo :: Cabal.SetupBuildInfo -> Nix.BuildInfo

152 convertSetupBuildInfo bi = mempty

168 convertSetupBuildInfo bi = mempty

153− & haskell .~ Set.fromList [ resolveInHackage (toNixName x) | (Dependency x _) <- Cabal.setupDepends bi ]

169+ & haskell .~ Set.fromList [ resolveInHackage (toNixName x) | (Dependency x _ _) <- Cabal.setupDepends bi ]

154

170

155bindNull :: Identifier -> Binding

171bindNull :: Identifier -> Binding

156bindNull i = binding # (i, path # ["null"])

172bindNull i = binding # (i, path # ["null"])

src/Distribution/Nixpkgs/Haskell/FromCabal/Configuration.hs+28−31

@@ -1,15 +1,21 @@

1{-# LANGUAGE RecordWildCards #-}

2−{-# LANGUAGE CPP #-}

3{-# LANGUAGE FlexibleInstances #-}

2{-# LANGUAGE FlexibleInstances #-}

4{-# LANGUAGE OverloadedStrings #-}

3{-# LANGUAGE OverloadedStrings #-}

5{-# LANGUAGE DeriveGeneric #-}

4{-# LANGUAGE DeriveGeneric #-}

6{-# OPTIONS_GHC -fno-warn-orphans #-}

5{-# OPTIONS_GHC -fno-warn-orphans #-}

7

6

8−module Distribution.Nixpkgs.Haskell.FromCabal.Configuration ( Configuration(..), readConfiguration, assertConsistency ) where

7+module Distribution.Nixpkgs.Haskell.FromCabal.Configuration

8+ ( Configuration(..), readConfiguration, assertConsistency

9+ )

10+ where

11+

12+import Prelude hiding ( fail )

9

13

10import Control.DeepSeq

14import Control.DeepSeq

15+import Control.Exception ( throwIO )

11import Control.Lens

16import Control.Lens

12−import Control.Monad

17+import Control.Monad hiding ( fail )

18+import Control.Monad.Fail

13import Data.Aeson

19import Data.Aeson

14import Data.Map as Map

20import Data.Map as Map

15import Data.Set as Set

21import Data.Set as Set

@@ -39,14 +45,22 @@ data Configuration = Configuration

39 -- role during dependency resolution.

45 -- role during dependency resolution.

40 , extraPackages :: [Constraint]

46 , extraPackages :: [Constraint]

41

47

42− -- |We know that these packages won't build, so we give them an empty

43− -- meta.hydraPlatforms attribute to avoid cluttering our Hydra output with

44− -- lots of failure messages.

45− , dontDistributePackages :: Map PackageName (Set Platform)

46−

47 -- |This information is used by the @hackage2nix@ utility to determine the

48 -- |This information is used by the @hackage2nix@ utility to determine the

48 -- 'maintainers' for a given Haskell package.

49 -- 'maintainers' for a given Haskell package.

49 , packageMaintainers :: Map Identifier (Set PackageName)

50 , packageMaintainers :: Map Identifier (Set PackageName)

51+

52+ -- |These packages (by design) don't support certain platforms.

53+ , unsupportedPlatforms :: Map PackageName (Set Platform)

54+

55+ -- |These packages cannot be distributed by Hydra, i.e. because they have an

56+ -- unfree license or depend on other tools that cannot be distributed for

57+ -- some reason.

58+ , dontDistributePackages :: Set PackageName

59+

60+ -- |We know that these packages won't compile, so we mark them as broken and

61+ -- also disable their meta.hydraPlatforms attribute to avoid cluttering our

62+ -- Hydra job with lots of failure messages.

63+ , brokenPackages :: [Constraint]

50 }

64 }

51 deriving (Show, Generic)

65 deriving (Show, Generic)

52

66

@@ -58,50 +72,33 @@ instance FromJSON Configuration where

58 <*> o .:? "core-packages" .!= mempty

72 <*> o .:? "core-packages" .!= mempty

59 <*> o .:? "default-package-overrides" .!= mempty

73 <*> o .:? "default-package-overrides" .!= mempty

60 <*> o .:? "extra-packages" .!= mempty

74 <*> o .:? "extra-packages" .!= mempty

61− <*> o .:? "dont-distribute-packages" .!= mempty

62 <*> o .:? "package-maintainers" .!= mempty

75 <*> o .:? "package-maintainers" .!= mempty

76+ <*> o .:? "unsupported-platforms" .!= mempty

77+ <*> o .:? "dont-distribute-packages" .!= mempty

78+ <*> o .:? "broken-packages" .!= mempty

63 parseJSON _ = error "invalid Configuration"

79 parseJSON _ = error "invalid Configuration"

64

80

65instance FromJSON Identifier where

81instance FromJSON Identifier where

66 parseJSON (String s) = pure (review ident (T.unpack s))

82 parseJSON (String s) = pure (review ident (T.unpack s))

67 parseJSON s = fail ("parseJSON: " ++ show s ++ " is not a valid Nix identifier")

83 parseJSON s = fail ("parseJSON: " ++ show s ++ " is not a valid Nix identifier")

68

84

69−#if MIN_VERSION_aeson(1,0,0)

70−

71instance FromJSONKey Identifier where

85instance FromJSONKey Identifier where

72 fromJSONKey = FromJSONKeyText parseKey

86 fromJSONKey = FromJSONKeyText parseKey

73

87

74instance FromJSONKey PackageName where

88instance FromJSONKey PackageName where

75 fromJSONKey = FromJSONKeyText parseKey

89 fromJSONKey = FromJSONKeyText parseKey

76

90

77−#elif MIN_VERSION_aeson(0,11,0)

78−

79−instance (FromJSON v) => FromJSON (Map Identifier v) where

80− parseJSON = fmap (Map.mapKeys parseKey) . parseJSON

81−

82−instance (FromJSON v) => FromJSON (Map PackageName v) where

83− parseJSON = fmap (Map.mapKeys parseKey) . parseJSON

84−

85−#else

86−

87−instance (Ord k, FromJSON k, FromJSON v) => FromJSON (Map k v) where

88− parseJSON = fmap (Map.mapKeys parseKey) . parseJSON

89−

90−#endif

91−

92parseKey :: FromJSON k => Text -> k

91parseKey :: FromJSON k => Text -> k

93parseKey s = either error id (parseEither parseJSON (String s))

92parseKey s = either error id (parseEither parseJSON (String s))

94

93

95readConfiguration :: FilePath -> IO Configuration

94readConfiguration :: FilePath -> IO Configuration

96−readConfiguration path =

95+readConfiguration path = decodeFileEither path >>= either throwIO assertConsistency

97− decodeFile path >>= maybe (fail ("invalid config file at " ++ show path)) assertConsistency

98

96

99−assertConsistency :: Monad m => Configuration -> m Configuration

97+assertConsistency :: MonadFail m => Configuration -> m Configuration

100assertConsistency cfg@Configuration {..} = do

98assertConsistency cfg@Configuration {..} = do

101 let report msg = fail ("*** configuration error: " ++ msg)

99 let report msg = fail ("*** configuration error: " ++ msg)

102−

103 maintainedPackages = Set.unions (Map.elems packageMaintainers)

100 maintainedPackages = Set.unions (Map.elems packageMaintainers)

104− disabledPackages = Map.keysSet dontDistributePackages

101+ disabledPackages = dontDistributePackages `Set.union` Set.fromList (depPkgName <$> brokenPackages)

105 disabledMaintainedPackages = maintainedPackages `Set.intersection` disabledPackages

102 disabledMaintainedPackages = maintainedPackages `Set.intersection` disabledPackages

106 unless (Set.null disabledMaintainedPackages) $

103 unless (Set.null disabledMaintainedPackages) $

107 report ("disabled packages that have a maintainer: " ++ show disabledMaintainedPackages)

104 report ("disabled packages that have a maintainer: " ++ show disabledMaintainedPackages)

src/Distribution/Nixpkgs/Haskell/FromCabal/Flags.hs+22−17

@@ -4,38 +4,37 @@ module Distribution.Nixpkgs.Haskell.FromCabal.Flags ( configureCabalFlags ) wher

4

5import Distribution.Nixpkgs.Haskell.OrphanInstances ( )

6

7+import Data.Char

7import Distribution.Package

8import Distribution.Package

8import Distribution.PackageDescription

9import Distribution.PackageDescription

9import Distribution.Version

10import Distribution.Version

10

11

11configureCabalFlags :: PackageIdentifier -> FlagAssignment

12configureCabalFlags :: PackageIdentifier -> FlagAssignment

13+configureCabalFlags = mkFlagAssignment . configureCabalFlags'

14+

15+configureCabalFlags' :: PackageIdentifier -> [(FlagName,Bool)]

12−configureCabalFlags (PackageIdentifier name version)

16+configureCabalFlags' (PackageIdentifier name version)

13 | name == "accelerate-examples"= [disable "opencl"]

17 | name == "accelerate-examples"= [disable "opencl"]

14 | name == "arithmoi" = [disable "llvm"]

18 | name == "arithmoi" = [disable "llvm"]

19+ | name == "bustle" = [disable "hgettext"] -- https://gitlab.freedesktop.org/bustle/bustle/issues/13

15 | name == "cabal-plan" = [enable "exe"]

20 | name == "cabal-plan" = [enable "exe"]

16 | name == "cassava" = [disable "bytestring--lt-0_10_4"]

21 | name == "cassava" = [disable "bytestring--lt-0_10_4"]

17 | name == "darcs" = [enable "library", enable "force-char8-encoding"]

22 | name == "darcs" = [enable "library", enable "force-char8-encoding"]

18 | name == "diagrams-builder" = [enable "cairo", enable "svg", enable "ps", enable "rasterific"]

23 | name == "diagrams-builder" = [enable "cairo", enable "svg", enable "ps", enable "rasterific"]

24+ | name == "fltkhs" = [enable "opengl"]

19 | name == "folds" = [disable "test-hlint"]

25 | name == "folds" = [disable "test-hlint"]

20 | name == "git-annex" = [ enable "assistant"

26 | name == "git-annex" = [ enable "assistant"

21− , enable "cryptonite"

27+ , disable "benchmark"

22 , enable "dbus"

28 , enable "dbus"

23− , enable "desktopnotify"

29+ , disable "debuglocks"

24− , enable "dns"

25− , enable "feed"

30+ , enable "magicmime"

26− , enable "inotify"

31+ , enable "networkbsd"

27 , enable "pairing"

32 , enable "pairing"

28 , enable "production"

33 , enable "production"

29− , enable "quvi"

30 , enable "s3"

34 , enable "s3"

31− , enable "tahoe"

32− , enable "tdfa"

33− , ("testsuite", version `withinRange` "< 6.20170925 || >= 6.20171214")

34 , enable "torrentparser"

35 , enable "torrentparser"

35 , enable "webapp"

36 , enable "webapp"

36− , enable "webapp-secure"

37 , enable "webdav"

38− , enable "xmpp"

39 ]

38 ]

40 | name == "haskeline" = [enable "terminfo"]

39 | name == "haskeline" = [enable "terminfo"]

41 | name == "haste-compiler" = [enable "portable"]

40 | name == "haste-compiler" = [enable "portable"]

@@ -43,21 +42,27 @@ configureCabalFlags (PackageIdentifier name version)

43 | name == "hlibsass" && version >= mkVersion [0,1,5]

42 | name == "hlibsass" && version >= mkVersion [0,1,5]

44 = [enable "externalLibsass"]

43 = [enable "externalLibsass"]

45 | name == "hmatrix" = [enable "openblas", enable "disable-default-paths"]

44 | name == "hmatrix" = [enable "openblas", enable "disable-default-paths"]

46− | name == "hslua" = [enable "system-lua"]

45+ | name == "hslua" = [enable "system-lua", disable "use-pkgconfig"]

47 | name == "idris" = [enable "gmp", enable "ffi", enable "curses", ("execonly", version `withinRange` orLaterVersion (mkVersion [1,1,1])) ]

46 | name == "idris" = [enable "gmp", enable "ffi", enable "curses", ("execonly", version `withinRange` orLaterVersion (mkVersion [1,1,1])) ]

48 | name == "io-streams" = [enable "NoInteractiveTests"]

47 | name == "io-streams" = [enable "NoInteractiveTests"]

49 | name == "liquid-fixpoint" = [enable "build-external"]

48 | name == "liquid-fixpoint" = [enable "build-external"]

50 | name == "pandoc" = [enable "https", disable "trypandoc"]

49 | name == "pandoc" = [enable "https", disable "trypandoc"]

50+ | name == "pandoc-placetable" = [enable "inlineMarkdown"]

51+ | name == "persistent-sqlite" = [enable "systemlib"]

51 | name == "reactive-banana-wx" = [disable "buildExamples"]

52 | name == "reactive-banana-wx" = [disable "buildExamples"]

52 | name == "snap-server" = [enable "openssl"]

53 | name == "snap-server" = [enable "openssl"]

53− | name == "xmobar" = [enable "all_extensions"]

54+ | name == "stack" = [enable "disable-git-info", enable "hide-dependency-versions", enable "supported-build"]

55+ | name == "xmobar" = [enable "with_alsa", enable "with_conduit", enable "with_datezone", enable "with_dbus", enable "with_inotify", enable "with_iwlib", enable "with_mpd", enable "with_mpris", enable "with_rtsopts", enable "with_threaded", enable "with_utf8", enable "with_uvmeter", enable "with_weather", enable "with_xft", enable "with_xpm"]

54 | name == "xmonad-extras" = [disable "with_hlist", enable "with_split", enable "with_parsec"]

56 | name == "xmonad-extras" = [disable "with_hlist", enable "with_split", enable "with_parsec"]

55− | name == "yaml" = [enable "system-libyaml"]

57+ | name == "yaml" = [("system-libyaml", version >= "0.10.1.1")]

56 | name == "yi" = [enable "pango", enable "vty"]

58 | name == "yi" = [enable "pango", enable "vty"]

57 | otherwise = []

59 | otherwise = []

58

60

59enable :: String -> (FlagName,Bool)

61enable :: String -> (FlagName,Bool)

60−enable name = (mkFlagName name, True)

62+enable name = (mkFlagName' name, True)

61

63

62disable :: String -> (FlagName,Bool)

64disable :: String -> (FlagName,Bool)

63−disable name = (mkFlagName name, False)

65+disable name = (mkFlagName' name, False)

66+

67+mkFlagName' :: String -> FlagName

68+mkFlagName' = mkFlagName . map toLower

src/Distribution/Nixpkgs/Haskell/FromCabal/License.hs+135−4

@@ -1,14 +1,20 @@

1{-# LANGUAGE ViewPatterns #-}

2

3−module Distribution.Nixpkgs.Haskell.FromCabal.License ( fromCabalLicense ) where

3+module Distribution.Nixpkgs.Haskell.FromCabal.License

4+ ( fromCabalLicense

5+ , fromSPDXLicense

6+ , isFreeLicense

7+ ) where

4

8

5−import Distribution.Nixpkgs.License

9+import Data.List (intercalate)

6import Distribution.License ( License(..), knownLicenses )

10import Distribution.License ( License(..), knownLicenses )

11+import Distribution.Nixpkgs.License

12+import Distribution.Pretty (prettyShow)

13+import qualified Distribution.SPDX as SPDX

7import Distribution.Text (display)

14import Distribution.Text (display)

8−import Data.List (intercalate)

9import Distribution.Version

15import Distribution.Version

10

16

11−-- TODO: Programatically strip trailing zeros from license version numbers.

17+-- TODO: Programmatically strip trailing zeros from license version numbers.

12

18

13fromCabalLicense :: Distribution.License.License -> Distribution.Nixpkgs.License.License

19fromCabalLicense :: Distribution.License.License -> Distribution.Nixpkgs.License.License

14fromCabalLicense (GPL Nothing) = Unknown (Just "GPL")

20fromCabalLicense (GPL Nothing) = Unknown (Just "GPL")

@@ -35,5 +41,130 @@ fromCabalLicense (Apache Nothing) = Known "stdenv.lib.l

35fromCabalLicense (Apache (Just (versionNumbers -> [2,0]))) = Known "stdenv.lib.licenses.asl20"

41fromCabalLicense (Apache (Just (versionNumbers -> [2,0]))) = Known "stdenv.lib.licenses.asl20"

36fromCabalLicense ISC = Known "stdenv.lib.licenses.isc"

42fromCabalLicense ISC = Known "stdenv.lib.licenses.isc"

37fromCabalLicense OtherLicense = Unknown Nothing

43fromCabalLicense OtherLicense = Unknown Nothing

44+fromCabalLicense (UnknownLicense "CC0-1.0") = Known "stdenv.lib.licenses.cc0"

45+fromCabalLicense (UnknownLicense "BSD3ClauseORApache20") = Known "stdenv.lib.licenses.bsd3"

38fromCabalLicense l = error $ "Distribution.Nixpkgs.Haskell.FromCabal.License.fromCabalLicense: unknown license"

46fromCabalLicense l = error $ "Distribution.Nixpkgs.Haskell.FromCabal.License.fromCabalLicense: unknown license"

39 ++ show l ++"\nChoose one of: " ++ intercalate ", " (map display knownLicenses)

47 ++ show l ++"\nChoose one of: " ++ intercalate ", " (map display knownLicenses)

48+

49+fromSPDXLicense :: SPDX.License -> Distribution.Nixpkgs.License.License

50+fromSPDXLicense SPDX.NONE = Unknown Nothing

51+fromSPDXLicense (SPDX.License expr) =

52+ case expr of

53+ SPDX.ELicense simpl Nothing ->

54+ -- Not handled: license exceptions

55+ case simpl of

56+ SPDX.ELicenseId lid ->

57+ case lid of

58+ SPDX.AFL_2_1 -> Known "stdenv.lib.licenses.afl21"

59+ SPDX.AFL_3_0 -> Known "stdenv.lib.licenses.afl3"

60+ SPDX.AGPL_3_0_only -> Known "stdenv.lib.licenses.agpl3"

61+ SPDX.AGPL_3_0_or_later -> Known "stdenv.lib.licenses.agpl3Plus"

62+ SPDX.APSL_2_0 -> Known "stdenv.lib.licenses.apsl20"

63+ SPDX.Artistic_1_0 -> Known "stdenv.lib.licenses.artistic1"

64+ SPDX.Artistic_2_0 -> Known "stdenv.lib.licenses.artistic2"

65+ SPDX.Apache_2_0 -> Known "stdenv.lib.licenses.asl20"

66+ SPDX.BSL_1_0 -> Known "stdenv.lib.licenses.boost"

67+ SPDX.Beerware -> Known "stdenv.lib.licenses.beerware"

68+ SPDX.NullBSD -> Known "stdenv.lib.licenses.bsd0"

69+ SPDX.BSD_2_Clause -> Known "stdenv.lib.licenses.bsd2"

70+ SPDX.BSD_3_Clause -> Known "stdenv.lib.licenses.bsd3"

71+ SPDX.BSD_4_Clause -> Known "stdenv.lib.licenses.bsdOriginal"

72+ SPDX.ClArtistic -> Known "stdenv.lib.licenses.clArtistic"

73+ SPDX.CC0_1_0 -> Known "stdenv.lib.licenses.cc0"

74+ SPDX.CC_BY_NC_SA_2_0 -> Known "stdenv.lib.licenses.cc-by-nc-sa-20"

75+ SPDX.CC_BY_NC_SA_2_5 -> Known "stdenv.lib.licenses.cc-by-nc-sa-25"

76+ SPDX.CC_BY_NC_SA_3_0 -> Known "stdenv.lib.licenses.cc-by-nc-sa-30"

77+ SPDX.CC_BY_NC_SA_4_0 -> Known "stdenv.lib.licenses.cc-by-nc-sa-40"

78+ SPDX.CC_BY_NC_4_0 -> Known "stdenv.lib.licenses.cc-by-nc-40"

79+ SPDX.CC_BY_ND_3_0 -> Known "stdenv.lib.licenses.cc-by-nd-30"

80+ SPDX.CC_BY_SA_2_5 -> Known "stdenv.lib.licenses.cc-by-sa-25"

81+ SPDX.CC_BY_3_0 -> Known "stdenv.lib.licenses.cc-by-30"

82+ SPDX.CC_BY_SA_3_0 -> Known "stdenv.lib.licenses.cc-by-sa-30"

83+ SPDX.CC_BY_4_0 -> Known "stdenv.lib.licenses.cc-by-40"

84+ SPDX.CC_BY_SA_4_0 -> Known "stdenv.lib.licenses.cc-by-sa-40"

85+ SPDX.CDDL_1_0 -> Known "stdenv.lib.licenses.cddl"

86+ SPDX.CECILL_2_0 -> Known "stdenv.lib.licenses.cecill20"

87+ SPDX.CECILL_B -> Known "stdenv.lib.licenses.cecill-b"

88+ SPDX.CECILL_C -> Known "stdenv.lib.licenses.cecill-c"

89+ SPDX.CPAL_1_0 -> Known "stdenv.lib.licenses.cpal10"

90+ SPDX.CPL_1_0 -> Known "stdenv.lib.licenses.cpl10"

91+ SPDX.Curl -> Known "stdenv.lib.licenses.curl"

92+ SPDX.DOC -> Known "stdenv.lib.licenses.doc"

93+ SPDX.EFL_1_0 -> Known "stdenv.lib.licenses.efl10"

94+ SPDX.EFL_2_0 -> Known "stdenv.lib.licenses.efl20"

95+ SPDX.EPL_1_0 -> Known "stdenv.lib.licenses.epl10"

96+ SPDX.EPL_2_0 -> Known "stdenv.lib.licenses.epl20"

97+ SPDX.EUPL_1_1 -> Known "stdenv.lib.licenses.eupl11"

98+ SPDX.GFDL_1_2_only -> Known "stdenv.lib.licenses.fdl12"

99+ SPDX.GFDL_1_3_only -> Known "stdenv.lib.licenses.fdl13"

100+ SPDX.GPL_1_0_only -> Known "stdenv.lib.licenses.gpl1"

101+ SPDX.GPL_1_0_or_later -> Known "stdenv.lib.licenses.gpl1Plus"

102+ SPDX.GPL_2_0_only -> Known "stdenv.lib.licenses.gpl2"

103+ SPDX.GPL_2_0_or_later -> Known "stdenv.lib.licenses.gpl2Plus"

104+ SPDX.GPL_3_0_only -> Known "stdenv.lib.licenses.gpl3"

105+ SPDX.GPL_3_0_or_later -> Known "stdenv.lib.licenses.gpl3Plus"

106+ SPDX.HPND -> Known "stdenv.lib.licenses.hpnd"

107+ SPDX.IJG -> Known "stdenv.lib.licenses.ijg"

108+ SPDX.ImageMagick -> Known "stdenv.lib.licenses.imagemagick"

109+ SPDX.IPA -> Known "stdenv.lib.licenses.ipa"

110+ SPDX.IPL_1_0 -> Known "stdenv.lib.licenses.ipl10"

111+ SPDX.ISC -> Known "stdenv.lib.licenses.isc"

112+ SPDX.JasPer_2_0 -> Known "stdenv.lib.licenses.jasper"

113+ SPDX.LGPL_2_0_only -> Known "stdenv.lib.licenses.lgpl2"

114+ SPDX.LGPL_2_0_or_later -> Known "stdenv.lib.licenses.lgpl2Plus"

115+ SPDX.LGPL_2_1_only -> Known "stdenv.lib.licenses.lgpl21"

116+ SPDX.LGPL_2_1_or_later -> Known "stdenv.lib.licenses.lgpl21Plus"

117+ SPDX.LGPL_3_0_only -> Known "stdenv.lib.licenses.lgpl3"

118+ SPDX.LGPL_3_0_or_later -> Known "stdenv.lib.licenses.lgpl3Plus"

119+ SPDX.Libpng -> Known "stdenv.lib.licenses.libpng"

120+ SPDX.Libtiff -> Known "stdenv.lib.licenses.libtiff"

121+ SPDX.LPPL_1_2 -> Known "stdenv.lib.licenses.lppl12"

122+ SPDX.LPPL_1_3c -> Known "stdenv.lib.licenses.lppl13c"

123+ SPDX.LPL_1_02 -> Known "stdenv.lib.licenses.lpl-102"

124+ SPDX.MIT -> Known "stdenv.lib.licenses.mit"

125+ SPDX.MPL_1_0 -> Known "stdenv.lib.licenses.mpl10"

126+ SPDX.MPL_1_1 -> Known "stdenv.lib.licenses.mpl11"

127+ SPDX.MPL_2_0 -> Known "stdenv.lib.licenses.mpl20"

128+ SPDX.MS_PL -> Known "stdenv.lib.licenses.mspl"

129+ SPDX.NCSA -> Known "stdenv.lib.licenses.ncsa"

130+ SPDX.NPOSL_3_0 -> Known "stdenv.lib.licenses.nposl3"

131+ SPDX.OFL_1_1 -> Known "stdenv.lib.licenses.ofl"

132+ SPDX.OLDAP_2_8 -> Known "stdenv.lib.licenses.openldap"

133+ SPDX.OpenSSL -> Known "stdenv.lib.licenses.openssl"

134+ SPDX.OSL_2_1 -> Known "stdenv.lib.licenses.osl21"

135+ SPDX.OSL_3_0 -> Known "stdenv.lib.licenses.osl3"

136+ SPDX.PHP_3_01 -> Known "stdenv.lib.licenses.php201"

137+ SPDX.PostgreSQL -> Known "stdenv.lib.licenses.postgresql"

138+ SPDX.Python_2_0 -> Known "stdenv.lib.licenses.psfl"

139+ SPDX.QPL_1_0 -> Known "stdenv.lib.licenses.qpl"

140+ SPDX.Ruby -> Known "stdenv.lib.licenses.ruby"

141+ SPDX.Sendmail -> Known "stdenv.lib.licenses.sendmail"

142+ SPDX.SGI_B_2_0 -> Known "stdenv.lib.licenses.sgi-b-0"

143+ SPDX.Sleepycat -> Known "stdenv.lib.licenses.sleepycat"

144+ SPDX.TCL -> Known "stdenv.lib.licenses.tcltx"

145+ SPDX.Unlicense -> Known "stdenv.lib.licenses.unlicense"

146+ SPDX.Vim -> Known "stdenv.lib.licenses.vim"

147+ SPDX.VSL_1_0 -> Known "stdenv.lib.licenses.vsl10"

148+ SPDX.Watcom_1_0 -> Known "stdenv.lib.licenses.watcom"

149+ SPDX.W3C -> Known "stdenv.lib.licenses.w3c"

150+ SPDX.WTFPL -> Known "stdenv.lib.licenses.wtfpl"

151+ SPDX.Zlib -> Known "stdenv.lib.licenses.zlib"

152+ SPDX.ZPL_2_0 -> Known "stdenv.lib.licenses.zpl20"

153+ SPDX.ZPL_2_1 -> Known "stdenv.lib.licenses.zpl21"

154+ _ ->

155+ -- Licence is not in Nixpkgs.

156+ -- Use the SPDX expression as a free-form license string.

157+ Unknown (Just $ prettyShow expr)

158+ _ ->

159+ -- Not handed: the '+' suffix and user-defined licences references.

160+ -- Use the SPDX expression as a free-form license string.

161+ Unknown (Just $ prettyShow expr)

162+ _ ->

163+ -- Not handled: compound expressions, not expressible in Nixpkgs.

164+ -- Use the SPDX expression as a free-form license string.

165+ Unknown (Just $ prettyShow expr)

166+

167+isFreeLicense :: Distribution.Nixpkgs.License.License -> Bool

168+isFreeLicense (Known "stdenv.lib.licenses.unfree") = False

169+isFreeLicense (Unknown Nothing) = False

170+isFreeLicense _ = True

src/Distribution/Nixpkgs/Haskell/FromCabal/Name.hs+33−16

@@ -29,6 +29,7 @@ libNixName "appindicator-0.1" = return "libappindicator-gtk2"

29libNixName "appindicator3-0.1" = return "libappindicator-gtk3"

30libNixName "asound" = return "alsaLib"

31libNixName "b2" = return "libb2"

32+libNixName "boost_context" = return "boost"

32libNixName "bz2" = return "bzip2"

33libNixName "bz2" = return "bzip2"

33libNixName "c++" = [] -- What is that?

34libNixName "c++" = [] -- What is that?

34libNixName "cairo-gobject" = return "cairo"

35libNixName "cairo-gobject" = return "cairo"

@@ -38,6 +39,8 @@ libNixName "cairo-svg" = return "cairo"

38libNixName "crypt" = [] -- provided by glibc

39libNixName "crypt" = [] -- provided by glibc

39libNixName "crypto" = return "openssl"

40libNixName "crypto" = return "openssl"

40libNixName "curses" = return "ncurses"

41libNixName "curses" = return "ncurses"

42+libNixName "dbusmenu-glib-0.4" = return "libdbusmenu"

43+libNixName "dbusmenu-gtk3-0.4" = ["libdbusmenu-gtk3", "gtk3"]

41libNixName "dl" = [] -- provided by glibc

44libNixName "dl" = [] -- provided by glibc

42libNixName "fftw3" = return "fftw"

45libNixName "fftw3" = return "fftw"

43libNixName "fftw3f" = return "fftwFloat"

46libNixName "fftw3f" = return "fftwFloat"

@@ -45,18 +48,19 @@ libNixName "gconf" = return "GConf"

45libNixName "gconf-2.0" = return "GConf"

48libNixName "gconf-2.0" = return "GConf"

46libNixName "gdk-2.0" = return "gtk2"

49libNixName "gdk-2.0" = return "gtk2"

47libNixName "gdk-3.0" = return "gtk3"

50libNixName "gdk-3.0" = return "gtk3"

48−libNixName "gdk-pixbuf-2.0" = return "gdk_pixbuf"

51+libNixName "gdk-pixbuf-2.0" = return "gdk-pixbuf"

49libNixName "gdk-x11-2.0" = return "gdk_x11"

52libNixName "gdk-x11-2.0" = return "gdk_x11"

53+libNixName "gdk-x11-3.0" = return "gtk3"

50libNixName "gio-2.0" = return "glib"

54libNixName "gio-2.0" = return "glib"

51−libNixName "GL" = return "mesa"

55+libNixName "GL" = return "libGL"

52−libNixName "GLU" = ["freeglut","mesa"]

56+libNixName "GLU" = ["libGLU","libGL"]

53−libNixName "glut" = ["freeglut","mesa"]

57+libNixName "glut" = ["freeglut","libGLU","libGL"]

54−libNixName "gnome-keyring" = return "gnome_keyring"

58+libNixName "gnome-keyring" = return "gnome-keyring"

55−libNixName "gnome-keyring-1" = return "gnome_keyring"

59+libNixName "gnome-keyring-1" = return "libgnome-keyring"

56−libNixName "gnome-vfs-2.0" = return "gnome_vfs"

60+libNixName "gnome-vfs-2.0" = return "gnome-vfs"

57−libNixName "gnome-vfs-module-2.0" = return "gnome_vfs_module"

61+libNixName "gnome-vfs-module-2.0" = return "gnome-vfs_module"

58libNixName "gobject-2.0" = return "glib"

62libNixName "gobject-2.0" = return "glib"

59−libNixName "gobject-introspection-1.0" = return "gobjectIntrospection"

63+libNixName "gobject-introspection-1.0" = return "gobject-introspection"

60libNixName "gstreamer-audio-0.10" = return "gst-plugins-base"

64libNixName "gstreamer-audio-0.10" = return "gst-plugins-base"

61libNixName "gstreamer-audio-1.0" = return "gst-plugins-base"

65libNixName "gstreamer-audio-1.0" = return "gst-plugins-base"

62libNixName "gstreamer-base-0.10" = return "gst-plugins-base"

66libNixName "gstreamer-base-0.10" = return "gst-plugins-base"

@@ -81,8 +85,8 @@ libNixName "ImageMagick" = return "imagemagick"

81libNixName "Imlib2" = return "imlib2"

85libNixName "Imlib2" = return "imlib2"

82libNixName "iw" = return "wirelesstools"

86libNixName "iw" = return "wirelesstools"

83libNixName "jack" = return "libjack2"

87libNixName "jack" = return "libjack2"

84−libNixName "javascriptcoregtk-3.0" = return "webkitgtk24x-gtk3" -- These are the old APIs, of which 2.4 is the last provider, so map directly to that.

88+libNixName "javascriptcoregtk-3.0" = return "webkitgtk24x-gtk3" -- These are the old APIs, of which 2.4 is the last provider, so map directly to that.

85−libNixName "javascriptcoregtk-4.0" = return "webkitgtk" -- This is the current API, so let it reference an alias for the latest version.

89+libNixName "javascriptcoregtk-4.0" = return "webkitgtk"

86libNixName "jpeg" = return "libjpeg"

90libNixName "jpeg" = return "libjpeg"

87libNixName "jvm" = return "jdk"

91libNixName "jvm" = return "jdk"

88libNixName "lapack" = return "liblapack"

92libNixName "lapack" = return "liblapack"

@@ -91,18 +95,26 @@ libNixName "ldap" = return "openldap"

91libNixName "libavutil" = return "ffmpeg"

95libNixName "libavutil" = return "ffmpeg"

92libNixName "libgsasl" = return "gsasl"

96libNixName "libgsasl" = return "gsasl"

93libNixName "libpcre" = return "pcre"

97libNixName "libpcre" = return "pcre"

98+libNixName "libpcre2" = return "pcre2"

99+libNixName "libpcre2-8" = libNixName "libpcre2"

100+libNixName "libqrencode" = return "qrencode"

94libNixName "libR" = return "R"

101libNixName "libR" = return "R"

95libNixName "libsoup-gnome-2.4" = return "libsoup"

102libNixName "libsoup-gnome-2.4" = return "libsoup"

96libNixName "libsystemd" = return "systemd"

103libNixName "libsystemd" = return "systemd"

104+libNixName "libudev" = return "systemd"

97libNixName "libxml-2.0" = return "libxml2"

105libNixName "libxml-2.0" = return "libxml2"

98libNixName "libzip" = return "libzip"

106libNixName "libzip" = return "libzip"

99libNixName "libzmq" = return "zeromq"

107libNixName "libzmq" = return "zeromq"

100libNixName "m" = [] -- in stdenv

108libNixName "m" = [] -- in stdenv

101libNixName "magic" = return "file"

109libNixName "magic" = return "file"

102libNixName "MagickWand" = return "imagemagick"

110libNixName "MagickWand" = return "imagemagick"

111+libNixName "mnl" = return "libmnl"

103libNixName "mpi" = return "openmpi"

112libNixName "mpi" = return "openmpi"

104libNixName "ncursesw" = return "ncurses"

113libNixName "ncursesw" = return "ncurses"

105libNixName "netsnmp" = return "net_snmp"

114libNixName "netsnmp" = return "net_snmp"

115+libNixName "nix-expr" = return "nix"

116+libNixName "nix-main" = return "nix"

117+libNixName "nix-store" = return "nix"

106libNixName "notify" = return "libnotify"

118libNixName "notify" = return "libnotify"

107libNixName "odbc" = return "unixODBC"

119libNixName "odbc" = return "unixODBC"

108libNixName "openblas" = return "openblasCompat"

120libNixName "openblas" = return "openblasCompat"

@@ -123,17 +135,17 @@ libNixName "Qt5Gui" = return "qt5"

123libNixName "Qt5Qml" = return "qt5"

135libNixName "Qt5Qml" = return "qt5"

124libNixName "Qt5Quick" = return "qt5"

136libNixName "Qt5Quick" = return "qt5"

125libNixName "Qt5Widgets" = return "qt5"

137libNixName "Qt5Widgets" = return "qt5"

138+libNixName "quadprog" = return "QuadProgpp"

126libNixName "rt" = [] -- in glibc

139libNixName "rt" = [] -- in glibc

127libNixName "rtlsdr" = return "rtl-sdr"

140libNixName "rtlsdr" = return "rtl-sdr"

128libNixName "ruby1.8" = return "ruby"

141libNixName "ruby1.8" = return "ruby"

129−libNixName "sane-backends" = return "saneBackends"

130libNixName "sass" = return "libsass"

142libNixName "sass" = return "libsass"

131libNixName "sctp" = return "lksctp-tools" -- This is linux-specific, we should create a common attribute if we ever add sctp support for other systems.

143libNixName "sctp" = return "lksctp-tools" -- This is linux-specific, we should create a common attribute if we ever add sctp support for other systems.

132libNixName "sdl2" = return "SDL2"

144libNixName "sdl2" = return "SDL2"

133−libNixName "ssh2" = return "libssh2"

134libNixName "sndfile" = return "libsndfile"

145libNixName "sndfile" = return "libsndfile"

135libNixName "sodium" = return "libsodium"

146libNixName "sodium" = return "libsodium"

136libNixName "sqlite3" = return "sqlite"

147libNixName "sqlite3" = return "sqlite"

148+libNixName "ssh2" = return "libssh2"

137libNixName "ssl" = return "openssl"

149libNixName "ssl" = return "openssl"

138libNixName "statgrab" = return "libstatgrab"

150libNixName "statgrab" = return "libstatgrab"

139libNixName "stdc++" = [] -- What is that?

151libNixName "stdc++" = [] -- What is that?

@@ -141,16 +153,20 @@ libNixName "stdc++.dll" = [] -- What is that?

141libNixName "systemd-journal" = return "systemd"

153libNixName "systemd-journal" = return "systemd"

142libNixName "tag_c" = return "taglib"

154libNixName "tag_c" = return "taglib"

143libNixName "taglib_c" = return "taglib"

155libNixName "taglib_c" = return "taglib"

156+libNixName "tensorflow" = return "libtensorflow"

144libNixName "udev" = return "systemd";

157libNixName "udev" = return "systemd";

145libNixName "uuid" = return "libossp_uuid";

158libNixName "uuid" = return "libossp_uuid";

159+libNixName "vte-2.91" = return "vte_291"

146libNixName "wayland-client" = return "wayland"

160libNixName "wayland-client" = return "wayland"

147libNixName "wayland-cursor" = return "wayland"

161libNixName "wayland-cursor" = return "wayland"

148−libNixName "wayland-egl" = return "mesa"

162+libNixName "wayland-egl" = return "libGL"

149libNixName "wayland-server" = return "wayland"

163libNixName "wayland-server" = return "wayland"

150−libNixName "webkit2gtk-4.0" = return "webkitgtk" -- This is the current API, so let it reference an alias for the latest version.

164+libNixName "webkit2gtk" = return "webkitgtk"

165+libNixName "webkit2gtk-4.0" = return "webkitgtk"

151−libNixName "webkit2gtk-web-extension-4.0" = return "webkitgtk-web-extension" -- This package doesn't actually exist in nixpkgs at present.

166+libNixName "webkit2gtk-web-extension-4.0" = return "webkitgtk"

152libNixName "webkitgtk-3.0" = return "webkitgtk24x-gtk3" -- These are the old APIs, of which 2.4 is the last provider, so map directly to that

167libNixName "webkitgtk-3.0" = return "webkitgtk24x-gtk3" -- These are the old APIs, of which 2.4 is the last provider, so map directly to that

153libNixName "X11" = return "libX11"

168libNixName "X11" = return "libX11"

169+libNixName "x11" = return "xlibsWrapper"

154libNixName "xau" = return "libXau"

170libNixName "xau" = return "libXau"

155libNixName "Xcursor" = return "libXcursor"

171libNixName "Xcursor" = return "libXcursor"

156libNixName "xerces-c" = return "xercesc"

172libNixName "xerces-c" = return "xercesc"

@@ -166,6 +182,7 @@ libNixName "Xrender" = return "libXrender"

166libNixName "Xss" = return "libXScrnSaver"

182libNixName "Xss" = return "libXScrnSaver"

167libNixName "Xtst" = return "libXtst"

183libNixName "Xtst" = return "libXtst"

168libNixName "Xxf86vm" = return "libXxf86vm"

184libNixName "Xxf86vm" = return "libXxf86vm"

185+libNixName "yaml" = return "libyaml"

169libNixName "yaml-0.1" = return "libyaml"

186libNixName "yaml-0.1" = return "libyaml"

170libNixName "z" = return "zlib"

187libNixName "z" = return "zlib"

171libNixName "zmq" = return "zeromq"

188libNixName "zmq" = return "zeromq"

src/Distribution/Nixpkgs/Haskell/FromCabal/Normalize.hs+1−20

@@ -1,17 +1,13 @@

1{-# LANGUAGE OverloadedStrings #-}

2

3−module Distribution.Nixpkgs.Haskell.FromCabal.Normalize ( normalize, normalizeCabalFlags ) where

3+module Distribution.Nixpkgs.Haskell.FromCabal.Normalize ( normalize ) where

4

5import Control.Lens

6−import Data.Function

7−import Data.List

8import qualified Data.Set as Set

6import qualified Data.Set as Set

9import Data.String

7import Data.String

10import Distribution.Nixpkgs.Haskell

8import Distribution.Nixpkgs.Haskell

11import Distribution.Nixpkgs.Meta

9import Distribution.Nixpkgs.Meta

12import Distribution.Package

10import Distribution.Package

13−import Distribution.PackageDescription ( FlagAssignment, mkFlagName, unFlagName )

14−import Distribution.Simple.Utils ( lowercase )

15import Language.Nix hiding ( quote )

11import Language.Nix hiding ( quote )

16

12

17normalize :: Derivation -> Derivation

13normalize :: Derivation -> Derivation

@@ -21,7 +17,6 @@ normalize drv = drv

21 & over testDepends (normalizeBuildInfo (packageName drv))

17 & over testDepends (normalizeBuildInfo (packageName drv))

22 & over benchmarkDepends (normalizeBuildInfo (packageName drv))

18 & over benchmarkDepends (normalizeBuildInfo (packageName drv))

23 & over metaSection normalizeMeta

19 & over metaSection normalizeMeta

24− & over cabalFlags normalizeCabalFlags

25 & jailbreak %~ (&& (packageName drv /= "jailbreak-cabal"))

20 & jailbreak %~ (&& (packageName drv /= "jailbreak-cabal"))

26

21

27normalizeBuildInfo :: PackageName -> BuildInfo -> BuildInfo

22normalizeBuildInfo :: PackageName -> BuildInfo -> BuildInfo

@@ -46,17 +41,3 @@ quote ('\\':c:cs) = '\\' : c : quote cs

46quote ('"':cs) = '\\' : '"' : quote cs

41quote ('"':cs) = '\\' : '"' : quote cs

47quote (c:cs) = c : quote cs

42quote (c:cs) = c : quote cs

48quote [] = []

43quote [] = []

49−

50−-- | When a flag is specified multiple times, the last occurrence counts. Flag

51−-- names are spelled all lowercase.

52−--

53−-- >>> normalizeCabalFlags [(mkFlagName "foo", True), (mkFlagName "FOO", True), (mkFlagName "Foo", False)]

54−-- [(FlagName "foo",False)]

55−

56−normalizeCabalFlags :: FlagAssignment -> FlagAssignment

57−normalizeCabalFlags flags =

58− sortBy (compare `on` fst) $

59− reverse $

60− nubBy ((==) `on` fst) $

61− reverse

62− [ (mkFlagName (lowercase (unFlagName n)), b) | (n, b) <- flags ]

src/Distribution/Nixpkgs/Haskell/FromCabal/PostProcess.hs+151−46

@@ -1,14 +1,19 @@

1{-# LANGUAGE OverloadedStrings #-}

2+{-# LANGUAGE ScopedTypeVariables #-}

2

3

3module Distribution.Nixpkgs.Haskell.FromCabal.PostProcess ( postProcess, pkg ) where

4module Distribution.Nixpkgs.Haskell.FromCabal.PostProcess ( postProcess, pkg ) where

4

5

5import Control.Lens

6import Control.Lens

7+import Control.Monad.Trans.State

6import Data.List.Split

8import Data.List.Split

9+import Data.Map ( Map )

10+import qualified Data.Map as Map

11+import Data.Map.Lens

7import Data.Set ( Set )

12import Data.Set ( Set )

8import qualified Data.Set as Set

13import qualified Data.Set as Set

9−import Data.Set.Lens

10import Distribution.Nixpkgs.Haskell

14import Distribution.Nixpkgs.Haskell

11import Distribution.Nixpkgs.Meta

15import Distribution.Nixpkgs.Meta

16+import Distribution.Nixpkgs.License

12import Distribution.Package

17import Distribution.Package

13import Distribution.System

18import Distribution.System

14import Distribution.Text

19import Distribution.Text

@@ -16,7 +21,11 @@ import Distribution.Version

16import Language.Nix

21import Language.Nix

17

22

18postProcess :: Derivation -> Derivation

23postProcess :: Derivation -> Derivation

24+postProcess deriv =

19−postProcess deriv = foldr ($) (fixGtkBuilds deriv) [ f | (Dependency n vr, f) <- hooks, packageName deriv == n, packageVersion deriv `withinRange` vr ]

25+ foldr (.) id [ f | (Dependency n vr _, f) <- hooks, packageName deriv == n, packageVersion deriv `withinRange` vr ]

26+ . fixGtkBuilds

27+ . fixBuildDependsForTools

28+ $ deriv

20

29

21fixGtkBuilds :: Derivation -> Derivation

30fixGtkBuilds :: Derivation -> Derivation

22fixGtkBuilds drv = drv & dependencies . pkgconfig %~ Set.filter (not . collidesWithHaskellName)

31fixGtkBuilds drv = drv & dependencies . pkgconfig %~ Set.filter (not . collidesWithHaskellName)

@@ -24,53 +33,93 @@ fixGtkBuilds drv = drv & dependencies . pkgconfig %~ Set.filter (not . collidesW

24 & dependencies . tool %~ Set.filter (not . collidesWithHaskellName)

33 & dependencies . tool %~ Set.filter (not . collidesWithHaskellName)

25 where

34 where

26 collidesWithHaskellName :: Binding -> Bool

35 collidesWithHaskellName :: Binding -> Bool

27− collidesWithHaskellName b = view localName b `Set.member` buildDeps

36+ collidesWithHaskellName b = case buildDeps Map.!? view localName b of

37+ Nothing -> False -- totally uncollided

38+ Just p -> p /= view reference b -- identical is not collision, and important to preserve for cross

28

39

29 myName :: Identifier

40 myName :: Identifier

30 myName = ident # unPackageName (packageName drv)

41 myName = ident # unPackageName (packageName drv)

31

42

32− buildDeps :: Set Identifier

43+ buildDeps :: Map Identifier Path

33− buildDeps = Set.delete myName (setOf (dependencies . haskell . folded . localName) drv)

44+ buildDeps = Map.delete myName (toMapOf (dependencies . haskell . to Set.toList . traverse . binding . ifolded) drv)

45+

46+-- Per https://github.com/haskell/cabal/issues/5412 hvr considers

47+-- `build-depends` providing executables an accident, and fragile one at that,

48+-- unworthy of any compatibility hacks. But while he and the other Hackage

49+-- maintainers is dedicated to fixing executables and libraries on Hackage, test

50+-- suites and benchmarks are not a priority, as it is trivial to skip building

51+-- test-suites with cabal-install. Nix however wishes to build test suites much

52+-- more widely, so skipping those components is not an option.

53+--

54+-- Between that, and Stack not changing behavior as of

55+-- https://github.com/commercialhaskell/stack/pull/4132, it seems likely that

56+-- for a while packages scraped from Hackage will continue to improperly use

57+-- `build-depends: package-for-tool` instead of `build-tool-depends` (which does

58+-- also work for Stack). Until that changes, we provide do this to work around

59+-- those package's brokenness.

60+fixBuildDependsForTools :: Derivation -> Derivation

61+fixBuildDependsForTools = foldr (.) id

62+ [ fmap snd $ runState $ do

63+ needs <- use $ cloneLens c . haskell . contains p

64+ cloneLens c . tool . contains p ||= needs

65+ | (c :: ALens' Derivation BuildInfo) <- [ testDepends, benchmarkDepends ]

66+ , p <- self <$> [ "hspec-discover"

67+ , "tasty-discover"

68+ , "hsx2hs"

69+ , "markdown-unlit"

70+ ]

71+ ]

34

72

35hooks :: [(Dependency, Derivation -> Derivation)]

73hooks :: [(Dependency, Derivation -> Derivation)]

36hooks =

74hooks =

37 [ ("Agda < 2.5", set (executableDepends . tool . contains (pkg "emacs")) True . set phaseOverrides agdaPostInstall)

75 [ ("Agda < 2.5", set (executableDepends . tool . contains (pkg "emacs")) True . set phaseOverrides agdaPostInstall)

38 , ("Agda >= 2.5", set (executableDepends . tool . contains (pkg "emacs")) True . set phaseOverrides agda25PostInstall)

76 , ("Agda >= 2.5", set (executableDepends . tool . contains (pkg "emacs")) True . set phaseOverrides agda25PostInstall)

39 , ("alex < 3.1.5", set (testDepends . tool . contains (pkg "perl")) True)

77 , ("alex < 3.1.5", set (testDepends . tool . contains (pkg "perl")) True)

40− , ("alex", set (executableDepends . tool . contains (bind "self.happy")) True)

78+ , ("alex", set (executableDepends . tool . contains (self "happy")) True)

41− , ("alsa-core", over (metaSection . platforms) (Set.filter (\(Platform _ os) -> os == Linux))) , ("bustle", set (libraryDepends . pkgconfig . contains "system-glib = pkgs.glib") True)

79+ , ("alsa-core", over (metaSection . platforms) (Set.filter (\(Platform _ os) -> os == Linux)))

42 , ("bindings-GLFW", over (libraryDepends . system) (Set.union (Set.fromList [bind "pkgs.xorg.libXext", bind "pkgs.xorg.libXfixes"])))

80 , ("bindings-GLFW", over (libraryDepends . system) (Set.union (Set.fromList [bind "pkgs.xorg.libXext", bind "pkgs.xorg.libXfixes"])))

43− , ("bindings-lxc", over (metaSection . platforms) (Set.filter (\(Platform _ os) -> os == Linux))) , ("bustle", set (libraryDepends . pkgconfig . contains "system-glib = pkgs.glib") True)

81+ , ("bindings-lxc", over (metaSection . platforms) (Set.filter (\(Platform _ os) -> os == Linux)))

44− , ("bustle", set (libraryDepends . pkgconfig . contains "system-glib = pkgs.glib") True)

82+ , ("bustle", bustleOverrides)

83+ , ("Cabal", set doCheck False) -- test suite doesn't work in Nix

84+ , ("Cabal >2.2", over (setupDepends . haskell) (Set.union (Set.fromList [self "mtl", self "parsec"]))) -- https://github.com/haskell/cabal/issues/5391

45 , ("cabal-helper", set doCheck False) -- https://github.com/DanielG/cabal-helper/issues/17

85 , ("cabal-helper", set doCheck False) -- https://github.com/DanielG/cabal-helper/issues/17

46 , ("cabal-install", set doCheck False . set phaseOverrides cabalInstallPostInstall)

86 , ("cabal-install", set doCheck False . set phaseOverrides cabalInstallPostInstall)

47− , ("Cabal", set doCheck False) -- test suite doesn't work in Nix

87+ , ("cabal2nix > 2", cabal2nixOverrides)

48 , ("darcs", set phaseOverrides darcsInstallPostInstall . set doCheck False)

88 , ("darcs", set phaseOverrides darcsInstallPostInstall . set doCheck False)

49 , ("dbus", set doCheck False) -- don't execute tests that try to access the network

89 , ("dbus", set doCheck False) -- don't execute tests that try to access the network

50 , ("dns", set testTarget "spec") -- don't execute tests that try to access the network

90 , ("dns", set testTarget "spec") -- don't execute tests that try to access the network

51 , ("eventstore", over (metaSection . platforms) (Set.filter (\(Platform arch _) -> arch == X86_64)))

91 , ("eventstore", over (metaSection . platforms) (Set.filter (\(Platform arch _) -> arch == X86_64)))

52 , ("freenect < 1.2.1", over configureFlags (Set.union (Set.fromList ["--extra-include-dirs=${pkgs.freenect}/include/libfreenect", "--extra-lib-dirs=${pkgs.freenect}/lib"])))

92 , ("freenect < 1.2.1", over configureFlags (Set.union (Set.fromList ["--extra-include-dirs=${pkgs.freenect}/include/libfreenect", "--extra-lib-dirs=${pkgs.freenect}/lib"])))

93+ , ("fltkhs", set (libraryDepends . system . contains (pkg "fltk14")) True . over (libraryDepends . pkgconfig) (Set.union (pkgs ["libGLU", "libGL"]))) -- TODO: fltk14 belongs into the *setup* dependencies.

53 , ("gf", set phaseOverrides gfPhaseOverrides . set doCheck False)

94 , ("gf", set phaseOverrides gfPhaseOverrides . set doCheck False)

54 , ("gi-cairo", giCairoPhaseOverrides) -- https://github.com/haskell-gi/haskell-gi/issues/36

95 , ("gi-cairo", giCairoPhaseOverrides) -- https://github.com/haskell-gi/haskell-gi/issues/36

96+ , ("gi-gdk", set runHaddock True )

97+ , ("gi-gio", set runHaddock True )

98+ , ("gi-glib", set runHaddock True )

99+ , ("gi-gst", giGstLibOverrides "gstreamer") -- https://github.com/haskell-gi/haskell-gi/issues/36

55 , ("gi-gstaudio", giGstLibOverrides "gst-plugins-base") -- https://github.com/haskell-gi/haskell-gi/issues/36

100 , ("gi-gstaudio", giGstLibOverrides "gst-plugins-base") -- https://github.com/haskell-gi/haskell-gi/issues/36

56 , ("gi-gstbase", giGstLibOverrides "gst-plugins-base") -- https://github.com/haskell-gi/haskell-gi/issues/36

101 , ("gi-gstbase", giGstLibOverrides "gst-plugins-base") -- https://github.com/haskell-gi/haskell-gi/issues/36

57− , ("gi-gst", giGstLibOverrides "gstreamer") -- https://github.com/haskell-gi/haskell-gi/issues/36

58 , ("gi-gstvideo", giGstLibOverrides "gst-plugins-base") -- https://github.com/haskell-gi/haskell-gi/issues/36

102 , ("gi-gstvideo", giGstLibOverrides "gst-plugins-base") -- https://github.com/haskell-gi/haskell-gi/issues/36

103+ , ("gi-gtk", set runHaddock True )

59 , ("gi-javascriptcore < 4.0.0.0", webkitgtk24xHook) -- https://github.com/haskell-gi/haskell-gi/issues/36

104 , ("gi-javascriptcore < 4.0.0.0", webkitgtk24xHook) -- https://github.com/haskell-gi/haskell-gi/issues/36

60− , ("gio", set (libraryDepends . pkgconfig . contains "system-glib = pkgs.glib") True)

61− , ("gi-pangocairo", giCairoPhaseOverrides) -- https://github.com/haskell-gi/haskell-gi/issues/36

62 , ("gi-pango", giCairoPhaseOverrides) -- https://github.com/haskell-gi/haskell-gi/issues/36

105 , ("gi-pango", giCairoPhaseOverrides) -- https://github.com/haskell-gi/haskell-gi/issues/36

63− , ("git-annex", gitAnnexHook)

106+ , ("gi-pango", set runHaddock True )

107+ , ("gi-pangocairo", giCairoPhaseOverrides) -- https://github.com/haskell-gi/haskell-gi/issues/36

108+ , ("gi-vte", set runHaddock True )

109+ , ("gi-webkit", webkitgtk24xHook) -- https://github.com/haskell-gi/haskell-gi/issues/36

110+ , ("gio", set (libraryDepends . pkgconfig . contains "system-glib = pkgs.glib") True)

111+ , ("git", set doCheck False) -- https://github.com/vincenthz/hit/issues/33

64 , ("git-annex >= 6.20170925 && < 6.20171214", set doCheck False) -- some versions of git-annex require their test suite to be run inside of a git checkout

112 , ("git-annex >= 6.20170925 && < 6.20171214", set doCheck False) -- some versions of git-annex require their test suite to be run inside of a git checkout

113+ , ("git-annex", gitAnnexHook)

65 , ("github-backup", set (executableDepends . tool . contains (pkg "git")) True)

114 , ("github-backup", set (executableDepends . tool . contains (pkg "git")) True)

66− , ("git", set doCheck False) -- https://github.com/vincenthz/hit/issues/33

115+ , ("GLFW", over (libraryDepends . system) (Set.union (Set.fromList [bind "pkgs.xorg.libXext", bind "pkgs.xorg.libXfixes"])))

67− , ("gi-webkit", webkitgtk24xHook) -- https://github.com/haskell-gi/haskell-gi/issues/36

68 , ("GlomeVec", set (libraryDepends . pkgconfig . contains (bind "self.llvmPackages.llvm")) True)

116 , ("GlomeVec", set (libraryDepends . pkgconfig . contains (bind "self.llvmPackages.llvm")) True)

117+ , ("graphviz", set (testDepends . system . contains (pkg "graphviz")) True)

69 , ("gtk3", gtk3Hook)

118 , ("gtk3", gtk3Hook)

119+ , ("gtkglext", gtkglextHook)

70 , ("haddock", haddockHook) -- https://github.com/haskell/haddock/issues/511

120 , ("haddock", haddockHook) -- https://github.com/haskell/haddock/issues/511

71 , ("hakyll", set (testDepends . tool . contains (pkg "utillinux")) True) -- test suite depends on "rev"

121 , ("hakyll", set (testDepends . tool . contains (pkg "utillinux")) True) -- test suite depends on "rev"

72 , ("haskell-src-exts", set doCheck False)

122 , ("haskell-src-exts", set doCheck False)

73− , ("hspec-core >= 2.4.4", hspecCoreOverrides)

74 , ("hfsevents", hfseventsOverrides)

123 , ("hfsevents", hfseventsOverrides)

75 , ("HFuse", set phaseOverrides hfusePreConfigure)

124 , ("HFuse", set phaseOverrides hfusePreConfigure)

76 , ("hlibgit2 >= 0.18.0.14", set (testDepends . tool . contains (pkg "git")) True)

125 , ("hlibgit2 >= 0.18.0.14", set (testDepends . tool . contains (pkg "git")) True)

@@ -78,30 +127,34 @@ hooks =

78 , ("holy-project", set doCheck False) -- attempts to access the network

127 , ("holy-project", set doCheck False) -- attempts to access the network

79 , ("hoogle", set testTarget "--test-option=--no-net")

128 , ("hoogle", set testTarget "--test-option=--no-net")

80 , ("hsignal < 0.2.7.4", set phaseOverrides "prePatch = \"rm -v Setup.lhs\";") -- https://github.com/amcphail/hsignal/issues/1

129 , ("hsignal < 0.2.7.4", set phaseOverrides "prePatch = \"rm -v Setup.lhs\";") -- https://github.com/amcphail/hsignal/issues/1

81− , ("hslua < 0.9.3", over (libraryDepends . each) (replace (pkg "lua") (pkg "lua5_1")))

130+ , ("hslua < 0.9.3", over (libraryDepends . system) (replace (pkg "lua") (pkg "lua5_1")))

82− , ("hslua >= 0.9.3", over (libraryDepends . each) (replace (pkg "lua") (pkg "lua5_3")))

131+ , ("hslua >= 0.9.3", over (libraryDepends . system) (replace (pkg "lua") (pkg "lua5_3")))

83− , ("http-client-openssl >= 0.2.0.1", set doCheck False) -- attempts to access the network

132+ , ("hspec-core >= 2.4.4", hspecCoreOverrides)

84 , ("http-client", set doCheck False) -- attempts to access the network

133 , ("http-client", set doCheck False) -- attempts to access the network

134+ , ("http-client-openssl >= 0.2.0.1", set doCheck False) -- attempts to access the network

85 , ("http-client-tls >= 0.2.2", set doCheck False) -- attempts to access the network

135 , ("http-client-tls >= 0.2.2", set doCheck False) -- attempts to access the network

86 , ("http-conduit", set doCheck False) -- attempts to access the network

136 , ("http-conduit", set doCheck False) -- attempts to access the network

87 , ("imagemagick", set (libraryDepends . pkgconfig . contains (pkg "imagemagick")) True) -- https://github.com/NixOS/cabal2nix/issues/136

137 , ("imagemagick", set (libraryDepends . pkgconfig . contains (pkg "imagemagick")) True) -- https://github.com/NixOS/cabal2nix/issues/136

88− , ("include-file <= 0.1.0.2", set (libraryDepends . haskell . contains (bind "self.random")) True) -- https://github.com/Daniel-Diaz/include-file/issues/1

138+ , ("include-file <= 0.1.0.2", set (libraryDepends . haskell . contains (self "random")) True) -- https://github.com/Daniel-Diaz/include-file/issues/1

89 , ("js-jquery", set doCheck False) -- attempts to access the network

139 , ("js-jquery", set doCheck False) -- attempts to access the network

90 , ("libconfig", over (libraryDepends . system) (replace "config = null" (pkg "libconfig")))

140 , ("libconfig", over (libraryDepends . system) (replace "config = null" (pkg "libconfig")))

91 , ("libxml", set (configureFlags . contains "--extra-include-dir=${libxml2.dev}/include/libxml2") True)

141 , ("libxml", set (configureFlags . contains "--extra-include-dir=${libxml2.dev}/include/libxml2") True)

92 , ("liquid-fixpoint", set (executableDepends . system . contains (pkg "ocaml")) True . set (testDepends . system . contains (pkg "z3")) True . set (testDepends . system . contains (pkg "nettools")) True . set (testDepends . system . contains (pkg "git")) True . set doCheck False)

142 , ("liquid-fixpoint", set (executableDepends . system . contains (pkg "ocaml")) True . set (testDepends . system . contains (pkg "z3")) True . set (testDepends . system . contains (pkg "nettools")) True . set (testDepends . system . contains (pkg "git")) True . set doCheck False)

93 , ("liquidhaskell", set (testDepends . system . contains (pkg "z3")) True)

143 , ("liquidhaskell", set (testDepends . system . contains (pkg "z3")) True)

94− , ("lzma-clib", over (metaSection . platforms) (Set.filter (\(Platform _ os) -> os == Windows)) . set (libraryDepends . haskell . contains (bind "self.only-buildable-on-windows")) False)

144+ , ("lzma-clib", over (metaSection . platforms) (Set.filter (\(Platform _ os) -> os == Windows)) . set (libraryDepends . haskell . contains (self "only-buildable-on-windows")) False)

95− , ("MFlow < 4.6", set (libraryDepends . tool . contains (bind "self.cpphs")) True)

145+ , ("MFlow < 4.6", set (libraryDepends . tool . contains (self "cpphs")) True)

96 , ("mwc-random", set doCheck False)

146 , ("mwc-random", set doCheck False)

97 , ("mysql", set (libraryDepends . system . contains (pkg "mysql")) True)

147 , ("mysql", set (libraryDepends . system . contains (pkg "mysql")) True)

98 , ("network-attoparsec", set doCheck False) -- test suite requires network access

148 , ("network-attoparsec", set doCheck False) -- test suite requires network access

99 , ("numeric-qq", set doCheck False) -- test suite doesn't finish even after 1+ days

149 , ("numeric-qq", set doCheck False) -- test suite doesn't finish even after 1+ days

100 , ("opencv", opencvOverrides)

150 , ("opencv", opencvOverrides)

101− , ("pandoc >= 1.16.0.2", set doCheck False) -- https://github.com/jgm/pandoc/issues/2709 and https://github.com/fpco/stackage/issues/1332

151+ , ("pandoc >= 1.16.0.2 && < 2.5", set doCheck False) -- https://github.com/jgm/pandoc/issues/2709 and https://github.com/fpco/stackage/issues/1332

152+ , ("pandoc < 2.6", pandocPre26Overrides)

153+ , ("pandoc >= 2.6", pandocOverrides)

102− , ("pandoc-citeproc", set doCheck False) -- https://github.com/jgm/pandoc-citeproc/issues/172

154+ , ("pandoc-citeproc", set doCheck False) -- https://github.com/jgm/pandoc-citeproc/issues/369

103− , ("pandoc", set jailbreak False) -- jailbreak-cabal break the build

104 , ("purescript", set doCheck False) -- test suite doesn't cope with Nix build env

155 , ("purescript", set doCheck False) -- test suite doesn't cope with Nix build env

156+ , ("proto-lens-protobuf-types", set (libraryDepends . tool . contains (pkg "protobuf")) True)

157+ , ("proto-lens-protoc", set (libraryDepends . tool . contains (pkg "protobuf")) True)

105 , ("qtah-cpp-qt5", set (libraryDepends . system . contains (bind "pkgs.qt5.qtbase")) True)

158 , ("qtah-cpp-qt5", set (libraryDepends . system . contains (bind "pkgs.qt5.qtbase")) True)

106 , ("qtah-qt5", set (libraryDepends . tool . contains (bind "pkgs.qt5.qtbase")) True)

159 , ("qtah-qt5", set (libraryDepends . tool . contains (bind "pkgs.qt5.qtbase")) True)

107 , ("readline", over (libraryDepends . system) (Set.union (pkgs ["readline", "ncurses"])))

160 , ("readline", over (libraryDepends . system) (Set.union (pkgs ["readline", "ncurses"])))

@@ -115,26 +168,31 @@ hooks =

115 , ("target", set (testDepends . system . contains (pkg "z3")) True)

168 , ("target", set (testDepends . system . contains (pkg "z3")) True)

116 , ("terminfo", set (libraryDepends . system . contains (pkg "ncurses")) True)

169 , ("terminfo", set (libraryDepends . system . contains (pkg "ncurses")) True)

117 , ("text", set doCheck False) -- break infinite recursion

170 , ("text", set doCheck False) -- break infinite recursion

118− , ("thyme", set (libraryDepends . tool . contains (bind "self.cpphs")) True) -- required on Darwin

171+ , ("tensorflow-proto", set (libraryDepends . tool . contains (pkg "protobuf")) True)

172+ , ("thyme", set (libraryDepends . tool . contains (self "cpphs")) True) -- required on Darwin

119 , ("twilio", set doCheck False) -- attempts to access the network

173 , ("twilio", set doCheck False) -- attempts to access the network

120 , ("tz", set phaseOverrides "preConfigure = \"export TZDIR=${pkgs.tzdata}/share/zoneinfo\";")

174 , ("tz", set phaseOverrides "preConfigure = \"export TZDIR=${pkgs.tzdata}/share/zoneinfo\";")

121− , ("udev", over (metaSection . platforms) (Set.filter (\(Platform _ os) -> os == Linux))) , ("bustle", set (libraryDepends . pkgconfig . contains "system-glib = pkgs.glib") True)

175+ , ("udev", over (metaSection . platforms) (Set.filter (\(Platform _ os) -> os == Linux)))

122− , ("webkitgtk3-javascriptcore", webkitgtk24xHook) -- https://github.com/haskell-gi/haskell-gi/issues/36

123 , ("webkitgtk3", webkitgtk24xHook) -- https://github.com/haskell-gi/haskell-gi/issues/36

176 , ("webkitgtk3", webkitgtk24xHook) -- https://github.com/haskell-gi/haskell-gi/issues/36

177+ , ("webkitgtk3-javascriptcore", webkitgtk24xHook) -- https://github.com/haskell-gi/haskell-gi/issues/36

124 , ("websockets", set doCheck False) -- https://github.com/jaspervdj/websockets/issues/104

178 , ("websockets", set doCheck False) -- https://github.com/jaspervdj/websockets/issues/104

125 , ("Win32", over (metaSection . platforms) (Set.filter (\(Platform _ os) -> os == Windows)))

179 , ("Win32", over (metaSection . platforms) (Set.filter (\(Platform _ os) -> os == Windows)))

126 , ("Win32-shortcut", over (metaSection . platforms) (Set.filter (\(Platform _ os) -> os == Windows)))

180 , ("Win32-shortcut", over (metaSection . platforms) (Set.filter (\(Platform _ os) -> os == Windows)))

127− , ("wxcore", set (libraryDepends . pkgconfig . contains (pkg "wxGTK")) True)

128 , ("wxc", wxcHook)

181 , ("wxc", wxcHook)

182+ , ("wxcore", set (libraryDepends . pkgconfig . contains (pkg "wxGTK")) True)

129 , ("X11", over (libraryDepends . system) (Set.union (Set.fromList $ map bind ["pkgs.xorg.libXinerama","pkgs.xorg.libXext","pkgs.xorg.libXrender","pkgs.xorg.libXScrnSaver"])))

183 , ("X11", over (libraryDepends . system) (Set.union (Set.fromList $ map bind ["pkgs.xorg.libXinerama","pkgs.xorg.libXext","pkgs.xorg.libXrender","pkgs.xorg.libXScrnSaver"])))

130− , ("xmonad", set phaseOverrides xmonadPostInstall)

184+ , ("xmonad >= 0.14.2", set phaseOverrides xmonadPostInstall)

131− , ("zip-archive < 0.3.1", over (testDepends . tool) (replace (bind "self.zip") (pkg "zip")))

185+ , ("zip-archive < 0.3.1", over (testDepends . tool) (replace (self "zip") (pkg "zip")))

132 , ("zip-archive >= 0.3.1 && < 0.3.2.3", over (testDepends . tool) (Set.union (Set.fromList [pkg "zip", pkg "unzip"]))) -- https://github.com/jgm/zip-archive/issues/35

186 , ("zip-archive >= 0.3.1 && < 0.3.2.3", over (testDepends . tool) (Set.union (Set.fromList [pkg "zip", pkg "unzip"]))) -- https://github.com/jgm/zip-archive/issues/35

187+ , ("zip-archive >= 0.4", set (testDepends . tool . contains (pkg "which")) True)

133 ]

188 ]

134

189

135pkg :: Identifier -> Binding

190pkg :: Identifier -> Binding

136pkg i = binding # (i, path # ["pkgs",i])

191pkg i = binding # (i, path # ["pkgs",i])

137

192

193+self :: Identifier -> Binding

194+self i = binding # (i, path # ["self",i])

195+

138pkgs :: [Identifier] -> Set Binding

196pkgs :: [Identifier] -> Set Binding

139pkgs = Set.fromList . map pkg

197pkgs = Set.fromList . map pkg

140

198

@@ -144,10 +202,18 @@ bind s = binding # (i, path # is)

144 is = map (review ident) (splitOn "." s)

202 is = map (review ident) (splitOn "." s)

145 i = last is

203 i = last is

146

204

205+-- | @replace old new bset@ replaces the Nix binding @old@ with @new@ in the

206+-- set of bindings @bset@. If @old@ is not found in @bset@, then the function

207+-- fails with an 'error'.

147replace :: Binding -> Binding -> Set Binding -> Set Binding

208replace :: Binding -> Binding -> Set Binding -> Set Binding

148−replace old new bs = if old `Set.member` bs then Set.insert new (Set.delete old bs) else bs

209+replace old new bs

210+ | old `Set.member` bs = Set.insert new (Set.delete old bs)

211+ | otherwise = error (unwords [ "post-process: cannot replace name binding"

212+ , show old, "by", show new

213+ , "because it's not found in set"

214+ , show bs

215+ ])

149

216

150−-- TODO: I need to figure out how to conveniently replace a binding in a set.

151gtk3Hook :: Derivation -> Derivation -- https://github.com/NixOS/cabal2nix/issues/145

217gtk3Hook :: Derivation -> Derivation -- https://github.com/NixOS/cabal2nix/issues/145

152gtk3Hook = set (libraryDepends . pkgconfig . contains (pkg "gtk3")) True

218gtk3Hook = set (libraryDepends . pkgconfig . contains (pkg "gtk3")) True

153 . over (libraryDepends . pkgconfig) (Set.filter (\b -> view localName b /= "gtk3"))

219 . over (libraryDepends . pkgconfig) (Set.filter (\b -> view localName b /= "gtk3"))

@@ -164,13 +230,12 @@ gitAnnexHook = set phaseOverrides gitAnnexOverrides

164 where

230 where

165 gitAnnexOverrides = unlines

231 gitAnnexOverrides = unlines

166 [ "preConfigure = \"export HOME=$TEMPDIR; patchShebangs .\";"

232 [ "preConfigure = \"export HOME=$TEMPDIR; patchShebangs .\";"

167− , "installPhase = \"make PREFIX=$out BUILDER=: install\";"

233+ , "postBuild = ''"

168− , "checkPhase = ''"

169 , " ln -sf dist/build/git-annex/git-annex git-annex"

234 , " ln -sf dist/build/git-annex/git-annex git-annex"

170 , " ln -sf git-annex git-annex-shell"

235 , " ln -sf git-annex git-annex-shell"

171− , " export PATH+=\":$PWD\""

172− , " git-annex test"

173 , "'';"

236 , "'';"

237+ , "installPhase = \"make PREFIX=$out BUILDER=: install install-completions\";"

238+ , "checkPhase = ''PATH+=\":$PWD\" git-annex test'';"

174 , "enableSharedExecutables = false;"

239 , "enableSharedExecutables = false;"

175 ]

240 ]

176 buildInputs = pkgs ["git","rsync","gnupg","curl","wget","lsof","openssh","which","bup","perl"]

241 buildInputs = pkgs ["git","rsync","gnupg","curl","wget","lsof","openssh","which","bup","perl"]

@@ -191,13 +256,13 @@ gfPhaseOverrides = unlines

191 , " sed -i \"s|numJobs (bf bi)++||\" ./Setup.hs"

256 , " sed -i \"s|numJobs (bf bi)++||\" ./Setup.hs"

192 -- Parallel compilation fails. Disable it.

257 -- Parallel compilation fails. Disable it.

193 , "'';"

258 , "'';"

194− , "preBuild = ''export LD_LIBRARY_PATH=`pwd`/dist/build:$LD_LIBRARY_PATH'';"

259+ , "preBuild = ''export LD_LIBRARY_PATH=`pwd`/dist/build''${LD_LIBRARY_PATH:+:}$LD_LIBRARY_PATH'';"

195 -- The build step itself, after having built the library, needs to be able

260 -- The build step itself, after having built the library, needs to be able

196 -- to find the library it just built in order to compile grammar files.

261 -- to find the library it just built in order to compile grammar files.

197 ]

262 ]

198

263

199wxcHook :: Derivation -> Derivation

264wxcHook :: Derivation -> Derivation

200−wxcHook drv = drv & libraryDepends . system %~ Set.union (Set.fromList [pkg "mesa", bind "pkgs.xorg.libX11"])

265+wxcHook drv = drv & libraryDepends . system %~ Set.union (Set.fromList [pkg "libGL", bind "pkgs.xorg.libX11"])

201 & libraryDepends . pkgconfig . contains (pkg "wxGTK") .~ True

266 & libraryDepends . pkgconfig . contains (pkg "wxGTK") .~ True

202 & phaseOverrides .~ wxcPostInstall (packageVersion drv)

267 & phaseOverrides .~ wxcPostInstall (packageVersion drv)

203 & runHaddock .~ False

268 & runHaddock .~ False

@@ -227,10 +292,8 @@ darcsInstallPostInstall = unlines

227xmonadPostInstall :: String

292xmonadPostInstall :: String

228xmonadPostInstall = unlines

293xmonadPostInstall = unlines

229 [ "postInstall = ''"

294 [ "postInstall = ''"

230− , " shopt -s globstar"

295+ , " install -D man/xmonad.1 ''${!outputDoc}/share/man/man1/xmonad.1"

231− , " mkdir -p $doc/share/man/man1"

296+ , " install -D man/xmonad.hs ''${!outputDoc}/share/doc/$name/sample-xmonad.hs"

232− , " mv \"$data/\"**\"/man/\"*[0-9] $doc/share/man/man1/"

233− , " rm \"$data/\"**\"/man/\"*"

234 , "'';"

297 , "'';"

235 ]

298 ]

236

299

@@ -297,8 +360,50 @@ webkitgtk24xHook = set (libraryDepends . pkgconfig . contains (pkg "webkitgtk24x

297opencvOverrides :: Derivation -> Derivation

360opencvOverrides :: Derivation -> Derivation

298opencvOverrides = set phaseOverrides "hardeningDisable = [ \"bindnow\" ];"

361opencvOverrides = set phaseOverrides "hardeningDisable = [ \"bindnow\" ];"

299 . over (libraryDepends . pkgconfig) (replace (pkg "opencv") (pkg "opencv3"))

362 . over (libraryDepends . pkgconfig) (replace (pkg "opencv") (pkg "opencv3"))

300− . set (configureFlags . contains "--with-gcc=${stdenv.cc}/bin/c++") True

301− . set (configureFlags . contains "--with-ld=${stdenv.cc}/bin/c++") True

302

363

303hspecCoreOverrides :: Derivation -> Derivation -- https://github.com/hspec/hspec/issues/330

364hspecCoreOverrides :: Derivation -> Derivation -- https://github.com/hspec/hspec/issues/330

304hspecCoreOverrides = set phaseOverrides "testTarget = \"--test-option=--skip --test-option='Test.Hspec.Core.Runner.hspecResult runs specs in parallel'\";"

365hspecCoreOverrides = set phaseOverrides "testTarget = \"--test-option=--skip --test-option='Test.Hspec.Core.Runner.hspecResult runs specs in parallel'\";"

366+

367+cabal2nixOverrides :: Derivation -> Derivation

368+cabal2nixOverrides = set phaseOverrides $ unlines

369+ [ "preCheck = ''"

370+ , " export PATH=\"$PWD/dist/build/cabal2nix:$PATH\""

371+ , " export HOME=\"$TMPDIR/home\""

372+ , "'';"

373+ ]

374+

375+gtkglextHook :: Derivation -> Derivation

376+gtkglextHook = over (libraryDepends . system) (Set.union (Set.fromList deps))

377+ where

378+ deps :: [Binding]

379+ deps = bind <$> [ "pkgs.gtk2"

380+ , "pkgs.libGLU"

381+ , "pkgs.xorg.libSM"

382+ , "pkgs.xorg.libICE"

383+ , "pkgs.xorg.libXt"

384+ , "pkgs.xorg.libXmu"

385+ ]

386+

387+pandocPre26Overrides :: Derivation -> Derivation

388+pandocPre26Overrides = set phaseOverrides postInstall

389+ where

390+ postInstall = unlines [ "postInstall = ''"

391+ , " mkdir -p $out/share"

392+ , " mv $data/*/*/man $out/share/"

393+ , "'';"

394+ ]

395+

396+pandocOverrides :: Derivation -> Derivation

397+pandocOverrides = set phaseOverrides postInstall

398+ where

399+ postInstall = unlines [ "postInstall = ''"

400+ , " mkdir -p $out/share/man/man1"

401+ , " mv \"man/\"*.1 $out/share/man/man1/"

402+ , "'';"

403+ ]

404+

405+bustleOverrides :: Derivation -> Derivation

406+bustleOverrides = set (libraryDepends . pkgconfig . contains "system-glib = pkgs.glib") True

407+ . set (executableDepends . pkgconfig . contains "gio-unix = null") False

408+ . set (metaSection . license) (Known "stdenv.lib.licenses.lgpl21Plus")

409+ . set (metaSection . hydraPlatforms) allKnownPlatforms

src/Distribution/Nixpkgs/Haskell/Hackage.hs+3−2

@@ -1,7 +1,8 @@

1module Distribution.Nixpkgs.Haskell.Hackage

2 ( HackageDB, PackageData, VersionData(..)

3− , hackageTarball, readTarball

3+ , hackageTarball, readTarball, parsePackageData

4− ) where

4+ )

5+ where

5

6

6import Data.Map as Map

7import Data.Map as Map

7import qualified Distribution.Hackage.DB.Parsed as P

8import qualified Distribution.Hackage.DB.Parsed as P

src/Distribution/Nixpkgs/Haskell/OrphanInstances.hs+29−54

@@ -8,62 +8,15 @@ import Data.String

8import qualified Data.Text as T

9import Data.Yaml

10import Distribution.Compiler

11−import Distribution.License

12import Distribution.Package

11import Distribution.Package

13−import Distribution.PackageDescription

12+import Distribution.Parsec

14import Distribution.System

13import Distribution.System

15−import Distribution.Text

14+import Distribution.Pretty as Cabal

16−import Distribution.Types.CondTree

15+import qualified Data.Version as Base

17−import Distribution.Types.ExecutableScope

18−import Distribution.Types.ForeignLib

19−import Distribution.Types.ForeignLibOption

20−import Distribution.Types.ForeignLibType

21−import Distribution.Types.IncludeRenaming

22−import Distribution.Types.Mixin

23import Distribution.Version

16import Distribution.Version

24−import Language.Haskell.Extension

17+import Language.Nix.PrettyPrinting as Nix

25−

18+

26−instance NFData SetupBuildInfo

27−instance (NFData v, NFData c, NFData a) => NFData (CondTree v c a)

28−instance (NFData v, NFData c, NFData a) => NFData (CondBranch v c a)

29−instance NFData Arch

30−instance NFData Benchmark

31−instance NFData BenchmarkInterface

32−instance NFData BenchmarkType

33−instance NFData BuildInfo

34−instance NFData BuildType

35−instance NFData LibVersionInfo

36−instance NFData CompilerFlavor

37−instance NFData ConfVar

38−instance NFData ExecutableScope

39−instance NFData IncludeRenaming

40−instance NFData ForeignLibType

41−instance NFData ForeignLibOption

42−instance NFData Executable

43−instance NFData Extension

44−instance NFData Flag

45−instance NFData Mixin

46−instance NFData FlagName

47−instance NFData GenericPackageDescription

48−instance NFData KnownExtension

49−instance NFData Language

50−instance NFData Library

51−instance NFData ForeignLib

52−instance NFData License

53−instance NFData ModuleReexport

54−instance NFData ModuleRenaming

55−instance NFData OS

56−instance NFData PackageDescription

57−instance NFData RepoKind

58−instance NFData RepoType

59−instance NFData SourceRepo

60−instance NFData TestSuite

61−instance NFData TestSuiteInterface

62−instance NFData TestType

63−instance NFData a => NFData (Condition a)

64−instance NFData Platform

65instance NFData CompilerInfo

19instance NFData CompilerInfo

66−instance NFData CompilerId

67instance NFData AbiTag

20instance NFData AbiTag

68

21

69instance IsString Version where

22instance IsString Version where

@@ -99,6 +52,10 @@ instance FromJSON PackageIdentifier where

99 parseJSON (String s) = return (fromString (T.unpack s))

52 parseJSON (String s) = return (fromString (T.unpack s))

100 parseJSON s = fail ("parseJSON: " ++ show s ++ " is not a valid Haskell package identifier")

53 parseJSON s = fail ("parseJSON: " ++ show s ++ " is not a valid Haskell package identifier")

101

54

55+instance FromJSON VersionRange where

56+ parseJSON (String s) = return (fromString (T.unpack s))

57+ parseJSON s = fail ("parseJSON: " ++ show s ++ " is not a valid Cabal VersionRange")

58+

102instance FromJSON Dependency where

59instance FromJSON Dependency where

103 parseJSON (String s) = return (fromString (T.unpack s))

60 parseJSON (String s) = return (fromString (T.unpack s))

104 parseJSON s = fail ("parseJSON: " ++ show s ++ " is not a valid Haskell Dependency")

61 parseJSON s = fail ("parseJSON: " ++ show s ++ " is not a valid Haskell Dependency")

@@ -107,7 +64,25 @@ instance FromJSON CompilerInfo where

107 parseJSON (String s) = return (unknownCompilerInfo (fromString (T.unpack s)) NoAbiTag)

64 parseJSON (String s) = return (unknownCompilerInfo (fromString (T.unpack s)) NoAbiTag)

108 parseJSON s = fail ("parseJSON: " ++ show s ++ " is not a valid Haskell compiler")

65 parseJSON s = fail ("parseJSON: " ++ show s ++ " is not a valid Haskell compiler")

109

66

67+instance Nix.Pretty Version where

68+ pPrint = pretty

69+

70+instance Nix.Pretty PackageName where

71+ pPrint = pretty

72+

73+instance Nix.Pretty PackageIdentifier where

74+ pPrint = pretty

75+

76+instance Nix.Pretty CompilerId where

77+ pPrint = pretty

78+

79+instance Nix.Pretty Platform where

80+ pPrint = pretty

81+

82+instance Nix.Pretty Base.Version where

83+ pPrint = text . Base.showVersion

84+

110-- parsing tools

85-- parsing tools

111

86

112−text2isString :: Text a => String -> String -> a

87+text2isString :: Parsec a => String -> String -> a

113−text2isString t s = fromMaybe (error ("fromString: " ++ show s ++ " is not a valid " ++ t)) (simpleParse s)

88+text2isString t s = fromMaybe (error ("fromString: " ++ show s ++ " is not a valid " ++ t)) (simpleParsec s)

src/Distribution/Nixpkgs/Haskell/PackageSourceSpec.hs+100−54

@@ -1,31 +1,42 @@

1module Distribution.Nixpkgs.Haskell.PackageSourceSpec

2− ( Package(..), getPackage, getPackage', loadHackageDB, sourceFromHackage

2+ ( HpackUse(..), Package(..), getPackage, getPackage', loadHackageDB, sourceFromHackage

3 ) where

4

5import qualified Control.Exception as Exception

6import Control.Monad

7import Control.Monad.IO.Class

8import Control.Monad.Trans.Maybe

9+import Data.Bifunctor

10+import qualified Data.ByteString.Char8 as BS

9import Data.List ( isSuffixOf, isPrefixOf )

11import Data.List ( isSuffixOf, isPrefixOf )

10import qualified Data.Map as DB

12import qualified Data.Map as DB

11import Data.Maybe

13import Data.Maybe

14+import qualified Data.Text as T

15+import qualified Data.Text.Encoding as T

12import Data.Time

16import Data.Time

13import Distribution.Nixpkgs.Fetch

17import Distribution.Nixpkgs.Fetch

14import Distribution.Nixpkgs.Hashes

18import Distribution.Nixpkgs.Hashes

15import qualified Distribution.Nixpkgs.Haskell.Hackage as DB

19import qualified Distribution.Nixpkgs.Haskell.Hackage as DB

20+import Distribution.Nixpkgs.Haskell.OrphanInstances ( )

16import qualified Distribution.Package as Cabal

21import qualified Distribution.Package as Cabal

17import Distribution.PackageDescription

22import Distribution.PackageDescription

18import qualified Distribution.PackageDescription as Cabal

23import qualified Distribution.PackageDescription as Cabal

19−import Distribution.PackageDescription.Parse as Cabal

24+import Distribution.PackageDescription.Parsec as Cabal

20−import Distribution.Text ( simpleParse, display )

25+import Distribution.Parsec

21import Distribution.Version

26import Distribution.Version

22−import qualified Hpack.Render as Hpack

23import qualified Hpack.Config as Hpack

27import qualified Hpack.Config as Hpack

24−import OpenSSL.Digest ( digestString, digestByName )

28+import qualified Hpack.Render as Hpack

29+import OpenSSL.Digest ( digest, digestByName )

25import System.Directory ( doesDirectoryExist, doesFileExist, createDirectoryIfMissing, getHomeDirectory, getDirectoryContents )

30import System.Directory ( doesDirectoryExist, doesFileExist, createDirectoryIfMissing, getHomeDirectory, getDirectoryContents )

26import System.Exit ( exitFailure )

31import System.Exit ( exitFailure )

27import System.FilePath ( (</>), (<.>) )

32import System.FilePath ( (</>), (<.>) )

28−import System.IO ( hPutStrLn, stderr, hPutStr )

33+import System.IO

34+import Text.PrettyPrint.HughesPJClass hiding ( first )

35+

36+data HpackUse

37+ = ForceHpack

38+ | PackageYamlHpack

39+ | NoHpack

29

40

30data Package = Package

41data Package = Package

31 { pkgSource :: DerivationSource

42 { pkgSource :: DerivationSource

@@ -34,39 +45,45 @@ data Package = Package

34 }

45 }

35 deriving (Show)

46 deriving (Show)

36

47

37−getPackage :: Bool

48+getPackage :: HpackUse

38− -- ^ Whether hpack should regenerate the cabal file.

49+ -- ^ the way hpack should be used.

50+ -> Bool

51+ -- ^ Whether to fetch submodules if fetching from git

39 -> Maybe FilePath

52 -> Maybe FilePath

40 -- ^ The path to the Hackage database.

53 -- ^ The path to the Hackage database.

41 -> Maybe UTCTime

54 -> Maybe UTCTime

42 -- ^ If we have hackage-snapshot time.

55 -- ^ If we have hackage-snapshot time.

43 -> Source

56 -> Source

44 -> IO Package

57 -> IO Package

45−getPackage optHpack optHackageDB optHackageSnapshot =

58+getPackage optHpack optSubmodules optHackageDB optHackageSnapshot =

46− getPackage' optHpack (loadHackageDB optHackageDB optHackageSnapshot)

59+ getPackage' optHpack optSubmodules (loadHackageDB optHackageDB optHackageSnapshot)

47

60

48−getPackage' :: Bool

61+getPackage' :: HpackUse

49− -- ^ Whether hpack should regenerate the cabal file.

62+ -- ^ the way hpack should be used.

63+ -> Bool

64+ -- ^ Whether to fetch submodules if fetching from git

50 -> IO DB.HackageDB

65 -> IO DB.HackageDB

51 -> Source

66 -> Source

52 -> IO Package

67 -> IO Package

53−getPackage' optHpack hackageDB source = do

68+getPackage' optHpack optSubmodules hackageDB source = do

54− (derivSource, ranHpack, pkgDesc) <- fetchOrFromDB optHpack hackageDB source

69+ (derivSource, ranHpack, pkgDesc) <- fetchOrFromDB optHpack optSubmodules hackageDB source

55 (\s -> Package s ranHpack pkgDesc) <$> maybe (sourceFromHackage (sourceHash source) (showPackageIdentifier pkgDesc) $ sourceCabalDir source) return derivSource

70 (\s -> Package s ranHpack pkgDesc) <$> maybe (sourceFromHackage (sourceHash source) (showPackageIdentifier pkgDesc) $ sourceCabalDir source) return derivSource

56

71

57−fetchOrFromDB :: Bool

72+fetchOrFromDB :: HpackUse

58− -- ^ Whether hpack should regenerate the cabal file

73+ -- ^ the way hpack should be used

74+ -> Bool

75+ -- ^ Whether to fetch submodules if fetching from git

59 -> IO DB.HackageDB

76 -> IO DB.HackageDB

60 -> Source

77 -> Source

61 -> IO (Maybe DerivationSource, Bool, Cabal.GenericPackageDescription)

78 -> IO (Maybe DerivationSource, Bool, Cabal.GenericPackageDescription)

62−fetchOrFromDB optHpack hackageDB src

79+fetchOrFromDB optHpack optSubmodules hackageDB src

63 | "cabal://" `isPrefixOf` sourceUrl src = do

80 | "cabal://" `isPrefixOf` sourceUrl src = do

64 (msrc, pkgDesc) <- fromDB hackageDB . drop (length "cabal://") $ sourceUrl src

81 (msrc, pkgDesc) <- fromDB hackageDB . drop (length "cabal://") $ sourceUrl src

65 return (msrc, False, pkgDesc)

82 return (msrc, False, pkgDesc)

66 | otherwise = do

83 | otherwise = do

67− r <- fetch (\dir -> cabalFromPath optHpack (dir </> sourceCabalDir src)) src

84+ r <- fetch optSubmodules (\dir -> cabalFromPath optHpack (dir </> sourceCabalDir src)) src

68 case r of

85 case r of

69− Nothing -> fail "Failed to fetch source. Does the URL exist?"

86+ Nothing -> fail $ "Failed to fetch source. Does this source exist? " ++ show src

70 Just (derivSource, (externalSource, ranHpack, pkgDesc)) ->

87 Just (derivSource, (externalSource, ranHpack, pkgDesc)) ->

71 return (derivSource <$ guard externalSource, ranHpack, pkgDesc)

88 return (derivSource <$ guard externalSource, ranHpack, pkgDesc)

72

89

@@ -87,16 +104,16 @@ fromDB hackageDBIO pkg = do

87 vd <- maybe unknownPackageError return (DB.lookup name hackageDB >>= lookupVersion)

104 vd <- maybe unknownPackageError return (DB.lookup name hackageDB >>= lookupVersion)

88 let ds = case DB.tarballSha256 vd of

105 let ds = case DB.tarballSha256 vd of

89 Nothing -> Nothing

106 Nothing -> Nothing

90− Just hash -> Just (DerivationSource "url" url "" hash)

107+ Just hash -> Just (urlDerivationSource url hash)

91 return (ds, setCabalFileHash (DB.cabalFileSha256 vd) (DB.cabalFile vd))

108 return (ds, setCabalFileHash (DB.cabalFileSha256 vd) (DB.cabalFile vd))

92 where

109 where

93 pkgId :: Cabal.PackageIdentifier

110 pkgId :: Cabal.PackageIdentifier

94− pkgId = fromMaybe (error ("invalid Haskell package id " ++ show pkg)) (simpleParse pkg)

111+ pkgId = fromMaybe (error ("invalid Haskell package id " ++ show pkg)) (simpleParsec pkg)

95 name = Cabal.packageName pkgId

112 name = Cabal.packageName pkgId

96

113

97− unknownPackageError = fail $ "No such package " ++ display pkgId ++ " in the cabal database. Did you run cabal update?"

114+ unknownPackageError = fail $ "No such package " ++ prettyShow pkgId ++ " in the cabal database. Did you run cabal update?"

98

115

99− url = "mirror://hackage/" ++ display pkgId ++ ".tar.gz"

116+ url = "mirror://hackage/" ++ prettyShow pkgId ++ ".tar.gz"

100

117

101 version :: Version

118 version :: Version

102 version = Cabal.packageVersion pkgId

119 version = Cabal.packageVersion pkgId

@@ -133,20 +150,20 @@ sourceFromHackage optHash pkgId cabalDir = do

133 -- Use the cached hash (either from cache file or given on cmdline via sha256 opt)

150 -- Use the cached hash (either from cache file or given on cmdline via sha256 opt)

134 -- if available, otherwise download from hackage to compute hash.

151 -- if available, otherwise download from hackage to compute hash.

135 case cachedHash of

152 case cachedHash of

136− Guess hash -> return $ DerivationSource "url" url "" hash

153+ Guess hash -> return $ urlDerivationSource url hash

137 Certain hash ->

154 Certain hash ->

138 -- We need to force the hash here. If we didn't do this, then when reading the

155 -- We need to force the hash here. If we didn't do this, then when reading the

139 -- hash from the cache file, the cache file will still be open for reading

156 -- hash from the cache file, the cache file will still be open for reading

140 -- (because lazy io) when writeFile opens the file again for writing. By forcing

157 -- (because lazy io) when writeFile opens the file again for writing. By forcing

141 -- the hash here, we ensure that the file is closed before opening it again.

158 -- the hash here, we ensure that the file is closed before opening it again.

142 seq (length hash) $

159 seq (length hash) $

143− DerivationSource "url" url "" hash <$ writeFile cacheFile hash

160+ urlDerivationSource url hash <$ writeFile cacheFile hash

144 UnknownHash -> do

161 UnknownHash -> do

145 maybeHash <- runMaybeT (derivHash . fst <$> fetchWith (False, "url", []) (Source url "" UnknownHash cabalDir))

162 maybeHash <- runMaybeT (derivHash . fst <$> fetchWith (False, "url", []) (Source url "" UnknownHash cabalDir))

146 case maybeHash of

163 case maybeHash of

147 Just hash ->

164 Just hash ->

148 seq (length hash) $

165 seq (length hash) $

149− DerivationSource "url" url "" hash <$ writeFile cacheFile hash

166+ urlDerivationSource url hash <$ writeFile cacheFile hash

150 Nothing -> do

167 Nothing -> do

151 hPutStr stderr $ unlines

168 hPutStr stderr $ unlines

152 [ "*** cannot compute hash. (Not a hackage project?)"

169 [ "*** cannot compute hash. (Not a hackage project?)"

@@ -159,12 +176,12 @@ sourceFromHackage optHash pkgId cabalDir = do

159 exitFailure

176 exitFailure

160

177

161showPackageIdentifier :: Cabal.GenericPackageDescription -> String

178showPackageIdentifier :: Cabal.GenericPackageDescription -> String

162−showPackageIdentifier pkgDesc = name ++ "-" ++ display version where

179+showPackageIdentifier pkgDesc = name ++ "-" ++ prettyShow version where

163 pkgId = Cabal.package . Cabal.packageDescription $ pkgDesc

180 pkgId = Cabal.package . Cabal.packageDescription $ pkgDesc

164 name = Cabal.unPackageName (Cabal.packageName pkgId)

181 name = Cabal.unPackageName (Cabal.packageName pkgId)

165 version = Cabal.packageVersion pkgId

182 version = Cabal.packageVersion pkgId

166

183

167−cabalFromPath :: Bool -- ^ Whether hpack should regenerate the cabal file

184+cabalFromPath :: HpackUse -- ^ the way hpack should be used

168 -> FilePath -> MaybeT IO (Bool, Bool, Cabal.GenericPackageDescription)

185 -> FilePath -> MaybeT IO (Bool, Bool, Cabal.GenericPackageDescription)

169cabalFromPath optHpack path = do

186cabalFromPath optHpack path = do

170 d <- liftIO $ doesDirectoryExist path

187 d <- liftIO $ doesDirectoryExist path

@@ -174,50 +191,79 @@ cabalFromPath optHpack path = do

174 return (d, ranHpack, pkg)

191 return (d, ranHpack, pkg)

175 else (,,) d False <$> cabalFromFile False path

192 else (,,) d False <$> cabalFromFile False path

176

193

177−cabalFromDirectory :: Bool -- ^ Whether hpack should regenerate the cabal file

194+cabalFromDirectory :: HpackUse -- ^ the way hpack should be used

178 -> FilePath -> MaybeT IO (Bool, Cabal.GenericPackageDescription)

195 -> FilePath -> MaybeT IO (Bool, Cabal.GenericPackageDescription)

179−cabalFromDirectory True dir = hpackDirectory dir

196+cabalFromDirectory ForceHpack dir = hpackDirectory dir

180−cabalFromDirectory False dir = do

197+cabalFromDirectory NoHpack dir = onlyCabalFromDirectory dir "*** No .cabal file was found. Exiting."

198+cabalFromDirectory PackageYamlHpack dir = do

199+ useHpack <- liftIO $ doesFileExist (dir </> "package.yaml")

200+ if useHpack

201+ then do

202+ liftIO $ hPutStrLn stderr "*** found package.yaml. Using hpack..."

203+ hpackDirectory dir

204+ else onlyCabalFromDirectory dir "*** Found neither a .cabal file nor package.yaml. Exiting."

205+

206+onlyCabalFromDirectory :: FilePath -> String -> MaybeT IO (Bool, Cabal.GenericPackageDescription)

207+onlyCabalFromDirectory dir errMsg = do

181 cabals <- liftIO $ getDirectoryContents dir >>= filterM doesFileExist . map (dir </>) . filter (".cabal" `isSuffixOf`)

208 cabals <- liftIO $ getDirectoryContents dir >>= filterM doesFileExist . map (dir </>) . filter (".cabal" `isSuffixOf`)

182 case cabals of

209 case cabals of

183− [] -> do

210+ [] -> fail errMsg

184− liftIO $ hPutStrLn stderr "*** found zero cabal files. Trying hpack..."

185− hpackDirectory dir

186 [cabalFile] -> (,) False <$> cabalFromFile True cabalFile

211 [cabalFile] -> (,) False <$> cabalFromFile True cabalFile

187− _ -> liftIO $ fail ("*** found more than one cabal file (" ++ show cabals ++ "). Exiting.")

212+ _ -> liftIO $ fail ("*** found more than one cabal file (" ++ show cabals ++ "). Exiting.")

188

213

189handleIO :: (Exception.IOException -> IO a) -> IO a -> IO a

214handleIO :: (Exception.IOException -> IO a) -> IO a -> IO a

190handleIO = Exception.handle

215handleIO = Exception.handle

191

216

217+encodeUtf8 :: String -> BS.ByteString

218+encodeUtf8 = T.encodeUtf8 . T.pack

219+

192hpackDirectory :: FilePath -> MaybeT IO (Bool, Cabal.GenericPackageDescription)

220hpackDirectory :: FilePath -> MaybeT IO (Bool, Cabal.GenericPackageDescription)

193hpackDirectory dir = do

221hpackDirectory dir = do

194− mPackage <- liftIO $ Hpack.readPackageConfig Hpack.defaultDecodeOptions {Hpack.decodeOptionsTarget = dir </> Hpack.packageConfig}

222+ mPackage <- liftIO $ Hpack.readPackageConfig Hpack.defaultDecodeOptions {

223+ Hpack.decodeOptionsProgramName = Hpack.ProgramName "cabal2nix"

224+ , Hpack.decodeOptionsTarget = dir </> Hpack.packageConfig

225+ }

195 case mPackage of

226 case mPackage of

196 Left err -> liftIO $ hPutStrLn stderr ("*** hpack error: " ++ show err ++ ". Exiting.") >> exitFailure

227 Left err -> liftIO $ hPutStrLn stderr ("*** hpack error: " ++ show err ++ ". Exiting.") >> exitFailure

197− Right (Hpack.DecodeResult pkg' _ _) -> do

228+ Right r -> do

198− let hpackOutput = Hpack.renderPackage [] pkg'

229+ let hpackOutput =

199− hash = printSHA256 $ digestString (digestByName "sha256") hpackOutput

230+ let body = Hpack.renderPackage [] (Hpack.decodeResultPackage r)

200− case parseGenericPackageDescription hpackOutput of

231+ cabalVersion = Hpack.decodeResultCabalVersion r

201− ParseFailed perr -> liftIO $ do

232+ in encodeUtf8 $ cabalVersion ++ body

202− hPutStrLn stderr $ "*** cannot parse hpack output: " ++ show perr

233+ hash = printSHA256 $ digest (digestByName "sha256") hpackOutput

203− hPutStrLn stderr $ "*** hpack output:\n" ++ hpackOutput

234+ case runParseGenericPackageDescription "<hpack output>" hpackOutput of

235+ Left msg -> liftIO $ do

236+ hPutStrLn stderr "*** hpack output:"

237+ BS.hPutStrLn stderr hpackOutput

238+ hPutStrLn stderr "*** cannot parse hpack output:"

239+ hPutStrLn stderr msg

204 fail "*** Exiting."

240 fail "*** Exiting."

205− ParseOk _ pkg -> MaybeT $ return $ Just $ (,) True $ setCabalFileHash hash pkg

241+ Right pkg -> MaybeT $ return $ Just $ (,) True $ setCabalFileHash hash pkg

206

242

207cabalFromFile :: Bool -> FilePath -> MaybeT IO Cabal.GenericPackageDescription

243cabalFromFile :: Bool -> FilePath -> MaybeT IO Cabal.GenericPackageDescription

208cabalFromFile failHard file =

244cabalFromFile failHard file =

209− -- readFile throws an error if it's used on binary files which contain sequences

245+ -- hGetContents throws an error if it's used on files which contain sequences

210 -- that do not represent valid characters. To catch that exception, we need to

246 -- that do not represent valid characters. To catch that exception, we need to

211− -- wrap the whole block in `catchIO`, because of lazy IO. The `case` will force

247+ -- wrap the whole block in `catchIO`.

212− -- the reading of the file, so we will always catch the expression here.

213 MaybeT $ handleIO (\err -> Nothing <$ hPutStrLn stderr ("*** parsing cabal file: " ++ show err)) $ do

248 MaybeT $ handleIO (\err -> Nothing <$ hPutStrLn stderr ("*** parsing cabal file: " ++ show err)) $ do

214− buf <- readFile file

249+ buf <- BS.readFile file

215− let hash = printSHA256 (digestString (digestByName "sha256") buf)

250+ let hash = printSHA256 (digest (digestByName "sha256") buf)

216− case parseGenericPackageDescription buf of

251+ case runParseGenericPackageDescription file buf of

217− ParseFailed perr -> if failHard

252+ Left msg | failHard -> liftIO $ do

218− then fail ("cannot parse " ++ show file ++ ": " ++ show perr)

253+ hPutStrLn stderr $ "*** cannot parse " ++ show file ++ ":"

219− else return Nothing

254+ hPutStrLn stderr msg

220− ParseOk _ pkg -> return $ Just $ setCabalFileHash hash pkg

255+ fail "*** Exiting."

256+ Left _ -> return Nothing

257+ Right pkg -> return $ Just $ setCabalFileHash hash pkg

258+

259+runParseGenericPackageDescription

260+ :: FilePath

261+ -> BS.ByteString

262+ -> Either String Cabal.GenericPackageDescription

263+runParseGenericPackageDescription fpath

264+ = first (unlines . fmap (showPError fpath) . snd)

265+ . snd . runParseResult

266+ . parseGenericPackageDescription

221

267

222setCabalFileHash :: String -> GenericPackageDescription -> GenericPackageDescription

268setCabalFileHash :: String -> GenericPackageDescription -> GenericPackageDescription

223setCabalFileHash sha256 gpd = gpd { packageDescription = (packageDescription gpd) {

269setCabalFileHash sha256 gpd = gpd { packageDescription = (packageDescription gpd) {

test/Main.hs+93−21

@@ -1,50 +1,122 @@

1+{-# LANGUAGE OverloadedStrings #-}

2+

1module Main ( main ) where

3module Main ( main ) where

2

4

3−import Distribution.Nixpkgs.Haskell.FromCabal

4−import Distribution.Nixpkgs.Haskell.Derivation

5import Distribution.Nixpkgs.Fetch

6+import Distribution.Nixpkgs.Haskell.Derivation

7+import Distribution.Nixpkgs.Haskell.FromCabal

8+import Distribution.Nixpkgs.Haskell.FromCabal.Flags

6

9

7import Control.Lens

10import Control.Lens

11+import Control.Monad

12+import qualified Data.Set as Set

8import Distribution.Compiler

13import Distribution.Compiler

14+import Distribution.Package

9import Distribution.PackageDescription

15import Distribution.PackageDescription

10−import Distribution.PackageDescription.Parse

16+import Distribution.PackageDescription.Parsec

11import Distribution.System

17import Distribution.System

12import Distribution.Verbosity

18import Distribution.Verbosity

13import Distribution.Version

19import Distribution.Version

14import Language.Nix

20import Language.Nix

21+import System.Directory

15import System.FilePath

22import System.FilePath

23+import System.Process

16import Test.Tasty

24import Test.Tasty

17import Test.Tasty.Golden

25import Test.Tasty.Golden

18import Text.PrettyPrint.HughesPJClass

26import Text.PrettyPrint.HughesPJClass

19

27

20main :: IO ()

28main :: IO ()

21main = do

29main = do

22− testCases <- findByExtension [".cabal"] "test/golden-test-cases"

30+ -- TODO: Run this test with all kinds of setLocaleEncoding values to ensure we don't

23− defaultMain $ testGroup "regression-tests" (map regressionTest testCases)

31+ -- depend on the system environment: https://github.com/NixOS/cabal2nix/issues/333.

32+ --

33+ -- TODO: Run this test without $HOME defined to ensure that we don't need that variable.

34+ cabal2nix <- findExecutable "cabal2nix" >>= maybe (fail "cannot find 'cabal2nix' in $PATH") return

35+ testCases <- listDirectoryFilesBySuffix ".cabal" "test/golden-test-cases"

36+ defaultMain $ testGroup "regression-tests"

37+ [ testGroup "cabal2nix library" (map testLibrary testCases)

38+ , testGroup "cabal2nix executable" (map (testExecutable cabal2nix) testCases)

39+ ]

24

40

25−regressionTest :: String -> TestTree

41+testLibrary :: String -> TestTree

26−regressionTest cabalFile = do

42+testLibrary cabalFile = do

27 let nixFile = cabalFile `replaceExtension` "nix"

43 let nixFile = cabalFile `replaceExtension` "nix"

28 goldenFile = nixFile `addExtension` "golden"

44 goldenFile = nixFile `addExtension` "golden"

29

45

30 cabal2nix :: GenericPackageDescription -> Derivation

46 cabal2nix :: GenericPackageDescription -> Derivation

31 cabal2nix gpd = fromGenericPackageDescription

47 cabal2nix gpd = fromGenericPackageDescription

32− (const True)

48+ (const True)

33− (\i -> Just (binding # (i, path # [i])))

49+ (\i -> Just (binding # (i, path # [ident # "pkgs", i])))

34− (Platform X86_64 Linux)

50+ (Platform X86_64 Linux)

35− (unknownCompilerInfo (CompilerId GHC (mkVersion [8,2])) NoAbiTag)

51+ (unknownCompilerInfo (CompilerId GHC (mkVersion [8,2])) NoAbiTag)

36− []

52+ (configureCabalFlags (packageId gpd))

37− []

53+ []

38− gpd

54+ gpd

39− & src .~ DerivationSource

55+ & src .~ DerivationSource

40− { derivKind = "url"

56+ { derivKind = "url"

41− , derivUrl = "http://example.org/"

57+ , derivUrl = "mirror://hackage/foo.tar.gz"

42− , derivRevision = ""

58+ , derivRevision = ""

43− , derivHash = "abc"

59+ , derivHash = "deadbeef"

44− }

60+ , derivSubmodule = Nothing

61+ }

62+ & extraFunctionArgs %~ Set.union (Set.singleton "inherit stdenv")

45 goldenVsFileDiff

63 goldenVsFileDiff

46 nixFile

64 nixFile

47 (\ref new -> ["diff", "-u", ref, new])

65 (\ref new -> ["diff", "-u", ref, new])

48 goldenFile

66 goldenFile

49 nixFile

67 nixFile

50− (readGenericPackageDescription silent cabalFile >>= writeFile nixFile . prettyShow . cabal2nix)

68+ (readGenericPackageDescription silent cabalFile >>= writeFileLn nixFile . prettyShow . cabal2nix)

69+

70+-- | TODO:

71+--

72+-- * Run cabal2nix in an empty environment. Currently, this fails because the

73+-- tool uses $HOME to write cache files for SHA256 hashes. To fix this, use

74+-- of the cache directory ought to be optional. Arguably, the whole notion

75+-- of caching those hashes is a bit silly in the presence of format 01

76+-- cabal-install tarballs which contain them already.

77+--

78+-- * If we cannot get along without $HOME, then we should at least set it to

79+-- some temporary location that is empty.

80+--

81+-- * Run this test with different kinds of encodings.

82+--

83+-- * Run tests with a different target OS, like Darwin. The packages "iconv",

84+-- "crypt-sha512", "gl" might be worthwhile for testing since their output

85+-- differs on Darwin.

86+

87+testExecutable :: FilePath -> FilePath -> TestTree

88+testExecutable exe cabalFile = do

89+ let nixFile = cabalFile `replaceExtension` "nix"

90+ goldenFile = nixFile `addExtension` "golden"

91+ goldenVsFileDiff

92+ nixFile

93+ (\ref new -> ["diff", "-u", ref, new])

94+ goldenFile

95+ nixFile

96+ (callCommand (unwords ["env LANG=en_US.UTF-8", exe, "--sha256=deadbeef", "--system=x86_64-linux", "--compiler=ghc-8.2", "--", cabalFile, ">"++nixFile]))

97+

98+-------------------------------------------------------------------------------

99+-- * Helper functions

100+-------------------------------------------------------------------------------

101+

102+-- | Find all *files* in the given directory that end with the given suffix.

103+-- This function does not recurse, nor does it include the special entries

104+-- @'.'@ or @'..'@ in the result.

105+--

106+-- "Test.Tasty.Golden" offers 'findByExtension', which does something similar

107+-- (and arguably more general) as those two functions, but unfortunately that

108+-- function recurses through the directory hierarchy and in the process needs

109+-- plenty of stack space. There might be a space leak in that code, I am not

110+-- sure. Anyhow, since our test suite is supposed to run with 1K stack space,

111+-- we prefer our own simpler code.

112+

113+listDirectoryFilesBySuffix :: String -> FilePath -> IO [FilePath]

114+listDirectoryFilesBySuffix suff dirPath = do

115+ entries <- listDirectory dirPath

116+ filterM doesFileExist [ dirPath </> e | e <- entries, takeExtension e == suff ]

117+

118+-- | A variant of 'writeFile' that appends a newline to the end of the buffer

119+-- before writing.

120+

121+writeFileLn :: FilePath -> String -> IO ()

122+writeFileLn p buf = writeFile p (buf ++ "\n")

test/golden-test-cases/ChasingBottoms.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, array, base, containers, fetchurl, mtl, QuickCheck

1+{ mkDerivation, array, base, containers, mtl, QuickCheck, random

2−, random, syb

2+, stdenv, syb

3}:

4mkDerivation {

5 pname = "ChasingBottoms";

6 version = "1.3.1.3";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base containers mtl QuickCheck random syb

9 base containers mtl QuickCheck random syb

13 ];

10 ];

@@ -16,4 +13,4 @@ mkDerivation {

16 ];

13 ];

17 description = "For testing partial and infinite values";

14 description = "For testing partial and infinite values";

18 license = stdenv.lib.licenses.mit;

15 license = stdenv.lib.licenses.mit;

19−}

16+}

test/golden-test-cases/Clipboard.nix.golden+3−7

@@ -1,14 +1,10 @@

1−{ mkDerivation, base, directory, fetchurl, unix, utf8-string, X11

1+{ mkDerivation, base, directory, stdenv, unix, utf8-string, X11 }:

2−}:

3mkDerivation {

2mkDerivation {

4 pname = "Clipboard";

3 pname = "Clipboard";

5 version = "2.3.2.0";

4 version = "2.3.2.0";

6− src = fetchurl {

5+ sha256 = "deadbeef";

7− url = "http://example.org/";

8− sha256 = "abc";

9− };

10 libraryHaskellDepends = [ base directory unix utf8-string X11 ];

6 libraryHaskellDepends = [ base directory unix utf8-string X11 ];

11 homepage = "http://haskell.org/haskellwiki/Clipboard";

7 homepage = "http://haskell.org/haskellwiki/Clipboard";

12 description = "System clipboard interface";

8 description = "System clipboard interface";

13 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

14−}

10+}

test/golden-test-cases/FenwickTree.nix.golden+3−6

@@ -1,15 +1,12 @@

1−{ mkDerivation, base, fetchurl, QuickCheck, template-haskell }:

1+{ mkDerivation, base, QuickCheck, stdenv, template-haskell }:

2mkDerivation {

3 pname = "FenwickTree";

4 version = "0.1.2.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 enableSeparateDataOutput = true;

6 enableSeparateDataOutput = true;

10 libraryHaskellDepends = [ base QuickCheck template-haskell ];

7 libraryHaskellDepends = [ base QuickCheck template-haskell ];

11 testHaskellDepends = [ base QuickCheck template-haskell ];

8 testHaskellDepends = [ base QuickCheck template-haskell ];

12 homepage = "https://github.com/mgajda/FenwickTree";

9 homepage = "https://github.com/mgajda/FenwickTree";

13 description = "Data structure for fast query and update of cumulative sums";

10 description = "Data structure for fast query and update of cumulative sums";

14 license = stdenv.lib.licenses.bsd3;

11 license = stdenv.lib.licenses.bsd3;

15−}

12+}

test/golden-test-cases/GPipe-GLFW.nix.golden+3−7

@@ -1,16 +1,12 @@

1−{ mkDerivation, async, base, containers, fetchurl, GLFW-b, GPipe

1+{ mkDerivation, async, base, containers, GLFW-b, GPipe, stdenv, stm

2−, stm

3}:

2}:

4mkDerivation {

3mkDerivation {

5 pname = "GPipe-GLFW";

4 pname = "GPipe-GLFW";

6 version = "1.4.1.1";

5 version = "1.4.1.1";

7− src = fetchurl {

6+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 enableSeparateDataOutput = true;

7 enableSeparateDataOutput = true;

12 libraryHaskellDepends = [ async base containers GLFW-b GPipe stm ];

8 libraryHaskellDepends = [ async base containers GLFW-b GPipe stm ];

13 homepage = "https://github.com/plredmond/GPipe-GLFW";

9 homepage = "https://github.com/plredmond/GPipe-GLFW";

14 description = "GLFW OpenGL context creation for GPipe";

10 description = "GLFW OpenGL context creation for GPipe";

15 license = stdenv.lib.licenses.mit;

11 license = stdenv.lib.licenses.mit;

16−}

12+}

test/golden-test-cases/GenericPretty.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, ghc-prim, pretty }:

1+{ mkDerivation, base, ghc-prim, pretty, stdenv }:

2mkDerivation {

3 pname = "GenericPretty";

4 version = "1.2.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ghc-prim pretty ];

6 libraryHaskellDepends = [ base ghc-prim pretty ];

10 homepage = "https://github.com/RazvanRanca/GenericPretty";

7 homepage = "https://github.com/RazvanRanca/GenericPretty";

11 description = "A generic, derivable, haskell pretty printer";

8 description = "A generic, derivable, haskell pretty printer";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/HPDF.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, array, base, base64-bytestring, binary, bytestring

2−, containers, errors, fetchurl, HTF, mtl, random, vector, zlib

2+, containers, errors, HTF, mtl, random, stdenv, vector, zlib

3}:

4mkDerivation {

5 pname = "HPDF";

6 version = "1.4.10";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 array base base64-bytestring binary bytestring containers errors

9 array base base64-bytestring binary bytestring containers errors

13 mtl random vector zlib

10 mtl random vector zlib

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "http://www.alpheccar.org";

13 homepage = "http://www.alpheccar.org";

17 description = "Generation of PDF documents";

14 description = "Generation of PDF documents";

18 license = stdenv.lib.licenses.bsd3;

15 license = stdenv.lib.licenses.bsd3;

19−}

16+}

test/golden-test-cases/HTF.nix.golden+5−8

@@ -1,17 +1,14 @@

1{ mkDerivation, aeson, aeson-pretty, array, base, base64-bytestring

2−, bytestring, containers, cpphs, Diff, directory, fetchurl

2+, bytestring, containers, cpphs, Diff, directory, filepath

3−, filepath, haskell-src, HUnit, lifted-base, monad-control, mtl

3+, haskell-src, HUnit, lifted-base, monad-control, mtl, old-time

4−, old-time, pretty, process, QuickCheck, random, regex-compat

4+, pretty, process, QuickCheck, random, regex-compat, stdenv

5, template-haskell, temporary, text, time, unix

6, unordered-containers, vector, xmlgen

7}:

8mkDerivation {

9 pname = "HTF";

10 version = "0.13.2.2";

11− src = fetchurl {

11+ sha256 = "deadbeef";

12− url = "http://example.org/";

13− sha256 = "abc";

14− };

15 isLibrary = true;

12 isLibrary = true;

16 isExecutable = true;

13 isExecutable = true;

17 libraryHaskellDepends = [

14 libraryHaskellDepends = [

@@ -31,4 +28,4 @@ mkDerivation {

31 homepage = "https://github.com/skogsbaer/HTF/";

28 homepage = "https://github.com/skogsbaer/HTF/";

32 description = "The Haskell Test Framework";

29 description = "The Haskell Test Framework";

33 license = "LGPL";

30 license = "LGPL";

34−}

31+}

test/golden-test-cases/HTTP.nix.golden+5−8

@@ -1,15 +1,12 @@

1{ mkDerivation, array, base, bytestring, case-insensitive, conduit

2−, conduit-extra, deepseq, fetchurl, http-types, httpd-shed, HUnit

2+, conduit-extra, deepseq, http-types, httpd-shed, HUnit, mtl

3−, mtl, network, network-uri, parsec, pureMD5, split, test-framework

3+, network, network-uri, parsec, pureMD5, split, stdenv

4−, test-framework-hunit, time, wai, warp

4+, test-framework, test-framework-hunit, time, wai, warp

5}:

6mkDerivation {

7 pname = "HTTP";

8 version = "4000.3.9";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

14 array base bytestring mtl network network-uri parsec time

11 array base bytestring mtl network network-uri parsec time

15 ];

12 ];

@@ -21,4 +18,4 @@ mkDerivation {

21 homepage = "https://github.com/haskell/HTTP";

18 homepage = "https://github.com/haskell/HTTP";

22 description = "A library for client-side HTTP";

19 description = "A library for client-side HTTP";

23 license = stdenv.lib.licenses.bsd3;

20 license = stdenv.lib.licenses.bsd3;

24−}

21+}

test/golden-test-cases/Hclip.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, mtl, process, strict }:

1+{ mkDerivation, base, mtl, process, stdenv, strict }:

2mkDerivation {

3 pname = "Hclip";

4 version = "3.0.0.4";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base mtl process strict ];

6 libraryHaskellDepends = [ base mtl process strict ];

10 homepage = "https://github.com/jetho/Hclip";

7 homepage = "https://github.com/jetho/Hclip";

11 description = "A small cross-platform library for reading and modifying the system clipboard";

8 description = "A small cross-platform library for reading and modifying the system clipboard";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/MissingH.nix.golden+5−8

@@ -1,15 +1,12 @@

1{ mkDerivation, array, base, containers, directory

2−, errorcall-eq-instance, fetchurl, filepath, hslogger, HUnit, mtl

2+, errorcall-eq-instance, filepath, hslogger, HUnit, mtl, network

3−, network, old-locale, old-time, parsec, process, QuickCheck

3+, old-locale, old-time, parsec, process, QuickCheck, random

4−, random, regex-compat, testpack, time, unix

4+, regex-compat, stdenv, testpack, time, unix

5}:

6mkDerivation {

7 pname = "MissingH";

8 version = "1.4.0.1";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

14 array base containers directory filepath hslogger HUnit mtl network

11 array base containers directory filepath hslogger HUnit mtl network

15 old-locale old-time parsec process random regex-compat time unix

12 old-locale old-time parsec process random regex-compat time unix

@@ -22,4 +19,4 @@ mkDerivation {

22 homepage = "http://software.complete.org/missingh";

19 homepage = "http://software.complete.org/missingh";

23 description = "Large utility library";

20 description = "Large utility library";

24 license = stdenv.lib.licenses.bsd3;

21 license = stdenv.lib.licenses.bsd3;

25−}

22+}

test/golden-test-cases/ObjectName.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, transformers }:

1+{ mkDerivation, base, stdenv, transformers }:

2mkDerivation {

3 pname = "ObjectName";

4 version = "1.1.0.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base transformers ];

6 libraryHaskellDepends = [ base transformers ];

10 homepage = "https://github.com/svenpanne/ObjectName";

7 homepage = "https://github.com/svenpanne/ObjectName";

11 description = "Explicitly handled object names";

8 description = "Explicitly handled object names";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/Only.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, base, deepseq, fetchurl }:

1+{ mkDerivation, base, deepseq, stdenv }:

2mkDerivation {

3 pname = "Only";

4 version = "0.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base deepseq ];

6 libraryHaskellDepends = [ base deepseq ];

10 description = "The 1-tuple type or single-value \"collection\"";

7 description = "The 1-tuple type or single-value \"collection\"";

11 license = stdenv.lib.licenses.bsd3;

8 license = stdenv.lib.licenses.bsd3;

12−}

9+}

test/golden-test-cases/QuasiText.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, attoparsec, base, fetchurl, haskell-src-meta

1+{ mkDerivation, attoparsec, base, haskell-src-meta, stdenv

2, template-haskell, text, th-lift-instances

3}:

4mkDerivation {

5 pname = "QuasiText";

6 version = "0.1.2.6";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 attoparsec base haskell-src-meta template-haskell text

9 attoparsec base haskell-src-meta template-haskell text

13 th-lift-instances

10 th-lift-instances

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://github.com/mikeplus64/QuasiText";

12 homepage = "https://github.com/mikeplus64/QuasiText";

16 description = "A QuasiQuoter for Text";

13 description = "A QuasiQuoter for Text";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/QuickCheck.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, containers, deepseq, fetchurl, random

1+{ mkDerivation, base, containers, deepseq, random, stdenv

2, template-haskell, tf-random, transformers

3}:

4mkDerivation {

5 pname = "QuickCheck";

6 version = "2.10.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base containers deepseq random template-haskell tf-random

9 base containers deepseq random template-haskell tf-random

13 transformers

10 transformers

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/nick8325/quickcheck";

13 homepage = "https://github.com/nick8325/quickcheck";

17 description = "Automatic testing of Haskell programs";

14 description = "Automatic testing of Haskell programs";

18 license = stdenv.lib.licenses.bsd3;

15 license = stdenv.lib.licenses.bsd3;

19−}

16+}

test/golden-test-cases/ReadArgs.nix.golden+3−6

@@ -1,11 +1,8 @@

1−{ mkDerivation, base, fetchurl, hspec, system-filepath, text }:

1+{ mkDerivation, base, hspec, stdenv, system-filepath, text }:

2mkDerivation {

3 pname = "ReadArgs";

4 version = "1.2.3";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 isLibrary = true;

6 isLibrary = true;

10 isExecutable = true;

7 isExecutable = true;

11 libraryHaskellDepends = [ base system-filepath text ];

8 libraryHaskellDepends = [ base system-filepath text ];

@@ -14,4 +11,4 @@ mkDerivation {

14 homepage = "http://github.com/rampion/ReadArgs";

11 homepage = "http://github.com/rampion/ReadArgs";

15 description = "Simple command line argument parsing";

12 description = "Simple command line argument parsing";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/SHA.nix.golden+4−8

@@ -1,21 +1,17 @@

1−{ mkDerivation, array, base, binary, bytestring, directory

1+{ mkDerivation, array, base, binary, bytestring, QuickCheck, stdenv

2−, fetchurl, QuickCheck, test-framework, test-framework-quickcheck2

2+, test-framework, test-framework-quickcheck2

3}:

4mkDerivation {

5 pname = "SHA";

6 version = "1.6.4.2";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 isLibrary = true;

8 isLibrary = true;

12 isExecutable = true;

9 isExecutable = true;

13 libraryHaskellDepends = [ array base binary bytestring ];

10 libraryHaskellDepends = [ array base binary bytestring ];

14− executableHaskellDepends = [ base bytestring directory ];

15 testHaskellDepends = [

11 testHaskellDepends = [

16 array base binary bytestring QuickCheck test-framework

12 array base binary bytestring QuickCheck test-framework

17 test-framework-quickcheck2

13 test-framework-quickcheck2

18 ];

14 ];

19 description = "Implementations of the SHA suite of message digest functions";

15 description = "Implementations of the SHA suite of message digest functions";

20 license = stdenv.lib.licenses.bsd3;

16 license = stdenv.lib.licenses.bsd3;

21−}

17+}

test/golden-test-cases/Strafunski-StrategyLib.nix.golden+3−7

@@ -1,13 +1,9 @@

1−{ mkDerivation, base, directory, fetchurl, mtl, syb, transformers

1+{ mkDerivation, base, directory, mtl, stdenv, syb, transformers }:

2−}:

3mkDerivation {

2mkDerivation {

4 pname = "Strafunski-StrategyLib";

3 pname = "Strafunski-StrategyLib";

5 version = "5.0.0.10";

4 version = "5.0.0.10";

6− src = fetchurl {

5+ sha256 = "deadbeef";

7− url = "http://example.org/";

8− sha256 = "abc";

9− };

10 libraryHaskellDepends = [ base directory mtl syb transformers ];

6 libraryHaskellDepends = [ base directory mtl syb transformers ];

11 description = "Library for strategic programming";

7 description = "Library for strategic programming";

12 license = stdenv.lib.licenses.bsd3;

8 license = stdenv.lib.licenses.bsd3;

13−}

9+}

test/golden-test-cases/accelerate-fftw.nix.golden+4−7

@@ -1,17 +1,14 @@

1−{ mkDerivation, accelerate, accelerate-io, base, carray, fetchurl

1+{ mkDerivation, accelerate, accelerate-io, base, carray, fft

2−, fft, storable-complex

2+, stdenv, storable-complex

3}:

4mkDerivation {

5 pname = "accelerate-fftw";

6 version = "1.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 accelerate accelerate-io base carray fft storable-complex

9 accelerate accelerate-io base carray fft storable-complex

13 ];

10 ];

14 homepage = "http://hub.darcs.net/thielema/accelerate-fftw/";

11 homepage = "http://hub.darcs.net/thielema/accelerate-fftw/";

15 description = "Accelerate frontend to the FFTW library (Fourier transform)";

12 description = "Accelerate frontend to the FFTW library (Fourier transform)";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/accelerate.nix.golden+4−7

@@ -1,15 +1,12 @@

1{ mkDerivation, ansi-wl-pprint, base, base-orphans, containers

2−, deepseq, directory, exceptions, fclabels, fetchurl, filepath

2+, deepseq, directory, exceptions, fclabels, filepath, ghc-prim

3−, ghc-prim, hashable, hashtables, mtl, template-haskell, time

3+, hashable, hashtables, mtl, stdenv, template-haskell, time

4, transformers, unique, unix, unordered-containers

5}:

6mkDerivation {

7 pname = "accelerate";

8 version = "1.1.1.0";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

14 ansi-wl-pprint base base-orphans containers deepseq directory

11 ansi-wl-pprint base base-orphans containers deepseq directory

15 exceptions fclabels filepath ghc-prim hashable hashtables mtl

12 exceptions fclabels filepath ghc-prim hashable hashtables mtl

@@ -18,4 +15,4 @@ mkDerivation {

18 homepage = "https://github.com/AccelerateHS/accelerate/";

15 homepage = "https://github.com/AccelerateHS/accelerate/";

19 description = "An embedded language for accelerated array processing";

16 description = "An embedded language for accelerated array processing";

20 license = stdenv.lib.licenses.bsd3;

17 license = stdenv.lib.licenses.bsd3;

21−}

18+}

test/golden-test-cases/active.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, lens, linear, QuickCheck

1+{ mkDerivation, base, lens, linear, QuickCheck, semigroupoids

2−, semigroupoids, semigroups, vector

2+, semigroups, stdenv, vector

3}:

4mkDerivation {

5 pname = "active";

6 version = "0.2.0.13";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base lens linear semigroupoids semigroups vector

9 base lens linear semigroupoids semigroups vector

13 ];

10 ];

@@ -16,4 +13,4 @@ mkDerivation {

16 ];

13 ];

17 description = "Abstractions for animation";

14 description = "Abstractions for animation";

18 license = stdenv.lib.licenses.bsd3;

15 license = stdenv.lib.licenses.bsd3;

19−}

16+}

test/golden-test-cases/adjunctions.nix.golden+4−7

@@ -1,14 +1,11 @@

1{ mkDerivation, array, base, comonad, containers, contravariant

2−, distributive, fetchurl, free, mtl, profunctors, semigroupoids

2+, distributive, free, mtl, profunctors, semigroupoids, semigroups

3−, semigroups, tagged, transformers, transformers-compat, void

3+, stdenv, tagged, transformers, transformers-compat, void

4}:

5mkDerivation {

6 pname = "adjunctions";

7 version = "4.3";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 array base comonad containers contravariant distributive free mtl

10 array base comonad containers contravariant distributive free mtl

14 profunctors semigroupoids semigroups tagged transformers

11 profunctors semigroupoids semigroups tagged transformers

@@ -17,4 +14,4 @@ mkDerivation {

17 homepage = "http://github.com/ekmett/adjunctions/";

14 homepage = "http://github.com/ekmett/adjunctions/";

18 description = "Adjunctions and representable functors";

15 description = "Adjunctions and representable functors";

19 license = stdenv.lib.licenses.bsd3;

16 license = stdenv.lib.licenses.bsd3;

20−}

17+}

test/golden-test-cases/aeson-diff.nix.golden+5−8

@@ -1,15 +1,12 @@

1{ mkDerivation, aeson, base, bytestring, directory, doctest

2−, edit-distance-vector, fetchurl, filepath, Glob, hashable, hlint

2+, edit-distance-vector, filepath, Glob, hashable, hlint, mtl

3−, mtl, optparse-applicative, QuickCheck, quickcheck-instances

3+, optparse-applicative, QuickCheck, quickcheck-instances

4−, scientific, text, unordered-containers, vector

4+, scientific, stdenv, text, unordered-containers, vector

5}:

6mkDerivation {

7 pname = "aeson-diff";

8 version = "1.1.0.4";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 isLibrary = true;

10 isLibrary = true;

14 isExecutable = true;

11 isExecutable = true;

15 libraryHaskellDepends = [

12 libraryHaskellDepends = [

@@ -26,4 +23,4 @@ mkDerivation {

26 homepage = "https://github.com/thsutton/aeson-diff";

23 homepage = "https://github.com/thsutton/aeson-diff";

27 description = "Extract and apply patches to JSON documents";

24 description = "Extract and apply patches to JSON documents";

28 license = stdenv.lib.licenses.bsd3;

25 license = stdenv.lib.licenses.bsd3;

29−}

26+}

test/golden-test-cases/aeson-pretty.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, aeson, attoparsec, base, base-compat, bytestring

2−, cmdargs, fetchurl, scientific, text, unordered-containers, vector

2+, cmdargs, scientific, stdenv, text, unordered-containers, vector

3}:

4mkDerivation {

5 pname = "aeson-pretty";

6 version = "0.8.5";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 isLibrary = true;

8 isLibrary = true;

12 isExecutable = true;

9 isExecutable = true;

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

@@ -20,4 +17,4 @@ mkDerivation {

20 homepage = "http://github.com/informatikr/aeson-pretty";

17 homepage = "http://github.com/informatikr/aeson-pretty";

21 description = "JSON pretty-printing library and command-line tool";

18 description = "JSON pretty-printing library and command-line tool";

22 license = stdenv.lib.licenses.bsd3;

19 license = stdenv.lib.licenses.bsd3;

23−}

20+}

test/golden-test-cases/algebraic-graphs.nix.golden+4−7

@@ -1,17 +1,14 @@

1−{ mkDerivation, array, base, containers, criterion, extra, fetchurl

1+{ mkDerivation, array, base, containers, criterion, extra

2−, QuickCheck

2+, QuickCheck, stdenv

3}:

4mkDerivation {

5 pname = "algebraic-graphs";

6 version = "0.0.5";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ array base containers ];

8 libraryHaskellDepends = [ array base containers ];

12 testHaskellDepends = [ base containers extra QuickCheck ];

9 testHaskellDepends = [ base containers extra QuickCheck ];

13 benchmarkHaskellDepends = [ base containers criterion ];

10 benchmarkHaskellDepends = [ base containers criterion ];

14 homepage = "https://github.com/snowleopard/alga";

11 homepage = "https://github.com/snowleopard/alga";

15 description = "A library for algebraic graph construction and transformation";

12 description = "A library for algebraic graph construction and transformation";

16 license = stdenv.lib.licenses.mit;

13 license = stdenv.lib.licenses.mit;

17−}

14+}

test/golden-test-cases/amazonka-cloudtrail.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, amazonka-core, amazonka-test, base, bytestring

2−, fetchurl, tasty, tasty-hunit, text, time, unordered-containers

2+, stdenv, tasty, tasty-hunit, text, time, unordered-containers

3}:

4mkDerivation {

5 pname = "amazonka-cloudtrail";

6 version = "1.5.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ amazonka-core base ];

8 libraryHaskellDepends = [ amazonka-core base ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

10 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/brendanhay/amazonka";

13 homepage = "https://github.com/brendanhay/amazonka";

17 description = "Amazon CloudTrail SDK";

14 description = "Amazon CloudTrail SDK";

18 license = stdenv.lib.licenses.mpl20;

15 license = stdenv.lib.licenses.mpl20;

19−}

16+}

test/golden-test-cases/amazonka-cloudwatch-logs.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, amazonka-core, amazonka-test, base, bytestring

2−, fetchurl, tasty, tasty-hunit, text, time, unordered-containers

2+, stdenv, tasty, tasty-hunit, text, time, unordered-containers

3}:

4mkDerivation {

5 pname = "amazonka-cloudwatch-logs";

6 version = "1.5.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ amazonka-core base ];

8 libraryHaskellDepends = [ amazonka-core base ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

10 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/brendanhay/amazonka";

13 homepage = "https://github.com/brendanhay/amazonka";

17 description = "Amazon CloudWatch Logs SDK";

14 description = "Amazon CloudWatch Logs SDK";

18 license = stdenv.lib.licenses.mpl20;

15 license = stdenv.lib.licenses.mpl20;

19−}

16+}

test/golden-test-cases/amazonka-codedeploy.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, amazonka-core, amazonka-test, base, bytestring

2−, fetchurl, tasty, tasty-hunit, text, time, unordered-containers

2+, stdenv, tasty, tasty-hunit, text, time, unordered-containers

3}:

4mkDerivation {

5 pname = "amazonka-codedeploy";

6 version = "1.5.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ amazonka-core base ];

8 libraryHaskellDepends = [ amazonka-core base ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

10 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/brendanhay/amazonka";

13 homepage = "https://github.com/brendanhay/amazonka";

17 description = "Amazon CodeDeploy SDK";

14 description = "Amazon CodeDeploy SDK";

18 license = stdenv.lib.licenses.mpl20;

15 license = stdenv.lib.licenses.mpl20;

19−}

16+}

test/golden-test-cases/amazonka-cognito-idp.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, amazonka-core, amazonka-test, base, bytestring

2−, fetchurl, tasty, tasty-hunit, text, time, unordered-containers

2+, stdenv, tasty, tasty-hunit, text, time, unordered-containers

3}:

4mkDerivation {

5 pname = "amazonka-cognito-idp";

6 version = "1.5.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ amazonka-core base ];

8 libraryHaskellDepends = [ amazonka-core base ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

10 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/brendanhay/amazonka";

13 homepage = "https://github.com/brendanhay/amazonka";

17 description = "Amazon Cognito Identity Provider SDK";

14 description = "Amazon Cognito Identity Provider SDK";

18 license = stdenv.lib.licenses.mpl20;

15 license = stdenv.lib.licenses.mpl20;

19−}

16+}

test/golden-test-cases/amazonka-ecs.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, amazonka-core, amazonka-test, base, bytestring

2−, fetchurl, tasty, tasty-hunit, text, time, unordered-containers

2+, stdenv, tasty, tasty-hunit, text, time, unordered-containers

3}:

4mkDerivation {

5 pname = "amazonka-ecs";

6 version = "1.5.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ amazonka-core base ];

8 libraryHaskellDepends = [ amazonka-core base ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

10 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/brendanhay/amazonka";

13 homepage = "https://github.com/brendanhay/amazonka";

17 description = "Amazon EC2 Container Service SDK";

14 description = "Amazon EC2 Container Service SDK";

18 license = stdenv.lib.licenses.mpl20;

15 license = stdenv.lib.licenses.mpl20;

19−}

16+}

test/golden-test-cases/amazonka-kms.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, amazonka-core, amazonka-test, base, bytestring

2−, fetchurl, tasty, tasty-hunit, text, time, unordered-containers

2+, stdenv, tasty, tasty-hunit, text, time, unordered-containers

3}:

4mkDerivation {

5 pname = "amazonka-kms";

6 version = "1.5.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ amazonka-core base ];

8 libraryHaskellDepends = [ amazonka-core base ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

10 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/brendanhay/amazonka";

13 homepage = "https://github.com/brendanhay/amazonka";

17 description = "Amazon Key Management Service SDK";

14 description = "Amazon Key Management Service SDK";

18 license = stdenv.lib.licenses.mpl20;

15 license = stdenv.lib.licenses.mpl20;

19−}

16+}

test/golden-test-cases/amazonka-lightsail.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, amazonka-core, amazonka-test, base, bytestring

2−, fetchurl, tasty, tasty-hunit, text, time, unordered-containers

2+, stdenv, tasty, tasty-hunit, text, time, unordered-containers

3}:

4mkDerivation {

5 pname = "amazonka-lightsail";

6 version = "1.5.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ amazonka-core base ];

8 libraryHaskellDepends = [ amazonka-core base ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

10 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/brendanhay/amazonka";

13 homepage = "https://github.com/brendanhay/amazonka";

17 description = "Amazon Lightsail SDK";

14 description = "Amazon Lightsail SDK";

18 license = stdenv.lib.licenses.mpl20;

15 license = stdenv.lib.licenses.mpl20;

19−}

16+}

test/golden-test-cases/amazonka-route53-domains.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, amazonka-core, amazonka-test, base, bytestring

2−, fetchurl, tasty, tasty-hunit, text, time, unordered-containers

2+, stdenv, tasty, tasty-hunit, text, time, unordered-containers

3}:

4mkDerivation {

5 pname = "amazonka-route53-domains";

6 version = "1.5.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ amazonka-core base ];

8 libraryHaskellDepends = [ amazonka-core base ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

10 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/brendanhay/amazonka";

13 homepage = "https://github.com/brendanhay/amazonka";

17 description = "Amazon Route 53 Domains SDK";

14 description = "Amazon Route 53 Domains SDK";

18 license = stdenv.lib.licenses.mpl20;

15 license = stdenv.lib.licenses.mpl20;

19−}

16+}

test/golden-test-cases/amazonka-waf.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, amazonka-core, amazonka-test, base, bytestring

2−, fetchurl, tasty, tasty-hunit, text, time, unordered-containers

2+, stdenv, tasty, tasty-hunit, text, time, unordered-containers

3}:

4mkDerivation {

5 pname = "amazonka-waf";

6 version = "1.5.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ amazonka-core base ];

8 libraryHaskellDepends = [ amazonka-core base ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

10 amazonka-core amazonka-test base bytestring tasty tasty-hunit text

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/brendanhay/amazonka";

13 homepage = "https://github.com/brendanhay/amazonka";

17 description = "Amazon WAF SDK";

14 description = "Amazon WAF SDK";

18 license = stdenv.lib.licenses.mpl20;

15 license = stdenv.lib.licenses.mpl20;

19−}

16+}

test/golden-test-cases/api-field-json-th.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, aeson, base, fetchurl, HUnit, lens, split

1+{ mkDerivation, aeson, base, HUnit, lens, split, stdenv

2, template-haskell, text

3}:

4mkDerivation {

5 pname = "api-field-json-th";

6 version = "0.1.0.2";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 aeson base lens split template-haskell text

9 aeson base lens split template-haskell text

13 ];

10 ];

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://github.com/nakaji-dayo/api-field-json-th";

12 homepage = "https://github.com/nakaji-dayo/api-field-json-th";

16 description = "option of aeson's deriveJSON";

13 description = "option of aeson's deriveJSON";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/app-settings.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, containers, directory, fetchurl, hspec, HUnit

1+{ mkDerivation, base, containers, directory, hspec, HUnit, mtl

2−, mtl, parsec, text

2+, parsec, stdenv, text

3}:

4mkDerivation {

5 pname = "app-settings";

6 version = "0.2.0.11";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base containers directory mtl parsec text

9 base containers directory mtl parsec text

13 ];

10 ];

@@ -17,4 +14,4 @@ mkDerivation {

17 homepage = "https://github.com/emmanueltouzery/app-settings";

14 homepage = "https://github.com/emmanueltouzery/app-settings";

18 description = "A library to manage application settings (INI file-like)";

15 description = "A library to manage application settings (INI file-like)";

19 license = stdenv.lib.licenses.bsd3;

16 license = stdenv.lib.licenses.bsd3;

20−}

17+}

test/golden-test-cases/apply-refact.nix.golden+5−8

@@ -1,15 +1,12 @@

1−{ mkDerivation, base, containers, directory, fetchurl, filemanip

1+{ mkDerivation, base, containers, directory, filemanip, filepath

2−, filepath, ghc, ghc-exactprint, mtl, optparse-applicative, process

2+, ghc, ghc-exactprint, mtl, optparse-applicative, process, refact

3−, refact, silently, syb, tasty, tasty-expected-failure

3+, silently, stdenv, syb, tasty, tasty-expected-failure

4, tasty-golden, temporary, transformers, unix-compat

5}:

6mkDerivation {

7 pname = "apply-refact";

8 version = "0.4.1.0";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 isLibrary = true;

10 isLibrary = true;

14 isExecutable = true;

11 isExecutable = true;

15 libraryHaskellDepends = [

12 libraryHaskellDepends = [

@@ -29,4 +26,4 @@ mkDerivation {

29 ];

26 ];

30 description = "Perform refactorings specified by the refact library";

27 description = "Perform refactorings specified by the refact library";

31 license = stdenv.lib.licenses.bsd3;

28 license = stdenv.lib.licenses.bsd3;

32−}

29+}

test/golden-test-cases/async.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, HUnit, stm, test-framework

1+{ mkDerivation, base, HUnit, stdenv, stm, test-framework

2, test-framework-hunit

3}:

4mkDerivation {

5 pname = "async";

6 version = "2.1.1.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base stm ];

8 libraryHaskellDepends = [ base stm ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 base HUnit test-framework test-framework-hunit

10 base HUnit test-framework test-framework-hunit

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://github.com/simonmar/async";

12 homepage = "https://github.com/simonmar/async";

16 description = "Run IO operations asynchronously and wait for their results";

13 description = "Run IO operations asynchronously and wait for their results";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/attoparsec-expr.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, attoparsec, base, fetchurl }:

1+{ mkDerivation, attoparsec, base, stdenv }:

2mkDerivation {

3 pname = "attoparsec-expr";

4 version = "0.1.1.2";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ attoparsec base ];

6 libraryHaskellDepends = [ attoparsec base ];

10 description = "Port of parsec's expression parser to attoparsec";

7 description = "Port of parsec's expression parser to attoparsec";

11 license = stdenv.lib.licenses.bsd3;

8 license = stdenv.lib.licenses.bsd3;

12−}

9+}

test/golden-test-cases/attoparsec-time.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, attoparsec, base, base-prelude, bytestring, Cabal

2−, cabal-doctest, directory, doctest, fetchurl, filepath, scientific

2+, cabal-doctest, directory, doctest, filepath, scientific, stdenv

3, text, time

4}:

5mkDerivation {

6 pname = "attoparsec-time";

7 version = "1";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 setupHaskellDepends = [ base Cabal cabal-doctest ];

9 setupHaskellDepends = [ base Cabal cabal-doctest ];

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

14 attoparsec base base-prelude bytestring scientific text time

11 attoparsec base base-prelude bytestring scientific text time

@@ -19,4 +16,4 @@ mkDerivation {

19 homepage = "https://github.com/nikita-volkov/attoparsec-time";

16 homepage = "https://github.com/nikita-volkov/attoparsec-time";

20 description = "Attoparsec parsers of time";

17 description = "Attoparsec parsers of time";

21 license = stdenv.lib.licenses.mit;

18 license = stdenv.lib.licenses.mit;

22−}

19+}

test/golden-test-cases/avers-server.nix.golden+5−8

@@ -1,16 +1,13 @@

1{ mkDerivation, aeson, avers, avers-api, base, base64-bytestring

2, bytestring, bytestring-conversion, containers, cookie, cryptonite

3−, fetchurl, http-types, memory, mtl, resource-pool

3+, http-types, memory, mtl, resource-pool, rethinkdb-client-driver

4−, rethinkdb-client-driver, servant, servant-server, stm, text, time

4+, servant, servant-server, stdenv, stm, text, time, transformers

5−, transformers, wai, wai-websockets, websockets

5+, wai, wai-websockets, websockets

6}:

7mkDerivation {

8 pname = "avers-server";

9 version = "0.1.0";

10− src = fetchurl {

10+ sha256 = "deadbeef";

11− url = "http://example.org/";

12− sha256 = "abc";

13− };

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

15 aeson avers avers-api base base64-bytestring bytestring

12 aeson avers avers-api base base64-bytestring bytestring

16 bytestring-conversion containers cookie cryptonite http-types

13 bytestring-conversion containers cookie cryptonite http-types

@@ -21,4 +18,4 @@ mkDerivation {

21 homepage = "http://github.com/wereHamster/avers-server";

18 homepage = "http://github.com/wereHamster/avers-server";

22 description = "Server implementation of the Avers API";

19 description = "Server implementation of the Avers API";

23 license = stdenv.lib.licenses.mit;

20 license = stdenv.lib.licenses.mit;

24−}

21+}

test/golden-test-cases/aws.nix.golden+6−9

@@ -2,20 +2,17 @@

2, base64-bytestring, blaze-builder, byteable, bytestring

3, case-insensitive, cereal, conduit, conduit-combinators

4, conduit-extra, containers, cryptonite, data-default, directory

5−, errors, fetchurl, filepath, http-client, http-client-tls

5+, errors, filepath, http-client, http-client-tls, http-conduit

6−, http-conduit, http-types, lifted-base, memory, monad-control, mtl

6+, http-types, lifted-base, memory, monad-control, mtl, network

7−, network, old-locale, QuickCheck, quickcheck-instances, resourcet

7+, old-locale, QuickCheck, quickcheck-instances, resourcet, safe

8−, safe, scientific, tagged, tasty, tasty-hunit, tasty-quickcheck

8+, scientific, stdenv, tagged, tasty, tasty-hunit, tasty-quickcheck

9, text, time, transformers, transformers-base, unordered-containers

10, utf8-string, vector, xml-conduit

11}:

12mkDerivation {

13 pname = "aws";

14 version = "0.18";

15− src = fetchurl {

15+ sha256 = "deadbeef";

16− url = "http://example.org/";

17− sha256 = "abc";

18− };

19 isLibrary = true;

16 isLibrary = true;

20 isExecutable = true;

17 isExecutable = true;

21 libraryHaskellDepends = [

18 libraryHaskellDepends = [

@@ -35,4 +32,4 @@ mkDerivation {

35 homepage = "http://github.com/aristidb/aws";

32 homepage = "http://github.com/aristidb/aws";

36 description = "Amazon Web Services (AWS) for Haskell";

33 description = "Amazon Web Services (AWS) for Haskell";

37 license = stdenv.lib.licenses.bsd3;

34 license = stdenv.lib.licenses.bsd3;

38−}

35+}

test/golden-test-cases/bbdb.nix.golden+3−6

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, fetchurl, hspec, parsec }:

1+{ mkDerivation, base, hspec, parsec, stdenv }:

2mkDerivation {

3 pname = "bbdb";

4 version = "0.8";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base parsec ];

6 libraryHaskellDepends = [ base parsec ];

10 testHaskellDepends = [ base hspec parsec ];

7 testHaskellDepends = [ base hspec parsec ];

11 homepage = "https://github.com/henrylaxen/bbdb";

8 homepage = "https://github.com/henrylaxen/bbdb";

12 description = "Ability to read, write, and modify BBDB files";

9 description = "Ability to read, write, and modify BBDB files";

13 license = stdenv.lib.licenses.gpl3;

10 license = stdenv.lib.licenses.gpl3;

14−}

11+}

test/golden-test-cases/benchpress.nix.golden+3−6

@@ -1,11 +1,8 @@

1−{ mkDerivation, base, bytestring, fetchurl, mtl, time }:

1+{ mkDerivation, base, bytestring, mtl, stdenv, time }:

2mkDerivation {

3 pname = "benchpress";

4 version = "0.2.2.10";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 isLibrary = true;

6 isLibrary = true;

10 isExecutable = true;

7 isExecutable = true;

11 libraryHaskellDepends = [ base mtl time ];

8 libraryHaskellDepends = [ base mtl time ];

@@ -13,4 +10,4 @@ mkDerivation {

13 homepage = "https://github.com/WillSewell/benchpress";

10 homepage = "https://github.com/WillSewell/benchpress";

14 description = "Micro-benchmarking with detailed statistics";

11 description = "Micro-benchmarking with detailed statistics";

15 license = stdenv.lib.licenses.bsd3;

12 license = stdenv.lib.licenses.bsd3;

16−}

13+}

test/golden-test-cases/binary-bits.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, binary, bytestring, fetchurl, QuickCheck

1+{ mkDerivation, base, binary, bytestring, QuickCheck, random

2−, random, test-framework, test-framework-quickcheck2

2+, stdenv, test-framework, test-framework-quickcheck2

3}:

4mkDerivation {

5 pname = "binary-bits";

6 version = "0.5";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base binary bytestring ];

8 libraryHaskellDepends = [ base binary bytestring ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 base binary bytestring QuickCheck random test-framework

10 base binary bytestring QuickCheck random test-framework

@@ -15,4 +12,4 @@ mkDerivation {

15 ];

12 ];

16 description = "Bit parsing/writing on top of binary";

13 description = "Bit parsing/writing on top of binary";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/binary-tagged.nix.golden+4−7

@@ -1,16 +1,13 @@

1{ mkDerivation, aeson, array, base, base16-bytestring, bifunctors

2, binary, binary-orphans, bytestring, containers, criterion

3−, deepseq, fetchurl, generics-sop, hashable, nats

3+, deepseq, generics-sop, hashable, nats, quickcheck-instances

4−, quickcheck-instances, scientific, semigroups, SHA, tagged, tasty

4+, scientific, semigroups, SHA, stdenv, tagged, tasty

5, tasty-quickcheck, text, time, unordered-containers, vector

6}:

7mkDerivation {

8 pname = "binary-tagged";

9 version = "0.1.4.2";

10− src = fetchurl {

10+ sha256 = "deadbeef";

11− url = "http://example.org/";

12− sha256 = "abc";

13− };

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

15 aeson array base base16-bytestring binary bytestring containers

12 aeson array base base16-bytestring binary bytestring containers

16 generics-sop hashable nats scientific semigroups SHA tagged text

13 generics-sop hashable nats scientific semigroups SHA tagged text

@@ -30,4 +27,4 @@ mkDerivation {

30 homepage = "https://github.com/phadej/binary-tagged#readme";

27 homepage = "https://github.com/phadej/binary-tagged#readme";

31 description = "Tagged binary serialisation";

28 description = "Tagged binary serialisation";

32 license = stdenv.lib.licenses.bsd3;

29 license = stdenv.lib.licenses.bsd3;

33−}

30+}

test/golden-test-cases/bindings-uname.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, base, fetchurl }:

1+{ mkDerivation, base, stdenv }:

2mkDerivation {

3 pname = "bindings-uname";

4 version = "0.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 description = "Low-level binding to POSIX uname(3)";

7 description = "Low-level binding to POSIX uname(3)";

11 license = stdenv.lib.licenses.publicDomain;

8 license = stdenv.lib.licenses.publicDomain;

12−}

9+}

test/golden-test-cases/bioalign.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, biocore, bytestring, fetchurl }:

1+{ mkDerivation, base, biocore, bytestring, stdenv }:

2mkDerivation {

3 pname = "bioalign";

4 version = "0.0.5";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base biocore bytestring ];

6 libraryHaskellDepends = [ base biocore bytestring ];

10 homepage = "https://patch-tag.com/r/dfornika/biophd/home";

7 homepage = "https://patch-tag.com/r/dfornika/biophd/home";

11 description = "Data structures and helper functions for calculating alignments";

8 description = "Data structures and helper functions for calculating alignments";

12 license = "GPL";

9 license = "GPL";

13−}

10+}

test/golden-test-cases/bits.nix.golden+4−7

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, bytes, Cabal, cabal-doctest, doctest

1+{ mkDerivation, base, bytes, Cabal, cabal-doctest, doctest, mtl

2−, fetchurl, mtl, transformers

2+, stdenv, transformers

3}:

4mkDerivation {

5 pname = "bits";

6 version = "0.5.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 setupHaskellDepends = [ base Cabal cabal-doctest ];

8 setupHaskellDepends = [ base Cabal cabal-doctest ];

12 libraryHaskellDepends = [ base bytes mtl transformers ];

9 libraryHaskellDepends = [ base bytes mtl transformers ];

13 testHaskellDepends = [ base doctest ];

10 testHaskellDepends = [ base doctest ];

14 homepage = "http://github.com/ekmett/bits";

11 homepage = "http://github.com/ekmett/bits";

15 description = "Various bit twiddling and bitwise serialization primitives";

12 description = "Various bit twiddling and bitwise serialization primitives";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/blank-canvas.nix.golden+4−7

@@ -1,16 +1,13 @@

1{ mkDerivation, aeson, base, base-compat, base64-bytestring

2, bytestring, colour, containers, data-default-class, directory

3−, fetchurl, http-types, kansas-comet, mime-types, process, scotty

3+, http-types, kansas-comet, mime-types, process, scotty, shake

4−, shake, stm, text, text-show, time, transformers, unix, vector

4+, stdenv, stm, text, text-show, time, transformers, unix, vector

5, wai, wai-extra, warp

6}:

7mkDerivation {

8 pname = "blank-canvas";

9 version = "0.6.1";

10− src = fetchurl {

10+ sha256 = "deadbeef";

11− url = "http://example.org/";

12− sha256 = "abc";

13− };

14 enableSeparateDataOutput = true;

11 enableSeparateDataOutput = true;

15 libraryHaskellDepends = [

12 libraryHaskellDepends = [

16 aeson base base-compat base64-bytestring bytestring colour

13 aeson base base-compat base64-bytestring bytestring colour

@@ -23,4 +20,4 @@ mkDerivation {

23 homepage = "https://github.com/ku-fpg/blank-canvas/wiki";

20 homepage = "https://github.com/ku-fpg/blank-canvas/wiki";

24 description = "HTML5 Canvas Graphics Library";

21 description = "HTML5 Canvas Graphics Library";

25 license = stdenv.lib.licenses.bsd3;

22 license = stdenv.lib.licenses.bsd3;

26−}

23+}

test/golden-test-cases/blaze-html.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, base, blaze-builder, blaze-markup, bytestring

2−, containers, fetchurl, HUnit, QuickCheck, test-framework

2+, containers, HUnit, QuickCheck, stdenv, test-framework

3, test-framework-hunit, test-framework-quickcheck2, text

4}:

5mkDerivation {

6 pname = "blaze-html";

7 version = "0.9.0.1";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 base blaze-builder blaze-markup bytestring text

10 base blaze-builder blaze-markup bytestring text

14 ];

11 ];

@@ -20,4 +17,4 @@ mkDerivation {

20 homepage = "http://jaspervdj.be/blaze";

17 homepage = "http://jaspervdj.be/blaze";

21 description = "A blazingly fast HTML combinator library for Haskell";

18 description = "A blazingly fast HTML combinator library for Haskell";

22 license = stdenv.lib.licenses.bsd3;

19 license = stdenv.lib.licenses.bsd3;

23−}

20+}

test/golden-test-cases/blaze-markup.nix.golden+4−7

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, blaze-builder, bytestring, containers

1+{ mkDerivation, base, blaze-builder, bytestring, containers, HUnit

2−, fetchurl, HUnit, QuickCheck, test-framework, test-framework-hunit

2+, QuickCheck, stdenv, test-framework, test-framework-hunit

3, test-framework-quickcheck2, text

4}:

5mkDerivation {

6 pname = "blaze-markup";

7 version = "0.8.0.0";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [ base blaze-builder bytestring text ];

9 libraryHaskellDepends = [ base blaze-builder bytestring text ];

13 testHaskellDepends = [

10 testHaskellDepends = [

14 base blaze-builder bytestring containers HUnit QuickCheck

11 base blaze-builder bytestring containers HUnit QuickCheck

@@ -17,4 +14,4 @@ mkDerivation {

17 homepage = "http://jaspervdj.be/blaze";

14 homepage = "http://jaspervdj.be/blaze";

18 description = "A blazingly fast markup combinator library for Haskell";

15 description = "A blazingly fast markup combinator library for Haskell";

19 license = stdenv.lib.licenses.bsd3;

16 license = stdenv.lib.licenses.bsd3;

20−}

17+}

test/golden-test-cases/blaze-svg.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, blaze-markup, fetchurl, mtl }:

1+{ mkDerivation, base, blaze-markup, mtl, stdenv }:

2mkDerivation {

3 pname = "blaze-svg";

4 version = "0.3.6.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base blaze-markup mtl ];

6 libraryHaskellDepends = [ base blaze-markup mtl ];

10 homepage = "https://github.com/deepakjois/blaze-svg";

7 homepage = "https://github.com/deepakjois/blaze-svg";

11 description = "SVG combinator library";

8 description = "SVG combinator library";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/blosum.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, containers, fasta, fetchurl, lens

1+{ mkDerivation, base, containers, fasta, lens, optparse-applicative

2−, optparse-applicative, pipes, pipes-text, split, text, text-show

2+, pipes, pipes-text, split, stdenv, text, text-show

3}:

4mkDerivation {

5 pname = "blosum";

6 version = "0.1.1.4";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 isLibrary = true;

8 isLibrary = true;

12 isExecutable = true;

9 isExecutable = true;

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

@@ -20,4 +17,4 @@ mkDerivation {

20 homepage = "http://github.com/GregorySchwartz/blosum#readme";

17 homepage = "http://github.com/GregorySchwartz/blosum#readme";

21 description = "BLOSUM generator";

18 description = "BLOSUM generator";

22 license = stdenv.lib.licenses.gpl2;

19 license = stdenv.lib.licenses.gpl2;

23−}

20+}

test/golden-test-cases/boomerang.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, base, fetchurl, mtl, template-haskell, text }:

1+{ mkDerivation, base, mtl, stdenv, template-haskell, text }:

2mkDerivation {

3 pname = "boomerang";

4 version = "1.4.5.3";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base mtl template-haskell text ];

6 libraryHaskellDepends = [ base mtl template-haskell text ];

10 description = "Library for invertible parsing and printing";

7 description = "Library for invertible parsing and printing";

11 license = stdenv.lib.licenses.bsd3;

8 license = stdenv.lib.licenses.bsd3;

12−}

9+}

test/golden-test-cases/boxes.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, QuickCheck, split }:

1+{ mkDerivation, base, QuickCheck, split, stdenv }:

2mkDerivation {

3 pname = "boxes";

4 version = "0.1.4";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base split ];

6 libraryHaskellDepends = [ base split ];

10 testHaskellDepends = [ base QuickCheck split ];

7 testHaskellDepends = [ base QuickCheck split ];

11 description = "2D text pretty-printing library";

8 description = "2D text pretty-printing library";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/brittany.nix.golden+5−8

@@ -1,17 +1,14 @@

1{ mkDerivation, aeson, base, butcher, bytestring, cmdargs

2, containers, czipwith, data-tree-print, deepseq, directory, extra

3−, fetchurl, filepath, ghc, ghc-boot-th, ghc-exactprint, ghc-paths

3+, filepath, ghc, ghc-boot-th, ghc-exactprint, ghc-paths, hspec

4−, hspec, monad-memo, mtl, multistate, neat-interpolation, parsec

4+, monad-memo, mtl, multistate, neat-interpolation, parsec, pretty

5−, pretty, safe, semigroups, strict, syb, text, transformers

5+, safe, semigroups, stdenv, strict, syb, text, transformers

6, uniplate, unsafe, yaml

7}:

8mkDerivation {

9 pname = "brittany";

10 version = "0.9.0.0";

11− src = fetchurl {

11+ sha256 = "deadbeef";

12− url = "http://example.org/";

13− sha256 = "abc";

14− };

15 isLibrary = true;

12 isLibrary = true;

16 isExecutable = true;

13 isExecutable = true;

17 libraryHaskellDepends = [

14 libraryHaskellDepends = [

@@ -38,4 +35,4 @@ mkDerivation {

38 homepage = "https://github.com/lspitzner/brittany/";

35 homepage = "https://github.com/lspitzner/brittany/";

39 description = "Haskell source code formatter";

36 description = "Haskell source code formatter";

40 license = stdenv.lib.licenses.agpl3;

37 license = stdenv.lib.licenses.agpl3;

41−}

38+}

test/golden-test-cases/broadcast-chan.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl }:

1+{ mkDerivation, base, stdenv }:

2mkDerivation {

3 pname = "broadcast-chan";

4 version = "0.1.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 homepage = "https://github.com/merijn/broadcast-chan";

7 homepage = "https://github.com/merijn/broadcast-chan";

11 description = "Broadcast channel type that avoids 0 reader space leaks";

8 description = "Broadcast channel type that avoids 0 reader space leaks";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/butcher.nix.golden+3−10

@@ -1,23 +1,16 @@

1{ mkDerivation, base, bifunctors, containers, deque, either, extra

2−, fetchurl, free, microlens, microlens-th, mtl, multistate, pretty

2+, free, microlens, microlens-th, mtl, multistate, pretty, stdenv

3, transformers, unsafe, void

4}:

5mkDerivation {

6 pname = "butcher";

7 version = "1.2.1.0";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 base bifunctors containers deque either extra free microlens

10 base bifunctors containers deque either extra free microlens

14 microlens-th mtl multistate pretty transformers unsafe void

11 microlens-th mtl multistate pretty transformers unsafe void

15 ];

12 ];

16− testHaskellDepends = [

17− base containers deque either extra free microlens microlens-th mtl

18− multistate pretty transformers unsafe

19− ];

20 homepage = "https://github.com/lspitzner/butcher/";

13 homepage = "https://github.com/lspitzner/butcher/";

21 description = "Chops a command or program invocation into digestable pieces";

14 description = "Chops a command or program invocation into digestable pieces";

22 license = stdenv.lib.licenses.bsd3;

15 license = stdenv.lib.licenses.bsd3;

23−}

16+}

test/golden-test-cases/bzlib.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, bzip2, fetchurl }:

1+{ mkDerivation, base, bytestring, bzip2, stdenv }:

2mkDerivation {

3 pname = "bzlib";

4 version = "0.5.0.5";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base bytestring ];

6 libraryHaskellDepends = [ base bytestring ];

10 librarySystemDepends = [ bzip2 ];

7 librarySystemDepends = [ bzip2 ];

11 description = "Compression and decompression in the bzip2 format";

8 description = "Compression and decompression in the bzip2 format";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/case-insensitive.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, criterion, deepseq, fetchurl

1+{ mkDerivation, base, bytestring, criterion, deepseq, hashable

2−, hashable, HUnit, test-framework, test-framework-hunit, text

2+, HUnit, stdenv, test-framework, test-framework-hunit, text

3}:

4mkDerivation {

5 pname = "case-insensitive";

6 version = "1.2.0.10";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base bytestring deepseq hashable text ];

8 libraryHaskellDepends = [ base bytestring deepseq hashable text ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 base bytestring HUnit test-framework test-framework-hunit text

10 base bytestring HUnit test-framework test-framework-hunit text

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/basvandijk/case-insensitive";

13 homepage = "https://github.com/basvandijk/case-insensitive";

17 description = "Case insensitive string comparison";

14 description = "Case insensitive string comparison";

18 license = stdenv.lib.licenses.bsd3;

15 license = stdenv.lib.licenses.bsd3;

19−}

16+}

test/golden-test-cases/cassava-conduit.nix.golden+4−7

@@ -1,14 +1,11 @@

1{ mkDerivation, array, base, bifunctors, bytestring, cassava

2−, conduit, conduit-extra, containers, criterion, fetchurl, mtl

2+, conduit, conduit-extra, containers, criterion, mtl, QuickCheck

3−, QuickCheck, text

3+, stdenv, text

4}:

5mkDerivation {

6 pname = "cassava-conduit";

7 version = "0.4.0.1";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 array base bifunctors bytestring cassava conduit conduit-extra

10 array base bifunctors bytestring cassava conduit conduit-extra

14 containers mtl text

11 containers mtl text

@@ -20,4 +17,4 @@ mkDerivation {

20 homepage = "https://github.com/domdere/cassava-conduit";

17 homepage = "https://github.com/domdere/cassava-conduit";

21 description = "Conduit interface for cassava package";

18 description = "Conduit interface for cassava package";

22 license = stdenv.lib.licenses.bsd3;

19 license = stdenv.lib.licenses.bsd3;

23−}

20+}

test/golden-test-cases/cassette.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, base, fetchurl }:

1+{ mkDerivation, base, stdenv }:

2mkDerivation {

3 pname = "cassette";

4 version = "0.1.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 description = "A combinator library for simultaneously defining parsers and pretty printers";

7 description = "A combinator library for simultaneously defining parsers and pretty printers";

11 license = stdenv.lib.licenses.bsd3;

8 license = stdenv.lib.licenses.bsd3;

12−}

9+}

test/golden-test-cases/cereal-text.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, cereal, fetchurl, text }:

1+{ mkDerivation, base, cereal, stdenv, text }:

2mkDerivation {

3 pname = "cereal-text";

4 version = "0.1.0.2";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base cereal text ];

6 libraryHaskellDepends = [ base cereal text ];

10 homepage = "https://github.com/ulikoehler/cereal-text";

7 homepage = "https://github.com/ulikoehler/cereal-text";

11 description = "Data.Text instances for the cereal serialization library";

8 description = "Data.Text instances for the cereal serialization library";

12 license = stdenv.lib.licenses.asl20;

9 license = stdenv.lib.licenses.asl20;

13−}

10+}

test/golden-test-cases/cheapskate.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, base, blaze-html, bytestring, containers

2−, data-default, deepseq, fetchurl, mtl, syb, text, uniplate

2+, data-default, deepseq, mtl, stdenv, syb, text, uniplate

3, xss-sanitize

4}:

5mkDerivation {

6 pname = "cheapskate";

7 version = "0.1.1";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 isLibrary = true;

9 isLibrary = true;

13 isExecutable = true;

10 isExecutable = true;

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

@@ -19,4 +16,4 @@ mkDerivation {

19 homepage = "http://github.com/jgm/cheapskate";

16 homepage = "http://github.com/jgm/cheapskate";

20 description = "Experimental markdown processor";

17 description = "Experimental markdown processor";

21 license = stdenv.lib.licenses.bsd3;

18 license = stdenv.lib.licenses.bsd3;

22−}

19+}

test/golden-test-cases/chell.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, ansi-terminal, base, bytestring, fetchurl, options

1+{ mkDerivation, ansi-terminal, base, bytestring, options, patience

2−, patience, random, template-haskell, text, transformers

2+, random, stdenv, template-haskell, text, transformers

3}:

4mkDerivation {

5 pname = "chell";

6 version = "0.4.0.2";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 ansi-terminal base bytestring options patience random

9 ansi-terminal base bytestring options patience random

13 template-haskell text transformers

10 template-haskell text transformers

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://john-millikin.com/software/chell/";

12 homepage = "https://john-millikin.com/software/chell/";

16 description = "A simple and intuitive library for automated testing";

13 description = "A simple and intuitive library for automated testing";

17 license = stdenv.lib.licenses.mit;

14 license = stdenv.lib.licenses.mit;

18−}

15+}

test/golden-test-cases/clumpiness.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, base, containers, fetchurl, tree-fun }:

1+{ mkDerivation, base, containers, stdenv, tree-fun }:

2mkDerivation {

3 pname = "clumpiness";

4 version = "0.17.0.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base containers tree-fun ];

6 libraryHaskellDepends = [ base containers tree-fun ];

10 description = "Calculate the clumpiness of leaf properties in a tree";

7 description = "Calculate the clumpiness of leaf properties in a tree";

11 license = stdenv.lib.licenses.gpl3;

8 license = stdenv.lib.licenses.gpl3;

12−}

9+}

test/golden-test-cases/code-page.nix.golden+3−6

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, fetchurl }:

1+{ mkDerivation, base, stdenv }:

2mkDerivation {

3 pname = "code-page";

4 version = "0.1.3";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 testHaskellDepends = [ base ];

7 testHaskellDepends = [ base ];

11 homepage = "https://github.com/RyanGlScott/code-page";

8 homepage = "https://github.com/RyanGlScott/code-page";

12 description = "Windows code page library for Haskell";

9 description = "Windows code page library for Haskell";

13 license = stdenv.lib.licenses.bsd3;

10 license = stdenv.lib.licenses.bsd3;

14−}

11+}

test/golden-test-cases/colorize-haskell.nix.golden+3−6

@@ -1,11 +1,8 @@

1−{ mkDerivation, ansi-terminal, base, fetchurl, haskell-lexer }:

1+{ mkDerivation, ansi-terminal, base, haskell-lexer, stdenv }:

2mkDerivation {

3 pname = "colorize-haskell";

4 version = "1.0.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 isLibrary = true;

6 isLibrary = true;

10 isExecutable = true;

7 isExecutable = true;

11 libraryHaskellDepends = [ ansi-terminal base haskell-lexer ];

8 libraryHaskellDepends = [ ansi-terminal base haskell-lexer ];

@@ -13,4 +10,4 @@ mkDerivation {

13 homepage = "http://github.com/yav/colorize-haskell";

10 homepage = "http://github.com/yav/colorize-haskell";

14 description = "Highligt Haskell source";

11 description = "Highligt Haskell source";

15 license = stdenv.lib.licenses.bsd3;

12 license = stdenv.lib.licenses.bsd3;

16−}

13+}

test/golden-test-cases/countable.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, fetchurl, silently, tasty

1+{ mkDerivation, base, bytestring, silently, stdenv, tasty

2, tasty-golden, tasty-hunit

3}:

4mkDerivation {

5 pname = "countable";

6 version = "1.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base ];

8 libraryHaskellDepends = [ base ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 base bytestring silently tasty tasty-golden tasty-hunit

10 base bytestring silently tasty tasty-golden tasty-hunit

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://github.com/AshleyYakeley/countable";

12 homepage = "https://github.com/AshleyYakeley/countable";

16 description = "Countable, Searchable, Finite, Empty classes";

13 description = "Countable, Searchable, Finite, Empty classes";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/cpu.nix.golden+3−6

@@ -1,11 +1,8 @@

1−{ mkDerivation, base, fetchurl }:

1+{ mkDerivation, base, stdenv }:

2mkDerivation {

3 pname = "cpu";

4 version = "0.1.2";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 isLibrary = true;

6 isLibrary = true;

10 isExecutable = true;

7 isExecutable = true;

11 enableSeparateDataOutput = true;

8 enableSeparateDataOutput = true;

@@ -13,4 +10,4 @@ mkDerivation {

13 homepage = "http://github.com/vincenthz/hs-cpu";

10 homepage = "http://github.com/vincenthz/hs-cpu";

14 description = "Cpu information and properties helpers";

11 description = "Cpu information and properties helpers";

15 license = stdenv.lib.licenses.bsd3;

12 license = stdenv.lib.licenses.bsd3;

16−}

13+}

test/golden-test-cases/criterion.nix.golden+4−7

@@ -1,18 +1,15 @@

1{ mkDerivation, aeson, ansi-wl-pprint, base, base-compat, binary

2, bytestring, cassava, code-page, containers, deepseq, directory

3−, exceptions, fetchurl, filepath, Glob, HUnit, js-flot, js-jquery

3+, exceptions, filepath, Glob, HUnit, js-flot, js-jquery

4, microstache, mtl, mwc-random, optparse-applicative, parsec

5−, QuickCheck, semigroups, statistics, tasty, tasty-hunit

5+, QuickCheck, semigroups, statistics, stdenv, tasty, tasty-hunit

6, tasty-quickcheck, text, time, transformers, transformers-compat

7, vector, vector-algorithms

8}:

9mkDerivation {

10 pname = "criterion";

11 version = "1.2.6.0";

12− src = fetchurl {

12+ sha256 = "deadbeef";

13− url = "http://example.org/";

14− sha256 = "abc";

15− };

16 isLibrary = true;

13 isLibrary = true;

17 isExecutable = true;

14 isExecutable = true;

18 enableSeparateDataOutput = true;

15 enableSeparateDataOutput = true;

@@ -31,4 +28,4 @@ mkDerivation {

31 homepage = "http://www.serpentine.com/criterion";

28 homepage = "http://www.serpentine.com/criterion";

32 description = "Robust, reliable performance measurement and analysis";

29 description = "Robust, reliable performance measurement and analysis";

33 license = stdenv.lib.licenses.bsd3;

30 license = stdenv.lib.licenses.bsd3;

34−}

31+}

test/golden-test-cases/crypt-sha512.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, attoparsec, base, bytestring, cryptohash-sha512

2−, fetchurl, quickcheck-instances, tasty, tasty-hunit

2+, quickcheck-instances, stdenv, tasty, tasty-hunit

3, tasty-quickcheck

4}:

5mkDerivation {

6 pname = "crypt-sha512";

7 version = "0";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 attoparsec base bytestring cryptohash-sha512

10 attoparsec base bytestring cryptohash-sha512

14 ];

11 ];

@@ -19,4 +16,4 @@ mkDerivation {

19 homepage = "https://github.com/phadej/crypt-sha512";

16 homepage = "https://github.com/phadej/crypt-sha512";

20 description = "Pure Haskell implelementation for GNU SHA512 crypt algorithm";

17 description = "Pure Haskell implelementation for GNU SHA512 crypt algorithm";

21 license = stdenv.lib.licenses.bsd3;

18 license = stdenv.lib.licenses.bsd3;

22−}

19+}

test/golden-test-cases/crypto-random-api.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, entropy, fetchurl }:

1+{ mkDerivation, base, bytestring, entropy, stdenv }:

2mkDerivation {

3 pname = "crypto-random-api";

4 version = "0.2.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base bytestring entropy ];

6 libraryHaskellDepends = [ base bytestring entropy ];

10 homepage = "http://github.com/vincenthz/hs-crypto-random-api";

7 homepage = "http://github.com/vincenthz/hs-crypto-random-api";

11 description = "Simple random generators API for cryptography related code";

8 description = "Simple random generators API for cryptography related code";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/csv.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, base, fetchurl, filepath, parsec }:

1+{ mkDerivation, base, filepath, parsec, stdenv }:

2mkDerivation {

3 pname = "csv";

4 version = "0.1.2";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base filepath parsec ];

6 libraryHaskellDepends = [ base filepath parsec ];

10 description = "CSV loader and dumper";

7 description = "CSV loader and dumper";

11 license = stdenv.lib.licenses.mit;

8 license = stdenv.lib.licenses.mit;

12−}

9+}

test/golden-test-cases/data-accessor.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, array, base, containers, fetchurl, transformers }:

1+{ mkDerivation, array, base, containers, stdenv, transformers }:

2mkDerivation {

3 pname = "data-accessor";

4 version = "0.2.2.7";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ array base containers transformers ];

6 libraryHaskellDepends = [ array base containers transformers ];

10 homepage = "http://www.haskell.org/haskellwiki/Record_access";

7 homepage = "http://www.haskell.org/haskellwiki/Record_access";

11 description = "Utilities for accessing and manipulating fields of records";

8 description = "Utilities for accessing and manipulating fields of records";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/data-default-instances-containers.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, base, containers, data-default-class, fetchurl }:

1+{ mkDerivation, base, containers, data-default-class, stdenv }:

2mkDerivation {

3 pname = "data-default-instances-containers";

4 version = "0.0.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base containers data-default-class ];

6 libraryHaskellDepends = [ base containers data-default-class ];

10 description = "Default instances for types in containers";

7 description = "Default instances for types in containers";

11 license = stdenv.lib.licenses.bsd3;

8 license = stdenv.lib.licenses.bsd3;

12−}

9+}

test/golden-test-cases/data-endian.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl }:

1+{ mkDerivation, base, stdenv }:

2mkDerivation {

3 pname = "data-endian";

4 version = "0.1.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 homepage = "https://github.com/mvv/data-endian";

7 homepage = "https://github.com/mvv/data-endian";

11 description = "Endian-sensitive data";

8 description = "Endian-sensitive data";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/data-msgpack.nix.golden+4−7

@@ -1,14 +1,11 @@

1{ mkDerivation, base, binary, bytestring, containers, criterion

2−, data-binary-ieee754, deepseq, fetchurl, groom, hashable, hspec

2+, data-binary-ieee754, deepseq, groom, hashable, hspec, QuickCheck

3−, QuickCheck, text, unordered-containers, vector, void

3+, stdenv, text, unordered-containers, vector, void

4}:

5mkDerivation {

6 pname = "data-msgpack";

7 version = "0.0.10";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 isLibrary = true;

9 isLibrary = true;

13 isExecutable = true;

10 isExecutable = true;

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

@@ -26,4 +23,4 @@ mkDerivation {

26 homepage = "http://msgpack.org/";

23 homepage = "http://msgpack.org/";

27 description = "A Haskell implementation of MessagePack";

24 description = "A Haskell implementation of MessagePack";

28 license = stdenv.lib.licenses.bsd3;

25 license = stdenv.lib.licenses.bsd3;

29−}

26+}

test/golden-test-cases/data-serializer.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, base, binary, bytestring, cereal, data-endian

2−, fetchurl, parsers, semigroups, split, tasty, tasty-quickcheck

2+, parsers, semigroups, split, stdenv, tasty, tasty-quickcheck

3}:

4mkDerivation {

5 pname = "data-serializer";

6 version = "0.3.2";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base binary bytestring cereal data-endian parsers semigroups split

9 base binary bytestring cereal data-endian parsers semigroups split

13 ];

10 ];

@@ -17,4 +14,4 @@ mkDerivation {

17 homepage = "https://github.com/mvv/data-serializer";

14 homepage = "https://github.com/mvv/data-serializer";

18 description = "Common API for serialization libraries";

15 description = "Common API for serialization libraries";

19 license = stdenv.lib.licenses.bsd3;

16 license = stdenv.lib.licenses.bsd3;

20−}

17+}

test/golden-test-cases/deque.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl }:

1+{ mkDerivation, base, stdenv }:

2mkDerivation {

3 pname = "deque";

4 version = "0.2";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 homepage = "https://github.com/nikita-volkov/deque";

7 homepage = "https://github.com/nikita-volkov/deque";

11 description = "Double-ended queue";

8 description = "Double-ended queue";

12 license = stdenv.lib.licenses.mit;

9 license = stdenv.lib.licenses.mit;

13−}

10+}

test/golden-test-cases/dhall-bash.nix.golden+4−7

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, bytestring, containers, dhall, fetchurl

1+{ mkDerivation, base, bytestring, containers, dhall

2−, neat-interpolation, optparse-generic, shell-escape, text

2+, neat-interpolation, optparse-generic, shell-escape, stdenv, text

3, text-format, trifecta, vector

4}:

5mkDerivation {

6 pname = "dhall-bash";

7 version = "1.0.6";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 isLibrary = true;

9 isLibrary = true;

13 isExecutable = true;

10 isExecutable = true;

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

@@ -20,4 +17,4 @@ mkDerivation {

20 ];

17 ];

21 description = "Compile Dhall to Bash";

18 description = "Compile Dhall to Bash";

22 license = stdenv.lib.licenses.bsd3;

19 license = stdenv.lib.licenses.bsd3;

23−}

20+}

test/golden-test-cases/diagrams-solve.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, deepseq, fetchurl, tasty, tasty-hunit

1+{ mkDerivation, base, deepseq, stdenv, tasty, tasty-hunit

2, tasty-quickcheck

3}:

4mkDerivation {

5 pname = "diagrams-solve";

6 version = "0.1.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base ];

8 libraryHaskellDepends = [ base ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 base deepseq tasty tasty-hunit tasty-quickcheck

10 base deepseq tasty tasty-hunit tasty-quickcheck

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "http://projects.haskell.org/diagrams";

12 homepage = "http://projects.haskell.org/diagrams";

16 description = "Pure Haskell solver routines used by diagrams";

13 description = "Pure Haskell solver routines used by diagrams";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/discrimination.nix.golden+4−7

@@ -1,15 +1,12 @@

1{ mkDerivation, array, base, containers, contravariant, criterion

2−, deepseq, fetchurl, ghc-prim, hashable, primitive, profunctors

2+, deepseq, ghc-prim, hashable, primitive, profunctors, promises

3−, promises, semigroups, transformers, transformers-compat

3+, semigroups, stdenv, transformers, transformers-compat

4, unordered-containers, vector, void

5}:

6mkDerivation {

7 pname = "discrimination";

8 version = "0.3";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

14 array base containers contravariant deepseq ghc-prim hashable

11 array base containers contravariant deepseq ghc-prim hashable

15 primitive profunctors promises semigroups transformers

12 primitive profunctors promises semigroups transformers

@@ -22,4 +19,4 @@ mkDerivation {

22 homepage = "http://github.com/ekmett/discrimination/";

19 homepage = "http://github.com/ekmett/discrimination/";

23 description = "Fast generic linear-time sorting, joins and container construction";

20 description = "Fast generic linear-time sorting, joins and container construction";

24 license = stdenv.lib.licenses.bsd3;

21 license = stdenv.lib.licenses.bsd3;

25−}

22+}

test/golden-test-cases/dotenv.nix.golden+5−8

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, base-compat, directory, exceptions, fetchurl

1+{ mkDerivation, base, base-compat, directory, exceptions, hspec

2−, hspec, hspec-megaparsec, megaparsec, optparse-applicative

2+, hspec-megaparsec, megaparsec, optparse-applicative, process

3−, process, text, transformers, yaml

3+, stdenv, text, transformers, yaml

4}:

5mkDerivation {

6 pname = "dotenv";

7 version = "0.5.2.1";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 isLibrary = true;

9 isLibrary = true;

13 isExecutable = true;

10 isExecutable = true;

14 enableSeparateDataOutput = true;

11 enableSeparateDataOutput = true;

@@ -27,4 +24,4 @@ mkDerivation {

27 homepage = "https://github.com/stackbuilders/dotenv-hs";

24 homepage = "https://github.com/stackbuilders/dotenv-hs";

28 description = "Loads environment variables from dotenv files";

25 description = "Loads environment variables from dotenv files";

29 license = stdenv.lib.licenses.mit;

26 license = stdenv.lib.licenses.mit;

30−}

27+}

test/golden-test-cases/dotnet-timespan.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl }:

1+{ mkDerivation, base, stdenv }:

2mkDerivation {

3 pname = "dotnet-timespan";

4 version = "0.0.1.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 homepage = "http://github.com/YoEight/dotnet-timespan";

7 homepage = "http://github.com/YoEight/dotnet-timespan";

11 description = ".NET TimeSpan";

8 description = ".NET TimeSpan";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/dpor.nix.golden+4−7

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, containers, deepseq, fetchurl, random

1+{ mkDerivation, base, containers, deepseq, random, semigroups

2−, semigroups

2+, stdenv

3}:

4mkDerivation {

5 pname = "dpor";

6 version = "0.2.0.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base containers deepseq random semigroups

9 base containers deepseq random semigroups

13 ];

10 ];

14 homepage = "https://github.com/barrucadu/dejafu";

11 homepage = "https://github.com/barrucadu/dejafu";

15 description = "A generic implementation of dynamic partial-order reduction (DPOR) for testing arbitrary models of concurrency";

12 description = "A generic implementation of dynamic partial-order reduction (DPOR) for testing arbitrary models of concurrency";

16 license = stdenv.lib.licenses.mit;

13 license = stdenv.lib.licenses.mit;

17−}

14+}

test/golden-test-cases/drawille.nix.golden+3−6

@@ -1,11 +1,8 @@

1−{ mkDerivation, base, containers, fetchurl, hspec, QuickCheck }:

1+{ mkDerivation, base, containers, hspec, QuickCheck, stdenv }:

2mkDerivation {

3 pname = "drawille";

4 version = "0.1.2.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 isLibrary = true;

6 isLibrary = true;

10 isExecutable = true;

7 isExecutable = true;

11 libraryHaskellDepends = [ base containers ];

8 libraryHaskellDepends = [ base containers ];

@@ -13,4 +10,4 @@ mkDerivation {

13 homepage = "https://github.com/yamadapc/haskell-drawille#readme";

10 homepage = "https://github.com/yamadapc/haskell-drawille#readme";

14 description = "A port of asciimoo's drawille to haskell";

11 description = "A port of asciimoo's drawille to haskell";

15 license = stdenv.lib.licenses.gpl3;

12 license = stdenv.lib.licenses.gpl3;

16−}

13+}

test/golden-test-cases/drifter-postgresql.nix.golden+5−8

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, containers, drifter, either, fetchurl, mtl

1+{ mkDerivation, base, containers, drifter, either, mtl

2−, postgresql-simple, tasty, tasty-hunit, text, time, transformers

2+, postgresql-simple, stdenv, tasty, tasty-hunit, text, time

3−, transformers-compat

3+, transformers, transformers-compat

4}:

5mkDerivation {

6 pname = "drifter-postgresql";

7 version = "0.2.1";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 base containers drifter mtl postgresql-simple time transformers

10 base containers drifter mtl postgresql-simple time transformers

14 transformers-compat

11 transformers-compat

@@ -19,4 +16,4 @@ mkDerivation {

19 homepage = "http://github.com/michaelxavier/drifter-postgresql";

16 homepage = "http://github.com/michaelxavier/drifter-postgresql";

20 description = "PostgreSQL support for the drifter schema migration tool";

17 description = "PostgreSQL support for the drifter schema migration tool";

21 license = stdenv.lib.licenses.mit;

18 license = stdenv.lib.licenses.mit;

22−}

19+}

test/golden-test-cases/ede.nix.golden+5−7

@@ -1,16 +1,13 @@

1{ mkDerivation, aeson, ansi-wl-pprint, base, bifunctors, bytestring

2−, comonad, directory, double-conversion, fetchurl, filepath, free

2+, comonad, directory, double-conversion, filepath, free, lens, mtl

3−, lens, mtl, parsers, scientific, semigroups, tasty, tasty-golden

3+, parsers, scientific, semigroups, stdenv, tasty, tasty-golden

4, text, text-format, text-manipulate, trifecta

5, unordered-containers, vector

6}:

7mkDerivation {

8 pname = "ede";

9 version = "0.2.8.7";

10− src = fetchurl {

10+ sha256 = "deadbeef";

11− url = "http://example.org/";

12− sha256 = "abc";

13− };

14 enableSeparateDataOutput = true;

11 enableSeparateDataOutput = true;

15 libraryHaskellDepends = [

12 libraryHaskellDepends = [

16 aeson ansi-wl-pprint base bifunctors bytestring comonad directory

13 aeson ansi-wl-pprint base bifunctors bytestring comonad directory

@@ -24,4 +21,5 @@ mkDerivation {

24 homepage = "http://github.com/brendanhay/ede";

21 homepage = "http://github.com/brendanhay/ede";

25 description = "Templating language with similar syntax and features to Liquid or Jinja2";

22 description = "Templating language with similar syntax and features to Liquid or Jinja2";

26 license = "unknown";

23 license = "unknown";

27−}

24+ hydraPlatforms = stdenv.lib.platforms.none;

25+}

test/golden-test-cases/ekg-cloudwatch.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, amazonka, amazonka-cloudwatch, amazonka-core, base

2−, bytestring, ekg-core, fetchurl, lens, resourcet, semigroups, text

2+, bytestring, ekg-core, lens, resourcet, semigroups, stdenv, text

3, time, unordered-containers

4}:

5mkDerivation {

6 pname = "ekg-cloudwatch";

7 version = "0.0.1.6";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 amazonka amazonka-cloudwatch amazonka-core base bytestring ekg-core

10 amazonka amazonka-cloudwatch amazonka-core base bytestring ekg-core

14 lens resourcet semigroups text time unordered-containers

11 lens resourcet semigroups text time unordered-containers

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/sellerlabs/ekg-cloudwatch#readme";

13 homepage = "https://github.com/sellerlabs/ekg-cloudwatch#readme";

17 description = "An ekg backend for Amazon Cloudwatch";

14 description = "An ekg backend for Amazon Cloudwatch";

18 license = stdenv.lib.licenses.bsd3;

15 license = stdenv.lib.licenses.bsd3;

19−}

16+}

test/golden-test-cases/emailaddress.nix.golden+5−8

@@ -1,15 +1,12 @@

1{ mkDerivation, aeson, base, bifunctors, bytestring, doctest

2−, email-validate, fetchurl, Glob, http-api-data, opaleye

2+, email-validate, Glob, http-api-data, opaleye, path-pieces

3−, path-pieces, persistent, postgresql-simple, product-profunctors

3+, persistent, postgresql-simple, product-profunctors, profunctors

4−, profunctors, text

4+, stdenv, text

5}:

6mkDerivation {

7 pname = "emailaddress";

8 version = "0.2.0.0";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

14 aeson base bifunctors bytestring email-validate http-api-data

11 aeson base bifunctors bytestring email-validate http-api-data

15 opaleye path-pieces persistent postgresql-simple

12 opaleye path-pieces persistent postgresql-simple

@@ -19,4 +16,4 @@ mkDerivation {

19 homepage = "https://github.com/cdepillabout/emailaddress#readme";

16 homepage = "https://github.com/cdepillabout/emailaddress#readme";

20 description = "Wrapper around email-validate library adding instances for common type classes";

17 description = "Wrapper around email-validate library adding instances for common type classes";

21 license = stdenv.lib.licenses.bsd3;

18 license = stdenv.lib.licenses.bsd3;

22−}

19+}

test/golden-test-cases/envelope.nix.golden+4−7

@@ -1,16 +1,13 @@

1−{ mkDerivation, aeson, base, doctest, fetchurl, Glob, http-api-data

1+{ mkDerivation, aeson, base, doctest, Glob, http-api-data, mtl

2−, mtl, text

2+, stdenv, text

3}:

4mkDerivation {

5 pname = "envelope";

6 version = "0.2.2.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ aeson base http-api-data mtl text ];

8 libraryHaskellDepends = [ aeson base http-api-data mtl text ];

12 testHaskellDepends = [ base doctest Glob ];

9 testHaskellDepends = [ base doctest Glob ];

13 homepage = "https://github.com/cdepillabout/envelope#readme";

10 homepage = "https://github.com/cdepillabout/envelope#readme";

14 description = "Defines generic 'Envelope' type to wrap reponses from a JSON API";

11 description = "Defines generic 'Envelope' type to wrap reponses from a JSON API";

15 license = stdenv.lib.licenses.bsd3;

12 license = stdenv.lib.licenses.bsd3;

16−}

13+}

test/golden-test-cases/eventful-sqlite.nix.golden+4−7

@@ -1,14 +1,11 @@

1{ mkDerivation, aeson, base, bytestring, eventful-core

2−, eventful-sql-common, eventful-test-helpers, fetchurl, hspec

2+, eventful-sql-common, eventful-test-helpers, hspec, HUnit, mtl

3−, HUnit, mtl, persistent, persistent-sqlite, text, uuid

3+, persistent, persistent-sqlite, stdenv, text, uuid

4}:

5mkDerivation {

6 pname = "eventful-sqlite";

7 version = "0.2.0";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 aeson base bytestring eventful-core eventful-sql-common mtl

10 aeson base bytestring eventful-core eventful-sql-common mtl

14 persistent text uuid

11 persistent text uuid

@@ -21,4 +18,4 @@ mkDerivation {

21 homepage = "https://github.com/jdreaver/eventful#readme";

18 homepage = "https://github.com/jdreaver/eventful#readme";

22 description = "SQLite implementations for eventful";

19 description = "SQLite implementations for eventful";

23 license = stdenv.lib.licenses.mit;

20 license = stdenv.lib.licenses.mit;

24−}

21+}

test/golden-test-cases/exact-pi.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, numtype-dk }:

1+{ mkDerivation, base, numtype-dk, stdenv }:

2mkDerivation {

3 pname = "exact-pi";

4 version = "0.4.1.2";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base numtype-dk ];

6 libraryHaskellDepends = [ base numtype-dk ];

10 homepage = "https://github.com/dmcclean/exact-pi/";

7 homepage = "https://github.com/dmcclean/exact-pi/";

11 description = "Exact rational multiples of pi (and integer powers of pi)";

8 description = "Exact rational multiples of pi (and integer powers of pi)";

12 license = stdenv.lib.licenses.mit;

9 license = stdenv.lib.licenses.mit;

13−}

10+}

test/golden-test-cases/expiring-cache-map.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, containers, fetchurl, hashable

1+{ mkDerivation, base, bytestring, containers, hashable, stdenv

2, time, unordered-containers

3}:

4mkDerivation {

5 pname = "expiring-cache-map";

6 version = "0.0.6.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base containers hashable unordered-containers

9 base containers hashable unordered-containers

13 ];

10 ];

@@ -17,4 +14,4 @@ mkDerivation {

17 homepage = "https://github.com/elblake/expiring-cache-map";

14 homepage = "https://github.com/elblake/expiring-cache-map";

18 description = "General purpose simple caching";

15 description = "General purpose simple caching";

19 license = stdenv.lib.licenses.bsd3;

16 license = stdenv.lib.licenses.bsd3;

20−}

17+}

test/golden-test-cases/explicit-exception.nix.golden+3−6

@@ -1,15 +1,12 @@

1−{ mkDerivation, base, deepseq, fetchurl, transformers }:

1+{ mkDerivation, base, deepseq, stdenv, transformers }:

2mkDerivation {

3 pname = "explicit-exception";

4 version = "0.1.9";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 isLibrary = true;

6 isLibrary = true;

10 isExecutable = true;

7 isExecutable = true;

11 libraryHaskellDepends = [ base deepseq transformers ];

8 libraryHaskellDepends = [ base deepseq transformers ];

12 homepage = "http://www.haskell.org/haskellwiki/Exception";

9 homepage = "http://www.haskell.org/haskellwiki/Exception";

13 description = "Exceptions which are explicit in the type signature";

10 description = "Exceptions which are explicit in the type signature";

14 license = stdenv.lib.licenses.bsd3;

11 license = stdenv.lib.licenses.bsd3;

15−}

12+}

test/golden-test-cases/fdo-notify.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, containers, dbus, fetchurl }:

1+{ mkDerivation, base, containers, dbus, stdenv }:

2mkDerivation {

3 pname = "fdo-notify";

4 version = "0.3.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base containers dbus ];

6 libraryHaskellDepends = [ base containers dbus ];

10 homepage = "http://bitbucket.org/taejo/fdo-notify/";

7 homepage = "http://bitbucket.org/taejo/fdo-notify/";

11 description = "Desktop Notifications client";

8 description = "Desktop Notifications client";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/fgl.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, array, base, containers, deepseq, fetchurl, hspec

1+{ mkDerivation, array, base, containers, deepseq, hspec, microbench

2−, microbench, QuickCheck, transformers

2+, QuickCheck, stdenv, transformers

3}:

4mkDerivation {

5 pname = "fgl";

6 version = "5.5.4.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 array base containers deepseq transformers

9 array base containers deepseq transformers

13 ];

10 ];

@@ -15,4 +12,4 @@ mkDerivation {

15 benchmarkHaskellDepends = [ base deepseq microbench ];

12 benchmarkHaskellDepends = [ base deepseq microbench ];

16 description = "Martin Erwig's Functional Graph Library";

13 description = "Martin Erwig's Functional Graph Library";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/file-modules.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, async, base, directory, fetchurl, filepath

1+{ mkDerivation, async, base, directory, filepath, haskell-src-exts

2−, haskell-src-exts, MissingH, regex-compat, regex-pcre

2+, MissingH, regex-compat, regex-pcre, stdenv

3}:

4mkDerivation {

5 pname = "file-modules";

6 version = "0.1.2.4";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 isLibrary = true;

8 isLibrary = true;

12 isExecutable = true;

9 isExecutable = true;

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

@@ -21,4 +18,4 @@ mkDerivation {

21 homepage = "https://github.com/yamadapc/stack-run-auto";

18 homepage = "https://github.com/yamadapc/stack-run-auto";

22 description = "Takes a Haskell source-code file and outputs its modules";

19 description = "Takes a Haskell source-code file and outputs its modules";

23 license = stdenv.lib.licenses.mit;

20 license = stdenv.lib.licenses.mit;

24−}

21+}

test/golden-test-cases/fingertree.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, HUnit, QuickCheck, test-framework

1+{ mkDerivation, base, HUnit, QuickCheck, stdenv, test-framework

2, test-framework-hunit, test-framework-quickcheck2

3}:

4mkDerivation {

5 pname = "fingertree";

6 version = "0.1.3.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base ];

8 libraryHaskellDepends = [ base ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 base HUnit QuickCheck test-framework test-framework-hunit

10 base HUnit QuickCheck test-framework test-framework-hunit

@@ -15,4 +12,4 @@ mkDerivation {

15 ];

12 ];

16 description = "Generic finger-tree structure, with example instances";

13 description = "Generic finger-tree structure, with example instances";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/fixed-vector.nix.golden+4−7

@@ -1,15 +1,12 @@

1−{ mkDerivation, base, deepseq, doctest, fetchurl, filemanip

1+{ mkDerivation, base, deepseq, doctest, filemanip, primitive

2−, primitive

2+, stdenv

3}:

4mkDerivation {

5 pname = "fixed-vector";

6 version = "1.0.0.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base deepseq primitive ];

8 libraryHaskellDepends = [ base deepseq primitive ];

12 testHaskellDepends = [ base doctest filemanip primitive ];

9 testHaskellDepends = [ base doctest filemanip primitive ];

13 description = "Generic vectors with statically known size";

10 description = "Generic vectors with statically known size";

14 license = stdenv.lib.licenses.bsd3;

11 license = stdenv.lib.licenses.bsd3;

15−}

12+}

test/golden-test-cases/fixed.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl }:

1+{ mkDerivation, base, stdenv }:

2mkDerivation {

3 pname = "fixed";

4 version = "0.2.1.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 homepage = "http://github.com/ekmett/fixed";

7 homepage = "http://github.com/ekmett/fixed";

11 description = "Signed 15.16 precision fixed point arithmetic";

8 description = "Signed 15.16 precision fixed point arithmetic";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/foundation.nix.golden+3−6

@@ -1,15 +1,12 @@

1−{ mkDerivation, base, basement, fetchurl, gauge, ghc-prim }:

1+{ mkDerivation, base, basement, gauge, ghc-prim, stdenv }:

2mkDerivation {

3 pname = "foundation";

4 version = "0.0.17";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base basement ghc-prim ];

6 libraryHaskellDepends = [ base basement ghc-prim ];

10 testHaskellDepends = [ base basement ];

7 testHaskellDepends = [ base basement ];

11 benchmarkHaskellDepends = [ base basement gauge ];

8 benchmarkHaskellDepends = [ base basement gauge ];

12 homepage = "https://github.com/haskell-foundation/foundation";

9 homepage = "https://github.com/haskell-foundation/foundation";

13 description = "Alternative prelude with batteries and no dependencies";

10 description = "Alternative prelude with batteries and no dependencies";

14 license = stdenv.lib.licenses.bsd3;

11 license = stdenv.lib.licenses.bsd3;

15−}

12+}

test/golden-test-cases/frisby.nix.golden+3−7

@@ -1,14 +1,10 @@

1−{ mkDerivation, array, base, containers, fetchurl, mtl, semigroups

1+{ mkDerivation, array, base, containers, mtl, semigroups, stdenv }:

2−}:

3mkDerivation {

2mkDerivation {

4 pname = "frisby";

3 pname = "frisby";

5 version = "0.2.2";

4 version = "0.2.2";

6− src = fetchurl {

5+ sha256 = "deadbeef";

7− url = "http://example.org/";

8− sha256 = "abc";

9− };

10 libraryHaskellDepends = [ array base containers mtl semigroups ];

6 libraryHaskellDepends = [ array base containers mtl semigroups ];

11 homepage = "http://repetae.net/computer/frisby/";

7 homepage = "http://repetae.net/computer/frisby/";

12 description = "Linear time composable parser for PEG grammars";

8 description = "Linear time composable parser for PEG grammars";

13 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

14−}

10+}

test/golden-test-cases/funcmp.nix.golden+3−6

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, fetchurl, filepath, process }:

1+{ mkDerivation, base, filepath, process, stdenv }:

2mkDerivation {

3 pname = "funcmp";

4 version = "1.8";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 enableSeparateDataOutput = true;

6 enableSeparateDataOutput = true;

10 libraryHaskellDepends = [ base filepath process ];

7 libraryHaskellDepends = [ base filepath process ];

11 homepage = "http://savannah.nongnu.org/projects/funcmp/";

8 homepage = "http://savannah.nongnu.org/projects/funcmp/";

12 description = "Functional MetaPost";

9 description = "Functional MetaPost";

13 license = stdenv.lib.licenses.gpl3;

10 license = stdenv.lib.licenses.gpl3;

14−}

11+}

test/golden-test-cases/functor-classes-compat.nix.golden+3−6

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, containers, fetchurl, hashable

1+{ mkDerivation, base, containers, hashable, stdenv

2, unordered-containers, vector

3}:

4mkDerivation {

5 pname = "functor-classes-compat";

6 version = "1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base containers hashable unordered-containers vector

9 base containers hashable unordered-containers vector

13 ];

10 ];

14 homepage = "https://github.com/phadej/functor-classes-compat#readme";

11 homepage = "https://github.com/phadej/functor-classes-compat#readme";

15 description = "Data.Functor.Classes instances for core packages";

12 description = "Data.Functor.Classes instances for core packages";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/general-games.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, hspec, HUnit, monad-loops

1+{ mkDerivation, base, hspec, HUnit, monad-loops, MonadRandom

2−, MonadRandom, random, random-shuffle

2+, random, random-shuffle, stdenv

3}:

4mkDerivation {

5 pname = "general-games";

6 version = "1.0.5";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base monad-loops MonadRandom random random-shuffle

9 base monad-loops MonadRandom random random-shuffle

13 ];

10 ];

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://github.com/cgorski/general-games";

12 homepage = "https://github.com/cgorski/general-games";

16 description = "Library supporting simulation of a number of games";

13 description = "Library supporting simulation of a number of games";

17 license = stdenv.lib.licenses.mit;

14 license = stdenv.lib.licenses.mit;

18−}

15+}

test/golden-test-cases/generic-lens.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, criterion, deepseq, doctest, fetchurl

1+{ mkDerivation, base, criterion, deepseq, doctest

2−, inspection-testing, lens, profunctors, QuickCheck, tagged

2+, inspection-testing, lens, profunctors, QuickCheck, stdenv, tagged

3}:

4mkDerivation {

5 pname = "generic-lens";

6 version = "0.5.1.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base profunctors tagged ];

8 libraryHaskellDepends = [ base profunctors tagged ];

12 testHaskellDepends = [ base doctest inspection-testing lens ];

9 testHaskellDepends = [ base doctest inspection-testing lens ];

13 benchmarkHaskellDepends = [

10 benchmarkHaskellDepends = [

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/kcsongor/generic-lens";

13 homepage = "https://github.com/kcsongor/generic-lens";

17 description = "Generic data-structure operations exposed as lenses";

14 description = "Generic data-structure operations exposed as lenses";

18 license = stdenv.lib.licenses.bsd3;

15 license = stdenv.lib.licenses.bsd3;

19−}

16+}

test/golden-test-cases/genvalidity-aeson.nix.golden+5−8

@@ -1,15 +1,12 @@

1−{ mkDerivation, aeson, base, fetchurl, genvalidity

1+{ mkDerivation, aeson, base, genvalidity, genvalidity-hspec

2−, genvalidity-hspec, genvalidity-scientific, genvalidity-text

2+, genvalidity-scientific, genvalidity-text

3, genvalidity-unordered-containers, genvalidity-vector, hspec

4−, QuickCheck, validity, validity-aeson

4+, QuickCheck, stdenv, validity, validity-aeson

5}:

6mkDerivation {

7 pname = "genvalidity-aeson";

8 version = "0.1.0.0";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

14 aeson base genvalidity genvalidity-scientific genvalidity-text

11 aeson base genvalidity genvalidity-scientific genvalidity-text

15 genvalidity-unordered-containers genvalidity-vector QuickCheck

12 genvalidity-unordered-containers genvalidity-vector QuickCheck

@@ -21,4 +18,4 @@ mkDerivation {

21 homepage = "https://github.com/NorfairKing/validity#readme";

18 homepage = "https://github.com/NorfairKing/validity#readme";

22 description = "GenValidity support for aeson";

19 description = "GenValidity support for aeson";

23 license = stdenv.lib.licenses.mit;

20 license = stdenv.lib.licenses.mit;

24−}

21+}

test/golden-test-cases/genvalidity-hspec-aeson.nix.golden+4−7

@@ -1,14 +1,11 @@

1−{ mkDerivation, aeson, base, bytestring, deepseq, doctest, fetchurl

1+{ mkDerivation, aeson, base, bytestring, deepseq, doctest

2, genvalidity, genvalidity-aeson, genvalidity-hspec

3−, genvalidity-text, hspec, QuickCheck, text

3+, genvalidity-text, hspec, QuickCheck, stdenv, text

4}:

5mkDerivation {

6 pname = "genvalidity-hspec-aeson";

7 version = "0.1.0.1";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 aeson base bytestring deepseq genvalidity genvalidity-hspec hspec

10 aeson base bytestring deepseq genvalidity genvalidity-hspec hspec

14 QuickCheck

11 QuickCheck

@@ -20,4 +17,4 @@ mkDerivation {

20 homepage = "http://cs-syd.eu";

17 homepage = "http://cs-syd.eu";

21 description = "Standard spec's for aeson-related instances";

18 description = "Standard spec's for aeson-related instances";

22 license = stdenv.lib.licenses.mit;

19 license = stdenv.lib.licenses.mit;

23−}

20+}

test/golden-test-cases/genvalidity-hspec-binary.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, binary, deepseq, doctest, fetchurl

1+{ mkDerivation, base, binary, deepseq, doctest, genvalidity

2−, genvalidity, genvalidity-hspec, hspec, QuickCheck

2+, genvalidity-hspec, hspec, QuickCheck, stdenv

3}:

4mkDerivation {

5 pname = "genvalidity-hspec-binary";

6 version = "0.1.0.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base binary deepseq genvalidity genvalidity-hspec hspec QuickCheck

9 base binary deepseq genvalidity genvalidity-hspec hspec QuickCheck

13 ];

10 ];

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://github.com/NorfairKing/validity#readme";

12 homepage = "https://github.com/NorfairKing/validity#readme";

16 description = "Standard spec's for binary-related Instances";

13 description = "Standard spec's for binary-related Instances";

17 license = stdenv.lib.licenses.mit;

14 license = stdenv.lib.licenses.mit;

18−}

15+}

test/golden-test-cases/genvalidity-scientific.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, genvalidity, genvalidity-hspec

1+{ mkDerivation, base, genvalidity, genvalidity-hspec, hspec

2−, hspec, QuickCheck, scientific, validity, validity-scientific

2+, QuickCheck, scientific, stdenv, validity, validity-scientific

3}:

4mkDerivation {

5 pname = "genvalidity-scientific";

6 version = "0.1.0.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base genvalidity QuickCheck scientific validity validity-scientific

9 base genvalidity QuickCheck scientific validity validity-scientific

13 ];

10 ];

@@ -17,4 +14,4 @@ mkDerivation {

17 homepage = "https://github.com/NorfairKing/validity#readme";

14 homepage = "https://github.com/NorfairKing/validity#readme";

18 description = "GenValidity support for Scientific";

15 description = "GenValidity support for Scientific";

19 license = stdenv.lib.licenses.mit;

16 license = stdenv.lib.licenses.mit;

20−}

17+}

test/golden-test-cases/genvalidity-uuid.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, genvalidity, genvalidity-hspec

1+{ mkDerivation, base, genvalidity, genvalidity-hspec, hspec

2−, hspec, QuickCheck, uuid, validity, validity-uuid

2+, QuickCheck, stdenv, uuid, validity, validity-uuid

3}:

4mkDerivation {

5 pname = "genvalidity-uuid";

6 version = "0.0.0.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base genvalidity QuickCheck uuid validity validity-uuid

9 base genvalidity QuickCheck uuid validity validity-uuid

13 ];

10 ];

@@ -17,4 +14,4 @@ mkDerivation {

17 homepage = "https://github.com/NorfairKing/validity#readme";

14 homepage = "https://github.com/NorfairKing/validity#readme";

18 description = "GenValidity support for UUID";

15 description = "GenValidity support for UUID";

19 license = stdenv.lib.licenses.mit;

16 license = stdenv.lib.licenses.mit;

20−}

17+}

test/golden-test-cases/ghc-syb-utils.nix.golden+3−6

@@ -1,16 +1,13 @@

1−{ mkDerivation, base, directory, fetchurl, filepath, ghc, ghc-paths

1+{ mkDerivation, base, directory, filepath, ghc, ghc-paths, stdenv

2, syb

3}:

4mkDerivation {

5 pname = "ghc-syb-utils";

6 version = "0.2.3.3";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base ghc syb ];

8 libraryHaskellDepends = [ base ghc syb ];

12 testHaskellDepends = [ base directory filepath ghc ghc-paths ];

9 testHaskellDepends = [ base directory filepath ghc ghc-paths ];

13 homepage = "http://github.com/nominolo/ghc-syb";

10 homepage = "http://github.com/nominolo/ghc-syb";

14 description = "Scrap Your Boilerplate utilities for the GHC API";

11 description = "Scrap Your Boilerplate utilities for the GHC API";

15 license = stdenv.lib.licenses.bsd3;

12 license = stdenv.lib.licenses.bsd3;

16−}

13+}

test/golden-test-cases/ghcid.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, ansi-terminal, base, cmdargs, containers, directory

2−, extra, fetchurl, filepath, fsnotify, process, tasty, tasty-hunit

2+, extra, filepath, fsnotify, process, stdenv, tasty, tasty-hunit

3, terminal-size, time, unix

4}:

5mkDerivation {

6 pname = "ghcid";

7 version = "0.6.8";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 isLibrary = true;

9 isLibrary = true;

13 isExecutable = true;

10 isExecutable = true;

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

@@ -25,4 +22,4 @@ mkDerivation {

25 homepage = "https://github.com/ndmitchell/ghcid#readme";

22 homepage = "https://github.com/ndmitchell/ghcid#readme";

26 description = "GHCi based bare bones IDE";

23 description = "GHCi based bare bones IDE";

27 license = stdenv.lib.licenses.bsd3;

24 license = stdenv.lib.licenses.bsd3;

28−}

25+}

test/golden-test-cases/giphy-api.nix.golden+5−9

@@ -1,15 +1,12 @@

1{ mkDerivation, aeson, base, basic-prelude, bytestring, containers

2−, directory, fetchurl, hspec, http-api-data, http-client

2+, directory, hspec, http-api-data, http-client, http-client-tls

3−, http-client-tls, lens, microlens, microlens-th, mtl, network-uri

3+, lens, microlens, microlens-th, mtl, network-uri, servant

4−, servant, servant-client, text, transformers

4+, servant-client, stdenv, text, transformers

5}:

6mkDerivation {

7 pname = "giphy-api";

8 version = "0.5.2.0";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 isLibrary = true;

10 isLibrary = true;

14 isExecutable = true;

11 isExecutable = true;

15 libraryHaskellDepends = [

12 libraryHaskellDepends = [

@@ -17,7 +14,6 @@ mkDerivation {

17 microlens microlens-th mtl network-uri servant servant-client text

14 microlens microlens-th mtl network-uri servant servant-client text

18 transformers

15 transformers

19 ];

16 ];

20− executableHaskellDepends = [ base network-uri text ];

21 testHaskellDepends = [

17 testHaskellDepends = [

22 aeson base basic-prelude bytestring containers directory hspec lens

18 aeson base basic-prelude bytestring containers directory hspec lens

23 network-uri text

19 network-uri text

@@ -25,4 +21,4 @@ mkDerivation {

25 homepage = "http://github.com/passy/giphy-api#readme";

21 homepage = "http://github.com/passy/giphy-api#readme";

26 description = "Giphy HTTP API wrapper and CLI search tool";

22 description = "Giphy HTTP API wrapper and CLI search tool";

27 license = stdenv.lib.licenses.bsd3;

23 license = stdenv.lib.licenses.bsd3;

28−}

24+}

test/golden-test-cases/github.nix.golden+6−9

@@ -1,19 +1,16 @@

1{ mkDerivation, aeson, aeson-compat, base, base-compat

2, base16-bytestring, binary, binary-orphans, byteable, bytestring

3, containers, cryptohash, deepseq, deepseq-generics, exceptions

4−, fetchurl, file-embed, hashable, hspec, hspec-discover

4+, file-embed, hashable, hspec, hspec-discover, http-client

5−, http-client, http-client-tls, http-link-header, http-types

5+, http-client-tls, http-link-header, http-types, iso8601-time, mtl

6−, iso8601-time, mtl, network-uri, semigroups, text, time, tls

6+, network-uri, semigroups, stdenv, text, time, tls, transformers

7−, transformers, transformers-compat, unordered-containers, vector

7+, transformers-compat, unordered-containers, vector

8, vector-instances

9}:

10mkDerivation {

11 pname = "github";

12 version = "0.18";

13− src = fetchurl {

13+ sha256 = "deadbeef";

14− url = "http://example.org/";

15− sha256 = "abc";

16− };

17 libraryHaskellDepends = [

14 libraryHaskellDepends = [

18 aeson aeson-compat base base-compat base16-bytestring binary

15 aeson aeson-compat base base-compat base16-bytestring binary

19 binary-orphans byteable bytestring containers cryptohash deepseq

16 binary-orphans byteable bytestring containers cryptohash deepseq

@@ -30,4 +27,4 @@ mkDerivation {

30 homepage = "https://github.com/phadej/github";

27 homepage = "https://github.com/phadej/github";

31 description = "Access to the GitHub API, v3";

28 description = "Access to the GitHub API, v3";

32 license = stdenv.lib.licenses.bsd3;

29 license = stdenv.lib.licenses.bsd3;

33−}

30+}

test/golden-test-cases/gl.nix.golden+5−8

@@ -1,20 +1,17 @@

1−{ mkDerivation, base, Cabal, containers, directory, fetchurl

1+{ mkDerivation, base, Cabal, containers, directory, filepath, fixed

2−, filepath, fixed, half, hxt, mesa, transformers

2+, half, hxt, libGL, stdenv, transformers

3}:

4mkDerivation {

5 pname = "gl";

6 version = "0.8.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 setupHaskellDepends = [

8 setupHaskellDepends = [

12 base Cabal containers directory filepath hxt transformers

9 base Cabal containers directory filepath hxt transformers

13 ];

10 ];

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

15 base containers fixed half transformers

12 base containers fixed half transformers

16 ];

13 ];

17− librarySystemDepends = [ mesa ];

14+ librarySystemDepends = [ libGL ];

18 description = "Complete OpenGL raw bindings";

15 description = "Complete OpenGL raw bindings";

19 license = stdenv.lib.licenses.bsd3;

16 license = stdenv.lib.licenses.bsd3;

20−}

17+}

test/golden-test-cases/gogol-adexchange-buyer.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-adexchange-buyer";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google Ad Exchange Buyer SDK";

8 description = "Google Ad Exchange Buyer SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/gogol-admin-emailmigration.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-admin-emailmigration";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google Email Migration API v2 SDK";

8 description = "Google Email Migration API v2 SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/gogol-affiliates.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-affiliates";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google Affiliate Network SDK";

8 description = "Google Affiliate Network SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/gogol-apps-tasks.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-apps-tasks";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google Tasks SDK";

8 description = "Google Tasks SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/gogol-appstate.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-appstate";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google App State SDK";

8 description = "Google App State SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/gogol-blogger.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-blogger";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google Blogger SDK";

8 description = "Google Blogger SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/gogol-datastore.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-datastore";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google Cloud Datastore SDK";

8 description = "Google Cloud Datastore SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/gogol-dfareporting.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-dfareporting";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google DCM/DFA Reporting And Trafficking SDK";

8 description = "Google DCM/DFA Reporting And Trafficking SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/gogol-firebase-rules.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-firebase-rules";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google Firebase Rules SDK";

8 description = "Google Firebase Rules SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/gogol-gmail.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-gmail";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google Gmail SDK";

8 description = "Google Gmail SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/gogol-kgsearch.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-kgsearch";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google Knowledge Graph Search SDK";

8 description = "Google Knowledge Graph Search SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/gogol-maps-engine.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-maps-engine";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google Maps Engine SDK";

8 description = "Google Maps Engine SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/gogol-plus.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-plus";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google + SDK";

8 description = "Google + SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/gogol-resourceviews.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-resourceviews";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google Compute Engine Instance Groups SDK";

8 description = "Google Compute Engine Instance Groups SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/gogol-translate.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-translate";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google Translate SDK";

8 description = "Google Translate SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/gogol-webmaster-tools.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-webmaster-tools";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google Search Console SDK";

8 description = "Google Search Console SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/gogol-youtube.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, fetchurl, gogol-core }:

1+{ mkDerivation, base, gogol-core, stdenv }:

2mkDerivation {

3 pname = "gogol-youtube";

4 version = "0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base gogol-core ];

6 libraryHaskellDepends = [ base gogol-core ];

10 homepage = "https://github.com/brendanhay/gogol";

7 homepage = "https://github.com/brendanhay/gogol";

11 description = "Google YouTube Data SDK";

8 description = "Google YouTube Data SDK";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/groundhog-mysql.nix.golden+4−7

@@ -1,18 +1,15 @@

1−{ mkDerivation, base, bytestring, containers, fetchurl, groundhog

1+{ mkDerivation, base, bytestring, containers, groundhog

2, monad-control, monad-logger, mysql, mysql-simple, resource-pool

3−, resourcet, text, time, transformers

3+, resourcet, stdenv, text, time, transformers

4}:

5mkDerivation {

6 pname = "groundhog-mysql";

7 version = "0.8";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 base bytestring containers groundhog monad-control monad-logger

10 base bytestring containers groundhog monad-control monad-logger

14 mysql mysql-simple resource-pool resourcet text time transformers

11 mysql mysql-simple resource-pool resourcet text time transformers

15 ];

12 ];

16 description = "MySQL backend for the groundhog library";

13 description = "MySQL backend for the groundhog library";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/gsasl.nix.golden+3−6

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, bytestring, fetchurl, gsasl, transformers }:

1+{ mkDerivation, base, bytestring, gsasl, stdenv, transformers }:

2mkDerivation {

3 pname = "gsasl";

4 version = "0.3.6";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base bytestring transformers ];

6 libraryHaskellDepends = [ base bytestring transformers ];

10 libraryPkgconfigDepends = [ gsasl ];

7 libraryPkgconfigDepends = [ gsasl ];

11 homepage = "https://john-millikin.com/software/haskell-gsasl/";

8 homepage = "https://john-millikin.com/software/haskell-gsasl/";

12 description = "Bindings for GNU libgsasl";

9 description = "Bindings for GNU libgsasl";

13 license = stdenv.lib.licenses.gpl3;

10 license = stdenv.lib.licenses.gpl3;

14−}

11+}

test/golden-test-cases/hOpenPGP.nix.golden+4−7

@@ -2,20 +2,17 @@

2, base64-bytestring, bifunctors, binary, binary-conduit, byteable

3, bytestring, bzlib, conduit, conduit-extra, containers, criterion

4, crypto-cipher-types, cryptonite, data-default-class, errors

5−, fetchurl, hashable, incremental-parser, ixset-typed, lens, memory

5+, hashable, incremental-parser, ixset-typed, lens, memory

6, monad-loops, nettle, network, network-uri, newtype

7, openpgp-asciiarmor, QuickCheck, quickcheck-instances, resourcet

8−, securemem, semigroups, split, tasty, tasty-hunit

8+, securemem, semigroups, split, stdenv, tasty, tasty-hunit

9, tasty-quickcheck, text, time, time-locale-compat, transformers

10, unordered-containers, wl-pprint-extras, zlib

11}:

12mkDerivation {

13 pname = "hOpenPGP";

14 version = "2.5.5";

15− src = fetchurl {

15+ sha256 = "deadbeef";

16− url = "http://example.org/";

17− sha256 = "abc";

18− };

19 libraryHaskellDepends = [

16 libraryHaskellDepends = [

20 aeson attoparsec base base16-bytestring base64-bytestring

17 aeson attoparsec base base16-bytestring base64-bytestring

21 bifunctors binary binary-conduit byteable bytestring bzlib conduit

18 bifunctors binary binary-conduit byteable bytestring bzlib conduit

@@ -49,4 +46,4 @@ mkDerivation {

49 homepage = "http://floss.scru.org/hOpenPGP/";

46 homepage = "http://floss.scru.org/hOpenPGP/";

50 description = "native Haskell implementation of OpenPGP (RFC4880)";

47 description = "native Haskell implementation of OpenPGP (RFC4880)";

51 license = stdenv.lib.licenses.mit;

48 license = stdenv.lib.licenses.mit;

52−}

49+}

test/golden-test-cases/hPDB-examples.nix.golden+4−7

@@ -1,15 +1,12 @@

1{ mkDerivation, AC-Vector, base, bytestring, containers, deepseq

2−, directory, fetchurl, ghc-prim, GLUT, hPDB, IfElse, iterable, mtl

2+, directory, ghc-prim, GLUT, hPDB, IfElse, iterable, mtl, Octree

3−, Octree, OpenGL, process, QuickCheck, template-haskell, text

3+, OpenGL, process, QuickCheck, stdenv, template-haskell, text

4, text-format, time, vector

5}:

6mkDerivation {

7 pname = "hPDB-examples";

8 version = "1.2.0.8";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 isLibrary = false;

10 isLibrary = false;

14 isExecutable = true;

11 isExecutable = true;

15 executableHaskellDepends = [

12 executableHaskellDepends = [

@@ -24,4 +21,4 @@ mkDerivation {

24 homepage = "https://github.com/BioHaskell/hPDB-examples";

21 homepage = "https://github.com/BioHaskell/hPDB-examples";

25 description = "Examples for hPDB library";

22 description = "Examples for hPDB library";

26 license = stdenv.lib.licenses.bsd3;

23 license = stdenv.lib.licenses.bsd3;

27−}

24+}

test/golden-test-cases/haddock-library.cabalnew file+130

@@ -0,0 +1,130 @@

1+name: haddock-library

2+version: 1.4.5

3+synopsis: Library exposing some functionality of Haddock.

4+description: Haddock is a documentation-generation tool for Haskell

5+ libraries. These modules expose some functionality of it

6+ without pulling in the GHC dependency. Please note that the

7+ API is likely to change so specify upper bounds in your

8+ project if you can't release often. For interacting with Haddock

9+ itself, see the ‘haddock’ package.

10+license: BSD3

11+license-file: LICENSE

12+maintainer: Alex Biehl <alexbiehl@gmail.com>, Simon Hengel <sol@typeful.net>, Mateusz Kowalczyk <fuuzetsu@fuuzetsu.co.uk>

13+homepage: http://www.haskell.org/haddock/

14+bug-reports: https://github.com/haskell/haddock/issues

15+category: Documentation

16+build-type: Simple

17+cabal-version: >= 2.0

18+extra-source-files:

19+ CHANGES.md

20+library

21+ default-language: Haskell2010

22+

23+ build-depends:

24+ base >= 4.5 && < 4.11

25+ , bytestring >= 0.9.2.1 && < 0.11

26+ , transformers >= 0.3.0 && < 0.6

27+

28+ -- internal sub-lib

29+ build-depends: attoparsec

30+

31+ hs-source-dirs: src

32+ ghc-options: -funbox-strict-fields -Wall -fwarn-tabs -O2

33+

34+ exposed-modules:

35+ Documentation.Haddock.Doc

36+ Documentation.Haddock.Markup

37+ Documentation.Haddock.Parser

38+ Documentation.Haddock.Parser.Monad

39+ Documentation.Haddock.Types

40+ Documentation.Haddock.Utf8

41+

42+ other-modules:

43+ Documentation.Haddock.Parser.Util

44+

45+ ghc-options: -Wall

46+ if impl(ghc >= 8.0)

47+ ghc-options: -Wcompat -Wnoncanonical-monad-instances -Wnoncanonical-monadfail-instances

48+

49+library attoparsec

50+ default-language: Haskell2010

51+

52+ build-depends:

53+ base >= 4.5 && < 4.11

54+ , bytestring >= 0.9.2.1 && < 0.11

55+ , deepseq >= 1.3 && < 1.5

56+

57+ hs-source-dirs: vendor/attoparsec-0.13.1.0

58+

59+ -- NB: haddock-library needs only small part of lib:attoparsec

60+ -- internally, so we only bundle that subset here

61+ exposed-modules:

62+ Data.Attoparsec.ByteString

63+ Data.Attoparsec.ByteString.Char8

64+

65+ other-modules:

66+ Data.Attoparsec

67+ Data.Attoparsec.ByteString.Buffer

68+ Data.Attoparsec.ByteString.FastSet

69+ Data.Attoparsec.ByteString.Internal

70+ Data.Attoparsec.Combinator

71+ Data.Attoparsec.Internal

72+ Data.Attoparsec.Internal.Fhthagn

73+ Data.Attoparsec.Internal.Types

74+ Data.Attoparsec.Number

75+

76+ ghc-options: -funbox-strict-fields -Wall -fwarn-tabs -O2

77+

78+ ghc-options: -Wall

79+ if impl(ghc >= 8.0)

80+ ghc-options: -Wcompat -Wnoncanonical-monad-instances -Wnoncanonical-monadfail-instances

81+ else

82+ build-depends: semigroups ^>= 0.18.3, fail ^>= 4.9.0.0

83+

84+

85+test-suite spec

86+ type: exitcode-stdio-1.0

87+ default-language: Haskell2010

88+ main-is: Spec.hs

89+ hs-source-dirs:

90+ test

91+ , src

92+ ghc-options: -Wall

93+

94+ cpp-options:

95+ -DTEST

96+

97+ other-modules:

98+ Documentation.Haddock.Doc

99+ Documentation.Haddock.Parser

100+ Documentation.Haddock.Parser.Monad

101+ Documentation.Haddock.Parser.Util

102+ Documentation.Haddock.Parser.UtilSpec

103+ Documentation.Haddock.ParserSpec

104+ Documentation.Haddock.Types

105+ Documentation.Haddock.Utf8

106+ Documentation.Haddock.Utf8Spec

107+

108+ build-depends:

109+ base-compat ^>= 0.9.3

110+ , transformers >= 0.3.0 && < 0.6

111+ , hspec ^>= 2.4.4

112+ , QuickCheck ^>= 2.10

113+

114+ -- internal sub-lib

115+ build-depends: attoparsec

116+

117+ -- Versions for the dependencies below are transitively pinned by

118+ -- dependency on haddock-library:lib:attoparsec

119+ build-depends:

120+ base

121+ , bytestring

122+ , deepseq

123+

124+ build-tool-depends:

125+ hspec-discover:hspec-discover ^>= 2.4.4

126+

127+source-repository head

128+ type: git

129+ subdir: haddock-library

130+ location: https://github.com/haskell/haddock.git

test/golden-test-cases/haddock-library.nix.goldennew file+17

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

1+{ mkDerivation, base, base-compat, bytestring, deepseq, hspec

2+, hspec-discover, QuickCheck, stdenv, transformers

3+}:

4+mkDerivation {

5+ pname = "haddock-library";

6+ version = "1.4.5";

7+ sha256 = "deadbeef";

8+ libraryHaskellDepends = [ base bytestring deepseq transformers ];

9+ testHaskellDepends = [

10+ base base-compat bytestring deepseq hspec QuickCheck transformers

11+ ];

12+ testToolDepends = [ hspec-discover ];

13+ doHaddock = false;

14+ homepage = "http://www.haskell.org/haddock/";

15+ description = "Library exposing some functionality of Haddock";

16+ license = stdenv.lib.licenses.bsd3;

17+}

test/golden-test-cases/hakyll.nix.golden+6−9

@@ -1,20 +1,17 @@

1{ mkDerivation, base, binary, blaze-html, blaze-markup, bytestring

2, containers, cryptohash, data-default, deepseq, directory

3−, fetchurl, filepath, fsnotify, http-conduit, http-types, lrucache

3+, filepath, fsnotify, http-conduit, http-types, lrucache, mtl

4−, mtl, network, network-uri, optparse-applicative, pandoc

4+, network, network-uri, optparse-applicative, pandoc

5, pandoc-citeproc, parsec, process, QuickCheck, random, regex-base

6−, regex-tdfa, resourcet, scientific, system-filepath, tagsoup

6+, regex-tdfa, resourcet, scientific, stdenv, system-filepath

7−, tasty, tasty-hunit, tasty-quickcheck, text, time

7+, tagsoup, tasty, tasty-hunit, tasty-quickcheck, text, time

8, time-locale-compat, unordered-containers, utillinux, vector, wai

9, wai-app-static, warp, yaml

10}:

11mkDerivation {

12 pname = "hakyll";

13 version = "4.10.0.0";

14− src = fetchurl {

14+ sha256 = "deadbeef";

15− url = "http://example.org/";

16− sha256 = "abc";

17− };

18 isLibrary = true;

15 isLibrary = true;

19 isExecutable = true;

16 isExecutable = true;

20 enableSeparateDataOutput = true;

17 enableSeparateDataOutput = true;

@@ -42,4 +39,4 @@ mkDerivation {

42 homepage = "http://jaspervdj.be/hakyll";

39 homepage = "http://jaspervdj.be/hakyll";

43 description = "A static website compiler library";

40 description = "A static website compiler library";

44 license = stdenv.lib.licenses.bsd3;

41 license = stdenv.lib.licenses.bsd3;

45−}

42+}

test/golden-test-cases/happstack-hsp.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, fetchurl, happstack-server, harp

1+{ mkDerivation, base, bytestring, happstack-server, harp, hsp

2−, hsp, hsx2hs, mtl, syb, text, utf8-string

2+, hsx2hs, mtl, stdenv, syb, text, utf8-string

3}:

4mkDerivation {

5 pname = "happstack-hsp";

6 version = "7.3.7.3";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base bytestring happstack-server harp hsp hsx2hs mtl syb text

9 base bytestring happstack-server harp hsp hsx2hs mtl syb text

13 utf8-string

10 utf8-string

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "http://www.happstack.com/";

12 homepage = "http://www.happstack.com/";

16 description = "Support for using HSP templates in Happstack";

13 description = "Support for using HSP templates in Happstack";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/happy.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, array, base, Cabal, containers, directory, fetchurl

1+{ mkDerivation, array, base, Cabal, containers, directory, filepath

2−, filepath, mtl, process

2+, mtl, process, stdenv

3}:

4mkDerivation {

5 pname = "happy";

6 version = "1.19.8";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 isLibrary = false;

8 isLibrary = false;

12 isExecutable = true;

9 isExecutable = true;

13 setupHaskellDepends = [ base Cabal directory filepath ];

10 setupHaskellDepends = [ base Cabal directory filepath ];

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://www.haskell.org/happy/";

13 homepage = "https://www.haskell.org/happy/";

17 description = "Happy is a parser generator for Haskell";

14 description = "Happy is a parser generator for Haskell";

18 license = stdenv.lib.licenses.bsd2;

15 license = stdenv.lib.licenses.bsd2;

19−}

16+}

test/golden-test-cases/harp.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl }:

1+{ mkDerivation, base, stdenv }:

2mkDerivation {

3 pname = "harp";

4 version = "0.4.3";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 homepage = "https://github.com/seereason/harp";

7 homepage = "https://github.com/seereason/harp";

11 description = "HaRP allows pattern-matching with regular expressions";

8 description = "HaRP allows pattern-matching with regular expressions";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/hashtables.nix.golden+3−7

@@ -1,17 +1,13 @@

1−{ mkDerivation, base, fetchurl, ghc-prim, hashable, primitive

1+{ mkDerivation, base, ghc-prim, hashable, primitive, stdenv, vector

2−, vector

3}:

2}:

4mkDerivation {

3mkDerivation {

5 pname = "hashtables";

4 pname = "hashtables";

6 version = "1.2.2.1";

5 version = "1.2.2.1";

7− src = fetchurl {

6+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

7 libraryHaskellDepends = [

12 base ghc-prim hashable primitive vector

8 base ghc-prim hashable primitive vector

13 ];

9 ];

14 homepage = "http://github.com/gregorycollins/hashtables";

10 homepage = "http://github.com/gregorycollins/hashtables";

15 description = "Mutable hash tables in the ST monad";

11 description = "Mutable hash tables in the ST monad";

16 license = stdenv.lib.licenses.bsd3;

12 license = stdenv.lib.licenses.bsd3;

17−}

13+}

test/golden-test-cases/haskell-tools-debug.nix.golden+6−9

@@ -1,15 +1,12 @@

1−{ mkDerivation, base, fetchurl, filepath, ghc, ghc-paths

1+{ mkDerivation, base, filepath, ghc, ghc-paths, haskell-tools-ast

2−, haskell-tools-ast, haskell-tools-backend-ghc

2+, haskell-tools-backend-ghc, haskell-tools-builtin-refactorings

3−, haskell-tools-builtin-refactorings, haskell-tools-prettyprint

3+, haskell-tools-prettyprint, haskell-tools-refactor, references

4−, haskell-tools-refactor, references, split, template-haskell

4+, split, stdenv, template-haskell

5}:

6mkDerivation {

7 pname = "haskell-tools-debug";

8 version = "1.0.0.3";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 isLibrary = true;

10 isLibrary = true;

14 isExecutable = true;

11 isExecutable = true;

15 libraryHaskellDepends = [

12 libraryHaskellDepends = [

@@ -22,4 +19,4 @@ mkDerivation {

22 homepage = "https://github.com/haskell-tools/haskell-tools";

19 homepage = "https://github.com/haskell-tools/haskell-tools";

23 description = "Debugging Tools for Haskell-tools";

20 description = "Debugging Tools for Haskell-tools";

24 license = stdenv.lib.licenses.bsd3;

21 license = stdenv.lib.licenses.bsd3;

25−}

22+}

test/golden-test-cases/haskell-tools-rewrite.nix.golden+5−8

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, containers, directory, fetchurl, filepath

1+{ mkDerivation, base, containers, directory, filepath, ghc

2−, ghc, haskell-tools-ast, haskell-tools-prettyprint, mtl

2+, haskell-tools-ast, haskell-tools-prettyprint, mtl, references

3−, references, tasty, tasty-hunit

3+, stdenv, tasty, tasty-hunit

4}:

5mkDerivation {

6 pname = "haskell-tools-rewrite";

7 version = "1.0.0.3";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 base containers ghc haskell-tools-ast haskell-tools-prettyprint mtl

10 base containers ghc haskell-tools-ast haskell-tools-prettyprint mtl

14 references

11 references

@@ -20,4 +17,4 @@ mkDerivation {

20 homepage = "https://github.com/haskell-tools/haskell-tools";

17 homepage = "https://github.com/haskell-tools/haskell-tools";

21 description = "Facilities for generating new parts of the Haskell-Tools AST";

18 description = "Facilities for generating new parts of the Haskell-Tools AST";

22 license = stdenv.lib.licenses.bsd3;

19 license = stdenv.lib.licenses.bsd3;

23−}

20+}

test/golden-test-cases/hasql.nix.golden+7−10

@@ -1,18 +1,15 @@

1{ mkDerivation, attoparsec, base, base-prelude, bug, bytestring

2, bytestring-strict-builder, contravariant, contravariant-extras

3−, criterion, data-default-class, dlist, fetchurl, hashable

3+, criterion, data-default-class, dlist, hashable, hashtables

4−, hashtables, loch-th, mtl, placeholders, postgresql-binary

4+, loch-th, mtl, placeholders, postgresql-binary, postgresql-libpq

5−, postgresql-libpq, profunctors, QuickCheck, quickcheck-instances

5+, profunctors, QuickCheck, quickcheck-instances, rebase, rerebase

6−, rebase, rerebase, semigroups, tasty, tasty-hunit

6+, semigroups, stdenv, tasty, tasty-hunit, tasty-quickcheck, text

7−, tasty-quickcheck, text, transformers, vector

7+, transformers, vector

8}:

9mkDerivation {

10 pname = "hasql";

11 version = "1.1.1";

12− src = fetchurl {

12+ sha256 = "deadbeef";

13− url = "http://example.org/";

14− sha256 = "abc";

15− };

16 libraryHaskellDepends = [

13 libraryHaskellDepends = [

17 attoparsec base base-prelude bytestring bytestring-strict-builder

14 attoparsec base base-prelude bytestring bytestring-strict-builder

18 contravariant contravariant-extras data-default-class dlist

15 contravariant contravariant-extras data-default-class dlist

@@ -27,4 +24,4 @@ mkDerivation {

27 homepage = "https://github.com/nikita-volkov/hasql";

24 homepage = "https://github.com/nikita-volkov/hasql";

28 description = "An efficient PostgreSQL driver and a flexible mapping API";

25 description = "An efficient PostgreSQL driver and a flexible mapping API";

29 license = stdenv.lib.licenses.mit;

26 license = stdenv.lib.licenses.mit;

30−}

27+}

test/golden-test-cases/hformat.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, ansi-terminal, base, base-unicode-symbols, fetchurl

1+{ mkDerivation, ansi-terminal, base, base-unicode-symbols, hspec

2−, hspec, text

2+, stdenv, text

3}:

4mkDerivation {

5 pname = "hformat";

6 version = "0.3.1.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 ansi-terminal base base-unicode-symbols text

9 ansi-terminal base base-unicode-symbols text

13 ];

10 ];

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "http://github.com/mvoidex/hformat";

12 homepage = "http://github.com/mvoidex/hformat";

16 description = "Simple Haskell formatting";

13 description = "Simple Haskell formatting";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/highlighting-kate.nix.golden+6−9

@@ -1,25 +1,22 @@

1−{ mkDerivation, base, blaze-html, containers, Diff, directory

1+{ mkDerivation, base, blaze-html, bytestring, containers, Diff

2−, fetchurl, filepath, mtl, parsec, process, regex-pcre-builtin

2+, directory, filepath, mtl, parsec, pcre-light, process, stdenv

3, utf8-string

4}:

5mkDerivation {

6 pname = "highlighting-kate";

7 version = "0.6.4";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

9+ configureFlags = [ "-fpcre-light" ];

10− sha256 = "abc";

11− };

12 isLibrary = true;

10 isLibrary = true;

13 isExecutable = true;

11 isExecutable = true;

14 libraryHaskellDepends = [

12 libraryHaskellDepends = [

15− base blaze-html containers mtl parsec regex-pcre-builtin

13+ base blaze-html bytestring containers mtl parsec pcre-light

16 utf8-string

14 utf8-string

17 ];

15 ];

18− executableHaskellDepends = [ base blaze-html containers filepath ];

19 testHaskellDepends = [

16 testHaskellDepends = [

20 base blaze-html containers Diff directory filepath process

17 base blaze-html containers Diff directory filepath process

21 ];

18 ];

22 homepage = "http://github.com/jgm/highlighting-kate";

19 homepage = "http://github.com/jgm/highlighting-kate";

23 description = "Syntax highlighting";

20 description = "Syntax highlighting";

24 license = "GPL";

21 license = "GPL";

25−}

22+}

test/golden-test-cases/hit.nix.golden+5−9

@@ -1,16 +1,12 @@

1{ mkDerivation, attoparsec, base, byteable, bytedump, bytestring

2−, containers, cryptohash, fetchurl, hourglass, mtl, parsec

2+, containers, cryptohash, hourglass, mtl, parsec, patience, random

3−, patience, random, system-fileio, system-filepath, tasty

3+, stdenv, system-fileio, system-filepath, tasty, tasty-quickcheck

4−, tasty-quickcheck, unix-compat, utf8-string, vector, zlib

4+, unix-compat, utf8-string, vector, zlib, zlib-bindings

5−, zlib-bindings

6}:

5}:

7mkDerivation {

6mkDerivation {

8 pname = "hit";

7 pname = "hit";

9 version = "0.6.3";

8 version = "0.6.3";

10− src = fetchurl {

9+ sha256 = "deadbeef";

11− url = "http://example.org/";

12− sha256 = "abc";

13− };

14 isLibrary = true;

10 isLibrary = true;

15 isExecutable = true;

11 isExecutable = true;

16 enableSeparateDataOutput = true;

12 enableSeparateDataOutput = true;

@@ -25,4 +21,4 @@ mkDerivation {

25 homepage = "http://github.com/vincenthz/hit";

21 homepage = "http://github.com/vincenthz/hit";

26 description = "Git operations in haskell";

22 description = "Git operations in haskell";

27 license = stdenv.lib.licenses.bsd3;

23 license = stdenv.lib.licenses.bsd3;

28−}

24+}

test/golden-test-cases/hjson.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, base, containers, fetchurl, parsec }:

1+{ mkDerivation, base, containers, parsec, stdenv }:

2mkDerivation {

3 pname = "hjson";

4 version = "1.3.2";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base containers parsec ];

6 libraryHaskellDepends = [ base containers parsec ];

10 description = "JSON parsing library";

7 description = "JSON parsing library";

11 license = stdenv.lib.licenses.bsd3;

8 license = stdenv.lib.licenses.bsd3;

12−}

9+}

test/golden-test-cases/hmpfr.nix.golden+3−6

@@ -1,15 +1,12 @@

1−{ mkDerivation, base, fetchurl, integer-gmp, mpfr }:

1+{ mkDerivation, base, integer-gmp, mpfr, stdenv }:

2mkDerivation {

3 pname = "hmpfr";

4 version = "0.4.3";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 enableSeparateDataOutput = true;

6 enableSeparateDataOutput = true;

10 libraryHaskellDepends = [ base integer-gmp ];

7 libraryHaskellDepends = [ base integer-gmp ];

11 librarySystemDepends = [ mpfr ];

8 librarySystemDepends = [ mpfr ];

12 homepage = "https://github.com/michalkonecny/hmpfr";

9 homepage = "https://github.com/michalkonecny/hmpfr";

13 description = "Haskell binding to the MPFR library";

10 description = "Haskell binding to the MPFR library";

14 license = stdenv.lib.licenses.bsd3;

11 license = stdenv.lib.licenses.bsd3;

15−}

12+}

test/golden-test-cases/hoogle.nix.golden+5−8

@@ -1,18 +1,15 @@

1{ mkDerivation, aeson, base, binary, bytestring, cmdargs, conduit

2, conduit-extra, connection, containers, deepseq, directory, extra

3−, fetchurl, filepath, haskell-src-exts, http-conduit, http-types

3+, filepath, haskell-src-exts, http-conduit, http-types, js-flot

4−, js-flot, js-jquery, mmap, network, network-uri, old-locale

4+, js-jquery, mmap, network, network-uri, old-locale, process

5−, process, process-extras, QuickCheck, resourcet, storable-tuple

5+, process-extras, QuickCheck, resourcet, stdenv, storable-tuple

6, tar, template-haskell, text, time, transformers, uniplate

7, utf8-string, vector, wai, wai-logger, warp, warp-tls, zlib

8}:

9mkDerivation {

10 pname = "hoogle";

11 version = "5.0.14";

12− src = fetchurl {

12+ sha256 = "deadbeef";

13− url = "http://example.org/";

14− sha256 = "abc";

15− };

16 isLibrary = true;

13 isLibrary = true;

17 isExecutable = true;

14 isExecutable = true;

18 enableSeparateDataOutput = true;

15 enableSeparateDataOutput = true;

@@ -30,4 +27,4 @@ mkDerivation {

30 homepage = "http://hoogle.haskell.org/";

27 homepage = "http://hoogle.haskell.org/";

31 description = "Haskell API Search";

28 description = "Haskell API Search";

32 license = stdenv.lib.licenses.bsd3;

29 license = stdenv.lib.licenses.bsd3;

33−}

30+}

test/golden-test-cases/hostname-validate.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, attoparsec, base, bytestring, fetchurl }:

1+{ mkDerivation, attoparsec, base, bytestring, stdenv }:

2mkDerivation {

3 pname = "hostname-validate";

4 version = "1.0.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ attoparsec base bytestring ];

6 libraryHaskellDepends = [ attoparsec base bytestring ];

10 description = "Validate hostnames e.g. localhost or foo.co.uk.";

7 description = "Validate hostnames e.g. localhost or foo.co.uk.";

11 license = stdenv.lib.licenses.bsd3;

8 license = stdenv.lib.licenses.bsd3;

12−}

9+}

test/golden-test-cases/hsinstall.nix.golden+3−6

@@ -1,11 +1,8 @@

1−{ mkDerivation, base, directory, fetchurl, filepath }:

1+{ mkDerivation, base, directory, filepath, stdenv }:

2mkDerivation {

3 pname = "hsinstall";

4 version = "1.6";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 isLibrary = true;

6 isLibrary = true;

10 isExecutable = true;

7 isExecutable = true;

11 enableSeparateDataOutput = true;

8 enableSeparateDataOutput = true;

@@ -13,4 +10,4 @@ mkDerivation {

13 executableHaskellDepends = [ base directory filepath ];

10 executableHaskellDepends = [ base directory filepath ];

14 description = "Install Haskell software";

11 description = "Install Haskell software";

15 license = stdenv.lib.licenses.isc;

12 license = stdenv.lib.licenses.isc;

16−}

13+}

test/golden-test-cases/hstatsd.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, fetchurl, mtl, network, text }:

1+{ mkDerivation, base, bytestring, mtl, network, stdenv, text }:

2mkDerivation {

3 pname = "hstatsd";

4 version = "0.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base bytestring mtl network text ];

6 libraryHaskellDepends = [ base bytestring mtl network text ];

10 homepage = "https://github.com/mokus0/hstatsd";

7 homepage = "https://github.com/mokus0/hstatsd";

11 description = "Quick and dirty statsd interface";

8 description = "Quick and dirty statsd interface";

12 license = stdenv.lib.licenses.publicDomain;

9 license = stdenv.lib.licenses.publicDomain;

13−}

10+}

test/golden-test-cases/hsx-jmacro.nix.golden+3−6

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, fetchurl, hsp, jmacro, mtl, text

1+{ mkDerivation, base, hsp, jmacro, mtl, stdenv, text

2, wl-pprint-text

3}:

4mkDerivation {

5 pname = "hsx-jmacro";

6 version = "7.3.8";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base hsp jmacro mtl text wl-pprint-text

9 base hsp jmacro mtl text wl-pprint-text

13 ];

10 ];

14 homepage = "http://www.happstack.com/";

11 homepage = "http://www.happstack.com/";

15 description = "hsp+jmacro support";

12 description = "hsp+jmacro support";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/hsyslog.nix.golden+3−6

@@ -1,11 +1,8 @@

1−{ mkDerivation, base, Cabal, cabal-doctest, doctest, fetchurl }:

1+{ mkDerivation, base, Cabal, cabal-doctest, doctest, stdenv }:

2mkDerivation {

3 pname = "hsyslog";

4 version = "5.0.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 isLibrary = true;

6 isLibrary = true;

10 isExecutable = true;

7 isExecutable = true;

11 setupHaskellDepends = [ base Cabal cabal-doctest ];

8 setupHaskellDepends = [ base Cabal cabal-doctest ];

@@ -14,4 +11,4 @@ mkDerivation {

14 homepage = "http://github.com/peti/hsyslog";

11 homepage = "http://github.com/peti/hsyslog";

15 description = "FFI interface to syslog(3) from POSIX.1-2001";

12 description = "FFI interface to syslog(3) from POSIX.1-2001";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/htoml.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, aeson, base, bytestring, containers, criterion

2−, fetchurl, file-embed, old-locale, parsec, tasty, tasty-hspec

2+, file-embed, old-locale, parsec, stdenv, tasty, tasty-hspec

3, tasty-hunit, text, time, unordered-containers, vector

4}:

5mkDerivation {

6 pname = "htoml";

7 version = "1.0.0.3";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 aeson base containers old-locale parsec text time

10 aeson base containers old-locale parsec text time

14 unordered-containers vector

11 unordered-containers vector

@@ -24,4 +21,4 @@ mkDerivation {

24 homepage = "https://github.com/cies/htoml";

21 homepage = "https://github.com/cies/htoml";

25 description = "Parser for TOML files";

22 description = "Parser for TOML files";

26 license = stdenv.lib.licenses.bsd3;

23 license = stdenv.lib.licenses.bsd3;

27−}

24+}

test/golden-test-cases/http-conduit.nix.golden+6−8

@@ -1,17 +1,15 @@

1{ mkDerivation, aeson, base, blaze-builder, bytestring

2, case-insensitive, conduit, conduit-extra, connection, cookie

3−, data-default-class, exceptions, fetchurl, hspec, http-client

3+, data-default-class, exceptions, hspec, http-client

4, http-client-tls, http-types, HUnit, lifted-base, monad-control

5−, mtl, network, resourcet, streaming-commons, temporary, text, time

5+, mtl, network, resourcet, stdenv, streaming-commons, temporary

6−, transformers, utf8-string, wai, wai-conduit, warp, warp-tls

6+, text, time, transformers, utf8-string, wai, wai-conduit, warp

7+, warp-tls

7}:

8}:

8mkDerivation {

9mkDerivation {

9 pname = "http-conduit";

10 pname = "http-conduit";

10 version = "2.2.4";

11 version = "2.2.4";

11− src = fetchurl {

12+ sha256 = "deadbeef";

12− url = "http://example.org/";

13− sha256 = "abc";

14− };

15 libraryHaskellDepends = [

13 libraryHaskellDepends = [

16 aeson base bytestring conduit conduit-extra exceptions http-client

14 aeson base bytestring conduit conduit-extra exceptions http-client

17 http-client-tls http-types lifted-base monad-control mtl resourcet

15 http-client-tls http-types lifted-base monad-control mtl resourcet

@@ -28,4 +26,4 @@ mkDerivation {

28 homepage = "http://www.yesodweb.com/book/http-conduit";

26 homepage = "http://www.yesodweb.com/book/http-conduit";

29 description = "HTTP client package with conduit interface and HTTPS support";

27 description = "HTTP client package with conduit interface and HTTPS support";

30 license = stdenv.lib.licenses.bsd3;

28 license = stdenv.lib.licenses.bsd3;

31−}

29+}

test/golden-test-cases/http-link-header.nix.golden+5−7

@@ -1,14 +1,12 @@

1{ mkDerivation, attoparsec, base, bytestring, bytestring-conversion

2−, criterion, directory, errors, fetchurl, hspec, hspec-attoparsec

2+, criterion, directory, errors, hspec, hspec-attoparsec

3−, http-api-data, network-uri, QuickCheck, text, transformers

3+, http-api-data, network-uri, QuickCheck, stdenv, text

4+, transformers

4}:

5}:

5mkDerivation {

6mkDerivation {

6 pname = "http-link-header";

7 pname = "http-link-header";

7 version = "1.0.3";

8 version = "1.0.3";

8− src = fetchurl {

9+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

10 libraryHaskellDepends = [

13 attoparsec base bytestring bytestring-conversion errors

11 attoparsec base bytestring bytestring-conversion errors

14 http-api-data network-uri text

12 http-api-data network-uri text

@@ -22,4 +20,4 @@ mkDerivation {

22 homepage = "https://github.com/myfreeweb/http-link-header";

20 homepage = "https://github.com/myfreeweb/http-link-header";

23 description = "A parser and writer for the HTTP Link header as specified in RFC 5988 \"Web Linking\"";

21 description = "A parser and writer for the HTTP Link header as specified in RFC 5988 \"Web Linking\"";

24 license = stdenv.lib.licenses.publicDomain;

22 license = stdenv.lib.licenses.publicDomain;

25−}

23+}

test/golden-test-cases/http-media.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, base, bytestring, case-insensitive, containers

2−, fetchurl, QuickCheck, test-framework, test-framework-quickcheck2

2+, QuickCheck, stdenv, test-framework, test-framework-quickcheck2

3, utf8-string

4}:

5mkDerivation {

6 pname = "http-media";

7 version = "0.7.1.1";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 base bytestring case-insensitive containers utf8-string

10 base bytestring case-insensitive containers utf8-string

14 ];

11 ];

@@ -19,4 +16,4 @@ mkDerivation {

19 homepage = "https://github.com/zmthy/http-media";

16 homepage = "https://github.com/zmthy/http-media";

20 description = "Processing HTTP Content-Type and Accept headers";

17 description = "Processing HTTP Content-Type and Accept headers";

21 license = stdenv.lib.licenses.mit;

18 license = stdenv.lib.licenses.mit;

22−}

19+}

test/golden-test-cases/hxt-charproperties.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl }:

1+{ mkDerivation, base, stdenv }:

2mkDerivation {

3 pname = "hxt-charproperties";

4 version = "9.2.0.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 homepage = "https://github.com/UweSchmidt/hxt";

7 homepage = "https://github.com/UweSchmidt/hxt";

11 description = "Character properties and classes for XML and Unicode";

8 description = "Character properties and classes for XML and Unicode";

12 license = stdenv.lib.licenses.mit;

9 license = stdenv.lib.licenses.mit;

13−}

10+}

test/golden-test-cases/hxt-expat.nix.golden+4−6

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, bytestring, fetchurl, hexpat, hxt }:

1+{ mkDerivation, base, bytestring, hexpat, hxt, stdenv }:

2mkDerivation {

3 pname = "hxt-expat";

4 version = "9.1.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base bytestring hexpat hxt ];

6 libraryHaskellDepends = [ base bytestring hexpat hxt ];

10 homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";

7 homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";

11 description = "Expat parser for HXT";

8 description = "Expat parser for HXT";

12 license = "unknown";

9 license = "unknown";

13−}

10+ hydraPlatforms = stdenv.lib.platforms.none;

11+}

test/golden-test-cases/hxt-tagsoup.nix.golden+5−7

@@ -1,17 +1,15 @@

1−{ mkDerivation, base, fetchurl, hxt, hxt-charproperties

1+{ mkDerivation, base, hxt, hxt-charproperties, hxt-unicode, stdenv

2−, hxt-unicode, tagsoup

2+, tagsoup

3}:

4mkDerivation {

5 pname = "hxt-tagsoup";

6 version = "9.1.4";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base hxt hxt-charproperties hxt-unicode tagsoup

9 base hxt hxt-charproperties hxt-unicode tagsoup

13 ];

10 ];

14 homepage = "https://github.com/UweSchmidt/hxt";

11 homepage = "https://github.com/UweSchmidt/hxt";

15 description = "TagSoup parser for HXT";

12 description = "TagSoup parser for HXT";

16 license = "unknown";

13 license = "unknown";

17−}

14+ hydraPlatforms = stdenv.lib.platforms.none;

15+}

test/golden-test-cases/iconv.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, base, bytestring, fetchurl }:

1+{ mkDerivation, base, bytestring, stdenv }:

2mkDerivation {

3 pname = "iconv";

4 version = "0.4.1.3";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base bytestring ];

6 libraryHaskellDepends = [ base bytestring ];

10 description = "String encoding conversion";

7 description = "String encoding conversion";

11 license = stdenv.lib.licenses.bsd3;

8 license = stdenv.lib.licenses.bsd3;

12−}

9+}

test/golden-test-cases/incremental-parser.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, base, bytestring, checkers, criterion, deepseq

2−, fetchurl, monoid-subclasses, QuickCheck, tasty, tasty-quickcheck

2+, monoid-subclasses, QuickCheck, stdenv, tasty, tasty-quickcheck

3, text

4}:

5mkDerivation {

6 pname = "incremental-parser";

7 version = "0.2.5.2";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [ base monoid-subclasses ];

9 libraryHaskellDepends = [ base monoid-subclasses ];

13 testHaskellDepends = [

10 testHaskellDepends = [

14 base checkers monoid-subclasses QuickCheck tasty tasty-quickcheck

11 base checkers monoid-subclasses QuickCheck tasty tasty-quickcheck

@@ -19,4 +16,4 @@ mkDerivation {

19 homepage = "https://github.com/blamario/incremental-parser";

16 homepage = "https://github.com/blamario/incremental-parser";

20 description = "Generic parser library capable of providing partial results from partial input";

17 description = "Generic parser library capable of providing partial results from partial input";

21 license = "GPL";

18 license = "GPL";

22−}

19+}

test/golden-test-cases/indentation-core.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, mtl }:

1+{ mkDerivation, base, mtl, stdenv }:

2mkDerivation {

3 pname = "indentation-core";

4 version = "0.0.0.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base mtl ];

6 libraryHaskellDepends = [ base mtl ];

10 homepage = "https://bitbucket.org/adamsmd/indentation";

7 homepage = "https://bitbucket.org/adamsmd/indentation";

11 description = "Indentation sensitive parsing combinators core library";

8 description = "Indentation sensitive parsing combinators core library";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/indentation-parsec.nix.golden+4−7

@@ -1,16 +1,13 @@

1−{ mkDerivation, base, fetchurl, indentation-core, mtl, parsec

1+{ mkDerivation, base, indentation-core, mtl, parsec, stdenv, tasty

2−, tasty, tasty-hunit

2+, tasty-hunit

3}:

4mkDerivation {

5 pname = "indentation-parsec";

6 version = "0.0.0.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base indentation-core mtl parsec ];

8 libraryHaskellDepends = [ base indentation-core mtl parsec ];

12 testHaskellDepends = [ base parsec tasty tasty-hunit ];

9 testHaskellDepends = [ base parsec tasty tasty-hunit ];

13 homepage = "https://bitbucket.org/adamsmd/indentation";

10 homepage = "https://bitbucket.org/adamsmd/indentation";

14 description = "Indentation sensitive parsing combinators for Parsec";

11 description = "Indentation sensitive parsing combinators for Parsec";

15 license = stdenv.lib.licenses.bsd3;

12 license = stdenv.lib.licenses.bsd3;

16−}

13+}

test/golden-test-cases/inline-c-cpp.nix.golden+3−6

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, fetchurl, hspec, inline-c, safe-exceptions

1+{ mkDerivation, base, hspec, inline-c, safe-exceptions, stdenv

2, template-haskell

3}:

4mkDerivation {

5 pname = "inline-c-cpp";

6 version = "0.2.1.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base inline-c safe-exceptions template-haskell

9 base inline-c safe-exceptions template-haskell

13 ];

10 ];

14 testHaskellDepends = [ base hspec inline-c safe-exceptions ];

11 testHaskellDepends = [ base hspec inline-c safe-exceptions ];

15 description = "Lets you embed C++ code into Haskell";

12 description = "Lets you embed C++ code into Haskell";

16 license = stdenv.lib.licenses.mit;

13 license = stdenv.lib.licenses.mit;

17−}

14+}

test/golden-test-cases/integer-logarithms.nix.golden+4−7

@@ -1,14 +1,11 @@

1−{ mkDerivation, array, base, fetchurl, ghc-prim, integer-gmp

1+{ mkDerivation, array, base, ghc-prim, integer-gmp, QuickCheck

2−, QuickCheck, smallcheck, tasty, tasty-hunit, tasty-quickcheck

2+, smallcheck, stdenv, tasty, tasty-hunit, tasty-quickcheck

3, tasty-smallcheck

4}:

5mkDerivation {

6 pname = "integer-logarithms";

7 version = "1.0.2";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [ array base ghc-prim integer-gmp ];

9 libraryHaskellDepends = [ array base ghc-prim integer-gmp ];

13 testHaskellDepends = [

10 testHaskellDepends = [

14 base QuickCheck smallcheck tasty tasty-hunit tasty-quickcheck

11 base QuickCheck smallcheck tasty tasty-hunit tasty-quickcheck

@@ -17,4 +14,4 @@ mkDerivation {

17 homepage = "https://github.com/phadej/integer-logarithms";

14 homepage = "https://github.com/phadej/integer-logarithms";

18 description = "Integer logarithms";

15 description = "Integer logarithms";

19 license = stdenv.lib.licenses.mit;

16 license = stdenv.lib.licenses.mit;

20−}

17+}

test/golden-test-cases/intero.nix.golden+4−7

@@ -1,15 +1,12 @@

1{ mkDerivation, array, base, bytestring, containers, directory

2−, fetchurl, filepath, ghc, ghc-boot-th, ghc-paths, ghci, haskeline

2+, filepath, ghc, ghc-boot-th, ghc-paths, ghci, haskeline, hspec

3−, hspec, process, regex-compat, syb, temporary, time, transformers

3+, process, regex-compat, stdenv, syb, temporary, time, transformers

4, unix

5}:

6mkDerivation {

7 pname = "intero";

8 version = "0.1.24";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 isLibrary = false;

10 isLibrary = false;

14 isExecutable = true;

11 isExecutable = true;

15 enableSeparateDataOutput = true;

12 enableSeparateDataOutput = true;

@@ -24,4 +21,4 @@ mkDerivation {

24 homepage = "https://github.com/commercialhaskell/intero";

21 homepage = "https://github.com/commercialhaskell/intero";

25 description = "Complete interactive development program for Haskell";

22 description = "Complete interactive development program for Haskell";

26 license = stdenv.lib.licenses.bsd3;

23 license = stdenv.lib.licenses.bsd3;

27−}

24+}

test/golden-test-cases/invariant.nix.golden+4−7

@@ -1,16 +1,13 @@

1{ mkDerivation, array, base, bifunctors, comonad, containers

2−, contravariant, fetchurl, ghc-prim, hspec, profunctors, QuickCheck

2+, contravariant, ghc-prim, hspec, profunctors, QuickCheck

3−, semigroups, StateVar, stm, tagged, template-haskell

3+, semigroups, StateVar, stdenv, stm, tagged, template-haskell

4, th-abstraction, transformers, transformers-compat

5, unordered-containers

6}:

7mkDerivation {

8 pname = "invariant";

9 version = "0.5";

10− src = fetchurl {

10+ sha256 = "deadbeef";

11− url = "http://example.org/";

12− sha256 = "abc";

13− };

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

15 array base bifunctors comonad containers contravariant ghc-prim

12 array base bifunctors comonad containers contravariant ghc-prim

16 profunctors semigroups StateVar stm tagged template-haskell

13 profunctors semigroups StateVar stm tagged template-haskell

@@ -21,4 +18,4 @@ mkDerivation {

21 homepage = "https://github.com/nfrisby/invariant-functors";

18 homepage = "https://github.com/nfrisby/invariant-functors";

22 description = "Haskell98 invariant functors";

19 description = "Haskell98 invariant functors";

23 license = stdenv.lib.licenses.bsd2;

20 license = stdenv.lib.licenses.bsd2;

24−}

21+}

test/golden-test-cases/io-machine.nix.golden+3−6

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, fetchurl, time }:

1+{ mkDerivation, base, stdenv, time }:

2mkDerivation {

3 pname = "io-machine";

4 version = "0.2.0.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base time ];

6 libraryHaskellDepends = [ base time ];

10 testHaskellDepends = [ base ];

7 testHaskellDepends = [ base ];

11 homepage = "https://github.com/YoshikuniJujo/io-machine#readme";

8 homepage = "https://github.com/YoshikuniJujo/io-machine#readme";

12 description = "Easy I/O model to learn IO monad";

9 description = "Easy I/O model to learn IO monad";

13 license = stdenv.lib.licenses.bsd3;

10 license = stdenv.lib.licenses.bsd3;

14−}

11+}

test/golden-test-cases/io-streams-haproxy.nix.golden+4−7

@@ -1,14 +1,11 @@

1−{ mkDerivation, attoparsec, base, bytestring, fetchurl, HUnit

1+{ mkDerivation, attoparsec, base, bytestring, HUnit, io-streams

2−, io-streams, network, test-framework, test-framework-hunit

2+, network, stdenv, test-framework, test-framework-hunit

3, transformers

4}:

5mkDerivation {

6 pname = "io-streams-haproxy";

7 version = "1.0.0.2";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 attoparsec base bytestring io-streams network transformers

10 attoparsec base bytestring io-streams network transformers

14 ];

11 ];

@@ -19,4 +16,4 @@ mkDerivation {

19 homepage = "http://snapframework.com/";

16 homepage = "http://snapframework.com/";

20 description = "HAProxy protocol 1.5 support for io-streams";

17 description = "HAProxy protocol 1.5 support for io-streams";

21 license = stdenv.lib.licenses.bsd3;

18 license = stdenv.lib.licenses.bsd3;

22−}

19+}

test/golden-test-cases/ip.nix.golden+4−7

@@ -1,15 +1,12 @@

1{ mkDerivation, aeson, attoparsec, base, bytestring, criterion

2−, doctest, fetchurl, hashable, HUnit, primitive, QuickCheck

2+, doctest, hashable, HUnit, primitive, QuickCheck

3−, quickcheck-classes, test-framework, test-framework-hunit

3+, quickcheck-classes, stdenv, test-framework, test-framework-hunit

4, test-framework-quickcheck2, text, vector

5}:

6mkDerivation {

7 pname = "ip";

8 version = "1.1.1";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

14 aeson attoparsec base bytestring hashable primitive text vector

11 aeson attoparsec base bytestring hashable primitive text vector

15 ];

12 ];

@@ -24,4 +21,4 @@ mkDerivation {

24 homepage = "https://github.com/andrewthad/haskell-ip#readme";

21 homepage = "https://github.com/andrewthad/haskell-ip#readme";

25 description = "Library for IP and MAC addresses";

22 description = "Library for IP and MAC addresses";

26 license = stdenv.lib.licenses.bsd3;

23 license = stdenv.lib.licenses.bsd3;

27−}

24+}

test/golden-test-cases/iso639.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl }:

1+{ mkDerivation, base, stdenv }:

2mkDerivation {

3 pname = "iso639";

4 version = "0.1.0.3";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 homepage = "https://github.com/HugoDaniel/iso639";

7 homepage = "https://github.com/HugoDaniel/iso639";

11 description = "ISO-639-1 language codes";

8 description = "ISO-639-1 language codes";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/iso8601-time.nix.golden+3−6

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, fetchurl, hspec, HUnit, time }:

1+{ mkDerivation, base, hspec, HUnit, stdenv, time }:

2mkDerivation {

3 pname = "iso8601-time";

4 version = "0.1.4";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base time ];

6 libraryHaskellDepends = [ base time ];

10 testHaskellDepends = [ base hspec HUnit time ];

7 testHaskellDepends = [ base hspec HUnit time ];

11 homepage = "https://github.com/nh2/iso8601-time";

8 homepage = "https://github.com/nh2/iso8601-time";

12 description = "Convert to/from the ISO 8601 time format";

9 description = "Convert to/from the ISO 8601 time format";

13 license = stdenv.lib.licenses.mit;

10 license = stdenv.lib.licenses.mit;

14−}

11+}

test/golden-test-cases/jmacro-rpc-happstack.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, aeson, base, blaze-html, bytestring, containers

2−, fetchurl, happstack-server, jmacro, jmacro-rpc, mtl

2+, happstack-server, jmacro, jmacro-rpc, mtl, stdenv

3}:

4mkDerivation {

5 pname = "jmacro-rpc-happstack";

6 version = "0.3.2";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 aeson base blaze-html bytestring containers happstack-server jmacro

9 aeson base blaze-html bytestring containers happstack-server jmacro

13 jmacro-rpc mtl

10 jmacro-rpc mtl

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "http://hub.darcs.net/gershomb/jmacro-rpc";

12 homepage = "http://hub.darcs.net/gershomb/jmacro-rpc";

16 description = "Happstack backend for jmacro-rpc";

13 description = "Happstack backend for jmacro-rpc";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/jmacro-rpc.nix.golden+4−7

@@ -1,14 +1,11 @@

1{ mkDerivation, aeson, attoparsec, base, blaze-html, bytestring

2−, containers, contravariant, fetchurl, jmacro, mtl, scientific

2+, containers, contravariant, jmacro, mtl, scientific, split, stdenv

3−, split, text, unordered-containers, vector

3+, text, unordered-containers, vector

4}:

5mkDerivation {

6 pname = "jmacro-rpc";

7 version = "0.3.2";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 aeson attoparsec base blaze-html bytestring containers

10 aeson attoparsec base blaze-html bytestring containers

14 contravariant jmacro mtl scientific split text unordered-containers

11 contravariant jmacro mtl scientific split text unordered-containers

@@ -17,4 +14,4 @@ mkDerivation {

17 homepage = "http://hub.darcs.net/gershomb/jmacro";

14 homepage = "http://hub.darcs.net/gershomb/jmacro";

18 description = "JSON-RPC clients and servers using JMacro, and evented client-server Reactive Programming";

15 description = "JSON-RPC clients and servers using JMacro, and evented client-server Reactive Programming";

19 license = stdenv.lib.licenses.bsd3;

16 license = stdenv.lib.licenses.bsd3;

20−}

17+}

test/golden-test-cases/jose.nix.golden+6−10

@@ -1,17 +1,13 @@

1{ mkDerivation, aeson, attoparsec, base, base64-bytestring

2−, bytestring, concise, containers, cryptonite, fetchurl, hspec

2+, bytestring, concise, containers, cryptonite, hspec, lens, memory

3−, lens, memory, monad-time, mtl, network-uri, QuickCheck

3+, monad-time, mtl, network-uri, QuickCheck, quickcheck-instances

4−, quickcheck-instances, safe, semigroups, tasty, tasty-hspec

4+, safe, semigroups, stdenv, tasty, tasty-hspec, tasty-quickcheck

5−, tasty-quickcheck, template-haskell, text, time

5+, template-haskell, text, time, unordered-containers, vector, x509

6−, unordered-containers, vector, x509

7}:

6}:

8mkDerivation {

7mkDerivation {

9 pname = "jose";

8 pname = "jose";

10 version = "0.6.0.3";

9 version = "0.6.0.3";

11− src = fetchurl {

10+ sha256 = "deadbeef";

12− url = "http://example.org/";

13− sha256 = "abc";

14− };

15 isLibrary = true;

11 isLibrary = true;

16 isExecutable = true;

12 isExecutable = true;

17 libraryHaskellDepends = [

13 libraryHaskellDepends = [

@@ -31,4 +27,4 @@ mkDerivation {

31 homepage = "https://github.com/frasertweedale/hs-jose";

27 homepage = "https://github.com/frasertweedale/hs-jose";

32 description = "Javascript Object Signing and Encryption and JSON Web Token library";

28 description = "Javascript Object Signing and Encryption and JSON Web Token library";

33 license = stdenv.lib.licenses.asl20;

29 license = stdenv.lib.licenses.asl20;

34−}

30+}

test/golden-test-cases/katip-elasticsearch.nix.golden+6−9

@@ -1,17 +1,14 @@

1{ mkDerivation, aeson, async, base, bloodhound, bytestring

2, containers, criterion, deepseq, enclosed-exceptions, exceptions

3−, fetchurl, http-client, http-types, katip, lens, lens-aeson

3+, http-client, http-types, katip, lens, lens-aeson

4−, quickcheck-instances, random, retry, scientific, stm, stm-chans

4+, quickcheck-instances, random, retry, scientific, stdenv, stm

5−, tagged, tasty, tasty-hunit, tasty-quickcheck, text, time

5+, stm-chans, tagged, tasty, tasty-hunit, tasty-quickcheck, text

6−, transformers, unordered-containers, uuid, vector

6+, time, transformers, unordered-containers, uuid, vector

7}:

8mkDerivation {

9 pname = "katip-elasticsearch";

10 version = "0.4.0.3";

11− src = fetchurl {

11+ sha256 = "deadbeef";

12− url = "http://example.org/";

13− sha256 = "abc";

14− };

15 libraryHaskellDepends = [

12 libraryHaskellDepends = [

16 aeson async base bloodhound bytestring enclosed-exceptions

13 aeson async base bloodhound bytestring enclosed-exceptions

17 exceptions http-client http-types katip retry scientific stm

14 exceptions http-client http-types katip retry scientific stm

@@ -30,4 +27,4 @@ mkDerivation {

30 homepage = "https://github.com/Soostone/katip";

27 homepage = "https://github.com/Soostone/katip";

31 description = "ElasticSearch scribe for the Katip logging framework";

28 description = "ElasticSearch scribe for the Katip logging framework";

32 license = stdenv.lib.licenses.bsd3;

29 license = stdenv.lib.licenses.bsd3;

33−}

30+}

test/golden-test-cases/katip.nix.golden+6−9

@@ -1,9 +1,9 @@

1{ mkDerivation, aeson, async, auto-update, base, blaze-builder

2, bytestring, containers, criterion, deepseq, directory, either

3−, fetchurl, filepath, hostname, microlens, microlens-th

3+, filepath, hostname, microlens, microlens-th, monad-control, mtl

4−, monad-control, mtl, old-locale, quickcheck-instances, regex-tdfa

4+, old-locale, quickcheck-instances, regex-tdfa, resourcet

5−, resourcet, safe-exceptions, scientific, semigroups, stm

5+, safe-exceptions, scientific, semigroups, stdenv, stm, string-conv

6−, string-conv, tasty, tasty-golden, tasty-hunit, tasty-quickcheck

6+, tasty, tasty-golden, tasty-hunit, tasty-quickcheck

7, template-haskell, text, time, time-locale-compat, transformers

8, transformers-base, transformers-compat, unix

9, unordered-containers

@@ -11,10 +11,7 @@

11mkDerivation {

12 pname = "katip";

13 version = "0.5.2.0";

14− src = fetchurl {

14+ sha256 = "deadbeef";

15− url = "http://example.org/";

16− sha256 = "abc";

17− };

18 libraryHaskellDepends = [

15 libraryHaskellDepends = [

19 aeson async auto-update base bytestring containers either hostname

16 aeson async auto-update base bytestring containers either hostname

20 microlens microlens-th monad-control mtl old-locale resourcet

17 microlens microlens-th monad-control mtl old-locale resourcet

@@ -35,4 +32,4 @@ mkDerivation {

35 homepage = "https://github.com/Soostone/katip";

32 homepage = "https://github.com/Soostone/katip";

36 description = "A structured logging framework";

33 description = "A structured logging framework";

37 license = stdenv.lib.licenses.bsd3;

34 license = stdenv.lib.licenses.bsd3;

38−}

35+}

test/golden-test-cases/katydid.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, containers, directory, fetchurl, filepath

1+{ mkDerivation, base, containers, directory, filepath, HUnit, hxt

2−, HUnit, hxt, json, mtl, parsec, regex-tdfa, tasty, tasty-hunit

2+, json, mtl, parsec, regex-tdfa, stdenv, tasty, tasty-hunit

3}:

4mkDerivation {

5 pname = "katydid";

6 version = "0.1.1.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 isLibrary = true;

8 isLibrary = true;

12 isExecutable = true;

9 isExecutable = true;

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

@@ -21,4 +18,4 @@ mkDerivation {

21 homepage = "https://github.com/katydid/katydid-haskell";

18 homepage = "https://github.com/katydid/katydid-haskell";

22 description = "A haskell implementation of Katydid";

19 description = "A haskell implementation of Katydid";

23 license = stdenv.lib.licenses.bsd3;

20 license = stdenv.lib.licenses.bsd3;

24−}

21+}

test/golden-test-cases/kawhi.nix.golden+6−9

@@ -1,15 +1,12 @@

1−{ mkDerivation, aeson, base, bytestring, exceptions, fetchurl

1+{ mkDerivation, aeson, base, bytestring, exceptions, http-client

2−, http-client, http-conduit, http-types, mtl, safe, scientific

2+, http-conduit, http-types, mtl, safe, scientific, smallcheck

3−, smallcheck, tasty, tasty-hunit, tasty-quickcheck

3+, stdenv, tasty, tasty-hunit, tasty-quickcheck, tasty-smallcheck

4−, tasty-smallcheck, text

4+, text

5}:

6mkDerivation {

7 pname = "kawhi";

8 version = "0.3.0";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

14 aeson base bytestring exceptions http-client http-conduit

11 aeson base bytestring exceptions http-client http-conduit

15 http-types mtl safe scientific text

12 http-types mtl safe scientific text

@@ -22,4 +19,4 @@ mkDerivation {

22 homepage = "https://github.com/thunky-monk/kawhi";

19 homepage = "https://github.com/thunky-monk/kawhi";

23 description = "stats.NBA.com library";

20 description = "stats.NBA.com library";

24 license = stdenv.lib.licenses.mit;

21 license = stdenv.lib.licenses.mit;

25−}

22+}

test/golden-test-cases/kraken.nix.golden+4−7

@@ -1,16 +1,13 @@

1−{ mkDerivation, aeson, base, bytestring, fetchurl, http-client

1+{ mkDerivation, aeson, base, bytestring, http-client

2−, http-client-tls, mtl

2+, http-client-tls, mtl, stdenv

3}:

4mkDerivation {

5 pname = "kraken";

6 version = "0.1.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 aeson base bytestring http-client http-client-tls mtl

9 aeson base bytestring http-client http-client-tls mtl

13 ];

10 ];

14 description = "Kraken.io API client";

11 description = "Kraken.io API client";

15 license = stdenv.lib.licenses.mit;

12 license = stdenv.lib.licenses.mit;

16−}

13+}

test/golden-test-cases/l10n.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, text, time }:

1+{ mkDerivation, base, stdenv, text, time }:

2mkDerivation {

3 pname = "l10n";

4 version = "0.1.0.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base text time ];

6 libraryHaskellDepends = [ base text time ];

10 homepage = "https://github.com/louispan/l10n#readme";

7 homepage = "https://github.com/louispan/l10n#readme";

11 description = "Enables providing localization as typeclass instances in separate files";

8 description = "Enables providing localization as typeclass instances in separate files";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/lambdabot-social-plugins.nix.golden+4−7

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, binary, bytestring, containers, fetchurl

1+{ mkDerivation, base, binary, bytestring, containers

2−, lambdabot-core, mtl, split, time

2+, lambdabot-core, mtl, split, stdenv, time

3}:

4mkDerivation {

5 pname = "lambdabot-social-plugins";

6 version = "5.1.0.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base binary bytestring containers lambdabot-core mtl split time

9 base binary bytestring containers lambdabot-core mtl split time

13 ];

10 ];

14 homepage = "https://wiki.haskell.org/Lambdabot";

11 homepage = "https://wiki.haskell.org/Lambdabot";

15 description = "Social plugins for Lambdabot";

12 description = "Social plugins for Lambdabot";

16 license = "GPL";

13 license = "GPL";

17−}

14+}

test/golden-test-cases/lazy-csv.nix.golden+3−6

@@ -1,11 +1,8 @@

1−{ mkDerivation, base, bytestring, fetchurl }:

1+{ mkDerivation, base, bytestring, stdenv }:

2mkDerivation {

3 pname = "lazy-csv";

4 version = "0.5.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 isLibrary = true;

6 isLibrary = true;

10 isExecutable = true;

7 isExecutable = true;

11 libraryHaskellDepends = [ base bytestring ];

8 libraryHaskellDepends = [ base bytestring ];

@@ -13,4 +10,4 @@ mkDerivation {

13 homepage = "http://code.haskell.org/lazy-csv";

10 homepage = "http://code.haskell.org/lazy-csv";

14 description = "Efficient lazy parsers for CSV (comma-separated values)";

11 description = "Efficient lazy parsers for CSV (comma-separated values)";

15 license = stdenv.lib.licenses.bsd3;

12 license = stdenv.lib.licenses.bsd3;

16−}

13+}

test/golden-test-cases/lens-aeson.nix.golden+5−8

@@ -1,15 +1,12 @@

1{ mkDerivation, aeson, attoparsec, base, bytestring, Cabal

2−, cabal-doctest, doctest, fetchurl, generic-deriving, lens

2+, cabal-doctest, doctest, generic-deriving, lens, scientific

3−, scientific, semigroups, simple-reflect, text

3+, semigroups, simple-reflect, stdenv, text, unordered-containers

4−, unordered-containers, vector

4+, vector

5}:

6mkDerivation {

7 pname = "lens-aeson";

8 version = "1.0.2";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 setupHaskellDepends = [ base Cabal cabal-doctest ];

10 setupHaskellDepends = [ base Cabal cabal-doctest ];

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

15 aeson attoparsec base bytestring lens scientific text

12 aeson attoparsec base bytestring lens scientific text

@@ -21,4 +18,4 @@ mkDerivation {

21 homepage = "http://github.com/lens/lens-aeson/";

18 homepage = "http://github.com/lens/lens-aeson/";

22 description = "Law-abiding lenses for aeson";

19 description = "Law-abiding lenses for aeson";

23 license = stdenv.lib.licenses.mit;

20 license = stdenv.lib.licenses.mit;

24−}

21+}

test/golden-test-cases/lens.nix.golden+6−9

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

1{ mkDerivation, array, base, base-orphans, bifunctors, bytestring

2, Cabal, cabal-doctest, call-stack, comonad, containers

3, contravariant, criterion, deepseq, directory, distributive

4−, doctest, exceptions, fetchurl, filepath, free, generic-deriving

4+, doctest, exceptions, filepath, free, generic-deriving, ghc-prim

5−, ghc-prim, hashable, HUnit, kan-extensions, mtl, nats, parallel

5+, hashable, HUnit, kan-extensions, mtl, nats, parallel, profunctors

6−, profunctors, QuickCheck, reflection, semigroupoids, semigroups

6+, QuickCheck, reflection, semigroupoids, semigroups, simple-reflect

7−, simple-reflect, tagged, template-haskell, test-framework

7+, stdenv, tagged, template-haskell, test-framework

8, test-framework-hunit, test-framework-quickcheck2

9, test-framework-th, text, th-abstraction, transformers

10, transformers-compat, unordered-containers, vector, void

@@ -12,10 +12,7 @@

12mkDerivation {

13 pname = "lens";

14 version = "4.15.4";

15− src = fetchurl {

15+ sha256 = "deadbeef";

16− url = "http://example.org/";

17− sha256 = "abc";

18− };

19 setupHaskellDepends = [ base Cabal cabal-doctest filepath ];

16 setupHaskellDepends = [ base Cabal cabal-doctest filepath ];

20 libraryHaskellDepends = [

17 libraryHaskellDepends = [

21 array base base-orphans bifunctors bytestring call-stack comonad

18 array base base-orphans bifunctors bytestring call-stack comonad

@@ -39,4 +36,4 @@ mkDerivation {

39 homepage = "http://github.com/ekmett/lens/";

36 homepage = "http://github.com/ekmett/lens/";

40 description = "Lenses, Folds and Traversals";

37 description = "Lenses, Folds and Traversals";

41 license = stdenv.lib.licenses.bsd2;

38 license = stdenv.lib.licenses.bsd2;

42−}

39+}

test/golden-test-cases/libgit.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, mtl, process }:

1+{ mkDerivation, base, mtl, process, stdenv }:

2mkDerivation {

3 pname = "libgit";

4 version = "0.3.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base mtl process ];

6 libraryHaskellDepends = [ base mtl process ];

10 homepage = "https://github.com/vincenthz/hs-libgit";

7 homepage = "https://github.com/vincenthz/hs-libgit";

11 description = "Simple Git Wrapper";

8 description = "Simple Git Wrapper";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/librato.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, aeson, attoparsec, base, bytestring, either

2−, fetchurl, http-client, http-conduit, http-types, mtl, resourcet

2+, http-client, http-conduit, http-types, mtl, resourcet, stdenv

3, text, unordered-containers, uri-templater, vector

4}:

5mkDerivation {

6 pname = "librato";

7 version = "0.2.0.1";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 aeson attoparsec base bytestring either http-client http-conduit

10 aeson attoparsec base bytestring either http-client http-conduit

14 http-types mtl resourcet text unordered-containers uri-templater

11 http-types mtl resourcet text unordered-containers uri-templater

@@ -17,4 +14,4 @@ mkDerivation {

17 homepage = "https://github.com/SaneTracker/librato";

14 homepage = "https://github.com/SaneTracker/librato";

18 description = "Bindings to the Librato API";

15 description = "Bindings to the Librato API";

19 license = stdenv.lib.licenses.mit;

16 license = stdenv.lib.licenses.mit;

20−}

17+}

test/golden-test-cases/lifted-async.nix.golden+5−8

@@ -1,14 +1,11 @@

1−{ mkDerivation, async, base, constraints, criterion, deepseq

1+{ mkDerivation, async, base, constraints, criterion, deepseq, HUnit

2−, fetchurl, HUnit, lifted-base, monad-control, mtl, tasty

2+, lifted-base, monad-control, mtl, stdenv, tasty, tasty-hunit

3−, tasty-hunit, tasty-th, transformers-base

3+, tasty-th, transformers-base

4}:

5mkDerivation {

6 pname = "lifted-async";

7 version = "0.9.3.2";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 async base constraints lifted-base monad-control transformers-base

10 async base constraints lifted-base monad-control transformers-base

14 ];

11 ];

@@ -20,4 +17,4 @@ mkDerivation {

20 homepage = "https://github.com/maoe/lifted-async";

17 homepage = "https://github.com/maoe/lifted-async";

21 description = "Run lifted IO operations asynchronously and wait for their results";

18 description = "Run lifted IO operations asynchronously and wait for their results";

22 license = stdenv.lib.licenses.bsd3;

19 license = stdenv.lib.licenses.bsd3;

23−}

20+}

test/golden-test-cases/lmdb.nix.golden+3−6

@@ -1,14 +1,11 @@

1−{ mkDerivation, array, base, fetchurl, lmdb }:

1+{ mkDerivation, array, base, lmdb, stdenv }:

2mkDerivation {

3 pname = "lmdb";

4 version = "0.2.5";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ array base ];

6 libraryHaskellDepends = [ array base ];

10 librarySystemDepends = [ lmdb ];

7 librarySystemDepends = [ lmdb ];

11 homepage = "http://github.com/dmbarbour/haskell-lmdb";

8 homepage = "http://github.com/dmbarbour/haskell-lmdb";

12 description = "Lightning MDB bindings";

9 description = "Lightning MDB bindings";

13 license = stdenv.lib.licenses.bsd2;

10 license = stdenv.lib.licenses.bsd2;

14−}

11+}

test/golden-test-cases/logging-effect-extra-file.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, logging-effect, template-haskell

1+{ mkDerivation, base, logging-effect, stdenv, template-haskell

2, wl-pprint-text

3}:

4mkDerivation {

5 pname = "logging-effect-extra-file";

6 version = "1.1.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 isLibrary = true;

8 isLibrary = true;

12 isExecutable = true;

9 isExecutable = true;

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

@@ -17,4 +14,4 @@ mkDerivation {

17 homepage = "https://github.com/jship/logging-effect-extra#readme";

14 homepage = "https://github.com/jship/logging-effect-extra#readme";

18 description = "TH splices to augment log messages with file info";

15 description = "TH splices to augment log messages with file info";

19 license = stdenv.lib.licenses.mit;

16 license = stdenv.lib.licenses.mit;

20−}

17+}

test/golden-test-cases/lucid.nix.golden+4−7

@@ -1,14 +1,11 @@

1{ mkDerivation, base, bifunctors, blaze-builder, bytestring

2−, containers, criterion, deepseq, fetchurl, hashable, hspec, HUnit

2+, containers, criterion, deepseq, hashable, hspec, HUnit, mmorph

3−, mmorph, mtl, parsec, text, transformers, unordered-containers

3+, mtl, parsec, stdenv, text, transformers, unordered-containers

4}:

5mkDerivation {

6 pname = "lucid";

7 version = "2.9.9";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 base blaze-builder bytestring containers hashable mmorph mtl text

10 base blaze-builder bytestring containers hashable mmorph mtl text

14 transformers unordered-containers

11 transformers unordered-containers

@@ -22,4 +19,4 @@ mkDerivation {

22 homepage = "https://github.com/chrisdone/lucid";

19 homepage = "https://github.com/chrisdone/lucid";

23 description = "Clear to write, read and edit DSL for HTML";

20 description = "Clear to write, read and edit DSL for HTML";

24 license = stdenv.lib.licenses.bsd3;

21 license = stdenv.lib.licenses.bsd3;

25−}

22+}

test/golden-test-cases/mainland-pretty.nix.golden+3−6

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, containers, fetchurl, srcloc, text

1+{ mkDerivation, base, containers, srcloc, stdenv, text

2, transformers

3}:

4mkDerivation {

5 pname = "mainland-pretty";

6 version = "0.6.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base containers srcloc text transformers

9 base containers srcloc text transformers

13 ];

10 ];

14 homepage = "https://github.com/mainland/mainland-pretty";

11 homepage = "https://github.com/mainland/mainland-pretty";

15 description = "Pretty printing designed for printing source code";

12 description = "Pretty printing designed for printing source code";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/matrices.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, criterion, deepseq, fetchurl, primitive

1+{ mkDerivation, base, criterion, deepseq, primitive, stdenv, tasty

2−, tasty, tasty-hunit, tasty-quickcheck, vector

2+, tasty-hunit, tasty-quickcheck, vector

3}:

4mkDerivation {

5 pname = "matrices";

6 version = "0.4.5";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base deepseq primitive vector ];

8 libraryHaskellDepends = [ base deepseq primitive vector ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 base tasty tasty-hunit tasty-quickcheck vector

10 base tasty tasty-hunit tasty-quickcheck vector

@@ -15,4 +12,4 @@ mkDerivation {

15 benchmarkHaskellDepends = [ base criterion vector ];

12 benchmarkHaskellDepends = [ base criterion vector ];

16 description = "native matrix based on vector";

13 description = "native matrix based on vector";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/median-stream.nix.golden+3−6

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, fetchurl, heap, QuickCheck }:

1+{ mkDerivation, base, heap, QuickCheck, stdenv }:

2mkDerivation {

3 pname = "median-stream";

4 version = "0.7.0.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base heap ];

6 libraryHaskellDepends = [ base heap ];

10 testHaskellDepends = [ base QuickCheck ];

7 testHaskellDepends = [ base QuickCheck ];

11 homepage = "https://github.com/caneroj1/median-stream#readme";

8 homepage = "https://github.com/caneroj1/median-stream#readme";

12 description = "Constant-time queries for the median of a stream of numeric data";

9 description = "Constant-time queries for the median of a stream of numeric data";

13 license = stdenv.lib.licenses.bsd3;

10 license = stdenv.lib.licenses.bsd3;

14−}

11+}

test/golden-test-cases/megaparsec.nix.golden+5−8

@@ -1,15 +1,12 @@

1{ mkDerivation, base, bytestring, case-insensitive, containers

2−, criterion, deepseq, fetchurl, hspec, hspec-expectations, mtl

2+, criterion, deepseq, hspec, hspec-expectations, mtl

3−, parser-combinators, QuickCheck, scientific, text, transformers

3+, parser-combinators, QuickCheck, scientific, stdenv, text

4−, weigh

4+, transformers, weigh

5}:

6mkDerivation {

7 pname = "megaparsec";

8 version = "6.3.0";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

14 base bytestring case-insensitive containers deepseq mtl

11 base bytestring case-insensitive containers deepseq mtl

15 parser-combinators scientific text transformers

12 parser-combinators scientific text transformers

@@ -22,4 +19,4 @@ mkDerivation {

22 homepage = "https://github.com/mrkkrp/megaparsec";

19 homepage = "https://github.com/mrkkrp/megaparsec";

23 description = "Monadic parser combinators";

20 description = "Monadic parser combinators";

24 license = stdenv.lib.licenses.bsd2;

21 license = stdenv.lib.licenses.bsd2;

25−}

22+}

test/golden-test-cases/mersenne-random.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, old-time }:

1+{ mkDerivation, base, old-time, stdenv }:

2mkDerivation {

3 pname = "mersenne-random";

4 version = "1.0.0.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base old-time ];

6 libraryHaskellDepends = [ base old-time ];

10 homepage = "http://code.haskell.org/~dons/code/mersenne-random";

7 homepage = "http://code.haskell.org/~dons/code/mersenne-random";

11 description = "Generate high quality pseudorandom numbers using a SIMD Fast Mersenne Twister";

8 description = "Generate high quality pseudorandom numbers using a SIMD Fast Mersenne Twister";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/messagepack.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, base, bytestring, cereal, containers, deepseq

2−, fetchurl, QuickCheck, test-framework, test-framework-quickcheck2

2+, QuickCheck, stdenv, test-framework, test-framework-quickcheck2

3, test-framework-th

4}:

5mkDerivation {

6 pname = "messagepack";

7 version = "0.5.4";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 base bytestring cereal containers deepseq

10 base bytestring cereal containers deepseq

14 ];

11 ];

@@ -19,4 +16,4 @@ mkDerivation {

19 homepage = "https://github.com/rodrigosetti/messagepack";

16 homepage = "https://github.com/rodrigosetti/messagepack";

20 description = "Serialize instance for Message Pack Object";

17 description = "Serialize instance for Message Pack Object";

21 license = stdenv.lib.licenses.mit;

18 license = stdenv.lib.licenses.mit;

22−}

19+}

test/golden-test-cases/microlens-ghc.nix.golden+4−7

@@ -1,17 +1,14 @@

1−{ mkDerivation, array, base, bytestring, containers, fetchurl

1+{ mkDerivation, array, base, bytestring, containers, microlens

2−, microlens, transformers

2+, stdenv, transformers

3}:

4mkDerivation {

5 pname = "microlens-ghc";

6 version = "0.4.8.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 array base bytestring containers microlens transformers

9 array base bytestring containers microlens transformers

13 ];

10 ];

14 homepage = "http://github.com/aelve/microlens";

11 homepage = "http://github.com/aelve/microlens";

15 description = "microlens + array, bytestring, containers, transformers";

12 description = "microlens + array, bytestring, containers, transformers";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/microlens.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl }:

1+{ mkDerivation, base, stdenv }:

2mkDerivation {

3 pname = "microlens";

4 version = "0.4.8.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 homepage = "http://github.com/aelve/microlens";

7 homepage = "http://github.com/aelve/microlens";

11 description = "A tiny lens library with no dependencies. If you're writing an app, you probably want microlens-platform, not this.";

8 description = "A tiny lens library with no dependencies. If you're writing an app, you probably want microlens-platform, not this.";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/minio-hs.nix.golden+7−11

@@ -1,20 +1,16 @@

1{ mkDerivation, aeson, async, base, base64-bytestring, bytestring

2, case-insensitive, conduit, conduit-combinators, conduit-extra

3, containers, cryptonite, cryptonite-conduit, data-default

4−, directory, exceptions, fetchurl, filepath, http-client

4+, directory, exceptions, filepath, http-client, http-conduit

5−, http-conduit, http-types, lifted-async, lifted-base, memory

5+, http-types, lifted-async, lifted-base, memory, monad-control

6−, monad-control, protolude, QuickCheck, resourcet, tasty

6+, protolude, QuickCheck, resourcet, stdenv, tasty, tasty-hunit

7−, tasty-hunit, tasty-quickcheck, tasty-smallcheck, temporary, text

7+, tasty-quickcheck, tasty-smallcheck, temporary, text, text-format

8−, text-format, time, transformers, transformers-base, vector

8+, time, transformers, transformers-base, vector, xml-conduit

9−, xml-conduit

10}:

9}:

11mkDerivation {

10mkDerivation {

12 pname = "minio-hs";

11 pname = "minio-hs";

13 version = "0.3.2";

12 version = "0.3.2";

14− src = fetchurl {

13+ sha256 = "deadbeef";

15− url = "http://example.org/";

16− sha256 = "abc";

17− };

18 libraryHaskellDepends = [

14 libraryHaskellDepends = [

19 aeson async base base64-bytestring bytestring case-insensitive

15 aeson async base base64-bytestring bytestring case-insensitive

20 conduit conduit-combinators conduit-extra containers cryptonite

16 conduit conduit-combinators conduit-extra containers cryptonite

@@ -35,4 +31,4 @@ mkDerivation {

35 homepage = "https://github.com/minio/minio-hs#readme";

31 homepage = "https://github.com/minio/minio-hs#readme";

36 description = "A Minio Haskell Library for Amazon S3 compatible cloud storage";

32 description = "A Minio Haskell Library for Amazon S3 compatible cloud storage";

37 license = stdenv.lib.licenses.asl20;

33 license = stdenv.lib.licenses.asl20;

38−}

34+}

test/golden-test-cases/mmorph.nix.golden+3−6

@@ -1,16 +1,13 @@

1−{ mkDerivation, base, fetchurl, mtl, transformers

1+{ mkDerivation, base, mtl, stdenv, transformers

2, transformers-compat

3}:

4mkDerivation {

5 pname = "mmorph";

6 version = "1.1.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base mtl transformers transformers-compat

9 base mtl transformers transformers-compat

13 ];

10 ];

14 description = "Monad morphisms";

11 description = "Monad morphisms";

15 license = stdenv.lib.licenses.bsd3;

12 license = stdenv.lib.licenses.bsd3;

16−}

13+}

test/golden-test-cases/mnist-idx.nix.golden+4−7

@@ -1,16 +1,13 @@

1−{ mkDerivation, base, binary, bytestring, directory, fetchurl

1+{ mkDerivation, base, binary, bytestring, directory, hspec, stdenv

2−, hspec, vector

2+, vector

3}:

4mkDerivation {

5 pname = "mnist-idx";

6 version = "0.1.2.8";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base binary bytestring vector ];

8 libraryHaskellDepends = [ base binary bytestring vector ];

12 testHaskellDepends = [ base binary directory hspec vector ];

9 testHaskellDepends = [ base binary directory hspec vector ];

13 homepage = "https://github.com/kryoxide/mnist-idx/";

10 homepage = "https://github.com/kryoxide/mnist-idx/";

14 description = "Read and write IDX data that is used in e.g. the MNIST database.";

11 description = "Read and write IDX data that is used in e.g. the MNIST database.";

15 license = stdenv.lib.licenses.lgpl3;

12 license = stdenv.lib.licenses.lgpl3;

16−}

13+}

test/golden-test-cases/mole.nix.golden+7−10

@@ -1,17 +1,14 @@

1{ mkDerivation, attoparsec, base, base64-bytestring, bytestring

2−, containers, cryptohash, css-syntax, directory, fetchurl

2+, containers, cryptohash, css-syntax, directory, filemanip

3−, filemanip, filepath, fsnotify, hspec, hspec-smallcheck, kraken

3+, filepath, fsnotify, hspec, hspec-smallcheck, kraken, mtl

4−, mtl, network-uri, optparse-applicative, process, smallcheck

4+, network-uri, optparse-applicative, process, smallcheck, snap-core

5−, snap-core, snap-server, stm, tagsoup, text, time, transformers

5+, snap-server, stdenv, stm, tagsoup, text, time, transformers, unix

6−, unix, unordered-containers, vector

6+, unordered-containers, vector

7}:

8mkDerivation {

9 pname = "mole";

10 version = "0.0.6";

11− src = fetchurl {

11+ sha256 = "deadbeef";

12− url = "http://example.org/";

13− sha256 = "abc";

14− };

15 isLibrary = false;

12 isLibrary = false;

16 isExecutable = true;

13 isExecutable = true;

17 executableHaskellDepends = [

14 executableHaskellDepends = [

@@ -26,4 +23,4 @@ mkDerivation {

26 ];

23 ];

27 description = "A glorified string replacement tool";

24 description = "A glorified string replacement tool";

28 license = stdenv.lib.licenses.mit;

25 license = stdenv.lib.licenses.mit;

29−}

26+}

test/golden-test-cases/monad-products.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, semigroupoids }:

1+{ mkDerivation, base, semigroupoids, stdenv }:

2mkDerivation {

3 pname = "monad-products";

4 version = "4.0.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base semigroupoids ];

6 libraryHaskellDepends = [ base semigroupoids ];

10 homepage = "http://github.com/ekmett/monad-products";

7 homepage = "http://github.com/ekmett/monad-products";

11 description = "Monad products";

8 description = "Monad products";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/monadcryptorandom.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, crypto-api, exceptions, fetchurl

1+{ mkDerivation, base, bytestring, crypto-api, exceptions, mtl

2−, mtl, tagged, transformers, transformers-compat

2+, stdenv, tagged, transformers, transformers-compat

3}:

4mkDerivation {

5 pname = "monadcryptorandom";

6 version = "0.7.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base bytestring crypto-api exceptions mtl tagged transformers

9 base bytestring crypto-api exceptions mtl tagged transformers

13 transformers-compat

10 transformers-compat

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://github.com/TomMD/monadcryptorandom";

12 homepage = "https://github.com/TomMD/monadcryptorandom";

16 description = "A monad for using CryptoRandomGen";

13 description = "A monad for using CryptoRandomGen";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/monadloc.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, template-haskell, transformers }:

1+{ mkDerivation, base, stdenv, template-haskell, transformers }:

2mkDerivation {

3 pname = "monadloc";

4 version = "0.7.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base template-haskell transformers ];

6 libraryHaskellDepends = [ base template-haskell transformers ];

10 homepage = "http://github.com/pepeiborra/monadloc";

7 homepage = "http://github.com/pepeiborra/monadloc";

11 description = "A class for monads which can keep a monadic call trace";

8 description = "A class for monads which can keep a monadic call trace";

12 license = stdenv.lib.licenses.publicDomain;

9 license = stdenv.lib.licenses.publicDomain;

13−}

10+}

test/golden-test-cases/mongoDB.nix.golden+5−8

@@ -1,17 +1,14 @@

1{ mkDerivation, array, base, base16-bytestring, base64-bytestring

2, binary, bson, bytestring, conduit, conduit-extra, containers

3−, criterion, cryptohash, data-default-class, fetchurl, hashtables

3+, criterion, cryptohash, data-default-class, hashtables, hspec

4−, hspec, lifted-base, monad-control, mtl, network, nonce

4+, lifted-base, monad-control, mtl, network, nonce, old-locale

5−, old-locale, parsec, pureMD5, random, random-shuffle, resourcet

5+, parsec, pureMD5, random, random-shuffle, resourcet, stdenv

6, tagged, text, time, tls, transformers, transformers-base

7}:

8mkDerivation {

9 pname = "mongoDB";

10 version = "2.3.0.1";

11− src = fetchurl {

11+ sha256 = "deadbeef";

12− url = "http://example.org/";

13− sha256 = "abc";

14− };

15 libraryHaskellDepends = [

12 libraryHaskellDepends = [

16 array base base16-bytestring base64-bytestring binary bson

13 array base base16-bytestring base64-bytestring binary bson

17 bytestring conduit conduit-extra containers cryptohash

14 bytestring conduit conduit-extra containers cryptohash

@@ -29,4 +26,4 @@ mkDerivation {

29 homepage = "https://github.com/mongodb-haskell/mongodb";

26 homepage = "https://github.com/mongodb-haskell/mongodb";

30 description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS";

27 description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS";

31 license = stdenv.lib.licenses.asl20;

28 license = stdenv.lib.licenses.asl20;

32−}

29+}

test/golden-test-cases/monoid-extras.nix.golden+4−7

@@ -1,15 +1,12 @@

1−{ mkDerivation, base, criterion, fetchurl, groups, semigroupoids

1+{ mkDerivation, base, criterion, groups, semigroupoids, semigroups

2−, semigroups

2+, stdenv

3}:

4mkDerivation {

5 pname = "monoid-extras";

6 version = "0.4.2";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base groups semigroupoids semigroups ];

8 libraryHaskellDepends = [ base groups semigroupoids semigroups ];

12 benchmarkHaskellDepends = [ base criterion ];

9 benchmarkHaskellDepends = [ base criterion ];

13 description = "Various extra monoid-related definitions and utilities";

10 description = "Various extra monoid-related definitions and utilities";

14 license = stdenv.lib.licenses.bsd3;

11 license = stdenv.lib.licenses.bsd3;

15−}

12+}

test/golden-test-cases/mwc-random-monad.nix.golden+4−7

@@ -1,16 +1,13 @@

1−{ mkDerivation, base, fetchurl, monad-primitive, mwc-random

1+{ mkDerivation, base, monad-primitive, mwc-random, primitive

2−, primitive, transformers, vector

2+, stdenv, transformers, vector

3}:

4mkDerivation {

5 pname = "mwc-random-monad";

6 version = "0.7.3.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base monad-primitive mwc-random primitive transformers vector

9 base monad-primitive mwc-random primitive transformers vector

13 ];

10 ];

14 description = "Monadic interface for mwc-random";

11 description = "Monadic interface for mwc-random";

15 license = stdenv.lib.licenses.bsd3;

12 license = stdenv.lib.licenses.bsd3;

16−}

13+}

test/golden-test-cases/mwc-random.nix.golden+4−12

@@ -1,23 +1,15 @@

1−{ mkDerivation, base, fetchurl, HUnit, math-functions, primitive

1+{ mkDerivation, base, math-functions, primitive, stdenv, time

2−, QuickCheck, statistics, test-framework, test-framework-hunit

2+, vector

3−, test-framework-quickcheck2, time, vector

4}:

3}:

5mkDerivation {

4mkDerivation {

6 pname = "mwc-random";

5 pname = "mwc-random";

7 version = "0.13.6.0";

6 version = "0.13.6.0";

8− src = fetchurl {

7+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

8 libraryHaskellDepends = [

13 base math-functions primitive time vector

9 base math-functions primitive time vector

14 ];

10 ];

15− testHaskellDepends = [

16− base HUnit QuickCheck statistics test-framework

17− test-framework-hunit test-framework-quickcheck2 vector

18− ];

19 doCheck = false;

11 doCheck = false;

20 homepage = "https://github.com/bos/mwc-random";

12 homepage = "https://github.com/bos/mwc-random";

21 description = "Fast, high quality pseudo random number generation";

13 description = "Fast, high quality pseudo random number generation";

22 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

23−}

15+}

test/golden-test-cases/nanospec.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, hspec, silently }:

1+{ mkDerivation, base, hspec, silently, stdenv }:

2mkDerivation {

3 pname = "nanospec";

4 version = "0.2.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 testHaskellDepends = [ base hspec silently ];

7 testHaskellDepends = [ base hspec silently ];

11 description = "A lightweight implementation of a subset of Hspec's API";

8 description = "A lightweight implementation of a subset of Hspec's API";

12 license = stdenv.lib.licenses.mit;

9 license = stdenv.lib.licenses.mit;

13−}

10+}

test/golden-test-cases/netpbm.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, attoparsec, attoparsec-binary, base, bytestring

2−, criterion, fetchurl, hspec, HUnit, storable-record

2+, criterion, hspec, HUnit, stdenv, storable-record

3, unordered-containers, vector, vector-th-unbox

4}:

5mkDerivation {

6 pname = "netpbm";

7 version = "1.0.2";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 attoparsec attoparsec-binary base bytestring storable-record

10 attoparsec attoparsec-binary base bytestring storable-record

14 unordered-containers vector vector-th-unbox

11 unordered-containers vector vector-th-unbox

@@ -18,4 +15,4 @@ mkDerivation {

18 homepage = "https://github.com/nh2/haskell-netpbm";

15 homepage = "https://github.com/nh2/haskell-netpbm";

19 description = "Loading PBM, PGM, PPM image files";

16 description = "Loading PBM, PGM, PPM image files";

20 license = stdenv.lib.licenses.mit;

17 license = stdenv.lib.licenses.mit;

21−}

18+}

test/golden-test-cases/network-protocol-xmpp.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, fetchurl, gnuidn, gnutls, gsasl

1+{ mkDerivation, base, bytestring, gnuidn, gnutls, gsasl, libxml-sax

2−, libxml-sax, monads-tf, network, text, transformers, xml-types

2+, monads-tf, network, stdenv, text, transformers, xml-types

3}:

4mkDerivation {

5 pname = "network-protocol-xmpp";

6 version = "0.4.8";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base bytestring gnuidn gnutls gsasl libxml-sax monads-tf network

9 base bytestring gnuidn gnutls gsasl libxml-sax monads-tf network

13 text transformers xml-types

10 text transformers xml-types

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://john-millikin.com/software/haskell-xmpp/";

12 homepage = "https://john-millikin.com/software/haskell-xmpp/";

16 description = "Client library for the XMPP protocol";

13 description = "Client library for the XMPP protocol";

17 license = stdenv.lib.licenses.gpl3;

14 license = stdenv.lib.licenses.gpl3;

18−}

15+}

test/golden-test-cases/network-transport-tcp.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, base, bytestring, containers, data-accessor

2−, fetchurl, network, network-transport, network-transport-tests

2+, network, network-transport, network-transport-tests, stdenv

3}:

4mkDerivation {

5 pname = "network-transport-tcp";

6 version = "0.6.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base bytestring containers data-accessor network network-transport

9 base bytestring containers data-accessor network network-transport

13 ];

10 ];

@@ -17,4 +14,4 @@ mkDerivation {

17 homepage = "http://haskell-distributed.github.com";

14 homepage = "http://haskell-distributed.github.com";

18 description = "TCP instantiation of Network.Transport";

15 description = "TCP instantiation of Network.Transport";

19 license = stdenv.lib.licenses.bsd3;

16 license = stdenv.lib.licenses.bsd3;

20−}

17+}

test/golden-test-cases/nix-paths.nix.golden+3−6

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, fetchurl, nix, process }:

1+{ mkDerivation, base, nix, process, stdenv }:

2mkDerivation {

3 pname = "nix-paths";

4 version = "1.0.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base process ];

6 libraryHaskellDepends = [ base process ];

10 libraryToolDepends = [ nix ];

7 libraryToolDepends = [ nix ];

11 homepage = "https://github.com/peti/nix-paths";

8 homepage = "https://github.com/peti/nix-paths";

12 description = "Knowledge of Nix's installation directories";

9 description = "Knowledge of Nix's installation directories";

13 license = stdenv.lib.licenses.bsd3;

10 license = stdenv.lib.licenses.bsd3;

14−}

11+}

test/golden-test-cases/nvim-hs.nix.golden+7−9

@@ -1,9 +1,9 @@

1{ mkDerivation, ansi-wl-pprint, base, bytestring, cereal

2, cereal-conduit, conduit, conduit-extra, containers, data-default

3−, deepseq, directory, dyre, exceptions, fetchurl, filepath

3+, deepseq, directory, dyre, exceptions, filepath, foreign-store

4−, foreign-store, hslogger, hspec, hspec-discover, HUnit

4+, hslogger, hspec, hspec-discover, HUnit, lifted-base, megaparsec

5−, lifted-base, megaparsec, messagepack, monad-control, mtl, network

5+, messagepack, monad-control, mtl, network, optparse-applicative

6−, optparse-applicative, process, QuickCheck, resourcet, setenv, stm

6+, process, QuickCheck, resourcet, setenv, stdenv, stm

7, streaming-commons, template-haskell, text, time

8, time-locale-compat, transformers, transformers-base, utf8-string

9, void

@@ -11,10 +11,7 @@

11mkDerivation {

12 pname = "nvim-hs";

13 version = "0.2.5";

14− src = fetchurl {

14+ sha256 = "deadbeef";

15− url = "http://example.org/";

16− sha256 = "abc";

17− };

18 isLibrary = true;

15 isLibrary = true;

19 isExecutable = true;

16 isExecutable = true;

20 libraryHaskellDepends = [

17 libraryHaskellDepends = [

@@ -35,7 +32,8 @@ mkDerivation {

35 template-haskell text time time-locale-compat transformers

32 template-haskell text time time-locale-compat transformers

36 transformers-base utf8-string

33 transformers-base utf8-string

37 ];

34 ];

35+ testToolDepends = [ hspec-discover ];

38 homepage = "https://github.com/neovimhaskell/nvim-hs";

36 homepage = "https://github.com/neovimhaskell/nvim-hs";

39 description = "Haskell plugin backend for neovim";

37 description = "Haskell plugin backend for neovim";

40 license = stdenv.lib.licenses.asl20;

38 license = stdenv.lib.licenses.asl20;

41−}

39+}

test/golden-test-cases/once.nix.golden+3−6

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, containers, fetchurl, hashable

1+{ mkDerivation, base, containers, hashable, stdenv

2, template-haskell, unordered-containers

3}:

4mkDerivation {

5 pname = "once";

6 version = "0.2";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base containers hashable template-haskell unordered-containers

9 base containers hashable template-haskell unordered-containers

13 ];

10 ];

14 homepage = "https://anonscm.debian.org/cgit/users/kaction-guest/haskell-once.git";

11 homepage = "https://anonscm.debian.org/cgit/users/kaction-guest/haskell-once.git";

15 description = "memoization for IO actions and functions";

12 description = "memoization for IO actions and functions";

16 license = stdenv.lib.licenses.gpl3;

13 license = stdenv.lib.licenses.gpl3;

17−}

14+}

test/golden-test-cases/one-liner.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bifunctors, contravariant, fetchurl, ghc-prim

1+{ mkDerivation, base, bifunctors, contravariant, ghc-prim, HUnit

2−, HUnit, profunctors, tagged, transformers

2+, profunctors, stdenv, tagged, transformers

3}:

4mkDerivation {

5 pname = "one-liner";

6 version = "0.9.2";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base bifunctors contravariant ghc-prim profunctors tagged

9 base bifunctors contravariant ghc-prim profunctors tagged

13 transformers

10 transformers

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/sjoerdvisscher/one-liner";

13 homepage = "https://github.com/sjoerdvisscher/one-liner";

17 description = "Constraint-based generics";

14 description = "Constraint-based generics";

18 license = stdenv.lib.licenses.bsd3;

15 license = stdenv.lib.licenses.bsd3;

19−}

16+}

test/golden-test-cases/online.nix.golden+3−6

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, fetchurl, foldl, numhask, protolude, tdigest

1+{ mkDerivation, base, foldl, numhask, protolude, stdenv, tdigest

2, vector, vector-algorithms

3}:

4mkDerivation {

5 pname = "online";

6 version = "0.2.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base foldl numhask protolude tdigest vector vector-algorithms

9 base foldl numhask protolude tdigest vector vector-algorithms

13 ];

10 ];

14 homepage = "https://github.com/tonyday567/online";

11 homepage = "https://github.com/tonyday567/online";

15 description = "online statistics";

12 description = "online statistics";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/opencv.cabalnew file+263

@@ -0,0 +1,263 @@

1+name: opencv

2+version: 0.0.2.1

3+homepage: https://github.com/LumiGuide/haskell-opencv

4+bug-reports: https://github.com/LumiGuide/haskell-opencv/issues

5+license: BSD3

6+license-file: LICENSE

7+author: Roel van Dijk <roel@lambdacube.nl>, Bas van Dijk <v.dijk.bas@gmail.com>

8+maintainer: Roel van Dijk <roel@lambdacube.nl>, Bas van Dijk <v.dijk.bas@gmail.com>

9+build-type: Custom

10+cabal-version: >=1.23

11+category: AI, Graphics

12+synopsis: Haskell binding to OpenCV-3.x

13+description: <<https://raw.githubusercontent.com/LumiGuide/haskell-opencv/master/data/haskell-opencv-logo-200x82.png>>

14+ .

15+ This is a Haskell library providing a binding to OpenCV-3.x.

16+ It binds directly with the C++ API using the @inline-c@ Haskell library.

17+ .

18+ The library is far from complete but the framework is there to easily

19+ bind missing functionality.

20+ .

21+ Note that the OpenCV contrib modules are provided by

22+ <http://hackage.haskell.org/package/opencv-extra opencv-extra>.

23+ .

24+ Make sure to checkout the

25+ <https://github.com/LumiGuide/haskell-opencv/tree/master/opencv-examples opencv-examples>.

26+

27+extra-source-files:

28+ CHANGELOG.md

29+ data/*.png

30+ data/*.jpg

31+ data/*.mp4

32+ data/*.xml

33+

34+extra-doc-files:

35+ doc/generated/*.png

36+ doc/generated/examples/*.png

37+ doc/generated/examples/*.gif

38+ doc/color_conversions.png

39+

40+source-repository head

41+ type: git

42+ location: git://github.com/LumiGuide/haskell-opencv.git

43+ subdir: opencv

44+

45+flag internal-documentation

46+ description: Enables documentation generation for internal modules.

47+ default: False

48+ manual: True

49+

50+custom-setup

51+ setup-depends: base, Cabal >= 1.23

52+

53+library

54+ hs-source-dirs: src

55+ include-dirs: include

56+ install-includes:

57+ haskell_opencv_matx_typedefs.hpp

58+ hsc_macros.hpp

59+ namespace.hpp

60+ orb.hpp

61+ simple_blob_detector.hpp

62+ termcriteria.hpp

63+ video_motion_analysis.hpp

64+

65+ cc-options: -Wall -std=c++11

66+ ghc-options: -Wall -fwarn-incomplete-patterns -funbox-strict-fields

67+ if flag(internal-documentation)

68+ cpp-options: -DENABLE_INTERNAL_DOCUMENTATION

69+

70+ build-depends:

71+ aeson >= 0.9.0.1

72+ , base >= 4.8 && <5

73+ , base64-bytestring >= 1.0.0.1

74+ , bindings-DSL >= 1.0.23

75+ , bytestring >= 0.10.6

76+ , containers >= 0.5.6.2

77+ , data-default >= 0.7.1.1

78+ , deepseq >= 1.4.1.1

79+ , inline-c >= 0.6

80+ , inline-c-cpp >= 0.2.1

81+ , JuicyPixels >= 3.2.8.1

82+ , linear >= 1.20.4

83+ , primitive >= 0.6.1

84+ , repa >= 3.4.0.2

85+ , template-haskell >= 2.10

86+ , text >= 1.2.2.1

87+ , transformers >= 0.4.2

88+ , vector >= 0.11

89+

90+ exposed-modules:

91+ OpenCV

92+ OpenCV.Calib3d

93+ OpenCV.Core.ArrayOps

94+ OpenCV.Core.Types

95+ OpenCV.Core.Types.Mat

96+ OpenCV.Core.Types.Mat.HMat

97+ OpenCV.Core.Types.Mat.Repa

98+ OpenCV.Core.Types.Matx

99+ OpenCV.Core.Types.Point

100+ OpenCV.Core.Types.Rect

101+ OpenCV.Core.Types.Size

102+ OpenCV.Core.Types.Vec

103+ OpenCV.Exception

104+ OpenCV.Features2d

105+ OpenCV.HighGui

106+ OpenCV.ImgCodecs

107+ OpenCV.ImgProc.ColorMaps

108+ OpenCV.ImgProc.Drawing

109+ OpenCV.ImgProc.FeatureDetection

110+ OpenCV.ImgProc.GeometricImgTransform

111+ OpenCV.ImgProc.ImgFiltering

112+ OpenCV.ImgProc.MiscImgTransform

113+ OpenCV.ImgProc.MiscImgTransform.ColorCodes

114+ OpenCV.ImgProc.ObjectDetection

115+ OpenCV.ImgProc.StructuralAnalysis

116+ OpenCV.ImgProc.Types

117+ OpenCV.ImgProc.CascadeClassifier

118+ OpenCV.JSON

119+ OpenCV.Photo

120+ OpenCV.TypeLevel

121+ OpenCV.Unsafe

122+ OpenCV.Video

123+ OpenCV.Video.MotionAnalysis

124+ OpenCV.VideoIO.Types

125+ OpenCV.VideoIO.VideoCapture

126+ OpenCV.VideoIO.VideoWriter

127+

128+ OpenCV.Internal

129+ OpenCV.Internal.Mutable

130+ OpenCV.Internal.C.Inline

131+ OpenCV.Internal.C.PlacementNew

132+ OpenCV.Internal.C.PlacementNew.TH

133+ OpenCV.Internal.C.Types

134+ OpenCV.Internal.Calib3d.Constants

135+ OpenCV.Internal.Core.ArrayOps

136+ OpenCV.Internal.Core.Types

137+ OpenCV.Internal.Core.Types.Constants

138+ OpenCV.Internal.Core.Types.Mat

139+ OpenCV.Internal.Core.Types.Mat.Depth

140+ OpenCV.Internal.Core.Types.Mat.HMat

141+ OpenCV.Internal.Core.Types.Mat.Marshal

142+ OpenCV.Internal.Core.Types.Mat.ToFrom

143+ OpenCV.Internal.Core.Types.Matx

144+ OpenCV.Internal.Core.Types.Matx.TH

145+ OpenCV.Internal.Core.Types.Point

146+ OpenCV.Internal.Core.Types.Point.TH

147+ OpenCV.Internal.Core.Types.Rect

148+ OpenCV.Internal.Core.Types.Rect.TH

149+ OpenCV.Internal.Core.Types.Size

150+ OpenCV.Internal.Core.Types.Size.TH

151+ OpenCV.Internal.Core.Types.Vec

152+ OpenCV.Internal.Core.Types.Vec.TH

153+ OpenCV.Internal.Exception

154+ OpenCV.Internal.ImgCodecs

155+ OpenCV.Internal.ImgProc.MiscImgTransform

156+ OpenCV.Internal.ImgProc.MiscImgTransform.TypeLevel

157+ OpenCV.Internal.ImgProc.MiscImgTransform.ColorCodes

158+ OpenCV.Internal.ImgProc.Types

159+ OpenCV.Internal.Photo.Constants

160+ OpenCV.Internal.VideoIO.Constants

161+ OpenCV.Internal.VideoIO.Types

162+ OpenCV.Juicy

163+

164+ default-extensions:

165+ BangPatterns

166+ DataKinds

167+ FlexibleContexts

168+ FlexibleInstances

169+ LambdaCase

170+ OverloadedStrings

171+ PackageImports

172+ PolyKinds

173+ ScopedTypeVariables

174+ TupleSections

175+ TypeFamilies

176+ TypeOperators

177+

178+ default-language: Haskell2010

179+ pkgconfig-depends: opencv >= 3.0.0

180+ extra-libraries: stdc++

181+

182+test-suite doc-images-opencv

183+ type: exitcode-stdio-1.0

184+ hs-source-dirs: doc

185+ main-is: images.hs

186+ other-modules:

187+ ExampleExtractor

188+ Language.Haskell.Meta.Syntax.Translate

189+ default-language: Haskell2010

190+ ghc-options: -Wall -fwarn-incomplete-patterns -threaded -funbox-strict-fields -rtsopts

191+ build-depends:

192+ base >= 4.8 && < 5

193+ , bytestring >= 0.10.6

194+ , containers >= 0.5.6.2

195+ , data-default >= 0.7.1.1

196+ , directory >= 1.2.2

197+ , Glob >= 0.9

198+ , haskell-src-exts >= 1.18.2

199+ , JuicyPixels >= 3.2.8.1

200+ , linear >= 1.20.4

201+ , opencv

202+ , primitive >= 0.6.1

203+ , template-haskell >= 2.10

204+ , text >= 1.2.2.1

205+ , transformers >= 0.4.2

206+ , vector >= 0.11

207+

208+ default-extensions:

209+ BangPatterns

210+ DataKinds

211+ LambdaCase

212+ OverloadedStrings

213+ PackageImports

214+ PolyKinds

215+ ScopedTypeVariables

216+ TupleSections

217+ TypeFamilies

218+ TypeOperators

219+

220+test-suite test-opencv

221+ type: exitcode-stdio-1.0

222+ hs-source-dirs: test

223+ main-is: test.hs

224+ default-language: Haskell2010

225+ ghc-options: -Wall -fwarn-incomplete-patterns -threaded -funbox-strict-fields -rtsopts

226+ build-depends:

227+ base >= 4.8 && < 5

228+ , bytestring >= 0.10.6

229+ , lens >= 4.13

230+ , linear >= 1.20.4

231+ , opencv

232+ , QuickCheck >= 2.10.1

233+ , repa >= 3.4.0.2

234+ , tasty >= 0.11.0.2

235+ , tasty-hunit >= 0.9.2

236+ , tasty-quickcheck >= 0.8.4

237+ , transformers >= 0.4.2

238+ , vector >= 0.11

239+

240+ default-extensions:

241+ DataKinds

242+ FlexibleContexts

243+ PackageImports

244+ RankNTypes

245+ ScopedTypeVariables

246+ TypeOperators

247+

248+benchmark bench-opencv

249+ type: exitcode-stdio-1.0

250+ hs-source-dirs: bench

251+ main-is: bench.hs

252+ default-language: Haskell2010

253+ ghc-options: -Wall -fwarn-incomplete-patterns -threaded -funbox-strict-fields -rtsopts

254+ build-depends:

255+ base >= 4.8 && < 5

256+ , bytestring >= 0.10.6

257+ , criterion >= 1.1.1

258+ , opencv

259+ , repa >= 3.4.0.2

260+

261+ default-extensions:

262+ DataKinds

263+ PackageImports

test/golden-test-cases/opencv.nix.goldennew file+30

@@ -0,0 +1,30 @@

1+{ mkDerivation, aeson, base, base64-bytestring, bindings-DSL

2+, bytestring, Cabal, containers, criterion, data-default, deepseq

3+, directory, Glob, haskell-src-exts, inline-c, inline-c-cpp

4+, JuicyPixels, lens, linear, opencv3, primitive, QuickCheck, repa

5+, stdenv, tasty, tasty-hunit, tasty-quickcheck, template-haskell

6+, text, transformers, vector

7+}:

8+mkDerivation {

9+ pname = "opencv";

10+ version = "0.0.2.1";

11+ sha256 = "deadbeef";

12+ setupHaskellDepends = [ base Cabal ];

13+ libraryHaskellDepends = [

14+ aeson base base64-bytestring bindings-DSL bytestring containers

15+ data-default deepseq inline-c inline-c-cpp JuicyPixels linear

16+ primitive repa template-haskell text transformers vector

17+ ];

18+ libraryPkgconfigDepends = [ opencv3 ];

19+ testHaskellDepends = [

20+ base bytestring containers data-default directory Glob

21+ haskell-src-exts JuicyPixels lens linear primitive QuickCheck repa

22+ tasty tasty-hunit tasty-quickcheck template-haskell text

23+ transformers vector

24+ ];

25+ benchmarkHaskellDepends = [ base bytestring criterion repa ];

26+ hardeningDisable = [ "bindnow" ];

27+ homepage = "https://github.com/LumiGuide/haskell-opencv";

28+ description = "Haskell binding to OpenCV-3.x";

29+ license = stdenv.lib.licenses.bsd3;

30+}

test/golden-test-cases/openexr-write.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, base, binary, bytestring, data-binary-ieee754

2−, deepseq, directory, fetchurl, hspec, split, vector, vector-split

2+, deepseq, directory, hspec, split, stdenv, vector, vector-split

3, zlib

4}:

5mkDerivation {

6 pname = "openexr-write";

7 version = "0.1.0.1";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 base binary bytestring data-binary-ieee754 deepseq split vector

10 base binary bytestring data-binary-ieee754 deepseq split vector

14 vector-split zlib

11 vector-split zlib

@@ -17,4 +14,4 @@ mkDerivation {

17 homepage = "https://github.com/pavolzetor/openexr-write#readme";

14 homepage = "https://github.com/pavolzetor/openexr-write#readme";

18 description = "Library for writing images in OpenEXR HDR file format";

15 description = "Library for writing images in OpenEXR HDR file format";

19 license = stdenv.lib.licenses.gpl3;

16 license = stdenv.lib.licenses.gpl3;

20−}

17+}

test/golden-test-cases/openpgp-asciiarmor.nix.golden+4−6

@@ -1,13 +1,10 @@

1{ mkDerivation, attoparsec, base, base64-bytestring, bytestring

2−, cereal, fetchurl, HUnit, test-framework, test-framework-hunit

2+, cereal, HUnit, stdenv, test-framework, test-framework-hunit

3}:

4mkDerivation {

5 pname = "openpgp-asciiarmor";

6 version = "0.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 attoparsec base base64-bytestring bytestring cereal

9 attoparsec base base64-bytestring bytestring cereal

13 ];

10 ];

@@ -18,4 +15,5 @@ mkDerivation {

18 homepage = "http://floss.scru.org/openpgp-asciiarmor";

15 homepage = "http://floss.scru.org/openpgp-asciiarmor";

19 description = "OpenPGP (RFC4880) ASCII Armor codec";

16 description = "OpenPGP (RFC4880) ASCII Armor codec";

20 license = "unknown";

17 license = "unknown";

21−}

18+ hydraPlatforms = stdenv.lib.platforms.none;

19+}

test/golden-test-cases/pager.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, base, bytestring, conduit, conduit-extra, directory

2−, fetchurl, process, resourcet, safe, terminfo, text, transformers

2+, process, resourcet, safe, stdenv, terminfo, text, transformers

3, unix

4}:

5mkDerivation {

6 pname = "pager";

7 version = "0.1.1.0";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 isLibrary = true;

9 isLibrary = true;

13 isExecutable = true;

10 isExecutable = true;

14 enableSeparateDataOutput = true;

11 enableSeparateDataOutput = true;

@@ -20,4 +17,4 @@ mkDerivation {

20 homepage = "https://github.com/pharpend/pager";

17 homepage = "https://github.com/pharpend/pager";

21 description = "Open up a pager, like 'less' or 'more'";

18 description = "Open up a pager, like 'less' or 'more'";

22 license = stdenv.lib.licenses.bsd2;

19 license = stdenv.lib.licenses.bsd2;

23−}

20+}

test/golden-test-cases/partial-isomorphisms.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, template-haskell }:

1+{ mkDerivation, base, stdenv, template-haskell }:

2mkDerivation {

3 pname = "partial-isomorphisms";

4 version = "0.2.2.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base template-haskell ];

6 libraryHaskellDepends = [ base template-haskell ];

10 homepage = "http://www.informatik.uni-marburg.de/~rendel/unparse";

7 homepage = "http://www.informatik.uni-marburg.de/~rendel/unparse";

11 description = "Partial isomorphisms";

8 description = "Partial isomorphisms";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/partial-semigroup.nix.golden+3−6

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, doctest, fetchurl, hedgehog }:

1+{ mkDerivation, base, doctest, hedgehog, stdenv }:

2mkDerivation {

3 pname = "partial-semigroup";

4 version = "0.3.0.2";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 testHaskellDepends = [ base doctest hedgehog ];

7 testHaskellDepends = [ base doctest hedgehog ];

11 homepage = "https://github.com/chris-martin/partial-semigroup";

8 homepage = "https://github.com/chris-martin/partial-semigroup";

12 description = "A partial binary associative operator";

9 description = "A partial binary associative operator";

13 license = stdenv.lib.licenses.asl20;

10 license = stdenv.lib.licenses.asl20;

14−}

11+}

test/golden-test-cases/pathtype.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, deepseq, directory, fetchurl, old-time

1+{ mkDerivation, base, deepseq, directory, old-time, QuickCheck

2−, QuickCheck, random, tagged, time, transformers, utility-ht

2+, random, stdenv, tagged, time, transformers, utility-ht

3}:

4mkDerivation {

5 pname = "pathtype";

6 version = "0.8";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 isLibrary = true;

8 isLibrary = true;

12 isExecutable = true;

9 isExecutable = true;

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

@@ -18,4 +15,4 @@ mkDerivation {

18 homepage = "http://hub.darcs.net/thielema/pathtype/";

15 homepage = "http://hub.darcs.net/thielema/pathtype/";

19 description = "Type-safe replacement for System.FilePath etc";

16 description = "Type-safe replacement for System.FilePath etc";

20 license = stdenv.lib.licenses.bsd3;

17 license = stdenv.lib.licenses.bsd3;

21−}

18+}

test/golden-test-cases/pcap.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, fetchurl, network, time }:

1+{ mkDerivation, base, bytestring, network, stdenv, time }:

2mkDerivation {

3 pname = "pcap";

4 version = "0.4.5.2";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base bytestring network time ];

6 libraryHaskellDepends = [ base bytestring network time ];

10 homepage = "https://github.com/bos/pcap";

7 homepage = "https://github.com/bos/pcap";

11 description = "A system-independent interface for user-level packet capture";

8 description = "A system-independent interface for user-level packet capture";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/pdfinfo.nix.golden+4−7

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, fetchurl, mtl, old-locale, process-extras

1+{ mkDerivation, base, mtl, old-locale, process-extras, stdenv, text

2−, text, time, time-locale-compat

2+, time, time-locale-compat

3}:

4mkDerivation {

5 pname = "pdfinfo";

6 version = "1.5.4";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base mtl old-locale process-extras text time time-locale-compat

9 base mtl old-locale process-extras text time time-locale-compat

13 ];

10 ];

14 homepage = "https://github.com/chrisdone/pdfinfo";

11 homepage = "https://github.com/chrisdone/pdfinfo";

15 description = "Wrapper around the pdfinfo command";

12 description = "Wrapper around the pdfinfo command";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/pell.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, arithmoi, base, Cabal, cabal-test-quickcheck

2−, containers, fetchurl, primes, QuickCheck

2+, containers, primes, QuickCheck, stdenv

3}:

4mkDerivation {

5 pname = "pell";

6 version = "0.1.1.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ arithmoi base containers ];

8 libraryHaskellDepends = [ arithmoi base containers ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 arithmoi base Cabal cabal-test-quickcheck containers primes

10 arithmoi base Cabal cabal-test-quickcheck containers primes

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/brunjlar/pell";

13 homepage = "https://github.com/brunjlar/pell";

17 description = "Package to solve the Generalized Pell Equation";

14 description = "Package to solve the Generalized Pell Equation";

18 license = stdenv.lib.licenses.mit;

15 license = stdenv.lib.licenses.mit;

19−}

16+}

test/golden-test-cases/persistable-types-HDBC-pg.nix.golden+5−7

@@ -1,13 +1,11 @@

1−{ mkDerivation, base, bytestring, convertible, fetchurl, HDBC

1+{ mkDerivation, base, bytestring, convertible, HDBC

2−, persistable-record, relational-query-HDBC, text-postgresql

2+, persistable-record, relational-query-HDBC, stdenv

3+, text-postgresql

3}:

4}:

4mkDerivation {

5mkDerivation {

5 pname = "persistable-types-HDBC-pg";

6 pname = "persistable-types-HDBC-pg";

6 version = "0.0.1.5";

7 version = "0.0.1.5";

7− src = fetchurl {

8+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

9 libraryHaskellDepends = [

12 base bytestring convertible HDBC persistable-record

10 base bytestring convertible HDBC persistable-record

13 relational-query-HDBC text-postgresql

11 relational-query-HDBC text-postgresql

@@ -15,4 +13,4 @@ mkDerivation {

15 homepage = "http://khibino.github.io/haskell-relational-record/";

13 homepage = "http://khibino.github.io/haskell-relational-record/";

16 description = "HDBC and Relational-Record instances of PostgreSQL extended types";

14 description = "HDBC and Relational-Record instances of PostgreSQL extended types";

17 license = stdenv.lib.licenses.bsd3;

15 license = stdenv.lib.licenses.bsd3;

18−}

16+}

test/golden-test-cases/persistent-mysql-haskell.nix.golden+5−8

@@ -1,15 +1,12 @@

1{ mkDerivation, aeson, base, bytestring, conduit, containers

2−, fetchurl, io-streams, monad-control, monad-logger, mysql-haskell

2+, io-streams, monad-control, monad-logger, mysql-haskell, network

3−, network, persistent, persistent-template, resource-pool

3+, persistent, persistent-template, resource-pool, resourcet, stdenv

4−, resourcet, text, time, tls, transformers

4+, text, time, tls, transformers

5}:

6mkDerivation {

7 pname = "persistent-mysql-haskell";

8 version = "0.3.6";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 isLibrary = true;

10 isLibrary = true;

14 isExecutable = true;

11 isExecutable = true;

15 libraryHaskellDepends = [

12 libraryHaskellDepends = [

@@ -23,4 +20,4 @@ mkDerivation {

23 homepage = "http://www.yesodweb.com/book/persistent";

20 homepage = "http://www.yesodweb.com/book/persistent";

24 description = "A pure haskell backend for the persistent library using MySQL database server";

21 description = "A pure haskell backend for the persistent library using MySQL database server";

25 license = stdenv.lib.licenses.mit;

22 license = stdenv.lib.licenses.mit;

26−}

23+}

test/golden-test-cases/picosat.nix.golden+3−6

@@ -1,16 +1,13 @@

1−{ mkDerivation, base, containers, fetchurl, random, rdtsc

1+{ mkDerivation, base, containers, random, rdtsc, stdenv

2, transformers

3}:

4mkDerivation {

5 pname = "picosat";

6 version = "0.1.4";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base containers transformers ];

8 libraryHaskellDepends = [ base containers transformers ];

12 testHaskellDepends = [ base containers random rdtsc transformers ];

9 testHaskellDepends = [ base containers random rdtsc transformers ];

13 homepage = "https://github.com/sdiehl/haskell-picosat";

10 homepage = "https://github.com/sdiehl/haskell-picosat";

14 description = "Bindings to the PicoSAT solver";

11 description = "Bindings to the PicoSAT solver";

15 license = stdenv.lib.licenses.mit;

12 license = stdenv.lib.licenses.mit;

16−}

13+}

test/golden-test-cases/pinch.nix.golden+4−6

@@ -1,14 +1,11 @@

1{ mkDerivation, array, base, bytestring, containers, deepseq

2−, fetchurl, ghc-prim, hashable, hspec, hspec-discover, QuickCheck

2+, ghc-prim, hashable, hspec, hspec-discover, QuickCheck, stdenv

3, text, unordered-containers, vector

4}:

5mkDerivation {

6 pname = "pinch";

7 version = "0.3.2.0";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 array base bytestring containers deepseq ghc-prim hashable text

10 array base bytestring containers deepseq ghc-prim hashable text

14 unordered-containers vector

11 unordered-containers vector

@@ -17,7 +14,8 @@ mkDerivation {

17 base bytestring containers hspec hspec-discover QuickCheck text

14 base bytestring containers hspec hspec-discover QuickCheck text

18 unordered-containers vector

15 unordered-containers vector

19 ];

16 ];

17+ testToolDepends = [ hspec-discover ];

20 homepage = "https://github.com/abhinav/pinch#readme";

18 homepage = "https://github.com/abhinav/pinch#readme";

21 description = "An alternative implementation of Thrift for Haskell";

19 description = "An alternative implementation of Thrift for Haskell";

22 license = stdenv.lib.licenses.bsd3;

20 license = stdenv.lib.licenses.bsd3;

23−}

21+}

test/golden-test-cases/pipes-network.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, fetchurl, network, network-simple

1+{ mkDerivation, base, bytestring, network, network-simple, pipes

2−, pipes, pipes-safe, transformers

2+, pipes-safe, stdenv, transformers

3}:

4mkDerivation {

5 pname = "pipes-network";

6 version = "0.6.4.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base bytestring network network-simple pipes pipes-safe

9 base bytestring network network-simple pipes pipes-safe

13 transformers

10 transformers

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://github.com/k0001/pipes-network";

12 homepage = "https://github.com/k0001/pipes-network";

16 description = "Use network sockets together with the pipes library";

13 description = "Use network sockets together with the pipes library";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/pipes-safe.nix.golden+4−8

@@ -1,18 +1,14 @@

1−{ mkDerivation, base, containers, exceptions, fetchurl

1+{ mkDerivation, base, containers, exceptions, monad-control, mtl

2−, monad-control, mtl, pipes, primitive, transformers

2+, pipes, primitive, stdenv, transformers, transformers-base

3−, transformers-base

4}:

3}:

5mkDerivation {

4mkDerivation {

6 pname = "pipes-safe";

5 pname = "pipes-safe";

7 version = "2.2.6";

6 version = "2.2.6";

8− src = fetchurl {

7+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

8 libraryHaskellDepends = [

13 base containers exceptions monad-control mtl pipes primitive

9 base containers exceptions monad-control mtl pipes primitive

14 transformers transformers-base

10 transformers transformers-base

15 ];

11 ];

16 description = "Safety for the pipes ecosystem";

12 description = "Safety for the pipes ecosystem";

17 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

18−}

14+}

test/golden-test-cases/pointed.nix.golden+4−8

@@ -1,15 +1,11 @@

1{ mkDerivation, base, comonad, containers, data-default-class

2−, fetchurl, hashable, kan-extensions, semigroupoids, semigroups

2+, hashable, kan-extensions, semigroupoids, semigroups, stdenv, stm

3−, stm, tagged, transformers, transformers-compat

3+, tagged, transformers, transformers-compat, unordered-containers

4−, unordered-containers

5}:

4}:

6mkDerivation {

5mkDerivation {

7 pname = "pointed";

6 pname = "pointed";

8 version = "5";

7 version = "5";

9− src = fetchurl {

8+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 libraryHaskellDepends = [

9 libraryHaskellDepends = [

14 base comonad containers data-default-class hashable kan-extensions

10 base comonad containers data-default-class hashable kan-extensions

15 semigroupoids semigroups stm tagged transformers

11 semigroupoids semigroups stm tagged transformers

@@ -18,4 +14,4 @@ mkDerivation {

18 homepage = "http://github.com/ekmett/pointed/";

14 homepage = "http://github.com/ekmett/pointed/";

19 description = "Pointed and copointed data";

15 description = "Pointed and copointed data";

20 license = stdenv.lib.licenses.bsd3;

16 license = stdenv.lib.licenses.bsd3;

21−}

17+}

test/golden-test-cases/poly-arity.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, base, constraints, fetchurl }:

1+{ mkDerivation, base, constraints, stdenv }:

2mkDerivation {

3 pname = "poly-arity";

4 version = "0.1.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base constraints ];

6 libraryHaskellDepends = [ base constraints ];

10 description = "Tools for working with functions of undetermined arity";

7 description = "Tools for working with functions of undetermined arity";

11 license = stdenv.lib.licenses.bsd3;

8 license = stdenv.lib.licenses.bsd3;

12−}

9+}

test/golden-test-cases/polynomials-bernstein.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, base, fetchurl, vector }:

1+{ mkDerivation, base, stdenv, vector }:

2mkDerivation {

3 pname = "polynomials-bernstein";

4 version = "1.1.2";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base vector ];

6 libraryHaskellDepends = [ base vector ];

10 description = "A solver for systems of polynomial equations in bernstein form";

7 description = "A solver for systems of polynomial equations in bernstein form";

11 license = "GPL";

8 license = "GPL";

12−}

9+}

test/golden-test-cases/postgresql-simple-url.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, network-uri, postgresql-simple

1+{ mkDerivation, base, network-uri, postgresql-simple, split, stdenv

2−, split, tasty, tasty-quickcheck

2+, tasty, tasty-quickcheck

3}:

4mkDerivation {

5 pname = "postgresql-simple-url";

6 version = "0.2.0.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base network-uri postgresql-simple split

9 base network-uri postgresql-simple split

13 ];

10 ];

@@ -17,4 +14,4 @@ mkDerivation {

17 homepage = "https://github.com/futurice/postgresql-simple-url";

14 homepage = "https://github.com/futurice/postgresql-simple-url";

18 description = "Parse postgres:// url into ConnectInfo";

15 description = "Parse postgres:// url into ConnectInfo";

19 license = stdenv.lib.licenses.mit;

16 license = stdenv.lib.licenses.mit;

20−}

17+}

test/golden-test-cases/prelude-safeenum.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl }:

1+{ mkDerivation, base, stdenv }:

2mkDerivation {

3 pname = "prelude-safeenum";

4 version = "0.1.1.2";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 homepage = "http://code.haskell.org/~wren/";

7 homepage = "http://code.haskell.org/~wren/";

11 description = "A redefinition of the Prelude's Enum class in order to render it safe";

8 description = "A redefinition of the Prelude's Enum class in order to render it safe";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/presburger.nix.golden+3−6

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, containers, fetchurl, pretty, QuickCheck }:

1+{ mkDerivation, base, containers, pretty, QuickCheck, stdenv }:

2mkDerivation {

3 pname = "presburger";

4 version = "1.3.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base containers pretty ];

6 libraryHaskellDepends = [ base containers pretty ];

10 testHaskellDepends = [ base QuickCheck ];

7 testHaskellDepends = [ base QuickCheck ];

11 homepage = "http://github.com/yav/presburger";

8 homepage = "http://github.com/yav/presburger";

12 description = "A decision procedure for quantifier-free linear arithmetic";

9 description = "A decision procedure for quantifier-free linear arithmetic";

13 license = stdenv.lib.licenses.bsd3;

10 license = stdenv.lib.licenses.bsd3;

14−}

11+}

test/golden-test-cases/prettyclass.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, base, fetchurl, pretty }:

1+{ mkDerivation, base, pretty, stdenv }:

2mkDerivation {

3 pname = "prettyclass";

4 version = "1.0.0.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base pretty ];

6 libraryHaskellDepends = [ base pretty ];

10 description = "Pretty printing class similar to Show";

7 description = "Pretty printing class similar to Show";

11 license = stdenv.lib.licenses.bsd3;

8 license = stdenv.lib.licenses.bsd3;

12−}

9+}

test/golden-test-cases/prettyprinter-compat-ansi-wl-pprint.nix.golden+4−7

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, fetchurl, prettyprinter

1+{ mkDerivation, base, prettyprinter, prettyprinter-ansi-terminal

2−, prettyprinter-ansi-terminal, text

2+, stdenv, text

3}:

4mkDerivation {

5 pname = "prettyprinter-compat-ansi-wl-pprint";

6 version = "1.0.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base prettyprinter prettyprinter-ansi-terminal text

9 base prettyprinter prettyprinter-ansi-terminal text

13 ];

10 ];

14 homepage = "http://github.com/quchen/prettyprinter";

11 homepage = "http://github.com/quchen/prettyprinter";

15 description = "Drop-in compatibility package to migrate from »ansi-wl-pprint« to »prettyprinter«";

12 description = "Drop-in compatibility package to migrate from »ansi-wl-pprint« to »prettyprinter«";

16 license = stdenv.lib.licenses.bsd2;

13 license = stdenv.lib.licenses.bsd2;

17−}

14+}

test/golden-test-cases/prettyprinter-compat-wl-pprint.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, prettyprinter, text }:

1+{ mkDerivation, base, prettyprinter, stdenv, text }:

2mkDerivation {

3 pname = "prettyprinter-compat-wl-pprint";

4 version = "1.0.0.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base prettyprinter text ];

6 libraryHaskellDepends = [ base prettyprinter text ];

10 homepage = "http://github.com/quchen/prettyprinter";

7 homepage = "http://github.com/quchen/prettyprinter";

11 description = "Prettyprinter compatibility module for previous users of the wl-pprint package";

8 description = "Prettyprinter compatibility module for previous users of the wl-pprint package";

12 license = stdenv.lib.licenses.bsd2;

9 license = stdenv.lib.licenses.bsd2;

13−}

10+}

test/golden-test-cases/primitive.nix.golden+3−6

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, fetchurl, ghc-prim, transformers }:

1+{ mkDerivation, base, ghc-prim, stdenv, transformers }:

2mkDerivation {

3 pname = "primitive";

4 version = "0.6.2.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ghc-prim transformers ];

6 libraryHaskellDepends = [ base ghc-prim transformers ];

10 testHaskellDepends = [ base ghc-prim ];

7 testHaskellDepends = [ base ghc-prim ];

11 homepage = "https://github.com/haskell/primitive";

8 homepage = "https://github.com/haskell/primitive";

12 description = "Primitive memory-related operations";

9 description = "Primitive memory-related operations";

13 license = stdenv.lib.licenses.bsd3;

10 license = stdenv.lib.licenses.bsd3;

14−}

11+}

test/golden-test-cases/product-profunctors.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, contravariant, fetchurl, profunctors, tagged

1+{ mkDerivation, base, contravariant, profunctors, stdenv, tagged

2, template-haskell

3}:

4mkDerivation {

5 pname = "product-profunctors";

6 version = "0.8.0.3";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base contravariant profunctors tagged template-haskell

9 base contravariant profunctors tagged template-haskell

13 ];

10 ];

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://github.com/tomjaguarpaw/product-profunctors";

12 homepage = "https://github.com/tomjaguarpaw/product-profunctors";

16 description = "product-profunctors";

13 description = "product-profunctors";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/profiterole.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, containers, directory, extra, fetchurl

1+{ mkDerivation, base, containers, directory, extra, filepath

2−, filepath, ghc-prof, hashable, scientific, text

2+, ghc-prof, hashable, scientific, stdenv, text

3}:

4mkDerivation {

5 pname = "profiterole";

6 version = "0.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 isLibrary = false;

8 isLibrary = false;

12 isExecutable = true;

9 isExecutable = true;

13 executableHaskellDepends = [

10 executableHaskellDepends = [

@@ -17,4 +14,4 @@ mkDerivation {

17 homepage = "https://github.com/ndmitchell/profiterole#readme";

14 homepage = "https://github.com/ndmitchell/profiterole#readme";

18 description = "Restructure GHC profile reports";

15 description = "Restructure GHC profile reports";

19 license = stdenv.lib.licenses.bsd3;

16 license = stdenv.lib.licenses.bsd3;

20−}

17+}

test/golden-test-cases/projectroot.nix.golden+3−6

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, directory, fetchurl, hspec, QuickCheck }:

1+{ mkDerivation, base, directory, hspec, QuickCheck, stdenv }:

2mkDerivation {

3 pname = "projectroot";

4 version = "0.2.0.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base directory ];

6 libraryHaskellDepends = [ base directory ];

10 testHaskellDepends = [ base hspec QuickCheck ];

7 testHaskellDepends = [ base hspec QuickCheck ];

11 homepage = "https://github.com/yamadapc/haskell-projectroot";

8 homepage = "https://github.com/yamadapc/haskell-projectroot";

12 description = "Bindings to the projectroot C logic";

9 description = "Bindings to the projectroot C logic";

13 license = stdenv.lib.licenses.mit;

10 license = stdenv.lib.licenses.mit;

14−}

11+}

test/golden-test-cases/proto-lens-optparse.nix.golden+3−6

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, fetchurl, optparse-applicative, proto-lens

1+{ mkDerivation, base, optparse-applicative, proto-lens, stdenv

2, text

3}:

4mkDerivation {

5 pname = "proto-lens-optparse";

6 version = "0.1.0.4";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base optparse-applicative proto-lens text

9 base optparse-applicative proto-lens text

13 ];

10 ];

14 homepage = "https://github.com/google/proto-lens";

11 homepage = "https://github.com/google/proto-lens";

15 description = "Adapting proto-lens to optparse-applicative ReadMs";

12 description = "Adapting proto-lens to optparse-applicative ReadMs";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/proto-lens.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, attoparsec, base, bytestring, containers

2−, data-default-class, fetchurl, lens-family, parsec, pretty, text

2+, data-default-class, lens-family, parsec, pretty, stdenv, text

3, transformers, void

4}:

5mkDerivation {

6 pname = "proto-lens";

7 version = "0.2.2.0";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 attoparsec base bytestring containers data-default-class

10 attoparsec base bytestring containers data-default-class

14 lens-family parsec pretty text transformers void

11 lens-family parsec pretty text transformers void

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/google/proto-lens";

13 homepage = "https://github.com/google/proto-lens";

17 description = "A lens-based implementation of protocol buffers in Haskell";

14 description = "A lens-based implementation of protocol buffers in Haskell";

18 license = stdenv.lib.licenses.bsd3;

15 license = stdenv.lib.licenses.bsd3;

19−}

16+}

test/golden-test-cases/psqueues.nix.golden+4−7

@@ -1,16 +1,13 @@

1{ mkDerivation, array, base, containers, criterion, deepseq

2−, fetchurl, fingertree-psqueue, ghc-prim, hashable, HUnit, mtl

2+, fingertree-psqueue, ghc-prim, hashable, HUnit, mtl, PSQueue

3−, PSQueue, QuickCheck, random, tagged, test-framework

3+, QuickCheck, random, stdenv, tagged, test-framework

4, test-framework-hunit, test-framework-quickcheck2

5, unordered-containers

6}:

7mkDerivation {

8 pname = "psqueues";

9 version = "0.2.4.0";

10− src = fetchurl {

10+ sha256 = "deadbeef";

11− url = "http://example.org/";

12− sha256 = "abc";

13− };

14 libraryHaskellDepends = [ base deepseq ghc-prim hashable ];

11 libraryHaskellDepends = [ base deepseq ghc-prim hashable ];

15 testHaskellDepends = [

12 testHaskellDepends = [

16 array base deepseq ghc-prim hashable HUnit QuickCheck tagged

13 array base deepseq ghc-prim hashable HUnit QuickCheck tagged

@@ -22,4 +19,4 @@ mkDerivation {

22 ];

19 ];

23 description = "Pure priority search queues";

20 description = "Pure priority search queues";

24 license = stdenv.lib.licenses.bsd3;

21 license = stdenv.lib.licenses.bsd3;

25−}

22+}

test/golden-test-cases/pusher-http-haskell.nix.golden+4−7

@@ -1,15 +1,12 @@

1{ mkDerivation, aeson, base, base16-bytestring, bytestring

2−, cryptonite, fetchurl, hashable, hspec, http-client, http-types

2+, cryptonite, hashable, hspec, http-client, http-types, memory

3−, memory, QuickCheck, scientific, text, time, transformers

3+, QuickCheck, scientific, stdenv, text, time, transformers

4, unordered-containers, vector

5}:

6mkDerivation {

7 pname = "pusher-http-haskell";

8 version = "1.5.1.0";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

14 aeson base base16-bytestring bytestring cryptonite hashable

11 aeson base base16-bytestring bytestring cryptonite hashable

15 http-client http-types memory text time transformers

12 http-client http-types memory text time transformers

@@ -23,4 +20,4 @@ mkDerivation {

23 homepage = "https://github.com/pusher-community/pusher-http-haskell";

20 homepage = "https://github.com/pusher-community/pusher-http-haskell";

24 description = "Haskell client library for the Pusher HTTP API";

21 description = "Haskell client library for the Pusher HTTP API";

25 license = stdenv.lib.licenses.mit;

22 license = stdenv.lib.licenses.mit;

26−}

23+}

test/golden-test-cases/quickcheck-arbitrary-adt.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, hspec, lens, QuickCheck

1+{ mkDerivation, base, hspec, lens, QuickCheck, stdenv

2, template-haskell, transformers

3}:

4mkDerivation {

5 pname = "quickcheck-arbitrary-adt";

6 version = "0.2.0.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base QuickCheck ];

8 libraryHaskellDepends = [ base QuickCheck ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 base hspec lens QuickCheck template-haskell transformers

10 base hspec lens QuickCheck template-haskell transformers

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://github.com/plow-technologies/quickcheck-arbitrary-adt#readme";

12 homepage = "https://github.com/plow-technologies/quickcheck-arbitrary-adt#readme";

16 description = "Generic typeclasses for generating arbitrary ADTs";

13 description = "Generic typeclasses for generating arbitrary ADTs";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/quickcheck-combinators.nix.golden+3−7

@@ -1,13 +1,9 @@

1−{ mkDerivation, base, fetchurl, QuickCheck, unfoldable-restricted

1+{ mkDerivation, base, QuickCheck, stdenv, unfoldable-restricted }:

2−}:

3mkDerivation {

2mkDerivation {

4 pname = "quickcheck-combinators";

3 pname = "quickcheck-combinators";

5 version = "0.0.2";

4 version = "0.0.2";

6− src = fetchurl {

5+ sha256 = "deadbeef";

7− url = "http://example.org/";

8− sha256 = "abc";

9− };

10 libraryHaskellDepends = [ base QuickCheck unfoldable-restricted ];

6 libraryHaskellDepends = [ base QuickCheck unfoldable-restricted ];

11 description = "Simple type-level combinators for augmenting QuickCheck instances";

7 description = "Simple type-level combinators for augmenting QuickCheck instances";

12 license = stdenv.lib.licenses.bsd3;

8 license = stdenv.lib.licenses.bsd3;

13−}

9+}

test/golden-test-cases/rank1dynamic.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, binary, fetchurl, HUnit, test-framework

1+{ mkDerivation, base, binary, HUnit, stdenv, test-framework

2, test-framework-hunit

3}:

4mkDerivation {

5 pname = "rank1dynamic";

6 version = "0.4.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base binary ];

8 libraryHaskellDepends = [ base binary ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 base HUnit test-framework test-framework-hunit

10 base HUnit test-framework test-framework-hunit

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "http://haskell-distributed.github.com";

12 homepage = "http://haskell-distributed.github.com";

16 description = "Like Data.Dynamic/Data.Typeable but with support for rank-1 polymorphic types";

13 description = "Like Data.Dynamic/Data.Typeable but with support for rank-1 polymorphic types";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/rasterific-svg.nix.golden+5−8

@@ -1,15 +1,12 @@

1{ mkDerivation, base, binary, bytestring, containers, directory

2−, fetchurl, filepath, FontyFruity, JuicyPixels, lens, linear, mtl

2+, filepath, FontyFruity, JuicyPixels, lens, linear, mtl

3−, optparse-applicative, primitive, Rasterific, scientific, svg-tree

3+, optparse-applicative, primitive, Rasterific, scientific, stdenv

4−, text, transformers, vector

4+, svg-tree, text, transformers, vector

5}:

6mkDerivation {

7 pname = "rasterific-svg";

8 version = "0.3.3";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 isLibrary = true;

10 isLibrary = true;

14 isExecutable = true;

11 isExecutable = true;

15 libraryHaskellDepends = [

12 libraryHaskellDepends = [

@@ -23,4 +20,4 @@ mkDerivation {

23 ];

20 ];

24 description = "SVG renderer based on Rasterific";

21 description = "SVG renderer based on Rasterific";

25 license = stdenv.lib.licenses.bsd3;

22 license = stdenv.lib.licenses.bsd3;

26−}

23+}

test/golden-test-cases/ratio-int.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl }:

1+{ mkDerivation, base, stdenv }:

2mkDerivation {

3 pname = "ratio-int";

4 version = "0.1.2";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 homepage = "https://github.com/RaphaelJ/ratio-int";

7 homepage = "https://github.com/RaphaelJ/ratio-int";

11 description = "Fast specialisation of Data.Ratio for Int.";

8 description = "Fast specialisation of Data.Ratio for Int.";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/rawstring-qm.nix.golden+3−7

@@ -1,14 +1,10 @@

1−{ mkDerivation, base, bytestring, fetchurl, template-haskell, text

1+{ mkDerivation, base, bytestring, stdenv, template-haskell, text }:

2−}:

3mkDerivation {

2mkDerivation {

4 pname = "rawstring-qm";

3 pname = "rawstring-qm";

5 version = "0.2.3.0";

4 version = "0.2.3.0";

6− src = fetchurl {

5+ sha256 = "deadbeef";

7− url = "http://example.org/";

8− sha256 = "abc";

9− };

10 libraryHaskellDepends = [ base bytestring template-haskell text ];

6 libraryHaskellDepends = [ base bytestring template-haskell text ];

11 homepage = "https://github.com/tolysz/rawstring-qm";

7 homepage = "https://github.com/tolysz/rawstring-qm";

12 description = "Simple raw string quotation and dictionary interpolation";

8 description = "Simple raw string quotation and dictionary interpolation";

13 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

14−}

10+}

test/golden-test-cases/reactive-banana.nix.golden+4−7

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, containers, fetchurl, hashable, HUnit, pqueue

1+{ mkDerivation, base, containers, hashable, HUnit, pqueue, psqueues

2−, psqueues, test-framework, test-framework-hunit, transformers

2+, stdenv, test-framework, test-framework-hunit, transformers

3, unordered-containers, vault

4}:

5mkDerivation {

6 pname = "reactive-banana";

7 version = "1.1.0.1";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 base containers hashable pqueue transformers unordered-containers

10 base containers hashable pqueue transformers unordered-containers

14 vault

11 vault

@@ -20,4 +17,4 @@ mkDerivation {

20 homepage = "http://wiki.haskell.org/Reactive-banana";

17 homepage = "http://wiki.haskell.org/Reactive-banana";

21 description = "Library for functional reactive programming (FRP)";

18 description = "Library for functional reactive programming (FRP)";

22 license = stdenv.lib.licenses.bsd3;

19 license = stdenv.lib.licenses.bsd3;

23−}

20+}

test/golden-test-cases/readline.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, ncurses, process, readline }:

1+{ mkDerivation, base, ncurses, process, readline, stdenv }:

2mkDerivation {

3 pname = "readline";

4 version = "1.0.3.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base process ];

6 libraryHaskellDepends = [ base process ];

10 librarySystemDepends = [ ncurses readline ];

7 librarySystemDepends = [ ncurses readline ];

11 description = "An interface to the GNU readline library";

8 description = "An interface to the GNU readline library";

12 license = "GPL";

9 license = "GPL";

13−}

10+}

test/golden-test-cases/rebase.nix.golden+4−7

@@ -1,16 +1,13 @@

1{ mkDerivation, base, base-prelude, bifunctors, bytestring

2, containers, contravariant, contravariant-extras, deepseq, dlist

3−, either, fail, fetchurl, hashable, mtl, profunctors, scientific

3+, either, fail, hashable, mtl, profunctors, scientific

4−, semigroupoids, semigroups, stm, text, time, transformers

4+, semigroupoids, semigroups, stdenv, stm, text, time, transformers

5, unordered-containers, uuid, vector, void

6}:

7mkDerivation {

8 pname = "rebase";

9 version = "1.1.1";

10− src = fetchurl {

10+ sha256 = "deadbeef";

11− url = "http://example.org/";

12− sha256 = "abc";

13− };

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

15 base base-prelude bifunctors bytestring containers contravariant

12 base base-prelude bifunctors bytestring containers contravariant

16 contravariant-extras deepseq dlist either fail hashable mtl

13 contravariant-extras deepseq dlist either fail hashable mtl

@@ -20,4 +17,4 @@ mkDerivation {

20 homepage = "https://github.com/nikita-volkov/rebase";

17 homepage = "https://github.com/nikita-volkov/rebase";

21 description = "A more progressive alternative to the \"base\" package";

18 description = "A more progressive alternative to the \"base\" package";

22 license = stdenv.lib.licenses.mit;

19 license = stdenv.lib.licenses.mit;

23−}

20+}

test/golden-test-cases/reform-blaze.nix.golden+3−6

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, blaze-html, blaze-markup, fetchurl, reform

1+{ mkDerivation, base, blaze-html, blaze-markup, reform, stdenv

2, text

3}:

4mkDerivation {

5 pname = "reform-blaze";

6 version = "0.2.4.3";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base blaze-html blaze-markup reform text

9 base blaze-html blaze-markup reform text

13 ];

10 ];

14 homepage = "http://www.happstack.com/";

11 homepage = "http://www.happstack.com/";

15 description = "Add support for using blaze-html with Reform";

12 description = "Add support for using blaze-html with Reform";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/reform-hsp.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, hsp, hsx2hs, reform, text }:

1+{ mkDerivation, base, hsp, hsx2hs, reform, stdenv, text }:

2mkDerivation {

3 pname = "reform-hsp";

4 version = "0.2.7.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base hsp hsx2hs reform text ];

6 libraryHaskellDepends = [ base hsp hsx2hs reform text ];

10 homepage = "http://www.happstack.com/";

7 homepage = "http://www.happstack.com/";

11 description = "Add support for using HSP with Reform";

8 description = "Add support for using HSP with Reform";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/regex-compat.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, array, base, fetchurl, regex-base, regex-posix }:

1+{ mkDerivation, array, base, regex-base, regex-posix, stdenv }:

2mkDerivation {

3 pname = "regex-compat";

4 version = "0.95.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ array base regex-base regex-posix ];

6 libraryHaskellDepends = [ array base regex-base regex-posix ];

10 homepage = "http://sourceforge.net/projects/lazy-regex";

7 homepage = "http://sourceforge.net/projects/lazy-regex";

11 description = "Replaces/Enhances Text.Regex";

8 description = "Replaces/Enhances Text.Regex";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/regex-pcre.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, array, base, bytestring, containers, fetchurl, pcre

1+{ mkDerivation, array, base, bytestring, containers, pcre

2−, regex-base

2+, regex-base, stdenv

3}:

4mkDerivation {

5 pname = "regex-pcre";

6 version = "0.94.4";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 array base bytestring containers regex-base

9 array base bytestring containers regex-base

13 ];

10 ];

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "http://hackage.haskell.org/package/regex-pcre";

12 homepage = "http://hackage.haskell.org/package/regex-pcre";

16 description = "Replaces/Enhances Text.Regex";

13 description = "Replaces/Enhances Text.Regex";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/relational-query.nix.golden+4−7

@@ -1,15 +1,12 @@

1{ mkDerivation, array, base, bytestring, containers, dlist

2−, fetchurl, names-th, persistable-record, product-isomorphic

2+, names-th, persistable-record, product-isomorphic

3−, quickcheck-simple, sql-words, template-haskell, text

3+, quickcheck-simple, sql-words, stdenv, template-haskell, text

4, th-reify-compat, time, time-locale-compat, transformers

5}:

6mkDerivation {

7 pname = "relational-query";

8 version = "0.11.0.0";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

14 array base bytestring containers dlist names-th persistable-record

11 array base bytestring containers dlist names-th persistable-record

15 product-isomorphic sql-words template-haskell text th-reify-compat

12 product-isomorphic sql-words template-haskell text th-reify-compat

@@ -21,4 +18,4 @@ mkDerivation {

21 homepage = "http://khibino.github.io/haskell-relational-record/";

18 homepage = "http://khibino.github.io/haskell-relational-record/";

22 description = "Typeful, Modular, Relational, algebraic query engine";

19 description = "Typeful, Modular, Relational, algebraic query engine";

23 license = stdenv.lib.licenses.bsd3;

20 license = stdenv.lib.licenses.bsd3;

24−}

21+}

test/golden-test-cases/relational-schemas.nix.golden+4−7

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, bytestring, containers, fetchurl

1+{ mkDerivation, base, bytestring, containers, relational-query

2−, relational-query, template-haskell, time

2+, stdenv, template-haskell, time

3}:

4mkDerivation {

5 pname = "relational-schemas";

6 version = "0.1.6.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base bytestring containers relational-query template-haskell time

9 base bytestring containers relational-query template-haskell time

13 ];

10 ];

14 homepage = "http://khibino.github.io/haskell-relational-record/";

11 homepage = "http://khibino.github.io/haskell-relational-record/";

15 description = "RDBMSs' schema templates for relational-query";

12 description = "RDBMSs' schema templates for relational-query";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/repa-io.nix.golden+4−7

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, binary, bmp, bytestring, fetchurl, old-time

1+{ mkDerivation, base, binary, bmp, bytestring, old-time, repa

2−, repa, vector

2+, stdenv, vector

3}:

4mkDerivation {

5 pname = "repa-io";

6 version = "3.4.1.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base binary bmp bytestring old-time repa vector

9 base binary bmp bytestring old-time repa vector

13 ];

10 ];

14 homepage = "http://repa.ouroborus.net";

11 homepage = "http://repa.ouroborus.net";

15 description = "Read and write Repa arrays in various formats";

12 description = "Read and write Repa arrays in various formats";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/repa.nix.golden+3−6

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, bytestring, fetchurl, ghc-prim, QuickCheck

1+{ mkDerivation, base, bytestring, ghc-prim, QuickCheck, stdenv

2, template-haskell, vector

3}:

4mkDerivation {

5 pname = "repa";

6 version = "3.4.1.3";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base bytestring ghc-prim QuickCheck template-haskell vector

9 base bytestring ghc-prim QuickCheck template-haskell vector

13 ];

10 ];

14 homepage = "http://repa.ouroborus.net";

11 homepage = "http://repa.ouroborus.net";

15 description = "High performance, regular, shape polymorphic parallel arrays";

12 description = "High performance, regular, shape polymorphic parallel arrays";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/rosezipper.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, base, containers, fetchurl }:

1+{ mkDerivation, base, containers, stdenv }:

2mkDerivation {

3 pname = "rosezipper";

4 version = "0.2";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base containers ];

6 libraryHaskellDepends = [ base containers ];

10 description = "Generic zipper implementation for Data.Tree";

7 description = "Generic zipper implementation for Data.Tree";

11 license = stdenv.lib.licenses.bsd3;

8 license = stdenv.lib.licenses.bsd3;

12−}

9+}

test/golden-test-cases/rvar.nix.golden+3−6

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, fetchurl, MonadPrompt, mtl, random-source

1+{ mkDerivation, base, MonadPrompt, mtl, random-source, stdenv

2, transformers

3}:

4mkDerivation {

5 pname = "rvar";

6 version = "0.2.0.3";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base MonadPrompt mtl random-source transformers

9 base MonadPrompt mtl random-source transformers

13 ];

10 ];

14 homepage = "https://github.com/mokus0/random-fu";

11 homepage = "https://github.com/mokus0/random-fu";

15 description = "Random Variables";

12 description = "Random Variables";

16 license = stdenv.lib.licenses.publicDomain;

13 license = stdenv.lib.licenses.publicDomain;

17−}

14+}

test/golden-test-cases/scalpel-core.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, base, bytestring, containers, criterion

2−, data-default, fail, fetchurl, HUnit, regex-base, regex-tdfa

2+, data-default, fail, HUnit, regex-base, regex-tdfa, stdenv

3, tagsoup, text, vector

4}:

5mkDerivation {

6 pname = "scalpel-core";

7 version = "0.5.1";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 base bytestring containers data-default fail regex-base regex-tdfa

10 base bytestring containers data-default fail regex-base regex-tdfa

14 tagsoup text vector

11 tagsoup text vector

@@ -18,4 +15,4 @@ mkDerivation {

18 homepage = "https://github.com/fimad/scalpel";

15 homepage = "https://github.com/fimad/scalpel";

19 description = "A high level web scraping library for Haskell";

16 description = "A high level web scraping library for Haskell";

20 license = stdenv.lib.licenses.asl20;

17 license = stdenv.lib.licenses.asl20;

21−}

18+}

test/golden-test-cases/sdl2.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, exceptions, fetchurl, linear

1+{ mkDerivation, base, bytestring, exceptions, linear, SDL2

2−, SDL2, StateVar, text, transformers, vector

2+, StateVar, stdenv, text, transformers, vector

3}:

4mkDerivation {

5 pname = "sdl2";

6 version = "2.3.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 isLibrary = true;

8 isLibrary = true;

12 isExecutable = true;

9 isExecutable = true;

13 enableSeparateDataOutput = true;

10 enableSeparateDataOutput = true;

@@ -18,4 +15,4 @@ mkDerivation {

18 libraryPkgconfigDepends = [ SDL2 ];

15 libraryPkgconfigDepends = [ SDL2 ];

19 description = "Both high- and low-level bindings to the SDL library (version 2.0.4+).";

16 description = "Both high- and low-level bindings to the SDL library (version 2.0.4+).";

20 license = stdenv.lib.licenses.bsd3;

17 license = stdenv.lib.licenses.bsd3;

21−}

18+}

test/golden-test-cases/selda-sqlite.nix.golden+4−7

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, direct-sqlite, directory, exceptions

1+{ mkDerivation, base, direct-sqlite, directory, exceptions, selda

2−, fetchurl, selda, text

2+, stdenv, text

3}:

4mkDerivation {

5 pname = "selda-sqlite";

6 version = "0.1.6.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base direct-sqlite directory exceptions selda text

9 base direct-sqlite directory exceptions selda text

13 ];

10 ];

14 homepage = "https://github.com/valderman/selda";

11 homepage = "https://github.com/valderman/selda";

15 description = "SQLite backend for the Selda database EDSL";

12 description = "SQLite backend for the Selda database EDSL";

16 license = stdenv.lib.licenses.mit;

13 license = stdenv.lib.licenses.mit;

17−}

14+}

test/golden-test-cases/selda.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, exceptions, fetchurl, hashable

1+{ mkDerivation, base, bytestring, exceptions, hashable, mtl

2−, mtl, psqueues, text, time, unordered-containers

2+, psqueues, stdenv, text, time, unordered-containers

3}:

4mkDerivation {

5 pname = "selda";

6 version = "0.1.11.2";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base bytestring exceptions hashable mtl psqueues text time

9 base bytestring exceptions hashable mtl psqueues text time

13 unordered-containers

10 unordered-containers

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://selda.link";

12 homepage = "https://selda.link";

16 description = "Type-safe, high-level EDSL for interacting with relational databases";

13 description = "Type-safe, high-level EDSL for interacting with relational databases";

17 license = stdenv.lib.licenses.mit;

14 license = stdenv.lib.licenses.mit;

18−}

15+}

test/golden-test-cases/servant-checked-exceptions.nix.golden+6−15

@@ -1,27 +1,18 @@

1−{ mkDerivation, aeson, base, bytestring, deepseq, doctest, fetchurl

1+{ mkDerivation, aeson, base, bytestring, deepseq, doctest, Glob

2−, Glob, hspec-wai, http-api-data, http-client, http-media

2+, hspec-wai, http-media, profunctors, servant, servant-client

3−, natural-transformation, optparse-applicative, profunctors

3+, servant-docs, servant-server, stdenv, tagged, tasty, tasty-hspec

4−, servant, servant-client, servant-docs, servant-server, tagged

4+, tasty-hunit, text, wai

5−, tasty, tasty-hspec, tasty-hunit, text, wai, warp

6}:

5}:

7mkDerivation {

6mkDerivation {

8 pname = "servant-checked-exceptions";

7 pname = "servant-checked-exceptions";

9 version = "0.4.1.0";

8 version = "0.4.1.0";

10− src = fetchurl {

9+ sha256 = "deadbeef";

11− url = "http://example.org/";

12− sha256 = "abc";

13− };

14 isLibrary = true;

10 isLibrary = true;

15 isExecutable = true;

11 isExecutable = true;

16 libraryHaskellDepends = [

12 libraryHaskellDepends = [

17 aeson base bytestring deepseq http-media profunctors servant

13 aeson base bytestring deepseq http-media profunctors servant

18 servant-client servant-docs servant-server tagged text

14 servant-client servant-docs servant-server tagged text

19 ];

15 ];

20− executableHaskellDepends = [

21− aeson base http-api-data http-client natural-transformation

22− optparse-applicative servant servant-client servant-docs

23− servant-server text wai warp

24− ];

25 testHaskellDepends = [

16 testHaskellDepends = [

26 base bytestring doctest Glob hspec-wai servant servant-server tasty

17 base bytestring doctest Glob hspec-wai servant servant-server tasty

27 tasty-hspec tasty-hunit wai

18 tasty-hspec tasty-hunit wai

@@ -29,4 +20,4 @@ mkDerivation {

29 homepage = "https://github.com/cdepillabout/servant-checked-exceptions";

20 homepage = "https://github.com/cdepillabout/servant-checked-exceptions";

30 description = "Checked exceptions for Servant APIs";

21 description = "Checked exceptions for Servant APIs";

31 license = stdenv.lib.licenses.bsd3;

22 license = stdenv.lib.licenses.bsd3;

32−}

23+}

test/golden-test-cases/set-cover.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, containers, enummapset, fetchurl, psqueues

1+{ mkDerivation, base, containers, enummapset, psqueues, stdenv

2, utility-ht

3}:

4mkDerivation {

5 pname = "set-cover";

6 version = "0.0.8";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 isLibrary = true;

8 isLibrary = true;

12 isExecutable = true;

9 isExecutable = true;

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "http://hub.darcs.net/thielema/set-cover/";

13 homepage = "http://hub.darcs.net/thielema/set-cover/";

17 description = "Solve exact set cover problems like Sudoku, 8 Queens, Soma Cube, Tetris Cube";

14 description = "Solve exact set cover problems like Sudoku, 8 Queens, Soma Cube, Tetris Cube";

18 license = stdenv.lib.licenses.bsd3;

15 license = stdenv.lib.licenses.bsd3;

19−}

16+}

test/golden-test-cases/sets.nix.golden+6−9

@@ -1,16 +1,13 @@

1{ mkDerivation, base, commutative, composition, containers

2−, contravariant, criterion, fetchurl, hashable, keys, mtl

2+, contravariant, criterion, hashable, keys, mtl, QuickCheck

3−, QuickCheck, quickcheck-instances, semigroupoids, semigroups

3+, quickcheck-instances, semigroupoids, semigroups, stdenv, tasty

4−, tasty, tasty-hunit, tasty-quickcheck, transformers

4+, tasty-hunit, tasty-quickcheck, transformers, transformers-base

5−, transformers-base, unordered-containers, witherable

5+, unordered-containers, witherable

6}:

7mkDerivation {

8 pname = "sets";

9 version = "0.0.5.2";

10− src = fetchurl {

10+ sha256 = "deadbeef";

11− url = "http://example.org/";

12− sha256 = "abc";

13− };

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

15 base commutative composition containers contravariant hashable keys

12 base commutative composition containers contravariant hashable keys

16 mtl QuickCheck semigroupoids semigroups transformers

13 mtl QuickCheck semigroupoids semigroups transformers

@@ -27,4 +24,4 @@ mkDerivation {

27 ];

24 ];

28 description = "Ducktyped set interface for Haskell containers";

25 description = "Ducktyped set interface for Haskell containers";

29 license = stdenv.lib.licenses.mit;

26 license = stdenv.lib.licenses.mit;

30−}

27+}

test/golden-test-cases/simple-smt.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, base, fetchurl, process }:

1+{ mkDerivation, base, process, stdenv }:

2mkDerivation {

3 pname = "simple-smt";

4 version = "0.7.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base process ];

6 libraryHaskellDepends = [ base process ];

10 description = "A simple way to interact with an SMT solver process";

7 description = "A simple way to interact with an SMT solver process";

11 license = stdenv.lib.licenses.bsd3;

8 license = stdenv.lib.licenses.bsd3;

12−}

9+}

test/golden-test-cases/slack-web.nix.golden+4−7

@@ -1,14 +1,11 @@

1−{ mkDerivation, aeson, base, containers, errors, fetchurl, hspec

1+{ mkDerivation, aeson, base, containers, errors, hspec

2, http-api-data, http-client, http-client-tls, megaparsec, mtl

3−, servant, servant-client, text, time, transformers

3+, servant, servant-client, stdenv, text, time, transformers

4}:

5mkDerivation {

6 pname = "slack-web";

7 version = "0.2.0.1";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 aeson base containers errors http-api-data http-client

10 aeson base containers errors http-api-data http-client

14 http-client-tls megaparsec mtl servant servant-client text time

11 http-client-tls megaparsec mtl servant servant-client text time

@@ -21,4 +18,4 @@ mkDerivation {

21 homepage = "https://github.com/jpvillaisaza/slack-web";

18 homepage = "https://github.com/jpvillaisaza/slack-web";

22 description = "Bindings for the Slack web API";

19 description = "Bindings for the Slack web API";

23 license = stdenv.lib.licenses.mit;

20 license = stdenv.lib.licenses.mit;

24−}

21+}

test/golden-test-cases/slug.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, aeson, base, exceptions, fetchurl, hspec

1+{ mkDerivation, aeson, base, exceptions, hspec, http-api-data

2−, http-api-data, path-pieces, persistent, QuickCheck, text

2+, path-pieces, persistent, QuickCheck, stdenv, text

3}:

4mkDerivation {

5 pname = "slug";

6 version = "0.1.7";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 aeson base exceptions http-api-data path-pieces persistent

9 aeson base exceptions http-api-data path-pieces persistent

13 QuickCheck text

10 QuickCheck text

@@ -18,4 +15,4 @@ mkDerivation {

18 homepage = "https://github.com/mrkkrp/slug";

15 homepage = "https://github.com/mrkkrp/slug";

19 description = "Type-safe slugs for Yesod ecosystem";

16 description = "Type-safe slugs for Yesod ecosystem";

20 license = stdenv.lib.licenses.bsd3;

17 license = stdenv.lib.licenses.bsd3;

21−}

18+}

test/golden-test-cases/soxlib.nix.golden+4−7

@@ -1,14 +1,11 @@

1{ mkDerivation, base, bytestring, containers, explicit-exception

2−, extensible-exceptions, fetchurl, sample-frame, sox

2+, extensible-exceptions, sample-frame, sox, stdenv, storablevector

3−, storablevector, transformers, utility-ht

3+, transformers, utility-ht

4}:

5mkDerivation {

6 pname = "soxlib";

7 version = "0.0.3";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 isLibrary = true;

9 isLibrary = true;

13 isExecutable = true;

10 isExecutable = true;

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

@@ -19,4 +16,4 @@ mkDerivation {

19 homepage = "http://www.haskell.org/haskellwiki/Sox";

16 homepage = "http://www.haskell.org/haskellwiki/Sox";

20 description = "Write, read, convert audio signals using libsox";

17 description = "Write, read, convert audio signals using libsox";

21 license = stdenv.lib.licenses.bsd3;

18 license = stdenv.lib.licenses.bsd3;

22−}

19+}

test/golden-test-cases/speedy-slice.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, containers, fetchurl, kan-extensions, lens

1+{ mkDerivation, base, containers, kan-extensions, lens, mcmc-types

2−, mcmc-types, mwc-probability, pipes, primitive, transformers

2+, mwc-probability, pipes, primitive, stdenv, transformers

3}:

4mkDerivation {

5 pname = "speedy-slice";

6 version = "0.3.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base kan-extensions lens mcmc-types mwc-probability pipes primitive

9 base kan-extensions lens mcmc-types mwc-probability pipes primitive

13 transformers

10 transformers

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "http://github.com/jtobin/speedy-slice";

13 homepage = "http://github.com/jtobin/speedy-slice";

17 description = "Speedy slice sampling";

14 description = "Speedy slice sampling";

18 license = stdenv.lib.licenses.mit;

15 license = stdenv.lib.licenses.mit;

19−}

16+}

test/golden-test-cases/splice.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, network }:

1+{ mkDerivation, base, network, stdenv }:

2mkDerivation {

3 pname = "splice";

4 version = "0.6.1.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base network ];

6 libraryHaskellDepends = [ base network ];

10 homepage = "http://corsis.github.com/splice/";

7 homepage = "http://corsis.github.com/splice/";

11 description = "Cross-platform Socket to Socket Data Splicing";

8 description = "Cross-platform Socket to Socket Data Splicing";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/spreadsheet.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, explicit-exception, fetchurl, transformers

1+{ mkDerivation, base, explicit-exception, stdenv, transformers

2, utility-ht

3}:

4mkDerivation {

5 pname = "spreadsheet";

6 version = "0.1.3.7";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 isLibrary = true;

8 isLibrary = true;

12 isExecutable = true;

9 isExecutable = true;

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "http://www.haskell.org/haskellwiki/Spreadsheet";

13 homepage = "http://www.haskell.org/haskellwiki/Spreadsheet";

17 description = "Read and write spreadsheets from and to CSV files in a lazy way";

14 description = "Read and write spreadsheets from and to CSV files in a lazy way";

18 license = stdenv.lib.licenses.bsd3;

15 license = stdenv.lib.licenses.bsd3;

19−}

16+}

test/golden-test-cases/stack-type.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, transformers }:

1+{ mkDerivation, base, stdenv, transformers }:

2mkDerivation {

3 pname = "stack-type";

4 version = "0.1.0.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base transformers ];

6 libraryHaskellDepends = [ base transformers ];

10 homepage = "https://github.com/aiya000/hs-stack-type";

7 homepage = "https://github.com/aiya000/hs-stack-type";

11 description = "The basic stack type";

8 description = "The basic stack type";

12 license = stdenv.lib.licenses.mit;

9 license = stdenv.lib.licenses.mit;

13−}

10+}

test/golden-test-cases/state-codes.nix.golden+4−7

@@ -1,16 +1,13 @@

1−{ mkDerivation, aeson, base, fetchurl, hspec, QuickCheck

1+{ mkDerivation, aeson, base, hspec, QuickCheck, shakespeare, stdenv

2−, shakespeare, text

2+, text

3}:

4mkDerivation {

5 pname = "state-codes";

6 version = "0.1.3";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ aeson base shakespeare text ];

8 libraryHaskellDepends = [ aeson base shakespeare text ];

12 testHaskellDepends = [ aeson base hspec QuickCheck text ];

9 testHaskellDepends = [ aeson base hspec QuickCheck text ];

13 homepage = "https://github.com/acamino/state-codes#README";

10 homepage = "https://github.com/acamino/state-codes#README";

14 description = "ISO 3166-2:US state codes and i18n names";

11 description = "ISO 3166-2:US state codes and i18n names";

15 license = stdenv.lib.licenses.mit;

12 license = stdenv.lib.licenses.mit;

16−}

13+}

test/golden-test-cases/stb-image-redux.nix.golden+3−6

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, fetchurl, hspec, vector }:

1+{ mkDerivation, base, hspec, stdenv, vector }:

2mkDerivation {

3 pname = "stb-image-redux";

4 version = "0.2.1.2";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base vector ];

6 libraryHaskellDepends = [ base vector ];

10 testHaskellDepends = [ base hspec vector ];

7 testHaskellDepends = [ base hspec vector ];

11 homepage = "https://github.com/typedrat/stb-image-redux#readme";

8 homepage = "https://github.com/typedrat/stb-image-redux#readme";

12 description = "Image loading and writing microlibrary";

9 description = "Image loading and writing microlibrary";

13 license = stdenv.lib.licenses.bsd3;

10 license = stdenv.lib.licenses.bsd3;

14−}

11+}

test/golden-test-cases/stm-containers.nix.golden+6−9

@@ -1,16 +1,13 @@

1{ mkDerivation, async, base, base-prelude, containers, criterion

2−, fetchurl, focus, free, hashable, hashtables, HTF, list-t, loch-th

2+, focus, free, hashable, hashtables, HTF, list-t, loch-th, mtl

3−, mtl, mtl-prelude, mwc-random, mwc-random-monad, placeholders

3+, mtl-prelude, mwc-random, mwc-random-monad, placeholders

4−, primitive, QuickCheck, text, transformers, unordered-containers

4+, primitive, QuickCheck, stdenv, text, transformers

5−, vector

5+, unordered-containers, vector

6}:

7mkDerivation {

8 pname = "stm-containers";

9 version = "0.2.16";

10− src = fetchurl {

10+ sha256 = "deadbeef";

11− url = "http://example.org/";

12− sha256 = "abc";

13− };

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

15 base base-prelude focus hashable list-t primitive transformers

12 base base-prelude focus hashable list-t primitive transformers

16 ];

13 ];

@@ -27,4 +24,4 @@ mkDerivation {

27 homepage = "https://github.com/nikita-volkov/stm-containers";

24 homepage = "https://github.com/nikita-volkov/stm-containers";

28 description = "Containers for STM";

25 description = "Containers for STM";

29 license = stdenv.lib.licenses.mit;

26 license = stdenv.lib.licenses.mit;

30−}

27+}

test/golden-test-cases/streaming-commons.nix.golden+4−7

@@ -1,14 +1,11 @@

1{ mkDerivation, array, async, base, blaze-builder, bytestring

2−, criterion, deepseq, directory, fetchurl, hspec, network, process

2+, criterion, deepseq, directory, hspec, network, process

3−, QuickCheck, random, stm, text, transformers, unix, zlib

3+, QuickCheck, random, stdenv, stm, text, transformers, unix, zlib

4}:

5mkDerivation {

6 pname = "streaming-commons";

7 version = "0.1.18";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 array async base blaze-builder bytestring directory network process

10 array async base blaze-builder bytestring directory network process

14 random stm text transformers unix zlib

11 random stm text transformers unix zlib

@@ -23,4 +20,4 @@ mkDerivation {

23 homepage = "https://github.com/fpco/streaming-commons";

20 homepage = "https://github.com/fpco/streaming-commons";

24 description = "Common lower-level functions needed by various streaming data libraries";

21 description = "Common lower-level functions needed by various streaming data libraries";

25 license = stdenv.lib.licenses.mit;

22 license = stdenv.lib.licenses.mit;

26−}

23+}

test/golden-test-cases/strict-base-types.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, aeson, base, bifunctors, binary, deepseq, fetchurl

1+{ mkDerivation, aeson, base, bifunctors, binary, deepseq, ghc-prim

2−, ghc-prim, hashable, lens, QuickCheck, strict

2+, hashable, lens, QuickCheck, stdenv, strict

3}:

4mkDerivation {

5 pname = "strict-base-types";

6 version = "0.5.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 aeson base bifunctors binary deepseq ghc-prim hashable lens

9 aeson base bifunctors binary deepseq ghc-prim hashable lens

13 QuickCheck strict

10 QuickCheck strict

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://github.com/meiersi/strict-base-types";

12 homepage = "https://github.com/meiersi/strict-base-types";

16 description = "Strict variants of the types provided in base";

13 description = "Strict variants of the types provided in base";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/strict-types.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, array, base, bytestring, containers, deepseq

2−, fetchurl, hashable, text, unordered-containers, vector

2+, hashable, stdenv, text, unordered-containers, vector

3}:

4mkDerivation {

5 pname = "strict-types";

6 version = "0.1.2";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 array base bytestring containers deepseq hashable text

9 array base bytestring containers deepseq hashable text

13 unordered-containers vector

10 unordered-containers vector

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://github.com/pepeiborra/strict-types";

12 homepage = "https://github.com/pepeiborra/strict-types";

16 description = "A type level predicate ranging over strict types";

13 description = "A type level predicate ranging over strict types";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/string-class.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, fetchurl, tagged, text }:

1+{ mkDerivation, base, bytestring, stdenv, tagged, text }:

2mkDerivation {

3 pname = "string-class";

4 version = "0.1.6.5";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base bytestring tagged text ];

6 libraryHaskellDepends = [ base bytestring tagged text ];

10 homepage = "https://github.com/bairyn/string-class";

7 homepage = "https://github.com/bairyn/string-class";

11 description = "String class library";

8 description = "String class library";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/stripe-haskell.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, stripe-core, stripe-http-streams }:

1+{ mkDerivation, base, stdenv, stripe-core, stripe-http-streams }:

2mkDerivation {

3 pname = "stripe-haskell";

4 version = "2.2.3";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base stripe-core stripe-http-streams ];

6 libraryHaskellDepends = [ base stripe-core stripe-http-streams ];

10 homepage = "https://github.com/dmjio/stripe";

7 homepage = "https://github.com/dmjio/stripe";

11 description = "Stripe API for Haskell";

8 description = "Stripe API for Haskell";

12 license = stdenv.lib.licenses.mit;

9 license = stdenv.lib.licenses.mit;

13−}

10+}

test/golden-test-cases/svg-tree.nix.golden+5−8

@@ -1,18 +1,15 @@

1−{ mkDerivation, attoparsec, base, bytestring, containers, fetchurl

1+{ mkDerivation, attoparsec, base, bytestring, containers

2−, JuicyPixels, lens, linear, mtl, scientific, text, transformers

2+, JuicyPixels, lens, linear, mtl, scientific, stdenv, text

3−, vector, xml

3+, transformers, vector, xml

4}:

5mkDerivation {

6 pname = "svg-tree";

7 version = "0.6.2.1";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 attoparsec base bytestring containers JuicyPixels lens linear mtl

10 attoparsec base bytestring containers JuicyPixels lens linear mtl

14 scientific text transformers vector xml

11 scientific text transformers vector xml

15 ];

12 ];

16 description = "SVG file loader and serializer";

13 description = "SVG file loader and serializer";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/swagger.nix.golden+5−7

@@ -1,17 +1,15 @@

1−{ mkDerivation, aeson, base, bytestring, fetchurl, tasty

1+{ mkDerivation, aeson, base, bytestring, stdenv, tasty, tasty-hunit

2−, tasty-hunit, text, time, transformers

2+, text, time, transformers

3}:

4mkDerivation {

5 pname = "swagger";

6 version = "0.3.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 aeson base bytestring text time transformers

9 aeson base bytestring text time transformers

13 ];

10 ];

14 testHaskellDepends = [ aeson base bytestring tasty tasty-hunit ];

11 testHaskellDepends = [ aeson base bytestring tasty tasty-hunit ];

15 description = "Implementation of swagger data model";

12 description = "Implementation of swagger data model";

16 license = "unknown";

13 license = "unknown";

17−}

14+ hydraPlatforms = stdenv.lib.platforms.none;

15+}

test/golden-test-cases/system-argv0.nix.golden+3−7

@@ -1,14 +1,10 @@

1−{ mkDerivation, base, bytestring, fetchurl, system-filepath, text

1+{ mkDerivation, base, bytestring, stdenv, system-filepath, text }:

2−}:

3mkDerivation {

2mkDerivation {

4 pname = "system-argv0";

3 pname = "system-argv0";

5 version = "0.1.1";

4 version = "0.1.1";

6− src = fetchurl {

5+ sha256 = "deadbeef";

7− url = "http://example.org/";

8− sha256 = "abc";

9− };

10 libraryHaskellDepends = [ base bytestring system-filepath text ];

6 libraryHaskellDepends = [ base bytestring system-filepath text ];

11 homepage = "https://john-millikin.com/software/haskell-filesystem/";

7 homepage = "https://john-millikin.com/software/haskell-filesystem/";

12 description = "Get argv[0] as a FilePath";

8 description = "Get argv[0] as a FilePath";

13 license = stdenv.lib.licenses.mit;

9 license = stdenv.lib.licenses.mit;

14−}

10+}

test/golden-test-cases/system-fileio.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, chell, fetchurl, system-filepath

1+{ mkDerivation, base, bytestring, chell, stdenv, system-filepath

2, temporary, text, time, transformers, unix

3}:

4mkDerivation {

5 pname = "system-fileio";

6 version = "0.3.16.3";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base bytestring system-filepath text time unix

9 base bytestring system-filepath text time unix

13 ];

10 ];

@@ -18,4 +15,4 @@ mkDerivation {

18 homepage = "https://github.com/fpco/haskell-filesystem";

15 homepage = "https://github.com/fpco/haskell-filesystem";

19 description = "Consistent filesystem interaction across GHC versions (deprecated)";

16 description = "Consistent filesystem interaction across GHC versions (deprecated)";

20 license = stdenv.lib.licenses.mit;

17 license = stdenv.lib.licenses.mit;

21−}

18+}

test/golden-test-cases/system-filepath.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, base, bytestring, chell, chell-quickcheck, deepseq

2−, fetchurl, QuickCheck, text

2+, QuickCheck, stdenv, text

3}:

4mkDerivation {

5 pname = "system-filepath";

6 version = "0.4.13.4";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base bytestring deepseq text ];

8 libraryHaskellDepends = [ base bytestring deepseq text ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 base bytestring chell chell-quickcheck QuickCheck text

10 base bytestring chell chell-quickcheck QuickCheck text

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://github.com/fpco/haskell-filesystem";

12 homepage = "https://github.com/fpco/haskell-filesystem";

16 description = "High-level, byte-based file and directory path manipulations (deprecated)";

13 description = "High-level, byte-based file and directory path manipulations (deprecated)";

17 license = stdenv.lib.licenses.mit;

14 license = stdenv.lib.licenses.mit;

18−}

15+}

test/golden-test-cases/tagged.nix.golden+3−6

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, deepseq, fetchurl, template-haskell

1+{ mkDerivation, base, deepseq, stdenv, template-haskell

2, transformers, transformers-compat

3}:

4mkDerivation {

5 pname = "tagged";

6 version = "0.8.5";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base deepseq template-haskell transformers transformers-compat

9 base deepseq template-haskell transformers transformers-compat

13 ];

10 ];

14 homepage = "http://github.com/ekmett/tagged";

11 homepage = "http://github.com/ekmett/tagged";

15 description = "Haskell 98 phantom types to avoid unsafely passing dummy arguments";

12 description = "Haskell 98 phantom types to avoid unsafely passing dummy arguments";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/taggy.nix.golden+3−6

@@ -1,14 +1,11 @@

1{ mkDerivation, attoparsec, base, blaze-html, blaze-markup

2−, criterion, directory, fetchurl, hspec, hspec-attoparsec, tagsoup

2+, criterion, directory, hspec, hspec-attoparsec, stdenv, tagsoup

3, text, unordered-containers, vector

4}:

5mkDerivation {

6 pname = "taggy";

7 version = "0.2.1";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 isLibrary = true;

9 isLibrary = true;

13 isExecutable = true;

10 isExecutable = true;

14 enableSeparateDataOutput = true;

11 enableSeparateDataOutput = true;

@@ -27,4 +24,4 @@ mkDerivation {

27 homepage = "http://github.com/alpmestan/taggy";

24 homepage = "http://github.com/alpmestan/taggy";

28 description = "Efficient and simple HTML/XML parsing library";

25 description = "Efficient and simple HTML/XML parsing library";

29 license = stdenv.lib.licenses.bsd3;

26 license = stdenv.lib.licenses.bsd3;

30−}

27+}

test/golden-test-cases/tagstream-conduit.nix.golden+4−7

@@ -1,15 +1,12 @@

1{ mkDerivation, attoparsec, base, blaze-builder, bytestring

2−, case-insensitive, conduit, conduit-extra, data-default, fetchurl

2+, case-insensitive, conduit, conduit-extra, data-default, hspec

3−, hspec, HUnit, QuickCheck, resourcet, text, transformers

3+, HUnit, QuickCheck, resourcet, stdenv, text, transformers

4, xml-conduit

5}:

6mkDerivation {

7 pname = "tagstream-conduit";

8 version = "0.5.5.3";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 libraryHaskellDepends = [

10 libraryHaskellDepends = [

14 attoparsec base blaze-builder bytestring case-insensitive conduit

11 attoparsec base blaze-builder bytestring case-insensitive conduit

15 conduit-extra data-default resourcet text transformers xml-conduit

12 conduit-extra data-default resourcet text transformers xml-conduit

@@ -20,4 +17,4 @@ mkDerivation {

20 homepage = "http://github.com/yihuang/tagstream-conduit";

17 homepage = "http://github.com/yihuang/tagstream-conduit";

21 description = "streamlined html tag parser";

18 description = "streamlined html tag parser";

22 license = stdenv.lib.licenses.bsd3;

19 license = stdenv.lib.licenses.bsd3;

23−}

20+}

test/golden-test-cases/tasty-hedgehog.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, hedgehog, tagged, tasty

1+{ mkDerivation, base, hedgehog, stdenv, tagged, tasty

2, tasty-expected-failure

3}:

4mkDerivation {

5 pname = "tasty-hedgehog";

6 version = "0.1.0.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base hedgehog tagged tasty ];

8 libraryHaskellDepends = [ base hedgehog tagged tasty ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 base hedgehog tasty tasty-expected-failure

10 base hedgehog tasty tasty-expected-failure

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "https://github.com/qfpl/tasty-hedghog";

12 homepage = "https://github.com/qfpl/tasty-hedghog";

16 description = "Integrates the hedgehog testing library with the tasty testing framework";

13 description = "Integrates the hedgehog testing library with the tasty testing framework";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/tasty-rerun.nix.golden+4−8

@@ -1,14 +1,10 @@

1−{ mkDerivation, base, containers, fetchurl, mtl

1+{ mkDerivation, base, containers, mtl, optparse-applicative

2−, optparse-applicative, reducers, split, stm, tagged, tasty

2+, reducers, split, stdenv, stm, tagged, tasty, transformers

3−, transformers

4}:

3}:

5mkDerivation {

4mkDerivation {

6 pname = "tasty-rerun";

5 pname = "tasty-rerun";

7 version = "1.1.8";

6 version = "1.1.8";

8− src = fetchurl {

7+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

8 libraryHaskellDepends = [

13 base containers mtl optparse-applicative reducers split stm tagged

9 base containers mtl optparse-applicative reducers split stm tagged

14 tasty transformers

10 tasty transformers

@@ -16,4 +12,4 @@ mkDerivation {

16 homepage = "http://github.com/ocharles/tasty-rerun";

12 homepage = "http://github.com/ocharles/tasty-rerun";

17 description = "Run tests by filtering the test tree depending on the result of previous test runs";

13 description = "Run tests by filtering the test tree depending on the result of previous test runs";

18 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

19−}

15+}

test/golden-test-cases/tce-conf.nix.golden+3−6

@@ -1,11 +1,8 @@

1−{ mkDerivation, base, containers, fetchurl, HUnit }:

1+{ mkDerivation, base, containers, HUnit, stdenv }:

2mkDerivation {

3 pname = "tce-conf";

4 version = "1.3";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 isLibrary = true;

6 isLibrary = true;

10 isExecutable = true;

7 isExecutable = true;

11 libraryHaskellDepends = [ base containers ];

8 libraryHaskellDepends = [ base containers ];

@@ -14,4 +11,4 @@ mkDerivation {

14 homepage = "http://hub.darcs.net/dino/tce-conf";

11 homepage = "http://hub.darcs.net/dino/tce-conf";

15 description = "Very simple config file reading";

12 description = "Very simple config file reading";

16 license = stdenv.lib.licenses.bsd3;

13 license = stdenv.lib.licenses.bsd3;

17−}

14+}

test/golden-test-cases/terminal-progress-bar.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, HUnit, stm, stm-chans

1+{ mkDerivation, base, HUnit, stdenv, stm, stm-chans, test-framework

2−, test-framework, test-framework-hunit

2+, test-framework-hunit

3}:

4mkDerivation {

5 pname = "terminal-progress-bar";

6 version = "0.1.1.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 isLibrary = true;

8 isLibrary = true;

12 isExecutable = true;

9 isExecutable = true;

13 libraryHaskellDepends = [ base stm stm-chans ];

10 libraryHaskellDepends = [ base stm stm-chans ];

@@ -17,4 +14,4 @@ mkDerivation {

17 homepage = "https://github.com/roelvandijk/terminal-progress-bar";

14 homepage = "https://github.com/roelvandijk/terminal-progress-bar";

18 description = "A simple progress bar in the terminal";

15 description = "A simple progress bar in the terminal";

19 license = stdenv.lib.licenses.bsd3;

16 license = stdenv.lib.licenses.bsd3;

20−}

17+}

test/golden-test-cases/test-fixture.nix.golden+5−7

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, data-default-class, exceptions, fetchurl

1+{ mkDerivation, base, data-default-class, exceptions

2, haskell-src-exts, haskell-src-meta, hspec, hspec-discover, mtl

3−, template-haskell, th-orphans, transformers

3+, stdenv, template-haskell, th-orphans, transformers

4}:

5mkDerivation {

6 pname = "test-fixture";

7 version = "0.5.1.0";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 base data-default-class exceptions haskell-src-exts

10 base data-default-class exceptions haskell-src-exts

14 haskell-src-meta mtl template-haskell th-orphans

11 haskell-src-meta mtl template-haskell th-orphans

@@ -16,7 +13,8 @@ mkDerivation {

16 testHaskellDepends = [

13 testHaskellDepends = [

17 base hspec hspec-discover mtl template-haskell transformers

14 base hspec hspec-discover mtl template-haskell transformers

18 ];

15 ];

16+ testToolDepends = [ hspec-discover ];

19 homepage = "http://github.com/cjdev/test-fixture#readme";

17 homepage = "http://github.com/cjdev/test-fixture#readme";

20 description = "Test monadic side-effects";

18 description = "Test monadic side-effects";

21 license = stdenv.lib.licenses.bsd3;

19 license = stdenv.lib.licenses.bsd3;

22−}

20+}

test/golden-test-cases/texmath.nix.golden+5−9

@@ -1,20 +1,16 @@

1−{ mkDerivation, base, bytestring, containers, directory, fetchurl

1+{ mkDerivation, base, bytestring, containers, directory, filepath

2−, filepath, mtl, network-uri, pandoc-types, parsec, process, split

2+, mtl, pandoc-types, parsec, process, split, stdenv, syb, temporary

3−, syb, temporary, text, utf8-string, xml

3+, text, utf8-string, xml

4}:

5mkDerivation {

6 pname = "texmath";

7 version = "0.10.1";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 isLibrary = true;

9 isLibrary = true;

13 isExecutable = true;

10 isExecutable = true;

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

15 base containers mtl pandoc-types parsec syb xml

12 base containers mtl pandoc-types parsec syb xml

16 ];

13 ];

17− executableHaskellDepends = [ network-uri ];

18 testHaskellDepends = [

14 testHaskellDepends = [

19 base bytestring directory filepath process split temporary text

15 base bytestring directory filepath process split temporary text

20 utf8-string xml

16 utf8-string xml

@@ -22,4 +18,4 @@ mkDerivation {

22 homepage = "http://github.com/jgm/texmath";

18 homepage = "http://github.com/jgm/texmath";

23 description = "Conversion between formats used to represent mathematics";

19 description = "Conversion between formats used to represent mathematics";

24 license = "GPL";

20 license = "GPL";

25−}

21+}

test/golden-test-cases/text-icu.nix.golden+4−8

@@ -1,15 +1,11 @@

1{ mkDerivation, array, base, bytestring, deepseq, directory

2−, fetchurl, ghc-prim, HUnit, icu, QuickCheck, random

2+, ghc-prim, HUnit, icu, QuickCheck, random, stdenv, test-framework

3−, test-framework, test-framework-hunit, test-framework-quickcheck2

3+, test-framework-hunit, test-framework-quickcheck2, text

4−, text

5}:

4}:

6mkDerivation {

5mkDerivation {

7 pname = "text-icu";

6 pname = "text-icu";

8 version = "0.7.0.1";

7 version = "0.7.0.1";

9− src = fetchurl {

8+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 libraryHaskellDepends = [ base bytestring deepseq text ];

9 libraryHaskellDepends = [ base bytestring deepseq text ];

14 librarySystemDepends = [ icu ];

10 librarySystemDepends = [ icu ];

15 testHaskellDepends = [

11 testHaskellDepends = [

@@ -20,4 +16,4 @@ mkDerivation {

20 homepage = "https://github.com/bos/text-icu";

16 homepage = "https://github.com/bos/text-icu";

21 description = "Bindings to the ICU library";

17 description = "Bindings to the ICU library";

22 license = stdenv.lib.licenses.bsd3;

18 license = stdenv.lib.licenses.bsd3;

23−}

19+}

test/golden-test-cases/text-postgresql.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, dlist, fetchurl, QuickCheck

1+{ mkDerivation, base, dlist, QuickCheck, quickcheck-simple, stdenv

2−, quickcheck-simple, transformers, transformers-compat

2+, transformers, transformers-compat

3}:

4mkDerivation {

5 pname = "text-postgresql";

6 version = "0.0.2.3";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base dlist transformers transformers-compat

9 base dlist transformers transformers-compat

13 ];

10 ];

@@ -15,4 +12,4 @@ mkDerivation {

15 homepage = "http://khibino.github.io/haskell-relational-record/";

12 homepage = "http://khibino.github.io/haskell-relational-record/";

16 description = "Parser and Printer of PostgreSQL extended types";

13 description = "Parser and Printer of PostgreSQL extended types";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

test/golden-test-cases/th-expand-syns.nix.golden+3−7

@@ -1,15 +1,11 @@

1−{ mkDerivation, base, containers, fetchurl, syb, template-haskell

1+{ mkDerivation, base, containers, stdenv, syb, template-haskell }:

2−}:

3mkDerivation {

2mkDerivation {

4 pname = "th-expand-syns";

3 pname = "th-expand-syns";

5 version = "0.4.4.0";

4 version = "0.4.4.0";

6− src = fetchurl {

5+ sha256 = "deadbeef";

7− url = "http://example.org/";

8− sha256 = "abc";

9− };

10 libraryHaskellDepends = [ base containers syb template-haskell ];

6 libraryHaskellDepends = [ base containers syb template-haskell ];

11 testHaskellDepends = [ base template-haskell ];

7 testHaskellDepends = [ base template-haskell ];

12 homepage = "https://github.com/DanielSchuessler/th-expand-syns";

8 homepage = "https://github.com/DanielSchuessler/th-expand-syns";

13 description = "Expands type synonyms in Template Haskell ASTs";

9 description = "Expands type synonyms in Template Haskell ASTs";

14 license = stdenv.lib.licenses.bsd3;

10 license = stdenv.lib.licenses.bsd3;

15−}

11+}

test/golden-test-cases/these.nix.golden+5−8

@@ -1,16 +1,13 @@

1{ mkDerivation, aeson, base, bifunctors, binary, containers

2−, data-default-class, deepseq, fetchurl, hashable, keys, mtl

2+, data-default-class, deepseq, hashable, keys, mtl, profunctors

3−, profunctors, QuickCheck, quickcheck-instances, semigroupoids

3+, QuickCheck, quickcheck-instances, semigroupoids, stdenv, tasty

4−, tasty, tasty-quickcheck, transformers, transformers-compat

4+, tasty-quickcheck, transformers, transformers-compat

5, unordered-containers, vector, vector-instances

6}:

7mkDerivation {

8 pname = "these";

9 version = "0.7.4";

10− src = fetchurl {

10+ sha256 = "deadbeef";

11− url = "http://example.org/";

12− sha256 = "abc";

13− };

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

15 aeson base bifunctors binary containers data-default-class deepseq

12 aeson base bifunctors binary containers data-default-class deepseq

16 hashable keys mtl profunctors QuickCheck semigroupoids transformers

13 hashable keys mtl profunctors QuickCheck semigroupoids transformers

@@ -24,4 +21,4 @@ mkDerivation {

24 homepage = "https://github.com/isomorphism/these";

21 homepage = "https://github.com/isomorphism/these";

25 description = "An either-or-both data type & a generalized 'zip with padding' typeclass";

22 description = "An either-or-both data type & a generalized 'zip with padding' typeclass";

26 license = stdenv.lib.licenses.bsd3;

23 license = stdenv.lib.licenses.bsd3;

27−}

24+}

test/golden-test-cases/timezone-series.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, deepseq, fetchurl, time }:

1+{ mkDerivation, base, deepseq, stdenv, time }:

2mkDerivation {

3 pname = "timezone-series";

4 version = "0.1.8";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base deepseq time ];

6 libraryHaskellDepends = [ base deepseq time ];

10 homepage = "http://projects.haskell.org/time-ng/";

7 homepage = "http://projects.haskell.org/time-ng/";

11 description = "Enhanced timezone handling for Data.Time";

8 description = "Enhanced timezone handling for Data.Time";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/transformers-compat.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, ghc-prim, transformers }:

1+{ mkDerivation, base, ghc-prim, stdenv, transformers }:

2mkDerivation {

3 pname = "transformers-compat";

4 version = "0.5.1.4";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ghc-prim transformers ];

6 libraryHaskellDepends = [ base ghc-prim transformers ];

10 homepage = "http://github.com/ekmett/transformers-compat/";

7 homepage = "http://github.com/ekmett/transformers-compat/";

11 description = "A small compatibility shim exposing the new types from transformers 0.3 and 0.4 to older Haskell platforms.";

8 description = "A small compatibility shim exposing the new types from transformers 0.3 and 0.4 to older Haskell platforms.";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/transformers-lift.nix.golden+3−7

@@ -1,16 +1,12 @@

1−{ mkDerivation, base, fetchurl, transformers

1+{ mkDerivation, base, stdenv, transformers, writer-cps-transformers

2−, writer-cps-transformers

3}:

2}:

4mkDerivation {

3mkDerivation {

5 pname = "transformers-lift";

4 pname = "transformers-lift";

6 version = "0.2.0.1";

5 version = "0.2.0.1";

7− src = fetchurl {

6+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

7 libraryHaskellDepends = [

12 base transformers writer-cps-transformers

8 base transformers writer-cps-transformers

13 ];

9 ];

14 description = "Ad-hoc type classes for lifting";

10 description = "Ad-hoc type classes for lifting";

15 license = stdenv.lib.licenses.bsd3;

11 license = stdenv.lib.licenses.bsd3;

16−}

12+}

test/golden-test-cases/tree-fun.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, base, containers, fetchurl, mtl }:

1+{ mkDerivation, base, containers, mtl, stdenv }:

2mkDerivation {

3 pname = "tree-fun";

4 version = "0.8.1.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base containers mtl ];

6 libraryHaskellDepends = [ base containers mtl ];

10 description = "Library for functions pertaining to tree exploration and manipulation";

7 description = "Library for functions pertaining to tree exploration and manipulation";

11 license = stdenv.lib.licenses.gpl3;

8 license = stdenv.lib.licenses.gpl3;

12−}

9+}

test/golden-test-cases/ttrie.nix.golden+4−7

@@ -1,16 +1,13 @@

1{ mkDerivation, async, atomic-primops, base, bifunctors, containers

2−, criterion-plus, deepseq, fetchurl, hashable, mwc-random

2+, criterion-plus, deepseq, hashable, mwc-random, primitive

3−, primitive, QuickCheck, stm, stm-containers, stm-stats

3+, QuickCheck, stdenv, stm, stm-containers, stm-stats

4, test-framework, test-framework-quickcheck2, text, transformers

5, unordered-containers, vector

6}:

7mkDerivation {

8 pname = "ttrie";

9 version = "0.1.2.1";

10− src = fetchurl {

10+ sha256 = "deadbeef";

11− url = "http://example.org/";

12− sha256 = "abc";

13− };

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

15 atomic-primops base hashable primitive stm

12 atomic-primops base hashable primitive stm

16 ];

13 ];

@@ -26,4 +23,4 @@ mkDerivation {

26 homepage = "http://github.com/mcschroeder/ttrie";

23 homepage = "http://github.com/mcschroeder/ttrie";

27 description = "Contention-free STM hash map";

24 description = "Contention-free STM hash map";

28 license = stdenv.lib.licenses.mit;

25 license = stdenv.lib.licenses.mit;

29−}

26+}

test/golden-test-cases/tuple-th.nix.golden+3−6

@@ -1,12 +1,9 @@

1−{ mkDerivation, base, containers, fetchurl, template-haskell }:

1+{ mkDerivation, base, containers, stdenv, template-haskell }:

2mkDerivation {

3 pname = "tuple-th";

4 version = "0.2.5";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base containers template-haskell ];

6 libraryHaskellDepends = [ base containers template-haskell ];

10 description = "Generate (non-recursive) utility functions for tuples of statically known size";

7 description = "Generate (non-recursive) utility functions for tuples of statically known size";

11 license = stdenv.lib.licenses.bsd3;

8 license = stdenv.lib.licenses.bsd3;

12−}

9+}

test/golden-test-cases/tuples-homogenous-h98.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl }:

1+{ mkDerivation, base, stdenv }:

2mkDerivation {

3 pname = "tuples-homogenous-h98";

4 version = "0.1.1.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 homepage = "https://github.com/ppetr/tuples-homogenous-h98";

7 homepage = "https://github.com/ppetr/tuples-homogenous-h98";

11 description = "Wrappers for n-ary tuples with Traversable and Applicative/Monad instances";

8 description = "Wrappers for n-ary tuples with Traversable and Applicative/Monad instances";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/turtle-options.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, HUnit, optional-args, parsec, text

1+{ mkDerivation, base, HUnit, optional-args, parsec, stdenv, text

2, turtle

3}:

4mkDerivation {

5 pname = "turtle-options";

6 version = "0.1.0.4";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 isLibrary = true;

8 isLibrary = true;

12 isExecutable = true;

9 isExecutable = true;

13 libraryHaskellDepends = [ base optional-args parsec text turtle ];

10 libraryHaskellDepends = [ base optional-args parsec text turtle ];

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/elaye/turtle-options#readme";

13 homepage = "https://github.com/elaye/turtle-options#readme";

17 description = "Collection of command line options and parsers for these options";

14 description = "Collection of command line options and parsers for these options";

18 license = stdenv.lib.licenses.bsd3;

15 license = stdenv.lib.licenses.bsd3;

19−}

16+}

test/golden-test-cases/type-operators.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, ghc-prim }:

1+{ mkDerivation, base, ghc-prim, stdenv }:

2mkDerivation {

3 pname = "type-operators";

4 version = "0.1.0.4";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ghc-prim ];

6 libraryHaskellDepends = [ base ghc-prim ];

10 homepage = "https://github.com/Shou/type-operators#readme";

7 homepage = "https://github.com/Shou/type-operators#readme";

11 description = "Various type-level operators";

8 description = "Various type-level operators";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/type-spec.nix.golden+3−6

@@ -1,14 +1,11 @@

1−{ mkDerivation, base, fetchurl, pretty }:

1+{ mkDerivation, base, pretty, stdenv }:

2mkDerivation {

3 pname = "type-spec";

4 version = "0.3.0.1";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base pretty ];

6 libraryHaskellDepends = [ base pretty ];

10 testHaskellDepends = [ base ];

7 testHaskellDepends = [ base ];

11 homepage = "https://github.com/sheyll/type-spec#readme";

8 homepage = "https://github.com/sheyll/type-spec#readme";

12 description = "Type Level Specification by Example";

9 description = "Type Level Specification by Example";

13 license = stdenv.lib.licenses.bsd3;

10 license = stdenv.lib.licenses.bsd3;

14−}

11+}

test/golden-test-cases/unicode-show.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, HUnit, QuickCheck, test-framework

1+{ mkDerivation, base, HUnit, QuickCheck, stdenv, test-framework

2, test-framework-hunit, test-framework-quickcheck2

3}:

4mkDerivation {

5 pname = "unicode-show";

6 version = "0.1.0.2";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base ];

8 libraryHaskellDepends = [ base ];

12 testHaskellDepends = [

9 testHaskellDepends = [

13 base HUnit QuickCheck test-framework test-framework-hunit

10 base HUnit QuickCheck test-framework test-framework-hunit

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "http://github.com/nushio3/unicode-show#readme";

13 homepage = "http://github.com/nushio3/unicode-show#readme";

17 description = "print and show in unicode";

14 description = "print and show in unicode";

18 license = stdenv.lib.licenses.bsd3;

15 license = stdenv.lib.licenses.bsd3;

19−}

16+}

test/golden-test-cases/unique.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, ghc-prim, hashable }:

1+{ mkDerivation, base, ghc-prim, hashable, stdenv }:

2mkDerivation {

3 pname = "unique";

4 version = "0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ghc-prim hashable ];

6 libraryHaskellDepends = [ base ghc-prim hashable ];

10 homepage = "http://github.com/ekmett/unique/";

7 homepage = "http://github.com/ekmett/unique/";

11 description = "Fully concurrent unique identifiers";

8 description = "Fully concurrent unique identifiers";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/unix-bytestring.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, fetchurl }:

1+{ mkDerivation, base, bytestring, stdenv }:

2mkDerivation {

3 pname = "unix-bytestring";

4 version = "0.3.7.3";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base bytestring ];

6 libraryHaskellDepends = [ base bytestring ];

10 homepage = "http://code.haskell.org/~wren/";

7 homepage = "http://code.haskell.org/~wren/";

11 description = "Unix/Posix-specific functions for ByteStrings";

8 description = "Unix/Posix-specific functions for ByteStrings";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/unlit.nix.golden+3−6

@@ -1,15 +1,12 @@

1−{ mkDerivation, base, directory, fetchurl, text }:

1+{ mkDerivation, base, directory, stdenv, text }:

2mkDerivation {

3 pname = "unlit";

4 version = "0.4.0.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 isLibrary = true;

6 isLibrary = true;

10 isExecutable = true;

7 isExecutable = true;

11 libraryHaskellDepends = [ base directory text ];

8 libraryHaskellDepends = [ base directory text ];

12 executableHaskellDepends = [ base directory text ];

9 executableHaskellDepends = [ base directory text ];

13 description = "Tool to convert literate code between styles or to code";

10 description = "Tool to convert literate code between styles or to code";

14 license = stdenv.lib.licenses.bsd3;

11 license = stdenv.lib.licenses.bsd3;

15−}

12+}

test/golden-test-cases/utility-ht.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, fetchurl, QuickCheck }:

1+{ mkDerivation, base, QuickCheck, stdenv }:

2mkDerivation {

3 pname = "utility-ht";

4 version = "0.0.14";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base ];

6 libraryHaskellDepends = [ base ];

10 testHaskellDepends = [ base QuickCheck ];

7 testHaskellDepends = [ base QuickCheck ];

11 description = "Various small helper functions for Lists, Maybes, Tuples, Functions";

8 description = "Various small helper functions for Lists, Maybes, Tuples, Functions";

12 license = stdenv.lib.licenses.bsd3;

9 license = stdenv.lib.licenses.bsd3;

13−}

10+}

test/golden-test-cases/validity-aeson.nix.golden+4−8

@@ -1,14 +1,10 @@

1−{ mkDerivation, aeson, base, fetchurl, validity

1+{ mkDerivation, aeson, base, stdenv, validity, validity-scientific

2−, validity-scientific, validity-text, validity-unordered-containers

2+, validity-text, validity-unordered-containers, validity-vector

3−, validity-vector

4}:

3}:

5mkDerivation {

4mkDerivation {

6 pname = "validity-aeson";

5 pname = "validity-aeson";

7 version = "0.1.0.0";

6 version = "0.1.0.0";

8− src = fetchurl {

7+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

8 libraryHaskellDepends = [

13 aeson base validity validity-scientific validity-text

9 aeson base validity validity-scientific validity-text

14 validity-unordered-containers validity-vector

10 validity-unordered-containers validity-vector

@@ -16,4 +12,4 @@ mkDerivation {

16 homepage = "https://github.com/NorfairKing/validity#readme";

12 homepage = "https://github.com/NorfairKing/validity#readme";

17 description = "Validity instances for aeson";

13 description = "Validity instances for aeson";

18 license = stdenv.lib.licenses.mit;

14 license = stdenv.lib.licenses.mit;

19−}

15+}

test/golden-test-cases/validity-containers.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, containers, fetchurl, validity }:

1+{ mkDerivation, base, containers, stdenv, validity }:

2mkDerivation {

3 pname = "validity-containers";

4 version = "0.2.0.0";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base containers validity ];

6 libraryHaskellDepends = [ base containers validity ];

10 homepage = "https://github.com/NorfairKing/validity#readme";

7 homepage = "https://github.com/NorfairKing/validity#readme";

11 description = "Validity instances for containers";

8 description = "Validity instances for containers";

12 license = stdenv.lib.licenses.mit;

9 license = stdenv.lib.licenses.mit;

13−}

10+}

test/golden-test-cases/vector-mmap.nix.golden+3−6

@@ -1,16 +1,13 @@

1−{ mkDerivation, base, fetchurl, mmap, primitive, QuickCheck

1+{ mkDerivation, base, mmap, primitive, QuickCheck, stdenv

2, temporary, vector

3}:

4mkDerivation {

5 pname = "vector-mmap";

6 version = "0.0.3";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base mmap primitive vector ];

8 libraryHaskellDepends = [ base mmap primitive vector ];

12 testHaskellDepends = [ base QuickCheck temporary vector ];

9 testHaskellDepends = [ base QuickCheck temporary vector ];

13 homepage = "http://github.com/pumpkin/vector-mmap";

10 homepage = "http://github.com/pumpkin/vector-mmap";

14 description = "Memory map immutable and mutable vectors";

11 description = "Memory map immutable and mutable vectors";

15 license = stdenv.lib.licenses.bsd3;

12 license = stdenv.lib.licenses.bsd3;

16−}

13+}

test/golden-test-cases/vivid-supercollider.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, binary, bytestring, cereal, fetchurl

1+{ mkDerivation, base, binary, bytestring, cereal, microspec

2−, microspec, QuickCheck, split, utf8-string, vivid-osc

2+, QuickCheck, split, stdenv, utf8-string, vivid-osc

3}:

4mkDerivation {

5 pname = "vivid-supercollider";

6 version = "0.3.0.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base binary bytestring cereal split utf8-string vivid-osc

9 base binary bytestring cereal split utf8-string vivid-osc

13 ];

10 ];

@@ -17,4 +14,4 @@ mkDerivation {

17 ];

14 ];

18 description = "Implementation of SuperCollider server specifications";

15 description = "Implementation of SuperCollider server specifications";

19 license = "GPL";

16 license = "GPL";

20−}

17+}

test/golden-test-cases/vty.nix.golden+6−9

@@ -1,18 +1,15 @@

1{ mkDerivation, base, blaze-builder, bytestring, Cabal, containers

2−, deepseq, directory, fetchurl, filepath, hashable, HUnit

2+, deepseq, directory, filepath, hashable, HUnit, microlens

3−, microlens, microlens-mtl, microlens-th, mtl, parallel, parsec

3+, microlens-mtl, microlens-th, mtl, parallel, parsec, QuickCheck

4−, QuickCheck, quickcheck-assertions, random, smallcheck, stm

4+, quickcheck-assertions, random, smallcheck, stdenv, stm, string-qq

5−, string-qq, terminfo, test-framework, test-framework-hunit

5+, terminfo, test-framework, test-framework-hunit

6, test-framework-smallcheck, text, transformers, unix, utf8-string

7, vector

8}:

9mkDerivation {

10 pname = "vty";

11 version = "5.19.1";

12− src = fetchurl {

12+ sha256 = "deadbeef";

13− url = "http://example.org/";

14− sha256 = "abc";

15− };

16 isLibrary = true;

13 isLibrary = true;

17 isExecutable = true;

14 isExecutable = true;

18 libraryHaskellDepends = [

15 libraryHaskellDepends = [

@@ -33,4 +30,4 @@ mkDerivation {

33 homepage = "https://github.com/jtdaugherty/vty";

30 homepage = "https://github.com/jtdaugherty/vty";

34 description = "A simple terminal UI library";

31 description = "A simple terminal UI library";

35 license = stdenv.lib.licenses.bsd3;

32 license = stdenv.lib.licenses.bsd3;

36−}

33+}

test/golden-test-cases/wai-cors.nix.golden+4−7

@@ -1,15 +1,12 @@

1{ mkDerivation, attoparsec, base, base-unicode-symbols, bytestring

2−, case-insensitive, directory, fetchurl, filepath, http-types, mtl

2+, case-insensitive, directory, filepath, http-types, mtl, network

3−, network, process, tasty, tasty-hunit, text, transformers, wai

3+, process, stdenv, tasty, tasty-hunit, text, transformers, wai

4, wai-extra, wai-websockets, warp, websockets

5}:

6mkDerivation {

7 pname = "wai-cors";

8 version = "0.2.6";

9− src = fetchurl {

9+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 enableSeparateDataOutput = true;

10 enableSeparateDataOutput = true;

14 libraryHaskellDepends = [

11 libraryHaskellDepends = [

15 attoparsec base base-unicode-symbols bytestring case-insensitive

12 attoparsec base base-unicode-symbols bytestring case-insensitive

@@ -23,4 +20,4 @@ mkDerivation {

23 homepage = "https://github.com/larskuhtz/wai-cors";

20 homepage = "https://github.com/larskuhtz/wai-cors";

24 description = "CORS for WAI";

21 description = "CORS for WAI";

25 license = stdenv.lib.licenses.mit;

22 license = stdenv.lib.licenses.mit;

26−}

23+}

test/golden-test-cases/wai-middleware-auth.nix.golden+6−9

@@ -1,18 +1,15 @@

1{ mkDerivation, aeson, base, base64-bytestring, binary

2, blaze-builder, blaze-html, bytestring, case-insensitive, cereal

3−, clientsession, cookie, exceptions, fetchurl, hoauth2, http-client

3+, clientsession, cookie, exceptions, hoauth2, http-client

4, http-client-tls, http-conduit, http-reverse-proxy, http-types

5−, optparse-simple, regex-posix, safe-exceptions, shakespeare, text

5+, optparse-simple, regex-posix, safe-exceptions, shakespeare

6−, unix-compat, unordered-containers, uri-bytestring, vault, wai

6+, stdenv, text, unix-compat, unordered-containers, uri-bytestring

7−, wai-app-static, wai-extra, warp, yaml

7+, vault, wai, wai-app-static, wai-extra, warp, yaml

8}:

9mkDerivation {

10 pname = "wai-middleware-auth";

11 version = "0.1.2.1";

12− src = fetchurl {

12+ sha256 = "deadbeef";

13− url = "http://example.org/";

14− sha256 = "abc";

15− };

16 isLibrary = true;

13 isLibrary = true;

17 isExecutable = true;

14 isExecutable = true;

18 libraryHaskellDepends = [

15 libraryHaskellDepends = [

@@ -28,4 +25,4 @@ mkDerivation {

28 ];

25 ];

29 description = "Authentication middleware that secures WAI application";

26 description = "Authentication middleware that secures WAI application";

30 license = stdenv.lib.licenses.mit;

27 license = stdenv.lib.licenses.mit;

31−}

28+}

test/golden-test-cases/wai-middleware-caching-redis.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, blaze-builder, bytestring, fetchurl, hedis

1+{ mkDerivation, base, blaze-builder, bytestring, hedis, http-types

2−, http-types, text, wai, wai-middleware-caching

2+, stdenv, text, wai, wai-middleware-caching

3}:

4mkDerivation {

5 pname = "wai-middleware-caching-redis";

6 version = "0.2.0.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base blaze-builder bytestring hedis http-types text wai

9 base blaze-builder bytestring hedis http-types text wai

13 wai-middleware-caching

10 wai-middleware-caching

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "http://github.com/yogsototh/wai-middleware-caching/tree/master/wai-middleware-caching-redis#readme";

13 homepage = "http://github.com/yogsototh/wai-middleware-caching/tree/master/wai-middleware-caching-redis#readme";

17 description = "Cache Wai Middleware using Redis backend";

14 description = "Cache Wai Middleware using Redis backend";

18 license = stdenv.lib.licenses.bsd3;

15 license = stdenv.lib.licenses.bsd3;

19−}

16+}

test/golden-test-cases/wai-middleware-prometheus.nix.golden+3−6

@@ -1,13 +1,10 @@

1{ mkDerivation, base, bytestring, clock, data-default, doctest

2−, fetchurl, http-types, prometheus-client, text, wai

2+, http-types, prometheus-client, stdenv, text, wai

3}:

4mkDerivation {

5 pname = "wai-middleware-prometheus";

6 version = "0.3.0";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base bytestring clock data-default http-types prometheus-client

9 base bytestring clock data-default http-types prometheus-client

13 text wai

10 text wai

@@ -16,4 +13,4 @@ mkDerivation {

16 homepage = "https://github.com/fimad/prometheus-haskell";

13 homepage = "https://github.com/fimad/prometheus-haskell";

17 description = "WAI middlware for exposing http://prometheus.io metrics.";

14 description = "WAI middlware for exposing http://prometheus.io metrics.";

18 license = stdenv.lib.licenses.asl20;

15 license = stdenv.lib.licenses.asl20;

19−}

16+}

test/golden-test-cases/warp.nix.golden+7−10

@@ -1,18 +1,15 @@

1{ mkDerivation, array, async, auto-update, base, blaze-builder

2, bytestring, bytestring-builder, case-insensitive, containers

3−, criterion, directory, doctest, fetchurl, ghc-prim, hashable

3+, criterion, directory, doctest, ghc-prim, hashable, hspec, HTTP

4−, hspec, HTTP, http-date, http-types, http2, HUnit, iproute

4+, http-date, http-types, http2, HUnit, iproute, lifted-base

5−, lifted-base, network, process, QuickCheck, silently

5+, network, process, QuickCheck, silently, simple-sendfile, stdenv

6−, simple-sendfile, stm, streaming-commons, text, time, transformers

6+, stm, streaming-commons, text, time, transformers, unix

7−, unix, unix-compat, vault, wai, word8

7+, unix-compat, vault, wai, word8

8}:

9mkDerivation {

10 pname = "warp";

11 version = "3.2.13";

12− src = fetchurl {

12+ sha256 = "deadbeef";

13− url = "http://example.org/";

14− sha256 = "abc";

15− };

16 libraryHaskellDepends = [

13 libraryHaskellDepends = [

17 array async auto-update base blaze-builder bytestring

14 array async auto-update base blaze-builder bytestring

18 bytestring-builder case-insensitive containers ghc-prim hashable

15 bytestring-builder case-insensitive containers ghc-prim hashable

@@ -34,4 +31,4 @@ mkDerivation {

34 homepage = "http://github.com/yesodweb/wai";

31 homepage = "http://github.com/yesodweb/wai";

35 description = "A fast, light-weight web server for WAI applications";

32 description = "A fast, light-weight web server for WAI applications";

36 license = stdenv.lib.licenses.mit;

33 license = stdenv.lib.licenses.mit;

37−}

34+}

test/golden-test-cases/weigh.nix.golden+5−11

@@ -1,21 +1,15 @@

1−{ mkDerivation, base, bytestring-trie, containers, deepseq

1+{ mkDerivation, base, deepseq, mtl, process, split, stdenv

2−, fetchurl, mtl, process, random, split, template-haskell

2+, template-haskell, temporary

3−, temporary, unordered-containers

4}:

3}:

5mkDerivation {

4mkDerivation {

6 pname = "weigh";

5 pname = "weigh";

7 version = "0.0.7";

6 version = "0.0.7";

8− src = fetchurl {

7+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

8 libraryHaskellDepends = [

13 base deepseq mtl process split template-haskell temporary

9 base deepseq mtl process split template-haskell temporary

14 ];

10 ];

15− testHaskellDepends = [

11+ testHaskellDepends = [ base deepseq ];

16− base bytestring-trie containers deepseq random unordered-containers

17− ];

18 homepage = "https://github.com/fpco/weigh#readme";

12 homepage = "https://github.com/fpco/weigh#readme";

19 description = "Measure allocations of a Haskell functions/values";

13 description = "Measure allocations of a Haskell functions/values";

20 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

21−}

15+}

test/golden-test-cases/xml-hamlet.nix.golden+4−7

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, containers, fetchurl, hspec, HUnit, parsec

1+{ mkDerivation, base, containers, hspec, HUnit, parsec, shakespeare

2−, shakespeare, template-haskell, text, xml-conduit

2+, stdenv, template-haskell, text, xml-conduit

3}:

4mkDerivation {

5 pname = "xml-hamlet";

6 version = "0.4.1.1";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base containers parsec shakespeare template-haskell text

9 base containers parsec shakespeare template-haskell text

13 xml-conduit

10 xml-conduit

@@ -19,4 +16,4 @@ mkDerivation {

19 homepage = "http://www.yesodweb.com/";

16 homepage = "http://www.yesodweb.com/";

20 description = "Hamlet-style quasiquoter for XML content";

17 description = "Hamlet-style quasiquoter for XML content";

21 license = stdenv.lib.licenses.bsd3;

18 license = stdenv.lib.licenses.bsd3;

22−}

19+}

test/golden-test-cases/xmonad-contrib.nix.golden+4−8

@@ -1,15 +1,11 @@

1{ mkDerivation, base, bytestring, containers, directory

2−, extensible-exceptions, fetchurl, filepath, mtl, old-locale

2+, extensible-exceptions, filepath, mtl, old-locale, old-time

3−, old-time, process, random, unix, utf8-string, X11, X11-xft

3+, process, random, stdenv, unix, utf8-string, X11, X11-xft, xmonad

4−, xmonad

5}:

4}:

6mkDerivation {

5mkDerivation {

7 pname = "xmonad-contrib";

6 pname = "xmonad-contrib";

8 version = "0.13";

7 version = "0.13";

9− src = fetchurl {

8+ sha256 = "deadbeef";

10− url = "http://example.org/";

11− sha256 = "abc";

12− };

13 libraryHaskellDepends = [

9 libraryHaskellDepends = [

14 base bytestring containers directory extensible-exceptions filepath

10 base bytestring containers directory extensible-exceptions filepath

15 mtl old-locale old-time process random unix utf8-string X11 X11-xft

11 mtl old-locale old-time process random unix utf8-string X11 X11-xft

@@ -18,4 +14,4 @@ mkDerivation {

18 homepage = "http://xmonad.org/";

14 homepage = "http://xmonad.org/";

19 description = "Third party extensions for xmonad";

15 description = "Third party extensions for xmonad";

20 license = stdenv.lib.licenses.bsd3;

16 license = stdenv.lib.licenses.bsd3;

21−}

17+}

test/golden-test-cases/yahoo-finance-api.nix.golden+4−7

@@ -1,14 +1,11 @@

1−{ mkDerivation, aeson, base, doctest, either, fetchurl, Glob, hspec

1+{ mkDerivation, aeson, base, doctest, either, Glob, hspec

2, http-api-data, http-client, http-client-tls, mtl, safe, servant

3−, servant-client, text, time, transformers, vector

3+, servant-client, stdenv, text, time, transformers, vector

4}:

5mkDerivation {

6 pname = "yahoo-finance-api";

7 version = "0.2.0.3";

8− src = fetchurl {

8+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

9 libraryHaskellDepends = [

13 aeson base either http-api-data http-client mtl servant

10 aeson base either http-api-data http-client mtl servant

14 servant-client text time transformers vector

11 servant-client text time transformers vector

@@ -20,4 +17,4 @@ mkDerivation {

20 homepage = "https://github.com/cdepillabout/yahoo-finance-api";

17 homepage = "https://github.com/cdepillabout/yahoo-finance-api";

21 description = "Read quotes from Yahoo Finance API";

18 description = "Read quotes from Yahoo Finance API";

22 license = stdenv.lib.licenses.bsd3;

19 license = stdenv.lib.licenses.bsd3;

23−}

20+}

test/golden-test-cases/yesod-form-bootstrap4.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, classy-prelude-yesod, fetchurl, yesod-form }:

1+{ mkDerivation, base, classy-prelude-yesod, stdenv, yesod-form }:

2mkDerivation {

3 pname = "yesod-form-bootstrap4";

4 version = "0.1.0.2";

5− src = fetchurl {

5+ sha256 = "deadbeef";

6− url = "http://example.org/";

7− sha256 = "abc";

8− };

9 libraryHaskellDepends = [ base classy-prelude-yesod yesod-form ];

6 libraryHaskellDepends = [ base classy-prelude-yesod yesod-form ];

10 homepage = "https://github.com/ncaq/yesod-form-bootstrap4#readme";

7 homepage = "https://github.com/ncaq/yesod-form-bootstrap4#readme";

11 description = "renderBootstrap4";

8 description = "renderBootstrap4";

12 license = stdenv.lib.licenses.mit;

9 license = stdenv.lib.licenses.mit;

13−}

10+}

test/golden-test-cases/yesod-gitrepo.nix.golden+4−8

@@ -1,14 +1,10 @@

1−{ mkDerivation, base, directory, enclosed-exceptions, fetchurl

1+{ mkDerivation, base, directory, enclosed-exceptions, http-types

2−, http-types, lifted-base, process, temporary, text, wai

2+, lifted-base, process, stdenv, temporary, text, wai, yesod-core

3−, yesod-core

4}:

3}:

5mkDerivation {

4mkDerivation {

6 pname = "yesod-gitrepo";

5 pname = "yesod-gitrepo";

7 version = "0.2.1.0";

6 version = "0.2.1.0";

8− src = fetchurl {

7+ sha256 = "deadbeef";

9− url = "http://example.org/";

10− sha256 = "abc";

11− };

12 libraryHaskellDepends = [

8 libraryHaskellDepends = [

13 base directory enclosed-exceptions http-types lifted-base process

9 base directory enclosed-exceptions http-types lifted-base process

14 temporary text wai yesod-core

10 temporary text wai yesod-core

@@ -16,4 +12,4 @@ mkDerivation {

16 homepage = "https://github.com/snoyberg/yesod-gitrepo";

12 homepage = "https://github.com/snoyberg/yesod-gitrepo";

17 description = "Host content provided by a Git repo";

13 description = "Host content provided by a Git repo";

18 license = stdenv.lib.licenses.mit;

14 license = stdenv.lib.licenses.mit;

19−}

15+}

test/golden-test-cases/yesod-recaptcha2.nix.golden+3−6

@@ -1,17 +1,14 @@

1−{ mkDerivation, base, classy-prelude-yesod, fetchurl, http-conduit

1+{ mkDerivation, base, classy-prelude-yesod, http-conduit, stdenv

2, yesod-auth

3}:

4mkDerivation {

5 pname = "yesod-recaptcha2";

6 version = "0.2.3";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [

8 libraryHaskellDepends = [

12 base classy-prelude-yesod http-conduit yesod-auth

9 base classy-prelude-yesod http-conduit yesod-auth

13 ];

10 ];

14 homepage = "https://github.com/ncaq/yesod-recaptcha2#readme";

11 homepage = "https://github.com/ncaq/yesod-recaptcha2#readme";

15 description = "yesod recaptcha2";

12 description = "yesod recaptcha2";

16 license = stdenv.lib.licenses.mit;

13 license = stdenv.lib.licenses.mit;

17−}

14+}

test/golden-test-cases/zlib.nix.golden+3−6

@@ -1,13 +1,10 @@

1−{ mkDerivation, base, bytestring, fetchurl, QuickCheck, tasty

1+{ mkDerivation, base, bytestring, QuickCheck, stdenv, tasty

2, tasty-hunit, tasty-quickcheck, zlib

3}:

4mkDerivation {

5 pname = "zlib";

6 version = "0.6.1.2";

7− src = fetchurl {

7+ sha256 = "deadbeef";

8− url = "http://example.org/";

9− sha256 = "abc";

10− };

11 libraryHaskellDepends = [ base bytestring ];

8 libraryHaskellDepends = [ base bytestring ];

12 librarySystemDepends = [ zlib ];

9 librarySystemDepends = [ zlib ];

13 testHaskellDepends = [

10 testHaskellDepends = [

@@ -15,4 +12,4 @@ mkDerivation {

15 ];

12 ];

16 description = "Compression and decompression in the gzip and zlib formats";

13 description = "Compression and decompression in the gzip and zlib formats";

17 license = stdenv.lib.licenses.bsd3;

14 license = stdenv.lib.licenses.bsd3;

18−}

15+}

update-hackage-snapshot.shnew file+19

@@ -0,0 +1,19 @@

1+#! /usr/bin/env bash

2+

3+set -eu -o pipefail

4+

5+rev=$( git ls-remote --heads git://github.com/commercialhaskell/all-cabal-hashes.git hackage \

6+ | cut -f1

7+ )

8+url="https://github.com/commercialhaskell/all-cabal-hashes/archive/$rev.tar.gz"

9+sha=$( nix-prefetch-url "$url" )

10+

11+sed -e "s|url = .*;|url = \"$url\";|" \

12+ -e "s|sha256 = .*;|sha256 = \"$sha\";|" \

13+ -i nixpkgs/pkgs/data/misc/hackage/default.nix

14+

15+cat <<EOF

16+Verify that the new snapshot actually works:

17+

18+nix-build --no-out-link -E 'with (import ./nixpkgs {}); haskellPackages.callHackage "hsdns" "1.7.1" {}'

19+EOF

update-nixpkgs.sh+1−1

@@ -31,7 +31,7 @@ hackage=$(git rev-parse --verify HEAD)

31cd ..

32

33# This command needs a recent development version of cabal-install. I don't

34−# think this works properly in verson 2.0.0.0 already.

34+# think this works properly in version 2.0.0.0 already.

35cabal -v0 new-run hackage2nix -- --nixpkgs="$PWD/nixpkgs" +RTS -M4G -RTS

36

37cd nixpkgs

update-stackage.sh+15−7

@@ -2,11 +2,14 @@

2

3set -eu -o pipefail

4

5−tmpfile=$(mktemp "stackage-update.XXXXXXX")

5+cd "$(dirname "$0")"

6−trap "rm $tmpfile" 0

7

6

8−curl -L -s "https://www.stackage.org/lts/cabal.config" >"$tmpfile"

7+tmpfile=$(mktemp "update-stackage.XXXXXXX")

9−version=$(sed -n "s/^--.*http:..www.stackage.org.snapshot.lts-//p" "$tmpfile")

8+# shellcheck disable=SC2064

9+trap "rm ${tmpfile} ${tmpfile}.new" 0

10+

11+curl -L -s "https://stackage.org/lts/cabal.config" >"$tmpfile"

12+version=$(sed -rn "s/^--.*http:..(www.)?stackage.org.snapshot.lts-//p" "$tmpfile")

10

13

11# Create a simple yaml version of the file.

14# Create a simple yaml version of the file.

12sed -r \

15sed -r \

@@ -16,12 +19,13 @@ sed -r \

16 -e 's|,$||' \

19 -e 's|,$||' \

17 -e '/installed$/d' \

20 -e '/installed$/d' \

18 -e '/^$/d' \

21 -e '/^$/d' \

19− -i "$tmpfile"

22+ < "${tmpfile}" | sort --ignore-case >"${tmpfile}.new"

20

23

21# Drop restrictions on some tools where we always want the latest version.

24# Drop restrictions on some tools where we always want the latest version.

22sed -r \

25sed -r \

23 -e '/ cabal-install /d' \

26 -e '/ cabal-install /d' \

24 -e '/ cabal2nix /d' \

27 -e '/ cabal2nix /d' \

28+ -e '/ cabal2spec /d' \

25 -e '/ distribution-nixpkgs /d' \

29 -e '/ distribution-nixpkgs /d' \

26 -e '/ git-annex /d' \

30 -e '/ git-annex /d' \

27 -e '/ hindent /d' \

31 -e '/ hindent /d' \

@@ -29,14 +33,18 @@ sed -r \

29 -e '/ hlint /d' \

33 -e '/ hlint /d' \

30 -e '/ hoogle /d' \

34 -e '/ hoogle /d' \

31 -e '/ hopenssl /d' \

35 -e '/ hopenssl /d' \

36+ -e '/ jailbreak-cabal /d' \

37+ -e '/ json-autotype/d' \

32 -e '/ language-nix /d' \

38 -e '/ language-nix /d' \

39+ -e '/ shake /d' \

33 -e '/ ShellCheck /d' \

40 -e '/ ShellCheck /d' \

34 -e '/ stack /d' \

41 -e '/ stack /d' \

35 -e '/ weeder /d' \

42 -e '/ weeder /d' \

36− -i "$tmpfile"

43+ < "${tmpfile}.new" > "${tmpfile}"

37

44

38# Drop the previous configuration ...

45# Drop the previous configuration ...

39−sed -e '/# LTS Haskell/,/^$/c \TODO\

46+# shellcheck disable=SC1004

47+sed -e '/ # LTS Haskell/,/^$/c \TODO\

40' -i nixpkgs/pkgs/development/haskell-modules/configuration-hackage2nix.yaml

48' -i nixpkgs/pkgs/development/haskell-modules/configuration-hackage2nix.yaml

41

49

42# ... and replace it with the new one.

50# ... and replace it with the new one.