commit 15c41e1d54fca9ba6f3c7fbaf294b8af139fbca2 · pyrox.dev/nixpkgs

+1 -1

nixos/doc/manual/default.nix

···

       161
       161
        
       in rec {

     

       162
       162
        
         inherit generatedSources;

     

       163
       163
        
       

     

       164
       164
       -
         inherit (optionsDoc) optionsJSON optionsXML optionsDocBook;

     

       164
       164
       +
         inherit (optionsDoc) optionsJSON optionsDocBook;

     

       165
       165
        
       

     

       166
       166
        
         # Generate the NixOS manual.

     

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

+37 -90

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

···

       24
       24
        
       }:

     

       25
       25
        
       

     

       26
       26
        
       let

     

       27
       27
       -
         # Replace functions by the string <function>

     

       28
       28
       -
         substFunction = x:

     

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

     

       30
       30
       -
           else if builtins.isList x then map substFunction x

     

       27
       27
       +
         # Make a value safe for JSON. Functions are replaced by the string "<function>",

     

       28
       28
       +
         # derivations are replaced with an attrset

     

       29
       29
       +
         # { _type = "derivation"; name = <name of that derivation>; }.

     

       30
       30
       +
         # We need to handle derivations specially because consumers want to know about them,

     

       31
       31
       +
         # but we can't easily use the type,name subset of keys (since type is often used as

     

       32
       32
       +
         # a module option and might cause confusion). Use _type,name instead to the same

     

       33
       33
       +
         # effect, since _type is already used by the module system.

     

       34
       34
       +
         substSpecial = x:

     

       35
       35
       +
           if lib.isDerivation x then { _type = "derivation"; name = x.name; }

     

       36
       36
       +
           else if builtins.isAttrs x then lib.mapAttrs (name: substSpecial) x

     

       37
       37
       +
           else if builtins.isList x then map substSpecial x

     

       31
       38
        
           else if lib.isFunction x then "<function>"

     

       32
       39
        
           else x;

     

       33
       40
        
       

     

       34
       34
       -
         optionsListDesc = lib.flip map optionsListVisible

     

       41
       41
       +
         optionsList = lib.flip map optionsListVisible

     

       35
       42
        
          (opt: transformOptions opt

     

       36
       36
       -
           // lib.optionalAttrs (opt ? example) { example = substFunction opt.example; }

     

       37
       37
       -
           // lib.optionalAttrs (opt ? default) { default = substFunction opt.default; }

     

       38
       38
       -
           // lib.optionalAttrs (opt ? type) { type = substFunction opt.type; }

     

       43
       43
       +
           // lib.optionalAttrs (opt ? example) { example = substSpecial opt.example; }

     

       44
       44
       +
           // lib.optionalAttrs (opt ? default) { default = substSpecial opt.default; }

     

       45
       45
       +
           // lib.optionalAttrs (opt ? type) { type = substSpecial opt.type; }

     

       39
       46
        
           // lib.optionalAttrs (opt ? relatedPackages && opt.relatedPackages != []) { relatedPackages = genRelatedPackages opt.relatedPackages opt.name; }

     

       40
       47
        
          );

     

       41
       48
        
       

     
···

       69
       76
        
               + "</listitem>";

     

       70
       77
        
           in "<itemizedlist>${lib.concatStringsSep "\n" (map (p: describe (unpack p)) packages)}</itemizedlist>";

     

       71
       78
        
       

     

       72
       72
       -
         # Custom "less" that pushes up all the things ending in ".enable*"

     

       73
       73
       -
         # and ".package*"

     

       74
       74
       -
         optionLess = a: b:

     

       75
       75
       -
           let

     

       76
       76
       -
             ise = lib.hasPrefix "enable";

     

       77
       77
       -
             isp = lib.hasPrefix "package";

     

       78
       78
       -
             cmp = lib.splitByAndCompare ise lib.compare

     

       79
       79
       -
                                        (lib.splitByAndCompare isp lib.compare lib.compare);

     

       80
       80
       -
           in lib.compareLists cmp a.loc b.loc < 0;

     

       81
       81
       -
       

     

       82
       79
        
         # Remove invisible and internal options.

     

       83
       80
        
         optionsListVisible = lib.filter (opt: opt.visible && !opt.internal) (lib.optionAttrSetToDocList options);

     

       84
       81
        
       

     

       85
       85
       -
         # Customly sort option list for the man page.

     

       86
       86
       -
         # Always ensure that the sort order matches sortXML.py!

     

       87
       87
       -
         optionsList = lib.sort optionLess optionsListDesc;

     

       88
       88
       -
       

     

       89
       89
       -
         # Convert the list of options into an XML file.

     

       90
       90
       -
         # This file is *not* sorted sorted to save on eval time, since the docbook XML

     

       91
       91
       -
         # and the manpage depend on it and thus we evaluate this on every system rebuild.

     

       92
       92
       -
         optionsXML = builtins.toFile "options.xml" (builtins.toXML optionsListDesc);

     

       93
       93
       -
       

     

       94
       82
        
         optionsNix = builtins.listToAttrs (map (o: { name = o.name; value = removeAttrs o ["name" "visible" "internal"]; }) optionsList);

     

       95
       83
        
       

     

       96
       96
       -
         # TODO: declarations: link to github

     

       97
       97
       -
         singleAsciiDoc = name: value: ''

     

       98
       98
       -
           == ${name}

     

       99
       99
       -
       

     

       100
       100
       -
           ${value.description}

     

       101
       101
       -
       

     

       102
       102
       -
           [discrete]

     

       103
       103
       -
           === details

     

       84
       84
       +
       in rec {

     

       85
       85
       +
         inherit optionsNix;

     

       104
       86
        
       

     

       105
       105
       -
           Type:: ${value.type}

     

       106
       106
       -
           ${ if lib.hasAttr "default" value

     

       107
       107
       -
              then ''

     

       108
       108
       -
               Default::

     

       109
       109
       -
               +

     

       110
       110
       -
               ----

     

       111
       111
       -
               ${builtins.toJSON value.default}

     

       112
       112
       -
               ----

     

       113
       113
       -
             ''

     

       114
       114
       -
             else "No Default:: {blank}"

     

       115
       115
       -
           }

     

       116
       116
       -
           ${ if value.readOnly

     

       117
       117
       -
              then "Read Only:: {blank}"

     

       118
       118
       -
             else ""

     

       119
       119
       -
           }

     

       120
       120
       -
           ${ if lib.hasAttr "example" value

     

       121
       121
       -
              then ''

     

       122
       122
       -
               Example::

     

       123
       123
       -
               +

     

       124
       124
       -
               ----

     

       125
       125
       -
               ${builtins.toJSON value.example}

     

       126
       126
       -
               ----

     

       127
       127
       -
             ''

     

       128
       128
       -
             else "No Example:: {blank}"

     

       129
       129
       -
           }

     

       87
       87
       +
         optionsAsciiDoc = pkgs.runCommand "options.adoc" {} ''

     

       88
       88
       +
           ${pkgs.python3Minimal}/bin/python ${./generateAsciiDoc.py} \

     

       89
       89
       +
             < ${optionsJSON}/share/doc/nixos/options.json \

     

       90
       90
       +
             > $out

     

       130
       91
        
         '';

     

       131
       92
        
       

     

       132
       132
       -
         singleMDDoc = name: value: ''

     

       133
       133
       -
           ## ${lib.escape [ "<" ">" ] name}

     

       134
       134
       -
           ${value.description}

     

       135
       135
       -
       

     

       136
       136
       -
           ${lib.optionalString (value ? type) ''

     

       137
       137
       -
             *_Type_*:

     

       138
       138
       -
             ${value.type}

     

       139
       139
       -
           ''}

     

       140
       140
       -
       

     

       141
       141
       -
           ${lib.optionalString (value ? default) ''

     

       142
       142
       -
             *_Default_*

     

       143
       143
       -
             ```

     

       144
       144
       -
             ${builtins.toJSON value.default}

     

       145
       145
       -
             ```

     

       146
       146
       -
           ''}

     

       147
       147
       -
       

     

       148
       148
       -
           ${lib.optionalString (value ? example) ''

     

       149
       149
       -
             *_Example_*

     

       150
       150
       -
             ```

     

       151
       151
       -
             ${builtins.toJSON value.example}

     

       152
       152
       -
             ```

     

       153
       153
       -
           ''}

     

       93
       93
       +
         optionsCommonMark = pkgs.runCommand "options.md" {} ''

     

       94
       94
       +
           ${pkgs.python3Minimal}/bin/python ${./generateCommonMark.py} \

     

       95
       95
       +
             < ${optionsJSON}/share/doc/nixos/options.json \

     

       96
       96
       +
             > $out

     

       154
       97
        
         '';

     

       155
       98
        
       

     

       156
       156
       -
       in {

     

       157
       157
       -
         inherit optionsNix;

     

       158
       158
       -
       

     

       159
       159
       -
         optionsAsciiDoc = lib.concatStringsSep "\n" (lib.mapAttrsToList singleAsciiDoc optionsNix);

     

       160
       160
       -
       

     

       161
       161
       -
         optionsMDDoc = lib.concatStringsSep "\n" (lib.mapAttrsToList singleMDDoc optionsNix);

     

       162
       162
       -
       

     

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

     

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

     

       165
       101
        
             buildInputs = [ pkgs.brotli ];

     
···

       176
       112
        
             mkdir -p $out/nix-support

     

       177
       113
        
             echo "file json $dst/options.json" >> $out/nix-support/hydra-build-products

     

       178
       114
        
             echo "file json-br $dst/options.json.br" >> $out/nix-support/hydra-build-products

     

       179
       179
       -
           ''; # */

     

       115
       115
       +
           '';

     

       116
       116
       +
       

     

       117
       117
       +
         # Convert options.json into an XML file.

     

       118
       118
       +
         # The actual generation of the xml file is done in nix purely for the convenience

     

       119
       119
       +
         # of not having to generate the xml some other way

     

       120
       120
       +
         optionsXML = pkgs.runCommand "options.xml" {} ''

     

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

     

       122
       122
       +
             --store dummy:// \

     

       123
       123
       +
             --eval --xml --strict ${./optionsJSONtoXML.nix} \

     

       124
       124
       +
             --argstr file ${optionsJSON}/share/doc/nixos/options.json \

     

       125
       125
       +
             > "$out"

     

       126
       126
       +
         '';

     

       180
       127
        
       

     

       181
       128
        
         optionsDocBook = pkgs.runCommand "options-docbook.xml" {} ''

     

       182
       129
        
           optionsXML=${optionsXML}

+37

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

···

       1
       1
       +
       import json

     

       2
       2
       +
       import sys

     

       3
       3
       +
       

     

       4
       4
       +
       options = json.load(sys.stdin)

     

       5
       5
       +
       # TODO: declarations: link to github

     

       6
       6
       +
       for (name, value) in options.items():

     

       7
       7
       +
           print(f'== {name}')

     

       8
       8
       +
           print()

     

       9
       9
       +
           print(value['description'])

     

       10
       10
       +
           print()

     

       11
       11
       +
           print('[discrete]')

     

       12
       12
       +
           print('=== details')

     

       13
       13
       +
           print()

     

       14
       14
       +
           print(f'Type:: {value["type"]}')

     

       15
       15
       +
           if 'default' in value:

     

       16
       16
       +
               print('Default::')

     

       17
       17
       +
               print('+')

     

       18
       18
       +
               print('----')

     

       19
       19
       +
               print(json.dumps(value['default'], ensure_ascii=False, separators=(',', ':')))

     

       20
       20
       +
               print('----')

     

       21
       21
       +
               print()

     

       22
       22
       +
           else:

     

       23
       23
       +
               print('No Default:: {blank}')

     

       24
       24
       +
           if value['readOnly']:

     

       25
       25
       +
               print('Read Only:: {blank}')

     

       26
       26
       +
           else:

     

       27
       27
       +
               print()

     

       28
       28
       +
           if 'example' in value:

     

       29
       29
       +
               print('Example::')

     

       30
       30
       +
               print('+')

     

       31
       31
       +
               print('----')

     

       32
       32
       +
               print(json.dumps(value['example'], ensure_ascii=False, separators=(',', ':')))

     

       33
       33
       +
               print('----')

     

       34
       34
       +
               print()

     

       35
       35
       +
           else:

     

       36
       36
       +
               print('No Example:: {blank}')

     

       37
       37
       +
           print()

+27

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

···

       1
       1
       +
       import json

     

       2
       2
       +
       import sys

     

       3
       3
       +
       

     

       4
       4
       +
       options = json.load(sys.stdin)

     

       5
       5
       +
       for (name, value) in options.items():

     

       6
       6
       +
           print('##', name.replace('<', '\\<').replace('>', '\\>'))

     

       7
       7
       +
           print(value['description'])

     

       8
       8
       +
           print()

     

       9
       9
       +
           if 'type' in value:

     

       10
       10
       +
               print('*_Type_*:')

     

       11
       11
       +
               print(value['type'])

     

       12
       12
       +
               print()

     

       13
       13
       +
           print()

     

       14
       14
       +
           if 'default' in value:

     

       15
       15
       +
               print('*_Default_*')

     

       16
       16
       +
               print('```')

     

       17
       17
       +
               print(json.dumps(value['default'], ensure_ascii=False, separators=(',', ':')))

     

       18
       18
       +
               print('```')

     

       19
       19
       +
           print()

     

       20
       20
       +
           print()

     

       21
       21
       +
           if 'example' in value:

     

       22
       22
       +
               print('*_Example_*')

     

       23
       23
       +
               print('```')

     

       24
       24
       +
               print(json.dumps(value['example'], ensure_ascii=False, separators=(',', ':')))

     

       25
       25
       +
               print('```')

     

       26
       26
       +
           print()

     

       27
       27
       +
           print()

+1 -1

nixos/lib/make-options-doc/options-to-docbook.xsl

···

       189
       189
        
         </xsl:template>

     

       190
       190
        
       

     

       191
       191
        
       

     

       192
       192
       -
         <xsl:template match="derivation">

     

       192
       192
       +
         <xsl:template match="attrs[attr[@name = '_type' and string[@value = 'derivation']]]">

     

       193
       193
        
           <replaceable>(build of <xsl:value-of select="attr[@name = 'name']/string/@value" />)</replaceable>

     

       194
       194
        
         </xsl:template>

     

       195
       195

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

···

       1
       1
       +
       { file }:

     

       2
       2
       +
       

     

       3
       3
       +
       builtins.attrValues

     

       4
       4
       +
         (builtins.mapAttrs

     

       5
       5
       +
           (name: def: def // { inherit name; })

     

       6
       6
       +
           (builtins.fromJSON (builtins.readFile file)))

-1

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

···

       19
       19
        
               for p in opt.findall('attr[@name="loc"]/list/string')

     

       20
       20
        
           ]

     

       21
       21
        
       

     

       22
       22
       -
       # always ensure that the sort order matches the order used in the nix expression!

     

       23
       22
        
       options.sort(key=sortKey)

     

       24
       23
        
       

     

       25
       24
        
       doc = ET.Element("expr")