commit 943592f69850fd07dd2422da062b1c1ebc45974d · pyrox.dev/nixpkgs

+7 -7

lib/customisation.nix

···

       1
       1
        
       { lib }:

     

       2
       2
        
       let

     

       3
       3
        
       

     

       4
       4
       -
         inherit (builtins) attrNames isFunction;

     

       4
       4
       +
         inherit (builtins) attrNames;

     

       5
       5
        
       

     

       6
       6
        
       in

     

       7
       7
        
       

     
···

       72
       72
        
         makeOverridable = f: origArgs:

     

       73
       73
        
           let

     

       74
       74
        
             ff = f origArgs;

     

       75
       75
       -
             overrideWith = newArgs: origArgs // (if builtins.isFunction newArgs then newArgs origArgs else newArgs);

     

       75
       75
       +
             overrideWith = newArgs: origArgs // (if lib.isFunction newArgs then newArgs origArgs else newArgs);

     

       76
       76
        
           in

     

       77
       77
        
             if builtins.isAttrs ff then (ff // {

     

       78
       78
        
               override = newArgs: makeOverridable f (overrideWith newArgs);

     
···

       81
       81
        
               ${if ff ? overrideAttrs then "overrideAttrs" else null} = fdrv:

     

       82
       82
        
                 makeOverridable (args: (f args).overrideAttrs fdrv) origArgs;

     

       83
       83
        
             })

     

       84
       84
       -
             else if builtins.isFunction ff then {

     

       84
       84
       +
             else if lib.isFunction ff then {

     

       85
       85
        
               override = newArgs: makeOverridable f (overrideWith newArgs);

     

       86
       86
        
               __functor = self: ff;

     

       87
       87
        
               overrideDerivation = throw "overrideDerivation not yet supported for functors";

     
···

       112
       112
        
         */

     

       113
       113
        
         callPackageWith = autoArgs: fn: args:

     

       114
       114
        
           let

     

       115
       115
       -
             f = if builtins.isFunction fn then fn else import fn;

     

       116
       116
       -
             auto = builtins.intersectAttrs (builtins.functionArgs f) autoArgs;

     

       115
       115
       +
             f = if lib.isFunction fn then fn else import fn;

     

       116
       116
       +
             auto = builtins.intersectAttrs (lib.functionArgs f) autoArgs;

     

       117
       117
        
           in makeOverridable f (auto // args);

     

       118
       118
        
       

     

       119
       119
        
       

     
···

       122
       122
        
            individual attributes. */

     

       123
       123
        
         callPackagesWith = autoArgs: fn: args:

     

       124
       124
        
           let

     

       125
       125
       -
             f = if builtins.isFunction fn then fn else import fn;

     

       126
       126
       -
             auto = builtins.intersectAttrs (builtins.functionArgs f) autoArgs;

     

       125
       125
       +
             f = if lib.isFunction fn then fn else import fn;

     

       126
       126
       +
             auto = builtins.intersectAttrs (lib.functionArgs f) autoArgs;

     

       127
       127
        
             origArgs = auto // args;

     

       128
       128
        
             pkgs = f origArgs;

     

       129
       129
        
             mkAttrOverridable = name: pkg: makeOverridable (newArgs: (f newArgs).${name}) origArgs;

+2 -2

lib/debug.nix

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
       

     

       5
       5
       -
       inherit (builtins) trace attrNamesToStr isAttrs isFunction isList isInt

     

       5
       5
       +
       inherit (builtins) trace attrNamesToStr isAttrs isList isInt

     

       6
       6
        
               isString isBool head substring attrNames;

     

       7
       7
        
       

     

       8
       8
       -
       inherit (lib) all id mapAttrsFlatten elem;

     

       8
       8
       +
       inherit (lib) all id mapAttrsFlatten elem isFunction;

     

       9
       9
        
       

     

       10
       10
        
       in

     

       11
       11

+2 -2

lib/default.nix

···

       51
       51
        
       

     

       52
       52
        
           inherit (builtins) add addErrorContext attrNames

     

       53
       53
        
             concatLists deepSeq elem elemAt filter genericClosure genList

     

       54
       54
       -
             getAttr hasAttr head isAttrs isBool isFunction isInt isList

     

       54
       54
       +
             getAttr hasAttr head isAttrs isBool isInt isList

     

       55
       55
        
             isString length lessThan listToAttrs pathExists readFile

     

       56
       56
        
             replaceStrings seq stringLength sub substring tail;

     

       57
       57
        
           inherit (trivial) id const concat or and boolToString mergeAttrs

     

       58
       58
        
             flip mapNullable inNixShell min max importJSON warn info

     

       59
       59
       -
             nixpkgsVersion mod;

     

       59
       59
       +
             nixpkgsVersion mod functionArgs setFunctionArgs isFunction;

     

       60
       60
        
       

     

       61
       61
        
           inherit (fixedPoints) fix fix' extends composeExtensions

     

       62
       62
        
             makeExtensible makeExtensibleWithCustomName;

+4 -4

lib/deprecated.nix

···

       1
       1
        
       { lib }:

     

       2
       2
        
       let

     

       3
       3
       -
           inherit (builtins) isFunction head tail isList isAttrs isInt attrNames;

     

       3
       3
       +
           inherit (builtins) head tail isList isAttrs isInt attrNames;

     

       4
       4
        
       

     

       5
       5
        
       in

     

       6
       6
        
       

     
···

       53
       53
        
                 f:        # the function applied to the arguments

     

       54
       54
        
                 initial:  # you pass attrs, the functions below are passing a function taking the fix argument

     

       55
       55
        
           let

     

       56
       56
       -
               takeFixed = if isFunction initial then initial else (fixed : initial); # transform initial to an expression always taking the fixed argument

     

       56
       56
       +
               takeFixed = if lib.isFunction initial then initial else (fixed : initial); # transform initial to an expression always taking the fixed argument

     

       57
       57
        
               tidy = args:

     

       58
       58
        
                   let # apply all functions given in "applyPreTidy" in sequence

     

       59
       59
        
                       applyPreTidyFun = fold ( n: a: x: n ( a x ) ) lib.id (maybeAttr "applyPreTidy" [] args);

     
···

       63
       63
        
                           let args = takeFixed fixed;

     

       64
       64
        
                               mergeFun = args.${n};

     

       65
       65
        
                           in if isAttrs x then (mergeFun args x)

     

       66
       66
       -
                              else assert isFunction x;

     

       66
       66
       +
                              else assert lib.isFunction x;

     

       67
       67
        
                                   mergeFun args (x ( args // { inherit fixed; }));

     

       68
       68
        
                   in overridableDelayableArgs f newArgs;

     

       69
       69
        
           in

     
···

       374
       374
        
             if isAttrs x then

     

       375
       375
        
                 if x ? outPath then "derivation"

     

       376
       376
        
                 else "attrs"

     

       377
       377
       -
             else if isFunction x then "function"

     

       377
       377
       +
             else if lib.isFunction x then "function"

     

       378
       378
        
             else if isList x then "list"

     

       379
       379
        
             else if x == true then "bool"

     

       380
       380
        
             else if x == false then "bool"

+3 -1

lib/generators.nix

···

       14
       14
        
         libAttr = lib.attrsets;

     

       15
       15
        
       

     

       16
       16
        
         flipMapAttrs = flip libAttr.mapAttrs;

     

       17
       17
       +
       

     

       18
       18
       +
         inherit (lib) isFunction;

     

       17
       19
        
       in

     

       18
       20
        
       

     

       19
       21
        
       rec {

     
···

       110
       112
        
           else if isString   v then "\"" + v + "\""

     

       111
       113
        
           else if null ==    v then "null"

     

       112
       114
        
           else if isFunction v then

     

       113
       113
       -
             let fna = functionArgs v;

     

       115
       115
       +
             let fna = lib.functionArgs v;

     

       114
       116
        
                 showFnas = concatStringsSep "," (libAttr.mapAttrsToList

     

       115
       117
        
                              (name: hasDefVal: if hasDefVal then "(${name})" else name)

     

       116
       118
        
                              fna);

+1 -1

lib/modules.nix

···

       155
       155
        
             # a module will resolve strictly the attributes used as argument but

     

       156
       156
        
             # not their values.  The values are forwarding the result of the

     

       157
       157
        
             # evaluation of the option.

     

       158
       158
       -
             requiredArgs = builtins.attrNames (builtins.functionArgs f);

     

       158
       158
       +
             requiredArgs = builtins.attrNames (lib.functionArgs f);

     

       159
       159
        
             context = name: ''while evaluating the module argument `${name}' in "${key}":'';

     

       160
       160
        
             extraArgs = builtins.listToAttrs (map (name: {

     

       161
       161
        
               inherit name;

+26 -1

lib/trivial.nix

···

       52
       52
        
       

     

       53
       53
        
         # Pull in some builtins not included elsewhere.

     

       54
       54
        
         inherit (builtins)

     

       55
       55
       -
           pathExists readFile isBool isFunction

     

       55
       55
       +
           pathExists readFile isBool

     

       56
       56
        
           isInt add sub lessThan

     

       57
       57
        
           seq deepSeq genericClosure;

     

       58
       58
        
       

     
···

       99
       99
        
         */

     

       100
       100
        
         warn = msg: builtins.trace "WARNING: ${msg}";

     

       101
       101
        
         info = msg: builtins.trace "INFO: ${msg}";

     

       102
       102
       +
       

     

       103
       103
       +
         # | Add metadata about expected function arguments to a function.

     

       104
       104
       +
         # The metadata should match the format given by

     

       105
       105
       +
         # builtins.functionArgs, i.e. a set from expected argument to a bool

     

       106
       106
       +
         # representing whether that argument has a default or not.

     

       107
       107
       +
         # setFunctionArgs : (a → b) → Map String Bool → (a → b)

     

       108
       108
       +
         #

     

       109
       109
       +
         # This function is necessary because you can't dynamically create a

     

       110
       110
       +
         # function of the { a, b ? foo, ... }: format, but some facilities

     

       111
       111
       +
         # like callPackage expect to be able to query expected arguments.

     

       112
       112
       +
         setFunctionArgs = f: args:

     

       113
       113
       +
           { # TODO: Should we add call-time "type" checking like built in?

     

       114
       114
       +
             __functor = self: f;

     

       115
       115
       +
             __functionArgs = args;

     

       116
       116
       +
           };

     

       117
       117
       +
       

     

       118
       118
       +
         # | Extract the expected function arguments from a function.

     

       119
       119
       +
         # This works both with nix-native { a, b ? foo, ... }: style

     

       120
       120
       +
         # functions and functions with args set with 'setFunctionArgs'. It

     

       121
       121
       +
         # has the same return type and semantics as builtins.functionArgs.

     

       122
       122
       +
         # setFunctionArgs : (a → b) → Map String Bool.

     

       123
       123
       +
         functionArgs = f: f.__functionArgs or (builtins.functionArgs f);

     

       124
       124
       +
       

     

       125
       125
       +
         isFunction = f: builtins.isFunction f ||

     

       126
       126
       +
           (f ? __functor && isFunction (f.__functor f));

     

       102
       127
        
       }

+1 -1

nixos/doc/manual/default.nix

···

       12
       12
        
         substFunction = x:

     

       13
       13
        
           if builtins.isAttrs x then lib.mapAttrs (name: substFunction) x

     

       14
       14
        
           else if builtins.isList x then map substFunction x

     

       15
       15
       -
           else if builtins.isFunction x then "<function>"

     

       15
       15
       +
           else if lib.isFunction x then "<function>"

     

       16
       16
        
           else x;

     

       17
       17
        
       

     

       18
       18
        
         # Clean up declaration sites to not refer to the NixOS source tree.

+1 -1

nixos/lib/testing.nix

···

       85
       85
        
       

     

       86
       86
        
             testScript' =

     

       87
       87
        
               # Call the test script with the computed nodes.

     

       88
       88
       -
               if builtins.isFunction testScript

     

       88
       88
       +
               if lib.isFunction testScript

     

       89
       89
        
               then testScript { inherit nodes; }

     

       90
       90
        
               else testScript;

     

       91
       91

+3 -3

nixos/modules/misc/nixpkgs.nix

···

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
        
         isConfig = x:

     

       7
       7
       -
           builtins.isAttrs x || builtins.isFunction x;

     

       7
       7
       +
           builtins.isAttrs x || lib.isFunction x;

     

       8
       8
        
       

     

       9
       9
        
         optCall = f: x:

     

       10
       10
       -
           if builtins.isFunction f

     

       10
       10
       +
           if lib.isFunction f

     

       11
       11
        
           then f x

     

       12
       12
        
           else f;

     

       13
       13
        
       

     
···

       38
       38
        
         overlayType = mkOptionType {

     

       39
       39
        
           name = "nixpkgs-overlay";

     

       40
       40
        
           description = "nixpkgs overlay";

     

       41
       41
       -
           check = builtins.isFunction;

     

       41
       41
       +
           check = lib.isFunction;

     

       42
       42
        
           merge = lib.mergeOneOption;

     

       43
       43
        
         };

     

       44
       44

+1 -1

nixos/modules/profiles/clone-config.nix

···

       17
       17
        
         # you should use files).

     

       18
       18
        
         moduleFiles =

     

       19
       19
        
           # FIXME: use typeOf (Nix 1.6.1).

     

       20
       20
       -
           filter (x: !isAttrs x && !builtins.isFunction x) modules;

     

       20
       20
       +
           filter (x: !isAttrs x && !lib.isFunction x) modules;

     

       21
       21
        
       

     

       22
       22
        
         # Partition module files because between NixOS and non-NixOS files.  NixOS

     

       23
       23
        
         # files may change if the repository is updated.

+1 -1

nixos/tests/make-test.nix

···

       2
       2
        
       

     

       3
       3
        
       with import ../lib/testing.nix { inherit system; };

     

       4
       4
        
       

     

       5
       5
       -
       makeTest (if builtins.isFunction f then f (args // { inherit pkgs; inherit (pkgs) lib; }) else f)

     

       5
       5
       +
       makeTest (if lib.isFunction f then f (args // { inherit pkgs; inherit (pkgs) lib; }) else f)

+1 -1

pkgs/build-support/emacs/wrapper.nix

···

       40
       40
        
       

     

       41
       41
        
       let

     

       42
       42
        
         explicitRequires =

     

       43
       43
       -
           if builtins.isFunction packagesFun

     

       43
       43
       +
           if lib.isFunction packagesFun

     

       44
       44
        
             then packagesFun self

     

       45
       45
        
           else packagesFun;

     

       46
       46
        
       in

+2 -2

pkgs/development/beam-modules/lib.nix

···

       6
       6
        
         */

     

       7
       7
        
         callPackageWith = autoArgs: fn: args:

     

       8
       8
        
           let

     

       9
       9
       -
             f = if builtins.isFunction fn then fn else import fn;

     

       10
       10
       -
             auto = builtins.intersectAttrs (builtins.functionArgs f) autoArgs;

     

       9
       9
       +
             f = if pkgs.lib.isFunction fn then fn else import fn;

     

       10
       10
       +
             auto = builtins.intersectAttrs (stdenv.lib.functionArgs f) autoArgs;

     

       11
       11
        
           in f (auto // args);

     

       12
       12
        
       

     

       13
       13
        
         callPackage = callPackageWith pkgs;

+2 -2

pkgs/development/haskell-modules/make-package-set.nix

···

       81
       81
        
             # lost on `.override`) but determine the auto-args based on `drv` (the problem here

     

       82
       82
        
             # is that nix has no way to "passthrough" args while preserving the reflection

     

       83
       83
        
             # info that callPackage uses to determine the arguments).

     

       84
       84
       -
             drv = if builtins.isFunction fn then fn else import fn;

     

       85
       85
       -
             auto = builtins.intersectAttrs (builtins.functionArgs drv) scope;

     

       84
       84
       +
             drv = if stdenv.lib.isFunction fn then fn else import fn;

     

       85
       85
       +
             auto = builtins.intersectAttrs (stdenv.lib.functionArgs drv) scope;

     

       86
       86
        
       

     

       87
       87
        
             # this wraps the `drv` function to add a `overrideScope` function to the result.

     

       88
       88
        
             drvScope = allArgs: drv allArgs // {

+1 -1

pkgs/os-specific/darwin/apple-source-releases/default.nix

···

       186
       186
        
           # There should be an IOVideo here, but they haven't released it :(

     

       187
       187
        
         };

     

       188
       188
        
       

     

       189
       189
       -
         IOKitSrcs = stdenv.lib.mapAttrs (name: value: if builtins.isFunction value then value name else value) IOKitSpecs;

     

       189
       189
       +
         IOKitSrcs = stdenv.lib.mapAttrs (name: value: if stdenv.lib.isFunction value then value name else value) IOKitSpecs;

     

       190
       190
        
       

     

       191
       191
        
         adv_cmds = applePackage "adv_cmds" "osx-10.5.8" "102ssayxbg9wb35mdmhswbnw0bg7js3pfd8fcbic83c5q3bqa6c6" {};

     

       192
       192

+1 -1

pkgs/top-level/default.nix

···

       49
       49
        
         # { /* the config */ } and

     

       50
       50
        
         # { pkgs, ... } : { /* the config */ }

     

       51
       51
        
         config =

     

       52
       52
       -
           if builtins.isFunction configExpr

     

       52
       52
       +
           if lib.isFunction configExpr

     

       53
       53
        
           then configExpr { inherit pkgs; }

     

       54
       54
        
           else configExpr;

     

       55
       55

+1 -1

pkgs/top-level/python-packages.nix

···

       40
       40
        
         makeOverridablePythonPackage = f: origArgs:

     

       41
       41
        
           let

     

       42
       42
        
             ff = f origArgs;

     

       43
       43
       -
             overrideWith = newArgs: origArgs // (if builtins.isFunction newArgs then newArgs origArgs else newArgs);

     

       43
       43
       +
             overrideWith = newArgs: origArgs // (if pkgs.lib.isFunction newArgs then newArgs origArgs else newArgs);

     

       44
       44
        
           in

     

       45
       45
        
             if builtins.isAttrs ff then (ff // {

     

       46
       46
        
               overridePythonAttrs = newArgs: makeOverridablePythonPackage f (overrideWith newArgs);