2017-04-12 18:28:06 +01:00
|
|
|
# This expression takes a file like `hackage-packages.nix` and constructs
|
|
|
|
# a full package set out of that.
|
|
|
|
|
2017-09-10 20:36:48 +01:00
|
|
|
{ # package-set used for build tools (all of nixpkgs)
|
|
|
|
buildPackages
|
|
|
|
|
2018-01-04 21:18:02 +00:00
|
|
|
, # A haskell package set for Setup.hs, compiler plugins, and similar
|
|
|
|
# build-time uses.
|
|
|
|
buildHaskellPackages
|
|
|
|
|
2017-09-10 20:36:48 +01:00
|
|
|
, # package-set used for non-haskell dependencies (all of nixpkgs)
|
2017-08-01 17:44:08 +01:00
|
|
|
pkgs
|
2017-04-12 18:28:06 +01:00
|
|
|
|
2017-08-01 17:44:08 +01:00
|
|
|
, # stdenv to use for building haskell packages
|
|
|
|
stdenv
|
|
|
|
|
|
|
|
, haskellLib
|
|
|
|
|
|
|
|
, # hashes for downloading Hackage packages
|
|
|
|
all-cabal-hashes
|
|
|
|
|
|
|
|
, # compiler to use
|
|
|
|
ghc
|
|
|
|
|
2018-01-04 21:18:02 +00:00
|
|
|
, # A function that takes `{ pkgs, stdenv, callPackage }` as the first arg and
|
|
|
|
# `self` as second, and returns a set of haskell packages
|
2017-08-01 17:44:08 +01:00
|
|
|
package-set
|
|
|
|
|
|
|
|
, # The final, fully overriden package set usable with the nixpkgs fixpoint
|
|
|
|
# overriding functionality
|
|
|
|
extensible-self
|
|
|
|
}:
|
2017-04-12 18:28:06 +01:00
|
|
|
|
|
|
|
# return value: a function from self to the package set
|
2017-08-06 20:46:49 +01:00
|
|
|
self:
|
|
|
|
|
|
|
|
let
|
2017-09-10 20:36:48 +01:00
|
|
|
inherit (stdenv) buildPlatform hostPlatform;
|
2017-04-12 18:28:06 +01:00
|
|
|
|
2017-09-29 14:11:26 +01:00
|
|
|
inherit (stdenv.lib) fix' extends makeOverridable;
|
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
|
|
|
inherit (haskellLib) overrideCabal;
|
2017-04-12 18:28:06 +01:00
|
|
|
|
|
|
|
mkDerivationImpl = pkgs.callPackage ./generic-builder.nix {
|
2017-12-28 18:23:41 +00:00
|
|
|
inherit stdenv;
|
2017-09-10 20:36:48 +01:00
|
|
|
nodejs = buildPackages.nodejs-slim;
|
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
|
|
|
inherit (self) buildHaskellPackages ghc ghcWithHoogle ghcWithPackages;
|
2018-09-17 20:59:37 +01:00
|
|
|
inherit (self.buildHaskellPackages) jailbreak-cabal;
|
|
|
|
hscolour = overrideCabal self.buildHaskellPackages.hscolour (drv: {
|
2017-04-12 18:28:06 +01:00
|
|
|
isLibrary = false;
|
|
|
|
doHaddock = false;
|
|
|
|
hyperlinkSource = false; # Avoid depending on hscolour for this build.
|
|
|
|
postFixup = "rm -rf $out/lib $out/share $out/nix-support";
|
|
|
|
});
|
|
|
|
cpphs = overrideCabal (self.cpphs.overrideScope (self: super: {
|
|
|
|
mkDerivation = drv: super.mkDerivation (drv // {
|
|
|
|
enableSharedExecutables = false;
|
|
|
|
enableSharedLibraries = false;
|
|
|
|
doHaddock = false;
|
|
|
|
useCpphs = false;
|
|
|
|
});
|
|
|
|
})) (drv: {
|
|
|
|
isLibrary = false;
|
|
|
|
postFixup = "rm -rf $out/lib $out/share $out/nix-support";
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
|
|
|
mkDerivation = makeOverridable mkDerivationImpl;
|
|
|
|
|
2017-09-29 14:11:26 +01:00
|
|
|
# manualArgs are the arguments that were explictly passed to `callPackage`, like:
|
|
|
|
#
|
|
|
|
# callPackage foo { bar = null; };
|
|
|
|
#
|
|
|
|
# here `bar` is a manual argument.
|
|
|
|
callPackageWithScope = scope: fn: manualArgs:
|
|
|
|
let
|
|
|
|
# this code is copied from callPackage in lib/customisation.nix
|
|
|
|
#
|
|
|
|
# we cannot use `callPackage` here because we want to call `makeOverridable`
|
|
|
|
# on `drvScope` (we cannot add `overrideScope` after calling `callPackage` because then it is
|
|
|
|
# lost on `.override`) but determine the auto-args based on `drv` (the problem here
|
|
|
|
# is that nix has no way to "passthrough" args while preserving the reflection
|
|
|
|
# info that callPackage uses to determine the arguments).
|
2018-01-31 19:02:19 +00:00
|
|
|
drv = if stdenv.lib.isFunction fn then fn else import fn;
|
|
|
|
auto = builtins.intersectAttrs (stdenv.lib.functionArgs drv) scope;
|
2017-09-29 14:11:26 +01:00
|
|
|
|
|
|
|
# this wraps the `drv` function to add a `overrideScope` function to the result.
|
|
|
|
drvScope = allArgs: drv allArgs // {
|
|
|
|
overrideScope = f:
|
|
|
|
let newScope = mkScope (fix' (extends f scope.__unfix__));
|
|
|
|
# note that we have to be careful here: `allArgs` includes the auto-arguments that
|
|
|
|
# weren't manually specified. If we would just pass `allArgs` to the recursive call here,
|
|
|
|
# then we wouldn't look up any packages in the scope in the next interation, because it
|
|
|
|
# appears as if all arguments were already manually passed, so the scope change would do
|
|
|
|
# nothing.
|
|
|
|
in callPackageWithScope newScope drv manualArgs;
|
|
|
|
};
|
|
|
|
in stdenv.lib.makeOverridable drvScope (auto // manualArgs);
|
|
|
|
|
2018-07-07 19:28:42 +01:00
|
|
|
mkScope = scope: let
|
|
|
|
ps = pkgs.__splicedPackages;
|
|
|
|
scopeSpliced = pkgs.splicePackages {
|
|
|
|
pkgsBuildBuild = scope.buildHaskellPackages.buildHaskellPackages;
|
|
|
|
pkgsBuildHost = scope.buildHaskellPackages;
|
|
|
|
pkgsBuildTarget = {};
|
|
|
|
pkgsHostHost = {};
|
|
|
|
pkgsHostTarget = scope;
|
|
|
|
pkgsTargetTarget = {};
|
|
|
|
} // {
|
|
|
|
# Don't splice these
|
|
|
|
inherit (scope) ghc buildHaskellPackages;
|
|
|
|
};
|
|
|
|
in ps // ps.xorg // ps.gnome2 // { inherit stdenv; } // scopeSpliced;
|
2017-04-12 18:28:06 +01:00
|
|
|
defaultScope = mkScope self;
|
2017-09-29 14:11:26 +01:00
|
|
|
callPackage = drv: args: callPackageWithScope defaultScope drv args;
|
2017-04-12 18:28:06 +01:00
|
|
|
|
2018-01-03 04:39:28 +00:00
|
|
|
withPackages = packages: buildPackages.callPackage ./with-packages-wrapper.nix {
|
2018-06-07 19:27:44 +01:00
|
|
|
inherit (self) ghc llvmPackages;
|
2017-04-12 18:28:06 +01:00
|
|
|
inherit packages;
|
|
|
|
};
|
|
|
|
|
2019-05-14 06:18:02 +01:00
|
|
|
# Use cabal2nix to create a default.nix for the package sources found at 'src'.
|
2018-03-09 13:47:47 +00:00
|
|
|
haskellSrc2nix = { name, src, sha256 ? null, extraCabal2nixOptions ? "" }:
|
2017-04-12 18:28:06 +01:00
|
|
|
let
|
2019-04-24 04:48:22 +01:00
|
|
|
sha256Arg = if sha256 == null then "--sha256=" else ''--sha256="${sha256}"'';
|
2019-10-01 17:35:51 +01:00
|
|
|
in buildPackages.stdenv.mkDerivation {
|
2017-04-12 18:28:06 +01:00
|
|
|
name = "cabal2nix-${name}";
|
2019-10-01 17:35:51 +01:00
|
|
|
nativeBuildInputs = [ buildPackages.cabal2nix ];
|
2017-05-01 23:21:42 +01:00
|
|
|
preferLocalBuild = true;
|
2018-11-06 14:17:07 +00:00
|
|
|
allowSubstitutes = false;
|
2017-04-12 18:28:06 +01:00
|
|
|
phases = ["installPhase"];
|
|
|
|
LANG = "en_US.UTF-8";
|
2018-07-17 14:42:55 +01:00
|
|
|
LOCALE_ARCHIVE = pkgs.lib.optionalString (buildPlatform.libc == "glibc") "${buildPackages.glibcLocales}/lib/locale/locale-archive";
|
2017-04-12 18:28:06 +01:00
|
|
|
installPhase = ''
|
|
|
|
export HOME="$TMP"
|
|
|
|
mkdir -p "$out"
|
2019-10-15 16:22:19 +01:00
|
|
|
cabal2nix --compiler=${self.ghc.haskellCompilerName} --system=${hostPlatform.config} ${sha256Arg} "${src}" ${extraCabal2nixOptions} > "$out/default.nix"
|
2017-04-12 18:28:06 +01:00
|
|
|
'';
|
|
|
|
};
|
|
|
|
|
2019-10-01 17:35:51 +01:00
|
|
|
all-cabal-hashes-component = name: version: buildPackages.runCommand "all-cabal-hashes-component-${name}-${version}" {} ''
|
2017-11-06 21:26:05 +00:00
|
|
|
tar --wildcards -xzvf ${all-cabal-hashes} \*/${name}/${version}/${name}.{json,cabal}
|
|
|
|
mkdir -p $out
|
|
|
|
mv */${name}/${version}/${name}.{json,cabal} $out
|
|
|
|
'';
|
|
|
|
|
|
|
|
hackage2nix = name: version: let component = all-cabal-hashes-component name version; in self.haskellSrc2nix {
|
2017-04-12 18:28:06 +01:00
|
|
|
name = "${name}-${version}";
|
2017-11-06 21:26:05 +00:00
|
|
|
sha256 = ''$(sed -e 's/.*"SHA256":"//' -e 's/".*$//' "${component}/${name}.json")'';
|
|
|
|
src = "${component}/${name}.cabal";
|
2017-04-12 18:28:06 +01:00
|
|
|
};
|
|
|
|
|
2018-03-25 08:12:28 +01:00
|
|
|
# Adds a nix file as an input to the haskell derivation it
|
|
|
|
# produces. This is useful for callHackage / callCabal2nix to
|
|
|
|
# prevent the generated default.nix from being garbage collected
|
|
|
|
# (requiring it to be frequently rebuilt), which can be an
|
|
|
|
# annoyance.
|
|
|
|
callPackageKeepDeriver = src: args:
|
|
|
|
overrideCabal (self.callPackage src args) (orig: {
|
|
|
|
preConfigure = ''
|
|
|
|
# Generated from ${src}
|
|
|
|
${orig.preConfigure or ""}
|
|
|
|
'';
|
2018-08-02 14:48:06 +01:00
|
|
|
passthru = orig.passthru or {} // {
|
|
|
|
# When using callCabal2nix or callHackage, it is often useful
|
|
|
|
# to debug a failure by inspecting the Nix expression
|
|
|
|
# generated by cabal2nix. This can be accessed via this
|
|
|
|
# cabal2nixDeriver field.
|
|
|
|
cabal2nixDeriver = src;
|
|
|
|
};
|
2018-03-25 08:12:28 +01:00
|
|
|
});
|
|
|
|
|
2017-04-12 18:28:06 +01:00
|
|
|
in package-set { inherit pkgs stdenv callPackage; } self // {
|
|
|
|
|
2018-07-07 19:28:42 +01:00
|
|
|
inherit mkDerivation callPackage haskellSrc2nix hackage2nix buildHaskellPackages;
|
2017-04-12 18:28:06 +01:00
|
|
|
|
2018-01-18 21:37:47 +00:00
|
|
|
inherit (haskellLib) packageSourceOverrides;
|
|
|
|
|
2019-05-14 06:18:02 +01:00
|
|
|
# callHackage :: Text -> Text -> AttrSet -> HaskellPackage
|
|
|
|
#
|
|
|
|
# e.g., while overriding a package set:
|
|
|
|
# '... foo = self.callHackage "foo" "1.5.3" {}; ...'
|
2018-03-25 08:12:28 +01:00
|
|
|
callHackage = name: version: callPackageKeepDeriver (self.hackage2nix name version);
|
2017-04-12 18:28:06 +01:00
|
|
|
|
2019-11-20 06:36:33 +00:00
|
|
|
# callHackageDirect
|
|
|
|
# :: { pkg :: Text, ver :: Text, sha256 :: Text }
|
|
|
|
# -> AttrSet
|
|
|
|
# -> HaskellPackage
|
2019-05-14 06:18:02 +01:00
|
|
|
#
|
2018-12-25 17:19:24 +00:00
|
|
|
# This function does not depend on all-cabal-hashes and therefore will work
|
|
|
|
# for any version that has been released on hackage as opposed to only
|
|
|
|
# versions released before whatever version of all-cabal-hashes you happen
|
|
|
|
# to be currently using.
|
2019-06-16 20:59:06 +01:00
|
|
|
callHackageDirect = {pkg, ver, sha256}:
|
2018-12-25 17:19:24 +00:00
|
|
|
let pkgver = "${pkg}-${ver}";
|
|
|
|
in self.callCabal2nix pkg (pkgs.fetchzip {
|
2019-04-05 18:49:48 +01:00
|
|
|
url = "mirror://hackage/${pkgver}/${pkgver}.tar.gz";
|
2018-12-25 17:19:24 +00:00
|
|
|
inherit sha256;
|
2019-01-27 17:28:01 +00:00
|
|
|
});
|
2018-12-25 17:19:24 +00:00
|
|
|
|
2017-04-12 18:28:06 +01:00
|
|
|
# Creates a Haskell package from a source package by calling cabal2nix on the source.
|
2018-08-03 20:55:29 +01:00
|
|
|
callCabal2nixWithOptions = name: src: extraCabal2nixOptions: args:
|
|
|
|
let
|
|
|
|
filter = path: type:
|
|
|
|
pkgs.lib.hasSuffix "${name}.cabal" path ||
|
|
|
|
baseNameOf path == "package.yaml";
|
|
|
|
expr = self.haskellSrc2nix {
|
|
|
|
inherit name extraCabal2nixOptions;
|
|
|
|
src = if pkgs.lib.canCleanSource src
|
|
|
|
then pkgs.lib.cleanSourceWith { inherit src filter; }
|
|
|
|
else src;
|
|
|
|
};
|
|
|
|
in overrideCabal (callPackageKeepDeriver expr args) (orig: {
|
|
|
|
inherit src;
|
|
|
|
});
|
|
|
|
|
|
|
|
callCabal2nix = name: src: args: self.callCabal2nixWithOptions name src "" args;
|
2017-04-12 18:28:06 +01:00
|
|
|
|
2017-06-13 00:29:46 +01:00
|
|
|
# : { root : Path
|
2018-10-15 21:15:03 +01:00
|
|
|
# , name : Defaulted String
|
2017-06-24 11:42:56 +01:00
|
|
|
# , source-overrides : Defaulted (Either Path VersionNumber)
|
2017-06-13 00:29:46 +01:00
|
|
|
# , overrides : Defaulted (HaskellPackageOverrideSet)
|
2018-01-30 03:29:59 +00:00
|
|
|
# , modifier : Defaulted
|
2018-05-16 06:02:00 +01:00
|
|
|
# , returnShellEnv : Defaulted
|
2017-06-13 00:29:46 +01:00
|
|
|
# } -> NixShellAwareDerivation
|
2018-10-17 19:44:07 +01:00
|
|
|
# Given a path to a haskell package directory, an optional package name
|
|
|
|
# which defaults to the base name of the path, an optional set of source
|
|
|
|
# overrides as appropriate for the 'packageSourceOverrides' function, an
|
|
|
|
# optional set of arbitrary overrides, and an optional haskell package
|
|
|
|
# modifier, return a derivation appropriate for nix-build or nix-shell to
|
|
|
|
# build that package.
|
2018-05-16 06:02:00 +01:00
|
|
|
developPackage =
|
|
|
|
{ root
|
2018-10-15 21:15:03 +01:00
|
|
|
, name ? builtins.baseNameOf root
|
2018-05-16 06:02:00 +01:00
|
|
|
, source-overrides ? {}
|
|
|
|
, overrides ? self: super: {}
|
|
|
|
, modifier ? drv: drv
|
|
|
|
, returnShellEnv ? pkgs.lib.inNixShell }:
|
|
|
|
let drv =
|
|
|
|
(extensible-self.extend
|
|
|
|
(pkgs.lib.composeExtensions
|
|
|
|
(self.packageSourceOverrides source-overrides)
|
|
|
|
overrides))
|
2018-10-15 21:15:03 +01:00
|
|
|
.callCabal2nix name root {};
|
2018-05-16 06:02:00 +01:00
|
|
|
in if returnShellEnv then (modifier drv).env else modifier drv;
|
2017-06-11 01:04:46 +01:00
|
|
|
|
2017-04-12 18:28:06 +01:00
|
|
|
ghcWithPackages = selectFrom: withPackages (selectFrom self);
|
|
|
|
|
|
|
|
ghcWithHoogle = selectFrom:
|
|
|
|
let
|
|
|
|
packages = selectFrom self;
|
|
|
|
hoogle = callPackage ./hoogle.nix {
|
|
|
|
inherit packages;
|
|
|
|
};
|
|
|
|
in withPackages (packages ++ [ hoogle ]);
|
|
|
|
|
2018-03-06 20:37:05 +00:00
|
|
|
# Returns a derivation whose environment contains a GHC with only
|
|
|
|
# the dependencies of packages listed in `packages`, not the
|
|
|
|
# packages themselves. Using nix-shell on this derivation will
|
|
|
|
# give you an environment suitable for developing the listed
|
|
|
|
# packages with an incremental tool like cabal-install.
|
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
|
|
|
# In addition to the "packages" arg and "withHoogle" arg, anything that
|
|
|
|
# can be passed into stdenv.mkDerivation can be included in the input attrset
|
2018-03-06 20:37:05 +00:00
|
|
|
#
|
|
|
|
# # default.nix
|
|
|
|
# with import <nixpkgs> {};
|
|
|
|
# haskellPackages.extend (haskell.lib.packageSourceOverrides {
|
|
|
|
# frontend = ./frontend;
|
|
|
|
# backend = ./backend;
|
|
|
|
# common = ./common;
|
|
|
|
# })
|
|
|
|
#
|
|
|
|
# # shell.nix
|
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
|
|
|
# let pkgs = import <nixpkgs> {} in
|
2018-03-06 20:37:05 +00:00
|
|
|
# (import ./.).shellFor {
|
|
|
|
# packages = p: [p.frontend p.backend p.common];
|
|
|
|
# withHoogle = true;
|
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
|
|
|
# buildInputs = [ pkgs.python ];
|
2018-03-06 20:37:05 +00:00
|
|
|
# }
|
|
|
|
#
|
|
|
|
# -- cabal.project
|
|
|
|
# packages:
|
|
|
|
# frontend/
|
|
|
|
# backend/
|
|
|
|
# common/
|
|
|
|
#
|
|
|
|
# bash$ nix-shell --run "cabal new-build all"
|
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
|
|
|
# bash$ nix-shell --run "python"
|
2018-03-06 20:37:05 +00:00
|
|
|
shellFor = { packages, withHoogle ? false, ... } @ args:
|
|
|
|
let
|
shellFor: Refactor for consistency and cross
This makes it work like work-on-multi from Reflex Platform. In
particular, rather than making `.env` from `shellFor`, we make `.env`
the primitive, and `shellFor` works by combining together the arguments
of all the packages to `generic-builder` and taking the `.env` of the
resulting mashup-package.
There are 2 benefits of this:
1. The dependency logic is deduplicated. generic builder just concatted
lists, whereas all the envs until now would sieve apart haskell and
system build inputs. Now, they both decide haskell vs system the same
way: according to the argument list and without reflection.
Consistency is good, especially because it mean that if the build
works, the shell is more likely to work.
2. Cross is handled better. For native builds, because the
`ghcWithPackages` calls would shadow, we through both the regular
component (lib, exe, test, bench) haskell deps and Setup.hs haskell
deps in the same `ghcWithPackages` call. But for cross builds we use
`buildPackages.ghcWithPackages` to get the setup deps. This ensures
everything works correctly.
2019-12-23 20:33:18 +00:00
|
|
|
combinedPackageFor = packages:
|
|
|
|
let
|
|
|
|
selected = packages self;
|
|
|
|
|
|
|
|
pname = if pkgs.lib.length selected == 1
|
|
|
|
then (pkgs.lib.head selected).name
|
|
|
|
else "packages";
|
|
|
|
|
|
|
|
# If `packages = [ a b ]` and `a` depends on `b`, don't build `b`,
|
|
|
|
# because cabal will end up ignoring that built version, assuming
|
|
|
|
# new-style commands.
|
|
|
|
combinedPackages = pkgs.lib.filter
|
|
|
|
(input: pkgs.lib.all (p: input.outPath or null != p.outPath) selected);
|
|
|
|
|
|
|
|
# Returns an attrset containing a combined list packages' inputs for each
|
|
|
|
# stage of the build process
|
|
|
|
packageInputs = pkgs.lib.zipAttrsWith
|
|
|
|
(_: pkgs.lib.concatMap combinedPackages)
|
|
|
|
(map (p: p.getCabalDeps) selected);
|
|
|
|
|
|
|
|
genericBuilderArgs = {
|
|
|
|
inherit pname;
|
|
|
|
version = "0";
|
|
|
|
license = null;
|
|
|
|
} // packageInputs;
|
|
|
|
|
|
|
|
in self.mkDerivation genericBuilderArgs;
|
|
|
|
|
|
|
|
envFuncArgs = builtins.removeAttrs args [ "packages" ];
|
|
|
|
in (combinedPackageFor packages).env.overrideAttrs (old: envFuncArgs // {
|
|
|
|
nativeBuildInputs = old.nativeBuildInputs ++ envFuncArgs.nativeBuildInputs or [];
|
|
|
|
buildInputs = old.buildInputs ++ envFuncArgs.buildInputs or [];
|
2018-03-06 20:37:05 +00:00
|
|
|
});
|
|
|
|
|
2017-04-12 18:28:06 +01:00
|
|
|
ghc = ghc // {
|
|
|
|
withPackages = self.ghcWithPackages;
|
|
|
|
withHoogle = self.ghcWithHoogle;
|
|
|
|
};
|
|
|
|
|
|
|
|
}
|