commit 027f7e1b7f4552c9c9f0ff909a6863d5bf347a72 · pyrox.dev/nixpkgs

+26 -13

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
       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
        
       

     
···

       72
       79
        
         # Remove invisible and internal options.

     

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

     

       74
       81
        
       

     

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

     

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

     

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

     

       78
       78
       -
         optionsXML = builtins.toFile "options.xml" (builtins.toXML optionsList);

     

       79
       79
       -
       

     

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

     

       81
       83
        
       

     

       82
       84
        
       in rec {

     
···

       110
       112
        
             mkdir -p $out/nix-support

     

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

     

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

     

       113
       113
       -
           ''; # */

     

       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
       +
         '';

     

       114
       127
        
       

     

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

     

       116
       129
        
           optionsXML=${optionsXML}

+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)))