2009-02-09 16:51:03 +00:00
|
|
|
|
# Nixpkgs/NixOS option handling.
|
|
|
|
|
|
|
|
|
|
let lib = import ./default.nix; in
|
|
|
|
|
|
2012-08-13 18:19:31 +00:00
|
|
|
|
with { inherit (builtins) head length; };
|
2009-02-28 18:21:25 +00:00
|
|
|
|
with import ./trivial.nix;
|
2009-02-09 16:51:03 +00:00
|
|
|
|
with import ./lists.nix;
|
2009-02-28 18:21:25 +00:00
|
|
|
|
with import ./misc.nix;
|
2009-02-09 16:51:03 +00:00
|
|
|
|
with import ./attrsets.nix;
|
2009-07-13 16:18:52 +00:00
|
|
|
|
with import ./properties.nix;
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
|
|
|
|
rec {
|
|
|
|
|
|
2009-06-26 13:53:31 +00:00
|
|
|
|
inherit (lib) typeOf;
|
|
|
|
|
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
|
|
|
|
isOption = attrs: (typeOf attrs) == "option";
|
2009-05-27 20:25:17 +00:00
|
|
|
|
mkOption = attrs: attrs // {
|
|
|
|
|
_type = "option";
|
|
|
|
|
# name (this is the name of the attributem it is automatically generated by the traversal)
|
|
|
|
|
# default (value used when no definition exists)
|
|
|
|
|
# example (documentation)
|
|
|
|
|
# description (documentation)
|
|
|
|
|
# type (option type, provide a default merge function and ensure type correctness)
|
|
|
|
|
# merge (function used to merge definitions into one definition: [ /type/ ] -> /type/)
|
|
|
|
|
# apply (convert the option value to ease the manipulation of the option result)
|
|
|
|
|
# options (set of sub-options declarations & definitions)
|
2009-09-28 18:22:49 +00:00
|
|
|
|
# extraConfigs (list of possible configurations)
|
2009-05-27 20:25:17 +00:00
|
|
|
|
};
|
|
|
|
|
|
2013-07-18 19:13:42 +00:00
|
|
|
|
mkEnableOption = name: mkOption {
|
|
|
|
|
default = false;
|
|
|
|
|
example = true;
|
|
|
|
|
description = "Whether to enable ${name}";
|
|
|
|
|
type = lib.types.bool;
|
|
|
|
|
};
|
|
|
|
|
|
2009-09-18 15:10:05 +00:00
|
|
|
|
mapSubOptions = f: opt:
|
|
|
|
|
if opt ? options then
|
|
|
|
|
opt // {
|
2013-06-07 07:42:46 +00:00
|
|
|
|
options = imap f (toList opt.options);
|
2009-09-18 15:10:05 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
opt;
|
|
|
|
|
|
2009-05-27 20:25:17 +00:00
|
|
|
|
# Make the option declaration more user-friendly by adding default
|
|
|
|
|
# settings and some verifications based on the declaration content (like
|
|
|
|
|
# type correctness).
|
|
|
|
|
addOptionMakeUp = {name, recurseInto}: decl:
|
|
|
|
|
let
|
|
|
|
|
init = {
|
|
|
|
|
inherit name;
|
|
|
|
|
merge = mergeDefaultOption;
|
|
|
|
|
apply = lib.id;
|
|
|
|
|
};
|
|
|
|
|
|
2009-09-19 16:49:31 +00:00
|
|
|
|
functionsFromType = opt:
|
2009-05-27 20:25:17 +00:00
|
|
|
|
if decl ? type && decl.type ? merge then
|
2009-09-19 16:49:31 +00:00
|
|
|
|
opt
|
|
|
|
|
// optionalAttrs (decl.type ? merge) { inherit (decl.type) merge; }
|
|
|
|
|
// optionalAttrs (decl.type ? check) { inherit (decl.type) check; }
|
2009-05-27 20:25:17 +00:00
|
|
|
|
else
|
|
|
|
|
opt;
|
|
|
|
|
|
|
|
|
|
addDeclaration = opt: opt // decl;
|
|
|
|
|
|
|
|
|
|
ensureMergeInputType = opt:
|
2009-09-19 16:49:31 +00:00
|
|
|
|
if opt ? check then
|
2009-05-27 20:25:17 +00:00
|
|
|
|
opt // {
|
|
|
|
|
merge = list:
|
2009-09-19 16:49:31 +00:00
|
|
|
|
if all opt.check list then
|
2009-05-27 20:25:17 +00:00
|
|
|
|
opt.merge list
|
|
|
|
|
else
|
|
|
|
|
throw "One of the definitions has a bad type.";
|
|
|
|
|
}
|
|
|
|
|
else opt;
|
|
|
|
|
|
|
|
|
|
ensureDefaultType = opt:
|
2009-09-19 16:49:31 +00:00
|
|
|
|
if opt ? check && opt ? default then
|
2009-05-27 20:25:17 +00:00
|
|
|
|
opt // {
|
|
|
|
|
default =
|
2009-09-19 16:49:31 +00:00
|
|
|
|
if opt.check opt.default then
|
|
|
|
|
opt.default
|
2009-05-27 20:25:17 +00:00
|
|
|
|
else
|
|
|
|
|
throw "The default value has a bad type.";
|
|
|
|
|
}
|
|
|
|
|
else opt;
|
|
|
|
|
|
|
|
|
|
handleOptionSets = opt:
|
2009-09-19 16:49:31 +00:00
|
|
|
|
if opt ? type && opt.type.hasOptions then
|
2009-06-11 16:03:26 +00:00
|
|
|
|
let
|
2009-11-07 01:59:45 +00:00
|
|
|
|
# Evaluate sub-modules.
|
|
|
|
|
subModuleMerge = path: vals:
|
|
|
|
|
lib.fix (args:
|
2013-06-04 21:47:42 +00:00
|
|
|
|
let
|
2013-06-07 07:42:46 +00:00
|
|
|
|
result = recurseInto path (opt.options ++ imap (index: v: args: {
|
|
|
|
|
key = rec {
|
|
|
|
|
#!!! Would be nice if we had the file the val was from
|
|
|
|
|
option = path;
|
|
|
|
|
number = index;
|
|
|
|
|
outPath = "option ${option} config number ${toString number}";
|
|
|
|
|
};
|
|
|
|
|
} // (lib.applyIfFunction v args)) (toList vals)) args;
|
2009-11-07 01:59:45 +00:00
|
|
|
|
name = lib.removePrefix (opt.name + ".") path;
|
2013-06-04 21:47:42 +00:00
|
|
|
|
extraArgs = opt.extraArgs or {};
|
|
|
|
|
individualExtraArgs = opt.individualExtraArgs or {};
|
|
|
|
|
in {
|
|
|
|
|
inherit (result) config options;
|
|
|
|
|
inherit name;
|
|
|
|
|
} //
|
|
|
|
|
(opt.extraArgs or {}) //
|
|
|
|
|
(if hasAttr name individualExtraArgs then getAttr name individualExtraArgs else {})
|
2009-11-07 01:59:45 +00:00
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
# Add _options in sub-modules to make it viewable from other
|
|
|
|
|
# modules.
|
|
|
|
|
subModuleMergeConfig = path: vals:
|
|
|
|
|
let result = subModuleMerge path vals; in
|
|
|
|
|
{ _args = result; } // result.config;
|
|
|
|
|
|
2009-06-11 16:03:26 +00:00
|
|
|
|
in
|
|
|
|
|
opt // {
|
|
|
|
|
merge = list:
|
2009-09-19 16:49:31 +00:00
|
|
|
|
opt.type.iter
|
2009-11-07 01:59:45 +00:00
|
|
|
|
subModuleMergeConfig
|
2009-06-11 16:03:26 +00:00
|
|
|
|
opt.name
|
|
|
|
|
(opt.merge list);
|
2009-09-15 13:36:30 +00:00
|
|
|
|
options =
|
2009-09-19 16:49:31 +00:00
|
|
|
|
let path = opt.type.docPath opt.name; in
|
2009-11-07 01:59:45 +00:00
|
|
|
|
(subModuleMerge path []).options;
|
2009-06-11 16:03:26 +00:00
|
|
|
|
}
|
2009-05-27 20:25:17 +00:00
|
|
|
|
else
|
|
|
|
|
opt;
|
|
|
|
|
in
|
|
|
|
|
foldl (opt: f: f opt) init [
|
|
|
|
|
# default settings
|
2009-09-19 16:49:31 +00:00
|
|
|
|
functionsFromType
|
2009-05-27 20:25:17 +00:00
|
|
|
|
|
|
|
|
|
# user settings
|
|
|
|
|
addDeclaration
|
|
|
|
|
|
|
|
|
|
# override settings
|
|
|
|
|
ensureMergeInputType
|
|
|
|
|
ensureDefaultType
|
|
|
|
|
handleOptionSets
|
|
|
|
|
];
|
|
|
|
|
|
|
|
|
|
# Merge a list of options containning different field. This is useful to
|
|
|
|
|
# separate the merge & apply fields from the interface.
|
|
|
|
|
mergeOptionDecls = opts:
|
|
|
|
|
if opts == [] then {}
|
2012-08-13 18:19:31 +00:00
|
|
|
|
else if length opts == 1 then
|
2009-05-27 20:25:17 +00:00
|
|
|
|
let opt = head opts; in
|
|
|
|
|
if opt ? options then
|
|
|
|
|
opt // { options = toList opt.options; }
|
|
|
|
|
else
|
|
|
|
|
opt
|
|
|
|
|
else
|
|
|
|
|
fold (opt1: opt2:
|
|
|
|
|
lib.addErrorContext "opt1 = ${lib.showVal opt1}\nopt2 = ${lib.showVal opt2}" (
|
|
|
|
|
# You cannot merge if two options have the same field.
|
|
|
|
|
assert opt1 ? default -> ! opt2 ? default;
|
|
|
|
|
assert opt1 ? example -> ! opt2 ? example;
|
|
|
|
|
assert opt1 ? description -> ! opt2 ? description;
|
|
|
|
|
assert opt1 ? merge -> ! opt2 ? merge;
|
|
|
|
|
assert opt1 ? apply -> ! opt2 ? apply;
|
|
|
|
|
assert opt1 ? type -> ! opt2 ? type;
|
2009-09-28 18:22:49 +00:00
|
|
|
|
opt1 // opt2
|
|
|
|
|
// optionalAttrs (opt1 ? options || opt2 ? options) {
|
2009-05-27 20:25:17 +00:00
|
|
|
|
options =
|
2012-08-13 18:39:45 +00:00
|
|
|
|
(toList (opt1.options or []))
|
|
|
|
|
++ (toList (opt2.options or []));
|
2009-05-27 20:25:17 +00:00
|
|
|
|
}
|
2009-09-28 18:22:49 +00:00
|
|
|
|
// optionalAttrs (opt1 ? extraConfigs || opt2 ? extraConfigs) {
|
2012-08-13 18:39:45 +00:00
|
|
|
|
extraConfigs = opt1.extraConfigs or [] ++ opt2.extraConfigs or [];
|
2009-09-28 18:22:49 +00:00
|
|
|
|
}
|
2013-06-05 15:20:59 +00:00
|
|
|
|
// optionalAttrs (opt1 ? extraArgs || opt2 ? extraArgs) {
|
|
|
|
|
extraArgs = opt1.extraArgs or {} // opt2.extraArgs or {};
|
|
|
|
|
}
|
|
|
|
|
// optionalAttrs (opt1 ? individualExtraArgs || opt2 ? individualExtraArgs) {
|
|
|
|
|
individualExtraArgs = zipAttrsWith (name: values:
|
|
|
|
|
if length values == 1 then head values else (head values // (head (tail values)))
|
|
|
|
|
) [ (opt1.individualExtraArgs or {}) (opt2.individualExtraArgs or {}) ];
|
|
|
|
|
}
|
2009-05-27 20:25:17 +00:00
|
|
|
|
)) {} opts;
|
|
|
|
|
|
2009-06-26 13:53:31 +00:00
|
|
|
|
|
2009-05-27 20:25:17 +00:00
|
|
|
|
# !!! This function will be removed because this can be done with the
|
|
|
|
|
# multiple option declarations.
|
2009-02-09 16:51:03 +00:00
|
|
|
|
addDefaultOptionValues = defs: opts: opts //
|
|
|
|
|
builtins.listToAttrs (map (defName:
|
|
|
|
|
{ name = defName;
|
|
|
|
|
value =
|
|
|
|
|
let
|
|
|
|
|
defValue = builtins.getAttr defName defs;
|
|
|
|
|
optValue = builtins.getAttr defName opts;
|
|
|
|
|
in
|
|
|
|
|
if typeOf defValue == "option"
|
|
|
|
|
then
|
|
|
|
|
# `defValue' is an option.
|
2009-05-19 14:54:41 +00:00
|
|
|
|
if hasAttr defName opts
|
2009-02-09 16:51:03 +00:00
|
|
|
|
then builtins.getAttr defName opts
|
|
|
|
|
else defValue.default
|
|
|
|
|
else
|
|
|
|
|
# `defValue' is an attribute set containing options.
|
|
|
|
|
# So recurse.
|
2009-05-19 14:54:41 +00:00
|
|
|
|
if hasAttr defName opts && isAttrs optValue
|
2009-02-09 16:51:03 +00:00
|
|
|
|
then addDefaultOptionValues defValue optValue
|
|
|
|
|
else addDefaultOptionValues defValue {};
|
|
|
|
|
}
|
2009-05-19 14:54:41 +00:00
|
|
|
|
) (attrNames defs));
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
|
|
|
|
mergeDefaultOption = list:
|
2012-08-13 18:19:31 +00:00
|
|
|
|
if length list == 1 then head list
|
2009-05-19 14:54:41 +00:00
|
|
|
|
else if all builtins.isFunction list then x: mergeDefaultOption (map (f: f x) list)
|
|
|
|
|
else if all isList list then concatLists list
|
|
|
|
|
else if all isAttrs list then fold lib.mergeAttrs {} list
|
2010-03-11 22:03:45 +00:00
|
|
|
|
else if all builtins.isBool list then fold lib.or false list
|
|
|
|
|
else if all builtins.isString list then lib.concatStrings list
|
2010-03-11 22:03:49 +00:00
|
|
|
|
else if all builtins.isInt list && all (x: x == head list) list
|
|
|
|
|
then head list
|
2009-02-09 16:51:03 +00:00
|
|
|
|
else throw "Cannot merge values.";
|
|
|
|
|
|
|
|
|
|
mergeTypedOption = typeName: predicate: merge: list:
|
|
|
|
|
if all predicate list then merge list
|
|
|
|
|
else throw "Expect a ${typeName}.";
|
|
|
|
|
|
|
|
|
|
mergeEnableOption = mergeTypedOption "boolean"
|
|
|
|
|
(x: true == x || false == x) (fold lib.or false);
|
|
|
|
|
|
2009-05-19 14:54:41 +00:00
|
|
|
|
mergeListOption = mergeTypedOption "list" isList concatLists;
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
|
|
|
|
mergeStringOption = mergeTypedOption "string"
|
|
|
|
|
(x: if builtins ? isString then builtins.isString x else x + "")
|
|
|
|
|
lib.concatStrings;
|
|
|
|
|
|
|
|
|
|
mergeOneOption = list:
|
2009-05-19 14:54:41 +00:00
|
|
|
|
if list == [] then abort "This case should never happen."
|
2012-08-13 18:19:31 +00:00
|
|
|
|
else if length list != 1 then throw "Multiple definitions. Only one is allowed for this option."
|
2009-02-09 16:51:03 +00:00
|
|
|
|
else head list;
|
|
|
|
|
|
|
|
|
|
|
2009-07-06 16:20:05 +00:00
|
|
|
|
fixableMergeFun = merge: f: config:
|
|
|
|
|
merge (
|
2009-09-15 13:36:30 +00:00
|
|
|
|
# generate the list of option sets.
|
|
|
|
|
f config
|
2009-06-11 16:03:26 +00:00
|
|
|
|
);
|
|
|
|
|
|
2009-07-06 16:20:05 +00:00
|
|
|
|
fixableMergeModules = merge: initModules: {...}@args: config:
|
|
|
|
|
fixableMergeFun merge (config:
|
2009-09-15 13:36:30 +00:00
|
|
|
|
lib.moduleClosure initModules (args // { inherit config; })
|
2009-07-06 16:20:05 +00:00
|
|
|
|
) config;
|
2009-06-11 16:03:26 +00:00
|
|
|
|
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2009-07-06 16:20:05 +00:00
|
|
|
|
fixableDefinitionsOf = initModules: {...}@args:
|
2009-09-15 13:36:30 +00:00
|
|
|
|
fixableMergeModules (modules: (lib.moduleMerge "" modules).config) initModules args;
|
2009-05-19 23:06:56 +00:00
|
|
|
|
|
2009-07-06 16:20:05 +00:00
|
|
|
|
fixableDeclarationsOf = initModules: {...}@args:
|
2009-09-15 13:36:30 +00:00
|
|
|
|
fixableMergeModules (modules: (lib.moduleMerge "" modules).options) initModules args;
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2009-07-06 16:20:05 +00:00
|
|
|
|
definitionsOf = initModules: {...}@args:
|
2009-09-15 13:36:30 +00:00
|
|
|
|
(lib.fix (module:
|
|
|
|
|
fixableMergeModules (lib.moduleMerge "") initModules args module.config
|
|
|
|
|
)).config;
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2009-07-06 16:20:05 +00:00
|
|
|
|
declarationsOf = initModules: {...}@args:
|
2009-09-15 13:36:30 +00:00
|
|
|
|
(lib.fix (module:
|
|
|
|
|
fixableMergeModules (lib.moduleMerge "") initModules args module.config
|
|
|
|
|
)).options;
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2009-06-11 16:03:38 +00:00
|
|
|
|
|
|
|
|
|
# Generate documentation template from the list of option declaration like
|
|
|
|
|
# the set generated with filterOptionSets.
|
|
|
|
|
optionAttrSetToDocList = ignore: newOptionAttrSetToDocList;
|
|
|
|
|
newOptionAttrSetToDocList = attrs:
|
|
|
|
|
let options = collect isOption attrs; in
|
|
|
|
|
fold (opt: rest:
|
|
|
|
|
let
|
|
|
|
|
docOption = {
|
|
|
|
|
inherit (opt) name;
|
|
|
|
|
description = if opt ? description then opt.description else
|
|
|
|
|
throw "Option ${opt.name}: No description.";
|
2009-09-18 15:10:11 +00:00
|
|
|
|
|
|
|
|
|
declarations = map (x: toString x.source) opt.declarations;
|
2010-08-11 11:46:09 +00:00
|
|
|
|
#definitions = map (x: toString x.source) opt.definitions;
|
2009-06-11 16:03:38 +00:00
|
|
|
|
}
|
2010-05-12 11:07:49 +00:00
|
|
|
|
// optionalAttrs (opt ? example) { example = scrubOptionValue opt.example; }
|
2010-05-28 11:20:45 +00:00
|
|
|
|
// optionalAttrs (opt ? default) { default = scrubOptionValue opt.default; }
|
|
|
|
|
// optionalAttrs (opt ? defaultText) { default = opt.defaultText; };
|
2009-06-11 16:03:38 +00:00
|
|
|
|
|
|
|
|
|
subOptions =
|
|
|
|
|
if opt ? options then
|
|
|
|
|
newOptionAttrSetToDocList opt.options
|
|
|
|
|
else
|
|
|
|
|
[];
|
|
|
|
|
in
|
|
|
|
|
[ docOption ] ++ subOptions ++ rest
|
|
|
|
|
) [] options;
|
|
|
|
|
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2010-05-12 11:07:49 +00:00
|
|
|
|
/* This function recursively removes all derivation attributes from
|
|
|
|
|
`x' except for the `name' attribute. This is to make the
|
|
|
|
|
generation of `options.xml' much more efficient: the XML
|
|
|
|
|
representation of derivations is very large (on the order of
|
|
|
|
|
megabytes) and is not actually used by the manual generator. */
|
|
|
|
|
scrubOptionValue = x:
|
2010-05-12 13:24:09 +00:00
|
|
|
|
if isDerivation x then { type = "derivation"; drvPath = x.name; outPath = x.name; name = x.name; }
|
2010-05-12 11:07:49 +00:00
|
|
|
|
else if isList x then map scrubOptionValue x
|
2010-06-01 14:24:16 +00:00
|
|
|
|
else if isAttrs x then mapAttrs (n: v: scrubOptionValue v) (removeAttrs x ["_args"])
|
2010-05-12 11:07:49 +00:00
|
|
|
|
else x;
|
|
|
|
|
|
2011-09-05 10:14:24 +00:00
|
|
|
|
|
|
|
|
|
/* For use in the ‘example’ option attribute. It causes the given
|
|
|
|
|
text to be included verbatim in documentation. This is necessary
|
|
|
|
|
for example values that are not simple values, e.g.,
|
|
|
|
|
functions. */
|
|
|
|
|
literalExample = text: { _type = "literalExample"; inherit text; };
|
|
|
|
|
|
|
|
|
|
|
2009-05-24 10:57:41 +00:00
|
|
|
|
}
|