xhtml2pdf 0.2.20__tar.gz → 0.2.22__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xhtml2pdf
-Version: 0.2.20
+Version: 0.2.22
 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>
@@ -250,10 +250,10 @@ Requires-Dist: pyHanko>=0.12.1
 Requires-Dist: pyhanko-certvalidator>=0.19.5
 Requires-Dist: pypdf>=3.1.0
 Requires-Dist: python-bidi>=0.5.0
-Requires-Dist: reportlab<6,>=4.0.4
+Requires-Dist: reportlab<6,>=4.4.9
 Requires-Dist: svglib>=1.2.1
 Provides-Extra: pycairo
-Requires-Dist: reportlab[pycairo]<6,>=4.0.4; extra == "pycairo"
+Requires-Dist: reportlab[pycairo]<6,>=4.4.9; extra == "pycairo"
 Provides-Extra: renderpm
 Requires-Dist: xhtml2pdf[pycairo]; extra == "renderpm"
 Provides-Extra: test

{xhtml2pdf-0.2.20 → xhtml2pdf-0.2.22}/pyproject.toml

@@ -54,7 +54,7 @@ dependencies = [
     "pyhanko-certvalidator>=0.19.5",
     "pypdf>=3.1.0",
     "python-bidi>=0.5.0",
-    "reportlab>=4.0.4,<6",
+    "reportlab>=4.4.9,<6",
     "svglib>=1.2.1"
 ]
 dynamic = ["version"]
@@ -67,7 +67,7 @@ Changelog = "https://xhtml2pdf.readthedocs.io/en/latest/release-notes.html"
 
 [project.optional-dependencies]
 pycairo = [
-    "reportlab[pycairo]>=4.0.4,<6",
+    "reportlab[pycairo]>=4.4.9,<6",
 ]
 # Deprecated alias. reportlab 5 dropped the C renderPM backend along with its
 # "renderpm" extra, so requesting it there resolves to nothing at all; the
@@ -113,13 +113,16 @@ include = ["xhtml2pdf*"]
 [tool.tox]
 legacy_tox_ini = """
     [tox]
-    envlist = py{3.10,3.11,3.12,3.13,3.14}-rl{4,5}
+    envlist = py{3.10,3.11,3.12,3.13,3.14}-rl{4,5}, py3.10-rlmin
 
     [testenv]
     deps =
         coverage[toml]
-        rl4: reportlab>=4.0.4,<5
+        rl4: reportlab>=4.4.9,<5
         rl5: reportlab>=5,<6
+        # The declared floor, exactly: rl4 installs the newest 4.x, so the
+        # floor went untested and drifted below what the code needs.
+        rlmin: reportlab==4.4.9
     commands =
         python3 -c 'import sys;print(sys.version_info)'
         python3 -c "from reportlab import Version; print('%s %s' % ('Reportlab Version', Version))"

{xhtml2pdf-0.2.20 → xhtml2pdf-0.2.22}/tests/test_cli.py

@@ -179,6 +179,22 @@ class RunAsAModuleTest(TestCase):
         self.assertTrue(dest.is_file())
         self.assertEqual(1, len(PdfReader(dest).pages))
 
+    def test_stdin_to_stdout_writes_only_the_pdf(self) -> None:
+        """`xhtml2pdf - -` (#464): the PDF alone on stdout, the message on stderr."""
+        result = subprocess.run(
+            [sys.executable, "-m", "xhtml2pdf", "-", "-"],
+            input=HTML.encode(),
+            capture_output=True,
+            check=False,
+        )
+
+        self.assertEqual(0, result.returncode, result.stderr.decode())
+        self.assertTrue(result.stdout.startswith(b"%PDF-"))
+        self.assertIn(b"Converting - to -", result.stderr)
+        self.assertIn(
+            "hello", PdfReader(io.BytesIO(result.stdout)).pages[0].extract_text()
+        )
+
 
 class StartViewerTest(TestCase):
     """

xhtml2pdf-0.2.22/tests/test_css_parser.py

@@ -0,0 +1,505 @@
+"""
+The CSS parser on its own: the at-rules, selectors and declarations that no
+document in the rest of the suite happens to contain.
+
+What is invalid is dropped and the rest applies, as CSS Syntax 3 says: an
+at-rule to its ";" or through its block, a declaration to its ";". Each of
+these used to raise instead -- a CSSParseError, an IndexError, a TypeError --
+and nothing catches it, so one line of a stylesheet cost the whole document.
+"""
+
+import logging
+import tempfile
+import threading
+from pathlib import Path
+from typing import ClassVar
+from unittest import TestCase
+from xml.dom import minidom
+
+from reportlab.lib.pagesizes import A5
+from reportlab.lib.units import cm
+
+from xhtml2pdf.context import pisaContext
+from xhtml2pdf.document import pisaStory
+from xhtml2pdf.w3c.css import CSSBuilder, CSSParser
+from xhtml2pdf.w3c.cssDOMElementInterface import CSSDOMElementInterface
+from xhtml2pdf.w3c.cssParser import CSSParseError
+
+
+class ParserTestCase(TestCase):
+    MEDIUM_SET: ClassVar[list[str]] = ["all", "print", "pdf"]
+
+    def setUp(self) -> None:
+        # The parser warns about every rule it drops, which is what most of
+        # these tests do on purpose.
+        logging.disable(logging.WARNING)
+        self.addCleanup(logging.disable, logging.NOTSET)
+
+    def _parser(self) -> CSSParser:
+        return CSSParser(CSSBuilder(mediumSet=self.MEDIUM_SET))
+
+    def _parse(self, css: str) -> dict:
+        # In a thread with a timeout: a skip that stops advancing loops
+        # forever, and that must fail one test rather than hang the suite.
+        result: dict = {}
+
+        def parse() -> None:
+            result["ruleset"] = self._parser().parse(css)[0]
+
+        worker = threading.Thread(target=parse, daemon=True)
+        worker.start()
+        worker.join(timeout=5)
+        self.assertFalse(worker.is_alive(), "parser did not terminate")
+        return {
+            str(selector): dict(decls) for selector, decls in result["ruleset"].items()
+        }
+
+
+class ParseErrorTest(ParserTestCase):
+    def test_message_points_at_the_error_in_its_context(self) -> None:
+        # What came before the error and where it starts, so a warning in
+        # the log says which CSS was dropped.
+        message = str(CSSParseError("Bad thing", "bc {x}", "p > bc {x}"))
+        self.assertTrue(message.startswith("Bad thing"))
+        self.assertIn("'p > '", message)
+        self.assertIn("'bc {x}'", message)
+
+    def test_error_at_the_start_is_located(self) -> None:
+        # Position 0 used to count as no position at all.
+        self.assertEqual("Bad:: ('', 'abc')", str(CSSParseError("Bad", "abc")))
+
+    def test_message_without_a_position_quotes_the_source(self) -> None:
+        self.assertEqual("Bad:: 'zzz'", str(CSSParseError("Bad", "zzz", "abc")))
+
+
+class PublicApiTest(ParserTestCase):
+    def test_parse_file(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            path = Path(directory, "style.css")
+            path.write_text("p { color: red; }", encoding="utf-8")
+            ruleset = self._parser().parseFile(str(path))[0]
+
+        self.assertEqual(
+            {"p": {"color": "red"}},
+            {str(selector): dict(decls) for selector, decls in ruleset.items()},
+        )
+
+    def test_parse_inline_drops_only_the_broken_declaration(self) -> None:
+        normal, _ = self._parser().parseInline("color: red; width: calc(1px")
+        self.assertEqual({"color": "red"}, dict(normal))
+        # An open "(" runs to the end of the source, taking the ";" with it
+        # (CSS Syntax 3, "consume a function"), as it does in a browser.
+        normal, _ = self._parser().parseInline("width: calc(1px ; color: red")
+        self.assertEqual({}, dict(normal))
+
+    def test_parse_attributes(self) -> None:
+        normal, important = self._parser().parseAttributes(
+            {"color": "red"}, font="10px Arial"
+        )
+        self.assertEqual({}, dict(important))
+        self.assertEqual("red", normal["color"])
+        self.assertEqual(("10", "px"), normal["font-size"])
+        self.assertEqual(["Arial"], normal["font-family"])
+
+    def test_parse_attributes_error(self) -> None:
+        # Unlike a style attribute, which drops the declaration: this API
+        # takes one value per property and has nothing else to keep.
+        with self.assertRaisesRegex(CSSParseError, "calc"):
+            self._parser().parseAttributes(width="calc(1px ;")
+
+    def test_parse_single_attribute(self) -> None:
+        parser = self._parser()
+        self.assertEqual(
+            [("110", "%"), "Times New Roman", "Arial"],
+            parser.parseSingleAttr('110%, "Times New Roman", Arial'),
+        )
+        # An !important value comes back from the other half of the result.
+        self.assertEqual("red", parser.parseSingleAttr("red !important"))
+
+
+class AtRuleTest(ParserTestCase):
+    def test_html_comment_markers_are_ignored(self) -> None:
+        self.assertEqual({"p": {"color": "red"}}, self._parse("<!-- p{color:red} -->"))
+
+    def test_charset(self) -> None:
+        self.assertEqual(
+            {"p": {"color": "red"}}, self._parse('@charset "utf-8"; p{color:red}')
+        )
+
+    def test_charset_without_semicolon(self) -> None:
+        # The at-rule runs on to the block of the next rule, and both go.
+        self.assertEqual({"div"}, set(self._parse('@charset "utf-8" p{c:d} div{c:d}')))
+
+    def _imports(self, css: str) -> tuple[list, set]:
+        """The stylesheets css imports, and the rules it keeps."""
+        imported = []
+
+        class Parser(CSSParser):
+            @staticmethod
+            def parseExternal(cssResourceName):
+                imported.append(cssResourceName)
+
+        parser = Parser(CSSBuilder(mediumSet=self.MEDIUM_SET))
+        ruleset = parser.parse(css)[0]
+        return imported, {str(selector) for selector in ruleset}
+
+    def test_import_media_list(self) -> None:
+        self.assertEqual(
+            (["x.css"], {"p"}), self._imports("@import 'x.css' print, screen; p{c:d}")
+        )
+        # None of the media apply, so the file is not even fetched.
+        self.assertEqual(
+            ([], {"p"}), self._imports("@import 'x.css' tv, aural; p{c:d}")
+        )
+
+    def test_malformed_import_is_dropped(self) -> None:
+        self.assertEqual(([], {"p"}), self._imports("@import foo; p{c:d}"))
+        # Without its ";" it takes the next rule's block as its own.
+        self.assertEqual(
+            ([], {"div"}), self._imports("@import 'x.css' print p{c:d} div{c:d}")
+        )
+
+    def test_import_after_a_rule_is_ignored(self) -> None:
+        # CSS 2.1 6.3: @import must come before every other rule.
+        self.assertEqual(
+            ([], {"p", "div"}), self._imports("p{c:d} @import url(x.css); div{c:d}")
+        )
+
+    NAMESPACED = (
+        "<root><circle xmlns='http://www.w3.org/2000/svg' id='svg'/>"
+        "<circle id='plain'/></root>"
+    )
+
+    def _matched(self, css: str) -> set:
+        ruleset = self._parser().parse(css)[0]
+        document = minidom.parseString(self.NAMESPACED)
+        return {
+            element.getIdAttr()
+            for element in map(
+                CSSDOMElementInterface, document.getElementsByTagName("*")
+            )
+            if any(selector.matches(element) for selector in ruleset)
+        }
+
+    def test_namespace(self) -> None:
+        declare = "@namespace svg url(http://www.w3.org/2000/svg);"
+        self.assertEqual({"svg"}, self._matched(declare + "svg|circle{c:d}"))
+        # A default namespace does not stop the prefixed one from resolving.
+        self.assertEqual(
+            {"svg"},
+            self._matched(
+                declare
+                + "@namespace url(http://www.w3.org/1999/xhtml); svg|circle{c:d}"
+            ),
+        )
+        self.assertEqual({"svg", "plain"}, self._matched("*|circle{c:d}"))
+
+    def test_empty_prefix_is_no_namespace(self) -> None:
+        # CSS Namespaces 3: "|circle" is a circle in no namespace. It used to
+        # match any, as "*|circle" does.
+        self.assertEqual({"plain"}, self._matched("|circle{c:d}"))
+
+    def test_malformed_namespace_is_dropped(self) -> None:
+        cases = {
+            "@namespace ; p{c:d}": {"p"},
+            "@namespace svg; p{c:d}": {"p"},
+            # Without its ";" it takes the next rule's block as its own.
+            "@namespace url(x) p{c:d} div{c:d}": {"div"},
+        }
+        for css, kept in cases.items():
+            with self.subTest(css=css):
+                self.assertEqual(kept, set(self._parse(css)))
+
+    def test_skipped_at_rule_ends_outside_strings(self) -> None:
+        self.assertEqual({"div"}, set(self._parse('@foo "a;b" { p{c:d} } div{c:d}')))
+
+    def test_at_rule_without_a_name_is_dropped(self) -> None:
+        self.assertEqual({"p"}, set(self._parse("@123 {} p{c:d}")))
+
+
+class MediaTest(ParserTestCase):
+    def test_unsupported_at_rule_inside_media(self) -> None:
+        # Used to raise TypeError: the skipped rule's NotImplemented was
+        # iterated as if it were a list of rules.
+        rules = self._parse(
+            "@media print {"
+            "  @keyframes fade { from { opacity: 0; } }"
+            "  @layer base;"
+            "  p { color: red; }"
+            "}"
+        )
+        self.assertEqual({"p": {"color": "red"}}, rules)
+
+    def test_skipped_at_rule_leaves_the_media_block_its_brace(self) -> None:
+        # "@foo bar" ends at the "}" of @media without taking it, so p is
+        # outside the (unmatched) screen block.
+        self.assertEqual({"p"}, set(self._parse("@media screen { @foo bar } p{c:d}")))
+
+    def test_at_rule_inside_media(self) -> None:
+        # The base CSSBuilder files a @font-face as a rule for "*"; that it is
+        # there at all is what this checks.
+        rules = self._parse(
+            "@media print { @font-face { font-family: x; src: url(a.ttf) }"
+            " p { color: red; } }"
+        )
+        self.assertEqual({"*", "p"}, set(rules))
+
+    def test_end_of_stylesheet_closes_the_block(self) -> None:
+        self.assertEqual(
+            {"p": {"color": "red"}}, self._parse("@media print { p{color:red}")
+        )
+
+    def test_media_without_a_block_is_dropped(self) -> None:
+        # These used to raise IndexError and AttributeError.
+        for css in ("p{c:d} @media print", "p{c:d} @media (max-width: 1px) p"):
+            with self.subTest(css=css):
+                self.assertEqual({"p"}, set(self._parse(css)))
+
+
+class PageTest(ParserTestCase):
+    @staticmethod
+    def _context(css: str) -> pisaContext:
+        context = pisaContext(".")
+        context.addCSS(css)
+        context.parseCSS()
+        return context
+
+    def test_size_as_two_lengths(self) -> None:
+        width, height = self._context("@page { size: 10cm 20cm }").pageSize
+        self.assertAlmostEqual(10 * cm, width)
+        self.assertAlmostEqual(20 * cm, height)
+
+    def test_pdf_page_size(self) -> None:
+        context = self._context("@page { -pdf-page-size: a5 }")
+        self.assertEqual(A5, tuple(context.pageSize))
+
+    def test_unsupported_at_rule_inside_page(self) -> None:
+        context = self._context("@page { @supports (x) { p { c: d } } size: a5 }")
+        self.assertEqual(A5, tuple(context.pageSize))
+
+    def test_page_without_a_block_is_dropped(self) -> None:
+        context = self._context("@page x y; @page { size: a5 }")
+        self.assertEqual(A5, tuple(context.pageSize))
+
+
+class AttributeSelectorTest(ParserTestCase):
+    HTML = (
+        "<form>"
+        "<input id='text' type='text' lang='en-GB' title='big red'/>"
+        "<input id='box' type='checkbox' lang='fr'/>"
+        "<a id='link' href='x' title='a b'/>"
+        "</form>"
+    )
+
+    def _matched(self, css: str) -> set:
+        ruleset = self._parser().parse(css)[0]
+        document = minidom.parseString(self.HTML)
+        matched = set()
+        for node in document.getElementsByTagName("*"):
+            element = CSSDOMElementInterface(node)
+            if any(selector.matches(element) for selector in ruleset):
+                matched.add(element.getIdAttr())
+        return matched
+
+    def test_presence(self) -> None:
+        self.assertEqual({"link"}, self._matched("[href] {c:d}"))
+
+    def test_equals(self) -> None:
+        self.assertEqual({"text"}, self._matched("input[type=text] {c:d}"))
+        self.assertEqual({"link"}, self._matched('a[title="a b"] {c:d}'))
+
+    def test_word_and_language(self) -> None:
+        self.assertEqual({"text"}, self._matched("[title~=red] {c:d}"))
+        self.assertEqual(set(), self._matched("[title~=re] {c:d}"))
+        self.assertEqual({"text"}, self._matched("[lang|=en] {c:d}"))
+        self.assertEqual({"box"}, self._matched("[lang|=fr] {c:d}"))
+        # A prefix up to a "-", not any "-" separated part: this used to match.
+        self.assertEqual(set(), self._matched("[lang|=GB] {c:d}"))
+
+    def test_prefix_suffix_and_substring(self) -> None:
+        # Selectors 3. "^=" used to raise RuntimeError, out of the document.
+        self.assertEqual(
+            {"text", "box"}, self._matched("[type^=te], [type^=check] {c:d}")
+        )
+        self.assertEqual({"box"}, self._matched("[type$=box] {c:d}"))
+        self.assertEqual({"text", "link"}, self._matched("[title*=' '] {c:d}"))
+        self.assertEqual(set(), self._matched("[type^=ext] {c:d}"))
+
+    def test_empty_value_matches_nothing(self) -> None:
+        for op in ("^=", "$=", "*="):
+            with self.subTest(op=op):
+                self.assertEqual(set(), self._matched(f"[type{op}''] {{c:d}}"))
+
+    def test_undeclared_namespace_prefix_drops_the_rule(self) -> None:
+        self.assertEqual({"p"}, set(self._parse("[ns|attr] {c:d} p{c:d}")))
+
+    def test_malformed_attribute_drops_only_its_rule(self) -> None:
+        # "!=" is no CSS operator; it used to parse, then raise when matched.
+        for css in ("a[=x]", "a[x=]", "a[x=y", "a[x!=y]"):
+            with self.subTest(css=css):
+                self.assertEqual({"p"}, set(self._parse(css + " {c:d} p{c:d}")))
+
+
+class SelectorTest(ParserTestCase):
+    def test_malformed_pseudo_drops_only_its_rule(self) -> None:
+        for css in ("a:", "li:nth-child(2"):
+            with self.subTest(css=css):
+                self.assertEqual({"p"}, set(self._parse(css + " {c:d} p{c:d}")))
+
+    def test_selector_starting_with_a_digit(self) -> None:
+        for css in (".1", "p .1"):
+            with self.subTest(css=css):
+                self.assertEqual({"p"}, set(self._parse(css + " {c:d} p{c:d}")))
+
+
+class DeclarationTest(ParserTestCase):
+    def test_rule_without_a_block_takes_the_next_one_with_it(self) -> None:
+        # "p ; div" is one prelude, so its block is not div's (CSS Syntax 3).
+        self.assertEqual({"span"}, set(self._parse("p ; div{c:d} span{c:d}")))
+
+    def test_empty_declarations_are_skipped(self) -> None:
+        # Both used to throw the whole rule away.
+        self.assertEqual(
+            {"p": {"color": "red", "font-size": ("2", "px")}},
+            self._parse("p{color:red;;font-size:2px}"),
+        )
+        self.assertEqual({"p": {"color": "red"}}, self._parse("p{;color:red}"))
+
+    def test_end_of_stylesheet_closes_the_block(self) -> None:
+        self.assertEqual({"p": {"color": "red"}}, self._parse("p{color:red"))
+
+    def test_invalid_declaration_drops_only_itself(self) -> None:
+        # It used to take the whole rule with it.
+        self.assertEqual(
+            {"p": {"color": "red"}, "div": {"c": "d"}},
+            self._parse("p{color:red; !ie} div{c:d}"),
+        )
+        self.assertEqual(
+            {"p": {"color": "red"}}, self._parse("p{color: red blue !x; color: red}")
+        )
+
+    def test_skipped_declaration_ends_outside_strings(self) -> None:
+        # The "}" in the string does not end the block.
+        self.assertEqual(
+            {"p": {"color": "red"}, "q": {"c": "d"}},
+            self._parse('p{ !x "a}b"; color: red } q{c:d}'),
+        )
+
+    def test_star_hack_is_dropped(self) -> None:
+        # "*font" is an old IE hack, invalid CSS that a browser ignores.
+        self.assertEqual(
+            {"color": "red"}, self._parse("p{*font: smaller; color:red}")["p"]
+        )
+
+    def test_equals_as_separator(self) -> None:
+        self.assertEqual({"p": {"color": "red"}}, self._parse("p{color=red}"))
+
+    def test_unicode_range(self) -> None:
+        # Used to raise IndexError, from every @font-face Google Fonts serves.
+        self.assertEqual(
+            {"unicode-range": "U+0025-00FF"},
+            self._parse("p{unicode-range: U+0025-00FF}")["p"],
+        )
+
+    def test_unclosed_function(self) -> None:
+        # At the end of the stylesheet this used to raise IndexError.
+        self.assertEqual(
+            {"p": {"color": "blue"}}, self._parse("p{color: blue; width: calc(1px")
+        )
+
+    def test_non_ascii_strings_and_names(self) -> None:
+        # Only Latin-1 counted as a string character: "宋体" gave NotImplemented,
+        # '宋体' kept its quotes, and "a宋" lost the whole rule.
+        self.assertEqual(
+            {
+                "p": {"font-family": ["宋体", "serif"]},
+                "q": {"font-family": "宋体"},
+                "b": {"font-family": "宋体"},
+                "i": {"content": "a宋"},
+            },
+            self._parse(
+                "p{font-family: \"宋体\", serif} q{font-family: '宋体'}"
+                ' b{font-family: 宋体} i{content: "a宋"}'
+            ),
+        )
+
+    def test_empty_string(self) -> None:
+        self.assertEqual({"content": ""}, self._parse("p{content: ''}")["p"])
+
+
+class DocumentTest(ParserTestCase):
+    """What the fixes above are for: the document renders, with the rest of the CSS."""
+
+    @staticmethod
+    def _colors(html: bytes) -> list[str]:
+        return [
+            str(flowable.style.textColor)
+            for flowable in pisaStory(html).story
+            if hasattr(flowable, "style")
+        ]
+
+    def test_malformed_at_rules_do_not_stop_the_document(self) -> None:
+        html = (
+            b"<style>@import foo; @namespace svg; @charset 'x'"
+            b" p { color: #ff0000 } @media print</style><p>x</p>"
+        )
+        # "@charset 'x' p {...}" is one invalid at-rule; the rule after it is not.
+        self.assertEqual(["Color(0,0,0,1)"], self._colors(html))
+        html = (
+            b"<style>@namespace svg; p { color: #ff0000 } @media print</style><p>x</p>"
+        )
+        self.assertEqual(["Color(1,0,0,1)"], self._colors(html))
+
+    def test_broken_inline_style_keeps_the_rest(self) -> None:
+        html = b'<p style="color: #ff0000; width: calc(1px">x</p>'
+        self.assertEqual(["Color(1,0,0,1)"], self._colors(html))
+
+    def test_sibling_combinators_tell_siblings_apart(self) -> None:
+        # Siblings shared one cache entry, so "h1 + p" coloured every
+        # paragraph after the heading and "h1 ~ p" and "p + p" none.
+        red, black = "Color(1,0,0,1)", "Color(0,0,0,1)"
+        cases = {
+            b"h1 + p": (b"<h1>t</h1><p>a</p><p>b</p>", [black, red, black]),
+            b"h1 ~ p": (b"<p>a</p><h1>t</h1><p>b</p>", [black, black, red]),
+            b"p + p": (b"<p>a</p><p>b</p><p>c</p>", [black, red, red]),
+        }
+        for selector, (body, colors) in cases.items():
+            with self.subTest(selector=selector):
+                css = b"<style>" + selector + b" { color: #ff0000 }</style>"
+                self.assertEqual(colors, self._colors(css + body))
+
+    def test_selector_list_pseudo_classes_tell_siblings_apart(self) -> None:
+        # Each of these tells two siblings with the same tag apart by
+        # something the style cache has to key on: a class inside :not(),
+        # the children for :has(), an attribute for :checked and :lang().
+        red, black = "Color(1,0,0,1)", "Color(0,0,0,1)"
+        cases = {
+            b"p:not(.x)": (b"<p class='x'>a</p><p>b</p>", [black, red]),
+            b"p:has(b)": (b"<p>a</p><p><b>b</b></p>", [black, red]),
+            b"p:not(:first-child)": (b"<p>a</p><p>b</p>", [black, red]),
+            b"p:lang(fr)": (b"<p lang='en'>a</p><p lang='fr'>b</p>", [black, red]),
+            b"p:is([title])": (b"<p>a</p><p title='t'>b</p>", [black, red]),
+        }
+        for selector, (body, colors) in cases.items():
+            with self.subTest(selector=selector):
+                css = b"<style>" + selector + b" { color: #ff0000 }</style>"
+                self.assertEqual(colors, self._colors(css + body))
+
+    def test_pseudo_class_specificity_in_the_cascade(self) -> None:
+        # div p:first-child is (0,1,2) and beats .x p (0,1,1); it used to be
+        # (0,0,3) and lose. :where() adds nothing, so p beats it.
+        html = (
+            b"<style>div p:first-child { color: #ff0000 } .x p { color: #000000 }"
+            b" p.y { color: #ff0000 } :where(p.y) { color: #000000 }</style>"
+            b"<div class='x'><p>a</p></div><p class='y'>b</p>"
+        )
+        self.assertEqual(["Color(1,0,0,1)", "Color(1,0,0,1)"], self._colors(html))
+
+    def test_attribute_selectors_tell_siblings_apart(self) -> None:
+        # The style cache keyed siblings by tag, class, id and style only, so
+        # the second paragraph was handed the first one's colour.
+        html = (
+            b"<style>p[title^=big] { color: #ff0000 }</style>"
+            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))

{xhtml2pdf-0.2.20 → xhtml2pdf-0.2.22}/tests/test_document.py

@@ -677,3 +677,40 @@ class SourceEncodingTest(TestCase):
         declared = '<meta charset="utf-8">'
         html = f"<html><head>{declared}</head><body><span>Ä-ö-ü</span></body></html>"
         self.assertEqual("Ä-ö-ü", self.text(html.encode("utf-8")))
+
+
+class DebugLogTest(TestCase):
+    """The debug log does not repeat the whole source document (#92)."""
+
+    def test_the_source_is_shortened(self) -> None:
+        html = "<p>" + "long paragraph " * 2000 + "</p>"
+        for src in (html, html.encode()):
+            with (
+                self.subTest(type=type(src).__name__),
+                self.assertLogs("xhtml2pdf.document", level="DEBUG") as logs,
+            ):
+                pisaDocument(src, BytesIO())
+            options = next(
+                line for line in logs.output if "pisaDocument options" in line
+            )
+            self.assertLess(len(options), 1000)
+            self.assertIn("long paragraph", options)
+
+
+class DefaultCssTest(TestCase):
+    """default_css replaces the predefined CSS; extending it keeps the text (#735)."""
+
+    @staticmethod
+    def text(**kwargs) -> str:
+        dest = BytesIO()
+        pisaDocument("<body><p>visible text</p></body>", dest, **kwargs)
+        dest.seek(0)
+        return PdfReader(dest).pages[0].extract_text()
+
+    def test_extending_the_default_css_keeps_the_text(self) -> None:
+        from xhtml2pdf.default import DEFAULT_CSS
+
+        self.assertIn(
+            "visible text",
+            self.text(default_css=DEFAULT_CSS + "body { font-size: 12pt; }"),
+        )