commit 73f32d03758a53ad1baac31795cfd99e325032f3 · pyrox.dev/nixpkgs

+2 -2

lib/modules.nix

···

       128
       128
        
                opt.options ? apply && res ? apply ||

     

       129
       129
        
                opt.options ? type && res ? type

     

       130
       130
        
             then

     

       131
       131
       -
               throw "The option `${showOption loc}' in `${opt.file}' is already declared in ${concatStringsSep " and " (map (d: "`${d}'") res.declarations)}."

     

       131
       131
       +
               throw "The option `${showOption loc}' in `${opt.file}' is already declared in ${showFiles res.declarations}."

     

       132
       132
        
             else

     

       133
       133
        
               opt.options // res //

     

       134
       134
        
                 { declarations = [opt.file] ++ res.declarations;

     
···

       153
       153
        
                 fold (def: res:

     

       154
       154
        
                   if opt.type.check def.value then res

     

       155
       155
        
                   else throw "The option value `${showOption loc}' in `${def.file}' is not a ${opt.type.name}.")

     

       156
       156
       -
                   (opt.type.merge' { prefix = loc; } (map (m: m.value) defsFinal)) defsFinal;

     

       156
       156
       +
                   (opt.type.merge { prefix = loc; files = map (m: m.file) defsFinal; } (map (m: m.value) defsFinal)) defsFinal;

     

       157
       157
        
             # Finally, apply the ‘apply’ function to the merged

     

       158
       158
        
             # value.  This allows options to yield a value computed

     

       159
       159
        
             # from the definitions.

+11 -10

lib/options.nix

···

       35
       35
        
         addDefaultOptionValues = defs: opts: opts //

     

       36
       36
        
           builtins.listToAttrs (map (defName:

     

       37
       37
        
             { name = defName;

     

       38
       38
       -
               value = 

     

       38
       38
       +
               value =

     

       39
       39
        
                 let

     

       40
       40
        
                   defValue = builtins.getAttr defName defs;

     

       41
       41
        
                   optValue = builtins.getAttr defName opts;

     
···

       49
       49
        
                 else

     

       50
       50
        
                   # `defValue' is an attribute set containing options.

     

       51
       51
        
                   # So recurse.

     

       52
       52
       -
                   if hasAttr defName opts && isAttrs optValue 

     

       52
       52
       +
                   if hasAttr defName opts && isAttrs optValue

     

       53
       53
        
                   then addDefaultOptionValues defValue optValue

     

       54
       54
        
                   else addDefaultOptionValues defValue {};

     

       55
       55
        
             }

     

       56
       56
        
           ) (attrNames defs));

     

       57
       57
        
       

     

       58
       58
       -
         mergeDefaultOption = list:

     

       58
       58
       +
         mergeDefaultOption = args: list:

     

       59
       59
        
           if length list == 1 then head list

     

       60
       60
       -
           else if all builtins.isFunction list then x: mergeDefaultOption (map (f: f x) list)

     

       60
       60
       +
           else if all builtins.isFunction list then x: mergeDefaultOption args (map (f: f x) list)

     

       61
       61
        
           else if all isList list then concatLists list

     

       62
       62
        
           else if all isAttrs list then fold lib.mergeAttrs {} list

     

       63
       63
        
           else if all builtins.isBool list then fold lib.or false list

     

       64
       64
        
           else if all builtins.isString list then lib.concatStrings list

     

       65
       65
       -
           else if all builtins.isInt list && all (x: x == head list) list

     

       66
       66
       -
                then head list

     

       67
       67
       -
           else throw "Cannot merge values.";

     

       65
       65
       +
           else if all builtins.isInt list && all (x: x == head list) list then head list

     

       66
       66
       +
           else throw "Cannot merge definitions of `${showOption args.prefix}' given in ${showFiles args.files}.";

     

       68
       67
        
       

     

       69
       68
        
       

     

       70
       69
        
         /* Obsolete, will remove soon.  Specify an option type or apply

     

       71
       70
        
            function instead.  */

     

       72
       72
       -
         mergeTypedOption = typeName: predicate: merge: list:

     

       71
       71
       +
         mergeTypedOption = typeName: predicate: merge: args: list:

     

       73
       72
        
           if all predicate list then merge list

     

       74
       73
        
           else throw "Expect a ${typeName}.";

     

       75
       74
        
       

     
···

       82
       81
        
           (x: if builtins ? isString then builtins.isString x else x + "")

     

       83
       82
        
           lib.concatStrings;

     

       84
       83
        
       

     

       85
       85
       -
         mergeOneOption = list:

     

       84
       84
       +
         mergeOneOption = args: list:

     

       86
       85
        
           if list == [] then abort "This case should never happen."

     

       87
       87
       -
           else if length list != 1 then throw "Multiple definitions. Only one is allowed for this option."

     

       86
       86
       +
           else if length list != 1 then

     

       87
       87
       +
             throw "The unique option `${showOption args.prefix}' is defined multiple times, in ${showFiles args.files}."

     

       88
       88
        
           else head list;

     

       89
       89
        
       

     

       90
       90
        
       

     
···

       135
       135
        
       

     

       136
       136
        
         /* Helper functions. */

     

       137
       137
        
         showOption = concatStringsSep ".";

     

       138
       138
       +
         showFiles = files: concatStringsSep " and " (map (f: "`${f}'") files);

     

       138
       139
        
         unknownModule = "<unknown-file>";

     

       139
       140
        
       

     

       140
       141
        
       }

+37 -39

lib/types.nix

···

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
        
       

     

       22
       22
       -
         # name (name of the type)

     

       23
       23
       -
         # check (check the config value)

     

       24
       24
       -
         # merge (default merge function)

     

       25
       25
       -
         # getSubOptions (returns sub-options for manual generation)

     

       26
       22
        
         isOptionType = isType "option-type";

     

       27
       23
        
         mkOptionType =

     

       28
       28
       -
           { name

     

       29
       29
       -
           , check ? (x: true)

     

       30
       30
       -
           , merge ? mergeDefaultOption

     

       31
       31
       -
           , merge' ? args: merge

     

       32
       32
       -
           , getSubOptions ? prefix: {}

     

       24
       24
       +
           { # Human-readable representation of the type.

     

       25
       25
       +
             name

     

       26
       26
       +
           , # Function applied to each definition that should return true if

     

       27
       27
       +
             # its type-correct, false otherwise.

     

       28
       28
       +
             check ? (x: true)

     

       29
       29
       +
           , # Merge a list of definitions together into a single value.

     

       30
       30
       +
             merge ? mergeDefaultOption

     

       31
       31
       +
           , # Return a flat list of sub-options.  Used to generate

     

       32
       32
       +
             # documentation.

     

       33
       33
       +
             getSubOptions ? prefix: {}

     

       33
       34
        
           }:

     

       34
       34
       -
       

     

       35
       35
        
           { _type = "option-type";

     

       36
       36
       -
             inherit name check merge merge' getSubOptions;

     

       36
       36
       +
             inherit name check merge getSubOptions;

     

       37
       37
        
           };

     

       38
       38
        
       

     

       39
       39
        
       

     

       40
       40
       -
         addToPrefix = args: name: args // { prefix = args.prefix ++ [name]; };

     

       41
       41
       -
       

     

       42
       42
       -
       

     

       43
       40
        
         types = rec {

     

       44
       41
        
       

     

       45
       42
        
           unspecified = mkOptionType {

     
···

       49
       46
        
           bool = mkOptionType {

     

       50
       47
        
             name = "boolean";

     

       51
       48
        
             check = builtins.isBool;

     

       52
       52
       -
             merge = fold lib.or false;

     

       49
       49
       +
             merge = args: fold lib.or false;

     

       53
       50
        
           };

     

       54
       51
        
       

     

       55
       52
        
           int = mkOptionType {

     
···

       60
       57
        
           string = mkOptionType {

     

       61
       58
        
             name = "string";

     

       62
       59
        
             check = builtins.isString;

     

       63
       63
       -
             merge = lib.concatStrings;

     

       60
       60
       +
             merge = args: lib.concatStrings;

     

       64
       61
        
           };

     

       65
       62
        
       

     

       66
       63
        
           # Like ‘string’, but add newlines between every value.  Useful for

     
···

       68
       65
        
           lines = mkOptionType {

     

       69
       66
        
             name = "string";

     

       70
       67
        
             check = builtins.isString;

     

       71
       71
       -
             merge = lib.concatStringsSep "\n";

     

       68
       68
       +
             merge = args: lib.concatStringsSep "\n";

     

       72
       69
        
           };

     

       73
       70
        
       

     

       74
       71
        
           commas = mkOptionType {

     

       75
       72
        
             name = "string";

     

       76
       73
        
             check = builtins.isString;

     

       77
       77
       -
             merge = lib.concatStringsSep ",";

     

       74
       74
       +
             merge = args: lib.concatStringsSep ",";

     

       78
       75
        
           };

     

       79
       76
        
       

     

       80
       77
        
           envVar = mkOptionType {

     

       81
       78
        
             name = "environment variable";

     

       82
       79
        
             inherit (string) check;

     

       83
       83
       -
             merge = lib.concatStringsSep ":";

     

       80
       80
       +
             merge = args: lib.concatStringsSep ":";

     

       84
       81
        
           };

     

       85
       82
        
       

     

       86
       83
        
           attrs = mkOptionType {

     

       87
       84
        
             name = "attribute set";

     

       88
       85
        
             check = isAttrs;

     

       89
       89
       -
             merge = fold lib.mergeAttrs {};

     

       86
       86
       +
             merge = args: fold lib.mergeAttrs {};

     

       90
       87
        
           };

     

       91
       88
        
       

     

       92
       89
        
           # derivation is a reserved keyword.

     

       93
       90
        
           package = mkOptionType {

     

       94
       91
        
             name = "derivation";

     

       95
       92
        
             check = isDerivation;

     

       93
       93
       +
             merge = mergeOneOption;

     

       96
       94
        
           };

     

       97
       95
        
       

     

       98
       96
        
           path = mkOptionType {

     

       99
       97
        
             name = "path";

     

       100
       98
        
             # Hacky: there is no ‘isPath’ primop.

     

       101
       99
        
             check = x: builtins.unsafeDiscardStringContext (builtins.substring 0 1 (toString x)) == "/";

     

       100
       100
       +
             merge = mergeOneOption;

     

       102
       101
        
           };

     

       103
       102
        
       

     

       104
       103
        
           # drop this in the future:

     

       105
       105
       -
           list = builtins.trace "types.list is deprecated; use types.listOf instead" types.listOf;

     

       104
       104
       +
           list = builtins.trace "`types.list' is deprecated; use `types.listOf' instead" types.listOf;

     

       106
       105
        
       

     

       107
       106
        
           listOf = elemType: mkOptionType {

     

       108
       107
        
             name = "list of ${elemType.name}s";

     

       109
       108
        
             check = value: isList value && all elemType.check value;

     

       110
       110
       -
             merge' = args: defs: imap (n: def: elemType.merge' (addToPrefix args (toString n)) [def]) (concatLists defs);

     

       109
       109
       +
             merge = args: defs: imap (n: def: elemType.merge (addToPrefix args (toString n)) [def]) (concatLists defs);

     

       111
       110
        
             getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["*"]);

     

       112
       111
        
           };

     

       113
       112
        
       

     

       114
       113
        
           attrsOf = elemType: mkOptionType {

     

       115
       114
        
             name = "attribute set of ${elemType.name}s";

     

       116
       115
        
             check = x: isAttrs x && all elemType.check (lib.attrValues x);

     

       117
       117
       -
             merge' = args: lib.zipAttrsWith (name:

     

       118
       118
       -
               elemType.merge' (addToPrefix (args // { inherit name; }) name));

     

       116
       116
       +
             merge = args: lib.zipAttrsWith (name:

     

       117
       117
       +
               elemType.merge (addToPrefix (args // { inherit name; }) name));

     

       119
       118
        
             getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["<name>"]);

     

       120
       119
        
           };

     

       121
       120
        
       

     
···

       138
       137
        
                 if isList x       then listOnly.check x

     

       139
       138
        
                 else if isAttrs x then attrOnly.check x

     

       140
       139
        
                 else false;

     

       141
       141
       -
               merge' = args: defs: attrOnly.merge' args (imap convertIfList defs);

     

       140
       140
       +
               merge = args: defs: attrOnly.merge args (imap convertIfList defs);

     

       142
       141
        
               getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["<name?>"]);

     

       143
       142
        
             };

     

       144
       143
        
       

     

       145
       144
        
           uniq = elemType: mkOptionType {

     

       146
       145
        
             inherit (elemType) name check;

     

       147
       147
       -
             merge = list:

     

       148
       148
       -
               if length list == 1 then

     

       149
       149
       -
                 head list

     

       150
       150
       -
               else

     

       151
       151
       -
                 throw "Multiple definitions of ${elemType.name}. Only one is allowed for this option.";

     

       146
       146
       +
             merge = mergeOneOption;

     

       152
       147
        
             getSubOptions = elemType.getSubOptions;

     

       153
       148
        
           };

     

       154
       149
        
       

     

       155
       150
        
           none = elemType: mkOptionType {

     

       156
       151
        
             inherit (elemType) name check;

     

       157
       157
       -
             merge = list:

     

       158
       158
       -
               throw "No definitions are allowed for this option.";

     

       152
       152
       +
             merge = args: list:

     

       153
       153
       +
               throw "No definitions are allowed for the option `${showOption args.prefix}'.";

     

       159
       154
        
             getSubOptions = elemType.getSubOptions;

     

       160
       155
        
           };

     

       161
       156
        
       

     

       162
       157
        
           nullOr = elemType: mkOptionType {

     

       163
       158
        
             name = "null or ${elemType.name}";

     

       164
       159
        
             check = x: builtins.isNull x || elemType.check x;

     

       165
       165
       -
             merge' = args: defs:

     

       160
       160
       +
             merge = args: defs:

     

       166
       161
        
               if all isNull defs then null

     

       167
       162
        
               else if any isNull defs then

     

       168
       168
       -
                 throw "Some but not all values are null."

     

       169
       169
       -
               else elemType.merge' args defs;

     

       163
       163
       +
                 throw "The option `${showOption args.prefix}' is defined both null and not null, in ${showFiles args.files}."

     

       164
       164
       +
               else elemType.merge args defs;

     

       170
       165
        
             getSubOptions = elemType.getSubOptions;

     

       171
       166
        
           };

     

       172
       167
        
       

     

       173
       168
        
           functionTo = elemType: mkOptionType {

     

       174
       169
        
             name = "function that evaluates to a(n) ${elemType.name}";

     

       175
       170
        
             check = builtins.isFunction;

     

       176
       176
       -
             merge' = args: fns:

     

       177
       177
       -
               fnArgs: elemType.merge' args (map (fn: fn fnArgs) fns);

     

       171
       171
       +
             merge = args: fns:

     

       172
       172
       +
               fnArgs: elemType.merge args (map (fn: fn fnArgs) fns);

     

       178
       173
        
             getSubOptions = elemType.getSubOptions;

     

       179
       174
        
           };

     

       180
       175
        
       

     
···

       183
       178
        
             mkOptionType rec {

     

       184
       179
        
               name = "submodule";

     

       185
       180
        
               check = x: isAttrs x || builtins.isFunction x;

     

       186
       186
       -
               merge = merge' {};

     

       187
       187
       -
               merge' = args: defs:

     

       181
       181
       +
               merge = args: defs:

     

       188
       182
        
                 let

     

       189
       183
        
                   coerce = def: if builtins.isFunction def then def else { config = def; };

     

       190
       184
        
                   modules = opts' ++ map coerce defs;

     
···

       203
       197
        
           };

     

       204
       198
        
       

     

       205
       199
        
         };

     

       200
       200
       +
       

     

       201
       201
       +
       

     

       202
       202
       +
         /* Helper function. */

     

       203
       203
       +
         addToPrefix = args: name: args // { prefix = args.prefix ++ [name]; };

     

       206
       204
        
       

     

       207
       205
        
       }

+6 -3

nixos/modules/config/shells-environment.nix

···

       25
       25
        
             '';

     

       26
       26
        
             type = types.attrsOf (mkOptionType {

     

       27
       27
        
               name = "a string or a list of strings";

     

       28
       28
       -
               merge = xs:

     

       28
       28
       +
               merge = args: xs:

     

       29
       29
        
                 let xs' = filterOverrides xs; in

     

       30
       30
        
                 if isList (head xs') then concatLists xs'

     

       31
       31
       -
                 else if builtins.lessThan 1 (length xs') then abort "variable in ‘environment.variables’ has multiple values"

     

       32
       32
       -
                 else if !builtins.isString (head xs') then abort "variable in ‘environment.variables’ does not have a string value"

     

       31
       31
       +
                 else if builtins.lessThan 1 (length xs') then

     

       32
       32
       +
                   # Don't show location info here, since it's too general.

     

       33
       33
       +
                   throw "The option `${showOption args.prefix}' is defined multiple times."

     

       34
       34
       +
                 else if !builtins.isString (head xs') then

     

       35
       35
       +
                   throw "The option `${showOption args.prefix}' does not have a string value."

     

       33
       36
        
                 else head xs';

     

       34
       37
        
             });

     

       35
       38
        
             apply = mapAttrs (n: v: if isList v then concatStringsSep ":" v else v);

+1 -1

nixos/modules/config/sysctl.nix

···

       7
       7
        
         sysctlOption = mkOptionType {

     

       8
       8
        
           name = "sysctl option value";

     

       9
       9
        
           check = x: builtins.isBool x || builtins.isString x || builtins.isInt x;

     

       10
       10
       -
           merge = xs: last xs; # FIXME: hacky way to allow overriding in configuration.nix.

     

       10
       10
       +
           merge = args: xs: last xs; # FIXME: hacky way to allow overriding in configuration.nix.

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
       in

+1 -1

nixos/modules/misc/nixpkgs.nix

···

       26
       26
        
         configType = mkOptionType {

     

       27
       27
        
           name = "nixpkgs config";

     

       28
       28
        
           check = traceValIfNot isConfig;

     

       29
       29
       -
           merge = fold mergeConfig {};

     

       29
       29
       +
           merge = args: fold mergeConfig {};

     

       30
       30
        
         };

     

       31
       31
        
       

     

       32
       32
        
       in