From d9123a2329f0d35af45d25aab5adb4348b8e3d56 Mon Sep 17 00:00:00 2001 From: Benjamin Staffin Date: Sat, 11 Mar 2017 17:39:40 -0500 Subject: [PATCH] lib: fix mixed tab/space indents, trailing whitespace, etc Nix style seems to have settled on not using spaces between bound variable names and the lambda : so I also tried to make those somewhat more consistent throughout. --- lib/composable-derivation.nix | 6 +- lib/debug.nix | 14 +-- lib/deprecated.nix | 179 +++++++++++++++++----------------- lib/modules.nix | 8 +- lib/tests.nix | 8 +- lib/types.nix | 2 +- 6 files changed, 110 insertions(+), 107 deletions(-) diff --git a/lib/composable-derivation.nix b/lib/composable-derivation.nix index e3e017d982d3..5442dcedeabc 100644 --- a/lib/composable-derivation.nix +++ b/lib/composable-derivation.nix @@ -1,4 +1,4 @@ -{lib, pkgs} : +{lib, pkgs}: let inherit (lib) nv nvs; in { @@ -19,7 +19,7 @@ let inherit (lib) nv nvs; in # * vim_configurable # # A minimal example illustrating most features would look like this: - # let base = composableDerivation { (fixed : let inherit (fixed.fixed) name in { + # let base = composableDerivation { (fixed: let inherit (fixed.fixed) name in { # src = fetchurl { # } # buildInputs = [A]; @@ -79,7 +79,7 @@ let inherit (lib) nv nvs; in # consider adding addtional elements by derivation.merge { removeAttrs = ["elem"]; }; removeAttrs ? ["cfg" "flags"] - }: (lib.defaultOverridableDelayableArgs ( a: mkDerivation a) + }: (lib.defaultOverridableDelayableArgs ( a: mkDerivation a) { inherit applyPreTidy removeAttrs; }).merge; diff --git a/lib/debug.nix b/lib/debug.nix index e2e895ab6202..5b3878554c5d 100644 --- a/lib/debug.nix +++ b/lib/debug.nix @@ -24,10 +24,10 @@ rec { traceValSeq = v: traceVal (builtins.deepSeq v v); # this can help debug your code as well - designed to not produce thousands of lines - traceShowVal = x : trace (showVal x) x; + traceShowVal = x: trace (showVal x) x; traceShowValMarked = str: x: trace (str + showVal x) x; - attrNamesToStr = a : lib.concatStringsSep "; " (map (x : "${x}=") (attrNames a)); - showVal = x : + attrNamesToStr = a: lib.concatStringsSep "; " (map (x: "${x}=") (attrNames a)); + showVal = x: if isAttrs x then if x ? outPath then "x is a derivation, name ${if x ? name then x.name else ""}, { ${attrNamesToStr x} }" else "x is attr set { ${attrNamesToStr x} }" @@ -43,9 +43,9 @@ rec { # trace the arguments passed to function and its result # maybe rewrite these functions in a traceCallXml like style. Then one function is enough - traceCall = n : f : a : let t = n2 : x : traceShowValMarked "${n} ${n2}:" x; in t "result" (f (t "arg 1" a)); - traceCall2 = n : f : a : b : let t = n2 : x : traceShowValMarked "${n} ${n2}:" x; in t "result" (f (t "arg 1" a) (t "arg 2" b)); - traceCall3 = n : f : a : b : c : let t = n2 : x : traceShowValMarked "${n} ${n2}:" x; in t "result" (f (t "arg 1" a) (t "arg 2" b) (t "arg 3" c)); + traceCall = n: f: a: let t = n2: x: traceShowValMarked "${n} ${n2}:" x; in t "result" (f (t "arg 1" a)); + traceCall2 = n: f: a: b: let t = n2: x: traceShowValMarked "${n} ${n2}:" x; in t "result" (f (t "arg 1" a) (t "arg 2" b)); + traceCall3 = n: f: a: b: c: let t = n2: x: traceShowValMarked "${n} ${n2}:" x; in t "result" (f (t "arg 1" a) (t "arg 2" b) (t "arg 3" c)); # FIXME: rename this? traceValIfNot = c: x: @@ -71,7 +71,7 @@ rec { # create a test assuming that list elements are true # usage: { testX = allTrue [ true ]; } - testAllTrue = expr : { inherit expr; expected = map (x: true) expr; }; + testAllTrue = expr: { inherit expr; expected = map (x: true) expr; }; strict = v: trace "Warning: strict is deprecated and will be removed in the next release" diff --git a/lib/deprecated.nix b/lib/deprecated.nix index 3729197f48bc..45a3893fc22d 100644 --- a/lib/deprecated.nix +++ b/lib/deprecated.nix @@ -16,23 +16,23 @@ rec { defaultMergeArg = x : y: if builtins.isAttrs y then y - else + else (y x); defaultMerge = x: y: x // (defaultMergeArg x y); - foldArgs = merger: f: init: x: - let arg=(merger init (defaultMergeArg init x)); - # now add the function with composed args already applied to the final attrs - base = (setAttrMerge "passthru" {} (f arg) - ( z : z // rec { - function = foldArgs merger f arg; - args = (lib.attrByPath ["passthru" "args"] {} z) // x; + foldArgs = merger: f: init: x: + let arg = (merger init (defaultMergeArg init x)); + # now add the function with composed args already applied to the final attrs + base = (setAttrMerge "passthru" {} (f arg) + ( z: z // rec { + function = foldArgs merger f arg; + args = (lib.attrByPath ["passthru" "args"] {} z) // x; } )); - withStdOverrides = base // { - override = base.passthru.function; - } ; + withStdOverrides = base // { + override = base.passthru.function; + }; in - withStdOverrides; - + withStdOverrides; + # predecessors: proposed replacement for applyAndFun (which has a bug cause it merges twice) # the naming "overridableDelayableArgs" tries to express that you can @@ -49,35 +49,35 @@ rec { # # examples: see test cases "res" below; overridableDelayableArgs = - f : # the function applied to the arguments - initial : # you pass attrs, the functions below are passing a function taking the fix argument + f: # the function applied to the arguments + initial: # you pass attrs, the functions below are passing a function taking the fix argument let takeFixed = if isFunction initial then initial else (fixed : initial); # transform initial to an expression always taking the fixed argument - tidy = args : + tidy = args: let # apply all functions given in "applyPreTidy" in sequence - applyPreTidyFun = fold ( n : a : x : n ( a x ) ) lib.id (maybeAttr "applyPreTidy" [] args); + applyPreTidyFun = fold ( n: a: x: n ( a x ) ) lib.id (maybeAttr "applyPreTidy" [] args); in removeAttrs (applyPreTidyFun args) ( ["applyPreTidy"] ++ (maybeAttr "removeAttrs" [] args) ); # tidy up args before applying them - fun = n : x : - let newArgs = fixed : - let args = takeFixed fixed; - mergeFun = args.${n}; - in if isAttrs x then (mergeFun args x) - else assert isFunction x; - mergeFun args (x ( args // { inherit fixed; })); - in overridableDelayableArgs f newArgs; + fun = n: x: + let newArgs = fixed: + let args = takeFixed fixed; + mergeFun = args.${n}; + in if isAttrs x then (mergeFun args x) + else assert isFunction x; + mergeFun args (x ( args // { inherit fixed; })); + in overridableDelayableArgs f newArgs; in (f (tidy (lib.fix takeFixed))) // { merge = fun "mergeFun"; replace = fun "keepFun"; }; - defaultOverridableDelayableArgs = f : + defaultOverridableDelayableArgs = f: let defaults = { mergeFun = mergeAttrByFunc; # default merge function. merge strategie (concatenate lists, strings) is given by mergeAttrBy - keepFun = a : b : { inherit (a) removeAttrs mergeFun keepFun mergeAttrBy; } // b; # even when using replace preserve these values + keepFun = a: b: { inherit (a) removeAttrs mergeFun keepFun mergeAttrBy; } // b; # even when using replace preserve these values applyPreTidy = []; # list of functions applied to args before args are tidied up (usage case : prepareDerivationArgs) mergeAttrBy = mergeAttrBy // { - applyPreTidy = a : b : a ++ b; - removeAttrs = a : b: a ++ b; + applyPreTidy = a: b: a ++ b; + removeAttrs = a: b: a ++ b; }; removeAttrs = ["mergeFun" "keepFun" "mergeAttrBy" "removeAttrs" "fixed" ]; # before applying the arguments to the function make sure these names are gone }; @@ -86,7 +86,7 @@ rec { # rec { # an example of how composedArgsAndFun can be used - # a = composedArgsAndFun (x : x) { a = ["2"]; meta = { d = "bar";}; }; + # a = composedArgsAndFun (x: x) { a = ["2"]; meta = { d = "bar";}; }; # # meta.d will be lost ! It's your task to preserve it (eg using a merge function) # b = a.passthru.function { a = [ "3" ]; meta = { d2 = "bar2";}; }; # # instead of passing/ overriding values you can use a merge function: @@ -119,7 +119,7 @@ rec { else if val == true || val == false then false else null; - + # Return true only if there is an attribute and it is true. checkFlag = attrSet: name: if name == "true" then true else @@ -134,29 +134,29 @@ rec { ( attrByPath [name] (if checkFlag attrSet name then true else if argList == [] then null else let x = builtins.head argList; in - if (head x) == name then + if (head x) == name then (head (tail x)) - else (getValue attrSet + else (getValue attrSet (tail argList) name)) attrSet ); - + # Input : attrSet, [[name default] ...], [ [flagname reqs..] ... ] # Output : are reqs satisfied? It's asserted. - checkReqs = attrSet : argList : condList : + checkReqs = attrSet: argList: condList: ( - fold lib.and true - (map (x: let name = (head x) ; in - - ((checkFlag attrSet name) -> + fold lib.and true + (map (x: let name = (head x); in + + ((checkFlag attrSet name) -> (fold lib.and true (map (y: let val=(getValue attrSet argList y); in - (val!=null) && (val!=false)) - (tail x))))) condList)) ; - + (val!=null) && (val!=false)) + (tail x))))) condList)); + # This function has O(n^2) performance. - uniqList = {inputList, acc ? []} : - let go = xs : acc : + uniqList = { inputList, acc ? [] }: + let go = xs: acc: if xs == [] then [] else let x = head xs; @@ -164,26 +164,26 @@ rec { in y ++ go (tail xs) (y ++ acc); in go inputList acc; - uniqListExt = {inputList, outputList ? [], - getter ? (x : x), compare ? (x: y: x==y)}: + uniqListExt = { inputList, + outputList ? [], + getter ? (x: x), + compare ? (x: y: x==y) }: if inputList == [] then outputList else - let x=head inputList; - isX = y: (compare (getter y) (getter x)); - newOutputList = outputList ++ - (if any isX outputList then [] else [x]); - in uniqListExt {outputList=newOutputList; - inputList = (tail inputList); - inherit getter compare; - }; + let x = head inputList; + isX = y: (compare (getter y) (getter x)); + newOutputList = outputList ++ + (if any isX outputList then [] else [x]); + in uniqListExt { outputList = newOutputList; + inputList = (tail inputList); + inherit getter compare; + }; - - condConcat = name: list: checker: if list == [] then name else - if checker (head list) then - condConcat - (name + (head (tail list))) - (tail (tail list)) + if checker (head list) then + condConcat + (name + (head (tail list))) + (tail (tail list)) checker else condConcat name (tail (tail list)) checker; @@ -202,12 +202,12 @@ rec { in work startSet [] []; - innerModifySumArgs = f: x: a: b: if b == null then (f a b) // x else + innerModifySumArgs = f: x: a: b: if b == null then (f a b) // x else innerModifySumArgs f x (a // b); modifySumArgs = f: x: innerModifySumArgs f x {}; - innerClosePropagation = acc : xs : + innerClosePropagation = acc: xs: if xs == [] then acc else let y = head xs; @@ -227,31 +227,31 @@ rec { closePropagation = list: (uniqList {inputList = (innerClosePropagation [] list);}); # calls a function (f attr value ) for each record item. returns a list - mapAttrsFlatten = f : r : map (attr: f attr r.${attr}) (attrNames r); + mapAttrsFlatten = f: r: map (attr: f attr r.${attr}) (attrNames r); # attribute set containing one attribute - nvs = name : value : listToAttrs [ (nameValuePair name value) ]; + nvs = name: value: listToAttrs [ (nameValuePair name value) ]; # adds / replaces an attribute of an attribute set - setAttr = set : name : v : set // (nvs name v); + setAttr = set: name: v: set // (nvs name v); # setAttrMerge (similar to mergeAttrsWithFunc but only merges the values of a particular name) - # setAttrMerge "a" [] { a = [2];} (x : x ++ [3]) -> { a = [2 3]; } - # setAttrMerge "a" [] { } (x : x ++ [3]) -> { a = [ 3]; } - setAttrMerge = name : default : attrs : f : + # setAttrMerge "a" [] { a = [2];} (x: x ++ [3]) -> { a = [2 3]; } + # setAttrMerge "a" [] { } (x: x ++ [3]) -> { a = [ 3]; } + setAttrMerge = name: default: attrs: f: setAttr attrs name (f (maybeAttr name default attrs)); - # Using f = a : b = b the result is similar to // + # Using f = a: b = b the result is similar to // # merge attributes with custom function handling the case that the attribute # exists in both sets - mergeAttrsWithFunc = f : set1 : set2 : - fold (n: set : if set ? ${n} + mergeAttrsWithFunc = f: set1: set2: + fold (n: set: if set ? ${n} then setAttr set n (f set.${n} set2.${n}) else set ) (set2 // set1) (attrNames set2); # merging two attribute set concatenating the values of same attribute names # eg { a = 7; } { a = [ 2 3 ]; } becomes { a = [ 7 2 3 ]; } - mergeAttrsConcatenateValues = mergeAttrsWithFunc ( a : b : (toList a) ++ (toList b) ); + mergeAttrsConcatenateValues = mergeAttrsWithFunc ( a: b: (toList a) ++ (toList b) ); # merges attributes using //, if a name exisits in both attributes # an error will be triggered unless its listed in mergeLists @@ -262,10 +262,10 @@ rec { # ! deprecated, use mergeAttrByFunc instead mergeAttrsNoOverride = { mergeLists ? ["buildInputs" "propagatedBuildInputs"], overrideSnd ? [ "buildPhase" ] - } : attrs1 : attrs2 : - fold (n: set : + }: attrs1: attrs2: + fold (n: set: setAttr set n ( if set ? ${n} - then # merge + then # merge if elem n mergeLists # attribute contains list, merge them by concatenating then attrs2.${n} ++ attrs1.${n} else if elem n overrideSnd @@ -286,14 +286,14 @@ rec { # { mergeAttrsBy = [...]; buildInputs = [ a b c d ]; } # is used by prepareDerivationArgs, defaultOverridableDelayableArgs and can be used when composing using # foldArgs, composedArgsAndFun or applyAndFun. Example: composableDerivation in all-packages.nix - mergeAttrByFunc = x : y : + mergeAttrByFunc = x: y: let - mergeAttrBy2 = { mergeAttrBy=lib.mergeAttrs; } + mergeAttrBy2 = { mergeAttrBy = lib.mergeAttrs; } // (maybeAttr "mergeAttrBy" {} x) // (maybeAttr "mergeAttrBy" {} y); in fold lib.mergeAttrs {} [ x y - (mapAttrs ( a : v : # merge special names using given functions + (mapAttrs ( a: v: # merge special names using given functions if x ? ${a} then if y ? ${a} then v x.${a} y.${a} # both have attr, use merge func @@ -313,9 +313,9 @@ rec { # # This function is best explained by an example: # - # {version ? "2.x"} : + # {version ? "2.x"}: # - # mkDerivation (mergeAttrsByVersion "package-name" version + # mkDerivation (mergeAttrsByVersion "package-name" version # { # version specific settings # "git" = { src = ..; preConfigre = "autogen.sh"; buildInputs = [automake autoconf libtool]; }; # "2.x" = { src = ..; }; @@ -346,21 +346,24 @@ rec { # See misc.nix -> versionedDerivation # discussion: nixpkgs: pull/310 mergeAttrsByVersion = name: version: attrsByVersion: base: - mergeAttrsByFuncDefaultsClean [ { name = "${name}-${version}"; } base (maybeAttr version (throw "bad version ${version} for ${name}") attrsByVersion)]; + mergeAttrsByFuncDefaultsClean [ { name = "${name}-${version}"; } + base + (maybeAttr version (throw "bad version ${version} for ${name}") attrsByVersion) + ]; # sane defaults (same name as attr name so that inherit can be used) mergeAttrBy = # { buildInputs = concatList; [...]; passthru = mergeAttr; [..]; } - listToAttrs (map (n : nameValuePair n lib.concat) + listToAttrs (map (n: nameValuePair n lib.concat) [ "nativeBuildInputs" "buildInputs" "propagatedBuildInputs" "configureFlags" "prePhases" "postAll" "patches" ]) - // listToAttrs (map (n : nameValuePair n lib.mergeAttrs) [ "passthru" "meta" "cfg" "flags" ]) - // listToAttrs (map (n : nameValuePair n (a: b: "${a}\n${b}") ) [ "preConfigure" "postInstall" ]) + // listToAttrs (map (n: nameValuePair n lib.mergeAttrs) [ "passthru" "meta" "cfg" "flags" ]) + // listToAttrs (map (n: nameValuePair n (a: b: "${a}\n${b}") ) [ "preConfigure" "postInstall" ]) ; # prepareDerivationArgs tries to make writing configurable derivations easier # example: # prepareDerivationArgs { # mergeAttrBy = { - # myScript = x : y : x ++ "\n" ++ y; + # myScript = x: y: x ++ "\n" ++ y; # }; # cfg = { # readlineSupport = true; @@ -392,10 +395,10 @@ rec { # TODO use args.mergeFun here as well? prepareDerivationArgs = args: let args2 = { cfg = {}; flags = {}; } // args; - flagName = name : "${name}Support"; - cfgWithDefaults = (listToAttrs (map (n : nameValuePair (flagName n) false) (attrNames args2.flags))) + flagName = name: "${name}Support"; + cfgWithDefaults = (listToAttrs (map (n: nameValuePair (flagName n) false) (attrNames args2.flags))) // args2.cfg; - opts = attrValues (mapAttrs (a : v : + opts = attrValues (mapAttrs (a: v: let v2 = if v ? set || v ? unset then v else { set = v; }; n = if cfgWithDefaults.${flagName a} then "set" else "unset"; attr = maybeAttr n {} v2; in diff --git a/lib/modules.nix b/lib/modules.nix index a7c397d2cf43..862488310d81 100644 --- a/lib/modules.nix +++ b/lib/modules.nix @@ -114,7 +114,7 @@ rec { /* Massage a module into canonical form, that is, a set consisting of ‘options’, ‘config’ and ‘imports’ attributes. */ unifyModuleSyntax = file: key: m: - let metaSet = if m ? meta + let metaSet = if m ? meta then { meta = m.meta; } else {}; in @@ -595,7 +595,7 @@ rec { functionality This show a warning if any a.b.c or d.e.f is set, and set the value of - x.y.z to the result of the merge function + x.y.z to the result of the merge function */ mkMergedOptionModule = from: to: mergeFn: { config, options, ... }: @@ -611,12 +611,12 @@ rec { let val = getAttrFromPath f config; opt = getAttrFromPath f options; in - optionalString + optionalString (val != "_mkMergedOptionModule") "The option `${showOption f}' defined in ${showFiles opt.files} has been changed to `${showOption to}' that has a different type. Please read `${showOption to}' documentation and update your configuration accordingly." ) from); } // setAttrByPath to (mkMerge - (optional + (optional (any (f: (getAttrFromPath f config) != "_mkMergedOptionModule") from) (mergeFn config))); }; diff --git a/lib/tests.nix b/lib/tests.nix index d33e3a824e34..251282d29904 100644 --- a/lib/tests.nix +++ b/lib/tests.nix @@ -80,7 +80,7 @@ runTests { y = x.merge {}; in (y.merge) { a = 10; }; - resRem7 = res6.replace (a : removeAttrs a ["a"]); + resRem7 = res6.replace (a: removeAttrs a ["a"]); resReplace6 = let x = defaultOverridableDelayableArgs id { a = 7; mergeAttrBy = { a = add; }; }; x2 = x.merge { a = 20; }; # now we have 27 @@ -88,10 +88,10 @@ runTests { # fixed tests (delayed args): (when using them add some comments, please) resFixed1 = - let x = defaultOverridableDelayableArgs id ( x : { a = 7; c = x.fixed.b; }); - y = x.merge (x : { name = "name-${builtins.toString x.fixed.c}"; }); + let x = defaultOverridableDelayableArgs id ( x: { a = 7; c = x.fixed.b; }); + y = x.merge (x: { name = "name-${builtins.toString x.fixed.c}"; }); in (y.merge) { b = 10; }; - strip = attrs : removeAttrs attrs ["merge" "replace"]; + strip = attrs: removeAttrs attrs ["merge" "replace"]; in all id [ ((strip res1) == { }) ((strip res2) == { a = 7; }) diff --git a/lib/types.nix b/lib/types.nix index 0d1a88a00f2d..175cb7472bf6 100644 --- a/lib/types.nix +++ b/lib/types.nix @@ -81,7 +81,7 @@ rec { # name: name of the type # type: type function. # wrapped: the type wrapped in case of compound types. - # payload: values of the type, two payloads of the same type must be + # payload: values of the type, two payloads of the same type must be # combinable with the binOp binary operation. # binOp: binary operation that merge two payloads of the same type. functor ? defaultFunctor name