commit 62edf873aad11ffd4acc95026a416eaa37fc42ec · pyrox.dev/nixpkgs

+61

doc/functions.xml

···

       99
       99
        
       

     

       100
       100
        
       </section>

     

       101
       101
        
       

     

       102
       102
       +
       <section xml:id="sec-pkg-overrideAttrs">

     

       103
       103
       +
         <title>&lt;pkg&gt;.overrideAttrs</title>

     

       104
       104
       +
       

     

       105
       105
       +
         <para>

     

       106
       106
       +
           The function <varname>overrideAttrs</varname> allows overriding the

     

       107
       107
       +
           attribute set passed to a <varname>stdenv.mkDerivation</varname> call,

     

       108
       108
       +
           producing a new derivation based on the original one.

     

       109
       109
       +
           This function is available on all derivations produced by the

     

       110
       110
       +
           <varname>stdenv.mkDerivation</varname> function, which is most packages

     

       111
       111
       +
           in the nixpkgs expression <varname>pkgs</varname>.

     

       112
       112
       +
         </para>

     

       113
       113
       +
       

     

       114
       114
       +
         <para>

     

       115
       115
       +
           Example usage:

     

       116
       116
       +
       

     

       117
       117
       +
           <programlisting>helloWithDebug = pkgs.hello.overrideAttrs (oldAttrs: rec {

     

       118
       118
       +
         separateDebugInfo = true;

     

       119
       119
       +
       });</programlisting>

     

       120
       120
       +
         </para>

     

       121
       121
       +
       

     

       122
       122
       +
         <para>

     

       123
       123
       +
           In the above example, the <varname>separateDebugInfo</varname> attribute is

     

       124
       124
       +
           overriden to be true, thus building debug info for

     

       125
       125
       +
           <varname>helloWithDebug</varname>, while all other attributes will be

     

       126
       126
       +
           retained from the original <varname>hello</varname> package.

     

       127
       127
       +
         </para>

     

       128
       128
       +
       

     

       129
       129
       +
         <para>

     

       130
       130
       +
           The argument <varname>oldAttrs</varname> is conventionally used to refer to

     

       131
       131
       +
           the attr set originally passed to <varname>stdenv.mkDerivation</varname>.

     

       132
       132
       +
         </para>

     

       133
       133
       +
       

     

       134
       134
       +
         <note>

     

       135
       135
       +
           <para>

     

       136
       136
       +
             Note that <varname>separateDebugInfo</varname> is processed only by the

     

       137
       137
       +
             <varname>stdenv.mkDerivation</varname> function, not the generated, raw

     

       138
       138
       +
             Nix derivation. Thus, using <varname>overrideDerivation</varname> will

     

       139
       139
       +
             not work in this case, as it overrides only the attributes of the final

     

       140
       140
       +
             derivation. It is for this reason that <varname>overrideAttrs</varname>

     

       141
       141
       +
             should be preferred in (almost) all cases to

     

       142
       142
       +
             <varname>overrideDerivation</varname>, i.e. to allow using

     

       143
       143
       +
             <varname>sdenv.mkDerivation</varname> to process input arguments, as well

     

       144
       144
       +
             as the fact that it is easier to use (you can use the same attribute

     

       145
       145
       +
             names you see in your Nix code, instead of the ones generated (e.g.

     

       146
       146
       +
             <varname>buildInputs</varname> vs <varname>nativeBuildInputs</varname>,

     

       147
       147
       +
             and involves less typing.

     

       148
       148
       +
           </para>

     

       149
       149
       +
         </note>

     

       150
       150
       +
       

     

       151
       151
       +
       </section>

     

       152
       152
       +
       

     

       153
       153
       +
       

     

       102
       154
        
       <section xml:id="sec-pkg-overrideDerivation">

     

       103
       155
        
         <title>&lt;pkg&gt;.overrideDerivation</title>

     

       156
       156
       +
       

     

       157
       157
       +
         <warning>

     

       158
       158
       +
           <para>You should prefer <varname>overrideAttrs</varname> in almost all

     

       159
       159
       +
           cases, see its documentation for the reasons why.

     

       160
       160
       +
           <varname>overrideDerivation</varname> is not deprecated and will continue

     

       161
       161
       +
           to work, but is less nice to use and does not have as many abilities as

     

       162
       162
       +
           <varname>overrideAttrs</varname>.

     

       163
       163
       +
           </para>

     

       164
       164
       +
         </warning>

     

       104
       165
        
       

     

       105
       166
        
         <warning>

     

       106
       167
        
           <para>Do not use this function in Nixpkgs as it evaluates a Derivation

+12 -10

lib/customisation.nix

···

       56
       56
        
             ff = f origArgs;

     

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

     

       58
       58
        
           in

     

       59
       59
       -
             if builtins.isAttrs ff then (ff //

     

       60
       60
       -
               { override = newArgs: makeOverridable f (overrideWith newArgs);

     

       61
       61
       -
                 overrideDerivation = fdrv:

     

       62
       62
       -
                   makeOverridable (args: overrideDerivation (f args) fdrv) origArgs;

     

       63
       63
       -
               })

     

       64
       64
       -
             else if builtins.isFunction ff then

     

       65
       65
       -
               { override = newArgs: makeOverridable f (overrideWith newArgs);

     

       66
       66
       -
                 __functor = self: ff;

     

       67
       67
       -
                 overrideDerivation = throw "overrideDerivation not yet supported for functors";

     

       68
       68
       -
               }

     

       59
       59
       +
             if builtins.isAttrs ff then (ff // {

     

       60
       60
       +
               override = newArgs: makeOverridable f (overrideWith newArgs);

     

       61
       61
       +
               overrideDerivation = fdrv:

     

       62
       62
       +
                 makeOverridable (args: overrideDerivation (f args) fdrv) origArgs;

     

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

     

       64
       64
       +
                 makeOverridable (args: (f args).overrideAttrs fdrv) origArgs;

     

       65
       65
       +
             })

     

       66
       66
       +
             else if builtins.isFunction ff then {

     

       67
       67
       +
               override = newArgs: makeOverridable f (overrideWith newArgs);

     

       68
       68
       +
               __functor = self: ff;

     

       69
       69
       +
               overrideDerivation = throw "overrideDerivation not yet supported for functors";

     

       70
       70
       +
             }

     

       69
       71
        
             else ff;

     

       70
       72
        
       

     

       71
       73

pkgs/stdenv/generic/default.nix

···

       234
       234
        
                 outputs = outputs';

     

       235
       235
        
               } else { })))) (

     

       236
       236
        
             {

     

       237
       237
       +
               overrideAttrs = f: mkDerivation (attrs // (f attrs));

     

       237
       238
        
               # The meta attribute is passed in the resulting attribute set,

     

       238
       239
        
               # but it's not part of the actual derivation, i.e., it's not

     

       239
       240
        
               # passed to the builder and is not a dependency.  But since we