commit e5e738b72a879f7c12b314df11f0d1528fc066dc · pyrox.dev/nixpkgs

+7 -6

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

···

       569
       569
        
                   self._redirection_targets.add(into)

     

       570
       570
        
               return tokens

     

       571
       571
        
       

     

       572
       572
       -
           def _number_examples(self, tokens: Sequence[Token], start: int = 1) -> int:

     

       572
       572
       +
           def _number_block(self, block: str, prefix: str, tokens: Sequence[Token], start: int = 1) -> int:

     

       573
       573
       +
               title_open, title_close = f'{block}_title_open', f'{block}_title_close'

     

       573
       574
        
               for (i, token) in enumerate(tokens):

     

       574
       574
       -
                   if token.type == "example_title_open":

     

       575
       575
       +
                   if token.type == title_open:

     

       575
       576
        
                       title = tokens[i + 1]

     

       576
       577
        
                       assert title.type == 'inline' and title.children

     

       577
       578
        
                       # the prefix is split into two tokens because the xref title_html will want

     

       578
       579
        
                       # only the first of the two, but both must be rendered into the example itself.

     

       579
       580
        
                       title.children = (

     

       580
       581
        
                           [

     

       581
       581
       -
                               Token('text', '', 0, content=f'Example {start}'),

     

       582
       582
       +
                               Token('text', '', 0, content=f'{prefix} {start}'),

     

       582
       583
        
                               Token('text', '', 0, content='. ')

     

       583
       584
        
                           ] + title.children

     

       584
       585
        
                       )

     

       585
       586
        
                       start += 1

     

       586
       587
        
                   elif token.type.startswith('included_') and token.type != 'included_options':

     

       587
       588
        
                       for sub, _path in token.meta['included']:

     

       588
       588
       -
                           start = self._number_examples(sub, start)

     

       589
       589
       +
                           start = self._number_block(block, prefix, sub, start)

     

       589
       590
        
               return start

     

       590
       591
        
       

     

       591
       592
        
           # xref | (id, type, heading inlines, file, starts new file)

     
···

       636
       637
        
                   toc_html = f"{n}. {title_html}"

     

       637
       638
        
                   title_html = f"Appendix&nbsp;{n}"

     

       638
       639
        
               elif typ == 'example':

     

       639
       639
       -
                   # skip the prepended `Example N. ` from _number_examples

     

       640
       640
       +
                   # skip the prepended `Example N. ` from numbering

     

       640
       641
        
                   toc_html, title = self._renderer.renderInline(inlines.children[2:]), title_html

     

       641
       642
        
                   # xref title wants only the prepended text, sans the trailing colon and space

     

       642
       643
        
                   title_html = self._renderer.renderInline(inlines.children[0:1])

     
···

       651
       652
        
               return XrefTarget(id, title_html, toc_html, re.sub('<.*?>', '', title), path, drop_fragment)

     

       652
       653
        
       

     

       653
       654
        
           def _postprocess(self, infile: Path, outfile: Path, tokens: Sequence[Token]) -> None:

     

       654
       654
       -
               self._number_examples(tokens)

     

       655
       655
       +
               self._number_block('example', "Example", tokens)

     

       655
       656
        
               xref_queue = self._collect_ids(tokens, outfile.name, 'book', True)

     

       656
       657
        
       

     

       657
       658
        
               failed = False

+19 -13

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

···

       1
       1
        
       from abc import ABC

     

       2
       2
        
       from collections.abc import Mapping, MutableMapping, Sequence

     

       3
       3
       -
       from typing import Any, cast, Generic, get_args, Iterable, Literal, NoReturn, Optional, TypeVar

     

       3
       3
       +
       from typing import Any, Callable, cast, Generic, get_args, Iterable, Literal, NoReturn, Optional, TypeVar

     

       4
       4
        
       

     

       5
       5
        
       import dataclasses

     

       6
       6
        
       import re

     
···

       426
       426
        
       

     

       427
       427
        
           md.core.ruler.push("block_attr", block_attr)

     

       428
       428
        
       

     

       429
       429
       -
       def _example_titles(md: markdown_it.MarkdownIt) -> None:

     

       429
       429
       +
       def _block_titles(block: str) -> Callable[[markdown_it.MarkdownIt], None]:

     

       430
       430
       +
           open, close = f'{block}_open', f'{block}_close'

     

       431
       431
       +
           title_open, title_close = f'{block}_title_open', f'{block}_title_close'

     

       432
       432
       +
       

     

       430
       433
        
           """

     

       431
       431
       -
           find title headings of examples and stick them into meta for renderers, then

     

       432
       432
       -
           remove them from the token stream. also checks whether any example contains a

     

       434
       434
       +
           find title headings of blocks and stick them into meta for renderers, then

     

       435
       435
       +
           remove them from the token stream. also checks whether any block contains a

     

       433
       436
        
           non-title heading since those would make toc generation extremely complicated.

     

       434
       437
        
           """

     

       435
       435
       -
           def example_titles(state: markdown_it.rules_core.StateCore) -> None:

     

       438
       438
       +
           def block_titles(state: markdown_it.rules_core.StateCore) -> None:

     

       436
       439
        
               in_example = [False]

     

       437
       440
        
               for i, token in enumerate(state.tokens):

     

       438
       438
       -
                   if token.type == 'example_open':

     

       441
       441
       +
                   if token.type == open:

     

       439
       442
        
                       if state.tokens[i + 1].type == 'heading_open':

     

       440
       443
        
                           assert state.tokens[i + 3].type == 'heading_close'

     

       441
       441
       -
                           state.tokens[i + 1].type = 'example_title_open'

     

       442
       442
       -
                           state.tokens[i + 3].type = 'example_title_close'

     

       444
       444
       +
                           state.tokens[i + 1].type = title_open

     

       445
       445
       +
                           state.tokens[i + 3].type = title_close

     

       443
       446
        
                       else:

     

       444
       447
        
                           assert token.map

     

       445
       445
       -
                           raise RuntimeError(f"found example without title in line {token.map[0] + 1}")

     

       448
       448
       +
                           raise RuntimeError(f"found {block} without title in line {token.map[0] + 1}")

     

       446
       449
        
                       in_example.append(True)

     

       447
       447
       -
                   elif token.type == 'example_close':

     

       450
       450
       +
                   elif token.type == close:

     

       448
       451
        
                       in_example.pop()

     

       449
       452
        
                   elif token.type == 'heading_open' and in_example[-1]:

     

       450
       453
        
                       assert token.map

     

       451
       451
       -
                       raise RuntimeError(f"unexpected non-title heading in example in line {token.map[0] + 1}")

     

       454
       454
       +
                       raise RuntimeError(f"unexpected non-title heading in {block} in line {token.map[0] + 1}")

     

       455
       455
       +
       

     

       456
       456
       +
           def do_add(md: markdown_it.MarkdownIt) -> None:

     

       457
       457
       +
               md.core.ruler.push(f"{block}_titles", block_titles)

     

       452
       458
        
       

     

       453
       453
       -
           md.core.ruler.push("example_titles", example_titles)

     

       459
       459
       +
           return do_add

     

       454
       460
        
       

     

       455
       461
        
       TR = TypeVar('TR', bound='Renderer')

     

       456
       462
        
       

     
···

       494
       500
        
               self._md.use(_heading_ids)

     

       495
       501
        
               self._md.use(_compact_list_attr)

     

       496
       502
        
               self._md.use(_block_attr)

     

       497
       497
       -
               self._md.use(_example_titles)

     

       503
       503
       +
               self._md.use(_block_titles("example"))

     

       498
       504
        
               self._md.enable(["smartquotes", "replacements"])

     

       499
       505
        
       

     

       500
       506
        
           def _parse(self, src: str) -> list[Token]: