How to version control patched dependencies? - haskell

Using cabal sandboxes, how do I specify that my project depends on a patched version of a library, then check that dependency into version control?
I know I can use cabal sandbox add-source to add a dependency on a patched version, but that just changes something locally right? Any other programmer would have to remember to run that command in order to build the project.

There are a couple of ways to constrain the version for installation.
Add lower and upper bounds to package versions in the cabal file, example of such a file here
Additionally, you can override the settings in the .cabal file with the flag constraint like so: cabal install --constraint="bar-2.1"
To remove a specific version of a package:
In a sandbox you can unregister a version with cabal sandbox hc-pkg unregister bar-2.1
Global unregistering can be done with this command outside of sandbox ghc-pkg unregister bar-2.1

Related

Cabal: only work with checked in libraries in project directory

I would like to download all the dependencies of my cabal project to my project directory/repository and force cabal to never use ~/.cabal/ and never download any new dependency from the internet. The downloaded libraries should be system independent (not include local paths etc.). Is this possible?
The idea behind this is, to copy the project directory to another (offline) system where the same ghc is installed and it should work out of the box.
According to the cabal docs, you can set active-repositories: none in your cabal.project or cabal file to put cabal-install in offline mode.
Then, you could create a cabal project and try to make all the dependencies that don't come bundled with GHC itself local packages. Clone them in your project folder and add them to the packages: section of cabal.project.
The problem with the above is that running cabal clean would require re-compiling all packages afterwards.
As an alternative, create a local no-index package repository in your offline machine, make it the only available package repository using active-repositories:, and put the sdist tarballs of all your dependencies there.
That way the dependencies will only be compiled once.

How do I get cabal to use a local version of a package as a dependency for a Hackage package?

I'm trying to install aeson on GHC 9.2.1. I first ran cabal install --allow-newer --lib aeson, which failed when it got to building attoparsec. It turns out this problem is already fixed in their Git repo, but hasn't landed in a release on Hackage yet. I then did these steps to build a local version with the fix:
git clone https://github.com/haskell/attoparsec.git
cd attoparsec
cabal install --allow-newer --lib .
cd ..
That succeeded, but then when I did cabal install --allow-newer --lib aeson again, it tried to build attoparsec from Hackage again, and so failed again. How can I make cabal use what I just built and installed instead?
There are two main methods.
One is to create a cabal project that includes both the cloned version of attoparsec and the local packages that you are working on (packages that might depend on aeson). It could be as simple as
packages: attoparsec yourpackage
In fact, you don't even need to clone the repo, you could use the source-repository-package field instead.
Because local packages always take precedence over external ones, the repo version will be chosen when resolving dependencies.
This approach works well but has the disadvantage that if you use the patched attoparsec in many different projects, you'll have to reference and re-compile it each time.
Another approach is to create a local no-index package repository in your machine, give it priority over stardard Hackage, and put attoparsec's sdist tarball there.
You need to declare the extra package repository using the repository field of your global cabal config (the path to the config is displayed in the last line of cabal help). By default, there's only Hackage:
repository hackage.haskell.org
url: http://hackage.haskell.org/
To give the local package repository priority over Hackage, you need to use the active-repositories field, either in your global Cabal config or in a cabal.project file.
The advantage of this method is that you don't need to create a Cabal project, and that the patched version of attoparsec will only be compiled once (as if it came from Hackage).

Why cabal sandbox init does not change PATH like virtualenv does?

Haskell newbie and Python guy here.
I think I may be missing something here but if you look at Yesod's quickstart, the autor install some packages before cabal sandbox init. I have seen the same pattern elsewhere. Questions:
Am I missing something? Is this the real way to use cabal sandbox?
Why can't (or shouldn't) I install yesod-bin inside a sandbox?
What if I use different versions of yesod-bin throughout some projects?
If there is some libraries that install binaries inside .cabal-sandbox/bin, why cabal sandbox init don't change PATH in order to match the sandboxed version?
Thank you very much in advance!
Yes, this how to use a sandbox.
cabal sandbox init will create some files / directories for you that will keep track of the packages you have installed.
cabal install some_package will install that package into the sandbox.
You are more than welcome to install yesod-bin into a sandbox.
Read point 2
cabal sandbox init doesn't change your path, because it doesn't really need to. Just add PATH=.cabal-sandbox/bin:$PATH in your .bash_profile.
Unlike virtual-env, you never need to 'enable' or 'disable' a sandbox. You just cd into a directory, and it is automatically enabled.
The only real downside I have found to cabal sandboxes, is that you need to be in the root directory in order to act upon a sandbox. Meaning, if you are in a sub-directory, running cabal install some_package will not install it into the sandbox that is up a level, instead it will install it into either the global or user database, depending on how you have cabal configured.
cabal exec lets you execute a program in the context of a sandbox. It changes the path to include the bin folder of the sandbox. You can see it by executing cabal exec printenv inside the sandbox.
Also, the latest versions of cabal let you create sandboxes in folders without .cabal files. Once you run cabal sandbox init, you can just cabal install the dependencies you need.
So, to use different versions of yesod-bin, install them in different sandboxes, and then invoke cabal exec yesod-bin on each one.
(Extra tip: cabal exec gchi is a useful command that makes ghci aware of the contents of the sandbox.)

Cabal-install installs old package versions by default

I just upgraded to the latest version of cabal-install which is 1.20. I am not sure if it is related but cabal started fetching old versions of packages for some reason.
In my cabal file, all dependencies are specified without version numbers. So I believe, cabal should fetch the latest versions available unless there is a conflict, correct?
If I run cabal install --only-dependencies within a sandbox environment, cabal pulls all kind of rubbish and old package versions like mongoDB-1.2.2 instead of 1.4.4 and scotty-0.5 instead of 0.7.2. If I run a specific package installation like cabal install scotty then it fetches the latest version and all is well. So I have to install all dependencies manually to get the latest versions - one by one. Annoying. What is going on?
Google gives me no hits.
If there are some kind of changes in cabal, what is it? And how do I pull all the latest dependencies within a sandbox.
Thanks.
Some of your dependencies have upper bounds that are forcing the usage of older versions of a given package. One thing that might help is to start over. Delete your package repository (~/.ghc on linux machines), and keep a discipline to work entirely within sandboxes. Use your package manager to install stuff you need globally, sandboxes for your development projects, and you can avoid a lot of the reasons this problem crops up. That said, if you're truly depending on a project that hasn't updated its upper bounds, then you're stuck using the older packages, short of submitting a patch to the library author or switching to a different dependency.

Link cabal to local library

Lets MyLib be my local Haskell library. I can build it with cabal build and install it with cabal install, but can I use it in other projects without the installation step?
I'm developing several libraries and installing them after every change is not a good solution.
Let's say you have two entirely separate projects, one called my-library and another called my-project. And my-project depends on my-library.
The way to build my-library and make it available to other projects is cabal install my-library. Once that's done, any other project can use the library.
Now you're ready to build my-project using the command cabal install my-project. It will not rebuild or reinstall my-library, but it will link your project with the library.
Now, if you make modifications to my-library, be sure to update the version number before running cabal install my-library. If you forget to bump the version number, you will be warned that my-project will be made obsolete. Now the old version and the new version of your library are available to other projects.
You can continue to run your projects. They will happily continue to use the previous version of my-library until you do another cabal install my-project. So there is no need to re-install everything after every change.
If you do want to rebuild your projects, but continue to work with an older version of your library, you can specify that in the build-depends section of your cabal file. For example, if you have versions 1.0 and 2.0 of my-library installed, you can build your project against the older version like this:
build-depends: my-library==1.0, ...
There isn't a great solution to your problem, but you can use sandboxes to keep your development environment a bit cleaner.
With cabal-1.18 or newer, you can create a sandbox with cabal sandbox init and then you can either install to that sandbox or add-source (cabal sandbox add-source <path to library>).
This helps to keep unstable libraries (and their potentially unstable dependencies) out of your user package database, and that can help prevent 'cabal hell' (unsolvable conflicts between dependencies). However, that doesn't directly help reduce the number of commands you need to issue each time you want to do a top-level build.
What you can do though, is set up a simple script that performs the add-source commands and builds your top-level package. eg:
#!/bin/bash
cabal sandbox init # a no-op if the sandbox exists.
cabal sandbox add-source ../MyLib
cabal install --dependencies-only
cabal build
Granted, you could do that before, but this time you can also easily clean up (removing all the installed artifacts) by cleaning the sandbox:
cabal sandbox delete

Resources