commit 8c2d14a6b850458020fd4ce079a90ee87e64c7a6 · pyrox.dev/nixpkgs

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

···

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

     

       185
       185
        
               self._list_stack.pop()

     

       186
       186
        
               return ""

     

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

     

       188
       188
       +
               if title := cast(str, token.attrs.get('title', '')):

     

       189
       189
       +
                   title = ' "' + title.replace('"', '\\"') + '"'

     

       190
       190
       +
               return f'![{token.content}]({token.attrs["src"]}{title})'

+13

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

···

       44
       44
        
               result += self._close_headings(None)

     

       45
       45
        
               return result

     

       46
       46
        
       

     

       47
       47
       +
           def _pull_image(self, path: str) -> str:

     

       48
       48
       +
               raise NotImplementedError()

     

       49
       49
       +
       

     

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

     

       48
       51
        
               return escape(token.content)

     

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

     
···

       224
       227
        
               return '<p class="title"><strong>'

     

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

     

       226
       229
        
               return '</strong></p><div class="example-contents">'

     

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

     

       231
       231
       +
               src = self._pull_image(cast(str, token.attrs['src']))

     

       232
       232
       +
               alt = f'alt="{escape(token.content, True)}"' if token.content else ""

     

       233
       233
       +
               if title := cast(str, token.attrs.get('title', '')):

     

       234
       234
       +
                   title = f'title="{escape(title, True)}"'

     

       235
       235
       +
               return (

     

       236
       236
       +
                   '<div class="mediaobject">'

     

       237
       237
       +
                   f'<img src="{escape(src, True)}" {alt} {title} />'

     

       238
       238
       +
                   '</div>'

     

       239
       239
       +
               )

     

       227
       240
        
       

     

       228
       241
        
           def _make_hN(self, level: int) -> tuple[str, str]:

     

       229
       242
        
               return f"h{min(6, max(1, level + self._hlevel_offset))}", ""

+29 -7

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

···

       1
       1
        
       import argparse

     

       2
       2
       +
       import hashlib

     

       2
       3
        
       import html

     

       3
       4
        
       import json

     

       4
       5
        
       import re

     
···

       241
       242
        
           toc_depth: int

     

       242
       243
        
           chunk_toc_depth: int

     

       243
       244
        
           section_toc_depth: int

     

       245
       245
       +
           media_dir: Path

     

       244
       246
        
       

     

       245
       247
        
       class ManualHTMLRenderer(RendererMixin, HTMLRenderer):

     

       246
       248
        
           _base_path: Path

     

       249
       249
       +
           _in_dir: Path

     

       247
       250
        
           _html_params: HTMLParameters

     

       248
       251
        
       

     

       249
       252
        
           def __init__(self, toplevel_tag: str, revision: str, html_params: HTMLParameters,

     

       250
       253
        
                        manpage_urls: Mapping[str, str], xref_targets: dict[str, XrefTarget],

     

       251
       251
       -
                        base_path: Path):

     

       254
       254
       +
                        in_dir: Path, base_path: Path):

     

       252
       255
        
               super().__init__(toplevel_tag, revision, manpage_urls, xref_targets)

     

       253
       253
       -
               self._base_path, self._html_params = base_path, html_params

     

       256
       256
       +
               self._in_dir = in_dir

     

       257
       257
       +
               self._base_path = base_path.absolute()

     

       258
       258
       +
               self._html_params = html_params

     

       259
       259
       +
       

     

       260
       260
       +
           def _pull_image(self, src: str) -> str:

     

       261
       261
       +
               src_path = Path(src)

     

       262
       262
       +
               content = (self._in_dir / src_path).read_bytes()

     

       263
       263
       +
               # images may be used more than once, but we want to store them only once and

     

       264
       264
       +
               # in an easily accessible (ie, not input-file-path-dependent) location without

     

       265
       265
       +
               # having to maintain a mapping structure. hashing the file and using the hash

     

       266
       266
       +
               # as both the path of the final image provides both.

     

       267
       267
       +
               content_hash = hashlib.sha3_256(content).hexdigest()

     

       268
       268
       +
               target_name = f"{content_hash}{src_path.suffix}"

     

       269
       269
       +
               target_path = self._base_path / self._html_params.media_dir / target_name

     

       270
       270
       +
               target_path.write_bytes(content)

     

       271
       271
       +
               return f"./{self._html_params.media_dir}/{target_name}"

     

       254
       272
        
       

     

       255
       273
        
           def _push(self, tag: str, hlevel_offset: int) -> Any:

     

       256
       256
       -
               result = (self._toplevel_tag, self._headings, self._attrspans, self._hlevel_offset)

     

       274
       274
       +
               result = (self._toplevel_tag, self._headings, self._attrspans, self._hlevel_offset, self._in_dir)

     

       257
       275
        
               self._hlevel_offset += hlevel_offset

     

       258
       276
        
               self._toplevel_tag, self._headings, self._attrspans = tag, [], []

     

       259
       277
        
               return result

     

       260
       278
        
       

     

       261
       279
        
           def _pop(self, state: Any) -> None:

     

       262
       262
       -
               (self._toplevel_tag, self._headings, self._attrspans, self._hlevel_offset) = state

     

       280
       280
       +
               (self._toplevel_tag, self._headings, self._attrspans, self._hlevel_offset, self._in_dir) = state

     

       263
       281
        
       

     

       264
       282
        
           def _render_book(self, tokens: Sequence[Token]) -> str:

     

       265
       283
        
               assert tokens[4].children

     
···

       481
       499
        
                   # we do not set _hlevel_offset=0 because docbook doesn't either.

     

       482
       500
        
               else:

     

       483
       501
        
                   inner = outer

     

       502
       502
       +
               in_dir = self._in_dir

     

       484
       503
        
               for included, path in fragments:

     

       485
       504
        
                   try:

     

       505
       505
       +
                       self._in_dir = (in_dir / path).parent

     

       486
       506
        
                       inner.append(self.render(included))

     

       487
       507
        
                   except Exception as e:

     

       488
       508
        
                       raise RuntimeError(f"rendering {path}") from e

     
···

       525
       545
        
               # renderer not set on purpose since it has a dependency on the output path!

     

       526
       546
        
       

     

       527
       547
        
           def convert(self, infile: Path, outfile: Path) -> None:

     

       528
       528
       -
               self._renderer = ManualHTMLRenderer('book', self._revision, self._html_params,

     

       529
       529
       -
                                                   self._manpage_urls, self._xref_targets, outfile.parent)

     

       548
       548
       +
               self._renderer = ManualHTMLRenderer(

     

       549
       549
       +
                   'book', self._revision, self._html_params, self._manpage_urls, self._xref_targets,

     

       550
       550
       +
                   infile.parent, outfile.parent)

     

       530
       551
        
               super().convert(infile, outfile)

     

       531
       552
        
       

     

       532
       553
        
           def _parse(self, src: str) -> list[Token]:

     
···

       687
       708
        
           p.add_argument('--toc-depth', default=1, type=int)

     

       688
       709
        
           p.add_argument('--chunk-toc-depth', default=1, type=int)

     

       689
       710
        
           p.add_argument('--section-toc-depth', default=0, type=int)

     

       711
       711
       +
           p.add_argument('--media-dir', default="media", type=Path)

     

       690
       712
        
           p.add_argument('infile', type=Path)

     

       691
       713
        
           p.add_argument('outfile', type=Path)

     

       692
       714
        
       

     
···

       700
       722
        
               md = HTMLConverter(

     

       701
       723
        
                   args.revision,

     

       702
       724
        
                   HTMLParameters(args.generator, args.stylesheet, args.script, args.toc_depth,

     

       703
       703
       -
                                  args.chunk_toc_depth, args.section_toc_depth),

     

       725
       725
       +
                                  args.chunk_toc_depth, args.section_toc_depth, args.media_dir),

     

       704
       726
        
                   json.load(manpage_urls))

     

       705
       727
        
               md.convert(args.infile, args.outfile)

     

       706
       728

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

···

       90
       90
        
                   "example_close": self.example_close,

     

       91
       91
        
                   "example_title_open": self.example_title_open,

     

       92
       92
        
                   "example_title_close": self.example_title_close,

     

       93
       93
       +
                   "image": self.image,

     

       93
       94
        
               }

     

       94
       95
        
       

     

       95
       96
        
               self._admonitions = {

     
···

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

     

       225
       226
        
               raise RuntimeError("md token not supported", token)

     

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

     

       228
       228
       +
               raise RuntimeError("md token not supported", token)

     

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

     

       227
       230
        
               raise RuntimeError("md token not supported", token)

     

       228
       231
        
       

     

       229
       232
        
       def _is_escaped(src: str, pos: int) -> bool:

pkgs/tools/nix/nixos-render-docs/src/tests/test_commonmark.py

···

       91
       91
        
        - *‌more stuff in same deflist‌*

     

       92
       92
        
          

     

       93
       93
        
          foo""".replace(' ', ' ')

     

       94
       94
       +
       

     

       95
       95
       +
       def test_images() -> None:

     

       96
       96
       +
           c = Converter({})

     

       97
       97
       +
           assert c._render("![*alt text*](foo \"title \\\"quoted\\\" text\")") == (

     

       98
       98
       +
               "![*alt text*](foo \"title \\\"quoted\\\" text\")"

     

       99
       99
       +
           )

+15 -1

pkgs/tools/nix/nixos-render-docs/src/tests/test_html.py

···

       3
       3
        
       

     

       4
       4
        
       from sample_md import sample1

     

       5
       5
        
       

     

       6
       6
       +
       class Renderer(nrd.html.HTMLRenderer):

     

       7
       7
       +
           def _pull_image(self, src: str) -> str:

     

       8
       8
       +
               return src

     

       9
       9
       +
       

     

       6
       10
        
       class Converter(nrd.md.Converter[nrd.html.HTMLRenderer]):

     

       7
       11
        
           def __init__(self, manpage_urls: dict[str, str], xrefs: dict[str, nrd.manual_structure.XrefTarget]):

     

       8
       12
        
               super().__init__()

     

       9
       9
       -
               self._renderer = nrd.html.HTMLRenderer(manpage_urls, xrefs)

     

       13
       13
       +
               self._renderer = Renderer(manpage_urls, xrefs)

     

       10
       14
        
       

     

       11
       15
        
       def unpretty(s: str) -> str:

     

       12
       16
        
           return "".join(map(str.strip, s.splitlines())).replace('␣', ' ').replace('↵', '\n')

     
···

       68
       72
        
           with pytest.raises(nrd.html.UnresolvedXrefError) as exc:

     

       69
       73
        
               c._render("[](#baz)")

     

       70
       74
        
           assert exc.value.args[0] == 'bad local reference, id #baz not known'

     

       75
       75
       +
       

     

       76
       76
       +
       def test_images() -> None:

     

       77
       77
       +
           c = Converter({}, {})

     

       78
       78
       +
           assert c._render("![*alt text*](foo \"title text\")") == unpretty("""

     

       79
       79
       +
             <p>

     

       80
       80
       +
              <div class="mediaobject">

     

       81
       81
       +
               <img src="foo" alt="*alt text*" title="title text" />

     

       82
       82
       +
              </div>

     

       83
       83
       +
             </p>

     

       84
       84
       +
           """)

     

       71
       85
        
       

     

       72
       86
        
       def test_full() -> None:

     

       73
       87
        
           c = Converter({ 'man(1)': 'http://example.org' }, {})