commit fc614c37c653637e5475a0b0a987489b4d1f351d · pyrox.dev/nixpkgs

+1 -1

lib/options.nix

···

       177
       177
        
               docOption = rec {

     

       178
       178
        
                 loc = opt.loc;

     

       179
       179
        
                 name = showOption opt.loc;

     

       180
       180
       -
                 description = opt.description or (lib.warn "Option `${name}' has no description." "This option has no description.");

     

       180
       180
       +
                 description = opt.description or null;

     

       181
       181
        
                 declarations = filter (x: x != unknownModule) opt.declarations;

     

       182
       182
        
                 internal = opt.internal or false;

     

       183
       183
        
                 visible =

+4 -4

nixos/doc/manual/default.nix

···

       1
       1
       -
       { pkgs, options, config, version, revision, extraSources ? [] }:

     

       1
       1
       +
       { pkgs, options, config, version, revision, extraSources ? [], baseOptionsJSON ? null, prefix ? ../../.. }:

     

       2
       2
        
       

     

       3
       3
        
       with pkgs;

     

       4
       4
        
       

     
···

       11
       11
        
         #

     

       12
       12
        
         # E.g. if some `options` came from modules in ${pkgs.customModules}/nix,

     

       13
       13
        
         # you'd need to include `extraSources = [ pkgs.customModules ]`

     

       14
       14
       -
         prefixesToStrip = map (p: "${toString p}/") ([ ../../.. ] ++ extraSources);

     

       14
       14
       +
         prefixesToStrip = map (p: "${toString p}/") ([ prefix ] ++ extraSources);

     

       15
       15
        
         stripAnyPrefixes = lib.flip (lib.foldr lib.removePrefix) prefixesToStrip;

     

       16
       16
        
       

     

       17
       17
        
         optionsDoc = buildPackages.nixosOptionsDoc {

     

       18
       18
       -
           inherit options revision;

     

       18
       18
       +
           inherit options revision baseOptionsJSON;

     

       19
       19
        
           transformOptions = opt: opt // {

     

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

     

       21
       21
        
             declarations = map stripAnyPrefixes opt.declarations;

     
···

       161
       161
        
       in rec {

     

       162
       162
        
         inherit generatedSources;

     

       163
       163
        
       

     

       164
       164
       -
         inherit (optionsDoc) optionsJSON optionsDocBook;

     

       164
       164
       +
         inherit (optionsDoc) optionsJSON optionsNix optionsDocBook;

     

       165
       165
        
       

     

       166
       166
        
         # Generate the NixOS manual.

     

       167
       167
        
         manualHTML = runCommand "nixos-manual-html"

+27 -1

nixos/doc/manual/development/meta-attributes.section.md

···

       5
       5
        
       special module.

     

       6
       6
        
       

     

       7
       7
        
       `meta` is a top level attribute like `options` and `config`. Available

     

       8
       8
       -
       meta-attributes are `maintainers` and `doc`.

     

       8
       8
       +
       meta-attributes are `maintainers`, `doc`, and `buildDocsInSandbox`.

     

       9
       9
        
       

     

       10
       10
        
       Each of the meta-attributes must be defined at most once per module

     

       11
       11
        
       file.

     
···

       24
       24
        
         meta = {

     

       25
       25
        
           maintainers = with lib.maintainers; [ ericsagnes ];

     

       26
       26
        
           doc = ./default.xml;

     

       27
       27
       +
           buildDocsInSandbox = true;

     

       27
       28
        
         };

     

       28
       29
        
       }

     

       29
       30
        
       ```

     
···

       38
       39
        
           ```ShellSession

     

       39
       40
        
           $ nix-build nixos/release.nix -A manual.x86_64-linux

     

       40
       41
        
           ```

     

       42
       42
       +
       

     

       43
       43
       +
       -  `buildDocsInSandbox` indicates whether the option documentation for the

     

       44
       44
       +
          module can be built in a derivation sandbox. This option is currently only

     

       45
       45
       +
          honored for modules shipped by nixpkgs. User modules and modules taken from

     

       46
       46
       +
          `NIXOS_EXTRA_MODULE_PATH` are always built outside of the sandbox, as has

     

       47
       47
       +
          been the case in previous releases.

     

       48
       48
       +
       

     

       49
       49
       +
          Building NixOS option documentation in a sandbox allows caching of the built

     

       50
       50
       +
          documentation, which greatly decreases the amount of time needed to evaluate

     

       51
       51
       +
          a system configuration that has NixOS documentation enabled. The sandbox also

     

       52
       52
       +
          restricts which attributes may be referenced by documentation attributes

     

       53
       53
       +
          (such as option descriptions) to the `options` and `lib` module arguments and

     

       54
       54
       +
          the `pkgs.formats` attribute of the `pkgs` argument, `config` and the rest of

     

       55
       55
       +
          `pkgs` are disallowed and will cause doc build failures when used. This

     

       56
       56
       +
          restriction is necessary because we cannot reproduce the full nixpkgs

     

       57
       57
       +
          instantiation with configuration and overlays from a system configuration

     

       58
       58
       +
          inside the sandbox. The `options` argument only includes options of modules

     

       59
       59
       +
          that are also built inside the sandbox, referencing an option of a module

     

       60
       60
       +
          that isn't built in the sandbox is also forbidden.

     

       61
       61
       +
       

     

       62
       62
       +
          The default is `true` and should usually not be changed; set it to `false`

     

       63
       63
       +
          only if the module requires access to `pkgs` in its documentation (e.g.

     

       64
       64
       +
          because it loads information from a linked package to build an option type)

     

       65
       65
       +
          or if its documentation depends on other modules that also aren't sandboxed

     

       66
       66
       +
          (e.g. by using types defined in the other module).

+42 -2

nixos/doc/manual/from_md/development/meta-attributes.section.xml

···

       8
       8
        
         <para>

     

       9
       9
        
           <literal>meta</literal> is a top level attribute like

     

       10
       10
        
           <literal>options</literal> and <literal>config</literal>. Available

     

       11
       11
       -
           meta-attributes are <literal>maintainers</literal> and

     

       12
       12
       -
           <literal>doc</literal>.

     

       11
       11
       +
           meta-attributes are <literal>maintainers</literal>,

     

       12
       12
       +
           <literal>doc</literal>, and <literal>buildDocsInSandbox</literal>.

     

       13
       13
        
         </para>

     

       14
       14
        
         <para>

     

       15
       15
        
           Each of the meta-attributes must be defined at most once per module

     
···

       29
       29
        
         meta = {

     

       30
       30
        
           maintainers = with lib.maintainers; [ ericsagnes ];

     

       31
       31
        
           doc = ./default.xml;

     

       32
       32
       +
           buildDocsInSandbox = true;

     

       32
       33
        
         };

     

       33
       34
        
       }

     

       34
       35
        
       </programlisting>

     
···

       50
       51
        
             <programlisting>

     

       51
       52
        
       $ nix-build nixos/release.nix -A manual.x86_64-linux

     

       52
       53
        
       </programlisting>

     

       54
       54
       +
           </listitem>

     

       55
       55
       +
           <listitem>

     

       56
       56
       +
             <para>

     

       57
       57
       +
               <literal>buildDocsInSandbox</literal> indicates whether the

     

       58
       58
       +
               option documentation for the module can be built in a derivation

     

       59
       59
       +
               sandbox. This option is currently only honored for modules

     

       60
       60
       +
               shipped by nixpkgs. User modules and modules taken from

     

       61
       61
       +
               <literal>NIXOS_EXTRA_MODULE_PATH</literal> are always built

     

       62
       62
       +
               outside of the sandbox, as has been the case in previous

     

       63
       63
       +
               releases.

     

       64
       64
       +
             </para>

     

       65
       65
       +
             <para>

     

       66
       66
       +
               Building NixOS option documentation in a sandbox allows caching

     

       67
       67
       +
               of the built documentation, which greatly decreases the amount

     

       68
       68
       +
               of time needed to evaluate a system configuration that has NixOS

     

       69
       69
       +
               documentation enabled. The sandbox also restricts which

     

       70
       70
       +
               attributes may be referenced by documentation attributes (such

     

       71
       71
       +
               as option descriptions) to the <literal>options</literal> and

     

       72
       72
       +
               <literal>lib</literal> module arguments and the

     

       73
       73
       +
               <literal>pkgs.formats</literal> attribute of the

     

       74
       74
       +
               <literal>pkgs</literal> argument, <literal>config</literal> and

     

       75
       75
       +
               the rest of <literal>pkgs</literal> are disallowed and will

     

       76
       76
       +
               cause doc build failures when used. This restriction is

     

       77
       77
       +
               necessary because we cannot reproduce the full nixpkgs

     

       78
       78
       +
               instantiation with configuration and overlays from a system

     

       79
       79
       +
               configuration inside the sandbox. The <literal>options</literal>

     

       80
       80
       +
               argument only includes options of modules that are also built

     

       81
       81
       +
               inside the sandbox, referencing an option of a module that isn’t

     

       82
       82
       +
               built in the sandbox is also forbidden.

     

       83
       83
       +
             </para>

     

       84
       84
       +
             <para>

     

       85
       85
       +
               The default is <literal>true</literal> and should usually not be

     

       86
       86
       +
               changed; set it to <literal>false</literal> only if the module

     

       87
       87
       +
               requires access to <literal>pkgs</literal> in its documentation

     

       88
       88
       +
               (e.g. because it loads information from a linked package to

     

       89
       89
       +
               build an option type) or if its documentation depends on other

     

       90
       90
       +
               modules that also aren’t sandboxed (e.g. by using types defined

     

       91
       91
       +
               in the other module).

     

       92
       92
       +
             </para>

     

       53
       93
        
           </listitem>

     

       54
       94
        
         </itemizedlist>

     

       55
       95
        
       </section>

+53

nixos/lib/eval-cacheable-options.nix

···

       1
       1
       +
       { libPath

     

       2
       2
       +
       , pkgsLibPath

     

       3
       3
       +
       , nixosPath

     

       4
       4
       +
       , modules

     

       5
       5
       +
       , stateVersion

     

       6
       6
       +
       , release

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       let

     

       10
       10
       +
         lib = import libPath;

     

       11
       11
       +
         modulesPath = "${nixosPath}/modules";

     

       12
       12
       +
         # dummy pkgs set that contains no packages, only `pkgs.lib` from the full set.

     

       13
       13
       +
         # not having `pkgs.lib` causes all users of `pkgs.formats` to fail.

     

       14
       14
       +
         pkgs = import pkgsLibPath {

     

       15
       15
       +
           inherit lib;

     

       16
       16
       +
           pkgs = null;

     

       17
       17
       +
         };

     

       18
       18
       +
         utils = import "${nixosPath}/lib/utils.nix" {

     

       19
       19
       +
           inherit config lib;

     

       20
       20
       +
           pkgs = null;

     

       21
       21
       +
         };

     

       22
       22
       +
         # this is used both as a module and as specialArgs.

     

       23
       23
       +
         # as a module it sets the _module special values, as specialArgs it makes `config`

     

       24
       24
       +
         # unusable. this causes documentation attributes depending on `config` to fail.

     

       25
       25
       +
         config = {

     

       26
       26
       +
           _module.check = false;

     

       27
       27
       +
           _module.args = {};

     

       28
       28
       +
           system.stateVersion = stateVersion;

     

       29
       29
       +
         };

     

       30
       30
       +
         eval = lib.evalModules {

     

       31
       31
       +
           modules = (map (m: "${modulesPath}/${m}") modules) ++ [

     

       32
       32
       +
             config

     

       33
       33
       +
           ];

     

       34
       34
       +
           specialArgs = {

     

       35
       35
       +
             inherit config pkgs utils;

     

       36
       36
       +
           };

     

       37
       37
       +
         };

     

       38
       38
       +
         docs = import "${nixosPath}/doc/manual" {

     

       39
       39
       +
           pkgs = pkgs // {

     

       40
       40
       +
             inherit lib;

     

       41
       41
       +
             # duplicate of the declaration in all-packages.nix

     

       42
       42
       +
             buildPackages.nixosOptionsDoc = attrs:

     

       43
       43
       +
               (import "${nixosPath}/lib/make-options-doc")

     

       44
       44
       +
                 ({ inherit pkgs lib; } // attrs);

     

       45
       45
       +
           };

     

       46
       46
       +
           config = config.config;

     

       47
       47
       +
           options = eval.options;

     

       48
       48
       +
           version = release;

     

       49
       49
       +
           revision = "release-${release}";

     

       50
       50
       +
           prefix = modulesPath;

     

       51
       51
       +
         };

     

       52
       52
       +
       in

     

       53
       53
       +
         docs.optionsNix

+15 -1

nixos/lib/make-options-doc/default.nix

···

       21
       21
        
       , options

     

       22
       22
        
       , transformOptions ? lib.id  # function for additional tranformations of the options

     

       23
       23
        
       , revision ? "" # Specify revision for the options

     

       24
       24
       +
       # a set of options the docs we are generating will be merged into, as if by recursiveUpdate.

     

       25
       25
       +
       # used to split the options doc build into a static part (nixos/modules) and a dynamic part

     

       26
       26
       +
       # (non-nixos modules imported via configuration.nix, other module sources).

     

       27
       27
       +
       , baseOptionsJSON ? null

     

       24
       28
        
       }:

     

       25
       29
        
       

     

       26
       30
        
       let

     
···

       99
       103
        
         optionsJSON = pkgs.runCommand "options.json"

     

       100
       104
        
           { meta.description = "List of NixOS options in JSON format";

     

       101
       105
        
             buildInputs = [ pkgs.brotli ];

     

       106
       106
       +
             options = builtins.toFile "options.json"

     

       107
       107
       +
               (builtins.unsafeDiscardStringContext (builtins.toJSON optionsNix));

     

       102
       108
        
           }

     

       103
       109
        
           ''

     

       104
       110
        
             # Export list of options in different format.

     

       105
       111
        
             dst=$out/share/doc/nixos

     

       106
       112
        
             mkdir -p $dst

     

       107
       113
        
       

     

       108
       108
       -
             cp ${builtins.toFile "options.json" (builtins.unsafeDiscardStringContext (builtins.toJSON optionsNix))} $dst/options.json

     

       114
       114
       +
             ${

     

       115
       115
       +
               if baseOptionsJSON == null

     

       116
       116
       +
                 then "cp $options $dst/options.json"

     

       117
       117
       +
                 else ''

     

       118
       118
       +
                   ${pkgs.python3Minimal}/bin/python ${./mergeJSON.py} \

     

       119
       119
       +
                     ${baseOptionsJSON} $options \

     

       120
       120
       +
                     > $dst/options.json

     

       121
       121
       +
                 ''

     

       122
       122
       +
             }

     

       109
       123
        
       

     

       110
       124
        
             brotli -9 < $dst/options.json > $dst/options.json.br

     

       111
       125

+71

nixos/lib/make-options-doc/mergeJSON.py

···

       1
       1
       +
       import collections

     

       2
       2
       +
       import json

     

       3
       3
       +
       import sys

     

       4
       4
       +
       

     

       5
       5
       +
       class Key:

     

       6
       6
       +
           def __init__(self, path):

     

       7
       7
       +
               self.path = path

     

       8
       8
       +
           def __hash__(self):

     

       9
       9
       +
               result = 0

     

       10
       10
       +
               for id in self.path:

     

       11
       11
       +
                   result ^= hash(id)

     

       12
       12
       +
               return result

     

       13
       13
       +
           def __eq__(self, other):

     

       14
       14
       +
               return type(self) is type(other) and self.path == other.path

     

       15
       15
       +
       

     

       16
       16
       +
       Option = collections.namedtuple('Option', ['name', 'value'])

     

       17
       17
       +
       

     

       18
       18
       +
       # pivot a dict of options keyed by their display name to a dict keyed by their path

     

       19
       19
       +
       def pivot(options):

     

       20
       20
       +
           result = dict()

     

       21
       21
       +
           for (name, opt) in options.items():

     

       22
       22
       +
               result[Key(opt['loc'])] = Option(name, opt)

     

       23
       23
       +
           return result

     

       24
       24
       +
       

     

       25
       25
       +
       # pivot back to indexed-by-full-name

     

       26
       26
       +
       # like the docbook build we'll just fail if multiple options with differing locs

     

       27
       27
       +
       # render to the same option name.

     

       28
       28
       +
       def unpivot(options):

     

       29
       29
       +
           result = dict()

     

       30
       30
       +
           for (key, opt) in options.items():

     

       31
       31
       +
               if opt.name in result:

     

       32
       32
       +
                   raise RuntimeError(

     

       33
       33
       +
                       'multiple options with colliding ids found',

     

       34
       34
       +
                       opt.name,

     

       35
       35
       +
                       result[opt.name]['loc'],

     

       36
       36
       +
                       opt.value['loc'],

     

       37
       37
       +
                   )

     

       38
       38
       +
               result[opt.name] = opt.value

     

       39
       39
       +
           return result

     

       40
       40
       +
       

     

       41
       41
       +
       options = pivot(json.load(open(sys.argv[1], 'r')))

     

       42
       42
       +
       overrides = pivot(json.load(open(sys.argv[2], 'r')))

     

       43
       43
       +
       

     

       44
       44
       +
       # fix up declaration paths in lazy options, since we don't eval them from a full nixpkgs dir

     

       45
       45
       +
       for (k, v) in options.items():

     

       46
       46
       +
           v.value['declarations'] = list(map(lambda s: f'nixos/modules/{s}', v.value['declarations']))

     

       47
       47
       +
       

     

       48
       48
       +
       # merge both descriptions

     

       49
       49
       +
       for (k, v) in overrides.items():

     

       50
       50
       +
           cur = options.setdefault(k, v).value

     

       51
       51
       +
           for (ok, ov) in v.value.items():

     

       52
       52
       +
               if ok == 'declarations':

     

       53
       53
       +
                   decls = cur[ok]

     

       54
       54
       +
                   for d in ov:

     

       55
       55
       +
                       if d not in decls:

     

       56
       56
       +
                           decls += [d]

     

       57
       57
       +
               elif ok == "type":

     

       58
       58
       +
                   # ignore types of placeholder options

     

       59
       59
       +
                   if ov != "_unspecified" or cur[ok] == "_unspecified":

     

       60
       60
       +
                       cur[ok] = ov

     

       61
       61
       +
               elif ov is not None or cur.get(ok, None) is None:

     

       62
       62
       +
                   cur[ok] = ov

     

       63
       63
       +
       

     

       64
       64
       +
       # check that every option has a description

     

       65
       65
       +
       # TODO: nixos-rebuild with flakes may hide the warning, maybe turn on -L by default for those?

     

       66
       66
       +
       for (k, v) in options.items():

     

       67
       67
       +
           if v.value.get('description', None) is None:

     

       68
       68
       +
               print(f"\x1b[1;31mwarning: option {v.name} has no description\x1b[0m", file=sys.stderr)

     

       69
       69
       +
               v.value['description'] = "This option has no description."

     

       70
       70
       +
       

     

       71
       71
       +
       json.dump(unpivot(options), fp=sys.stdout)

+3

nixos/modules/config/qt5.nix

···

       101
       101
        
           environment.systemPackages = packages;

     

       102
       102
        
       

     

       103
       103
        
         };

     

       104
       104
       +
       

     

       105
       105
       +
         # uses relatedPackages

     

       106
       106
       +
         meta.buildDocsInSandbox = false;

     

       104
       107
        
       }

+3

nixos/modules/i18n/input-method/fcitx.nix

···

       40
       40
        
           };

     

       41
       41
        
           services.xserver.displayManager.sessionCommands = "${fcitxPackage}/bin/fcitx";

     

       42
       42
        
         };

     

       43
       43
       +
       

     

       44
       44
       +
         # uses attributes of the linked package

     

       45
       45
       +
         meta.buildDocsInSandbox = false;

     

       43
       46
        
       }

+3

nixos/modules/i18n/input-method/ibus.nix

···

       80
       80
        
             ibusPackage

     

       81
       81
        
           ];

     

       82
       82
        
         };

     

       83
       83
       +
       

     

       84
       84
       +
         # uses attributes of the linked package

     

       85
       85
       +
         meta.buildDocsInSandbox = false;

     

       83
       86
        
       }

+3 -1

nixos/modules/i18n/input-method/kime.nix

···

       45
       45
        
       

     

       46
       46
        
           environment.etc."xdg/kime/config.yaml".text = replaceStrings [ "\\\\" ] [ "\\" ] (builtins.toJSON cfg.config);

     

       47
       47
        
         };

     

       48
       48
       -
       }

     

       49
       48
        
       

     

       49
       49
       +
         # uses attributes of the linked package

     

       50
       50
       +
         meta.buildDocsInSandbox = false;

     

       51
       51
       +
       }

+85 -10

nixos/modules/misc/documentation.nix

···

       1
       1
       -
       { config, lib, pkgs, extendModules, noUserModules, ... }:

     

       1
       1
       +
       { config, options, lib, pkgs, utils, modules, baseModules, extraModules, modulesPath, ... }:

     

       2
       2
        
       

     

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
        
       

     

       7
       7
        
         cfg = config.documentation;

     

       8
       8
       +
         allOpts = options;

     

       8
       9
        
       

     

       9
       10
        
         /* Modules for which to show options even when not imported. */

     

       10
       11
        
         extraDocModules = [ ../virtualisation/qemu-vm.nix ];

     

       11
       12
        
       

     

       12
       12
       -
         /* For the purpose of generating docs, evaluate options with each derivation

     

       13
       13
       -
           in `pkgs` (recursively) replaced by a fake with path "\${pkgs.attribute.path}".

     

       14
       14
       -
           It isn't perfect, but it seems to cover a vast majority of use cases.

     

       15
       15
       -
           Caveat: even if the package is reached by a different means,

     

       16
       16
       -
           the path above will be shown and not e.g. `${config.services.foo.package}`. */

     

       13
       13
       +
         canCacheDocs = m:

     

       14
       14
       +
           let

     

       15
       15
       +
             f = import m;

     

       16
       16
       +
             instance = f (mapAttrs (n: _: abort "evaluating ${n} for `meta` failed") (functionArgs f));

     

       17
       17
       +
           in

     

       18
       18
       +
             cfg.nixos.splitOptionDocBuild

     

       19
       19
       +
               && builtins.isPath m

     

       20
       20
       +
               && isFunction f

     

       21
       21
       +
               && instance ? options

     

       22
       22
       +
               && instance.meta.buildDocsInSandbox or true;

     

       23
       23
       +
       

     

       24
       24
       +
         docModules =

     

       25
       25
       +
           let

     

       26
       26
       +
             p = partition canCacheDocs (baseModules ++ extraDocModules);

     

       27
       27
       +
           in

     

       28
       28
       +
             {

     

       29
       29
       +
               lazy = p.right;

     

       30
       30
       +
               eager = p.wrong ++ optionals cfg.nixos.includeAllModules (extraModules ++ modules);

     

       31
       31
       +
             };

     

       32
       32
       +
       

     

       17
       33
        
         manual = import ../../doc/manual rec {

     

       18
       34
        
           inherit pkgs config;

     

       19
       35
        
           version = config.system.nixos.release;

     
···

       21
       37
        
           extraSources = cfg.nixos.extraModuleSources;

     

       22
       38
        
           options =

     

       23
       39
        
             let

     

       24
       24
       -
               extendNixOS = if cfg.nixos.includeAllModules then extendModules else noUserModules.extendModules;

     

       25
       25
       -
               scrubbedEval = extendNixOS {

     

       26
       26
       -
                 modules = extraDocModules;

     

       27
       27
       -
                 specialArgs.pkgs = scrubDerivations "pkgs" pkgs;

     

       40
       40
       +
               scrubbedEval = evalModules {

     

       41
       41
       +
                 modules = [ {

     

       42
       42
       +
                   _module.check = false;

     

       43
       43
       +
                 } ] ++ docModules.eager;

     

       44
       44
       +
                 specialArgs = {

     

       45
       45
       +
                   pkgs = scrubDerivations "pkgs" pkgs;

     

       46
       46
       +
                   # allow access to arbitrary options for eager modules, eg for getting

     

       47
       47
       +
                   # option types from lazy modules

     

       48
       48
       +
                   options = allOpts;

     

       49
       49
       +
                   inherit modulesPath utils;

     

       50
       50
       +
                 };

     

       28
       51
        
               };

     

       29
       52
        
               scrubDerivations = namePrefix: pkgSet: mapAttrs

     

       30
       53
        
                 (name: value:

     
···

       36
       59
        
                 )

     

       37
       60
        
                 pkgSet;

     

       38
       61
        
             in scrubbedEval.options;

     

       62
       62
       +
           baseOptionsJSON =

     

       63
       63
       +
             let

     

       64
       64
       +
               filter =

     

       65
       65
       +
                 builtins.filterSource

     

       66
       66
       +
                   (n: t:

     

       67
       67
       +
                     (t == "directory" -> baseNameOf n != "tests")

     

       68
       68
       +
                     && (t == "file" -> hasSuffix ".nix" n)

     

       69
       69
       +
                   );

     

       70
       70
       +
             in

     

       71
       71
       +
               pkgs.runCommand "lazy-options.json" {

     

       72
       72
       +
                 libPath = filter "${toString pkgs.path}/lib";

     

       73
       73
       +
                 pkgsLibPath = filter "${toString pkgs.path}/pkgs/pkgs-lib";

     

       74
       74
       +
                 nixosPath = filter "${toString pkgs.path}/nixos";

     

       75
       75
       +
                 modules = map (p: ''"${removePrefix "${modulesPath}/" (toString p)}"'') docModules.lazy;

     

       76
       76
       +
               } ''

     

       77
       77
       +
                 export NIX_STORE_DIR=$TMPDIR/store

     

       78
       78
       +
                 export NIX_STATE_DIR=$TMPDIR/state

     

       79
       79
       +
                 ${pkgs.nix}/bin/nix-instantiate \

     

       80
       80
       +
                   --show-trace \

     

       81
       81
       +
                   --eval --json --strict \

     

       82
       82
       +
                   --argstr libPath "$libPath" \

     

       83
       83
       +
                   --argstr pkgsLibPath "$pkgsLibPath" \

     

       84
       84
       +
                   --argstr nixosPath "$nixosPath" \

     

       85
       85
       +
                   --arg modules "[ $modules ]" \

     

       86
       86
       +
                   --argstr stateVersion "${options.system.stateVersion.default}" \

     

       87
       87
       +
                   --argstr release "${config.system.nixos.release}" \

     

       88
       88
       +
                   $nixosPath/lib/eval-cacheable-options.nix > $out \

     

       89
       89
       +
                   || {

     

       90
       90
       +
                     echo -en "\e[1;31m"

     

       91
       91
       +
                     echo 'Cacheable portion of option doc build failed.'

     

       92
       92
       +
                     echo 'Usually this means that an option attribute that ends up in documentation (eg' \

     

       93
       93
       +
                       '`default` or `description`) depends on the restricted module arguments' \

     

       94
       94
       +
                       '`config` or `pkgs`.'

     

       95
       95
       +
                     echo

     

       96
       96
       +
                     echo 'Rebuild your configuration with `--show-trace` to find the offending' \

     

       97
       97
       +
                       'location. Remove the references to restricted arguments (eg by escaping' \

     

       98
       98
       +
                       'their antiquotations or adding a `defaultText`) or disable the sandboxed' \

     

       99
       99
       +
                       'build for the failing module by setting `meta.buildDocsInSandbox = false`.'

     

       100
       100
       +
                     echo -en "\e[0m"

     

       101
       101
       +
                     exit 1

     

       102
       102
       +
                   } >&2

     

       103
       103
       +
               '';

     

       39
       104
        
         };

     

       40
       105
        
       

     

       41
       106
        
       

     
···

       188
       253
        
                 <listitem><para>This includes the HTML manual and the <command>nixos-help</command> command if

     

       189
       254
        
                           <option>documentation.doc.enable</option> is set.</para></listitem>

     

       190
       255
        
                 </itemizedlist>

     

       256
       256
       +
               '';

     

       257
       257
       +
             };

     

       258
       258
       +
       

     

       259
       259
       +
             nixos.splitOptionDocBuild = mkOption {

     

       260
       260
       +
               type = types.bool;

     

       261
       261
       +
               default = true;

     

       262
       262
       +
               description = ''

     

       263
       263
       +
                 Whether to split the option docs build into a cacheable and an uncacheable part.

     

       264
       264
       +
                 Splitting the build can substantially decrease the amount of time needed to build

     

       265
       265
       +
                 the manual, but some user modules may be incompatible with this splitting.

     

       191
       266
        
               '';

     

       192
       267
        
             };

     

       193
       268

+15

nixos/modules/misc/meta.nix

···

       54
       54
        
               '';

     

       55
       55
        
             };

     

       56
       56
        
       

     

       57
       57
       +
             buildDocsInSandbox = mkOption {

     

       58
       58
       +
               type = types.bool // {

     

       59
       59
       +
                 merge = loc: defs: defs;

     

       60
       60
       +
               };

     

       61
       61
       +
               internal = true;

     

       62
       62
       +
               default = true;

     

       63
       63
       +
               description = ''

     

       64
       64
       +
                 Whether to include this module in the split options doc build.

     

       65
       65
       +
                 Disable if the module references `config`, `pkgs` or other module

     

       66
       66
       +
                 arguments that cannot be evaluated as constants.

     

       67
       67
       +
       

     

       68
       68
       +
                 This option should be defined at most once per module.

     

       69
       69
       +
               '';

     

       70
       70
       +
             };

     

       71
       71
       +
       

     

       57
       72
        
           };

     

       58
       73
        
         };

     

       59
       74

+3

nixos/modules/misc/nixpkgs.nix

···

       248
       248
        
             )

     

       249
       249
        
           ];

     

       250
       250
        
         };

     

       251
       251
       +
       

     

       252
       252
       +
         # needs a full nixpkgs path to import nixpkgs

     

       253
       253
       +
         meta.buildDocsInSandbox = false;

     

       251
       254
        
       }

+2

nixos/modules/misc/version.nix

···

       119
       119
        
       

     

       120
       120
        
         };

     

       121
       121
        
       

     

       122
       122
       +
         # uses version info nixpkgs, which requires a full nixpkgs path

     

       123
       123
       +
         meta.buildDocsInSandbox = false;

     

       122
       124
        
       }

+2

nixos/modules/programs/dmrconfig.nix

···

       7
       7
        
       

     

       8
       8
        
       in {

     

       9
       9
        
         meta.maintainers = [ maintainers.etu ];

     

       10
       10
       +
         # uses relatedPackages

     

       11
       11
       +
         meta.buildDocsInSandbox = false;

     

       10
       12
        
       

     

       11
       13
        
         ###### interface

     

       12
       14
        
         options = {

+2

nixos/modules/programs/gnupg.nix

···

       149
       149
        
           ];

     

       150
       150
        
         };

     

       151
       151
        
       

     

       152
       152
       +
         # uses attributes of the linked package

     

       153
       153
       +
         meta.buildDocsInSandbox = false;

     

       152
       154
        
       }

+3

nixos/modules/programs/tmux.nix

···

       185
       185
        
         imports = [

     

       186
       186
        
           (lib.mkRenamedOptionModule [ "programs" "tmux" "extraTmuxConf" ] [ "programs" "tmux" "extraConfig" ])

     

       187
       187
        
         ];

     

       188
       188
       +
       

     

       189
       189
       +
         # uses relatedPackages

     

       190
       190
       +
         meta.buildDocsInSandbox = false;

     

       188
       191
        
       }

+4 -1

nixos/modules/services/backup/sanoid.nix

···

       51
       51
        
         datasetOptions = rec {

     

       52
       52
        
           use_template = mkOption {

     

       53
       53
        
             description = "Names of the templates to use for this dataset.";

     

       54
       54
       -
             type = types.listOf (types.enum (attrNames cfg.templates));

     

       54
       54
       +
             type = types.listOf (types.str // {

     

       55
       55
       +
               check = (types.enum (attrNames cfg.templates)).check;

     

       56
       56
       +
               description = "configured template name";

     

       57
       57
       +
             });

     

       55
       58
        
             default = [ ];

     

       56
       59
        
           };

     

       57
       60
        
           useTemplate = use_template;

+2

nixos/modules/services/desktops/pipewire/pipewire-media-session.nix

···

       29
       29
        
       

     

       30
       30
        
         meta = {

     

       31
       31
        
           maintainers = teams.freedesktop.members;

     

       32
       32
       +
           # uses attributes of the linked package

     

       33
       33
       +
           buildDocsInSandbox = false;

     

       32
       34
        
         };

     

       33
       35
        
       

     

       34
       36
        
         ###### interface

+2

nixos/modules/services/desktops/pipewire/pipewire.nix

···

       40
       40
        
       

     

       41
       41
        
         meta = {

     

       42
       42
        
           maintainers = teams.freedesktop.members;

     

       43
       43
       +
           # uses attributes of the linked package

     

       44
       44
       +
           buildDocsInSandbox = false;

     

       43
       45
        
         };

     

       44
       46
        
       

     

       45
       47
        
         ###### interface

+3

nixos/modules/services/hardware/thinkfan.nix

···

       221
       221
        
           boot.extraModprobeConfig = "options thinkpad_acpi experimental=1 fan_control=1";

     

       222
       222
        
       

     

       223
       223
        
         };

     

       224
       224
       +
       

     

       225
       225
       +
         # uses relatedPackages

     

       226
       226
       +
         meta.buildDocsInSandbox = false;

     

       224
       227
        
       }

+3

nixos/modules/services/misc/matrix-appservice-irc.nix

···

       226
       226
        
             isSystemUser = true;

     

       227
       227
        
           };

     

       228
       228
        
         };

     

       229
       229
       +
       

     

       230
       230
       +
         # uses attributes of the linked package

     

       231
       231
       +
         meta.buildDocsInSandbox = false;

     

       229
       232
        
       }

+3

nixos/modules/services/networking/dnscrypt-proxy2.nix

···

       118
       118
        
             };

     

       119
       119
        
           };

     

       120
       120
        
         };

     

       121
       121
       +
       

     

       122
       122
       +
         # uses attributes of the linked package

     

       123
       123
       +
         meta.buildDocsInSandbox = false;

     

       121
       124
        
       }

+2

nixos/modules/services/networking/kea.nix

···

       378
       378
        
         ]);

     

       379
       379
        
       

     

       380
       380
        
         meta.maintainers = with maintainers; [ hexa ];

     

       381
       381
       +
         # uses attributes of the linked package

     

       382
       382
       +
         meta.buildDocsInSandbox = false;

     

       381
       383
        
       }

+2 -1

nixos/modules/services/networking/searx.nix

···

       228
       228
        
         };

     

       229
       229
        
       

     

       230
       230
        
         meta.maintainers = with maintainers; [ rnhmjoj ];

     

       231
       231
       -
       

     

       231
       231
       +
         # uses relatedPackages

     

       232
       232
       +
         meta.buildDocsInSandbox = false;

     

       232
       233
        
       }

+3

nixos/modules/services/security/vaultwarden/default.nix

···

       179
       179
        
             wantedBy = [ "multi-user.target" ];

     

       180
       180
        
           };

     

       181
       181
        
         };

     

       182
       182
       +
       

     

       183
       183
       +
         # uses attributes of the linked package

     

       184
       184
       +
         meta.buildDocsInSandbox = false;

     

       182
       185
        
       }

+3

nixos/modules/services/web-apps/dex.nix

···

       112
       112
        
             };

     

       113
       113
        
           };

     

       114
       114
        
         };

     

       115
       115
       +
       

     

       116
       116
       +
         # uses attributes of the linked package

     

       117
       117
       +
         meta.buildDocsInSandbox = false;

     

       115
       118
        
       }

+2

nixos/modules/services/web-apps/gerrit.nix

···

       237
       237
        
         };

     

       238
       238
        
       

     

       239
       239
        
         meta.maintainers = with lib.maintainers; [ edef zimbatm ];

     

       240
       240
       +
         # uses attributes of the linked package

     

       241
       241
       +
         meta.buildDocsInSandbox = false;

     

       240
       242
        
       }

+3

nixos/modules/services/web-apps/jirafeau.nix

···

       167
       167
        
             "d ${cfg.dataDir}/async/ 0750 ${user} ${group} - -"

     

       168
       168
        
           ];

     

       169
       169
        
         };

     

       170
       170
       +
       

     

       171
       171
       +
         # uses attributes of the linked package

     

       172
       172
       +
         meta.buildDocsInSandbox = false;

     

       170
       173
        
       }

+2

nixos/modules/services/web-apps/nextcloud.nix

···

       932
       932
        
         ]);

     

       933
       933
        
       

     

       934
       934
        
         meta.doc = ./nextcloud.xml;

     

       935
       935
       +
         # uses relatedPackages

     

       936
       936
       +
         meta.buildDocsInSandbox = false;

     

       935
       937
        
       }

+3

nixos/modules/services/web-apps/powerdns-admin.nix

···

       146
       146
        
             group = "powerdnsadmin";

     

       147
       147
        
           };

     

       148
       148
        
         };

     

       149
       149
       +
       

     

       150
       150
       +
         # uses attributes of the linked package

     

       151
       151
       +
         meta.buildDocsInSandbox = false;

     

       149
       152
        
       }

+2

nixos/modules/services/x11/xserver.nix

···

       865
       865
        
       

     

       866
       866
        
         };

     

       867
       867
        
       

     

       868
       868
       +
         # uses relatedPackages

     

       869
       869
       +
         meta.buildDocsInSandbox = false;

     

       868
       870
        
       }

+2

nixos/modules/system/activation/top-level.nix

···

       317
       317
        
       

     

       318
       318
        
         };

     

       319
       319
        
       

     

       320
       320
       +
         # uses extendModules to generate a type

     

       321
       321
       +
         meta.buildDocsInSandbox = false;

     

       320
       322
        
       }

+3

nixos/modules/virtualisation/qemu-vm.nix

···

       999
       999
        
             ];

     

       1000
       1000
        
       

     

       1001
       1001
        
         };

     

       1002
       1002
       +
       

     

       1003
       1003
       +
         # uses types of services/x11/xserver.nix

     

       1004
       1004
       +
         meta.buildDocsInSandbox = false;

     

       1002
       1005
        
       }

+3

nixos/modules/virtualisation/xen-dom0.nix

···

       451
       451
        
       

     

       452
       452
        
         };

     

       453
       453
        
       

     

       454
       454
       +
       

     

       455
       455
       +
         # uses relatedPackages

     

       456
       456
       +
         meta.buildDocsInSandbox = false;

     

       454
       457
        
       }