texdiff 0.2.2__tar.gz → 0.2.3__tar.gz

{texdiff-0.2.2/src/texdiff.egg-info → texdiff-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: texdiff
-Version: 0.2.2
+Version: 0.2.3
 Summary: AST-driven semantic diff for LaTeX documents
 Author: GoBobr
 License: MIT License

{texdiff-0.2.2 → texdiff-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "texdiff"
-version = "0.2.2"
+version = "0.2.3"
 description = "AST-driven semantic diff for LaTeX documents"
 readme = "README.md"
 license = { file = "LICENSE" }

{texdiff-0.2.2 → texdiff-0.2.3}/src/texdiff/align.py

@@ -120,12 +120,17 @@ def _align_plain(old: list[Node], new: list[Node]) -> list[Edit]:
         return Modify(old=o, new=n)
 
     # 1. common prefix, paired positionally (identical to what a
-    # matching-block run does - only the anchoring is stronger)
+    # matching-block run does - only the anchoring is stronger).
+    # Wildcard signatures additionally need equal text: for them
+    # signature equality means only "same kind of node", so an
+    # inserted sibling shifts every following wildcard by one and a
+    # signature-only prefix would pair the unchanged old item with
+    # the newly inserted neighbour.
     pre = 0
     while (
         pre < len(old)
         and pre < len(new)
-        and old[pre].signature() == new[pre].signature()
+        and _anchorable(old[pre], new[pre])
     ):
         pre += 1
     # common suffix (may not overlap the prefix)
@@ -133,7 +138,9 @@ def _align_plain(old: list[Node], new: list[Node]) -> list[Edit]:
     while (
         suf < len(old) - pre
         and suf < len(new) - pre
-        and old[len(old) - 1 - suf].signature() == new[len(new) - 1 - suf].signature()
+        and _anchorable(
+            old[len(old) - 1 - suf], new[len(new) - 1 - suf]
+        )
     ):
         suf += 1
     mid_old = old[pre : len(old) - suf]
@@ -612,6 +619,31 @@ def _content_similarity(a: "Node", b: "Node") -> float:
     return _text_similarity(a.text or "", b.text or "")
 
 
+# wildcard signatures: equality means "same node kind", not
+# "counterpart" - prefix/suffix anchoring demands equal text for them
+_PLAIN_SIGS = ("text", "group", "env", "macro:label")
+
+
+def _anchorable(o: Node, n: Node) -> bool:
+    """Whether two nodes may extend the prefix/suffix anchor.
+
+    Equal signature is a real anchor for SPECIFIC signatures (macro
+    names, sectioning titles, table row keys). The wildcard
+    signatures (``text``, ``group``, ...) say only "same kind of
+    node": an inserted sibling item shifts every following wildcard
+    by one, and a signature-only anchor then pairs the unchanged old
+    item with the newly inserted neighbour - spurious inline diffs -
+    while the old item's byte-identical counterpart ends up among
+    the inserts. For wildcards we therefore also demand equal text;
+    a genuinely rewritten paragraph simply anchors the diff at its
+    first differing node, which the sequence alignment over the
+    remaining middle then pairs as before.
+    """
+    if o.signature() != n.signature():
+        return False
+    return o.text == n.text or o.signature() not in _PLAIN_SIGS
+
+
 def _sibling_swap_rescue(edits: list[Edit], _pair) -> list[Edit]:
     """Re-pair a Modify whose new side is the WRONG same-sig sibling.
 

{texdiff-0.2.2 → texdiff-0.2.3}/src/texdiff/api.py

@@ -256,6 +256,27 @@ def _run_similarity(a: str, b: str) -> float:
     return SequenceMatcher(a=wa, b=wb, autojunk=False).ratio()
 
 
+def _extends_by_words(short: str, long: str) -> bool:
+    """Whether one run is the other with words appended (or removed).
+
+    Text appended to a sentence (``... compression.`` growing into
+    ``... compression: the file structure ...``) drives the word
+    overlap ratio far below the replace threshold - the shared
+    prefix is drowned by the additions - yet the change IS an edit
+    of the same sentence: the word differ renders exactly the right
+    thing (struck final period, inserted tail). Prefix/suffix word
+    containment therefore overrides the ratio before a paragraph is
+    judged a wholesale rewrite.
+    """
+    wa = [w for w in (t.strip(".,;:!?()\"'`") for t in short.split()) if w]
+    wb = [w for w in (t.strip(".,;:!?()\"'`") for t in long.split()) if w]
+    if len(wa) >= len(wb):
+        wa, wb = wb, wa
+    if not wa or len(wb) - len(wa) < 3:
+        return False
+    return wb[: len(wa)] == wa or wb[len(wb) - len(wa):] == wa
+
+
 def _paragraph_edits(old: str, new: str) -> list[Edit] | None:
     """Word-refine a text run paragraph by paragraph.
 
@@ -283,10 +304,13 @@ def _paragraph_edits(old: str, new: str) -> list[Edit] | None:
     if len(paras_a) != len(paras_b) or any(
         not p.strip() for p in paras_a + paras_b
     ):
-        # mismatched paragraph structure: whole-run judgement
+        # mismatched paragraph structure: whole-run judgement.
+        # (A word-prefix run is still an edit of the same sentence,
+        # never a rewrite - keep the word-level treatment.)
         return (
             None
             if _run_similarity(old, new) < _REPLACE_WORD_SIMILARITY
+            and not _extends_by_words(old, new)
             else _chunks_to_edits(word_diff(old, new))
         )
 
@@ -294,9 +318,17 @@ def _paragraph_edits(old: str, new: str) -> list[Edit] | None:
         # paragraph separator, kept from the NEW side when it exists
         return Match(node=text_node(text if text.strip() else "\n\n"))
 
-    out: list[Edit] = [sep(lead_b or lead_a)]
+    # the lead is leading whitespace of the run (often empty): an
+    # EMPTY lead must not fabricate a "\n\n" paragraph break that
+    # neither revision had - it would typeset a blank line at the
+    # start of the marked run (e.g. right after a list item's bold
+    # label, splitting the item into "label." + "rest" lines)
+    out: list[Edit] = [Match(node=text_node(lead_b or lead_a))]
     for k, (ca, cb) in enumerate(zip(paras_a, paras_b)):
-        if _run_similarity(ca, cb) < _REPLACE_WORD_SIMILARITY:
+        if (
+            _run_similarity(ca, cb) < _REPLACE_WORD_SIMILARITY
+            and not _extends_by_words(ca, cb)
+        ):
             out.append(Delete(old=text_node(ca)))
             out.append(Insert(new=text_node(cb)))
         else:

{texdiff-0.2.2 → texdiff-0.2.3}/src/texdiff/emit.py

@@ -162,11 +162,125 @@ def render(edits: list[Edit], markup: LatexdiffMarkup = LatexdiffMarkup()) -> st
             else:
                 out.append(_wrap_node(edit.old, markup, added=False))
                 out.append(_wrap_node(edit.new, markup, added=True))
-    return _collapse_repeated_hlines(
-        _normalize_endmark_colours("".join(out))
+    return _strike_deleted_blocks(
+        _collapse_repeated_hlines(
+            _collapse_marker_glue(
+                _hoist_markers_off_macros(_normalize_endmark_colours("".join(out)))
+            )
+        )
     )
 
 
+# a block marker sitting directly after a control-sequence name.
+# TeX expands tokens while scanning a macro's argument, so a marker
+# glued after an argument-taking macro (\sphinxcode\DIFaddend{...})
+# executes INSIDE the argument's group scope: the colour switch it
+# performs never unbalances at the outer level and the added colour
+# bleeds over all following black material. Hoisting the marker in
+# front of the macro makes it execute at the outer level where the
+# emitter intended it. The macro part must not itself be a DIF
+# marker (adjacent markers may not commute).
+_MARKER_AFTER_MACRO_RE = re.compile(
+    r"(\\(?!DIF(?:add|del))[a-zA-Z]+\*?)"
+    r"((?:\\DIF(?:add|del)(?:begin|end)(?:FL)?)[ \t]*\n?)"
+)
+
+
+def _hoist_markers_off_macros(text: str) -> str:
+    """Move block markers from after a macro name to before it."""
+    if "\\DIFadd" not in text and "\\DIFdel" not in text:
+        return text
+    return _MARKER_AFTER_MACRO_RE.sub(r"\2\1", text)
+
+
+# a whole deleted block: text between the block markers. Only spans
+# that do not nest and do not already carry word marks are struck;
+# within them, a strike candidate is a text fragment WITHOUT any
+# backslash (macro), brace, ampersand, comment or math shift -
+# prose fragments between inline macro calls strike, entire lines
+# carrying macros stay red-unstruck
+_STRIKE_FRAGMENT_RE = re.compile(r"[^\\{}&%$]*[A-Za-z]{3,}[^\\{}&%$]*")
+
+# a del-block span, non-greedy, not nested (del begin..end never
+# nests another del begin by construction of the emitter)
+_DEL_SPAN_RE = re.compile(
+    r"(\\DIFdelbegin(?:FL)?)(.*?)(\\DIFdelend(?:FL)?)", re.S
+)
+
+
+def _strike_deleted_blocks(text: str) -> str:
+    """Strike plain text lines inside whole deleted blocks.
+
+    A block deletion (a retired environment or list item) colours
+    its span red via ``\\DIFdelbegin`` but never strikes it: the
+    ``\\sout`` of a single \\DIFdel{..} wrapper cannot span the
+    environment/structure inside. The plain prose between the
+    structural commands CAN be struck though, line by line, one
+    ``\\sout{..}`` per word (ulem cannot span the line break
+    itself). Lines containing anything TeX-structural (a macro,
+    brace, ampersand, comment, math) keep the plain red colour -
+    striking those would not compile or would mangle the markup.
+    Lines already carrying an inline \\DIFdel{..} word mark (mixed
+    word-level diffs inside a block region) stay untouched.
+    """
+    if "\\DIFdelbegin" not in text:
+        return text
+
+    def _strike_span(m: "re.Match") -> str:
+        body = m.group(2)
+        if "\\DIFdel{" in body or "\\DIFadd{" in body:
+            return m.group(0)  # already word-marked content
+        if "\\sout{" in body:
+            return m.group(0)  # a per-word strike already present
+        if not re.search(r"[A-Za-z]{3,}", body):
+            return m.group(0)  # structural content only, all red
+        # strike the longest safe fragment of each line: everything
+        # up to the first TeX-structural character; the remainder
+        # (macro calls, braces) keeps the plain red colour
+        out_lines = []
+        for line in body.split("\n"):
+            frag = _STRIKE_FRAGMENT_RE.match(line)
+            if not frag or not frag.group(0).strip():
+                out_lines.append(line)
+                continue
+            head = frag.group(0)
+            words = head.split()
+            struck = " ".join(f"\\sout{{{w}}}" for w in words)
+            out_lines.append(struck + line[len(head):])
+        return m.group(1) + "\n".join(out_lines) + m.group(3)
+
+    return _DEL_SPAN_RE.sub(_strike_span, text)
+
+
+# markup-glue blank lines: a whitespace-only line between block
+# markers of the same type is fabricated by the marker's own
+# trailing newline plus matched glue - TeX reads it as \par and
+# visibly splits an inserted list item's number from its content
+# ("8." alone, blank line, then the blue text). Whitespace-only
+# content carries no information: no revision ever had a blank line
+# between markers with nothing renderable between them.
+_MARKER_GLUE_RE = re.compile(
+    r"(\\DIF(?:add|del)(?:begin|end)(?:FL)?)"
+    r"((?:(?:[ \t]*\n)+[ \t]*|\\DIFadd\{\{\}\})+)"
+    r"(\\DIF(?:add|del)(?:begin|end)(?:FL)?)"
+)
+
+
+def _collapse_marker_glue(text: str) -> str:
+    """Merge blank-line runs between adjacent block markers.
+
+    Only glue that would typeset nothing - whitespace-only lines or
+    an empty ``\\DIFadd{{}}`` wrapper - is collapsed between markers
+    of the same family; real content between markers keeps its
+    paragraphs untouched.
+    """
+    while True:
+        new = _MARKER_GLUE_RE.sub(r"\1\3", text)
+        if new == text:
+            return new
+        text = new
+
+
 # inline end-marker tokens of longtable HEAD material; NOT preceded
 # by an existing colour declaration (the lookbehind avoids doubling
 # up on lines the row renderers already reset). Foot markers
@@ -861,10 +975,37 @@ def _wrap_node(node: Node, markup: LatexdiffMarkup, added: bool) -> str:
         # outside markup - \DIFdel{a & b} is illegal in alignment
         return _wrap_row(node, markup, added)
     if _needs_block(node):
+        if _SAFE_DECOR_RE.fullmatch(node.text.strip()) and _is_safe_inline(
+            _SAFE_DECOR_RE.fullmatch(node.text.strip()).group(2)
+        ):
+            # a decoration macro WITH its complete argument
+            # (\textbf{...} from Sphinx's \sphinxstylestrong etc.)
+            # is LR-safe to wrap as a whole: the markup braces
+            # cannot steal the macro's argument because the node
+            # text carries it. The block markers' trailing newlines
+            # would instead insert a paragraph break after the
+            # wrapped label (a lone \DIFaddend\n between label and
+            # text leaves a blank line at the item's first row).
+            pad_l = node.text[: len(node.text) - len(node.text.lstrip())]
+            pad_r = node.text[len(node.text.rstrip()) :]
+            core = node.text.strip()
+            if added:
+                return pad_l + _wrap(core, markup.add_open, markup.add_close) + pad_r
+            return pad_l + _wrap(core, markup.del_open, markup.del_close) + pad_r
         if added:
             body = _mark_added_listings(node.text)
             body = _mark_heading_args_in_run(body)
             return f"{markup.block_add_open}{body}{markup.block_add_close}"
+        if _DEFINES_MACRO_RE.search(node.text):
+            # a deleted macro definition would not *render* in the
+            # red-strike region - it would EXECUTE at typeset time
+            # and silently redefine the macro, overriding whatever
+            # the (possibly marked-up) preamble or an earlier part
+            # of the body established. latexdiff's convention for
+            # deleted commands applies: comment the definition out
+            # (%DIFDELCMD), invisible in the output, reviewable in
+            # the source.
+            return _comment_out(node.text)
         return f"{markup.block_del_open}{node.text}{markup.block_del_close}"
     if added:
         body = _mark_heading_args_in_run(node.text)
@@ -1052,6 +1193,16 @@ def _wrap_row(node: Node, markup: LatexdiffMarkup, added: bool) -> str:
 # list/paragraph primitives that cannot appear inside \uwave/\sout
 _LIST_ITEM_RE = re.compile(r"\\(?:item|par|newline|linebreak|cr)\b")
 
+# a macro definition inside a deleted block: \def/\gdef/\edef/\xdef
+# directly followed by the defined name, or a \newcommand/\renewcommand
+# whose first argument is the defined name. Matching only the OPENING
+# token keeps false positives near zero (\definedcolor etc. do not
+# parse as \def + name).
+_DEFINES_MACRO_RE = re.compile(
+    r"\\(?:gdef|edef|xdef|def)\s*\\[a-zA-Z]+\s*\{"
+    r"|\\(?:re)?newcommand\*?\s*\{\s*\\[a-zA-Z]+\s*\}"
+)
+
 
 def _comment_out(text: str) -> str:
     """Comment out each line, latexdiff ``%DIFDELCMD <`` convention.
@@ -1570,6 +1721,13 @@ def _render_row_region(edits: list[Edit], markup: LatexdiffMarkup) -> str:
         # single edit: normal render path, but recurse for inner lists
         if isinstance(e, Modify) and e.inner is not None:
             out.append(_render_recursed(e, markup))
+        elif isinstance(e, Modify):
+            # a plain Modify (no children to recurse into) used to
+            # fall through every branch and vanish from the output -
+            # e.g. a reworded \textbf{label} macro inside a modified
+            # list item. Render both sides with the normal wrap.
+            out.append(_wrap_node(e.old, markup, added=False))
+            out.append(_wrap_node(e.new, markup, added=True))
         elif isinstance(e, Match):
             txt = e.node.text
             _record_tail(txt, emitted_tails)

{texdiff-0.2.2 → texdiff-0.2.3}/src/texdiff/preamble.py

@@ -190,7 +190,10 @@ def mark_preamble_macro_changes(
     per-cell colour treatment the emitter uses for unsafe added runs
     - ``\\color{blue}`` re-started after each ``&``. Deleted lines are
     commented out (``%DIF <``, latexdiff preamble convention) so the
-    old rows stay visible in the source without typesetting.
+    old rows stay visible in the source without typesetting. The
+    definition and pure closing lines of a tracked macro stay
+    verbatim, so the colour declaration cannot leak out of the cell
+    groups (see :func:`_color_body_line`).
 
     The operation is textual and strictly contained in the preamble;
     it cannot affect compilation because ``\\color`` inside a macro
@@ -200,6 +203,11 @@ def mark_preamble_macro_changes(
     pre_new, body_new, _post_new = split_preamble(new_source)
     if not pre_new:
         return marked_up
+    # The old counterpart of a preamble macro may be defined in the
+    # old BODY (macros can migrate between revisions): search the
+    # whole old document, so a moved definition keeps its unchanged
+    # rows unmarked instead of painting the entire table blue.
+    old_def = old_source
     names = _invoked_preamble_macros(pre_new, body_new)
     # only macro bodies that are typeset as TABLES may carry the
     # per-cell colour markup: a \color is only meaningful - and only
@@ -216,35 +224,13 @@ def mark_preamble_macro_changes(
     if not changed and not deleted:
         return marked_up
     return (
-        _apply_macro_markup(pre_old, pre_new, changed, deleted, names)
+        _apply_macro_markup(old_def, pre_new, changed, deleted, names)
         + marked_up[len(pre_new) :]
     )
 
 
 def _apply_macro_markup(
-    old_pre: str,
-    new_pre: str,
-    changed: list[str],
-    deleted: list[str],
-    names: set[str],
-) -> str:
-    """Merge the old and new tracked macro bodies, marked per line.
-
-    Emits the NEW preamble with, inside each tracked macro body:
-
-    * genuinely new lines prefixed ``\\color{blue}`` per cell;
-    * lines that existed only in the old body re-inserted at their
-      original position as ``%DIF <`` comments (latexdiff preamble
-      convention: invisible in the typeset output, reviewable in
-      source).
-
-    The merge aligns the old and new body lines on their normalized
-    content (SequenceMatcher over normalized lines): equal lines are
-    kept verbatim, old-only lines become comments, new-only lines
-    are coloured blue.
-    """
-def _apply_macro_markup(
-    old_pre: str,
+    old_def: str,
     new_pre: str,
     changed: list[str],
     deleted: list[str],
@@ -262,15 +248,17 @@ def _apply_macro_markup(
 
     Each macro's old and new body lines are aligned on their
     normalized content (SequenceMatcher): equal lines kept verbatim,
-    old-only lines commented, new-only lines coloured blue. Bodies
-    are spliced back in reverse document order so earlier line
-    indices stay valid.
+    old-only lines commented, new-only lines coloured blue.
+
+    ``old_def`` carries the OLD side text the macro bodies are read
+    from - usually the old preamble, but a whole document when the
+    macro was defined in the old body (migration case).
     """
     pre_out = new_pre.splitlines()
     spliced = False
     for name, rng in _body_ranges(new_pre, names):
         new_body = _macro_body(new_pre, name)
-        old_body = _macro_body(old_pre, name)
+        old_body = _macro_body(old_def, name)
         sm = difflib.SequenceMatcher(
             a=[_norm_line(l) for l in old_body],
             b=[_norm_line(l) for l in new_body],
@@ -290,10 +278,10 @@ def _apply_macro_markup(
             elif tag == "delete":
                 merged.extend(f"%DIF < {l}" for l in old_body[i1:i2])
             elif tag == "insert":
-                merged.extend(_color_line(l) for l in new_body[j1:j2])
+                merged.extend(_color_body_line(l) for l in new_body[j1:j2])
             else:  # replace
                 merged.extend(f"%DIF < {l}" for l in old_body[i1:i2])
-                merged.extend(_color_line(l) for l in new_body[j1:j2])
+                merged.extend(_color_body_line(l) for l in new_body[j1:j2])
         if merged != new_body or len(merged) != len(new_body):
             pre_out[rng[0] : rng[1]] = merged
             spliced = True
@@ -389,3 +377,27 @@ def _color_line(line: str) -> str:
     """Prepend \\color{blue} per table cell (after every &)."""
     line = f"\\color{{blue}} {line}"
     return re.sub(r"(?<!\\)&", r"& \\color{blue} ", line)
+
+
+def _color_body_line(line: str) -> str:
+    """Colour one macro-body line blue, unless it must stay verbatim.
+
+    Two kinds of lines are returned untouched:
+
+    * any definition/newcommand opener (``\\def\\name{...``) - a
+      ``\\color`` painted on the macro's own definition line
+      executes while the PREAMBLE is being read, before any group
+      scopes it, and the declaration then leaks over the entire
+      document (table captions, running headers and page numbers
+      all render blue);
+    * a line that is nothing but braces/whitespace/comment (a pure
+      closing ``}``) - it carries no content and no cell group to
+      contain the declaration.
+    """
+    code = _strip_comment(line)
+    if _DEF_RE.search(code) or _NEWCOMMAND_RE.search(code):
+        return line
+    if _is_closing_line(line):
+        return line
+    line = f"\\color{{blue}} {line}"
+    return re.sub(r"(?<!\\)&", r"& \\color{blue} ", line)

{texdiff-0.2.2 → texdiff-0.2.3/src/texdiff.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: texdiff
-Version: 0.2.2
+Version: 0.2.3
 Summary: AST-driven semantic diff for LaTeX documents
 Author: GoBobr
 License: MIT License

{texdiff-0.2.2 → texdiff-0.2.3}/tests/test_align.py

@@ -69,3 +69,23 @@ class TestSameSignatureDifferentText:
         mods = [e for e in edits if isinstance(e, Modify)]
         assert len(mods) == 1
         assert mods[0].new.children[0].text == "B"
+
+    def test_inserted_sibling_does_not_steal_wildcard_anchor(self):
+        # one item inserted into a list whose entries are wildcard-
+        # signature nodes (texts and plain groups): the unchanged
+        # old tail must Match verbatim, not inline-diff against the
+        # inserted neighbour
+        old = [text_node("a\n\n"), text_node("b long body\n\n"), text_node("c\n\n")]
+        new = [text_node("a\n\n"), text_node("NEW inserted\n\n"), text_node("b long body\n\n"), text_node("c\n\n")]
+        edits = align(old, new)
+        assert [type(e).__name__ for e in edits] == [
+            "Match", "Insert", "Match", "Match",
+        ]
+
+    def test_inserted_group_sibling_leaves_equal_groups_matched(self):
+        # same scenario with plain groups (e.g. {\sphinxupquote{...}}
+        # label groups): equal-text groups anchor, unequal ones do not
+        old = [group(text_node("handlers")), text_node("tail\n\n")]
+        new = [group(text_node("schemas")), group(text_node("handlers")), text_node("tail\n\n")]
+        edits = align(old, new)
+        assert [type(e).__name__ for e in edits] == ["Insert", "Match", "Match"]

texdiff-0.2.3/tests/test_api.py

@@ -0,0 +1,247 @@
+"""End-to-end contract tests for the public API."""
+
+from __future__ import annotations
+
+import pytest
+
+from texdiff import DiffResult, diff_documents, diff_files
+
+
+OLD_DOC = """\
+\\documentclass{article}
+\\begin{document}
+The sensor measures temperature.
+\\begin{itemize}
+\\item accuracy
+\\item range
+\\end{itemize}
+Formula: $E = mc^2$
+\\end{document}
+"""
+
+NEW_DOC = """\
+\\documentclass{article}
+\\begin{document}
+The instrument measures temperature.
+\\begin{itemize}
+\\item accuracy
+\\item dynamic range
+\\item stability
+\\end{itemize}
+Formula: $E = mc^2$
+\\end{document}
+"""
+
+
+class TestDiffDocuments:
+    def test_returns_result_object(self):
+        r = diff_documents(OLD_DOC, NEW_DOC)
+        assert isinstance(r, DiffResult)
+
+    def test_stats_count_changes(self):
+        r = diff_documents(OLD_DOC, NEW_DOC)
+        assert r.stats.changed > 0
+
+    def test_identical_docs_no_changes(self):
+        r = diff_documents(OLD_DOC, OLD_DOC)
+        assert r.stats.changed == 0
+        assert r.marked_up == OLD_DOC
+
+    def test_markup_present(self):
+        r = diff_documents(OLD_DOC, NEW_DOC)
+        assert "\\DIFadd{" in r.marked_up or "\\DIFdel{" in r.marked_up
+
+    def test_unchanged_lines_verbatim(self):
+        r = diff_documents(OLD_DOC, NEW_DOC)
+        assert "Formula: $E = mc^2$" in r.marked_up
+
+    def test_preamble_injected_before_begin_document(self):
+        r = diff_documents(OLD_DOC, NEW_DOC)
+        assert "\\providecommand{\\DIFadd}" in r.marked_up
+        # injected before \begin{document}, i.e. into the preamble
+        assert r.marked_up.index("\\providecommand{\\DIFadd}") < r.marked_up.index(
+            "\\begin{document}"
+        )
+
+    def test_preamble_not_injected_when_already_defined(self):
+        doc = OLD_DOC.replace(
+            "\\begin{document}",
+            "\\providecommand{\\DIFadd}[1]{#1}\n\\providecommand{\\DIFdel}[1]{#1}\n\\begin{document}",
+        )
+        r = diff_documents(doc, doc)
+        marked = r.marked_up
+        assert marked.count("\\providecommand{\\DIFadd}") == 1
+
+    def test_no_preamble_for_fragments(self):
+        r = diff_documents("plain fragment old\n", "plain fragment new\n")
+        assert "\\providecommand" not in r.marked_up
+
+
+class TestDiffFiles:
+    def test_file_api(self, tmp_path):
+        old = tmp_path / "old.tex"
+        new = tmp_path / "new.tex"
+        old.write_text(OLD_DOC, encoding="utf-8")
+        new.write_text(NEW_DOC, encoding="utf-8")
+        r = diff_files(str(old), str(new))
+        assert "\\DIFadd{" in r.marked_up or "\\DIFdel{" in r.marked_up
+
+
+class TestTableScenario:
+    """The scenario that breaks latexdiff: restructured longtable rows."""
+
+    OLD_TABLE = """\
+\\begin{longtable}{|l|l|}
+\\hline
+name & type \\\\
+\\hline
+longitude & float32 \\\\
+latitude & float32 \\\\
+\\hline
+\\end{longtable}
+"""
+
+    NEW_TABLE = """\
+\\begin{longtable}{|l|l|}
+\\hline
+name & type \\\\
+\\hline
+latitude & float32 \\\\
+longitude & float32 \\\\
+\\hline
+\\end{longtable}
+"""
+
+    def test_row_reorder_produces_valid_markup(self):
+        r = diff_documents(self.OLD_TABLE, self.NEW_TABLE)
+        # rows reordered: aligned/merged, never glued together
+        assert "longitude" not in r.marked_up.split("latitude")[0].split("\\DIFdel")[0] or True
+        assert "\\begin{longtable}" in r.marked_up
+        assert "\\end{longtable}" in r.marked_up
+
+    def test_row_insertion_marks_row(self):
+        old = self.OLD_TABLE
+        extra = old.replace(
+            "latitude & float32 \\\\\n",
+            "latitude & float32 \\\\\npolarised & float \\\\\n",
+        )
+        r = diff_documents(old, extra)
+        # v0 contract: tables are atomic (row-granular alignment is
+        # v1), so the whole table is block-replaced - but the output
+        # must still contain the added row and compile-safe markers
+        assert "\\DIFaddbegin" in r.marked_up
+        assert "polarised" in r.marked_up
+        assert "\\begin{longtable}" in r.marked_up
+        assert "\\end{longtable}" in r.marked_up
+
+
+class TestModifiedLabelledItem:
+    """A reworded item of a labelled list (bold head + text body).
+
+    Sphinx list items render as ``\\item {}`` + ``\\par`` +
+    ``\\sphinxstylestrong{Label}: body``; the bold head is an atomic
+    macro node and the body a separate text node. Both used to take
+    block markers whose trailing newlines - plus a fabricated ``\\n\\n``
+    lead from the paragraph refine - typeset a blank line between the
+    item number and the (struck/added) content, breaking the item
+    across two visual lines.
+    """
+
+    OLD = """\
+\\documentclass{article}
+\\begin{document}
+\\begin{enumerate}
+\\item {}
+\\par
+\\textbf{Output packaging}: Processed files packaged by the IOHandler.
+\\end{enumerate}
+\\end{document}
+"""
+
+    def _diff(self, new_body: str) -> str:
+        new = self.OLD.replace(
+            "\\textbf{Output packaging}: Processed files packaged by the IOHandler.",
+            new_body,
+        )
+        return diff_documents(self.OLD, new, inject_preamble=False).marked_up
+
+    def test_no_paragraph_break_after_item_label(self):
+        out = self._diff(
+            "\\textbf{Schema-driven output}: Each file created by the writer."
+        )
+        # the label keeps the inline wrap (no block markers with
+        # their trailing newlines) and stays glued to the body:
+        # no blank line between the item label and the text run
+        assert "\\DIFdelbegin\n" not in out
+        assert "\\textbf{Output packaging}\\DIFdelend" not in out
+        assert "\\DIFdel{\\textbf{Output packaging}}" in out
+        assert "\\DIFadd{\\textbf{Schema-driven output}}" in out
+        assert "\\DIFdel{\\textbf{Output packaging}}\\DIFadd{" in out
+
+    def test_reworded_plain_item_stays_one_paragraph(self):
+        out = self._diff(
+            "\\textbf{Output packaging}: Each file is packaged into SAFE containers."
+        )
+        # same label, reworded body: the label stays visible right
+        # after \par and no blank line opens between it and the
+        # marked-up body
+        assert "\\textbf{Output packaging}" in out
+        assert "par\n\\textbf" in out
+        assert "\\textbf{Output packaging}\n\n" not in out
+        assert "\\DIFdel{" in out and "\\DIFadd{" in out
+
+
+class TestAppendedClause:
+    """A sentence extended with a new clause stays word-diffed.
+
+    The overlap ratio of "... compression." growing into
+    "... compression: the file structure ..." falls below the
+    replace threshold, yet the change is an edit of the same
+    sentence - not a wholesale rewrite. The word differ renders it
+    as a struck final period plus an inserted tail.
+    """
+
+    OLD = (
+        "\\documentclass{article}\n\\begin{document}\n"
+        "Write output to NetCDF4 with standardised metadata and compression.\n"
+        "\\end{document}\n"
+    )
+
+    def _diff(self, new_body: str) -> str:
+        new = self.OLD.replace(
+            "Write output to NetCDF4 with standardised metadata and compression.",
+            new_body,
+        )
+        return diff_documents(self.OLD, new, inject_preamble=False).marked_up
+
+    def test_appended_clause_is_word_diffed(self):
+        out = self._diff(
+            "Write output to NetCDF4 with standardised metadata and "
+            "compression: the file structure (dimensions, variables, "
+            "types, fill values, attributes) is defined by the NCML "
+            "product schema for the output type and written through "
+            "the generic schema-driven writer."
+        )
+        # the shared sentence is kept and the change is inline word
+        # markup (both families present), NOT a whole-paragraph
+        # retire + re-add, which would strike the full old sentence
+        assert "Write output to NetCDF4 with standardised metadata" in out
+        assert "\\DIFadd{" in out
+        assert "\\DIFdel{" in out
+        # the struck material is punctuation/small words only - the
+        # sentence body is never deleted wholesale
+        import re as _re
+
+        for m in _re.finditer(r"\\DIFdel\{([^{}]*)\}", out):
+            words = [w for w in m.group(1).split() if w.isalpha()]
+            assert len(words) <= 2, m.group(1)
+
+    def test_genuine_rewrite_still_retires(self):
+        out = self._diff(
+            "Completely different content that shares no words at all here."
+        )
+        # unrelated sentence: whole-paragraph retire + re-add - the
+        # full old sentence is struck in one piece (block or whole-
+        # paragraph inline form, never word fragments)
+        assert "\\DIFdel{Write output to NetCDF4" in out
+        assert "\\DIFadd{Completely different" in out

{texdiff-0.2.2 → texdiff-0.2.3}/tests/test_preamble.py

@@ -14,6 +14,8 @@ from __future__ import annotations
 
 import pytest
 
+import re
+
 from texdiff.api import diff_documents
 from texdiff.preamble import new_preamble, preamble_tuple, split_preamble
 
@@ -151,3 +153,55 @@ class TestMacroBodyMarkup:
         out = self._run(old_rows, new_rows)
         assert out.count("2 & 2023 & & DCR1") == 1
         assert "\\hline}" in out
+
+    def test_definition_line_never_coloured(self):
+        # a \color painted on the macro's own definition line would
+        # execute while the PREAMBLE is being read - no group scopes
+        # it there - leaking blue over the entire document (table
+        # captions, running headers, page numbers)
+        old_rows = "1 & 2022 & & Init \\\\\n\\hline"
+        new_rows = "1 & 2022 & & Init \\\\\n2 & 2023 & & DCR1 \\\\\n\\hline"
+        out = self._run(old_rows, new_rows)
+        assert "\\color{blue} \\def\\changerecord{" not in out
+        start = out.index("\\def\\changerecord{")
+        assert not out[start:].startswith("\\color")
+
+    def test_migrated_macro_keeps_unchanged_rows_black(self):
+        # the macro defined in the old BODY and in the new PREAMBLE:
+        # the old body must be searched for the counterpart rows, or
+        # every row (including unchanged ones) is painted blue
+        old = (
+            "\\documentclass{article}\n"
+            "\\begin{document}\n"
+            "\\def\\changerecord{%\n"
+            "1 & 2022 & & Init \\\\\n"
+            "}\n"
+            "\\begin{longtable}{ll}\n\\changerecord\n\\end{longtable}\n"
+            "\\end{document}\n"
+        )
+        new = (
+            "\\documentclass{article}\n"
+            "\\def\\changerecord{%\n"
+            "1 & 2022 & & Init \\\\\n"
+            "2 & 2023 & & DCR1 \\\\\n"
+            "}\n"
+            "\\begin{document}\n"
+            "\\begin{longtable}{ll}\n\\changerecord\n\\end{longtable}\n"
+            "\\end{document}\n"
+        )
+        out = diff_documents(old, new).marked_up
+        pre = out[: out.index("\\begin{document}")]
+        # the unchanged row 1 keeps no colour declaration ahead of it
+        assert "\\color{blue} 1 & 2022" not in pre
+        # the new row 2 is coloured per cell
+        assert re.search(
+            r"\\color\{blue\} 2 & \\color\{blue\}\s+2023", pre
+        )
+        # the old body-side definition no longer typesets: it would
+        # silently redefine the macro and override the marked one
+        # (it must survive only inside %DIFDELCMD comments)
+        body = out[out.index("\\begin{document}") :]
+        body_code = "\n".join(
+            l for l in body.splitlines() if not l.lstrip().startswith("%")
+        )
+        assert "\\def\\changerecord{" not in body_code

texdiff-0.2.2/tests/test_api.py

@@ -1,135 +0,0 @@
-"""End-to-end contract tests for the public API."""
-
-from __future__ import annotations
-
-import pytest
-
-from texdiff import DiffResult, diff_documents, diff_files
-
-
-OLD_DOC = """\
-\\documentclass{article}
-\\begin{document}
-The sensor measures temperature.
-\\begin{itemize}
-\\item accuracy
-\\item range
-\\end{itemize}
-Formula: $E = mc^2$
-\\end{document}
-"""
-
-NEW_DOC = """\
-\\documentclass{article}
-\\begin{document}
-The instrument measures temperature.
-\\begin{itemize}
-\\item accuracy
-\\item dynamic range
-\\item stability
-\\end{itemize}
-Formula: $E = mc^2$
-\\end{document}
-"""
-
-
-class TestDiffDocuments:
-    def test_returns_result_object(self):
-        r = diff_documents(OLD_DOC, NEW_DOC)
-        assert isinstance(r, DiffResult)
-
-    def test_stats_count_changes(self):
-        r = diff_documents(OLD_DOC, NEW_DOC)
-        assert r.stats.changed > 0
-
-    def test_identical_docs_no_changes(self):
-        r = diff_documents(OLD_DOC, OLD_DOC)
-        assert r.stats.changed == 0
-        assert r.marked_up == OLD_DOC
-
-    def test_markup_present(self):
-        r = diff_documents(OLD_DOC, NEW_DOC)
-        assert "\\DIFadd{" in r.marked_up or "\\DIFdel{" in r.marked_up
-
-    def test_unchanged_lines_verbatim(self):
-        r = diff_documents(OLD_DOC, NEW_DOC)
-        assert "Formula: $E = mc^2$" in r.marked_up
-
-    def test_preamble_injected_before_begin_document(self):
-        r = diff_documents(OLD_DOC, NEW_DOC)
-        assert "\\providecommand{\\DIFadd}" in r.marked_up
-        # injected before \begin{document}, i.e. into the preamble
-        assert r.marked_up.index("\\providecommand{\\DIFadd}") < r.marked_up.index(
-            "\\begin{document}"
-        )
-
-    def test_preamble_not_injected_when_already_defined(self):
-        doc = OLD_DOC.replace(
-            "\\begin{document}",
-            "\\providecommand{\\DIFadd}[1]{#1}\n\\providecommand{\\DIFdel}[1]{#1}\n\\begin{document}",
-        )
-        r = diff_documents(doc, doc)
-        marked = r.marked_up
-        assert marked.count("\\providecommand{\\DIFadd}") == 1
-
-    def test_no_preamble_for_fragments(self):
-        r = diff_documents("plain fragment old\n", "plain fragment new\n")
-        assert "\\providecommand" not in r.marked_up
-
-
-class TestDiffFiles:
-    def test_file_api(self, tmp_path):
-        old = tmp_path / "old.tex"
-        new = tmp_path / "new.tex"
-        old.write_text(OLD_DOC, encoding="utf-8")
-        new.write_text(NEW_DOC, encoding="utf-8")
-        r = diff_files(str(old), str(new))
-        assert "\\DIFadd{" in r.marked_up or "\\DIFdel{" in r.marked_up
-
-
-class TestTableScenario:
-    """The scenario that breaks latexdiff: restructured longtable rows."""
-
-    OLD_TABLE = """\
-\\begin{longtable}{|l|l|}
-\\hline
-name & type \\\\
-\\hline
-longitude & float32 \\\\
-latitude & float32 \\\\
-\\hline
-\\end{longtable}
-"""
-
-    NEW_TABLE = """\
-\\begin{longtable}{|l|l|}
-\\hline
-name & type \\\\
-\\hline
-latitude & float32 \\\\
-longitude & float32 \\\\
-\\hline
-\\end{longtable}
-"""
-
-    def test_row_reorder_produces_valid_markup(self):
-        r = diff_documents(self.OLD_TABLE, self.NEW_TABLE)
-        # rows reordered: aligned/merged, never glued together
-        assert "longitude" not in r.marked_up.split("latitude")[0].split("\\DIFdel")[0] or True
-        assert "\\begin{longtable}" in r.marked_up
-        assert "\\end{longtable}" in r.marked_up
-
-    def test_row_insertion_marks_row(self):
-        old = self.OLD_TABLE
-        extra = old.replace(
-            "latitude & float32 \\\\\n",
-            "latitude & float32 \\\\\npolarised & float \\\\\n",
-        )
-        r = diff_documents(old, extra)
-        # v0 contract: tables are atomic (row-granular alignment is
-        # v1), so the whole table is block-replaced - but the output
-        # must still contain the added row and compile-safe markers
-        assert "\\DIFaddbegin" in r.marked_up
-        assert "polarised" in r.marked_up
-        assert "\\begin{longtable}" in r.marked_up
-        assert "\\end{longtable}" in r.marked_up