docvortex 0.4.20__tar.gz → 0.4.21__tar.gz

{docvortex-0.4.20/src/docvortex.egg-info → docvortex-0.4.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docvortex
-Version: 0.4.20
+Version: 0.4.21
 Summary: A fast, multi-format document parsing and conversion engine
 License-Expression: MIT
 Project-URL: Repository, https://github.com/myhloli/DocVortex

{docvortex-0.4.20 → docvortex-0.4.21}/src/docvortex/render/_internal/pdf/inline.py

@@ -16,7 +16,7 @@ from reportlab.platypus.paraparser import ParaParser
 from ....schema import CodeInlineSpan, EquationInlineSpan, HyperlinkSpan, InlineSpan, TextSpan
 from .formula import FormulaRenderer, InlineFormulaImage, PdfFormulaError
 from .diagnostics import report_pdf_diagnostic
-from .paragraph import MeasuredCJKParagraph, MeasuredParagraph, PlainCJKParagraph
+from .paragraph import CJKParagraph, MeasuredCJKParagraph, MeasuredParagraph, PlainCJKParagraph
 from .styles import ACCENT_COLOR, HAN_FONT, JAPANESE_FONT, KOREAN_FONT, MONO_FONT, UNICODE_FALLBACK_FONT
 
 _BOOKMARK_SAFE_RE = re.compile(r"[^A-Za-z0-9_]+")
@@ -160,6 +160,14 @@ def build_pdf_paragraph(
         getattr(fragment, "text", "") and fragment.fontName in (HAN_FONT, JAPANESE_FONT, KOREAN_FONT) for fragment in fragments
     ):
         parsed_style = parsed_style.clone(parsed_style.name + " CJK", wordWrap="CJK")
+    if parsed_style.wordWrap == "CJK" and context.formula_images:
+        for fragment in fragments:
+            if isinstance(getattr(getattr(fragment, "cbDefn", None), "image", None), InlineFormulaImage):
+                fragment._pdf_location = context.location(page_idx, block_index, block_type)
+                fragment._pdf_page_idx = page_idx
+                # 公式的上下界参与实际行高，避免高分数与前后行重叠；不修改共享样式。
+                if getattr(parsed_style, "autoLeading", "") in ("", "off"):
+                    parsed_style = parsed_style.clone(parsed_style.name + " Formula", autoLeading="max")
     bullet_text = None
     if bullet_fragments:
         bullet_text = "".join(getattr(fragment, "text", "") for fragment in bullet_fragments)
@@ -169,7 +177,9 @@ def build_pdf_paragraph(
         and not getattr(style, "keepWithNext", False)
         and (parsed_style.wordWrap == "CJK" or sum(len(getattr(fragment, "text", "")) for fragment in fragments) >= 256)
     )
-    paragraph_class = MeasuredParagraph if cache_measurement else Paragraph
+    paragraph_class = (
+        MeasuredParagraph if cache_measurement else (CJKParagraph if parsed_style.wordWrap == "CJK" else Paragraph)
+    )
     if (
         parsed_style.wordWrap == "CJK"
         and not anchor

docvortex-0.4.21/src/docvortex/render/_internal/pdf/paragraph.py

@@ -0,0 +1,250 @@
+"""局部修复 CJK 对象断行，并在普通段落上复用测量，保持 ReportLab 的拆分与绘制契约。"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from copy import copy, deepcopy
+from types import FunctionType
+from unicodedata import category
+
+from reportlab.platypus import Paragraph
+from reportlab.platypus import paragraph as rl_paragraph
+from reportlab.platypus.paraparser import ParaFrag
+
+from .diagnostics import report_pdf_diagnostic
+from .formula import InlineFormulaImage
+
+
+def _natural_cjk_unit(fragment: ParaFrag, text: str) -> rl_paragraph.cjkU:
+    """分页后的公式从未缩放的回调恢复几何，试排不修改原始片段或共享公式。"""
+    definition = getattr(fragment, "cbDefn", None)
+    original = getattr(definition, "_pdf_cjk_original", None)
+    if original is not None:
+        fragment = fragment.clone(cbDefn=original)
+    return rl_paragraph.cjkU(text, fragment, "utf8")
+
+
+def _fit_cjk_formula(unit: rl_paragraph.cjkU, width: float) -> rl_paragraph.cjkU:
+    """仅在空行仍容不下时缩小自有公式，保留原始回调供后续宽窄试排和分页复用。"""
+    definition = getattr(unit.frag, "cbDefn", None)
+    if not isinstance(getattr(definition, "image", None), InlineFormulaImage) or not 0 < width < unit.width:
+        return unit
+    scale = width / unit.width
+    fitted = copy(definition)
+    fitted._pdf_cjk_original = definition
+    fitted.width = width
+    fitted.height = definition.height * scale
+    fitted.valign = definition.valign * scale
+    return rl_paragraph.cjkU(str(unit), unit.frag.clone(cbDefn=fitted), "utf8")
+
+
+def _safe_cjk_split(frags: list[ParaFrag], widths: list[float], calc_bounds: bool) -> rl_paragraph.ParaLines:
+    """沿用上游 CJK 断行规则，但把空文本回调当作完整对象，安全移行并保留零宽标记。"""
+    # Adapted from ReportLab 4.4.4/5.0.1 cjkFragSplit (BSD); see licenses/REPORTLAB.txt.
+    units = []
+    for fragment in frags:
+        text = fragment.text
+        if isinstance(text, bytes):
+            text = text.decode("utf8")
+        units.extend(_natural_cjk_unit(fragment, character) for character in text or [""])
+    lines = []
+    index = start = 0
+    used = 0.0
+    width = widths[0]
+    while index < len(units):
+        unit = units[index]
+        if used == 0:
+            unit = units[index] = _fit_cjk_formula(unit, width)
+        index += 1
+        advance = unit.width
+        if hasattr(advance, "normalizedValue"):
+            advance = advance.normalizedValue(width)
+        used += advance
+        forced = hasattr(unit.frag, "lineBreak")
+        if (used > width + rl_paragraph._FUZZ and used > 0) or forced:
+            extra = width - used
+            if not forced:
+                if unit and ord(unit) < 0x3000:
+                    limit = (start + index) >> 1
+                    for candidate in range(index - 1, limit, -1):
+                        previous = units[candidate]
+                        if previous and (category(previous) == "Zs" or ord(previous) >= 0x3000):
+                            following = candidate + 1
+                            if following < index:
+                                next_index = following + 1
+                                extra += sum(item.width for item in units[next_index:index])
+                                advance = units[following].width
+                                unit = units[following]
+                                index = next_index
+                                break
+                # 空串属于任意字符串的子串，必须显式排除，不能当作悬挂的禁则标点。
+                if (not unit or unit not in rl_paragraph.ALL_CANNOT_START) and index > start + 1:
+                    index -= 1
+                    extra += advance
+            lines.append(rl_paragraph.makeCJKParaLine(units[start:index], width, width - extra, extra, forced, calc_bounds))
+            width = widths[min(len(lines), len(widths) - 1)]
+            start = index
+            used = 0.0
+    # 零宽 anchor 仍有绘制副作用，不能按累计宽度决定是否丢弃尾部片段。
+    if start < len(units):
+        lines.append(rl_paragraph.makeCJKParaLine(units[start:], width, used, width - used, False, calc_bounds))
+    return rl_paragraph.ParaLines(kind=1, lines=lines)
+
+
+def _split_cjk_lines(lines: rl_paragraph.ParaLines, start: int, stop: int) -> list[ParaFrag]:
+    """直接复制已分行的 CJK 片段，避免上游给公式补空格或修改原段落的绘制状态。"""
+    return [fragment.clone() for line in lines.lines[start:stop] for fragment in line.words]
+
+
+class CJKParagraph(Paragraph):
+    """为自有 CJK 特殊片段提供局部安全断行，其余内容继续遵守原生 Paragraph 契约。"""
+
+    def breakLinesCJK(self, maxWidths: float | list[float] | tuple[float, ...]) -> rl_paragraph.ParaLines:
+        """只接管含空文本的片段；保留首行缩进、项目符号及分页首片的既有布局。"""
+        self._pdf_safe_cjk = False
+        if not any(getattr(fragment, "text", None) == "" for fragment in self.frags):
+            return super().breakLinesCJK(maxWidths)
+        self._pdf_safe_cjk = True
+        if hasattr(self, "blPara") and getattr(self, "_splitpara", False):
+            return self.blPara
+        widths = list(maxWidths) if isinstance(maxWidths, (list, tuple)) else [maxWidths]
+        self.height = 0
+        rl_paragraph._handleBulletWidth(self.bulletText, self.style, widths)
+        auto_leading = getattr(self, "autoLeading", getattr(self.style, "autoLeading", ""))
+        return _safe_cjk_split(self.frags, widths, auto_leading not in ("", "off"))
+
+    def _get_split_blParaFunc(self) -> Callable[[rl_paragraph.ParaLines, int, int], list[ParaFrag]]:
+        """只对安全组行的富片段使用无补空格拆分，普通文本仍走原生拆分入口。"""
+        if getattr(self, "_pdf_safe_cjk", False):
+            return _split_cjk_lines
+        return super()._get_split_blParaFunc()
+
+    def draw(self) -> None:
+        """仅对最终绘制的超小公式报告诊断，避免试排产生过时告警。"""
+        if getattr(self, "_pdf_safe_cjk", False):
+            for line in self.blPara.lines:
+                for fragment in line.words:
+                    definition = getattr(fragment, "cbDefn", None)
+                    original = getattr(definition, "_pdf_cjk_original", None)
+                    if original is not None and fragment.fontSize * definition.width / original.width < 6:
+                        report_pdf_diagnostic(
+                            "pdf_layout_small_text",
+                            f"Inline formula fitted below 6 pt ({getattr(fragment, '_pdf_location', '')})",
+                            getattr(fragment, "_pdf_page_idx", None),
+                        )
+        super().draw()
+
+
+_STYLE_FIELDS = ("fontName", "fontSize", "textColor", "rise", "us_lines", "link", "backColor", "nobr")
+_MISSING = object()
+
+
+def _same_plain_style(first, second) -> bool:
+    """普通片段按身份或样式字典比较，避免逐字符触发动态属性查找和缺失属性异常。"""
+    if first is second:
+        return True
+    left, right = first.__dict__, second.__dict__
+    # 保留原生比较中「属性不存在」与「属性值为 None」的区别。
+    return [left.get(name, _MISSING) for name in _STYLE_FIELDS] == [right.get(name, _MISSING) for name in _STYLE_FIELDS]
+
+
+def _plain_cjk_breaker():
+    """仅为自有段落绑定局部比较函数，不复制断行算法，也不修改 ReportLab 模块全局。"""
+    replacement = _same_plain_style
+    for function, dependency in (
+        (getattr(rl_paragraph, "makeCJKParaLine", None), "sameFrag"),
+        (getattr(rl_paragraph, "cjkFragSplit", None), "makeCJKParaLine"),
+        (Paragraph.breakLinesCJK, "cjkFragSplit"),
+    ):
+        # ReportLab 内部实现变化或已被外部包装时，保守回到其原有入口。
+        if not isinstance(function, FunctionType) or dependency not in function.__code__.co_names:
+            return None
+        namespace = function.__globals__.copy()
+        namespace[dependency] = replacement
+        replacement = FunctionType(function.__code__, namespace, function.__name__, function.__defaults__, function.__closure__)
+        replacement.__kwdefaults__ = function.__kwdefaults__
+    return replacement
+
+
+_PLAIN_CJK_BREAK = _plain_cjk_breaker()
+
+
+class PlainCJKParagraph(CJKParagraph):
+    """仅普通 CJK 组行使用局部比较，复杂内容和拆分后的段落交给安全断行层。"""
+
+    def breakLinesCJK(self, maxWidths):
+        """每次检查当前片段，内容变更后不沿用旧资格或样式比较缓存。"""
+        self._pdf_safe_cjk = False
+        if (
+            _PLAIN_CJK_BREAK is not None
+            and len(self.frags) > 1
+            and not self.bulletText
+            and not self.style.endDots
+            and not getattr(self, "_splitpara", False)
+            and all(
+                type(fragment) is ParaFrag
+                and type(getattr(fragment, "text", None)) is str
+                and bool(fragment.text)
+                and "cbDefn" not in fragment.__dict__
+                and "lineBreak" not in fragment.__dict__
+                and not any(fragment.__dict__.get(name) for name in ("link", "us_lines", "rise", "nobr"))
+                for fragment in self.frags
+            )
+        ):
+            return _PLAIN_CJK_BREAK(self, maxWidths)
+        return super().breakLinesCJK(maxWidths)
+
+
+class MeasuredParagraph(CJKParagraph):
+    """缓存仍保存在本对象中的完整排版状态，不跨段落分享 blPara 或 fragments。"""
+
+    def _measurement_key(self, width: float) -> tuple | None:
+        """检查内容、样式及已保存几何；复杂回调和处理后的词列表保守重新测量。"""
+        if any(not hasattr(fragment, "__dict__") or hasattr(fragment, "cbDefn") for fragment in self.frags):
+            return None
+        style = vars(self.style).copy()
+        # ReportLab 已把继承值复制到当前样式，parent 本身不参与 wrap，不能按对象身份比较其深副本。
+        style.pop("parent", None)
+        return (
+            width,
+            style,
+            getattr(self, "autoLeading", None),
+            tuple(vars(fragment) for fragment in self.frags),
+            id(getattr(self, "blPara", None)),
+            getattr(self, "width", None),
+            getattr(self, "height", None),
+            tuple(getattr(self, "_wrapWidths", ())),
+        )
+
+    def wrap(self, availWidth: float, availHeight: float) -> tuple[float, float]:
+        """同宽且状态未变时复用现有换行；Paragraph 本身不使用可用高度决定换行。"""
+        key = self._measurement_key(availWidth)
+        cached = getattr(self, "_measurement_cache", None)
+        if key is not None and cached is not None and key == cached[0]:
+            return cached[1]
+        self._measurement_cache = None
+        result = super().wrap(availWidth, availHeight)
+        key = self._measurement_key(availWidth)
+        if key is not None:
+            # 只在真实换行后保存独立快照；命中时用字典比较，避免逐次序列化样式和长文本。
+            self._measurement_cache = (deepcopy(key), result)
+        return result
+
+    def split(self, availWidth: float, availHeight: float) -> list:
+        """拆分可能修改行布局，返回的新段落独立缓存，原对象随后重新测量。"""
+        self._measurement_cache = None
+        try:
+            return super().split(availWidth, availHeight)
+        finally:
+            self._measurement_cache = None
+
+    def draw(self) -> None:
+        """绘制可能更新行内状态，绘制后不再把旧结果当作未改变的试排状态。"""
+        try:
+            super().draw()
+        finally:
+            self._measurement_cache = None
+
+
+class MeasuredCJKParagraph(MeasuredParagraph, PlainCJKParagraph):
+    """组合普通 CJK 比较与原有测量复用，拆分段落继续拥有独立排版状态。"""

{docvortex-0.4.20 → docvortex-0.4.21}/src/docvortex/version.py

@@ -1,3 +1,3 @@
-__version__ = "0.4.20"
+__version__ = "0.4.21"
 
 __all__ = ["__version__"]

{docvortex-0.4.20 → docvortex-0.4.21/src/docvortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docvortex
-Version: 0.4.20
+Version: 0.4.21
 Summary: A fast, multi-format document parsing and conversion engine
 License-Expression: MIT
 Project-URL: Repository, https://github.com/myhloli/DocVortex

{docvortex-0.4.20 → docvortex-0.4.21}/src/docvortex.egg-info/SOURCES.txt

@@ -606,6 +606,7 @@ tests/unittest/test_ofd_vector_tables.py
 tests/unittest/test_office_demo_exports.py
 tests/unittest/test_office_demo_pages.py
 tests/unittest/test_office_parser_regressions.py
+tests/unittest/test_pdf_cjk_objects.py
 tests/unittest/test_pdf_cjk_style.py
 tests/unittest/test_pdf_cjk_wrapping.py
 tests/unittest/test_pdf_classify.py

docvortex-0.4.21/tests/unittest/test_pdf_cjk_objects.py

@@ -0,0 +1,229 @@
+"""验证 CJK 非文本片段的移行、基线、宽度恢复与真实 PDF 输出。"""
+
+from copy import deepcopy
+from io import BytesIO
+
+import pytest
+from pypdf import PdfReader
+from reportlab.graphics.shapes import Drawing, Rect
+from reportlab.lib import colors
+from reportlab.platypus import Paragraph
+from reportlab.platypus import paragraph as rl_paragraph
+
+from docvortex.render import PdfLayout, render_pdf
+from docvortex.render._internal.pdf.diagnostics import collect_pdf_diagnostics
+from docvortex.render._internal.pdf.formula import FormulaRenderer, FormulaVector
+from docvortex.render._internal.pdf.inline import PdfAnchorRegistry, PdfInlineContext, build_pdf_paragraph
+from docvortex.render._internal.pdf.renderer import _PdfCanvas
+from docvortex.render._internal.pdf.styles import build_pdf_styles
+from docvortex.schema import EquationInlineSpan, TextSpan
+from test_pdf_original_layout import _middle, _text
+
+
+class _SizedFormulas(FormulaRenderer):
+    """以明确宽高的矢量替代字体度量，让边界与基线测试不依赖 ZiaMath 字形。"""
+
+    def render(self, latex: str, *, inline: bool, font_size: float, color: str = "#1f2937") -> FormulaVector:
+        """构造包含实际墨迹的公式代理，绘制测试能检测静默丢失。"""
+        width = float(latex)
+        drawing = Drawing(width, 20)
+        drawing.add(Rect(0, 0, width, 20, fillColor=colors.red, strokeColor=None))
+        return FormulaVector(drawing, width, 20, 15, 5)
+
+
+def _paragraph(parts: list[str | float], *, cached: bool = False, anchor: str | None = None, indent: float = 0):
+    """通过生产段落构造入口生成中文、公式、锚点和显式换行。"""
+    spans = [
+        TextSpan(type="text", content=part)
+        if isinstance(part, str)
+        else EquationInlineSpan(type="equation_inline", content=str(part))
+        for part in parts
+    ]
+    context = PdfInlineContext(_SizedFormulas(), PdfAnchorRegistry([anchor] if anchor else []), cache_paragraphs=cached)
+    return build_pdf_paragraph(
+        spans,
+        build_pdf_styles().body.clone("object-test", fontSize=10, leading=12, firstLineIndent=indent),
+        context=context,
+        page_idx=2,
+        block_index=7,
+        block_type="text",
+        max_width=float("inf"),
+        preserve_newlines=True,
+        anchor=anchor,
+    )
+
+
+def _images(paragraph):
+    """提取最终组行中保留下来的公式回调，而不是原始输入片段。"""
+    return [
+        f.cbDefn
+        for line in paragraph.blPara.lines
+        for f in line.words
+        if getattr(getattr(f, "cbDefn", None), "kind", None) == "img"
+    ]
+
+
+def _text_content(paragraph) -> str:
+    """检查组行结果中的文字顺序及是否被分页插入了空格。"""
+    return "".join(f.text for line in paragraph.blPara.lines for f in line.words)
+
+
+def _assert_bounds(paragraph) -> None:
+    """独立重算每行的真实对象宽度，不只信任 Paragraph 返回的框宽。"""
+    for line in paragraph.blPara.lines:
+        actual = sum(
+            getattr(fragment.cbDefn, "width", 0)
+            if hasattr(fragment, "cbDefn")
+            else rl_paragraph.stringWidth(fragment.text, fragment.fontName, fragment.fontSize)
+            for fragment in line.words
+        )
+        assert actual <= line.maxWidth + 1e-7
+        assert line.currentWidth == pytest.approx(actual)
+
+
+@pytest.mark.parametrize("cached", [False, True])
+def test_formula_moves_intact_to_next_line(cached):
+    """公式放不进剩余空间时整体移行，不能被当作悬挂标点或缩到剩余空隙。"""
+    paragraph = _paragraph(["中文前", 80.0, "后文"], cached=cached)
+    paragraph.wrap(100, 1000)
+    assert not any(hasattr(f, "cbDefn") for f in paragraph.blPara.lines[0].words)
+    assert [image.width for image in _images(paragraph)] == [80]
+    assert _text_content(paragraph) == "中文前后文"
+    _assert_bounds(paragraph)
+
+
+def test_latin_backtracking_crosses_formula_without_ord_error():
+    """Latin 溢出向前回溯会经过空文本公式，覆盖第二处 ord 调用。"""
+    paragraph = _paragraph(["中AAAAAAAA", 20.0, "aaaaaaa"])
+    paragraph.wrap(100, 1000)
+    assert len(_images(paragraph)) == 1
+    assert _text_content(paragraph) == "中AAAAAAAAaaaaaaa"
+    _assert_bounds(paragraph)
+
+
+@pytest.mark.parametrize("cached", [False, True])
+def test_oversize_formula_fits_empty_line_and_restores_on_rewrap(cached):
+    """只缩放临时回调，宽窄交替后宽高与基线从基准恢复，原始最小列宽不变。"""
+    paragraph = _paragraph([300.0, "中文"], cached=cached)
+    original = next(f.cbDefn for f in paragraph.frags if hasattr(f, "cbDefn"))
+    natural_minimum = paragraph.minWidth()
+    for width in [100, 40, 400]:
+        paragraph.wrap(width, 1000)
+        image = _images(paragraph)[0]
+        ratio = min(width / 300, 1)
+        assert (image.width, image.height, image.valign) == pytest.approx((300 * ratio, 20 * ratio, -5 * ratio))
+        assert paragraph.blPara.lines[0].ascent == pytest.approx(15 * ratio)
+        _assert_bounds(paragraph)
+    assert (original.width, original.height, original.valign) == (300, 20, -5)
+    assert paragraph.minWidth() == natural_minimum
+
+
+def test_first_line_indent_adjacent_formulas_and_explicit_breaks():
+    """首行缩进、连续公式和显式换行共同作用时，所有对象只出现一次。"""
+    paragraph = _paragraph([120.0, 60.0, "中文\n结束"], anchor="target", indent=30)
+    paragraph.wrap(100, 1000)
+    assert [image.width for image in _images(paragraph)] == [70, 60]
+    assert _text_content(paragraph) == "中文结束"
+    assert paragraph.blPara.lines[-1].words[-1].text == "结束"
+    _assert_bounds(paragraph)
+
+
+def test_zero_width_anchor_survives_after_forced_break():
+    """宽度为零的末尾 anchor 仍需要绘制，不能被累计宽度判断丢弃。"""
+    from docvortex.render._internal.pdf.paragraph import CJKParagraph
+
+    style = build_pdf_styles().body.clone("anchor-test", wordWrap="CJK")
+    paragraph = CJKParagraph('中文<br/><a name="end"/>', style)
+    paragraph.wrap(100, 1000)
+    output = BytesIO()
+    canvas = _PdfCanvas(output, document_title="anchors")
+    paragraph.drawOn(canvas, 20, 100)
+    assert canvas._destinations["end"].fmt is not None
+    canvas.save()
+
+
+def test_page_split_preserves_objects_text_and_natural_geometry():
+    """分页不修改父段落，不补空格，续段重新变宽后恢复原始公式尺寸。"""
+    paragraph = _paragraph(["中文", 180.0, "后文\n"] * 12, cached=True)
+    paragraph.wrap(100, 1000)
+    original_text = _text_content(paragraph)
+    pieces = paragraph.split(100, 90)
+    assert len(pieces) == 2
+    assert _text_content(paragraph) == original_text
+    for piece in pieces:
+        piece.wrap(100, 1000)
+        _assert_bounds(piece)
+    assert "".join(_text_content(piece) for piece in pieces) == original_text
+    assert sum(len(_images(piece)) for piece in pieces) == 12
+    pieces[1].wrap(300, 1000)
+    assert all(image.width == 180 for image in _images(pieces[1]))
+
+
+def test_small_formula_diagnostic_only_describes_final_drawing():
+    """试排不报告低字号，最终绘制时诊断带有实际页块定位。"""
+    paragraph = _paragraph([300.0, "中文"])
+    with collect_pdf_diagnostics() as diagnostics:
+        paragraph.wrap(30, 1000)
+        assert not diagnostics
+        canvas = _PdfCanvas(BytesIO(), document_title="diagnostics")
+        paragraph.drawOn(canvas, 20, 100)
+        canvas.save()
+    assert len(diagnostics) == 1
+    assert diagnostics[0].code == "pdf_layout_small_text"
+    assert diagnostics[0].page_index == 2
+    assert "block_index=7" in diagnostics[0].message
+
+
+@pytest.mark.parametrize("layout", [PdfLayout.AUTO, PdfLayout.ORIGINAL, PdfLayout.REFLOW])
+def test_public_render_preserves_vectors_links_and_input(layout):
+    """真实长公式经过公开渲染入口，输出矢量与链接并保持 MiddleJson 不变。"""
+    block = _text("中文前文", bbox=(0.1, 0.1, 0.4, 0.8))
+    block["content"] += [
+        {"type": "equation_inline", "content": "+".join(["x_i"] * 80)},
+        {"type": "hyperlink", "url": "https://example.com", "content": [{"type": "text", "content": "中文后文"}]},
+    ]
+    middle = _middle([{"page_idx": 0, "blocks": [block]}])
+    before = deepcopy(middle.to_dict())
+    payload = render_pdf(middle, layout=layout)
+    reader = PdfReader(BytesIO(payload))
+    assert "中文前文" in reader.pages[0].extract_text()
+    assert "中文后文" in reader.pages[0].extract_text()
+    assert reader.pages[0]["/Annots"][0].get_object()["/A"]["/URI"] == "https://example.com"
+    assert b" c" in reader.pages[0].get_contents().get_data()
+    assert middle.to_dict() == before
+
+
+def test_safe_path_does_not_change_reportlab_globals():
+    """安全路径不修改第三方的断行、字符对象或 Paragraph 入口。"""
+    original = (rl_paragraph.cjkFragSplit, rl_paragraph.cjkU, Paragraph.breakLinesCJK)
+    _paragraph(["中文", 300.0]).wrap(100, 1000)
+    assert original == (rl_paragraph.cjkFragSplit, rl_paragraph.cjkU, Paragraph.breakLinesCJK)
+
+
+def test_table_cell_keeps_natural_width_and_draws_fitted_formula():
+    """表格列宽测量保留公式自然宽度，实际窄列绘制仍可缩放且不污染后续宽列。"""
+    from reportlab.platypus import Table
+
+    paragraph = _paragraph(["中文", 180.0, "后文"], cached=True)
+    minimum = paragraph.minWidth()
+    for width in (100, 300):
+        canvas = _PdfCanvas(BytesIO(), document_title="table")
+        table = Table([[paragraph]], colWidths=[width + 12])
+        table.wrapOn(canvas, width + 12, 1000)
+        table.drawOn(canvas, 20, 100)
+        canvas.save()
+        assert _images(paragraph)[0].width == min(180, width)
+        assert paragraph.minWidth() == minimum
+        _assert_bounds(paragraph)
+
+
+def test_mutating_special_paragraph_back_to_plain_clears_safe_state():
+    """可变段落恢复为单一纯文本后，绘制不能继续把普通行结构当作富片段处理。"""
+    paragraph = _paragraph(["中文", 180.0])
+    paragraph.wrap(100, 1000)
+    paragraph.frags = [paragraph.frags[0]]
+    paragraph.wrap(100, 1000)
+    canvas = _PdfCanvas(BytesIO(), document_title="mutated")
+    paragraph.drawOn(canvas, 20, 100)
+    canvas.save()
+    assert not paragraph._pdf_safe_cjk

docvortex-0.4.20/src/docvortex/render/_internal/pdf/paragraph.py

@@ -1,123 +0,0 @@
-"""只在自有普通段落上复用最近一次换行，保持 ReportLab 的拆分与绘制契约。"""
-
-from __future__ import annotations
-
-from copy import deepcopy
-from types import FunctionType
-
-from reportlab.platypus import Paragraph
-from reportlab.platypus import paragraph as rl_paragraph
-from reportlab.platypus.paraparser import ParaFrag
-
-
-_STYLE_FIELDS = ("fontName", "fontSize", "textColor", "rise", "us_lines", "link", "backColor", "nobr")
-_MISSING = object()
-
-
-def _same_plain_style(first, second) -> bool:
-    """普通片段按身份或样式字典比较，避免逐字符触发动态属性查找和缺失属性异常。"""
-    if first is second:
-        return True
-    left, right = first.__dict__, second.__dict__
-    # 保留原生比较中「属性不存在」与「属性值为 None」的区别。
-    return [left.get(name, _MISSING) for name in _STYLE_FIELDS] == [right.get(name, _MISSING) for name in _STYLE_FIELDS]
-
-
-def _plain_cjk_breaker():
-    """仅为自有段落绑定局部比较函数，不复制断行算法，也不修改 ReportLab 模块全局。"""
-    replacement = _same_plain_style
-    for function, dependency in (
-        (getattr(rl_paragraph, "makeCJKParaLine", None), "sameFrag"),
-        (getattr(rl_paragraph, "cjkFragSplit", None), "makeCJKParaLine"),
-        (Paragraph.breakLinesCJK, "cjkFragSplit"),
-    ):
-        # ReportLab 内部实现变化或已被外部包装时，保守回到其原有入口。
-        if not isinstance(function, FunctionType) or dependency not in function.__code__.co_names:
-            return None
-        namespace = function.__globals__.copy()
-        namespace[dependency] = replacement
-        replacement = FunctionType(function.__code__, namespace, function.__name__, function.__defaults__, function.__closure__)
-        replacement.__kwdefaults__ = function.__kwdefaults__
-    return replacement
-
-
-_PLAIN_CJK_BREAK = _plain_cjk_breaker()
-
-
-class PlainCJKParagraph(Paragraph):
-    """仅普通 CJK 组行使用局部比较，复杂内容和拆分后的段落仍交给原入口。"""
-
-    def breakLinesCJK(self, maxWidths):
-        """每次检查当前片段，内容变更后不沿用旧资格或样式比较缓存。"""
-        if (
-            _PLAIN_CJK_BREAK is not None
-            and len(self.frags) > 1
-            and not self.bulletText
-            and not self.style.endDots
-            and not getattr(self, "_splitpara", False)
-            and all(
-                type(fragment) is ParaFrag
-                and type(getattr(fragment, "text", None)) is str
-                and "cbDefn" not in fragment.__dict__
-                and "lineBreak" not in fragment.__dict__
-                and not any(fragment.__dict__.get(name) for name in ("link", "us_lines", "rise", "nobr"))
-                for fragment in self.frags
-            )
-        ):
-            return _PLAIN_CJK_BREAK(self, maxWidths)
-        return super().breakLinesCJK(maxWidths)
-
-
-class MeasuredParagraph(Paragraph):
-    """缓存仍保存在本对象中的完整排版状态，不跨段落分享 blPara 或 fragments。"""
-
-    def _measurement_key(self, width: float) -> tuple | None:
-        """检查内容、样式及已保存几何；复杂回调和处理后的词列表保守重新测量。"""
-        if any(not hasattr(fragment, "__dict__") or hasattr(fragment, "cbDefn") for fragment in self.frags):
-            return None
-        style = vars(self.style).copy()
-        # ReportLab 已把继承值复制到当前样式，parent 本身不参与 wrap，不能按对象身份比较其深副本。
-        style.pop("parent", None)
-        return (
-            width,
-            style,
-            getattr(self, "autoLeading", None),
-            tuple(vars(fragment) for fragment in self.frags),
-            id(getattr(self, "blPara", None)),
-            getattr(self, "width", None),
-            getattr(self, "height", None),
-            tuple(getattr(self, "_wrapWidths", ())),
-        )
-
-    def wrap(self, availWidth: float, availHeight: float) -> tuple[float, float]:
-        """同宽且状态未变时复用现有换行；Paragraph 本身不使用可用高度决定换行。"""
-        key = self._measurement_key(availWidth)
-        cached = getattr(self, "_measurement_cache", None)
-        if key is not None and cached is not None and key == cached[0]:
-            return cached[1]
-        self._measurement_cache = None
-        result = super().wrap(availWidth, availHeight)
-        key = self._measurement_key(availWidth)
-        if key is not None:
-            # 只在真实换行后保存独立快照；命中时用字典比较，避免逐次序列化样式和长文本。
-            self._measurement_cache = (deepcopy(key), result)
-        return result
-
-    def split(self, availWidth: float, availHeight: float) -> list:
-        """拆分可能修改行布局，返回的新段落独立缓存，原对象随后重新测量。"""
-        self._measurement_cache = None
-        try:
-            return super().split(availWidth, availHeight)
-        finally:
-            self._measurement_cache = None
-
-    def draw(self) -> None:
-        """绘制可能更新行内状态，绘制后不再把旧结果当作未改变的试排状态。"""
-        try:
-            super().draw()
-        finally:
-            self._measurement_cache = None
-
-
-class MeasuredCJKParagraph(MeasuredParagraph, PlainCJKParagraph):
-    """组合普通 CJK 比较与原有测量复用，拆分段落继续拥有独立排版状态。"""