lib/deprecated.nix

   1 { lib }:
   2 let
   3     inherit (builtins) head tail isList isAttrs isInt attrNames;
   4
   5 in
   6
   7 with lib.lists;
   8 with lib.attrsets;
   9 with lib.strings;
  10
  11 rec {
  12
  13   # returns default if env var is not set
  14   maybeEnv = name: default:
  15     let value = builtins.getEnv name; in
  16     if value == "" then default else value;
  17
  18   defaultMergeArg = x : y: if builtins.isAttrs y then
  19     y
  20   else
  21     (y x);
  22   defaultMerge = x: y: x // (defaultMergeArg x y);
  23   foldArgs = merger: f: init: x:
  24     let arg = (merger init (defaultMergeArg init x));
  25         # now add the function with composed args already applied to the final attrs
  26         base = (setAttrMerge "passthru" {} (f arg)
  27                         ( z: z // {
  28                             function = foldArgs merger f arg;
  29                             args = (lib.attrByPath ["passthru" "args"] {} z) // x;
  30                           } ));
  31         withStdOverrides = base // {
  32           override = base.passthru.function;
  33         };
  34         in
  35           withStdOverrides;
  36
  37
  38   # shortcut for attrByPath ["name"] default attrs
  39   maybeAttrNullable = maybeAttr;
  40
  41   # shortcut for attrByPath ["name"] default attrs
  42   maybeAttr = name: default: attrs: attrs.${name} or default;
  43
  44
  45   # Return the second argument if the first one is true or the empty version
  46   # of the second argument.
  47   ifEnable = cond: val:
  48     if cond then val
  49     else if builtins.isList val then []
  50     else if builtins.isAttrs val then {}
  51     # else if builtins.isString val then ""
  52     else if val == true || val == false then false
  53     else null;
  54
  55
  56   # Return true only if there is an attribute and it is true.
  57   checkFlag = attrSet: name:
  58         if name == "true" then true else
  59         if name == "false" then false else
  60         if (elem name (attrByPath ["flags"] [] attrSet)) then true else
  61         attrByPath [name] false attrSet ;
  62
  63
  64   # Input : attrSet, [ [name default] ... ], name
  65   # Output : its value or default.
  66   getValue = attrSet: argList: name:
  67   ( attrByPath [name] (if checkFlag attrSet name then true else
  68         if argList == [] then null else
  69         let x = builtins.head argList; in
  70                 if (head x) == name then
  71                         (head (tail x))
  72                 else (getValue attrSet
  73                         (tail argList) name)) attrSet );
  74
  75
  76   # Input : attrSet, [[name default] ...], [ [flagname reqs..] ... ]
  77   # Output : are reqs satisfied? It's asserted.
  78   checkReqs = attrSet: argList: condList:
  79   (
  80     foldr lib.and true
  81       (map (x: let name = (head x); in
  82
  83         ((checkFlag attrSet name) ->
  84         (foldr lib.and true
  85         (map (y: let val=(getValue attrSet argList y); in
  86                 (val!=null) && (val!=false))
  87         (tail x))))) condList));
  88
  89
  90   # This function has O(n^2) performance.
  91   uniqList = { inputList, acc ? [] }:
  92     let go = xs: acc:
  93              if xs == []
  94              then []
  95              else let x = head xs;
  96                       y = if elem x acc then [] else [x];
  97                   in y ++ go (tail xs) (y ++ acc);
  98     in go inputList acc;
  99
 100   uniqListExt = { inputList,
 101                   outputList ? [],
 102                   getter ? (x: x),
 103                   compare ? (x: y: x==y) }:
 104         if inputList == [] then outputList else
 105         let x = head inputList;
 106             isX = y: (compare (getter y) (getter x));
 107             newOutputList = outputList ++
 108                 (if any isX outputList then [] else [x]);
 109         in uniqListExt { outputList = newOutputList;
 110                          inputList = (tail inputList);
 111                          inherit getter compare;
 112                        };
 113
 114   condConcat = name: list: checker:
 115         if list == [] then name else
 116         if checker (head list) then
 117                 condConcat
 118                         (name + (head (tail list)))
 119                         (tail (tail list))
 120                         checker
 121         else condConcat
 122                 name (tail (tail list)) checker;
 123
 124   lazyGenericClosure = {startSet, operator}:
 125     let
 126       work = list: doneKeys: result:
 127         if list == [] then
 128           result
 129         else
 130           let x = head list; key = x.key; in
 131           if elem key doneKeys then
 132             work (tail list) doneKeys result
 133           else
 134             work (tail list ++ operator x) ([key] ++ doneKeys) ([x] ++ result);
 135     in
 136       work startSet [] [];
 137
 138   innerModifySumArgs = f: x: a: b: if b == null then (f a b) // x else
 139         innerModifySumArgs f x (a // b);
 140   modifySumArgs = f: x: innerModifySumArgs f x {};
 141
 142
 143   innerClosePropagation = acc: xs:
 144     if xs == []
 145     then acc
 146     else let y  = head xs;
 147              ys = tail xs;
 148          in if ! isAttrs y
 149             then innerClosePropagation acc ys
 150             else let acc' = [y] ++ acc;
 151                  in innerClosePropagation
 152                       acc'
 153                       (uniqList { inputList = (maybeAttrNullable "propagatedBuildInputs" [] y)
 154                                            ++ (maybeAttrNullable "propagatedNativeBuildInputs" [] y)
 155                                            ++ ys;
 156                                   acc = acc';
 157                                 }
 158                       );
 159
 160   closePropagationSlow = list: (uniqList {inputList = (innerClosePropagation [] list);});
 161
 162   # This is an optimisation of lib.closePropagation which avoids the O(n^2) behavior
 163   # Using a list of derivations, it generates the full closure of the propagatedXXXBuildInputs
 164   # The ordering / sorting / comparison is done based on the `outPath`
 165   # attribute of each derivation.
 166   # On some benchmarks, it performs up to 15 times faster than lib.closePropagation.
 167   # See https://github.com/NixOS/nixpkgs/pull/194391 for details.
 168   closePropagationFast = list:
 169     builtins.map (x: x.val) (builtins.genericClosure {
 170       startSet = builtins.map (x: {
 171         key = x.outPath;
 172         val = x;
 173       }) (builtins.filter (x: x != null) list);
 174       operator = item:
 175         if !builtins.isAttrs item.val then
 176           [ ]
 177         else
 178           builtins.concatMap (x:
 179             if x != null then [{
 180               key = x.outPath;
 181               val = x;
 182             }] else
 183               [ ]) ((item.val.propagatedBuildInputs or [ ])
 184                 ++ (item.val.propagatedNativeBuildInputs or [ ]));
 185     });
 186
 187   closePropagation = if builtins ? genericClosure
 188     then closePropagationFast
 189     else closePropagationSlow;
 190
 191   # calls a function (f attr value ) for each record item. returns a list
 192   mapAttrsFlatten = f: r: map (attr: f attr r.${attr}) (attrNames r);
 193
 194   # attribute set containing one attribute
 195   nvs = name: value: listToAttrs [ (nameValuePair name value) ];
 196   # adds / replaces an attribute of an attribute set
 197   setAttr = set: name: v: set // (nvs name v);
 198
 199   # setAttrMerge (similar to mergeAttrsWithFunc but only merges the values of a particular name)
 200   # setAttrMerge "a" [] { a = [2];} (x: x ++ [3]) -> { a = [2 3]; }
 201   # setAttrMerge "a" [] {         } (x: x ++ [3]) -> { a = [  3]; }
 202   setAttrMerge = name: default: attrs: f:
 203     setAttr attrs name (f (maybeAttr name default attrs));
 204
 205   # Using f = a: b = b the result is similar to //
 206   # merge attributes with custom function handling the case that the attribute
 207   # exists in both sets
 208   mergeAttrsWithFunc = f: set1: set2:
 209     foldr (n: set: if set ? ${n}
 210                         then setAttr set n (f set.${n} set2.${n})
 211                         else set )
 212            (set2 // set1) (attrNames set2);
 213
 214   # merging two attribute set concatenating the values of same attribute names
 215   # eg { a = 7; } {  a = [ 2 3 ]; } becomes { a = [ 7 2 3 ]; }
 216   mergeAttrsConcatenateValues = mergeAttrsWithFunc ( a: b: (toList a) ++ (toList b) );
 217
 218   # merges attributes using //, if a name exists in both attributes
 219   # an error will be triggered unless its listed in mergeLists
 220   # so you can mergeAttrsNoOverride { buildInputs = [a]; } { buildInputs = [a]; } {} to get
 221   # { buildInputs = [a b]; }
 222   # merging buildPhase doesn't really make sense. The cases will be rare where appending /prefixing will fit your needs?
 223   # in these cases the first buildPhase will override the second one
 224   # ! deprecated, use mergeAttrByFunc instead
 225   mergeAttrsNoOverride = { mergeLists ? ["buildInputs" "propagatedBuildInputs"],
 226                            overrideSnd ? [ "buildPhase" ]
 227                          }: attrs1: attrs2:
 228     foldr (n: set:
 229         setAttr set n ( if set ? ${n}
 230             then # merge
 231               if elem n mergeLists # attribute contains list, merge them by concatenating
 232                 then attrs2.${n} ++ attrs1.${n}
 233               else if elem n overrideSnd
 234                 then attrs1.${n}
 235               else throw "error mergeAttrsNoOverride, attribute ${n} given in both attributes - no merge func defined"
 236             else attrs2.${n} # add attribute not existing in attr1
 237            )) attrs1 (attrNames attrs2);
 238
 239
 240   # example usage:
 241   # mergeAttrByFunc  {
 242   #   inherit mergeAttrBy; # defined below
 243   #   buildInputs = [ a b ];
 244   # } {
 245   #  buildInputs = [ c d ];
 246   # };
 247   # will result in
 248   # { mergeAttrsBy = [...]; buildInputs = [ a b c d ]; }
 249   # is used by defaultOverridableDelayableArgs and can be used when composing using
 250   # foldArgs, composedArgsAndFun or applyAndFun. Example: composableDerivation in all-packages.nix
 251   mergeAttrByFunc = x: y:
 252     let
 253           mergeAttrBy2 = { mergeAttrBy = lib.mergeAttrs; }
 254                       // (maybeAttr "mergeAttrBy" {} x)
 255                       // (maybeAttr "mergeAttrBy" {} y); in
 256     foldr lib.mergeAttrs {} [
 257       x y
 258       (mapAttrs ( a: v: # merge special names using given functions
 259           if x ? ${a}
 260              then if y ? ${a}
 261                then v x.${a} y.${a} # both have attr, use merge func
 262                else x.${a} # only x has attr
 263              else y.${a} # only y has attr)
 264           ) (removeAttrs mergeAttrBy2
 265                          # don't merge attrs which are neither in x nor y
 266                          (filter (a: ! x ? ${a} && ! y ? ${a})
 267                                  (attrNames mergeAttrBy2))
 268             )
 269       )
 270     ];
 271   mergeAttrsByFuncDefaults = foldl mergeAttrByFunc { inherit mergeAttrBy; };
 272   mergeAttrsByFuncDefaultsClean = list: removeAttrs (mergeAttrsByFuncDefaults list) ["mergeAttrBy"];
 273
 274   # sane defaults (same name as attr name so that inherit can be used)
 275   mergeAttrBy = # { buildInputs = concatList; [...]; passthru = mergeAttr; [..]; }
 276     listToAttrs (map (n: nameValuePair n lib.concat)
 277       [ "nativeBuildInputs" "buildInputs" "propagatedBuildInputs" "configureFlags" "prePhases" "postAll" "patches" ])
 278     // listToAttrs (map (n: nameValuePair n lib.mergeAttrs) [ "passthru" "meta" "cfg" "flags" ])
 279     // listToAttrs (map (n: nameValuePair n (a: b: "${a}\n${b}") ) [ "preConfigure" "postInstall" ])
 280   ;
 281
 282   nixType = x:
 283       if isAttrs x then
 284           if x ? outPath then "derivation"
 285           else "attrs"
 286       else if lib.isFunction x then "function"
 287       else if isList x then "list"
 288       else if x == true then "bool"
 289       else if x == false then "bool"
 290       else if x == null then "null"
 291       else if isInt x then "int"
 292       else "string";
 293
 294   /* deprecated:
 295
 296      For historical reasons, imap has an index starting at 1.
 297
 298      But for consistency with the rest of the library we want an index
 299      starting at zero.
 300   */
 301   imap = imap1;
 302
 303   # Fake hashes. Can be used as hash placeholders, when computing hash ahead isn't trivial
 304   fakeHash = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
 305   fakeSha256 = "0000000000000000000000000000000000000000000000000000000000000000";
 306   fakeSha512 = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
 307 }