xhtml2pdf 0.2.22__tar.gz → 0.2.23__tar.gz

{xhtml2pdf-0.2.22/xhtml2pdf.egg-info → xhtml2pdf-0.2.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xhtml2pdf
-Version: 0.2.22
+Version: 0.2.23
 Summary: PDF generator using HTML and CSS
 Author-email: Dirk Holtwick <dirk.holtwick@gmail.com>
 Maintainer-email: Luis Zarate <luisza14@gmail.com>, Timo Brembeck <opensource@timo.brembeck.email>

xhtml2pdf-0.2.23/tests/test_block_box.py

@@ -0,0 +1,486 @@
+"""A block's padding, border and background drawn once around all it holds (#627)."""
+
+from __future__ import annotations
+
+import io
+from typing import TYPE_CHECKING, NamedTuple
+from unittest import TestCase, mock
+
+from pypdf import PdfReader
+from reportlab.lib.colors import toColor
+from reportlab.platypus.tables import Table
+
+from xhtml2pdf import pisa
+from xhtml2pdf.builders import block
+from xhtml2pdf.builders.block import BlockBox
+from xhtml2pdf.document import pisaStory
+from xhtml2pdf.xhtml2pdf_reportlab import PmlParagraph, PmlTable, PmlTableOfContents
+
+if TYPE_CHECKING:
+    from xhtml2pdf.builders.flex import BoxStyle
+
+RED = toColor("red")
+BLUE = toColor("blue")
+
+
+class Box(NamedTuple):
+    """A box's border, as drawn: page, left, bottom, width, height, style."""
+
+    page: int
+    x: float
+    y: float
+    w: float
+    h: float
+    style: BoxStyle
+
+
+class Drawn(NamedTuple):
+    """A table as drawn: page, left, bottom, width, height."""
+
+    page: int
+    x: float
+    y: float
+    w: float
+    h: float
+
+
+def render(
+    html: str, *, last_pass: bool = False
+) -> tuple[list[Box], list[Drawn], bytes]:
+    """
+    The boxes BlockBox drew, the tables, and the PDF.
+
+    A document with an index is built more than once; last_pass keeps only
+    what the last build drew.
+    """
+    boxes: list[Box] = []
+    tables: list[Drawn] = []
+    borders = block.drawBoxBorders
+    draw = Table.drawOn
+    before = PmlTableOfContents.beforeBuild
+
+    def spy_pass(self) -> None:
+        if last_pass:
+            boxes.clear()
+            tables.clear()
+        before(self)
+
+    def spy_borders(canvas, x, y, w, h, style, *args, **kw):
+        ax, ay = canvas.absolutePosition(x, y)
+        boxes.append(Box(canvas.getPageNumber(), ax, ay, w, h, style))
+        return borders(canvas, x, y, w, h, style, *args, **kw)
+
+    def spy_table(self, canvas, x, y, _sW=0):
+        ax, ay = canvas.absolutePosition(self._hAlignAdjust(x, _sW), y)
+        tables.append(Drawn(canvas.getPageNumber(), ax, ay, self._width, self._height))
+        return draw(self, canvas, x, y, _sW)
+
+    dest = io.BytesIO()
+    with (
+        mock.patch.object(block, "drawBoxBorders", spy_borders),
+        mock.patch.object(Table, "drawOn", spy_table),
+        mock.patch.object(PmlTableOfContents, "beforeBuild", spy_pass),
+    ):
+        result = pisa.CreatePDF(html, dest=dest)
+    assert not result.err
+    return boxes, tables, dest.getvalue()
+
+
+def table_commands(html: str) -> list[tuple]:
+    """The style commands of every PmlTable built."""
+    commands: list[tuple] = []
+    init = PmlTable.__init__
+
+    def spy(self, data, *args, **kw):
+        init(self, data, *args, **kw)
+        commands.extend(kw["style"].getCommands())
+
+    with mock.patch.object(PmlTable, "__init__", spy):
+        pisa.CreatePDF(html, dest=io.BytesIO())
+    return commands
+
+
+def frame() -> tuple[float, float]:
+    """The left edge and the width of the default frame."""
+    _, (table,), _ = render("<table><tr><td>x</td></tr></table>")
+    return table.x, table.w
+
+
+ROW = "<tr><td>one</td><td>two</td></tr>"
+DIV = '<div style="margin-left: 50pt; padding: 10pt; border: 2pt solid red">{}</div>'
+TABLE = f'<table style="border: 1pt solid blue">{ROW}</table>'
+
+
+class OneBoxTestCase(TestCase):
+    def test_text_table_and_text_are_in_one_box(self) -> None:
+        boxes, (table,), _ = render(DIV.format(f"<p>before</p>{TABLE}<p>after</p>"))
+
+        (box,) = boxes
+        self.assertGreater(box.y + box.h, table.y + table.h)
+        self.assertLess(box.y, table.y)
+        # Room above the table for "before", below it for "after".
+        self.assertGreater(box.y + box.h - (table.y + table.h), 20)
+        self.assertGreater(table.y - box.y, 20)
+
+    def test_the_table_sits_inside_the_margin_and_padding(self) -> None:
+        left, width = frame()
+        boxes, (table,), _ = render(DIV.format(TABLE))
+
+        (box,) = boxes
+        self.assertAlmostEqual(left + 50, box.x)
+        self.assertAlmostEqual(width - 50, box.w)
+        self.assertAlmostEqual(left + 50 + 12, table.x)
+        self.assertAlmostEqual(width - 50 - 24, table.w)
+        self.assertAlmostEqual(box.y + 12, table.y)
+
+    def test_each_border_keeps_its_own_colour(self) -> None:
+        html = DIV.format(TABLE)
+        lines = [c for c in table_commands(html) if c[0].startswith("LINE")]
+        boxes, _, _ = render(html)
+
+        self.assertTrue(lines)
+        self.assertTrue(all(c[4] == BLUE for c in lines), lines)
+        (box,) = boxes
+        for side in ("Left", "Right", "Top", "Bottom"):
+            self.assertEqual(RED, getattr(box.style, f"border{side}Color"))
+
+    def test_the_table_does_not_take_the_padding(self) -> None:
+        commands = table_commands(DIV.format(TABLE))
+
+        paddings = {c[3] for c in commands if c[0].endswith("PADDING")}
+        self.assertNotIn(10.0, paddings, commands)
+
+    def test_what_is_inside_does_not_repeat_the_box(self) -> None:
+        story = pisaStory(DIV.format(f"<p>before</p>{TABLE}<p>after</p>")).story
+        (box,) = [f for f in story if isinstance(f, BlockBox)]
+
+        paragraphs = [f for f in box.content if isinstance(f, PmlParagraph)]
+        self.assertEqual(2, len(paragraphs))
+        for paragraph in paragraphs:
+            style = paragraph.style
+            self.assertEqual(0, style.paddingLeft)
+            self.assertEqual(0, style.borderLeftWidth or 0)
+            self.assertIsNone(style.backColor)
+            self.assertEqual(0, style.leftIndent)
+
+    def test_a_block_of_text_alone_keeps_its_paragraph_box(self) -> None:
+        story = pisaStory(DIV.format("only text")).story
+
+        self.assertFalse([f for f in story if isinstance(f, BlockBox)])
+        (paragraph,) = [f for f in story if isinstance(f, PmlParagraph)]
+        self.assertEqual(10, paragraph.style.paddingLeft)
+
+    def test_an_inherited_padding_is_no_box(self) -> None:
+        """A margin alone makes no box: the indent is the paragraphs' still."""
+        story = pisaStory('<div style="margin-left: 50pt"><p>a</p><p>b</p></div>').story
+
+        self.assertFalse([f for f in story if isinstance(f, BlockBox)])
+
+    def test_a_background_covers_the_gap_between_paragraphs(self) -> None:
+        story = pisaStory(
+            '<div style="background-color: #eee"><p>a</p><p>b</p></div>'
+        ).story
+
+        (box,) = [f for f in story if isinstance(f, BlockBox)]
+        self.assertIsNotNone(box.style.backColor)
+        for paragraph in box.content:
+            self.assertIsNone(paragraph.style.backColor)
+
+    def test_nested_boxes(self) -> None:
+        inner = (
+            '<div style="border: 1pt solid blue; padding: 5pt"><p>a</p><p>b</p></div>'
+        )
+        boxes, _, _ = render(DIV.format(f"<p>x</p>{inner}"))
+
+        outer, nested = sorted(boxes, key=lambda b: b.w, reverse=True)
+        self.assertAlmostEqual(outer.x + 12, nested.x)
+        self.assertAlmostEqual(outer.w - 24, nested.w)
+
+    def test_a_shrunk_table_is_centred_in_the_content_area(self) -> None:
+        boxes, (table,), _ = render(
+            DIV.format(f'<table style="margin: 0 auto">{ROW}</table>')
+        )
+
+        (box,) = boxes
+        middle = box.x + box.w / 2
+        self.assertAlmostEqual(middle, table.x + table.w / 2, places=3)
+        self.assertLess(table.w, box.w / 2)
+
+    def test_a_rounded_border_is_drawn_once(self) -> None:
+        boxes, _, _ = render(
+            '<div style="border: 1pt solid red; border-radius: 6pt">'
+            f"<p>a</p>{TABLE}</div>"
+        )
+
+        self.assertEqual(1, len(boxes))
+
+
+class PageTestCase(TestCase):
+    PARAS = "".join(f"<p>paragraph {i}</p>" for i in range(120))
+
+    def test_a_box_across_pages_is_sliced(self) -> None:
+        boxes, _, _ = render(DIV.format(self.PARAS))
+
+        self.assertGreater(len(boxes), 1)
+        self.assertEqual(list(range(1, len(boxes) + 1)), [b.page for b in boxes])
+        first, last = boxes[0].style, boxes[-1].style
+        self.assertIsNone(first.borderBottomStyle)
+        self.assertEqual("solid", first.borderTopStyle)
+        self.assertIsNone(last.borderTopStyle)
+        self.assertEqual("solid", last.borderBottomStyle)
+
+    def test_a_page_break_inside_cuts_the_box(self) -> None:
+        for brk in ("<pdf:nextpage/>", '<p style="page-break-before: always">b</p>'):
+            with self.subTest(brk=brk):
+                boxes, _, _ = render(DIV.format(f"<p>a</p>{brk}<p>c</p>"))
+
+                self.assertEqual([1, 2], [b.page for b in boxes])
+                self.assertIsNone(boxes[0].style.borderBottomStyle)
+                self.assertIsNone(boxes[1].style.borderTopStyle)
+
+    def test_page_break_inside_avoid_moves_the_box_whole(self) -> None:
+        filler = '<div style="height: 1pt"></div>' + "<p>filler</p>" * 50
+        boxes, _, _ = render(
+            filler
+            + '<div style="border: 1pt solid red; page-break-inside: avoid">'
+            + "".join(f"<p>{i}</p>" for i in range(20))
+            + "</div>"
+        )
+
+        # The 1pt filler is a box of its own now that a height makes one.
+        self.assertEqual([2], [b.page for b in boxes if b.style.border("Top")])
+
+    def test_a_heading_inside_reaches_the_index(self) -> None:
+        _, _, pdf = render(
+            '<div style="page-break-after: always"><pdf:toc/></div>'
+            + DIV.format("<h1>Chapter</h1><p>text</p>")
+        )
+
+        reader = PdfReader(io.BytesIO(pdf))
+        self.assertIn("Chapter", reader.pages[0].extract_text())
+        self.assertEqual(["Chapter"], [o.title for o in reader.outline])
+
+    def test_an_index_inside_a_box_still_fills(self) -> None:
+        _, _, pdf = render(
+            DIV.format("<pdf:toc/><p>x</p>")
+            + '<h1 style="page-break-before: always">Chapter</h1>'
+        )
+
+        reader = PdfReader(io.BytesIO(pdf))
+        self.assertIn("Chapter", reader.pages[0].extract_text())
+
+    def assertInside(self, box: Box, table: Drawn) -> None:
+        self.assertEqual(box.page, table.page)
+        self.assertGreaterEqual(table.x, box.x)
+        self.assertLessEqual(table.x + table.w, box.x + box.w + 0.01)
+        self.assertGreaterEqual(table.y, box.y - 0.01)
+        self.assertLessEqual(table.y + table.h, box.y + box.h + 0.01)
+
+    def test_an_index_is_drawn_inside_its_box(self) -> None:
+        for html in (DIV.format("<pdf:toc/>"), DIV.format(DIV.format("<pdf:toc/>"))):
+            with self.subTest(html=html):
+                boxes, tables, _ = render(
+                    html + '<h1 style="page-break-before: always">Chapter</h1>',
+                    last_pass=True,
+                )
+                # The index is the table of its entries; the box is not one
+                # around nothing, with the index below it.
+                (index,) = tables
+                self.assertTrue(boxes)
+                for box in boxes:
+                    self.assertInside(box, index)
+
+    def test_an_index_in_a_box_goes_on_to_the_next_page(self) -> None:
+        headings = "".join(f"<h1>Chapter {i}</h1>" for i in range(80))
+        boxes, tables, pdf = render(
+            DIV.format("<pdf:toc/>")
+            + f'<div style="page-break-before: always">{headings}</div>',
+            last_pass=True,
+        )
+
+        parts = [t for t in tables if t.page <= 2]
+        self.assertEqual(2, len(parts))
+        self.assertEqual([1, 2], [b.page for b in boxes])
+        for box, part in zip(boxes, parts, strict=True):
+            self.assertInside(box, part)
+        reader = PdfReader(io.BytesIO(pdf))
+        text = reader.pages[0].extract_text() + reader.pages[1].extract_text()
+        for i in range(80):
+            self.assertIn(f"Chapter {i}", text)
+
+
+class ListTestCase(TestCase):
+    @staticmethod
+    def marker_and_text(html: str) -> tuple[float, float]:
+        """The x of the list marker and of the item's text."""
+        dest = io.BytesIO()
+        pisa.CreatePDF(html, dest=dest)
+        runs: list[tuple[float, str]] = []
+
+        def visit(text, cm, tm, font_dict, font_size) -> None:  # noqa: ARG001
+            if text.strip():
+                runs.append((tm[4] * cm[0] + cm[4], text.strip()))
+
+        PdfReader(io.BytesIO(dest.getvalue())).pages[0].extract_text(visitor_text=visit)
+        marker = min(x for x, t in runs if "item" not in t)
+        text = min(x for x, t in runs if "item" in t)
+        return marker, text
+
+    def test_a_marker_hangs_outside_a_bordered_item(self) -> None:
+        plain = self.marker_and_text("<ul><li><p>item</p><p>more</p></li></ul>")
+        boxed = self.marker_and_text(
+            '<ul><li style="border: 1pt solid red"><p>item</p><p>more</p></li></ul>'
+        )
+
+        self.assertLess(boxed[0], boxed[1])
+        self.assertAlmostEqual(plain[0], boxed[0], places=1)
+
+    def test_a_box_inside_an_item_keeps_the_marker(self) -> None:
+        marker, text = self.marker_and_text(
+            '<ul><li><div style="border: 1pt solid red"><p>item</p><p>x</p></div>'
+            "</li></ul>"
+        )
+
+        self.assertLess(marker, text)
+
+
+class PlacesTestCase(TestCase):
+    def test_in_a_table_cell(self) -> None:
+        boxes, _, _ = render(
+            f"<table><tr><td>{DIV.format('<p>a</p><p>b</p>')}</td></tr></table>"
+        )
+
+        self.assertEqual(1, len(boxes))
+
+    def test_in_a_flex_item(self) -> None:
+        boxes, _, _ = render(
+            '<div style="display: flex"><div>'
+            + DIV.format("<p>a</p><p>b</p>")
+            + "</div><div>c</div></div>"
+        )
+
+        self.assertEqual(1, len(boxes))
+
+    def test_right_to_left(self) -> None:
+        left, width = frame()
+        boxes, (table,), _ = render(
+            '<div dir="rtl" style="margin-right: 50pt; padding: 10pt;'
+            f' border: 2pt solid red">{TABLE}</div>'
+        )
+
+        (box,) = boxes
+        self.assertAlmostEqual(left, box.x)
+        self.assertAlmostEqual(width - 50, box.w)
+        self.assertAlmostEqual(box.x + box.w - 12, table.x + table.w)
+
+    def test_a_relative_box(self) -> None:
+        boxes, _, _ = render(
+            '<div style="position: relative; border: 1pt solid red; padding: 5pt">'
+            '<p>a</p><p>b</p><div style="position: absolute; top: 0; right: 0">'
+            "corner</div></div>"
+        )
+
+        self.assertEqual(1, len(boxes))
+
+
+class EmptyBoxTestCase(TestCase):
+    """
+    A block with a border or a background and nothing in it is drawn.
+
+    It made no flowable at all: no block content for a box, and no text for
+    a paragraph to draw one round. CSS draws it, padding and borders tall.
+    """
+
+    def test_an_empty_div(self) -> None:
+        boxes, _, _ = render(
+            '<div style="border: 2pt solid red; padding: 3pt"></div><p>after</p>'
+        )
+
+        (box,) = boxes
+        self.assertAlmostEqual(2 * (2 + 3), box.h)
+
+    def test_an_empty_paragraph(self) -> None:
+        boxes, _, _ = render('<p style="border-bottom: 1pt solid red"></p>')
+
+        self.assertEqual(1, len(boxes))
+
+    def test_a_block_of_text_keeps_its_paragraph_box(self) -> None:
+        boxes, _, _ = render('<div style="border: 1pt solid red">text</div>')
+
+        self.assertEqual([], boxes)
+
+
+class HeightTestCase(TestCase):
+    """
+    A block's CSS height is the least its content area takes.
+
+    It was read only for images, cells, flex items, barcodes and positioned
+    boxes; a block in the flow was as tall as its content whatever it said.
+    """
+
+    TWENTY_MM = 20 * 72 / 25.4
+
+    def test_an_empty_block(self) -> None:
+        boxes, _, _ = render('<div style="border: 1pt solid red; height: 20mm"></div>')
+
+        (box,) = boxes
+        self.assertAlmostEqual(self.TWENTY_MM + 2, box.h, places=3)
+
+    def test_a_block_of_blocks(self) -> None:
+        boxes, _, _ = render(
+            '<div style="border: 1pt solid red; height: 20mm"><p>a</p><p>b</p></div>'
+        )
+
+        (box,) = boxes
+        self.assertAlmostEqual(self.TWENTY_MM + 2, box.h, places=3)
+
+    def test_a_block_of_text(self) -> None:
+        boxes, _, _ = render('<div style="border: 1pt solid red; height: 20mm">a</div>')
+
+        (box,) = boxes
+        self.assertAlmostEqual(self.TWENTY_MM + 2, box.h, places=3)
+
+    def test_content_taller_than_the_height_wins(self) -> None:
+        boxes, _, _ = render(
+            '<div style="border: 1pt solid red; height: 5pt">'
+            + "<p>line</p>" * 5
+            + "</div>"
+        )
+
+        (box,) = boxes
+        self.assertGreater(box.h, 50)
+
+    def test_a_percentage_is_ignored(self) -> None:
+        boxes, _, _ = render(
+            '<div style="border: 1pt solid red; height: 50%"><p>a</p><p>b</p></div>'
+        )
+
+        (box,) = boxes
+        self.assertLess(box.h, 100)
+
+    def test_a_block_without_a_box_still_takes_the_room(self) -> None:
+        def after(html: str) -> float:
+            from pypdf import PdfReader
+
+            ys: list[float] = []
+            page = PdfReader(io.BytesIO(render(html)[2])).pages[0]
+            page.extract_text(
+                visitor_text=lambda text, cm, tm, *_: (
+                    ys.append(tm[5] * cm[3] + cm[5]) if "after" in text else None
+                )
+            )
+            return ys[0]
+
+        spaced = after('<p>before</p><div style="height: 20mm"></div><p>after</p>')
+        plain = after("<p>before</p><p>after</p>")
+        self.assertGreater(plain - spaced, self.TWENTY_MM)
+
+    def test_a_flex_item_is_left_to_its_container(self) -> None:
+        """The container sizes and draws an item; a box inside it was drawn too."""
+        boxes, _, _ = render(
+            '<div style="display: flex">'
+            '<div style="border: 1pt solid red; height: 20mm">a</div>'
+            '<div style="border: 1pt solid red"></div></div>'
+        )
+
+        self.assertEqual([], boxes)

{xhtml2pdf-0.2.22 → xhtml2pdf-0.2.23}/tests/test_css_parser.py

@@ -503,3 +503,84 @@ class DocumentTest(ParserTestCase):
             b"<p title='big one'>x</p><p title='small'>y</p>"
         )
         self.assertEqual(["Color(1,0,0,1)", "Color(0,0,0,1)"], self._colors(html))
+
+
+class SourceTest(ParserTestCase):
+    """Each stylesheet is parsed on its own, and a warning names it (#780)."""
+
+    def _render(self, html: str, files: dict[str, str]) -> tuple[list[str], list]:
+        logging.disable(logging.NOTSET)
+        with tempfile.TemporaryDirectory() as directory:
+            for name, text in files.items():
+                Path(directory, name).write_text(text, encoding="utf-8")
+            with self.assertLogs("xhtml2pdf", logging.WARNING) as logs:
+                logging.getLogger("xhtml2pdf").warning("start")
+                context = pisaStory(html, path=str(Path(directory, "doc.html")))
+        styles = [f.style for f in context.story if hasattr(f, "style")]
+        return logs.output, styles
+
+    def test_a_warning_names_the_stylesheet(self) -> None:
+        output, _ = self._render(
+            '<link rel="stylesheet" href="fa.css"><style>p { width: calc(1px }</style>'
+            '<p class="fa" style="color: calc(2px">x</p>',
+            {"fa.css": ".fa { margin-left: calc(var(--w, 2em) * -1) }"},
+        )
+        messages = "\n".join(output)
+        # The issue's own declaration: var() is substituted when an element
+        # uses it, and what comes out is still traced to its stylesheet.
+        self.assertRegex(
+            messages, r"fa\.css, var\(\) in margin-left: Ignoring CSS declaration"
+        )
+        self.assertIn("<style> block 2: Ignoring CSS declaration", messages)
+        self.assertIn("the style attribute of <p>: Ignoring", messages)
+
+    def test_unimplemented_properties_are_named_by_source(self) -> None:
+        output, _ = self._render(
+            '<style>p { box-shadow: 1px 1px red }</style><link rel="stylesheet"'
+            ' href="ext.css"><p style="opacity: 0.5; width: min(1pt, 2pt)">y</p>',
+            {"ext.css": "p { float: left }"},
+        )
+        unimplemented = [
+            # "WARNING:logger:message"
+            line.split(":", 2)[2]
+            for line in output
+            if "does not implement" in line
+        ]
+        self.assertEqual(3, len(unimplemented), output)
+        style, ext, attribute = unimplemented
+        self.assertTrue(style.startswith("<style> block 1: "), style)
+        self.assertTrue(style.endswith(": box-shadow"), style)
+        self.assertIn("ext.css: ", ext)
+        self.assertTrue(ext.endswith(": float"), ext)
+        # A style attribute used to be read without a word about it.
+        self.assertTrue(attribute.startswith("the style attribute of <p>: "))
+        self.assertTrue(attribute.endswith(": opacity"), attribute)
+        self.assertIn(
+            "the style attribute of <p>: Ignoring CSS declarations whose value"
+            " xhtml2pdf cannot evaluate: width: min()",
+            "\n".join(output),
+        )
+
+    def test_the_default_css_is_not_reported(self) -> None:
+        output, _ = self._render("<p>x</p>", {})
+        self.assertFalse([line for line in output if "does not implement" in line])
+
+    def test_a_link_after_a_style_applies(self) -> None:
+        # Both used to be one source, the <link> an "@import" in the middle
+        # of it, and an @import after a rule is ignored.
+        output, styles = self._render(
+            '<style>p { color: #ff0000 }</style><link rel="stylesheet" href="b.css">'
+            "<p>x</p>",
+            {"b.css": "p { font-size: 30pt }"},
+        )
+        self.assertNotIn("@import", "\n".join(output))
+        self.assertEqual(30, styles[0].fontSize)
+        self.assertEqual("Color(1,0,0,1)", str(styles[0].textColor))
+
+    def test_a_later_stylesheet_wins_a_tie(self) -> None:
+        _, styles = self._render(
+            '<link rel="stylesheet" href="a.css"><style>p { color: #0000ff }</style>'
+            '<link rel="stylesheet" href="a2.css"><p>x</p>',
+            {"a.css": "p { color: #ff0000 }", "a2.css": "p { color: #00ff00 }"},
+        )
+        self.assertEqual("Color(0,1,0,1)", str(styles[0].textColor))