git.iko.soy/haskell.nix
on 19052d8 help sign in
haskell.nix/modules/plan.nix
307 lines 11 kB history raw
1# The plan (that is, a package set description like an LTS set or a
2# plan.nix (derived from plan.json)) will produce a structure that
3# looks like, which is stored in config.plan.pkg-def:
4#
5# { packages = { "package" = { revision = hackageConfigs.$package.$version.revisions.default;
6# flags = { flag1 = true; flag2 = false; ... }; };
7# ... };
8# compiler = { version = "X.Y.Z"; nix-name ="ghcXYZ";
9# # packages that come bundled with the compiler
10# packages = { "bytestring" = "a.b.c.d"; ... }; };
11# }
13{ lib, config, pkgs, pkgconfPkgs, haskellLib, ... }:
15with lib;
16with types;
18let
19 # dealing with str is a bit annoying especially with `nullOr str` as that apparently defaults to ""
20 # instead of null :shrug:. This then messes with our option inheritance logic.
21 # Hence we have a uniqueStr type that ensures multiple identically defined options are collapsed
22 # without raising an error. And a way to fetch default options that will retain `null` if the
23 # option is not defined or "".
24 getDefaultOrNull = def: key: if def ? ${key} && def.${key} != "" then def.${key} else null;
25 mergeUniqueOption = locs: defs: let
26 mergeOneOption = loc: defs':
27 # we ignore "" as optionalString, will default to "".
28 let defs = filter (x: x.value != "") defs'; in
29 if defs == [] then null
30 else if length defs != 1 then
31 throw "The unique option `${showOption loc}' is defined multiple times, in ${showFiles (getFiles defs)}; with values `${concatStringsSep "', `" (map (x: x.value) defs)}'."
32 else (head defs).value;
33 in mergeOneOption locs (lists.unique defs);
34 uniqueStr = str // { merge = mergeUniqueOption; };
36 # This is just like listOf, except that it filters out all null elements.
37 listOfFilteringNulls = elemType: listOf elemType // {
38 # Mostly copied from nixpkgs/lib/types.nix
39 merge = loc: defs:
40 map (x: x.value) (filter (x: x ? value && x.value != null) (concatLists (imap1 (n: def:
41 if isList def.value then
42 imap1 (m: def':
43 (mergeDefinitions
44 (loc ++ ["[definition ${toString n}-entry ${toString m}]"])
45 elemType
46 [{ inherit (def) file; value = def'; }]
47 ).optionalValue
48 ) def.value
49 else
50 throw "The option value `${showOption loc}` in `${def.file}` is not a list.") defs)));
51 };
53 componentOptions = def: {
54 buildable = mkOption {
55 type = bool;
56 default = true;
57 };
58 configureFlags = mkOption {
59 type = listOfFilteringNulls str;
60 default = (def.configureFlags or []);
61 };
62 setupBuildFlags = mkOption {
63 type = listOfFilteringNulls str;
64 default = (def.setupBuildFlags or []);
65 };
66 testFlags = mkOption {
67 type = listOfFilteringNulls str;
68 default = (def.testFlags or []);
69 };
70 setupInstallFlags = mkOption {
71 type = listOfFilteringNulls str;
72 default = (def.setupInstallFlags or []);
73 };
74 setupHaddockFlags = mkOption {
75 type = listOfFilteringNulls str;
76 default = (def.setupHaddockFlags or []);
77 };
78 doExactConfig = mkOption {
79 type = bool;
80 default = (def.doExactConfig or false);
81 };
82 doCheck = mkOption {
83 type = bool;
84 default = (def.doCheck or true);
85 };
86 doCrossCheck = mkOption {
87 description = "Run doCheck also in cross compilation settings. This can be tricky as the test logic must know how to run the tests on the target.";
88 type = bool;
89 default = (def.doCrossCheck or false);
90 };
91 doHaddock = mkOption {
92 description = "Enable building of the Haddock documentation from the annotated Haskell source code.";
93 type = bool;
94 default = (def.doHaddock or true);
95 };
96 doHoogle = mkOption {
97 description = "Also build a hoogle index.";
98 type = bool;
99 default = (def.doHoogle or true);
100 };
101 doHyperlinkSource = mkOption {
102 description = "Link documentation to the source code.";
103 type = bool;
104 default = (def.doHyperlinkSource or true);
105 };
106 doQuickjump = mkOption {
107 description = "Generate an index for interactive documentation navigation.";
108 type = bool;
109 default = (def.doQuickjump or true);
110 };
111 doCoverage = mkOption {
112 description = "Enable production of test coverage reports.";
113 type = bool;
114 default = (def.doCoverage or false);
115 };
116 dontPatchELF = mkOption {
117 description = "If set, the patchelf command is not used to remove unnecessary RPATH entries. Only applies to Linux.";
118 type = bool;
119 default = (def.dontPatchELF or true);
120 };
121 dontStrip = mkOption {
122 description = "If set, libraries and executables are not stripped.";
123 type = bool;
124 default = (def.dontStrip or true);
125 };
126 enableDeadCodeElimination = mkOption {
127 description = "If set, enables split sections for link-time dead-code stripping. Only applies to Linux";
128 type = bool;
129 default = (def.enableDeadCodeElimination or true);
130 };
131 enableStatic = mkOption {
132 description = "If set, enables building static libraries and executables.";
133 type = bool;
134 default = (def.enableStatic or true);
135 };
136 enableShared = mkOption {
137 description = "If set, enables building shared libraries.";
138 type = bool;
139 default = (def.enableShared or true);
140 };
141 configureAllComponents = mkOption {
142 description = "If set all the components in the package are configured (useful for cabal-doctest).";
143 type = bool;
144 default = false;
145 };
146 shellHook = mkOption {
147 description = "Hook to run when entering a shell";
148 type = unspecified; # Can be either a string or a function
149 default = (def.shellHook or "");
150 };
151 enableLibraryProfiling = mkOption {
152 type = bool;
153 default = (def.enableLibraryProfiling or false);
154 };
156 enableSeparateDataOutput = mkOption {
157 type = bool;
158 default = (def.enableSeparateDataOutput or false);
159 };
161 enableExecutableProfiling = mkOption {
162 type = bool;
163 default = (def.enableExecutableProfiling or false);
164 };
166 profilingDetail = mkOption {
167 type = nullOr uniqueStr;
168 default = (def.profilingDetail or "default");
169 };
171 keepSource = mkOption {
172 type = bool;
173 default = (def.keepSource or false);
174 description = "Keep component source in the store in a `source` output";
175 };
177 writeHieFiles = mkOption {
178 type = bool;
179 default = (def.writeHieFiles or false);
180 description = "Write component `.hie` files in the store in a `hie` output";
181 };
182 };
183 packageOptions = def: componentOptions def // {
184 preUnpack = mkOption {
185 type = nullOr lines;
186 default = (def.preUnpack or null);
187 };
188 postUnpack = mkOption {
189 type = nullOr uniqueStr;
190 default = getDefaultOrNull def "postUnpack";
191 };
192 preConfigure = mkOption {
193 type = nullOr uniqueStr;
194 default = getDefaultOrNull def "preConfigure";
195 };
196 postConfigure = mkOption {
197 type = nullOr uniqueStr;
198 default = getDefaultOrNull def "postConfigure";
199 };
200 preBuild = mkOption {
201 type = nullOr uniqueStr;
202 default = getDefaultOrNull def "preBuild";
203 };
204 postBuild = mkOption {
205 type = nullOr uniqueStr;
206 default = getDefaultOrNull def "postBuild";
207 };
208 preCheck = mkOption {
209 type = nullOr uniqueStr;
210 default = getDefaultOrNull def "preCheck";
211 };
212 # Wrapper for test executable run in checkPhase
213 testWrapper = mkOption {
214 type = listOfFilteringNulls str;
215 default = def.testWrapper or [];
216 description = "A command to run for executing tests in checkPhase, which takes the original test command as its arguments.";
217 example = "echo";
218 };
219 postCheck = mkOption {
220 type = nullOr uniqueStr;
221 default = getDefaultOrNull def "postCheck";
222 };
223 preInstall = mkOption {
224 type = nullOr uniqueStr;
225 default = getDefaultOrNull def "preInstall";
226 };
227 postInstall = mkOption {
228 type = nullOr uniqueStr;
229 default = getDefaultOrNull def "postInstall";
230 };
231 preHaddock = mkOption {
232 type = nullOr uniqueStr;
233 default = getDefaultOrNull def "preHaddock";
234 };
235 postHaddock = mkOption {
236 type = nullOr uniqueStr;
237 default = getDefaultOrNull def "postHaddock";
238 };
239 hardeningDisable = mkOption {
240 type = listOfFilteringNulls str;
241 default = (def.hardeningDisable or []);
242 };
243 ghcOptions = mkOption {
244 type = listOfFilteringNulls str;
245 default = def.ghcOptions or [];
246 };
247 planned = mkOption {
248 description = "Set to true by `plan-to-nix` for any component that was included in the `plan.json` file.";
249 # This is here so that (rather than in componentOptions) so it can be set project wide for stack projects
250 type = bool;
251 default = def.planned or false;
252 };
253 };
256in {
257 # Global options. These are passed down to the package level, and from there to the
258 # component level, unless specifically overridden. Depending on the flag flags are
259 # combined or replaced. We seed the package Options with an empty set forcing the
260 # default values.
261 options = (packageOptions {}) // {
263 packages = mkOption {
264 type =
265 let mod_args = {
266 inherit pkgs pkgconfPkgs haskellLib;
267 inherit (config) hsPkgs errorHandler;
268 inherit (config.cabal) system compiler;
269 }; in
270 attrsOf (submodule (import ./package.nix {
271 inherit mod_args listOfFilteringNulls;
272 inherit componentOptions packageOptions;
273 parentConfig = config;
274 }));
275 };
277 compiler = {
278 version = mkOption {
279 type = str;
280 };
281 nix-name = mkOption {
282 type = str;
283 };
284 packages = mkOption {
285 type = attrsOf str;
286 };
287 };
289 plan.pkg-def = mkOption {
290 type = unspecified;
291 visible = false;
292 internal = true;
293 };
294 };
296 config = let module = config.plan.pkg-def config.hackage.configs; in {
297 inherit (module) compiler;
298 packages = lib.mapAttrs (name: { revision, ... }@revArgs: { system, compiler, flags, pkgs, hsPkgs, errorHandler, pkgconfPkgs, ... }@modArgs:
300 let m = if revision == null
301 then (abort "${name} has no revision!")
302 else revision (modArgs // { hsPkgs = hsPkgs // (mapAttrs (l: _: hsPkgs.${name}.components.sublibs.${l}) (m.components.sublibs or {})); });
303 in
304 m // { flags = lib.mapAttrs (_: lib.mkDefault) (m.flags // revArgs.flags or {}); }
305 ) (lib.filterAttrs (n: v: v == null || v.revision != null ) module.packages);
306 };