Test Cabalized package against multiple dependency versions http://www.github.com/massysett/sunlight
|Latest on Hackage:||0.6.0.0|
This package is not currently in any snapshots. If you're interested in using it, we recommend adding it to Stackage Nightly. Doing so will make builds more reliable, and allow stackage.org to host generated Haddocks.
sunlight helps you test your Cabalized package against multiple dependency versions.
I wrote sunlight because of minor quibbles I have with the Haskell Package Versioning Policy. The PVP encourages you to record top bounds on each of the dependencies in your package. This often keeps packages from building when dependencies are updated, even if the dependencies have changed in harmless ways.
I'm not the only one with quibbles here: Haskell Cafe discussion. My only quibble is with upper bounds; specifying the release of a package by using the PVP is an excellent practice.
I figure it would be much more useful for the Cabal file to serve as documentation of software versions that the package will build with. The problem is that there was no easy way to make sure that a package builds with the minimum versions specified in the Cabal file. For example, cabal install does not have an option to fetch the lowest version of each dependency; instead, it eagerly fetches the most recent dependencies--which is what you want most of the time, but this makes it hard to ensure that the package builds with the lowest possible dependencies.
sunlight automatically builds the package using multiple GHC versions, so you can verify that the package builds even with different dependencies or compiler versions. This also makes it easier to maintain a package that builds with older GHC versions that you may not use regularly.
To use sunlight, you need to specify a minimum bound for each dependency. That minimum bound must be resolvable to an actual version of the package. It's OK to specify an exact bound, or an optional maximum bound, but there must be a minimum.
For example, these are all acceptable:
bytestring ==0.9.2.1 bytestring >= 0.9.2.1 && < 0.10 bytestring >= 0.9.2.1
This is not acceptable because there is no bound at all:
This is not acceptable because there is no lower bound:
bytestring <= 0.10
Then you build a test executable. An example is in the
sunlight-test.hs file in the sunlight git tree. This program
tests sunlight itself.
The executable will output a number of reports in a
directory, and it will also output a
to show you the most recent versions of dependencies that work with
your package, as well as a
minimum-versions.txt file showing you
that your package builds and tests with the minimum package
Also, see the Haddocks on the Test.Sunlight module.
sunlight works, but I'm not sure it is a good solution to the problem of managing bounds and dependencies in a Cabal file. In particular, it might be a better long-term idea to change cabal-install so that it can fetch the lowest versions rather than the most recent ones.
sunlight works on simple Cabal files but I have not tested it on any exotic files.
sunlight makes no effort to be compatible with any Haskell compiler other than GHC.
cabal-freeze - hopefully will appear in
sunlight is licensed under the BSD license.
Why the name?
The word "cabal" has shadowy connotations. This package helps ensure your cabal is doing what you say it is doing...so it helps shine sunlight on your cabal which is, as they say, the best disinfectant.