commit 150bf4fa3b548fe907fbcd5583eb3beb9a9feedd · pyrox.dev/nixpkgs

+4 -2

lib/generators.nix

···

       48
        
           else if isAttrs    v then err "attrsets" v

     

       49
        
           # functions can’t be printed of course

     

       50
        
           else if isFunction v then err "functions" v

     

       51
       -
           # let’s not talk about floats. There is no sensible `toString` for them.

     

       52
       -
           else if isFloat    v then err "floats" v

     

       0
        
       
     

       0
        
       
     

       53
        
           else err "this value is" (toString v);

     

       54
        
       

     

       55

···

       48
        
           else if isAttrs    v then err "attrsets" v

     

       49
        
           # functions can’t be printed of course

     

       50
        
           else if isFunction v then err "functions" v

     

       51
       +
           # Floats currently can't be converted to precise strings,

     

       52
       +
           # condition warning on nix version once this isn't a problem anymore

     

       53
       +
           # See https://github.com/NixOS/nix/pull/3480

     

       54
       +
           else if isFloat    v then libStr.floatToString v

     

       55
        
           else err "this value is" (toString v);

     

       56
        
       

     

       57

+16

lib/strings.nix

···

       612
        
         */

     

       613
        
         fixedWidthNumber = width: n: fixedWidthString width "0" (toString n);

     

       614
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       615
        
         /* Check whether a value can be coerced to a string */

     

       616
        
         isCoercibleToString = x:

     

       617
        
           builtins.elem (builtins.typeOf x) [ "path" "string" "null" "int" "float" "bool" ] ||

···

       612
        
         */

     

       613
        
         fixedWidthNumber = width: n: fixedWidthString width "0" (toString n);

     

       614
        
       

     

       615
       +
         /* Convert a float to a string, but emit a warning when precision is lost

     

       616
       +
            during the conversion

     

       617
       +
       

     

       618
       +
            Example:

     

       619
       +
              floatToString 0.000001

     

       620
       +
              => "0.000001"

     

       621
       +
              floatToString 0.0000001

     

       622
       +
              => trace: warning: Imprecise conversion from float to string 0.000000

     

       623
       +
                 "0.000000"

     

       624
       +
         */

     

       625
       +
         floatToString = float: let

     

       626
       +
           result = toString float;

     

       627
       +
           precise = float == builtins.fromJSON result;

     

       628
       +
         in if precise then result

     

       629
       +
           else lib.warn "Imprecise conversion from float to string ${result}" result;

     

       630
       +
       

     

       631
        
         /* Check whether a value can be coerced to a string */

     

       632
        
         isCoercibleToString = x:

     

       633
        
           builtins.elem (builtins.typeOf x) [ "path" "string" "null" "int" "float" "bool" ] ||

+179

nixos/doc/manual/development/settings-options.xml

···

       1
       +
       <section xmlns="http://docbook.org/ns/docbook"

     

       2
       +
               xmlns:xlink="http://www.w3.org/1999/xlink"

     

       3
       +
               xmlns:xi="http://www.w3.org/2001/XInclude"

     

       4
       +
               version="5.0"

     

       5
       +
               xml:id="sec-settings-options">

     

       6
       +
        <title>Options for Program Settings</title>

     

       7
       +
       

     

       8
       +
        <para>

     

       9
       +
          Many programs have configuration files where program-specific settings can be declared. File formats can be separated into two categories:

     

       10
       +
          <itemizedlist>

     

       11
       +
            <listitem>

     

       12
       +
              <para>

     

       13
       +
                Nix-representable ones: These can trivially be mapped to a subset of Nix syntax. E.g. JSON is an example, since its values like <literal>{"foo":{"bar":10}}</literal> can be mapped directly to Nix: <literal>{ foo = { bar = 10; }; }</literal>. Other examples are INI, YAML and TOML. The following section explains the convention for these settings.

     

       14
       +
              </para>

     

       15
       +
            </listitem>

     

       16
       +
            <listitem>

     

       17
       +
              <para>

     

       18
       +
                Non-nix-representable ones: These can't be trivially mapped to a subset of Nix syntax. Most generic programming languages are in this group, e.g. bash, since the statement <literal>if true; then echo hi; fi</literal> doesn't have a trivial representation in Nix.

     

       19
       +
              </para>

     

       20
       +
              <para>

     

       21
       +
                Currently there are no fixed conventions for these, but it is common to have a <literal>configFile</literal> option for setting the configuration file path directly. The default value of <literal>configFile</literal> can be an auto-generated file, with convenient options for controlling the contents. For example an option of type <literal>attrsOf str</literal> can be used for representing environment variables which generates a section like <literal>export FOO="foo"</literal>. Often it can also be useful to also include an <literal>extraConfig</literal> option of type <literal>lines</literal> to allow arbitrary text after the autogenerated part of the file.

     

       22
       +
              </para>

     

       23
       +
            </listitem>

     

       24
       +
          </itemizedlist>

     

       25
       +
        </para>

     

       26
       +
        <section xml:id="sec-settings-nix-representable">

     

       27
       +
          <title>Nix-representable Formats (JSON, YAML, TOML, INI, ...)</title>

     

       28
       +
          <para>

     

       29
       +
            By convention, formats like this are handled with a generic <literal>settings</literal> option, representing the full program configuration as a Nix value. The type of this option should represent the format. The most common formats have a predefined type and string generator already declared under <literal>pkgs.formats</literal>:

     

       30
       +
            <variablelist>

     

       31
       +
              <varlistentry>

     

       32
       +
                <term>

     

       33
       +
                  <varname>pkgs.formats.json</varname> { }

     

       34
       +
                </term>

     

       35
       +
                <listitem>

     

       36
       +
                  <para>

     

       37
       +
                    A function taking an empty attribute set (for future extensibility) and returning a set with JSON-specific attributes <varname>type</varname> and <varname>generate</varname> as specified <link linkend='pkgs-formats-result'>below</link>.

     

       38
       +
                  </para>

     

       39
       +
                </listitem>

     

       40
       +
              </varlistentry>

     

       41
       +
              <varlistentry>

     

       42
       +
                <term>

     

       43
       +
                  <varname>pkgs.formats.yaml</varname> { }

     

       44
       +
                </term>

     

       45
       +
                <listitem>

     

       46
       +
                  <para>

     

       47
       +
                    A function taking an empty attribute set (for future extensibility) and returning a set with YAML-specific attributes <varname>type</varname> and <varname>generate</varname> as specified <link linkend='pkgs-formats-result'>below</link>.

     

       48
       +
                  </para>

     

       49
       +
                </listitem>

     

       50
       +
              </varlistentry>

     

       51
       +
              <varlistentry>

     

       52
       +
                <term>

     

       53
       +
                  <varname>pkgs.formats.ini</varname> { <replaceable>listsAsDuplicateKeys</replaceable> ? false, ... }

     

       54
       +
                </term>

     

       55
       +
                <listitem>

     

       56
       +
                  <para>

     

       57
       +
                    A function taking an attribute set with values

     

       58
       +
                    <variablelist>

     

       59
       +
                      <varlistentry>

     

       60
       +
                        <term>

     

       61
       +
                          <varname>listsAsDuplicateKeys</varname>

     

       62
       +
                        </term>

     

       63
       +
                        <listitem>

     

       64
       +
                          <para>

     

       65
       +
                            A boolean for controlling whether list values can be used to represent duplicate INI keys

     

       66
       +
                          </para>

     

       67
       +
                        </listitem>

     

       68
       +
                      </varlistentry>

     

       69
       +
                    </variablelist>

     

       70
       +
                   It returns a set with INI-specific attributes <varname>type</varname> and <varname>generate</varname> as specified <link linkend='pkgs-formats-result'>below</link>.

     

       71
       +
                  </para>

     

       72
       +
                </listitem>

     

       73
       +
              </varlistentry>

     

       74
       +
              <varlistentry>

     

       75
       +
                <term>

     

       76
       +
                  <varname>pkgs.formats.toml</varname> { }

     

       77
       +
                </term>

     

       78
       +
                <listitem>

     

       79
       +
                  <para>

     

       80
       +
                    A function taking an empty attribute set (for future extensibility) and returning a set with TOML-specific attributes <varname>type</varname> and <varname>generate</varname> as specified <link linkend='pkgs-formats-result'>below</link>.

     

       81
       +
                  </para>

     

       82
       +
                </listitem>

     

       83
       +
              </varlistentry>

     

       84
       +
            </variablelist>

     

       85
       +
       

     

       86
       +
          </para>

     

       87
       +
          <para xml:id="pkgs-formats-result">

     

       88
       +
            These functions all return an attribute set with these values:

     

       89
       +
           <variablelist>

     

       90
       +
             <varlistentry>

     

       91
       +
               <term>

     

       92
       +
                 <varname>type</varname>

     

       93
       +
               </term>

     

       94
       +
               <listitem>

     

       95
       +
                 <para>

     

       96
       +
                   A module system type representing a value of the format

     

       97
       +
                 </para>

     

       98
       +
               </listitem>

     

       99
       +
             </varlistentry>

     

       100
       +
             <varlistentry>

     

       101
       +
               <term>

     

       102
       +
                 <varname>generate</varname> <replaceable>filename</replaceable> <replaceable>jsonValue</replaceable>

     

       103
       +
               </term>

     

       104
       +
               <listitem>

     

       105
       +
                 <para>

     

       106
       +
                  A function that can render a value of the format to a file. Returns a file path.

     

       107
       +
                  <note>

     

       108
       +
                   <para>

     

       109
       +
                    This function puts the value contents in the Nix store. So this should be avoided for secrets.

     

       110
       +
                   </para>

     

       111
       +
                  </note>

     

       112
       +
                 </para>

     

       113
       +
               </listitem>

     

       114
       +
             </varlistentry>

     

       115
       +
           </variablelist>

     

       116
       +
          </para>

     

       117
       +
          <example xml:id="ex-settings-nix-representable">

     

       118
       +
            <title>Module with conventional <literal>settings</literal> option</title>

     

       119
       +
            <para>

     

       120
       +
              The following shows a module for an example program that uses a JSON configuration file. It demonstrates how above values can be used, along with some other related best practices. See the comments for explanations.

     

       121
       +
            </para>

     

       122
       +
       <programlisting>

     

       123
       +
       { options, config, lib, pkgs, ... }:

     

       124
       +
       let

     

       125
       +
         cfg = config.services.foo;

     

       126
       +
         # Define the settings format used for this program

     

       127
       +
         settingsFormat = pkgs.formats.json {};

     

       128
       +
       in {

     

       129
       +
       

     

       130
       +
         options.services.foo = {

     

       131
       +
           enable = lib.mkEnableOption "foo service";

     

       132
       +
       

     

       133
       +
           settings = lib.mkOption {

     

       134
       +
             # Setting this type allows for correct merging behavior

     

       135
       +
             type = settingsFormat.type;

     

       136
       +
             default = {};

     

       137
       +
             description = ''

     

       138
       +
               Configuration for foo, see

     

       139
       +
               &lt;link xlink:href="https://example.com/docs/foo"/&gt;

     

       140
       +
               for supported values.

     

       141
       +
             '';

     

       142
       +
           };

     

       143
       +
         };

     

       144
       +
       

     

       145
       +
         config = lib.mkIf cfg.enable {

     

       146
       +
           # We can assign some default settings here to make the service work by just

     

       147
       +
           # enabling it. We use `mkDefault` for values that can be changed without

     

       148
       +
           # problems

     

       149
       +
           services.foo.settings = {

     

       150
       +
             # Fails at runtime without any value set

     

       151
       +
             log_level = lib.mkDefault "WARN";

     

       152
       +
       

     

       153
       +
             # We assume systemd's `StateDirectory` is used, so we require this value,

     

       154
       +
             # therefore no mkDefault

     

       155
       +
             data_path = "/var/lib/foo";

     

       156
       +
       

     

       157
       +
             # Since we use this to create a user we need to know the default value at

     

       158
       +
             # eval time

     

       159
       +
             user = lib.mkDefault "foo";

     

       160
       +
           };

     

       161
       +
       

     

       162
       +
           environment.etc."foo.json".source =

     

       163
       +
             # The formats generator function takes a filename and the Nix value

     

       164
       +
             # representing the format value and produces a filepath with that value

     

       165
       +
             # rendered in the format

     

       166
       +
             settingsFormat.generate "foo-config.json" cfg.settings;

     

       167
       +
       

     

       168
       +
           # We know that the `user` attribute exists because we set a default value

     

       169
       +
           # for it above, allowing us to use it without worries here

     

       170
       +
           users.users.${cfg.settings.user} = {}

     

       171
       +
       

     

       172
       +
           # ...

     

       173
       +
         };

     

       174
       +
       }

     

       175
       +
       </programlisting>

     

       176
       +
          </example>

     

       177
       +
        </section>

     

       178
       +
       

     

       179
       +
       </section>

nixos/doc/manual/development/writing-modules.xml

···

       183
        
        <xi:include href="meta-attributes.xml" />

     

       184
        
        <xi:include href="importing-modules.xml" />

     

       185
        
        <xi:include href="replace-modules.xml" />

     

       0
        
       
     

       186
        
       </chapter>

···

       183
        
        <xi:include href="meta-attributes.xml" />

     

       184
        
        <xi:include href="importing-modules.xml" />

     

       185
        
        <xi:include href="replace-modules.xml" />

     

       186
       +
        <xi:include href="settings-options.xml" />

     

       187
        
       </chapter>

+11

pkgs/pkgs-lib/default.nix

···

       1
       +
       # pkgs-lib is for functions and values that can't be in lib because

     

       2
       +
       # they depend on some packages. This notably is *not* for supporting package

     

       3
       +
       # building, instead pkgs/build-support is the place for that.

     

       4
       +
       { lib, pkgs }: {

     

       5
       +
         # setting format types and generators. These do not fit in lib/types.nix,

     

       6
       +
         # because they depend on pkgs for rendering some formats

     

       7
       +
         formats = import ./formats.nix {

     

       8
       +
           inherit lib pkgs;

     

       9
       +
         };

     

       10
       +
       }

     

       11
       +

+109

pkgs/pkgs-lib/formats.nix

···

       1
       +
       { lib, pkgs }:

     

       2
       +
       rec {

     

       3
       +
       

     

       4
       +
         /*

     

       5
       +
       

     

       6
       +
         Every following entry represents a format for program configuration files

     

       7
       +
         used for `settings`-style options (see https://github.com/NixOS/rfcs/pull/42).

     

       8
       +
         Each entry should look as follows:

     

       9
       +
       

     

       10
       +
           <format> = <parameters>: {

     

       11
       +
             #        ^^ Parameters for controlling the format

     

       12
       +
       

     

       13
       +
             # The module system type most suitable for representing such a format

     

       14
       +
             # The description needs to be overwritten for recursive types

     

       15
       +
             type = ...;

     

       16
       +
       

     

       17
       +
             # generate :: Name -> Value -> Path

     

       18
       +
             # A function for generating a file with a value of such a type

     

       19
       +
             generate = ...;

     

       20
       +
       

     

       21
       +
           });

     

       22
       +
         */

     

       23
       +
       

     

       24
       +
       

     

       25
       +
         json = {}: {

     

       26
       +
       

     

       27
       +
           type = with lib.types; let

     

       28
       +
             valueType = nullOr (oneOf [

     

       29
       +
               bool

     

       30
       +
               int

     

       31
       +
               float

     

       32
       +
               str

     

       33
       +
               (attrsOf valueType)

     

       34
       +
               (listOf valueType)

     

       35
       +
             ]) // {

     

       36
       +
               description = "JSON value";

     

       37
       +
             };

     

       38
       +
           in valueType;

     

       39
       +
       

     

       40
       +
           generate = name: value: pkgs.runCommandNoCC name {

     

       41
       +
             nativeBuildInputs = [ pkgs.jq ];

     

       42
       +
             value = builtins.toJSON value;

     

       43
       +
             passAsFile = [ "value" ];

     

       44
       +
           } ''

     

       45
       +
             jq . "$valuePath"> $out

     

       46
       +
           '';

     

       47
       +
       

     

       48
       +
         };

     

       49
       +
       

     

       50
       +
         # YAML has been a strict superset of JSON since 1.2

     

       51
       +
         yaml = {}:

     

       52
       +
           let jsonSet = json {};

     

       53
       +
           in jsonSet // {

     

       54
       +
             type = jsonSet.type // {

     

       55
       +
               description = "YAML value";

     

       56
       +
             };

     

       57
       +
           };

     

       58
       +
       

     

       59
       +
         ini = { listsAsDuplicateKeys ? false, ... }@args: {

     

       60
       +
       

     

       61
       +
           type = with lib.types; let

     

       62
       +
       

     

       63
       +
             singleIniAtom = nullOr (oneOf [

     

       64
       +
               bool

     

       65
       +
               int

     

       66
       +
               float

     

       67
       +
               str

     

       68
       +
             ]) // {

     

       69
       +
               description = "INI atom (null, bool, int, float or string)";

     

       70
       +
             };

     

       71
       +
       

     

       72
       +
             iniAtom =

     

       73
       +
               if listsAsDuplicateKeys then

     

       74
       +
                 coercedTo singleIniAtom lib.singleton (listOf singleIniAtom) // {

     

       75
       +
                   description = singleIniAtom.description + " or a list of them for duplicate keys";

     

       76
       +
                 }

     

       77
       +
               else

     

       78
       +
                 singleIniAtom;

     

       79
       +
       

     

       80
       +
           in attrsOf (attrsOf iniAtom);

     

       81
       +
       

     

       82
       +
           generate = name: value: pkgs.writeText name (lib.generators.toINI args value);

     

       83
       +
       

     

       84
       +
         };

     

       85
       +
       

     

       86
       +
         toml = {}: json {} // {

     

       87
       +
           type = with lib.types; let

     

       88
       +
             valueType = oneOf [

     

       89
       +
               bool

     

       90
       +
               int

     

       91
       +
               float

     

       92
       +
               str

     

       93
       +
               (attrsOf valueType)

     

       94
       +
               (listOf valueType)

     

       95
       +
             ] // {

     

       96
       +
               description = "TOML value";

     

       97
       +
             };

     

       98
       +
           in valueType;

     

       99
       +
       

     

       100
       +
           generate = name: value: pkgs.runCommandNoCC name {

     

       101
       +
             nativeBuildInputs = [ pkgs.remarshal ];

     

       102
       +
             value = builtins.toJSON value;

     

       103
       +
             passAsFile = [ "value" ];

     

       104
       +
           } ''

     

       105
       +
             json2toml "$valuePath" "$out"

     

       106
       +
           '';

     

       107
       +
       

     

       108
       +
         };

     

       109
       +
       }

pkgs/pkgs-lib/tests/default.nix

···

       1
       +
       # Call nix-build on this file to run all tests in this directory

     

       2
       +
       { pkgs ? import ../../.. {} }:

     

       3
       +
       let

     

       4
       +
         formats = import ./formats.nix { inherit pkgs; };

     

       5
       +
       in pkgs.linkFarm "nixpkgs-pkgs-lib-tests" [

     

       6
       +
         { name = "formats"; path = import ./formats.nix { inherit pkgs; }; }

     

       7
       +
       ]

+157

pkgs/pkgs-lib/tests/formats.nix

···

       1
       +
       { pkgs }:

     

       2
       +
       let

     

       3
       +
         inherit (pkgs) lib formats;

     

       4
       +
       in

     

       5
       +
       with lib;

     

       6
       +
       let

     

       7
       +
       

     

       8
       +
         evalFormat = format: args: def:

     

       9
       +
           let

     

       10
       +
             formatSet = format args;

     

       11
       +
             config = formatSet.type.merge [] (imap1 (n: def: {

     

       12
       +
               value = def;

     

       13
       +
               file = "def${toString n}";

     

       14
       +
             }) [ def ]);

     

       15
       +
           in formatSet.generate "test-format-file" config;

     

       16
       +
       

     

       17
       +
         runBuildTest = name: { drv, expected }: pkgs.runCommandNoCC name {} ''

     

       18
       +
           if diff ${drv} ${builtins.toFile "expected" expected}; then

     

       19
       +
             touch $out

     

       20
       +
           else

     

       21
       +
             echo "Got: $(cat ${drv})"

     

       22
       +
             echo "Should be: ${expected}"

     

       23
       +
             exit 1

     

       24
       +
           fi

     

       25
       +
         '';

     

       26
       +
       

     

       27
       +
         runBuildTests = tests: pkgs.linkFarm "nixpkgs-pkgs-lib-format-tests" (mapAttrsToList (name: value: { inherit name; path = runBuildTest name value; }) (filterAttrs (name: value: value != null) tests));

     

       28
       +
       

     

       29
       +
       in runBuildTests {

     

       30
       +
       

     

       31
       +
         testJsonAtoms = {

     

       32
       +
           drv = evalFormat formats.json {} {

     

       33
       +
             null = null;

     

       34
       +
             false = false;

     

       35
       +
             true = true;

     

       36
       +
             int = 10;

     

       37
       +
             float = 3.141;

     

       38
       +
             str = "foo";

     

       39
       +
             attrs.foo = null;

     

       40
       +
             list = [ null null ];

     

       41
       +
           };

     

       42
       +
           expected = ''

     

       43
       +
             {

     

       44
       +
               "attrs": {

     

       45
       +
                 "foo": null

     

       46
       +
               },

     

       47
       +
               "false": false,

     

       48
       +
               "float": 3.141,

     

       49
       +
               "int": 10,

     

       50
       +
               "list": [

     

       51
       +
                 null,

     

       52
       +
                 null

     

       53
       +
               ],

     

       54
       +
               "null": null,

     

       55
       +
               "str": "foo",

     

       56
       +
               "true": true

     

       57
       +
             }

     

       58
       +
           '';

     

       59
       +
         };

     

       60
       +
       

     

       61
       +
         testYamlAtoms = {

     

       62
       +
           drv = evalFormat formats.yaml {} {

     

       63
       +
             null = null;

     

       64
       +
             false = false;

     

       65
       +
             true = true;

     

       66
       +
             float = 3.141;

     

       67
       +
             str = "foo";

     

       68
       +
             attrs.foo = null;

     

       69
       +
             list = [ null null ];

     

       70
       +
           };

     

       71
       +
           expected = ''

     

       72
       +
             {

     

       73
       +
               "attrs": {

     

       74
       +
                 "foo": null

     

       75
       +
               },

     

       76
       +
               "false": false,

     

       77
       +
               "float": 3.141,

     

       78
       +
               "list": [

     

       79
       +
                 null,

     

       80
       +
                 null

     

       81
       +
               ],

     

       82
       +
               "null": null,

     

       83
       +
               "str": "foo",

     

       84
       +
               "true": true

     

       85
       +
             }

     

       86
       +
           '';

     

       87
       +
         };

     

       88
       +
       

     

       89
       +
         testIniAtoms = {

     

       90
       +
           drv = evalFormat formats.ini {} {

     

       91
       +
             foo = {

     

       92
       +
               bool = true;

     

       93
       +
               int = 10;

     

       94
       +
               float = 3.141;

     

       95
       +
               str = "string";

     

       96
       +
             };

     

       97
       +
           };

     

       98
       +
           expected = ''

     

       99
       +
             [foo]

     

       100
       +
             bool=true

     

       101
       +
             float=3.141000

     

       102
       +
             int=10

     

       103
       +
             str=string

     

       104
       +
           '';

     

       105
       +
         };

     

       106
       +
       

     

       107
       +
         testIniDuplicateKeys = {

     

       108
       +
           drv = evalFormat formats.ini { listsAsDuplicateKeys = true; } {

     

       109
       +
             foo = {

     

       110
       +
               bar = [ null true "test" 1.2 10 ];

     

       111
       +
               baz = false;

     

       112
       +
               qux = "qux";

     

       113
       +
             };

     

       114
       +
           };

     

       115
       +
           expected = ''

     

       116
       +
             [foo]

     

       117
       +
             bar=null

     

       118
       +
             bar=true

     

       119
       +
             bar=test

     

       120
       +
             bar=1.200000

     

       121
       +
             bar=10

     

       122
       +
             baz=false

     

       123
       +
             qux=qux

     

       124
       +
           '';

     

       125
       +
         };

     

       126
       +
       

     

       127
       +
         testTomlAtoms = {

     

       128
       +
           drv = evalFormat formats.toml {} {

     

       129
       +
             false = false;

     

       130
       +
             true = true;

     

       131
       +
             int = 10;

     

       132
       +
             float = 3.141;

     

       133
       +
             str = "foo";

     

       134
       +
             attrs.foo = "foo";

     

       135
       +
             list = [ 1 2 ];

     

       136
       +
             level1.level2.level3.level4 = "deep";

     

       137
       +
           };

     

       138
       +
           expected = ''

     

       139
       +
             false = false

     

       140
       +
             float = 3.141

     

       141
       +
             int = 10

     

       142
       +
             list = [1, 2]

     

       143
       +
             str = "foo"

     

       144
       +
             true = true

     

       145
       +
       

     

       146
       +
             [attrs]

     

       147
       +
             foo = "foo"

     

       148
       +
       

     

       149
       +
             [level1]

     

       150
       +
       

     

       151
       +
             [level1.level2]

     

       152
       +
       

     

       153
       +
             [level1.level2.level3]

     

       154
       +
             level4 = "deep"

     

       155
       +
           '';

     

       156
       +
         };

     

       157
       +
       }

pkgs/top-level/all-packages.nix

···

       525
        
         #package writers

     

       526
        
         writers = callPackage ../build-support/writers {};

     

       527
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       528
        
         ### TOOLS

     

       529
        
       

     

       530
        
         _0x0 = callPackage ../tools/misc/0x0 { };

···

       525
        
         #package writers

     

       526
        
         writers = callPackage ../build-support/writers {};

     

       527
        
       

     

       528
       +
         # lib functions depending on pkgs

     

       529
       +
         inherit (import ../pkgs-lib { inherit lib pkgs; }) formats;

     

       530
       +
       

     

       531
        
         ### TOOLS

     

       532
        
       

     

       533
        
         _0x0 = callPackage ../tools/misc/0x0 { };

pkgs/top-level/release.nix

···

       34
        
       

     

       35
        
             manual = import ../../doc { inherit pkgs nixpkgs; };

     

       36
        
             lib-tests = import ../../lib/tests/release.nix { inherit pkgs; };

     

       0
        
       
     

       37
        
       

     

       38
        
             darwin-tested = if supportDarwin then pkgs.releaseTools.aggregate

     

       39
        
               { name = "nixpkgs-darwin-${jobs.tarball.version}";

     
···

       91
        
                   [ jobs.tarball

     

       92
        
                     jobs.manual

     

       93
        
                     jobs.lib-tests

     

       0
        
       
     

       94
        
                     jobs.stdenv.x86_64-linux

     

       95
        
                     jobs.linux.x86_64-linux

     

       96
        
                     jobs.pandoc.x86_64-linux

···

       34
        
       

     

       35
        
             manual = import ../../doc { inherit pkgs nixpkgs; };

     

       36
        
             lib-tests = import ../../lib/tests/release.nix { inherit pkgs; };

     

       37
       +
             pkgs-lib-tests = import ../pkgs-lib/tests { inherit pkgs; };

     

       38
        
       

     

       39
        
             darwin-tested = if supportDarwin then pkgs.releaseTools.aggregate

     

       40
        
               { name = "nixpkgs-darwin-${jobs.tarball.version}";

     
···

       92
        
                   [ jobs.tarball

     

       93
        
                     jobs.manual

     

       94
        
                     jobs.lib-tests

     

       95
       +
                     jobs.pkgs-lib-tests

     

       96
        
                     jobs.stdenv.x86_64-linux

     

       97
        
                     jobs.linux.x86_64-linux

     

       98
        
                     jobs.pandoc.x86_64-linux