texdiff 0.2.5__tar.gz → 0.2.6__tar.gz

{texdiff-0.2.5/src/texdiff.egg-info → texdiff-0.2.6}/PKG-INFO

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

{texdiff-0.2.5 → texdiff-0.2.6}/pyproject.toml

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

{texdiff-0.2.5 → texdiff-0.2.6}/src/texdiff/__init__.py

@@ -42,4 +42,4 @@ __all__ = [
     "word_diff",
 ]
 
-__version__ = "0.2.5"
+__version__ = "0.2.6"

{texdiff-0.2.5 → texdiff-0.2.6}/src/texdiff/align.py

@@ -107,6 +107,18 @@ def _align_plain(old: list[Node], new: list[Node]) -> list[Edit]:
     def _pair(o: Node, n: Node) -> Edit:
         if o.text == n.text:
             return Match(node=o)
+        if not (o.text or "").strip() and not (n.text or "").strip():
+            # whitespace-only pair: the two revisions differ only in
+            # how many blank lines separate two paragraphs. A Modify
+            # here renders as a del-block + add-block pair, and the
+            # marker glue pass then collapses the blank line BETWEEN
+            # those markers - the paragraph break both revisions had
+            # disappears, and the next paragraph's \sphinxAtStartPar
+            # (a \leavevmode, NOT a \par) leaves its first line glued
+            # to the previous one. Keep the NEW bytes verbatim: the
+            # break survives and no change is marked for invisible
+            # whitespace.
+            return Match(node=n)
         if o.kind == "row" and n.kind == "row" and o.name == n.name:
             # equal row signature (content key) with differing text
             # means the difference is purely structural: \hline on

{texdiff-0.2.5 → texdiff-0.2.6}/src/texdiff/api.py

@@ -21,6 +21,11 @@ from .align import Delete, Edit, Insert, Match, Modify, align
 # re-added wholesale instead of word-marked: two sentences sharing
 # less than half their words are a rewrite, not an edit
 _REPLACE_WORD_SIMILARITY = 0.5
+
+# minimum common word run at a paragraph edge that keeps the pair on
+# the word-level path even below the ratio floor: a whole clause
+# (4+ words) is clearly the same sentence edited, not a rewrite
+_EDGE_WORD_MIN = 4
 from .emit import LatexdiffMarkup, render
 from .flatten import Flattener, flatten_file, flatten_source
 from .nodes import Node, text_node
@@ -257,24 +262,54 @@ def _run_similarity(a: str, b: str) -> float:
 
 
 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
+    """Whether one run shares a long word edge with the other.
+
+    Two cases keep a paragraph word-diffed even when the overlap
+    ratio falls below the replace threshold:
+
+    * **appended clause** - ``... compression.`` growing into
+      ``... compression: the file structure ...``: the shared
+      prefix is drowned by the additions, yet the change IS an
+      edit of the same sentence (struck final period, inserted
+      tail);
+    * **shared edge** - a paragraph split at a macro boundary (the
+      parser cuts runs at ``\\sphinxhyphen`` etc.) can leave a tail
+      whose common prefix with the other side is a whole clause
+      (``array support and HDF5 diagnostic suppression)``) while
+      the rest is reworded. Full containment misses it; a long
+      common edge catches it.
+
+    The word differ renders both correctly, so a shared edge of at
+    least a few words overrides the ratio before the 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:
+    if not wa or not wb:
         return False
-    return wb[: len(wa)] == wa or wb[len(wb) - len(wa):] == wa
+    # containment (append/remove): needs a meaningful addition
+    if len(wb) - len(wa) >= 3 and (
+        wb[: len(wa)] == wa or wb[len(wb) - len(wa):] == wa
+    ):
+        return True
+    # shared edge: longest common word run at the start or the end
+    # of both, counted case-insensitively (``Writing`` vs
+    # ``writing`` is the same word) and requiring a meaningful
+    # stretch - a whole clause, not a stop word
+    def edge(a: list[str], b: list[str]) -> int:
+        n = 0
+        for x, y in zip(a, b):
+            if x.lower() != y.lower():
+                break
+            n += 1
+        return n
+
+    return max(
+        edge(wa, wb),
+        edge(wa[::-1], wb[::-1]),
+    ) >= _EDGE_WORD_MIN
 
 
 def _paragraph_edits(old: str, new: str) -> list[Edit] | None:

{texdiff-0.2.5 → texdiff-0.2.6}/src/texdiff/emit.py

@@ -87,6 +87,7 @@ def render(edits: list[Edit], markup: LatexdiffMarkup = LatexdiffMarkup()) -> st
     # between two Inserts and blocks the fusion
     edits = _pull_punctuation_deletes(edits)
     edits = _fuse_split_add_regions(edits)
+    edits = _hoist_repeated_phrases(edits)
     for edit in edits:
         if isinstance(edit, Match):
             out.append(edit.node.text)
@@ -685,6 +686,268 @@ def _fuse_split_add_regions(edits: list[Edit]) -> list[Edit]:
     return out
 
 
+# relocated-phrase detection: a word run shared between a deleted
+# region and the following added region must span at least this many
+# words ...
+_SHARED_RUN_MIN_WORDS = 4
+# ... AND at least this fraction of the shorter region's words, so
+# the bar rises with region size: a 30-word region needs a 10-word
+# shared run, a 6-word region only the floor of 4
+_SHARED_RUN_MIN_FRACTION = 3
+
+# edge punctuation: word identity ignores it ("filtering)" pairs
+# with "filtering"), but the characters themselves belong to the
+# side that carries them and keep that side's markup
+_SHARED_RUN_PUNCT = ".,;:!?()\"'`"
+
+
+def _shared_run_min(na: int, nb: int) -> int:
+    """Minimum word count for a run to count as relocated text.
+
+    Scales with region size instead of a flat constant: the longer
+    the deleted and added regions, the longer a common stretch must
+    be before it is treated as deliberate unchanged content that
+    moved, rather than words two different sentences happen to
+    share.
+    """
+    return max(
+        _SHARED_RUN_MIN_WORDS, min(na, nb) // _SHARED_RUN_MIN_FRACTION
+    )
+
+
+def _word_spans(text: str) -> list[tuple[int, int, str]]:
+    """(start, end, word) for every whitespace-separated word."""
+    return [(m.start(), m.end(), m.group(0)) for m in re.finditer(r"\S+", text)]
+
+
+def _relocated_span(del_text: str, ins_text: str) -> tuple[int, int] | None:
+    """Character span in ``del_text`` of a phrase that also exists
+    verbatim in ``ins_text`` (the following added region).
+
+    Words are compared with edge punctuation stripped - a deleted
+    word ``filtering)`` pairs with an added ``filtering`` - but the
+    returned span stops at word-character boundaries, so stray
+    punctuation (the ``(`` of ``(with``, the ``).`` after
+    ``filtering``) stays struck on the old side. The shared span
+    must appear in the added text character-for-character; interior
+    punctuation differences are not relocation.
+    """
+    dw = _word_spans(del_text)
+    iw = _word_spans(ins_text)
+    if not dw or not iw:
+        return None
+
+    def keys(spans: list[tuple[int, int, str]]) -> list[str]:
+        # empty keys (pure-punctuation words) must not match each
+        # other; sentinel keeps 1:1 index alignment with spans
+        return [
+            w[2].strip(_SHARED_RUN_PUNCT) or f"\x00{w[0]}"
+            for w in spans
+        ]
+
+    dk, ik = keys(dw), keys(iw)
+    sm = SequenceMatcher(a=dk, b=ik, autojunk=False)
+    best: tuple[int, int] | None = None
+    for blk in sm.get_matching_blocks():
+        if blk.size < _shared_run_min(len(dk), len(ik)):
+            continue
+        first, last = dw[blk.a], dw[blk.a + blk.size - 1]
+        s = first[0] + (len(first[2]) - len(first[2].lstrip(_SHARED_RUN_PUNCT)))
+        e = last[1] - (len(last[2]) - len(last[2].rstrip(_SHARED_RUN_PUNCT)))
+        if e <= s:
+            continue
+        if ins_text.find(del_text[s:e]) < 0:
+            continue
+        if best is None or (e - s) > (best[1] - best[0]):
+            best = (s, e)
+    return best
+
+
+def _hoist_repeated_phrases(edits: list[Edit]) -> list[Edit]:
+    """Render a phrase that moved across a node boundary once, unmarked.
+
+    The parser splits text at macro boundaries (``\\sphinxhyphen{}``,
+    ``{\\hyperref{...}}``), so a sentence fragment deleted on the old
+    side and its identical twin inside the following inserted text
+    can never meet inside one word diff - the aligner saw two
+    different fragments. The phrase would render twice: once struck
+    red in place, once again coloured as new ("with configurable
+    zlib compression and shuffle filtering" retired AND re-added).
+
+    A delete whose text contains a word run long enough to be
+    deliberate unchanged content and shared - word-for-word, ignoring
+    edge punctuation - with the following added region (inserts and
+    macro glue up to the next real delete or paragraph break) is a
+    relocation, not a deletion. Both regions give the shared run up:
+    the delete keeps only what truly went away (the stray bracket
+    characters around the run) and, when the run sits inside ONE
+    insert, that insert splits into add-run / plain shared text /
+    add-run - the phrase typesets once, unmarked, exactly as
+    latexdiff renders text present in both revisions.
+    """
+
+    def text_node(t: str, like: Node) -> Node:
+        return Node(kind=like.kind, text=t, atom=True, pos=like.pos)
+
+    for _ in range(10):  # converges; guard against pathological loops
+        replaced = False
+        for i, edit in enumerate(edits):
+            if not (isinstance(edit, Delete) and edit.old.kind == "text"):
+                continue
+            del_text = edit.old.text
+            if len(_word_spans(del_text)) < _SHARED_RUN_MIN_WORDS:
+                continue
+            region: list[str] = []
+            # eligible inserts in the region, as (index, accumulated
+            # offset) so a char span in the joined text maps back
+            ins_at: list[tuple[int, int]] = []
+            off = 0
+            for j, nxt in enumerate(edits[i + 1 :], start=i + 1):
+                if isinstance(nxt, Delete):
+                    if nxt.old.text.strip():
+                        break  # real competing old content ends it
+                    continue  # old paragraph separator: text goes on
+                if isinstance(nxt, Match):
+                    if "\n\n" in nxt.node.text:
+                        break  # paragraph boundary ends the region
+                    region.append(nxt.node.text)
+                    off += len(nxt.node.text)
+                elif isinstance(nxt, Insert) and _inline_kind(nxt.new):
+                    region.append(nxt.new.text)
+                    ins_at.append((j, off))
+                    off += len(nxt.new.text)
+                elif (
+                    isinstance(nxt, Insert)
+                    and nxt.new.kind == "group"
+                    and not _needs_block_env(nxt.new)
+                ):
+                    # inline group (e.g. {\hyperref{...}}): part of the
+                    # surrounding sentence, its text belongs to the
+                    # added region
+                    region.append(nxt.new.text)
+                    ins_at.append((j, off))
+                    off += len(nxt.new.text)
+                else:
+                    break
+            span = _relocated_span(del_text, "".join(region))
+            if span is None:
+                continue
+            lo, hi = span
+            shared = del_text[lo:hi]
+            # position of the shared run inside the JOINED region -
+            # del-text offsets and region offsets are different
+            # coordinate systems
+            rlo = "".join(region).find(shared)
+            if rlo < 0:
+                continue
+            # locate the single insert carrying the shared run; when
+            # it straddles insert/match boundaries the plain-text
+            # emission is not possible - the insert stays whole and
+            # the phrase renders as (unstruck) added text
+            carrier: tuple[int, int] | None = None
+            for j, base in ins_at:
+                txt = edits[j].new.text
+                if base <= rlo and base + len(txt) >= rlo + len(shared):
+                    found = txt.find(shared)
+                    if found < 0:
+                        carrier = None
+                        break
+                    carrier = (j, found)
+                    break
+            if carrier is None:
+                continue
+            j, c_off = carrier
+            ins = edits[j]
+            before, after = (
+                ins.new.text[:c_off],
+                ins.new.text[c_off + len(shared) :],
+            )
+            # the delete keeps only its genuinely removed edges. The
+            # PREFIX edge stays at the delete's position (the "(" of
+            # a retired parenthetical reads correctly right before
+            # the replacement text); the SUFFIX edge belongs AFTER
+            # the relocated phrase - the old ")" closed the
+            # parenthetical, which now ends at the phrase's new
+            # position, so striking it before the phrase puts the
+            # closing bracket in the middle of the sentence.
+            head = [t for t in (del_text[:lo],) if t.strip()]
+            tail = [t for t in (del_text[hi:],) if t.strip()]
+            # the insert: shared run pulled out as plain text. Edge
+            # fragments keep their WHITESPACE - a dropped fragment's
+            # leading/trailing newlines carry the new revision's
+            # paragraphing, and losing them glues the next paragraph
+            # onto the relocated phrase ('...filtering).' + 'SAFE
+            # handling:' on one line).
+            def ws_only(t: str) -> str:
+                return "".join(c for c in t if c.isspace())
+
+            pieces: list[Edit] = [Match(node=text_node(shared, ins.new))]
+            if before.strip():
+                pieces.insert(
+                    0, Insert(new=text_node(before, ins.new))
+                )
+            elif before:
+                pieces.insert(0, Match(node=text_node(before, ins.new)))
+            # an add-side tail that is pure punctuation the delete's
+            # suffix edge already carries (the final "." of both
+            # revisions) must not render twice - the struck suffix
+            # covers it, but any whitespace in the tail is the new
+            # side's paragraphing and survives as a plain match
+            dropped_tail = False
+            if after.strip() and not (
+                tail
+                and after.strip() in "".join(tail).strip()
+                and not re.search(r"\w", after)
+            ):
+                pieces.append(Insert(new=text_node(after, ins.new)))
+            else:
+                dropped_tail = True
+            if tail:
+                # the old suffix may end with punctuation the new
+                # side repeats after the phrase (both revisions end
+                # the sentence with "."): strike only the part that
+                # truly went away (the ")") and let the repeated
+                # punctuation render once, plain
+                t = "".join(tail)
+                a = after.strip()
+                common = 0
+                while (
+                    common < len(t)
+                    and common < len(a)
+                    and t[-1 - common] == a[-1 - common]
+                    and t[-1 - common] in _SHARED_RUN_PUNCT
+                ):
+                    common += 1
+                pure = t[: len(t) - common]
+                carry = t[len(t) - common :]
+                # suffix edge + shared punctuation, then the new
+                # side's paragraph break - the order matters: the
+                # break glued after a dropped tail sticks the next
+                # paragraph onto the struck bracket
+                if pure.strip():
+                    pieces.append(Delete(old=text_node(pure, edit.old)))
+                if carry:
+                    pieces.append(
+                        Match(node=text_node(carry, edit.old))
+                    )
+            if dropped_tail:
+                ws = ws_only(after)
+                if ws:
+                    pieces.append(Match(node=text_node(ws, ins.new)))
+            edits = (
+                edits[:i]
+                + [Delete(old=text_node(t, edit.old)) for t in head]
+                + edits[i + 1 : j]
+                + pieces
+                + edits[j + 1 :]
+            )
+            replaced = True
+            break
+        if not replaced:
+            break
+    return edits
+
+
 # sentence punctuation a stranded Delete of which reads as noise
 _LONE_PUNCTUATION = {".", ",", ";", ":", "!", "?", ")", "(", "]."}
 
@@ -1616,7 +1879,13 @@ def _render_recursed(edit: Modify, markup: LatexdiffMarkup) -> str:
             edit.new.text, markup.add_open, markup.add_close
         )
     prefix, suffix = wrapped
-    rendered = _render_row_region(edit.inner or [], markup)
+    # the inner script is a flat list of atomic edits just like the
+    # top-level one: relocation hoisting must run here too (a moved
+    # phrase and its twin can straddle a macro inside the recursed
+    # body, e.g. ...schema} + \sphinxhyphen{} + driven writer...)
+    rendered = _render_row_region(
+        _hoist_repeated_phrases(edit.inner or []), markup
+    )
     # the parse absorbs a longtable tail (``\endfoot\endlastfoot``)
     # into the first data row node's text; when the surrounding
     # prefix already carries the tail, drop the duplicate from the

{texdiff-0.2.5 → texdiff-0.2.6}/src/texdiff/textdiff.py

@@ -86,6 +86,7 @@ def word_diff(old: str, new: str) -> list[Chunk]:
     chunks = _merge_adjacent(chunks)
     chunks = _whitespace_to_new(chunks)
     chunks = _merge_replacements(chunks)
+    chunks = _coalesce_interleaved(chunks)
     return chunks
 
 
@@ -155,3 +156,71 @@ def _merge_replacements(chunks: list[Chunk]) -> list[Chunk]:
                     changed = True
                     break
     return _merge_adjacent(out)
+
+
+# a fragmented region must have at least this many change groups
+# (delete/insert runs) before it is coalesced into one replacement;
+# fewer means a plain word-level edit, not a reordering
+_COALESCE_MIN_GROUPS = 3
+
+# an equal chunk of at least this many words counts as a stable
+# "bridge": edits on either side of it are SEPARATE edits, each
+# keeping its own word-level markup. Shorter equals are filler the
+# sequence matcher paired across the real edit and get absorbed
+_BRIDGE_WORDS = 2
+
+
+def _word_count(text: str) -> int:
+    return len([w for w in text.split() if w])
+
+
+def _coalesce_interleaved(chunks: list[Chunk]) -> list[Chunk]:
+    """Collapse fragmented regions between stable bridges.
+
+    A reworded sentence often shares filler words with its new
+    version (``with``, ``configurable``, ``zlib``, ...), and the
+    sequence matcher happily pairs them while crossing the real
+    edit - the result is a del/ins mosaic where reviewer-relevant
+    clauses are shredded token by token.
+
+    Partition the chunk list at stable bridges (equal chunks of a
+    few words or more - the shared prefix, the shared tail, or
+    genuinely unchanged stretches inside the sentence). A region
+    BETWEEN bridges that consists of three or more change groups
+    is a crossed reordering, not separate small edits: render it
+    as ONE struck old region followed by ONE added new region -
+    the track-changes look of a whole-clause replacement.
+    """
+    if not chunks or len(chunks) < 5:
+        return chunks
+
+    # segment boundaries: indices after which a stable bridge ends
+    out: list[Chunk] = []
+    seg: list[Chunk] = []  # current region between bridges
+
+    def flush(seg: list[Chunk]) -> None:
+        if not seg:
+            return
+        groups = 0
+        prev_op = EQUAL
+        for c in seg:
+            if c.op != EQUAL and prev_op == EQUAL:
+                groups += 1
+            prev_op = c.op
+        if groups >= _COALESCE_MIN_GROUPS:
+            old_mid = "".join(c.text for c in seg if c.op in (EQUAL, DELETE))
+            new_mid = "".join(c.text for c in seg if c.op in (EQUAL, INSERT))
+            out.append(Chunk(DELETE, old_mid))
+            out.append(Chunk(INSERT, new_mid))
+        else:
+            out.extend(seg)
+
+    for c in chunks:
+        if c.op == EQUAL and _word_count(c.text) >= _BRIDGE_WORDS:
+            flush(seg)
+            seg = []
+            out.append(c)
+        else:
+            seg.append(c)
+    flush(seg)
+    return out

{texdiff-0.2.5 → texdiff-0.2.6/src/texdiff.egg-info}/PKG-INFO

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

{texdiff-0.2.5 → texdiff-0.2.6}/tests/test_align.py

@@ -90,6 +90,19 @@ class TestSameSignatureDifferentText:
         edits = align(old, new)
         assert [type(e).__name__ for e in edits] == ["Insert", "Match", "Match"]
 
+    def test_whitespace_only_pair_matches_new_bytes(self):
+        # two revisions differing only in blank-line count between
+        # paragraphs: a Modify here renders as del-block + add-block
+        # markers, and the marker glue pass then eats the blank line
+        # between them - the paragraph break vanishes and the next
+        # paragraph's first line glues to the previous one. The pair
+        # must Match the NEW bytes instead.
+        old = [text_node("para one."), text_node("\n\n\n"), text_node("para two.")]
+        new = [text_node("para one."), text_node("\n\n"), text_node("para two.")]
+        edits = align(old, new)
+        assert all(isinstance(e, Match) for e in edits)
+        assert edits[1].node.text == "\n\n"  # new bytes kept
+
 
 def test_sibling_swap_rescue_pairs_verbatim_equal_swap_as_match():
     """A swap that lands on a verbatim-equal sibling must Match.

{texdiff-0.2.5 → texdiff-0.2.6}/tests/test_api.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import re
+
 import pytest
 
 from texdiff import DiffResult, diff_documents, diff_files
@@ -245,3 +247,62 @@ class TestAppendedClause:
         # paragraph inline form, never word fragments)
         assert "\\DIFdel{Write output to NetCDF4" in out
         assert "\\DIFadd{Completely different" in out
+
+    def test_shared_edge_paragraph_stays_word_diffed(self):
+        # a paragraph split at a macro boundary leaves a tail whose
+        # common prefix with the other side is a whole clause while
+        # the rest is reworded: the ratio dips below the floor, but
+        # the shared edge proves it is an edit, not a rewrite
+        old = (
+            "\\documentclass{article}\n\\begin{document}\n"
+            "Common methods for reading HDF5 datasets (with masked-array "
+            "support and HDF5 diagnostic suppression) and writing NetCDF4 "
+            "outputs (with configurable zlib compression and shuffle "
+            "filtering).\n\\end{document}\n"
+        )
+        new = old.replace(
+            "suppression) and writing NetCDF4 outputs (with configurable "
+            "zlib compression and shuffle filtering).",
+            "suppression). Writing of NetCDF4 outputs is performed through "
+            "the generic schema-driven writer (see Overview), with "
+            "configurable zlib compression and shuffle filtering.",
+        )
+        out = diff_documents(old, new, inject_preamble=False).marked_up
+        # the shared prefix is untouched - no wholesale retire
+        assert "\\DIFdel{Common methods for reading" not in out
+        # and the change is marked inline at word level
+        assert "\\DIFdel{" in out and "\\DIFadd{" in out
+
+    def test_relocated_phrase_not_struck_twice(self):
+        # the parser splits the new sentence at \sphinxhyphen{}, so
+        # the deleted parenthetical and its identical twin inside
+        # the following inserted text never meet inside ONE word
+        # diff. Without relocation hoisting the phrase renders
+        # twice: struck red in place AND again in the added region.
+        # A long shared word run is a relocation, not a deletion:
+        # only the stray parens stay struck, the phrase carries
+        # once (in the added region).
+        old = (
+            "\\begin{document}\n"
+            "The reader retires one option (with configurable zlib "
+            "compression and shuffle filtering).\n"
+            "\\end{document}\n"
+        )
+        new = (
+            "\\begin{document}\n"
+            "The reader retires one option is performed through the "
+            "generic schema\\sphinxhyphen{}driven writer (see Overview), "
+            "with configurable zlib compression and shuffle filtering.\n"
+            "\\end{document}\n"
+        )
+        out = diff_documents(old, new, inject_preamble=False).marked_up
+        # the relocated phrase is never struck...
+        assert not re.search(r"\\DIFdel\{[^}]*configurable", out)
+        # ...but is present once, in the added region
+        assert out.count("with configurable zlib compression") == 1
+        # the truly deleted opening paren keeps its strike; the
+        # closing paren is struck after the relocated phrase while
+        # the sentence-final period (present in BOTH revisions)
+        # stays plain, and the paragraph break survives
+        assert "\\DIFdel{(" in out
+        assert re.search(r"filtering\\DIFdel\{\)\}\.", out)

texdiff-0.2.6/tests/test_textdiff.py

@@ -0,0 +1,123 @@
+"""Contract tests for texdiff.textdiff: word-level diffs of text runs."""
+
+from __future__ import annotations
+
+from texdiff.textdiff import Chunk, word_diff
+
+
+def apply(chunks: list[Chunk], old: bool) -> str:
+    return "".join(
+        c.text for c in chunks if c.op == "equal" or (c.op == ("delete" if old else "insert"))
+    )
+
+
+class TestBasics:
+    def test_identical_text_single_equal(self):
+        chunks = word_diff("same text", "same text")
+        assert chunks == [Chunk("equal", "same text")]
+
+    def test_reconstruction(self):
+        old, new = "the quick brown fox", "the quick red fox"
+        chunks = word_diff(old, new)
+        assert apply(chunks, True) == old
+        assert apply(chunks, False) == new
+
+    def test_changed_word_split_out(self):
+        chunks = word_diff("the quick brown fox", "the quick red fox")
+        ops = [c.op for c in chunks]
+        assert ops.count("delete") == 1
+        assert ops.count("insert") == 1
+        deleted = [c for c in chunks if c.op == "delete"]
+        inserted = [c for c in chunks if c.op == "insert"]
+        assert deleted[0].text == "brown"
+        assert inserted[0].text == "red"
+
+    def test_insertion_in_middle(self):
+        chunks = word_diff("a c", "a b c")
+        ops = [c.op for c in chunks]
+        assert ops == ["equal", "insert", "equal"]
+
+
+class TestLaTeXSafety:
+    def test_command_name_not_split_from_braces(self):
+        chunks = word_diff("\\textbf{x}", "\\emph{x}")
+        # no intermediate chunk may end between the backslash command
+        # name and its argument braces
+        for c in chunks:
+            assert not (c.text.endswith("\\textb") or c.text.endswith("\\emp"))
+
+    def test_whitespace_only_change_keeps_new(self):
+        chunks = word_diff("a  b", "a b")
+        assert apply(chunks, False) == "a b"
+        assert apply(chunks, True) in ("a  b", "a b")
+
+
+class TestSemanticCleanup:
+    def test_adjacent_edits_merge_into_replacement(self):
+        # a scattered single-char edit should become ONE delete+insert
+        # region, not many alternating islands
+        chunks = word_diff("xxaxx", "xxbxx")
+        ops = [c.op for c in chunks if c.op != "equal"]
+        assert ops == ["delete", "insert"]
+
+    def test_reworded_sentence_not_shredded_word_by_word(self):
+        # a reworded sentence shares filler words with its new version
+        # ("with", "configurable", "zlib", ...); the sequence matcher
+        # pairs them across the real edit, producing a del/ins mosaic.
+        # The region between stable bridges must collapse into whole
+        # delete + insert clauses - the track-changes look reviewers
+        # expect - while the shared prefix and suffix stay equal.
+        old = (
+            "Common methods for reading HDF5 datasets (with masked-array "
+            "support and HDF5 diagnostic suppression) and writing NetCDF4 "
+            "outputs (with configurable zlib compression and shuffle "
+            "filtering)."
+        )
+        new = (
+            "Common methods for reading HDF5 datasets (with masked-array "
+            "support and HDF5 diagnostic suppression). Writing of NetCDF4 "
+            "outputs is performed through the generic schema-driven writer "
+            "(see Overview), with configurable zlib compression and shuffle "
+            "filtering."
+        )
+        chunks = word_diff(old, new)
+        # contract: chunks still reconstruct both sides exactly
+        assert apply(chunks, True) == old
+        assert apply(chunks, False) == new
+        # the shared prefix survives as an equal region; the long shared
+        # tail ("configurable ... shuffle") too - it may be followed by
+        # one tiny token pair ("filtering)." vs "filtering.")
+        assert chunks[0].op == "equal" and "HDF5 diagnostic" in chunks[0].text
+        equal_tails = [c for c in chunks if c.op == "equal" and "shuffle" in c.text]
+        assert equal_tails
+        # the reworded middle is coalesced: few change regions, each a
+        # whole clause - not dozens of single-token del/ins islands
+        change_groups = 0
+        prev = "equal"
+        for c in chunks:
+            if c.op in ("delete", "insert") and prev == "equal":
+                change_groups += 1
+            prev = c.op
+        assert change_groups <= 4
+        # and the rewording appears as whole clauses: the crossed
+        # "suppression) and writing" pair is a multi-word delete
+        clausal = [t for t in (c.text for c in chunks if c.op == "delete")]
+        assert any("suppression" in t and "writing" in t for t in clausal), clausal
+
+    def test_separate_small_edits_keep_word_level(self):
+        # two genuinely distinct single-word edits separated by a long
+        # stable stretch: word-level markup, NOT coalesced into one
+        # big replacement
+        chunks = word_diff(
+            "alpha beta gamma delta epsilon zeta eta theta",
+            " ALPHA beta gamma delta epsilon ZETA eta theta",
+        )
+        # each case-only word change is its own small region; the long
+        # bridge between them forbids coalescing
+        groups = 0
+        prev = "equal"
+        for c in chunks:
+            if c.op in ("delete", "insert") and prev == "equal":
+                groups += 1
+            prev = c.op
+        assert groups == 2

texdiff-0.2.5/tests/test_textdiff.py

@@ -1,61 +0,0 @@
-"""Contract tests for texdiff.textdiff: word-level diffs of text runs."""
-
-from __future__ import annotations
-
-from texdiff.textdiff import Chunk, word_diff
-
-
-def apply(chunks: list[Chunk], old: bool) -> str:
-    return "".join(
-        c.text for c in chunks if c.op == "equal" or (c.op == ("delete" if old else "insert"))
-    )
-
-
-class TestBasics:
-    def test_identical_text_single_equal(self):
-        chunks = word_diff("same text", "same text")
-        assert chunks == [Chunk("equal", "same text")]
-
-    def test_reconstruction(self):
-        old, new = "the quick brown fox", "the quick red fox"
-        chunks = word_diff(old, new)
-        assert apply(chunks, True) == old
-        assert apply(chunks, False) == new
-
-    def test_changed_word_split_out(self):
-        chunks = word_diff("the quick brown fox", "the quick red fox")
-        ops = [c.op for c in chunks]
-        assert ops.count("delete") == 1
-        assert ops.count("insert") == 1
-        deleted = [c for c in chunks if c.op == "delete"]
-        inserted = [c for c in chunks if c.op == "insert"]
-        assert deleted[0].text == "brown"
-        assert inserted[0].text == "red"
-
-    def test_insertion_in_middle(self):
-        chunks = word_diff("a c", "a b c")
-        ops = [c.op for c in chunks]
-        assert ops == ["equal", "insert", "equal"]
-
-
-class TestLaTeXSafety:
-    def test_command_name_not_split_from_braces(self):
-        chunks = word_diff("\\textbf{x}", "\\emph{x}")
-        # no intermediate chunk may end between the backslash command
-        # name and its argument braces
-        for c in chunks:
-            assert not (c.text.endswith("\\textb") or c.text.endswith("\\emp"))
-
-    def test_whitespace_only_change_keeps_new(self):
-        chunks = word_diff("a  b", "a b")
-        assert apply(chunks, False) == "a b"
-        assert apply(chunks, True) in ("a  b", "a b")
-
-
-class TestSemanticCleanup:
-    def test_adjacent_edits_merge_into_replacement(self):
-        # a scattered single-char edit should become ONE delete+insert
-        # region, not many alternating islands
-        chunks = word_diff("xxaxx", "xxbxx")
-        ops = [c.op for c in chunks if c.op != "equal"]
-        assert ops == ["delete", "insert"]