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   closePropagation = list: (uniqList {inputList = (innerClosePropagation [] list);});
 161
 162   # calls a function (f attr value ) for each record item. returns a list
 163   mapAttrsFlatten = f: r: map (attr: f attr r.${attr}) (attrNames r);
 164
 165   # attribute set containing one attribute
 166   nvs = name: value: listToAttrs [ (nameValuePair name value) ];
 167   # adds / replaces an attribute of an attribute set
 168   setAttr = set: name: v: set // (nvs name v);
 169
 170   # setAttrMerge (similar to mergeAttrsWithFunc but only merges the values of a particular name)
 171   # setAttrMerge "a" [] { a = [2];} (x: x ++ [3]) -> { a = [2 3]; }
 172   # setAttrMerge "a" [] {         } (x: x ++ [3]) -> { a = [  3]; }
 173   setAttrMerge = name: default: attrs: f:
 174     setAttr attrs name (f (maybeAttr name default attrs));
 175
 176   # Using f = a: b = b the result is similar to //
 177   # merge attributes with custom function handling the case that the attribute
 178   # exists in both sets
 179   mergeAttrsWithFunc = f: set1: set2:
 180     foldr (n: set: if set ? ${n}
 181                         then setAttr set n (f set.${n} set2.${n})
 182                         else set )
 183            (set2 // set1) (attrNames set2);
 184
 185   # merging two attribute set concatenating the values of same attribute names
 186   # eg { a = 7; } {  a = [ 2 3 ]; } becomes { a = [ 7 2 3 ]; }
 187   mergeAttrsConcatenateValues = mergeAttrsWithFunc ( a: b: (toList a) ++ (toList b) );
 188
 189   # merges attributes using //, if a name exists in both attributes
 190   # an error will be triggered unless its listed in mergeLists
 191   # so you can mergeAttrsNoOverride { buildInputs = [a]; } { buildInputs = [a]; } {} to get
 192   # { buildInputs = [a b]; }
 193   # merging buildPhase doesn't really make sense. The cases will be rare where appending /prefixing will fit your needs?
 194   # in these cases the first buildPhase will override the second one
 195   # ! deprecated, use mergeAttrByFunc instead
 196   mergeAttrsNoOverride = { mergeLists ? ["buildInputs" "propagatedBuildInputs"],
 197                            overrideSnd ? [ "buildPhase" ]
 198                          }: attrs1: attrs2:
 199     foldr (n: set:
 200         setAttr set n ( if set ? ${n}
 201             then # merge
 202               if elem n mergeLists # attribute contains list, merge them by concatenating
 203                 then attrs2.${n} ++ attrs1.${n}
 204               else if elem n overrideSnd
 205                 then attrs1.${n}
 206               else throw "error mergeAttrsNoOverride, attribute ${n} given in both attributes - no merge func defined"
 207             else attrs2.${n} # add attribute not existing in attr1
 208            )) attrs1 (attrNames attrs2);
 209
 210
 211   # example usage:
 212   # mergeAttrByFunc  {
 213   #   inherit mergeAttrBy; # defined below
 214   #   buildInputs = [ a b ];
 215   # } {
 216   #  buildInputs = [ c d ];
 217   # };
 218   # will result in
 219   # { mergeAttrsBy = [...]; buildInputs = [ a b c d ]; }
 220   # is used by defaultOverridableDelayableArgs and can be used when composing using
 221   # foldArgs, composedArgsAndFun or applyAndFun. Example: composableDerivation in all-packages.nix
 222   mergeAttrByFunc = x: y:
 223     let
 224           mergeAttrBy2 = { mergeAttrBy = lib.mergeAttrs; }
 225                       // (maybeAttr "mergeAttrBy" {} x)
 226                       // (maybeAttr "mergeAttrBy" {} y); in
 227     foldr lib.mergeAttrs {} [
 228       x y
 229       (mapAttrs ( a: v: # merge special names using given functions
 230           if x ? ${a}
 231              then if y ? ${a}
 232                then v x.${a} y.${a} # both have attr, use merge func
 233                else x.${a} # only x has attr
 234              else y.${a} # only y has attr)
 235           ) (removeAttrs mergeAttrBy2
 236                          # don't merge attrs which are neither in x nor y
 237                          (filter (a: ! x ? ${a} && ! y ? ${a})
 238                                  (attrNames mergeAttrBy2))
 239             )
 240       )
 241     ];
 242   mergeAttrsByFuncDefaults = foldl mergeAttrByFunc { inherit mergeAttrBy; };
 243   mergeAttrsByFuncDefaultsClean = list: removeAttrs (mergeAttrsByFuncDefaults list) ["mergeAttrBy"];
 244
 245   # sane defaults (same name as attr name so that inherit can be used)
 246   mergeAttrBy = # { buildInputs = concatList; [...]; passthru = mergeAttr; [..]; }
 247     listToAttrs (map (n: nameValuePair n lib.concat)
 248       [ "nativeBuildInputs" "buildInputs" "propagatedBuildInputs" "configureFlags" "prePhases" "postAll" "patches" ])
 249     // listToAttrs (map (n: nameValuePair n lib.mergeAttrs) [ "passthru" "meta" "cfg" "flags" ])
 250     // listToAttrs (map (n: nameValuePair n (a: b: "${a}\n${b}") ) [ "preConfigure" "postInstall" ])
 251   ;
 252
 253   nixType = x:
 254       if isAttrs x then
 255           if x ? outPath then "derivation"
 256           else "attrs"
 257       else if lib.isFunction x then "function"
 258       else if isList x then "list"
 259       else if x == true then "bool"
 260       else if x == false then "bool"
 261       else if x == null then "null"
 262       else if isInt x then "int"
 263       else "string";
 264
 265   /* deprecated:
 266
 267      For historical reasons, imap has an index starting at 1.
 268
 269      But for consistency with the rest of the library we want an index
 270      starting at zero.
 271   */
 272   imap = imap1;
 273
 274   # Fake hashes. Can be used as hash placeholders, when computing hash ahead isn't trivial
 275   fakeHash = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
 276   fakeSha256 = "0000000000000000000000000000000000000000000000000000000000000000";
 277   fakeSha512 = "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
 278 }