commit 9c3c13b50d02380cda1c834bc15cff3346956ea4 · pyrox.dev/nixpkgs

+4

doc/build-aux/pandoc-filters/docbook-writer/rst-roles.lua

···

       31
       31
        
             tag = 'command'

     

       32
       32
        
           elseif elem.attributes['role'] == 'option' then

     

       33
       33
        
             tag = 'option'

     

       34
       34
       +
           elseif elem.attributes['role'] == 'var' then

     

       35
       35
       +
             tag = 'varname'

     

       36
       36
       +
           elseif elem.attributes['role'] == 'env' then

     

       37
       37
       +
             tag = 'envar'

     

       34
       38
        
           end

     

       35
       39
        
       

     

       36
       40
        
           if tag ~= nil then

+3 -1

doc/contributing/contributing-to-documentation.chapter.md

···

       58
       58
        
         A few markups for other kinds of literals are also available:

     

       59
       59
        
       

     

       60
       60
        
         - `` {command}`rm -rfi` `` turns into {command}`rm -rfi`

     

       61
       61
       -
         - `` {option}`networking.useDHCP` `` turns into {option}`networking.useDHCP`

     

       61
       61
       +
         - `` {env}`XDG_DATA_DIRS` `` turns into {env}`XDG_DATA_DIRS`

     

       62
       62
        
         - `` {file}`/etc/passwd` `` turns into {file}`/etc/passwd`

     

       63
       63
       +
         - `` {option}`networking.useDHCP` `` turns into {option}`networking.useDHCP`

     

       64
       64
       +
         - `` {var}`/etc/passwd` `` turns into {var}`/etc/passwd`

     

       63
       65
        
       

     

       64
       66
        
         These literal kinds are used mostly in NixOS option documentation.

     

       65
       67

+19 -1

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

···

       114
       114
        
               return f"<option>{escape(text)}</option>"

     

       115
       115
        
           def file(self, text):

     

       116
       116
        
               return f"<filename>{escape(text)}</filename>"

     

       117
       117
       +
           def var(self, text):

     

       118
       118
       +
               return f"<varname>{escape(text)}</varname>"

     

       119
       119
       +
           def env(self, text):

     

       120
       120
       +
               return f"<envar>{escape(text)}</envar>"

     

       117
       121
        
           def manpage(self, page, section):

     

       118
       122
        
               title = f"<refentrytitle>{escape(page)}</refentrytitle>"

     

       119
       123
        
               vol = f"<manvolnum>{escape(section)}</manvolnum>"

     
···

       136
       140
        
           md.inline.register_rule('file', FILE_PATTERN, parse)

     

       137
       141
        
           md.inline.rules.append('file')

     

       138
       142
        
       

     

       143
       143
       +
       def p_var(md):

     

       144
       144
       +
           VAR_PATTERN = r'\{var\}`(.*?)`'

     

       145
       145
       +
           def parse(self, m, state):

     

       146
       146
       +
               return ('var', m.group(1))

     

       147
       147
       +
           md.inline.register_rule('var', VAR_PATTERN, parse)

     

       148
       148
       +
           md.inline.rules.append('var')

     

       149
       149
       +
       

     

       150
       150
       +
       def p_env(md):

     

       151
       151
       +
           ENV_PATTERN = r'\{env\}`(.*?)`'

     

       152
       152
       +
           def parse(self, m, state):

     

       153
       153
       +
               return ('env', m.group(1))

     

       154
       154
       +
           md.inline.register_rule('env', ENV_PATTERN, parse)

     

       155
       155
       +
           md.inline.rules.append('env')

     

       156
       156
       +
       

     

       139
       157
        
       def p_option(md):

     

       140
       158
        
           OPTION_PATTERN = r'\{option\}`(.*?)`'

     

       141
       159
        
           def parse(self, m, state):

     
···

       162
       180
        
           md.block.rules.append('admonition')

     

       163
       181
        
       

     

       164
       182
        
       md = mistune.create_markdown(renderer=Renderer(), plugins=[

     

       165
       165
       -
           p_command, p_file, p_option, p_manpage, p_admonition

     

       183
       183
       +
           p_command, p_file, p_var, p_env, p_option, p_manpage, p_admonition

     

       166
       184
        
       ])

     

       167
       185
        
       

     

       168
       186
        
       # converts in-place!