commit 6f253fc70b5f21fde4a61f873650778478cdcc30 · pyrox.dev/nixpkgs

+47 -92

pkgs/tools/nix/nixos-render-docs/src/nixos_render_docs/asciidoc.py

···

       1
       1
       -
       from collections.abc import Mapping, MutableMapping, Sequence

     

       1
       1
       +
       from collections.abc import Mapping, Sequence

     

       2
       2
        
       from dataclasses import dataclass

     

       3
       3
        
       from typing import Any, cast, Optional

     

       4
       4
        
       from urllib.parse import quote

     
···

       6
       6
        
       from .md import Renderer

     

       7
       7
        
       

     

       8
       8
        
       from markdown_it.token import Token

     

       9
       9
       -
       from markdown_it.utils import OptionsDict

     

       10
       9
        
       

     

       11
       10
        
       _asciidoc_escapes = {

     

       12
       11
        
           # escape all dots, just in case one is pasted at SOL

     
···

       95
       94
        
               self._list_stack.pop()

     

       96
       95
        
               return ""

     

       97
       96
        
       

     

       98
       98
       -
           def text(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       99
       99
       -
                    env: MutableMapping[str, Any]) -> str:

     

       97
       97
       +
           def text(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       100
       98
        
               self._parstack[-1].continuing = True

     

       101
       99
        
               return asciidoc_escape(token.content)

     

       102
       102
       -
           def paragraph_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       103
       103
       -
                              env: MutableMapping[str, Any]) -> str:

     

       100
       100
       +
           def paragraph_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       104
       101
        
               return self._break()

     

       105
       105
       -
           def paragraph_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       106
       106
       -
                               env: MutableMapping[str, Any]) -> str:

     

       102
       102
       +
           def paragraph_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       107
       103
        
               return ""

     

       108
       108
       -
           def hardbreak(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       109
       109
       -
                         env: MutableMapping[str, Any]) -> str:

     

       104
       104
       +
           def hardbreak(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       110
       105
        
               return " +\n"

     

       111
       111
       -
           def softbreak(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       112
       112
       -
                         env: MutableMapping[str, Any]) -> str:

     

       106
       106
       +
           def softbreak(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       113
       107
        
               return f" "

     

       114
       114
       -
           def code_inline(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       115
       115
       -
                           env: MutableMapping[str, Any]) -> str:

     

       108
       108
       +
           def code_inline(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       116
       109
        
               self._parstack[-1].continuing = True

     

       117
       110
        
               return f"``{asciidoc_escape(token.content)}``"

     

       118
       118
       -
           def code_block(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       119
       119
       -
                          env: MutableMapping[str, Any]) -> str:

     

       120
       120
       -
               return self.fence(token, tokens, i, options, env)

     

       121
       121
       -
           def link_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       122
       122
       -
                         env: MutableMapping[str, Any]) -> str:

     

       111
       111
       +
           def code_block(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       112
       112
       +
               return self.fence(token, tokens, i)

     

       113
       113
       +
           def link_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       123
       114
        
               self._parstack[-1].continuing = True

     

       124
       115
        
               return f"link:{quote(cast(str, token.attrs['href']), safe='/:')}["

     

       125
       125
       -
           def link_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       126
       126
       -
                          env: MutableMapping[str, Any]) -> str:

     

       116
       116
       +
           def link_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       127
       117
        
               return "]"

     

       128
       128
       -
           def list_item_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       129
       129
       -
                              env: MutableMapping[str, Any]) -> str:

     

       118
       118
       +
           def list_item_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       130
       119
        
               self._enter_block(True)

     

       131
       120
        
               # allow the next token to be a block or an inline.

     

       132
       121
        
               return f'\n{self._list_stack[-1].head} {{empty}}'

     

       133
       133
       -
           def list_item_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       134
       134
       -
                               env: MutableMapping[str, Any]) -> str:

     

       122
       122
       +
           def list_item_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       135
       123
        
               self._leave_block()

     

       136
       124
        
               return "\n"

     

       137
       137
       -
           def bullet_list_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       138
       138
       -
                                env: MutableMapping[str, Any]) -> str:

     

       125
       125
       +
           def bullet_list_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       139
       126
        
               return self._list_open(token, '*')

     

       140
       140
       -
           def bullet_list_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       141
       141
       -
                                 env: MutableMapping[str, Any]) -> str:

     

       127
       127
       +
           def bullet_list_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       142
       128
        
               return self._list_close()

     

       143
       143
       -
           def em_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       144
       144
       -
                       env: MutableMapping[str, Any]) -> str:

     

       129
       129
       +
           def em_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       145
       130
        
               return "__"

     

       146
       146
       -
           def em_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       147
       147
       -
                        env: MutableMapping[str, Any]) -> str:

     

       131
       131
       +
           def em_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       148
       132
        
               return "__"

     

       149
       149
       -
           def strong_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       150
       150
       -
                           env: MutableMapping[str, Any]) -> str:

     

       133
       133
       +
           def strong_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       151
       134
        
               return "**"

     

       152
       152
       -
           def strong_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       153
       153
       -
                            env: MutableMapping[str, Any]) -> str:

     

       135
       135
       +
           def strong_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       154
       136
        
               return "**"

     

       155
       155
       -
           def fence(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       156
       156
       -
                     env: MutableMapping[str, Any]) -> str:

     

       137
       137
       +
           def fence(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       157
       138
        
               attrs = f"[source,{token.info}]\n" if token.info else ""

     

       158
       139
        
               code = token.content

     

       159
       140
        
               if code.endswith('\n'):

     

       160
       141
        
                   code = code[:-1]

     

       161
       142
        
               return f"{self._break(True)}{attrs}----\n{code}\n----"

     

       162
       162
       -
           def blockquote_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       163
       163
       -
                               env: MutableMapping[str, Any]) -> str:

     

       143
       143
       +
           def blockquote_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       164
       144
        
               pbreak = self._break(True)

     

       165
       145
        
               self._enter_block(False)

     

       166
       146
        
               return f"{pbreak}[quote]\n{self._parstack[-2].block_delim}\n"

     

       167
       167
       -
           def blockquote_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       168
       168
       -
                                env: MutableMapping[str, Any]) -> str:

     

       147
       147
       +
           def blockquote_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       169
       148
        
               self._leave_block()

     

       170
       149
        
               return f"\n{self._parstack[-1].block_delim}"

     

       171
       171
       -
           def note_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       172
       172
       -
                         env: MutableMapping[str, Any]) -> str:

     

       150
       150
       +
           def note_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       173
       151
        
               return self._admonition_open("NOTE")

     

       174
       174
       -
           def note_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       175
       175
       -
                          env: MutableMapping[str, Any]) -> str:

     

       152
       152
       +
           def note_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       176
       153
        
               return self._admonition_close()

     

       177
       177
       -
           def caution_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       178
       178
       -
                            env: MutableMapping[str, Any]) -> str:

     

       154
       154
       +
           def caution_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       179
       155
        
               return self._admonition_open("CAUTION")

     

       180
       180
       -
           def caution_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       181
       181
       -
                             env: MutableMapping[str, Any]) -> str:

     

       156
       156
       +
           def caution_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       182
       157
        
               return self._admonition_close()

     

       183
       183
       -
           def important_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       184
       184
       -
                              env: MutableMapping[str, Any]) -> str:

     

       158
       158
       +
           def important_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       185
       159
        
               return self._admonition_open("IMPORTANT")

     

       186
       186
       -
           def important_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       187
       187
       -
                               env: MutableMapping[str, Any]) -> str:

     

       160
       160
       +
           def important_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       188
       161
        
               return self._admonition_close()

     

       189
       189
       -
           def tip_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       190
       190
       -
                        env: MutableMapping[str, Any]) -> str:

     

       162
       162
       +
           def tip_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       191
       163
        
               return self._admonition_open("TIP")

     

       192
       192
       -
           def tip_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       193
       193
       -
                         env: MutableMapping[str, Any]) -> str:

     

       164
       164
       +
           def tip_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       194
       165
        
               return self._admonition_close()

     

       195
       195
       -
           def warning_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       196
       196
       -
                            env: MutableMapping[str, Any]) -> str:

     

       166
       166
       +
           def warning_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       197
       167
        
               return self._admonition_open("WARNING")

     

       198
       198
       -
           def warning_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       199
       199
       -
                             env: MutableMapping[str, Any]) -> str:

     

       168
       168
       +
           def warning_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       200
       169
        
               return self._admonition_close()

     

       201
       201
       -
           def dl_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       202
       202
       -
                       env: MutableMapping[str, Any]) -> str:

     

       170
       170
       +
           def dl_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       203
       171
        
               return f"{self._break()}[]"

     

       204
       204
       -
           def dl_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       205
       205
       -
                        env: MutableMapping[str, Any]) -> str:

     

       172
       172
       +
           def dl_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       206
       173
        
               return ""

     

       207
       207
       -
           def dt_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       208
       208
       -
                       env: MutableMapping[str, Any]) -> str:

     

       174
       174
       +
           def dt_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       209
       175
        
               return self._break()

     

       210
       210
       -
           def dt_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       211
       211
       -
                        env: MutableMapping[str, Any]) -> str:

     

       176
       176
       +
           def dt_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       212
       177
        
               self._enter_block(True)

     

       213
       178
        
               return ":: {empty}"

     

       214
       214
       -
           def dd_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       215
       215
       -
                       env: MutableMapping[str, Any]) -> str:

     

       179
       179
       +
           def dd_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       216
       180
        
               return ""

     

       217
       217
       -
           def dd_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       218
       218
       -
                        env: MutableMapping[str, Any]) -> str:

     

       181
       181
       +
           def dd_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       219
       182
        
               self._leave_block()

     

       220
       183
        
               return "\n"

     

       221
       221
       -
           def myst_role(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       222
       222
       -
                         env: MutableMapping[str, Any]) -> str:

     

       184
       184
       +
           def myst_role(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       223
       185
        
               self._parstack[-1].continuing = True

     

       224
       186
        
               content = asciidoc_escape(token.content)

     

       225
       187
        
               if token.meta['name'] == 'manpage' and (url := self._manpage_urls.get(token.content)):

     

       226
       188
        
                   return f"link:{quote(url, safe='/:')}[{content}]"

     

       227
       189
        
               return f"[.{token.meta['name']}]``{asciidoc_escape(token.content)}``"

     

       228
       228
       -
           def inline_anchor(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       229
       229
       -
                             env: MutableMapping[str, Any]) -> str:

     

       190
       190
       +
           def inline_anchor(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       230
       191
        
               self._parstack[-1].continuing = True

     

       231
       192
        
               return f"[[{token.attrs['id']}]]"

     

       232
       232
       -
           def attr_span_begin(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       233
       233
       -
                               env: MutableMapping[str, Any]) -> str:

     

       193
       193
       +
           def attr_span_begin(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       234
       194
        
               self._parstack[-1].continuing = True

     

       235
       195
        
               (id_part, class_part) = ("", "")

     

       236
       196
        
               if id := token.attrs.get('id'):

     
···

       240
       200
        
                       class_part = "kbd:["

     

       241
       201
        
                       self._attrspans.append("]")

     

       242
       202
        
                   else:

     

       243
       243
       -
                       return super().attr_span_begin(token, tokens, i, options, env)

     

       203
       203
       +
                       return super().attr_span_begin(token, tokens, i)

     

       244
       204
        
               else:

     

       245
       205
        
                   self._attrspans.append("")

     

       246
       206
        
               return id_part + class_part

     

       247
       247
       -
           def attr_span_end(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       248
       248
       -
                             env: MutableMapping[str, Any]) -> str:

     

       207
       207
       +
           def attr_span_end(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       249
       208
        
               return self._attrspans.pop()

     

       250
       250
       -
           def heading_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       251
       251
       -
                            env: MutableMapping[str, Any]) -> str:

     

       209
       209
       +
           def heading_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       252
       210
        
               return token.markup.replace("#", "=") + " "

     

       253
       253
       -
           def heading_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       254
       254
       -
                             env: MutableMapping[str, Any]) -> str:

     

       211
       211
       +
           def heading_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       255
       212
        
               return "\n"

     

       256
       256
       -
           def ordered_list_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       257
       257
       -
                                 env: MutableMapping[str, Any]) -> str:

     

       213
       213
       +
           def ordered_list_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       258
       214
        
               return self._list_open(token, '.')

     

       259
       259
       -
           def ordered_list_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       260
       260
       -
                                  env: MutableMapping[str, Any]) -> str:

     

       215
       215
       +
           def ordered_list_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       261
       216
        
               return self._list_close()

+45 -89

pkgs/tools/nix/nixos-render-docs/src/nixos_render_docs/commonmark.py

···

       1
       1
       -
       from collections.abc import Mapping, MutableMapping, Sequence

     

       1
       1
       +
       from collections.abc import Mapping, Sequence

     

       2
       2
        
       from dataclasses import dataclass

     

       3
       3
        
       from typing import Any, cast, Optional

     

       4
       4
        
       

     

       5
       5
        
       from .md import md_escape, md_make_code, Renderer

     

       6
       6
        
       

     

       7
       7
        
       from markdown_it.token import Token

     

       8
       8
       -
       from markdown_it.utils import OptionsDict

     

       9
       8
        
       

     

       10
       9
        
       @dataclass(kw_only=True)

     

       11
       10
        
       class List:

     
···

       57
       56
        
                   return s

     

       58
       57
        
               return f"\n{self._parstack[-1].indent}".join(s.splitlines())

     

       59
       58
        
       

     

       60
       60
       -
           def text(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       61
       61
       -
                    env: MutableMapping[str, Any]) -> str:

     

       59
       59
       +
           def text(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       62
       60
        
               self._parstack[-1].continuing = True

     

       63
       61
        
               return self._indent_raw(md_escape(token.content))

     

       64
       64
       -
           def paragraph_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       65
       65
       -
                              env: MutableMapping[str, Any]) -> str:

     

       62
       62
       +
           def paragraph_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       66
       63
        
               return self._maybe_parbreak()

     

       67
       67
       -
           def paragraph_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       68
       68
       -
                               env: MutableMapping[str, Any]) -> str:

     

       64
       64
       +
           def paragraph_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       69
       65
        
               return ""

     

       70
       70
       -
           def hardbreak(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       71
       71
       -
                         env: MutableMapping[str, Any]) -> str:

     

       66
       66
       +
           def hardbreak(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       72
       67
        
               return f"  {self._break()}"

     

       73
       73
       -
           def softbreak(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       74
       74
       -
                         env: MutableMapping[str, Any]) -> str:

     

       68
       68
       +
           def softbreak(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       75
       69
        
               return self._break()

     

       76
       76
       -
           def code_inline(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       77
       77
       -
                           env: MutableMapping[str, Any]) -> str:

     

       70
       70
       +
           def code_inline(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       78
       71
        
               self._parstack[-1].continuing = True

     

       79
       72
        
               return md_make_code(token.content)

     

       80
       80
       -
           def code_block(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       81
       81
       -
                          env: MutableMapping[str, Any]) -> str:

     

       82
       82
       -
               return self.fence(token, tokens, i, options, env)

     

       83
       83
       -
           def link_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       84
       84
       -
                         env: MutableMapping[str, Any]) -> str:

     

       73
       73
       +
           def code_block(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       74
       74
       +
               return self.fence(token, tokens, i)

     

       75
       75
       +
           def link_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       85
       76
        
               self._parstack[-1].continuing = True

     

       86
       77
        
               self._link_stack.append(cast(str, token.attrs['href']))

     

       87
       78
        
               return "["

     

       88
       88
       -
           def link_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       89
       89
       -
                          env: MutableMapping[str, Any]) -> str:

     

       79
       79
       +
           def link_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       90
       80
        
               return f"]({md_escape(self._link_stack.pop())})"

     

       91
       91
       -
           def list_item_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       92
       92
       -
                              env: MutableMapping[str, Any]) -> str:

     

       81
       81
       +
           def list_item_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       93
       82
        
               lst = self._list_stack[-1]

     

       94
       83
        
               lbreak = "" if not lst.first_item_seen else self._break() * (1 if lst.compact else 2)

     

       95
       84
        
               lst.first_item_seen = True

     
···

       99
       88
        
                   lst.next_idx += 1

     

       100
       89
        
               self._enter_block(" " * (len(head) + 1))

     

       101
       90
        
               return f'{lbreak}{head} '

     

       102
       102
       -
           def list_item_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       103
       103
       -
                               env: MutableMapping[str, Any]) -> str:

     

       91
       91
       +
           def list_item_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       104
       92
        
               self._leave_block()

     

       105
       93
        
               return ""

     

       106
       106
       -
           def bullet_list_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       107
       107
       -
                                env: MutableMapping[str, Any]) -> str:

     

       94
       94
       +
           def bullet_list_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       108
       95
        
               self._list_stack.append(List(compact=bool(token.meta['compact'])))

     

       109
       96
        
               return self._maybe_parbreak()

     

       110
       110
       -
           def bullet_list_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       111
       111
       -
                                 env: MutableMapping[str, Any]) -> str:

     

       97
       97
       +
           def bullet_list_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       112
       98
        
               self._list_stack.pop()

     

       113
       99
        
               return ""

     

       114
       114
       -
           def em_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       115
       115
       -
                       env: MutableMapping[str, Any]) -> str:

     

       100
       100
       +
           def em_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       116
       101
        
               return "*"

     

       117
       117
       -
           def em_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       118
       118
       -
                        env: MutableMapping[str, Any]) -> str:

     

       102
       102
       +
           def em_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       119
       103
        
               return "*"

     

       120
       120
       -
           def strong_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       121
       121
       -
                           env: MutableMapping[str, Any]) -> str:

     

       104
       104
       +
           def strong_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       122
       105
        
               return "**"

     

       123
       123
       -
           def strong_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       124
       124
       -
                            env: MutableMapping[str, Any]) -> str:

     

       106
       106
       +
           def strong_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       125
       107
        
               return "**"

     

       126
       126
       -
           def fence(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       127
       127
       -
                     env: MutableMapping[str, Any]) -> str:

     

       108
       108
       +
           def fence(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       128
       109
        
               code = token.content

     

       129
       110
        
               if code.endswith('\n'):

     

       130
       111
        
                   code = code[:-1]

     

       131
       112
        
               pbreak = self._maybe_parbreak()

     

       132
       113
        
               return pbreak + self._indent_raw(md_make_code(code, info=token.info, multiline=True))

     

       133
       133
       -
           def blockquote_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       134
       134
       -
                               env: MutableMapping[str, Any]) -> str:

     

       114
       114
       +
           def blockquote_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       135
       115
        
               pbreak = self._maybe_parbreak()

     

       136
       116
        
               self._enter_block("> ")

     

       137
       117
        
               return pbreak + "> "

     

       138
       138
       -
           def blockquote_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       139
       139
       -
                                env: MutableMapping[str, Any]) -> str:

     

       118
       118
       +
           def blockquote_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       140
       119
        
               self._leave_block()

     

       141
       120
        
               return ""

     

       142
       142
       -
           def note_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       143
       143
       -
                         env: MutableMapping[str, Any]) -> str:

     

       121
       121
       +
           def note_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       144
       122
        
               return self._admonition_open("Note")

     

       145
       145
       -
           def note_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       146
       146
       -
                          env: MutableMapping[str, Any]) -> str:

     

       123
       123
       +
           def note_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       147
       124
        
               return self._admonition_close()

     

       148
       148
       -
           def caution_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       149
       149
       -
                            env: MutableMapping[str, Any]) -> str:

     

       125
       125
       +
           def caution_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       150
       126
        
               return self._admonition_open("Caution")

     

       151
       151
       -
           def caution_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       152
       152
       -
                             env: MutableMapping[str, Any]) -> str:

     

       127
       127
       +
           def caution_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       153
       128
        
               return self._admonition_close()

     

       154
       154
       -
           def important_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       155
       155
       -
                              env: MutableMapping[str, Any]) -> str:

     

       129
       129
       +
           def important_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       156
       130
        
               return self._admonition_open("Important")

     

       157
       157
       -
           def important_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       158
       158
       -
                               env: MutableMapping[str, Any]) -> str:

     

       131
       131
       +
           def important_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       159
       132
        
               return self._admonition_close()

     

       160
       160
       -
           def tip_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       161
       161
       -
                        env: MutableMapping[str, Any]) -> str:

     

       133
       133
       +
           def tip_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       162
       134
        
               return self._admonition_open("Tip")

     

       163
       163
       -
           def tip_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       164
       164
       -
                         env: MutableMapping[str, Any]) -> str:

     

       135
       135
       +
           def tip_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       165
       136
        
               return self._admonition_close()

     

       166
       166
       -
           def warning_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       167
       167
       -
                            env: MutableMapping[str, Any]) -> str:

     

       137
       137
       +
           def warning_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       168
       138
        
               return self._admonition_open("Warning")

     

       169
       169
       -
           def warning_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       170
       170
       -
                             env: MutableMapping[str, Any]) -> str:

     

       139
       139
       +
           def warning_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       171
       140
        
               return self._admonition_close()

     

       172
       172
       -
           def dl_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       173
       173
       -
                       env: MutableMapping[str, Any]) -> str:

     

       141
       141
       +
           def dl_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       174
       142
        
               self._list_stack.append(List(compact=False))

     

       175
       143
        
               return ""

     

       176
       176
       -
           def dl_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       177
       177
       -
                        env: MutableMapping[str, Any]) -> str:

     

       144
       144
       +
           def dl_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       178
       145
        
               self._list_stack.pop()

     

       179
       146
        
               return ""

     

       180
       180
       -
           def dt_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       181
       181
       -
                       env: MutableMapping[str, Any]) -> str:

     

       147
       147
       +
           def dt_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       182
       148
        
               pbreak = self._maybe_parbreak()

     

       183
       149
        
               self._enter_block("   ")

     

       184
       150
        
               # add an opening zero-width non-joiner to separate *our* emphasis from possible

     

       185
       151
        
               # emphasis in the provided term

     

       186
       152
        
               return f'{pbreak} - *{chr(0x200C)}'

     

       187
       187
       -
           def dt_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       188
       188
       -
                        env: MutableMapping[str, Any]) -> str:

     

       153
       153
       +
           def dt_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       189
       154
        
               return f"{chr(0x200C)}*"

     

       190
       190
       -
           def dd_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       191
       191
       -
                       env: MutableMapping[str, Any]) -> str:

     

       155
       155
       +
           def dd_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       192
       156
        
               self._parstack[-1].continuing = True

     

       193
       157
        
               return ""

     

       194
       194
       -
           def dd_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       195
       195
       -
                        env: MutableMapping[str, Any]) -> str:

     

       158
       158
       +
           def dd_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       196
       159
        
               self._leave_block()

     

       197
       160
        
               return ""

     

       198
       198
       -
           def myst_role(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       199
       199
       -
                         env: MutableMapping[str, Any]) -> str:

     

       161
       161
       +
           def myst_role(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       200
       162
        
               self._parstack[-1].continuing = True

     

       201
       163
        
               content = md_make_code(token.content)

     

       202
       164
        
               if token.meta['name'] == 'manpage' and (url := self._manpage_urls.get(token.content)):

     

       203
       165
        
                   return f"[{content}]({url})"

     

       204
       166
        
               return content # no roles in regular commonmark

     

       205
       205
       -
           def attr_span_begin(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       206
       206
       -
                               env: MutableMapping[str, Any]) -> str:

     

       167
       167
       +
           def attr_span_begin(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       207
       168
        
               # there's no way we can emit attrspans correctly in all cases. we could use inline

     

       208
       169
        
               # html for ids, but that would not round-trip. same holds for classes. since this

     

       209
       170
        
               # renderer is only used for approximate options export and all of these things are

     

       210
       171
        
               # not allowed in options we can ignore them for now.

     

       211
       172
        
               return ""

     

       212
       212
       -
           def attr_span_end(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       213
       213
       -
                             env: MutableMapping[str, Any]) -> str:

     

       173
       173
       +
           def attr_span_end(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       214
       174
        
               return ""

     

       215
       215
       -
           def heading_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       216
       216
       -
                            env: MutableMapping[str, Any]) -> str:

     

       175
       175
       +
           def heading_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       217
       176
        
               return token.markup + " "

     

       218
       218
       -
           def heading_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       219
       219
       -
                             env: MutableMapping[str, Any]) -> str:

     

       177
       177
       +
           def heading_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       220
       178
        
               return "\n"

     

       221
       221
       -
           def ordered_list_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       222
       222
       -
                                 env: MutableMapping[str, Any]) -> str:

     

       179
       179
       +
           def ordered_list_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       223
       180
        
               self._list_stack.append(

     

       224
       181
        
                   List(next_idx = cast(int, token.attrs.get('start', 1)),

     

       225
       182
        
                        compact  = bool(token.meta['compact'])))

     

       226
       183
        
               return self._maybe_parbreak()

     

       227
       227
       -
           def ordered_list_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       228
       228
       -
                                  env: MutableMapping[str, Any]) -> str:

     

       184
       184
       +
           def ordered_list_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       229
       185
        
               self._list_stack.pop()

     

       230
       186
        
               return ""

+56 -105

pkgs/tools/nix/nixos-render-docs/src/nixos_render_docs/docbook.py

···

       1
       1
       -
       from collections.abc import Mapping, MutableMapping, Sequence

     

       1
       1
       +
       from collections.abc import Mapping, Sequence

     

       2
       2
        
       from typing import Any, cast, Optional, NamedTuple

     

       3
       3
        
       

     

       4
       4
        
       import markdown_it

     

       5
       5
        
       from markdown_it.token import Token

     

       6
       6
       -
       from markdown_it.utils import OptionsDict

     

       7
       6
        
       from xml.sax.saxutils import escape, quoteattr

     

       8
       7
        
       

     

       9
       8
        
       from .md import Renderer

     
···

       44
       43
        
               self._headings = []

     

       45
       44
        
               self._attrspans = []

     

       46
       45
        
       

     

       47
       47
       -
           def render(self, tokens: Sequence[Token], options: OptionsDict,

     

       48
       48
       -
                      env: MutableMapping[str, Any]) -> str:

     

       49
       49
       -
               result = super().render(tokens, options, env)

     

       50
       50
       -
               result += self._close_headings(None, env)

     

       46
       46
       +
           def render(self, tokens: Sequence[Token]) -> str:

     

       47
       47
       +
               result = super().render(tokens)

     

       48
       48
       +
               result += self._close_headings(None)

     

       51
       49
        
               return result

     

       52
       52
       -
           def renderInline(self, tokens: Sequence[Token], options: OptionsDict,

     

       53
       53
       -
                            env: MutableMapping[str, Any]) -> str:

     

       50
       50
       +
           def renderInline(self, tokens: Sequence[Token]) -> str:

     

       54
       51
        
               # HACK to support docbook links and xrefs. link handling is only necessary because the docbook

     

       55
       52
        
               # manpage stylesheet converts - in urls to a mathematical minus, which may be somewhat incorrect.

     

       56
       53
        
               for i, token in enumerate(tokens):

     
···

       64
       61
        
                   if tokens[i + 1].type == 'text' and tokens[i + 1].content == token.attrs['href']:

     

       65
       62
        
                       tokens[i + 1].content = ''

     

       66
       63
        
       

     

       67
       67
       -
               return super().renderInline(tokens, options, env)

     

       64
       64
       +
               return super().renderInline(tokens)

     

       68
       65
        
       

     

       69
       69
       -
           def text(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       70
       70
       -
                    env: MutableMapping[str, Any]) -> str:

     

       66
       66
       +
           def text(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       71
       67
        
               return escape(token.content)

     

       72
       72
       -
           def paragraph_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       73
       73
       -
                              env: MutableMapping[str, Any]) -> str:

     

       68
       68
       +
           def paragraph_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       74
       69
        
               return "<para>"

     

       75
       75
       -
           def paragraph_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       76
       76
       -
                               env: MutableMapping[str, Any]) -> str:

     

       70
       70
       +
           def paragraph_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       77
       71
        
               return "</para>"

     

       78
       78
       -
           def hardbreak(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       79
       79
       -
                         env: MutableMapping[str, Any]) -> str:

     

       72
       72
       +
           def hardbreak(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       80
       73
        
               return "<literallayout>\n</literallayout>"

     

       81
       81
       -
           def softbreak(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       82
       82
       -
                         env: MutableMapping[str, Any]) -> str:

     

       74
       74
       +
           def softbreak(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       83
       75
        
               # should check options.breaks() and emit hard break if so

     

       84
       76
        
               return "\n"

     

       85
       85
       -
           def code_inline(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       86
       86
       -
                           env: MutableMapping[str, Any]) -> str:

     

       77
       77
       +
           def code_inline(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       87
       78
        
               return f"<literal>{escape(token.content)}</literal>"

     

       88
       88
       -
           def code_block(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       89
       89
       -
                          env: MutableMapping[str, Any]) -> str:

     

       79
       79
       +
           def code_block(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       90
       80
        
               return f"<programlisting>{escape(token.content)}</programlisting>"

     

       91
       91
       -
           def link_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       92
       92
       -
                         env: MutableMapping[str, Any]) -> str:

     

       81
       81
       +
           def link_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       93
       82
        
               self._link_tags.append(token.tag)

     

       94
       83
        
               href = cast(str, token.attrs['href'])

     

       95
       84
        
               (attr, start) = ('linkend', 1) if href[0] == '#' else ('xlink:href', 0)

     

       96
       85
        
               return f"<{token.tag} {attr}={quoteattr(href[start:])}>"

     

       97
       97
       -
           def link_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       98
       98
       -
                          env: MutableMapping[str, Any]) -> str:

     

       86
       86
       +
           def link_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       99
       87
        
               return f"</{self._link_tags.pop()}>"

     

       100
       100
       -
           def list_item_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       101
       101
       -
                              env: MutableMapping[str, Any]) -> str:

     

       88
       88
       +
           def list_item_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       102
       89
        
               return "<listitem>"

     

       103
       103
       -
           def list_item_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       104
       104
       -
                               env: MutableMapping[str, Any]) -> str:

     

       90
       90
       +
           def list_item_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       105
       91
        
               return "</listitem>\n"

     

       106
       92
        
           # HACK open and close para for docbook change size. remove soon.

     

       107
       107
       -
           def bullet_list_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       108
       108
       -
                                env: MutableMapping[str, Any]) -> str:

     

       93
       93
       +
           def bullet_list_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       109
       94
        
               spacing = ' spacing="compact"' if token.meta.get('compact', False) else ''

     

       110
       95
        
               return f"<para><itemizedlist{spacing}>\n"

     

       111
       111
       -
           def bullet_list_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       112
       112
       -
                                 env: MutableMapping[str, Any]) -> str:

     

       96
       96
       +
           def bullet_list_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       113
       97
        
               return "\n</itemizedlist></para>"

     

       114
       114
       -
           def em_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       115
       115
       -
                       env: MutableMapping[str, Any]) -> str:

     

       98
       98
       +
           def em_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       116
       99
        
               return "<emphasis>"

     

       117
       117
       -
           def em_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       118
       118
       -
                        env: MutableMapping[str, Any]) -> str:

     

       100
       100
       +
           def em_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       119
       101
        
               return "</emphasis>"

     

       120
       120
       -
           def strong_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       121
       121
       -
                           env: MutableMapping[str, Any]) -> str:

     

       102
       102
       +
           def strong_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       122
       103
        
               return "<emphasis role=\"strong\">"

     

       123
       123
       -
           def strong_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       124
       124
       -
                            env: MutableMapping[str, Any]) -> str:

     

       104
       104
       +
           def strong_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       125
       105
        
               return "</emphasis>"

     

       126
       126
       -
           def fence(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       127
       127
       -
                     env: MutableMapping[str, Any]) -> str:

     

       106
       106
       +
           def fence(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       128
       107
        
               info = f" language={quoteattr(token.info)}" if token.info != "" else ""

     

       129
       108
        
               return f"<programlisting{info}>{escape(token.content)}</programlisting>"

     

       130
       130
       -
           def blockquote_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       131
       131
       -
                               env: MutableMapping[str, Any]) -> str:

     

       109
       109
       +
           def blockquote_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       132
       110
        
               return "<para><blockquote>"

     

       133
       133
       -
           def blockquote_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       134
       134
       -
                                env: MutableMapping[str, Any]) -> str:

     

       111
       111
       +
           def blockquote_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       135
       112
        
               return "</blockquote></para>"

     

       136
       136
       -
           def note_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       137
       137
       -
                         env: MutableMapping[str, Any]) -> str:

     

       113
       113
       +
           def note_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       138
       114
        
               return "<para><note>"

     

       139
       139
       -
           def note_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       140
       140
       -
                          env: MutableMapping[str, Any]) -> str:

     

       115
       115
       +
           def note_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       141
       116
        
               return "</note></para>"

     

       142
       142
       -
           def caution_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       143
       143
       -
                            env: MutableMapping[str, Any]) -> str:

     

       117
       117
       +
           def caution_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       144
       118
        
               return "<para><caution>"

     

       145
       145
       -
           def caution_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       146
       146
       -
                             env: MutableMapping[str, Any]) -> str:

     

       119
       119
       +
           def caution_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       147
       120
        
               return "</caution></para>"

     

       148
       148
       -
           def important_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       149
       149
       -
                              env: MutableMapping[str, Any]) -> str:

     

       121
       121
       +
           def important_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       150
       122
        
               return "<para><important>"

     

       151
       151
       -
           def important_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       152
       152
       -
                               env: MutableMapping[str, Any]) -> str:

     

       123
       123
       +
           def important_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       153
       124
        
               return "</important></para>"

     

       154
       154
       -
           def tip_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       155
       155
       -
                        env: MutableMapping[str, Any]) -> str:

     

       125
       125
       +
           def tip_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       156
       126
        
               return "<para><tip>"

     

       157
       157
       -
           def tip_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       158
       158
       -
                         env: MutableMapping[str, Any]) -> str:

     

       127
       127
       +
           def tip_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       159
       128
        
               return "</tip></para>"

     

       160
       160
       -
           def warning_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       161
       161
       -
                            env: MutableMapping[str, Any]) -> str:

     

       129
       129
       +
           def warning_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       162
       130
        
               return "<para><warning>"

     

       163
       163
       -
           def warning_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       164
       164
       -
                             env: MutableMapping[str, Any]) -> str:

     

       131
       131
       +
           def warning_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       165
       132
        
               return "</warning></para>"

     

       166
       133
        
           # markdown-it emits tokens based on the html syntax tree, but docbook is

     

       167
       134
        
           # slightly different. html has <dl>{<dt/>{<dd/>}}</dl>,

     

       168
       135
        
           # docbook has <variablelist>{<varlistentry><term/><listitem/></varlistentry>}<variablelist>

     

       169
       136
        
           # we have to reject multiple definitions for the same term for time being.

     

       170
       170
       -
           def dl_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       171
       171
       -
                       env: MutableMapping[str, Any]) -> str:

     

       137
       137
       +
           def dl_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       172
       138
        
               self._deflists.append(Deflist())

     

       173
       139
        
               return "<para><variablelist>"

     

       174
       174
       -
           def dl_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       175
       175
       -
                        env: MutableMapping[str, Any]) -> str:

     

       140
       140
       +
           def dl_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       176
       141
        
               self._deflists.pop()

     

       177
       142
        
               return "</variablelist></para>"

     

       178
       178
       -
           def dt_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       179
       179
       -
                       env: MutableMapping[str, Any]) -> str:

     

       143
       143
       +
           def dt_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       180
       144
        
               self._deflists[-1].has_dd = False

     

       181
       145
        
               return "<varlistentry><term>"

     

       182
       182
       -
           def dt_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       183
       183
       -
                        env: MutableMapping[str, Any]) -> str:

     

       146
       146
       +
           def dt_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       184
       147
        
               return "</term>"

     

       185
       185
       -
           def dd_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       186
       186
       -
                       env: MutableMapping[str, Any]) -> str:

     

       148
       148
       +
           def dd_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       187
       149
        
               if self._deflists[-1].has_dd:

     

       188
       150
        
                   raise Exception("multiple definitions per term not supported")

     

       189
       151
        
               self._deflists[-1].has_dd = True

     

       190
       152
        
               return "<listitem>"

     

       191
       191
       -
           def dd_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       192
       192
       -
                        env: MutableMapping[str, Any]) -> str:

     

       153
       153
       +
           def dd_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       193
       154
        
               return "</listitem></varlistentry>"

     

       194
       194
       -
           def myst_role(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       195
       195
       -
                         env: MutableMapping[str, Any]) -> str:

     

       155
       155
       +
           def myst_role(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       196
       156
        
               if token.meta['name'] == 'command':

     

       197
       157
        
                   return f"<command>{escape(token.content)}</command>"

     

       198
       158
        
               if token.meta['name'] == 'file':

     
···

       215
       175
        
                   else:

     

       216
       176
        
                       return ref

     

       217
       177
        
               raise NotImplementedError("md node not supported yet", token)

     

       218
       218
       -
           def attr_span_begin(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       219
       219
       -
                               env: MutableMapping[str, Any]) -> str:

     

       178
       178
       +
           def attr_span_begin(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       220
       179
        
               # we currently support *only* inline anchors and the special .keycap class to produce

     

       221
       180
        
               # <keycap> docbook elements.

     

       222
       181
        
               (id_part, class_part) = ("", "")

     
···

       227
       186
        
                       class_part = "<keycap>"

     

       228
       187
        
                       self._attrspans.append("</keycap>")

     

       229
       188
        
                   else:

     

       230
       230
       -
                       return super().attr_span_begin(token, tokens, i, options, env)

     

       189
       189
       +
                       return super().attr_span_begin(token, tokens, i)

     

       231
       190
        
               else:

     

       232
       191
        
                   self._attrspans.append("")

     

       233
       192
        
               return id_part + class_part

     

       234
       234
       -
           def attr_span_end(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       235
       235
       -
                               env: MutableMapping[str, Any]) -> str:

     

       193
       193
       +
           def attr_span_end(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       236
       194
        
               return self._attrspans.pop()

     

       237
       237
       -
           def ordered_list_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       238
       238
       -
                                 env: MutableMapping[str, Any]) -> str:

     

       195
       195
       +
           def ordered_list_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       239
       196
        
               start = f' startingnumber="{token.attrs["start"]}"' if 'start' in token.attrs else ""

     

       240
       197
        
               spacing = ' spacing="compact"' if token.meta.get('compact', False) else ''

     

       241
       198
        
               return f"<orderedlist{start}{spacing}>"

     

       242
       242
       -
           def ordered_list_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       243
       243
       -
                                  env: MutableMapping[str, Any]) -> str:

     

       199
       199
       +
           def ordered_list_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       244
       200
        
               return f"</orderedlist>"

     

       245
       245
       -
           def heading_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       246
       246
       -
                            env: MutableMapping[str, Any]) -> str:

     

       201
       201
       +
           def heading_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       247
       202
        
               hlevel = int(token.tag[1:])

     

       248
       248
       -
               result = self._close_headings(hlevel, env)

     

       249
       249
       -
               (tag, attrs) = self._heading_tag(token, tokens, i, options, env)

     

       203
       203
       +
               result = self._close_headings(hlevel)

     

       204
       204
       +
               (tag, attrs) = self._heading_tag(token, tokens, i)

     

       250
       205
        
               self._headings.append(Heading(tag, hlevel))

     

       251
       206
        
               attrs_str = "".join([ f" {k}={quoteattr(v)}" for k, v in attrs.items() ])

     

       252
       207
        
               return result + f'<{tag}{attrs_str}>\n<title>'

     

       253
       253
       -
           def heading_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       254
       254
       -
                             env: MutableMapping[str, Any]) -> str:

     

       208
       208
       +
           def heading_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       255
       209
        
               heading = self._headings[-1]

     

       256
       210
        
               result = '</title>'

     

       257
       211
        
               if heading.container_tag == 'part':

     
···

       263
       217
        
                       maybe_id = " xml:id=" + quoteattr(id + "-intro")

     

       264
       218
        
                   result += f"<partintro{maybe_id}>"

     

       265
       219
        
               return result

     

       266
       266
       -
           def example_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       267
       267
       -
                            env: MutableMapping[str, Any]) -> str:

     

       220
       220
       +
           def example_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       268
       221
        
               if id := token.attrs.get('id'):

     

       269
       222
        
                   return f"<anchor xml:id={quoteattr(cast(str, id))} />"

     

       270
       223
        
               return ""

     

       271
       271
       -
           def example_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       272
       272
       -
                             env: MutableMapping[str, Any]) -> str:

     

       224
       224
       +
           def example_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       273
       225
        
               return ""

     

       274
       226
        
       

     

       275
       275
       -
           def _close_headings(self, level: Optional[int], env: MutableMapping[str, Any]) -> str:

     

       227
       227
       +
           def _close_headings(self, level: Optional[int]) -> str:

     

       276
       228
        
               # we rely on markdown-it producing h{1..6} tags in token.tag for this to work

     

       277
       229
        
               result = []

     

       278
       230
        
               while len(self._headings):

     
···

       285
       237
        
                       break

     

       286
       238
        
               return "\n".join(result)

     

       287
       239
        
       

     

       288
       288
       -
           def _heading_tag(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       289
       289
       -
                            env: MutableMapping[str, Any]) -> tuple[str, dict[str, str]]:

     

       240
       240
       +
           def _heading_tag(self, token: Token, tokens: Sequence[Token], i: int) -> tuple[str, dict[str, str]]:

     

       290
       241
        
               attrs = {}

     

       291
       242
        
               if id := token.attrs.get('id'):

     

       292
       243
        
                   attrs['xml:id'] = cast(str, id)

+48 -93

pkgs/tools/nix/nixos-render-docs/src/nixos_render_docs/manpage.py

···

       1
       1
       -
       from collections.abc import Mapping, MutableMapping, Sequence

     

       1
       1
       +
       from collections.abc import Mapping, Sequence

     

       2
       2
        
       from dataclasses import dataclass

     

       3
       3
        
       from typing import Any, cast, Iterable, Optional

     

       4
       4
        
       

     
···

       6
       6
        
       

     

       7
       7
        
       import markdown_it

     

       8
       8
        
       from markdown_it.token import Token

     

       9
       9
       -
       from markdown_it.utils import OptionsDict

     

       10
       9
        
       

     

       11
       10
        
       from .md import Renderer

     

       12
       11
        
       

     
···

       123
       122
        
               self._leave_block()

     

       124
       123
        
               return ".RE"

     

       125
       124
        
       

     

       126
       126
       -
           def render(self, tokens: Sequence[Token], options: OptionsDict,

     

       127
       127
       -
                      env: MutableMapping[str, Any]) -> str:

     

       125
       125
       +
           def render(self, tokens: Sequence[Token]) -> str:

     

       128
       126
        
               self._do_parbreak_stack = [ False ]

     

       129
       127
        
               self._font_stack = [ "\\fR" ]

     

       130
       130
       -
               return super().render(tokens, options, env)

     

       128
       128
       +
               return super().render(tokens)

     

       131
       129
        
       

     

       132
       132
       -
           def text(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       133
       133
       -
                    env: MutableMapping[str, Any]) -> str:

     

       130
       130
       +
           def text(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       134
       131
        
               return man_escape(token.content)

     

       135
       135
       -
           def paragraph_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       136
       136
       -
                              env: MutableMapping[str, Any]) -> str:

     

       132
       132
       +
           def paragraph_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       137
       133
        
               return self._maybe_parbreak()

     

       138
       138
       -
           def paragraph_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       139
       139
       -
                               env: MutableMapping[str, Any]) -> str:

     

       134
       134
       +
           def paragraph_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       140
       135
        
               return ""

     

       141
       141
       -
           def hardbreak(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       142
       142
       -
                         env: MutableMapping[str, Any]) -> str:

     

       136
       136
       +
           def hardbreak(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       143
       137
        
               return ".br"

     

       144
       144
       -
           def softbreak(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       145
       145
       -
                         env: MutableMapping[str, Any]) -> str:

     

       138
       138
       +
           def softbreak(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       146
       139
        
               return " "

     

       147
       147
       -
           def code_inline(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       148
       148
       -
                           env: MutableMapping[str, Any]) -> str:

     

       140
       140
       +
           def code_inline(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       149
       141
        
               s = _protect_spaces(man_escape(token.content))

     

       150
       142
        
               return f"\\fR\\(oq{s}\\(cq\\fP" if self.inline_code_is_quoted else s

     

       151
       151
       -
           def code_block(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       152
       152
       -
                          env: MutableMapping[str, Any]) -> str:

     

       153
       153
       -
               return self.fence(token, tokens, i, options, env)

     

       154
       154
       -
           def link_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       155
       155
       -
                         env: MutableMapping[str, Any]) -> str:

     

       143
       143
       +
           def code_block(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       144
       144
       +
               return self.fence(token, tokens, i)

     

       145
       145
       +
           def link_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       156
       146
        
               href = cast(str, token.attrs['href'])

     

       157
       147
        
               self._link_stack.append(href)

     

       158
       148
        
               text = ""

     
···

       161
       151
        
                   text = self._href_targets[href]

     

       162
       152
        
               self._font_stack.append("\\fB")

     

       163
       153
        
               return f"\\fB{text}\0 <"

     

       164
       164
       -
           def link_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       165
       165
       -
                          env: MutableMapping[str, Any]) -> str:

     

       154
       154
       +
           def link_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       166
       155
        
               href = self._link_stack.pop()

     

       167
       156
        
               text = ""

     

       168
       157
        
               if self.link_footnotes is not None:

     
···

       174
       163
        
                   text = "\\fR" + man_escape(f"[{idx}]")

     

       175
       164
        
               self._font_stack.pop()

     

       176
       165
        
               return f">\0 {text}{self._font_stack[-1]}"

     

       177
       177
       -
           def list_item_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       178
       178
       -
                              env: MutableMapping[str, Any]) -> str:

     

       166
       166
       +
           def list_item_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       179
       167
        
               self._enter_block()

     

       180
       168
        
               lst = self._list_stack[-1]

     

       181
       169
        
               maybe_space = '' if lst.compact or not lst.first_item_seen else '.sp\n'

     
···

       189
       177
        
                   f'.RS {lst.width}\n'

     

       190
       178
        
                   f"\\h'-{len(head) + 1}'\\fB{man_escape(head)}\\fP\\h'1'\\c"

     

       191
       179
        
               )

     

       192
       192
       -
           def list_item_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       193
       193
       -
                               env: MutableMapping[str, Any]) -> str:

     

       180
       180
       +
           def list_item_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       194
       181
        
               self._leave_block()

     

       195
       182
        
               return ".RE"

     

       196
       196
       -
           def bullet_list_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       197
       197
       -
                                env: MutableMapping[str, Any]) -> str:

     

       183
       183
       +
           def bullet_list_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       198
       184
        
               self._list_stack.append(List(width=4, compact=bool(token.meta['compact'])))

     

       199
       185
        
               return self._maybe_parbreak()

     

       200
       200
       -
           def bullet_list_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       201
       201
       -
                                 env: MutableMapping[str, Any]) -> str:

     

       186
       186
       +
           def bullet_list_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       202
       187
        
               self._list_stack.pop()

     

       203
       188
        
               return ""

     

       204
       204
       -
           def em_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       205
       205
       -
                       env: MutableMapping[str, Any]) -> str:

     

       189
       189
       +
           def em_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       206
       190
        
               self._font_stack.append("\\fI")

     

       207
       191
        
               return "\\fI"

     

       208
       208
       -
           def em_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       209
       209
       -
                        env: MutableMapping[str, Any]) -> str:

     

       192
       192
       +
           def em_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       210
       193
        
               self._font_stack.pop()

     

       211
       194
        
               return self._font_stack[-1]

     

       212
       212
       -
           def strong_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       213
       213
       -
                           env: MutableMapping[str, Any]) -> str:

     

       195
       195
       +
           def strong_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       214
       196
        
               self._font_stack.append("\\fB")

     

       215
       197
        
               return "\\fB"

     

       216
       216
       -
           def strong_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       217
       217
       -
                            env: MutableMapping[str, Any]) -> str:

     

       198
       198
       +
           def strong_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       218
       199
        
               self._font_stack.pop()

     

       219
       200
        
               return self._font_stack[-1]

     

       220
       220
       -
           def fence(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       221
       221
       -
                     env: MutableMapping[str, Any]) -> str:

     

       201
       201
       +
           def fence(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       222
       202
        
               s = man_escape(token.content).rstrip('\n')

     

       223
       203
        
               return (

     

       224
       204
        
                   '.sp\n'

     
···

       228
       208
        
                   '.fi\n'

     

       229
       209
        
                   '.RE'

     

       230
       210
        
               )

     

       231
       231
       -
           def blockquote_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       232
       232
       -
                               env: MutableMapping[str, Any]) -> str:

     

       211
       211
       +
           def blockquote_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       233
       212
        
               maybe_par = self._maybe_parbreak("\n")

     

       234
       213
        
               self._enter_block()

     

       235
       214
        
               return (

     
···

       237
       216
        
                   ".RS 4\n"

     

       238
       217
        
                   f"\\h'-3'\\fI\\(lq\\(rq\\fP\\h'1'\\c"

     

       239
       218
        
               )

     

       240
       240
       -
           def blockquote_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       241
       241
       -
                                env: MutableMapping[str, Any]) -> str:

     

       219
       219
       +
           def blockquote_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       242
       220
        
               self._leave_block()

     

       243
       221
        
               return ".RE"

     

       244
       244
       -
           def note_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       245
       245
       -
                         env: MutableMapping[str, Any]) -> str:

     

       222
       222
       +
           def note_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       246
       223
        
               return self._admonition_open("Note")

     

       247
       247
       -
           def note_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       248
       248
       -
                          env: MutableMapping[str, Any]) -> str:

     

       224
       224
       +
           def note_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       249
       225
        
               return self._admonition_close()

     

       250
       250
       -
           def caution_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       251
       251
       -
                            env: MutableMapping[str, Any]) -> str:

     

       226
       226
       +
           def caution_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       252
       227
        
               return self._admonition_open( "Caution")

     

       253
       253
       -
           def caution_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       254
       254
       -
                             env: MutableMapping[str, Any]) -> str:

     

       228
       228
       +
           def caution_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       255
       229
        
               return self._admonition_close()

     

       256
       256
       -
           def important_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       257
       257
       -
                              env: MutableMapping[str, Any]) -> str:

     

       230
       230
       +
           def important_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       258
       231
        
               return self._admonition_open( "Important")

     

       259
       259
       -
           def important_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       260
       260
       -
                               env: MutableMapping[str, Any]) -> str:

     

       232
       232
       +
           def important_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       261
       233
        
               return self._admonition_close()

     

       262
       262
       -
           def tip_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       263
       263
       -
                        env: MutableMapping[str, Any]) -> str:

     

       234
       234
       +
           def tip_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       264
       235
        
               return self._admonition_open( "Tip")

     

       265
       265
       -
           def tip_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       266
       266
       -
                         env: MutableMapping[str, Any]) -> str:

     

       236
       236
       +
           def tip_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       267
       237
        
               return self._admonition_close()

     

       268
       268
       -
           def warning_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       269
       269
       -
                            env: MutableMapping[str, Any]) -> str:

     

       238
       238
       +
           def warning_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       270
       239
        
               return self._admonition_open( "Warning")

     

       271
       271
       -
           def warning_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       272
       272
       -
                             env: MutableMapping[str, Any]) -> str:

     

       240
       240
       +
           def warning_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       273
       241
        
               return self._admonition_close()

     

       274
       274
       -
           def dl_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       275
       275
       -
                       env: MutableMapping[str, Any]) -> str:

     

       242
       242
       +
           def dl_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       276
       243
        
               return ".RS 4"

     

       277
       277
       -
           def dl_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       278
       278
       -
                        env: MutableMapping[str, Any]) -> str:

     

       244
       244
       +
           def dl_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       279
       245
        
               return ".RE"

     

       280
       280
       -
           def dt_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       281
       281
       -
                       env: MutableMapping[str, Any]) -> str:

     

       246
       246
       +
           def dt_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       282
       247
        
               return ".PP"

     

       283
       283
       -
           def dt_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       284
       284
       -
                        env: MutableMapping[str, Any]) -> str:

     

       248
       248
       +
           def dt_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       285
       249
        
               return ""

     

       286
       286
       -
           def dd_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       287
       287
       -
                       env: MutableMapping[str, Any]) -> str:

     

       250
       250
       +
           def dd_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       288
       251
        
               self._enter_block()

     

       289
       252
        
               return ".RS 4"

     

       290
       290
       -
           def dd_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       291
       291
       -
                        env: MutableMapping[str, Any]) -> str:

     

       253
       253
       +
           def dd_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       292
       254
        
               self._leave_block()

     

       293
       255
        
               return ".RE"

     

       294
       294
       -
           def myst_role(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       295
       295
       -
                         env: MutableMapping[str, Any]) -> str:

     

       256
       256
       +
           def myst_role(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       296
       257
        
               if token.meta['name'] in [ 'command', 'env', 'option' ]:

     

       297
       258
        
                   return f'\\fB{man_escape(token.content)}\\fP'

     

       298
       259
        
               elif token.meta['name'] in [ 'file', 'var' ]:

     
···

       303
       264
        
                   return f'\\fB{man_escape(page)}\\fP\\fR({man_escape(section)})\\fP'

     

       304
       265
        
               else:

     

       305
       266
        
                   raise NotImplementedError("md node not supported yet", token)

     

       306
       306
       -
           def attr_span_begin(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       307
       307
       -
                               env: MutableMapping[str, Any]) -> str:

     

       267
       267
       +
           def attr_span_begin(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       308
       268
        
               # mdoc knows no anchors so we can drop those, but classes must be rejected.

     

       309
       269
        
               if 'class' in token.attrs:

     

       310
       310
       -
                   return super().attr_span_begin(token, tokens, i, options, env)

     

       270
       270
       +
                   return super().attr_span_begin(token, tokens, i)

     

       311
       271
        
               return ""

     

       312
       312
       -
           def attr_span_end(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       313
       313
       -
                             env: MutableMapping[str, Any]) -> str:

     

       272
       272
       +
           def attr_span_end(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       314
       273
        
               return ""

     

       315
       315
       -
           def heading_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       316
       316
       -
                            env: MutableMapping[str, Any]) -> str:

     

       274
       274
       +
           def heading_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       317
       275
        
               raise RuntimeError("md token not supported in manpages", token)

     

       318
       318
       -
           def heading_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       319
       319
       -
                             env: MutableMapping[str, Any]) -> str:

     

       276
       276
       +
           def heading_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       320
       277
        
               raise RuntimeError("md token not supported in manpages", token)

     

       321
       321
       -
           def ordered_list_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       322
       322
       -
                                 env: MutableMapping[str, Any]) -> str:

     

       278
       278
       +
           def ordered_list_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       323
       279
        
               # max item head width for a number, a dot, and one leading space and one trailing space

     

       324
       280
        
               width = 3 + len(str(cast(int, token.meta['end'])))

     

       325
       281
        
               self._list_stack.append(

     
···

       327
       283
        
                        next_idx = cast(int, token.attrs.get('start', 1)),

     

       328
       284
        
                        compact  = bool(token.meta['compact'])))

     

       329
       285
        
               return self._maybe_parbreak()

     

       330
       330
       -
           def ordered_list_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       331
       331
       -
                                  env: MutableMapping[str, Any]) -> str:

     

       286
       286
       +
           def ordered_list_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       332
       287
        
               self._list_stack.pop()

     

       333
       288
        
               return ""

+22 -31

pkgs/tools/nix/nixos-render-docs/src/nixos_render_docs/manual.py

···

       2
       2
        
       import json

     

       3
       3
        
       

     

       4
       4
        
       from abc import abstractmethod

     

       5
       5
       -
       from collections.abc import Mapping, MutableMapping, Sequence

     

       5
       5
       +
       from collections.abc import Mapping, Sequence

     

       6
       6
        
       from pathlib import Path

     

       7
       7
        
       from typing import Any, cast, NamedTuple, Optional, Union

     

       8
       8
        
       from xml.sax.saxutils import escape, quoteattr

     

       9
       9
        
       

     

       10
       10
        
       import markdown_it

     

       11
       11
        
       from markdown_it.token import Token

     

       12
       12
       -
       from markdown_it.utils import OptionsDict

     

       13
       12
        
       

     

       14
       13
        
       from . import options

     

       15
       14
        
       from .docbook import DocBookRenderer, Heading

     
···

       30
       29
        
                   'included_options': self.included_options,

     

       31
       30
        
               }

     

       32
       31
        
       

     

       33
       33
       -
           def render(self, tokens: Sequence[Token], options: OptionsDict,

     

       34
       34
       -
                      env: MutableMapping[str, Any]) -> str:

     

       32
       32
       +
           def render(self, tokens: Sequence[Token]) -> str:

     

       35
       33
        
               wanted = { 'h1': 'title' }

     

       36
       34
        
               wanted |= { 'h2': 'subtitle' } if self._toplevel_tag == 'book' else {}

     

       37
       35
        
               for (i, (tag, kind)) in enumerate(wanted.items()):

     
···

       62
       60
        
                   return (f'<book xmlns="http://docbook.org/ns/docbook"'

     

       63
       61
        
                           f'      xmlns:xlink="http://www.w3.org/1999/xlink"'

     

       64
       62
        
                           f'      {maybe_id} version="5.0">'

     

       65
       65
       -
                           f'  <title>{self.renderInline(tokens[1].children, options, env)}</title>'

     

       66
       66
       -
                           f'  <subtitle>{self.renderInline(tokens[4].children, options, env)}</subtitle>'

     

       67
       67
       -
                           f'  {super().render(tokens[6:], options, env)}'

     

       63
       63
       +
                           f'  <title>{self.renderInline(tokens[1].children)}</title>'

     

       64
       64
       +
                           f'  <subtitle>{self.renderInline(tokens[4].children)}</subtitle>'

     

       65
       65
       +
                           f'  {super().render(tokens[6:])}'

     

       68
       66
        
                           f'</book>')

     

       69
       67
        
       

     

       70
       70
       -
               return super().render(tokens, options, env)

     

       68
       68
       +
               return super().render(tokens)

     

       71
       69
        
       

     

       72
       72
       -
           def _heading_tag(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       73
       73
       -
                            env: MutableMapping[str, Any]) -> tuple[str, dict[str, str]]:

     

       74
       74
       -
               (tag, attrs) = super()._heading_tag(token, tokens, i, options, env)

     

       70
       70
       +
           def _heading_tag(self, token: Token, tokens: Sequence[Token], i: int) -> tuple[str, dict[str, str]]:

     

       71
       71
       +
               (tag, attrs) = super()._heading_tag(token, tokens, i)

     

       75
       72
        
               # render() has already verified that we don't have supernumerary headings and since the

     

       76
       73
        
               # book tag is handled specially we can leave the check this simple

     

       77
       74
        
               if token.tag != 'h1':

     
···

       81
       78
        
                   'xmlns:xlink': "http://www.w3.org/1999/xlink",

     

       82
       79
        
               })

     

       83
       80
        
       

     

       84
       84
       -
           def _included_thing(self, tag: str, token: Token, tokens: Sequence[Token], i: int,

     

       85
       85
       -
                               options: OptionsDict, env: MutableMapping[str, Any]) -> str:

     

       81
       81
       +
           def _included_thing(self, tag: str, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       86
       82
        
               result = []

     

       87
       83
        
               # close existing partintro. the generic render doesn't really need this because

     

       88
       84
        
               # it doesn't have a concept of structure in the way the manual does.

     
···

       94
       90
        
               r = ManualDocBookRenderer(tag, self._manpage_urls)

     

       95
       91
        
               for (included, path) in token.meta['included']:

     

       96
       92
        
                   try:

     

       97
       97
       -
                       result.append(r.render(included, options, env))

     

       93
       93
       +
                       result.append(r.render(included))

     

       98
       94
        
                   except Exception as e:

     

       99
       95
        
                       raise RuntimeError(f"rendering {path}") from e

     

       100
       96
        
               return "".join(result)

     

       101
       101
       -
           def included_options(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       102
       102
       -
                                env: MutableMapping[str, Any]) -> str:

     

       97
       97
       +
           def included_options(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       103
       98
        
               return cast(str, token.meta['rendered-options'])

     

       104
       99
        
       

     

       105
       100
        
           # TODO minimize docbook diffs with existing conversions. remove soon.

     

       106
       106
       -
           def paragraph_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       107
       107
       -
                              env: MutableMapping[str, Any]) -> str:

     

       108
       108
       -
               return super().paragraph_open(token, tokens, i, options, env) + "\n "

     

       109
       109
       -
           def paragraph_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       110
       110
       -
                               env: MutableMapping[str, Any]) -> str:

     

       111
       111
       -
               return "\n" + super().paragraph_close(token, tokens, i, options, env)

     

       112
       112
       -
           def code_block(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       113
       113
       -
                          env: MutableMapping[str, Any]) -> str:

     

       101
       101
       +
           def paragraph_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       102
       102
       +
               return super().paragraph_open(token, tokens, i) + "\n "

     

       103
       103
       +
           def paragraph_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       104
       104
       +
               return "\n" + super().paragraph_close(token, tokens, i)

     

       105
       105
       +
           def code_block(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       114
       106
        
               return f"<programlisting>\n{escape(token.content)}</programlisting>"

     

       115
       115
       -
           def fence(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       116
       116
       -
                     env: MutableMapping[str, Any]) -> str:

     

       107
       107
       +
           def fence(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       117
       108
        
               info = f" language={quoteattr(token.info)}" if token.info != "" else ""

     

       118
       109
        
               return f"<programlisting{info}>\n{escape(token.content)}</programlisting>"

     

       119
       110
        
       

     
···

       134
       125
        
               except Exception as e:

     

       135
       126
        
                   raise RuntimeError(f"failed to render manual {file}") from e

     

       136
       127
        
       

     

       137
       137
       -
           def _parse(self, src: str, env: Optional[MutableMapping[str, Any]] = None) -> list[Token]:

     

       138
       138
       -
               tokens = super()._parse(src, env)

     

       128
       128
       +
           def _parse(self, src: str) -> list[Token]:

     

       129
       129
       +
               tokens = super()._parse(src)

     

       139
       130
        
               for token in tokens:

     

       140
       131
        
                   if token.type != "fence" or not token.info.startswith("{=include=} "):

     

       141
       132
        
                       continue

     
···

       145
       136
        
                       self._parse_options(token)

     

       146
       137
        
                   elif typ in [ 'sections', 'chapters', 'preface', 'parts', 'appendix' ]:

     

       147
       138
        
                       token.type = 'included_' + typ

     

       148
       148
       -
                       self._parse_included_blocks(token, env)

     

       139
       139
       +
                       self._parse_included_blocks(token)

     

       149
       140
        
                   else:

     

       150
       141
        
                       raise RuntimeError(f"unsupported structural include type '{typ}'")

     

       151
       142
        
               return tokens

     

       152
       143
        
       

     

       153
       153
       -
           def _parse_included_blocks(self, token: Token, env: Optional[MutableMapping[str, Any]]) -> None:

     

       144
       144
       +
           def _parse_included_blocks(self, token: Token) -> None:

     

       154
       145
        
               assert token.map

     

       155
       146
        
               included = token.meta['included'] = []

     

       156
       147
        
               for (lnum, line) in enumerate(token.content.splitlines(), token.map[0] + 2):

     
···

       161
       152
        
                   try:

     

       162
       153
        
                       self._base_paths.append(path)

     

       163
       154
        
                       with open(path, 'r') as f:

     

       164
       164
       -
                           tokens = self._parse(f.read(), env)

     

       155
       155
       +
                           tokens = self._parse(f.read())

     

       165
       156
        
                           included.append((tokens, path))

     

       166
       157
        
                       self._base_paths.pop()

     

       167
       158
        
                   except Exception as e:

+59 -109

pkgs/tools/nix/nixos-render-docs/src/nixos_render_docs/md.py

···

       104
       104
        
           def _join_inline(self, ls: Iterable[str]) -> str:

     

       105
       105
        
               return "".join(ls)

     

       106
       106
        
       

     

       107
       107
       -
           def admonition_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       108
       108
       -
                               env: MutableMapping[str, Any]) -> str:

     

       107
       107
       +
           def admonition_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       109
       108
        
               tag = token.meta['kind']

     

       110
       109
        
               self._admonition_stack.append(tag)

     

       111
       111
       -
               return self._admonitions[tag][0](token, tokens, i, options, env)

     

       112
       112
       -
           def admonition_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       113
       113
       -
                                env: MutableMapping[str, Any]) -> str:

     

       114
       114
       -
               return self._admonitions[self._admonition_stack.pop()][1](token, tokens, i, options, env)

     

       110
       110
       +
               return self._admonitions[tag][0](token, tokens, i)

     

       111
       111
       +
           def admonition_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       112
       112
       +
               return self._admonitions[self._admonition_stack.pop()][1](token, tokens, i)

     

       115
       113
        
       

     

       116
       116
       -
           def render(self, tokens: Sequence[Token], options: OptionsDict,

     

       117
       117
       -
                      env: MutableMapping[str, Any]) -> str:

     

       114
       114
       +
           def render(self, tokens: Sequence[Token]) -> str:

     

       118
       115
        
               def do_one(i: int, token: Token) -> str:

     

       119
       116
        
                   if token.type == "inline":

     

       120
       117
        
                       assert token.children is not None

     

       121
       121
       -
                       return self.renderInline(token.children, options, env)

     

       118
       118
       +
                       return self.renderInline(token.children)

     

       122
       119
        
                   elif token.type in self.rules:

     

       123
       123
       -
                       return self.rules[token.type](tokens[i], tokens, i, options, env)

     

       120
       120
       +
                       return self.rules[token.type](tokens[i], tokens, i)

     

       124
       121
        
                   else:

     

       125
       122
        
                       raise NotImplementedError("md token not supported yet", token)

     

       126
       123
        
               return self._join_block(map(lambda arg: do_one(*arg), enumerate(tokens)))

     

       127
       127
       -
           def renderInline(self, tokens: Sequence[Token], options: OptionsDict,

     

       128
       128
       -
                            env: MutableMapping[str, Any]) -> str:

     

       124
       124
       +
           def renderInline(self, tokens: Sequence[Token]) -> str:

     

       129
       125
        
               def do_one(i: int, token: Token) -> str:

     

       130
       126
        
                   if token.type in self.rules:

     

       131
       131
       -
                       return self.rules[token.type](tokens[i], tokens, i, options, env)

     

       127
       127
       +
                       return self.rules[token.type](tokens[i], tokens, i)

     

       132
       128
        
                   else:

     

       133
       129
        
                       raise NotImplementedError("md token not supported yet", token)

     

       134
       130
        
               return self._join_inline(map(lambda arg: do_one(*arg), enumerate(tokens)))

     

       135
       131
        
       

     

       136
       136
       -
           def text(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       137
       137
       -
                    env: MutableMapping[str, Any]) -> str:

     

       132
       132
       +
           def text(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       138
       133
        
               raise RuntimeError("md token not supported", token)

     

       139
       139
       -
           def paragraph_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       140
       140
       -
                              env: MutableMapping[str, Any]) -> str:

     

       134
       134
       +
           def paragraph_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       141
       135
        
               raise RuntimeError("md token not supported", token)

     

       142
       142
       -
           def paragraph_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       143
       143
       -
                               env: MutableMapping[str, Any]) -> str:

     

       136
       136
       +
           def paragraph_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       144
       137
        
               raise RuntimeError("md token not supported", token)

     

       145
       145
       -
           def hardbreak(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       146
       146
       -
                         env: MutableMapping[str, Any]) -> str:

     

       138
       138
       +
           def hardbreak(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       147
       139
        
               raise RuntimeError("md token not supported", token)

     

       148
       148
       -
           def softbreak(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       149
       149
       -
                         env: MutableMapping[str, Any]) -> str:

     

       140
       140
       +
           def softbreak(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       150
       141
        
               raise RuntimeError("md token not supported", token)

     

       151
       151
       -
           def code_inline(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       152
       152
       -
                           env: MutableMapping[str, Any]) -> str:

     

       142
       142
       +
           def code_inline(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       153
       143
        
               raise RuntimeError("md token not supported", token)

     

       154
       154
       -
           def code_block(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       155
       155
       -
                          env: MutableMapping[str, Any]) -> str:

     

       144
       144
       +
           def code_block(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       156
       145
        
               raise RuntimeError("md token not supported", token)

     

       157
       157
       -
           def link_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       158
       158
       -
                         env: MutableMapping[str, Any]) -> str:

     

       146
       146
       +
           def link_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       159
       147
        
               raise RuntimeError("md token not supported", token)

     

       160
       160
       -
           def link_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       161
       161
       -
                          env: MutableMapping[str, Any]) -> str:

     

       148
       148
       +
           def link_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       162
       149
        
               raise RuntimeError("md token not supported", token)

     

       163
       163
       -
           def list_item_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       164
       164
       -
                              env: MutableMapping[str, Any]) -> str:

     

       150
       150
       +
           def list_item_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       165
       151
        
               raise RuntimeError("md token not supported", token)

     

       166
       166
       -
           def list_item_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       167
       167
       -
                               env: MutableMapping[str, Any]) -> str:

     

       152
       152
       +
           def list_item_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       168
       153
        
               raise RuntimeError("md token not supported", token)

     

       169
       169
       -
           def bullet_list_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       170
       170
       -
                                env: MutableMapping[str, Any]) -> str:

     

       154
       154
       +
           def bullet_list_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       171
       155
        
               raise RuntimeError("md token not supported", token)

     

       172
       172
       -
           def bullet_list_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       173
       173
       -
                                 env: MutableMapping[str, Any]) -> str:

     

       156
       156
       +
           def bullet_list_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       174
       157
        
               raise RuntimeError("md token not supported", token)

     

       175
       175
       -
           def em_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       176
       176
       -
                       env: MutableMapping[str, Any]) -> str:

     

       158
       158
       +
           def em_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       177
       159
        
               raise RuntimeError("md token not supported", token)

     

       178
       178
       -
           def em_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       179
       179
       -
                        env: MutableMapping[str, Any]) -> str:

     

       160
       160
       +
           def em_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       180
       161
        
               raise RuntimeError("md token not supported", token)

     

       181
       181
       -
           def strong_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       182
       182
       -
                           env: MutableMapping[str, Any]) -> str:

     

       162
       162
       +
           def strong_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       183
       163
        
               raise RuntimeError("md token not supported", token)

     

       184
       184
       -
           def strong_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       185
       185
       -
                            env: MutableMapping[str, Any]) -> str:

     

       164
       164
       +
           def strong_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       186
       165
        
               raise RuntimeError("md token not supported", token)

     

       187
       187
       -
           def fence(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       188
       188
       -
                     env: MutableMapping[str, Any]) -> str:

     

       166
       166
       +
           def fence(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       189
       167
        
               raise RuntimeError("md token not supported", token)

     

       190
       190
       -
           def blockquote_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       191
       191
       -
                               env: MutableMapping[str, Any]) -> str:

     

       168
       168
       +
           def blockquote_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       192
       169
        
               raise RuntimeError("md token not supported", token)

     

       193
       193
       -
           def blockquote_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       194
       194
       -
                                env: MutableMapping[str, Any]) -> str:

     

       170
       170
       +
           def blockquote_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       195
       171
        
               raise RuntimeError("md token not supported", token)

     

       196
       196
       -
           def note_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       197
       197
       -
                         env: MutableMapping[str, Any]) -> str:

     

       172
       172
       +
           def note_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       198
       173
        
               raise RuntimeError("md token not supported", token)

     

       199
       199
       -
           def note_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       200
       200
       -
                          env: MutableMapping[str, Any]) -> str:

     

       174
       174
       +
           def note_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       201
       175
        
               raise RuntimeError("md token not supported", token)

     

       202
       202
       -
           def caution_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       203
       203
       -
                            env: MutableMapping[str, Any]) -> str:

     

       176
       176
       +
           def caution_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       204
       177
        
               raise RuntimeError("md token not supported", token)

     

       205
       205
       -
           def caution_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       206
       206
       -
                             env: MutableMapping[str, Any]) -> str:

     

       178
       178
       +
           def caution_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       207
       179
        
               raise RuntimeError("md token not supported", token)

     

       208
       208
       -
           def important_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       209
       209
       -
                              env: MutableMapping[str, Any]) -> str:

     

       180
       180
       +
           def important_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       210
       181
        
               raise RuntimeError("md token not supported", token)

     

       211
       211
       -
           def important_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       212
       212
       -
                               env: MutableMapping[str, Any]) -> str:

     

       182
       182
       +
           def important_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       213
       183
        
               raise RuntimeError("md token not supported", token)

     

       214
       214
       -
           def tip_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       215
       215
       -
                        env: MutableMapping[str, Any]) -> str:

     

       184
       184
       +
           def tip_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       216
       185
        
               raise RuntimeError("md token not supported", token)

     

       217
       217
       -
           def tip_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       218
       218
       -
                         env: MutableMapping[str, Any]) -> str:

     

       186
       186
       +
           def tip_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       219
       187
        
               raise RuntimeError("md token not supported", token)

     

       220
       220
       -
           def warning_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       221
       221
       -
                            env: MutableMapping[str, Any]) -> str:

     

       188
       188
       +
           def warning_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       222
       189
        
               raise RuntimeError("md token not supported", token)

     

       223
       223
       -
           def warning_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       224
       224
       -
                             env: MutableMapping[str, Any]) -> str:

     

       190
       190
       +
           def warning_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       225
       191
        
               raise RuntimeError("md token not supported", token)

     

       226
       226
       -
           def dl_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       227
       227
       -
                       env: MutableMapping[str, Any]) -> str:

     

       192
       192
       +
           def dl_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       228
       193
        
               raise RuntimeError("md token not supported", token)

     

       229
       229
       -
           def dl_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       230
       230
       -
                        env: MutableMapping[str, Any]) -> str:

     

       194
       194
       +
           def dl_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       231
       195
        
               raise RuntimeError("md token not supported", token)

     

       232
       232
       -
           def dt_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       233
       233
       -
                       env: MutableMapping[str, Any]) -> str:

     

       196
       196
       +
           def dt_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       234
       197
        
               raise RuntimeError("md token not supported", token)

     

       235
       235
       -
           def dt_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       236
       236
       -
                        env: MutableMapping[str, Any]) -> str:

     

       198
       198
       +
           def dt_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       237
       199
        
               raise RuntimeError("md token not supported", token)

     

       238
       238
       -
           def dd_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       239
       239
       -
                       env: MutableMapping[str, Any]) -> str:

     

       200
       200
       +
           def dd_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       240
       201
        
               raise RuntimeError("md token not supported", token)

     

       241
       241
       -
           def dd_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       242
       242
       -
                        env: MutableMapping[str, Any]) -> str:

     

       202
       202
       +
           def dd_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       243
       203
        
               raise RuntimeError("md token not supported", token)

     

       244
       244
       -
           def myst_role(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       245
       245
       -
                         env: MutableMapping[str, Any]) -> str:

     

       204
       204
       +
           def myst_role(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       246
       205
        
               raise RuntimeError("md token not supported", token)

     

       247
       247
       -
           def attr_span_begin(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       248
       248
       -
                               env: MutableMapping[str, Any]) -> str:

     

       206
       206
       +
           def attr_span_begin(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       249
       207
        
               raise RuntimeError("md token not supported", token)

     

       250
       250
       -
           def attr_span_end(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       251
       251
       -
                             env: MutableMapping[str, Any]) -> str:

     

       208
       208
       +
           def attr_span_end(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       252
       209
        
               raise RuntimeError("md token not supported", token)

     

       253
       253
       -
           def heading_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       254
       254
       -
                            env: MutableMapping[str, Any]) -> str:

     

       210
       210
       +
           def heading_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       255
       211
        
               raise RuntimeError("md token not supported", token)

     

       256
       256
       -
           def heading_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       257
       257
       -
                             env: MutableMapping[str, Any]) -> str:

     

       212
       212
       +
           def heading_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       258
       213
        
               raise RuntimeError("md token not supported", token)

     

       259
       259
       -
           def ordered_list_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       260
       260
       -
                                 env: MutableMapping[str, Any]) -> str:

     

       214
       214
       +
           def ordered_list_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       261
       215
        
               raise RuntimeError("md token not supported", token)

     

       262
       262
       -
           def ordered_list_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       263
       263
       -
                                  env: MutableMapping[str, Any]) -> str:

     

       216
       216
       +
           def ordered_list_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       264
       217
        
               raise RuntimeError("md token not supported", token)

     

       265
       265
       -
           def example_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       266
       266
       -
                            env: MutableMapping[str, Any]) -> str:

     

       218
       218
       +
           def example_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       267
       219
        
               raise RuntimeError("md token not supported", token)

     

       268
       268
       -
           def example_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       269
       269
       -
                             env: MutableMapping[str, Any]) -> str:

     

       220
       220
       +
           def example_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       270
       221
        
               raise RuntimeError("md token not supported", token)

     

       271
       222
        
       

     

       272
       223
        
       def _is_escaped(src: str, pos: int) -> bool:

     
···

       510
       461
        
               self._md.use(_block_attr)

     

       511
       462
        
               self._md.enable(["smartquotes", "replacements"])

     

       512
       463
        
       

     

       513
       513
       -
           def _parse(self, src: str, env: Optional[MutableMapping[str, Any]] = None) -> list[Token]:

     

       514
       514
       -
               return self._md.parse(src, env if env is not None else {})

     

       464
       464
       +
           def _parse(self, src: str) -> list[Token]:

     

       465
       465
       +
               return self._md.parse(src, {})

     

       515
       466
        
       

     

       516
       516
       -
           def _render(self, src: str, env: Optional[MutableMapping[str, Any]] = None) -> str:

     

       517
       517
       -
               env = {} if env is None else env

     

       518
       518
       -
               tokens = self._parse(src, env)

     

       519
       519
       -
               return self._renderer.render(tokens, self._md.options, env)

     

       467
       467
       +
           def _render(self, src: str) -> str:

     

       468
       468
       +
               tokens = self._parse(src)

     

       469
       469
       +
               return self._renderer.render(tokens)

+9 -16

pkgs/tools/nix/nixos-render-docs/src/nixos_render_docs/options.py

···

       4
       4
        
       import json

     

       5
       5
        
       

     

       6
       6
        
       from abc import abstractmethod

     

       7
       7
       -
       from collections.abc import Mapping, MutableMapping, Sequence

     

       8
       8
       -
       from markdown_it.utils import OptionsDict

     

       7
       7
       +
       from collections.abc import Mapping, Sequence

     

       9
       8
        
       from markdown_it.token import Token

     

       10
       9
        
       from typing import Any, Generic, Optional

     

       11
       10
        
       from urllib.parse import quote

     
···

       174
       173
        
           def finalize(self) -> str: raise NotImplementedError()

     

       175
       174
        
       

     

       176
       175
        
       class OptionDocsRestrictions:

     

       177
       177
       -
           def heading_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       178
       178
       -
                            env: MutableMapping[str, Any]) -> str:

     

       176
       176
       +
           def heading_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       179
       177
        
               raise RuntimeError("md token not supported in options doc", token)

     

       180
       180
       -
           def heading_close(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       181
       181
       -
                             env: MutableMapping[str, Any]) -> str:

     

       178
       178
       +
           def heading_close(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       182
       179
        
               raise RuntimeError("md token not supported in options doc", token)

     

       183
       183
       -
           def attr_span_begin(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       184
       184
       -
                               env: MutableMapping[str, Any]) -> str:

     

       180
       180
       +
           def attr_span_begin(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       185
       181
        
               raise RuntimeError("md token not supported in options doc", token)

     

       186
       186
       -
           def example_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       187
       187
       -
                            env: MutableMapping[str, Any]) -> str:

     

       182
       182
       +
           def example_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       188
       183
        
               raise RuntimeError("md token not supported in options doc", token)

     

       189
       184
        
       

     

       190
       185
        
       class OptionsDocBookRenderer(OptionDocsRestrictions, DocBookRenderer):

     

       191
       186
        
           # TODO keep optionsDocBook diff small. remove soon if rendering is still good.

     

       192
       192
       -
           def ordered_list_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       193
       193
       -
                                 env: MutableMapping[str, Any]) -> str:

     

       187
       187
       +
           def ordered_list_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       194
       188
        
               token.meta['compact'] = False

     

       195
       195
       -
               return super().ordered_list_open(token, tokens, i, options, env)

     

       196
       196
       -
           def bullet_list_open(self, token: Token, tokens: Sequence[Token], i: int, options: OptionsDict,

     

       197
       197
       -
                                env: MutableMapping[str, Any]) -> str:

     

       189
       189
       +
               return super().ordered_list_open(token, tokens, i)

     

       190
       190
       +
           def bullet_list_open(self, token: Token, tokens: Sequence[Token], i: int) -> str:

     

       198
       191
        
               token.meta['compact'] = False

     

       199
       199
       -
               return super().bullet_list_open(token, tokens, i, options, env)

     

       192
       192
       +
               return super().bullet_list_open(token, tokens, i)

     

       200
       193
        
       

     

       201
       194
        
       class DocBookConverter(BaseConverter[OptionsDocBookRenderer]):

     

       202
       195
        
           __option_block_separator__ = ""

+2 -3

pkgs/tools/nix/nixos-render-docs/src/nixos_render_docs/types.py

···

       1
       1
       -
       from collections.abc import Sequence, MutableMapping

     

       1
       1
       +
       from collections.abc import Sequence

     

       2
       2
        
       from typing import Any, Callable, Optional, Tuple, NamedTuple

     

       3
       3
        
       

     

       4
       4
        
       from markdown_it.token import Token

     

       5
       5
       -
       from markdown_it.utils import OptionsDict

     

       6
       5
        
       

     

       7
       6
        
       OptionLoc = str | dict[str, str]

     

       8
       7
        
       Option = dict[str, str | dict[str, str] | list[OptionLoc]]

     
···

       12
       11
        
           lines: list[str]

     

       13
       12
        
           links: Optional[list[str]] = None

     

       14
       13
        
       

     

       15
       15
       -
       RenderFn = Callable[[Token, Sequence[Token], int, OptionsDict, MutableMapping[str, Any]], str]

     

       14
       14
       +
       RenderFn = Callable[[Token, Sequence[Token], int], str]