pyDiffTools 0.1.53__tar.gz → 0.1.55__tar.gz

{pydifftools-0.1.53/pyDiffTools.egg-info → pydifftools-0.1.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDiffTools
-Version: 0.1.53
+Version: 0.1.55
 Summary: Diff tools
 Author: J M Franck
 License: Copyright (c) 2015, jmfranck
@@ -306,7 +306,9 @@ included are (listed in order of fun/utility):
     * ``cpb`` and ``wmatch`` share a matcher that finds changed hunks, aligns
       their words using Git's minimal diff, and restores reference whitespace.
       It then considers extra breaks that preserve an unchanged reference line
-      without stranding a tiny edited fragment, and checks wrapping rules.
+      without stranding an edited fragment of three words or fewer, and checks
+      wrapping rules. When matching a baseline, edited lines may exceed the
+      character width by at most four words before wrapping is required.
 
     * ``--wrapnumber`` sets the maximum width (79 for ``cpb`` and ``wmatch``).
       Wmatch also uses nearby reference widths for large edits, retaining

{pydifftools-0.1.53 → pydifftools-0.1.55}/README.rst

@@ -251,7 +251,9 @@ included are (listed in order of fun/utility):
     * ``cpb`` and ``wmatch`` share a matcher that finds changed hunks, aligns
       their words using Git's minimal diff, and restores reference whitespace.
       It then considers extra breaks that preserve an unchanged reference line
-      without stranding a tiny edited fragment, and checks wrapping rules.
+      without stranding an edited fragment of three words or fewer, and checks
+      wrapping rules. When matching a baseline, edited lines may exceed the
+      character width by at most four words before wrapping is required.
 
     * ``--wrapnumber`` sets the maximum width (79 for ``cpb`` and ``wmatch``).
       Wmatch also uses nearby reference widths for large edits, retaining

{pydifftools-0.1.53 → pydifftools-0.1.55/pyDiffTools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDiffTools
-Version: 0.1.53
+Version: 0.1.55
 Summary: Diff tools
 Author: J M Franck
 License: Copyright (c) 2015, jmfranck
@@ -306,7 +306,9 @@ included are (listed in order of fun/utility):
     * ``cpb`` and ``wmatch`` share a matcher that finds changed hunks, aligns
       their words using Git's minimal diff, and restores reference whitespace.
       It then considers extra breaks that preserve an unchanged reference line
-      without stranding a tiny edited fragment, and checks wrapping rules.
+      without stranding an edited fragment of three words or fewer, and checks
+      wrapping rules. When matching a baseline, edited lines may exceed the
+      character width by at most four words before wrapping is required.
 
     * ``--wrapnumber`` sets the maximum width (79 for ``cpb`` and ``wmatch``).
       Wmatch also uses nearby reference widths for large edits, retaining

{pydifftools-0.1.53 → pydifftools-0.1.55}/pydifftools/line_alignment.py

@@ -88,7 +88,7 @@ def align_line_breaks(
 ):
     """Return changed hunks with original, linted and proposed layouts.
 
-    Align words with minimal diff, reuse whitespace after matching words,
+    Align words with minimal diff, reuse equivalent source whitespace,
     then preserve complete reference lines and enforce line linting. CPB
     and wmatch apply the aligned layout automatically.
     Width can be a number or a function choosing a limit after restoration.
@@ -148,6 +148,9 @@ def align_line_breaks(
             margins[row] = allowed[row] and (
                 inside or (
                     margins[row] and "\t" not in indent and len(indent) < 4
+                    and not (
+                        row and not rows[row - 1].strip() and len(indent) >= 2
+                    )
                 )
             )
             position += len(line)
@@ -174,7 +177,7 @@ def align_line_breaks(
                if p["marker"] else "")
             for p in prefixes
         ]
-        math_word = re.compile(
+        span_word = re.compile(
             r"\$\$|\$|\\[A-Za-z]+|\\[^\s]|[A-Za-z]+|[0-9]+(?:\.[0-9]+)?|[^\s]"
         )
         tokens = []
@@ -186,7 +189,11 @@ def align_line_breaks(
                           end]
             for left, right in zip(boundaries, boundaries[1:]):
                 in_math = region_at(equations, base + left) is not None
-                pattern = math_word if in_math else WORD
+                hidden = region_at(comments, base + left) is not None
+                # Hidden source has no rendered word boundaries. Separate
+                # punctuation there too, so layout changes do not turn
+                # "$$R_c" into unmatched "$$" and "R_c" tokens.
+                pattern = span_word if in_math or hidden else WORD
                 tokens.extend(
                     (row, match.start(), match.end())
                     for match in pattern.finditer(text, left, right)
@@ -249,6 +256,7 @@ def align_line_breaks(
                 if allowed:
                     for line, message in check_prose(
                         span, width, punctuation_slop, offset,
+                        overflow_words=4,
                     ):
                         issues.setdefault(line, message)
                 offset += span.count("\n")
@@ -348,6 +356,39 @@ def align_line_breaks(
         whitespace = dict(gaps)
         ending = "\r\n" if "\r\n" in before else "\n"
 
+        def equivalent_gap(number, replacement):
+            # {{{ keep rendered separators and explicit Markdown hard breaks
+            raw = gaps[number]
+            left = start + tokens[number][1]
+            right = start + tokens[number + 1][1]
+            region = region_at(current_comments, left)
+            if region is not None and right < region[1]:
+                return True
+            region = region_at(current_equations, left)
+            if region is not None and right < region[1]:
+                # Display delimiters can sit on their own source lines.
+                # All other math gaps obey the same rule as prose; no
+                # knowledge of TeX commands or text macros is needed.
+                if current[region[0]:region[0] + 2] == "$$" and (
+                    tokens[number][1] + start == region[0]
+                    or tokens[number + 1][2] + start == region[1]
+                ):
+                    return True
+                return bool(raw) == bool(replacement)
+            # Collapsing a whitespace run retains one separator. It cannot
+            # create a separator from an empty gap or remove the last one.
+            # Line margins are handled separately, with structural margins
+            # excluded. Two spaces before a newline are a Markdown hard
+            # break, and a newline after a backslash is explicit as well.
+            if any(re.search(r" {2,}\r?\n", gap)
+                   for gap in (raw, replacement)) or (
+                before[tokens[number][2] - 1:tokens[number][2]] == "\\"
+                and ("\n" in raw or "\n" in replacement)
+            ):
+                return raw == replacement
+            return bool(raw) == bool(replacement)
+            # }}}
+
         # {{{ restore presentation indentation at matching line starts
         old_first = {}
         for number, (row, _, _) in enumerate(old_tokens):
@@ -430,19 +471,27 @@ def align_line_breaks(
                         old_number = candidate
                 if old_number in old_gaps:
                     raw = old_gaps[old_number]
+                    if not equivalent_gap(number, raw):
+                        continue
                     region = region_at(regions, start + tokens[number][1])
                     inside_region = (
                         region is not None
                         and start + tokens[number + 1][1] < region[1]
                     )
-                    if (
-                        number not in matches[hunk] and "\n" in raw
-                        and "\n" not in gaps[number] and not inside_region
-                        and len("".join(
-                            before[:tokens[number][2]].split("\n")[-1].split()
-                        )) < 10
+                    if "\n" in raw and "\n" not in gaps[number] and (
+                        not inside_region
                     ):
-                        continue
+                        original_rows = set(render(whitespace).splitlines())
+                        proposed = dict(whitespace)
+                        proposed[number] = raw
+                        inherited = {line.rstrip() for line in reference_lines}
+                        if any(
+                            line not in original_rows
+                            and line.rstrip() not in inherited
+                            and 0 < len(line.split()) <= 3
+                            for line in render(proposed).splitlines()
+                        ):
+                            continue
                     if inside_region or (
                         current_layout[3][j1 + tokens[number][0]]
                         and current_layout[3][j1 + tokens[number + 1][0]]
@@ -494,12 +543,17 @@ def align_line_breaks(
                     elif "\n" in proposed[number]:
                         proposed[number] = " "
                 proposed_rows = render(proposed).splitlines()
+                if any(
+                    not equivalent_gap(number, proposed[number])
+                    for number in needed
+                ):
+                    continue
                 if old_line not in {line.rstrip() for line in proposed_rows}:
                     continue
                 if any(
                     line not in original_rows
                     and line.rstrip() not in inherited
-                    and 0 < len("".join(line.split())) < 10
+                    and 0 < len(line.split()) <= 3
                     for line in proposed_rows
                 ):
                     continue

{pydifftools-0.1.53 → pydifftools-0.1.55}/pydifftools/match_spaces.py

@@ -1,6 +1,7 @@
 from difflib import SequenceMatcher
 from bisect import bisect_left
 import math
+import re
 from .line_alignment import align_line_breaks
 from .wrapping_options import (
     DEFAULT_WIDTH,
@@ -92,7 +93,6 @@ def match_text(
     trailing_dependent_phrase=DEFAULT_TRAILING_DEPENDENT_PHRASE,
 ):
     """Align reference lines and wrap only overflowing edited prose."""
-    text2 = text2.replace("\u00a0", " ").replace("\u2004", " ")
     # {{{ choose the nearby reference width before any line linting
     reference_lines = classify_lines(text1, filetype)
     prose_rows = [
@@ -118,7 +118,12 @@ def match_text(
         return (
             local
             if any(
-                len(line) > (local if joined else 1.5 * local)
+                len(line) > local and (
+                    joined or sum(
+                        match.end() > local
+                        for match in re.finditer(r"\S+", line)
+                    ) > 4
+                )
                 for line in restored.splitlines()
             )
             else fallback_width

{pydifftools-0.1.53 → pydifftools-0.1.55}/pydifftools/wrap_sentences.py

@@ -880,9 +880,14 @@ def wr(
             fp.write(result)
 
 
-def check_prose(content, wrapnumber, punctuation_slop, line_start=1):
+def check_prose(
+    content, wrapnumber, punctuation_slop, line_start=1, overflow_words=0,
+):
     """Report source lines in `content` that break wr's rules.
 
+    Diff alignment can set overflow_words to tolerate that many words ending
+    beyond the character width. Ordinary wrapping checks use a strict limit.
+
     Checks mirror wrap_prose's own paragraph/sentence/macro
     splitting so the two commands never disagree about what counts as a
     sentence: lines must not hold more words than wr's own greedy choice
@@ -953,7 +958,18 @@ def check_prose(content, wrapnumber, punctuation_slop, line_start=1):
                                 + len(words[actual_end])
                                 - positions[fragment_offset]
                             )
-                            if actual_end > wr_end:
+                            # Diff alignment can keep a few extra words to
+                            # avoid moving the sentence tail onto a new line.
+                            # Count against the character limit, independently
+                            # of an earlier preferred punctuation break.
+                            excess = sum(
+                                positions[j] + len(words[j])
+                                - positions[fragment_offset] > wrapnumber
+                                for j in range(fragment_offset, actual_end + 1)
+                            )
+                            if actual_end > wr_end and not (
+                                overflow_words and 0 < excess <= overflow_words
+                            ):
                                 overflow = words[wr_end + 1]
                                 rule = (
                                     "line too long"
@@ -1134,7 +1150,7 @@ def _mask_html_comments(content, initially_open=False):
 
 
 def markdown_lint_issues_from_text(
-    content, wrapnumber=45, punctuation_slop=20
+    content, wrapnumber=45, punctuation_slop=20, overflow_words=0,
 ):
     """Return Markdown writing issues, including unfinished source spans."""
     masked_content = _mask_html_comments(content)
@@ -1149,7 +1165,9 @@ def markdown_lint_issues_from_text(
         for line, width, span in _iter_block_spans(
             markdown_blocks(prose_content), wrapnumber
         )
-        for issue in check_prose(span, width, punctuation_slop, line)
+        for issue in check_prose(
+            span, width, punctuation_slop, line, overflow_words,
+        )
     ]
     issues.extend(
         (issue["line"], issue["message"])
@@ -1523,7 +1541,8 @@ def autofix_markdown_file(
     # issue at a time re-lints the whole file for every single fix.
     for _ in range(100):
         issues = markdown_lint_issues_from_text(
-            content, wrapnumber=wrapnumber, punctuation_slop=punctuation_slop
+            content, wrapnumber=wrapnumber, punctuation_slop=punctuation_slop,
+            overflow_words=4 if baseline is not None else 0,
         )
         fixable = {}
         for line_number, message in issues:

{pydifftools-0.1.53 → pydifftools-0.1.55}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyDiffTools"
-version = "0.1.53"
+version = "0.1.55"
 authors = [{ name = "J M Franck" }]
 description = "Diff tools"
 readme = "README.rst"

{pydifftools-0.1.53 → pydifftools-0.1.55}/tests/test_line_alignment.py

@@ -47,6 +47,129 @@ def test_partial_matching_lines_restore_whitespace_first(tmp_path):
     assert new.read_text() == expected
 
 
+@pytest.mark.parametrize("reference,current", [
+    (
+        r"the TEMPO-SO~4~ probe ($32.9;\text{kJ}/\text{mol}$"
+        "(@fig:DodecaTSO4TempCycle, blue),\nwhich\n",
+        r"the TEMPO-SO~4~ probe ($32.9;\text{kJ}/\text{mol}$"
+        " (@fig:DodecaTSO4TempCycle, blue),\nwhich\n",
+    ),
+    (
+        r"the TEMPO-SO~4~ probe inside small RMs dispersed in"
+        "\ndodecane ($32.9;\\text{kJ}/\\text{mol}$ : "
+        "@fig:DodecaTSO4TempCycle, blue),\nwhich\n",
+        r"the TEMPO-SO~4~ probe inside small RMs dispersed in"
+        "\ndodecane ($32.9;\\text{kJ}/\\text{mol}$: "
+        "@fig:DodecaTSO4TempCycle, blue),\nwhich\n",
+    ),
+    ("First $x$ (reference).\n", "First $x$(reference).\n"),
+    ("First $x$: reference.\n", "First $x$ : reference.\n"),
+    ("First words continue here.\n", "First words  \ncontinue here.\n"),
+    ("A long unchanged introductory line stays here.\n"
+     "First words\\\ncontinue here.\n",
+     "A long unchanged introductory line stays here.\n"
+     "First words\\ continue here.\n"),
+    ("Keep ordinary spaces.\n", "Keep\u00a0ordinary\u2004spaces.\n"),
+    (r"Use $\text{a,b}$ here." + "\n",
+     r"Use $\text{a, b}$ here." + "\n"),
+    (r"Use $\text{a, b}$ here." + "\n",
+     r"Use $\text{a,b}$ here." + "\n"),
+    (r"Use $\text{a,{b,c}}$ here." + "\n",
+     r"Use $\text{a, {b, c}}$ here." + "\n"),
+    (r"Use $\text{a \text{b} c,d}$ here." + "\n",
+     r"Use $\text{a \text{b} c, d}$ here." + "\n"),
+    (r"Use $\alpha{}b$ here." + "\n",
+     r"Use $\alpha b$ here." + "\n"),
+    (r"Use $\custom{a,b}$ here." + "\n",
+     r"Use $\custom{a, b}$ here." + "\n"),
+    ("Use $<!-- hidden words -->$ here.\n",
+     "Use $<!--hidden words-->$ here.\n"),
+])
+def test_rendered_spacing_survives_shared_alignment_and_wmatch(
+    tmp_path, reference, current,
+):
+    for result in align_line_breaks(reference, current, width=1000):
+        assert result["aligned"] == result["before"]
+    old, new = tmp_path / "old.md", tmp_path / "new.md"
+    old.write_text(reference)
+    new.write_text(current)
+    run([str(old), str(new)], wrapnumber=1000)
+    assert new.read_text() == current
+
+
+def test_removed_hard_break_is_not_restored_by_alignment(tmp_path):
+    reference = "First words  \ncontinue here.\n"
+    current = "First words continue here.\n"
+    (result,) = align_line_breaks(reference, current)
+    assert "  \n" not in result["aligned"]
+    old, new = tmp_path / "old.md", tmp_path / "new.md"
+    old.write_text(reference)
+    new.write_text(current)
+    run([str(old), str(new)])
+    assert "  \n" not in new.read_text()
+
+
+@pytest.mark.parametrize("context", ["{}", "Use ${}$ here."])
+@pytest.mark.parametrize("before,after", [
+    ("alpha,beta", "alpha, beta"),
+    ("alpha, beta", "alpha,beta"),
+    ("alpha(beta)", "alpha (beta)"),
+    ("alpha (beta)", "alpha(beta)"),
+    ("alpha:beta", "alpha :beta"),
+    ("alpha :beta", "alpha:beta"),
+])
+def test_alignment_preserves_last_space_everywhere(
+    tmp_path, context, before, after,
+):
+    reference = context.format(before) + "\n"
+    current = context.format(after) + "\n"
+    for result in align_line_breaks(reference, current):
+        assert result["aligned"] == result["before"]
+    old, new = tmp_path / "old.md", tmp_path / "new.md"
+    old.write_text(reference)
+    new.write_text(current)
+    run([str(old), str(new)])
+    assert new.read_text() == current
+
+
+def test_extra_spaces_and_presentation_margins_can_be_cleaned(tmp_path):
+    reference = "Keep one separator here.\n"
+    current = " Keep   one \t separator here.\n"
+    (result,) = align_line_breaks(reference, current, width=79)
+    assert result["aligned"] == reference
+    old, new = tmp_path / "old.md", tmp_path / "new.md"
+    old.write_text(reference)
+    new.write_text(current)
+    run([str(old), str(new)])
+    assert new.read_text() == reference
+    new.write_text(reference.rstrip("\n") + " \n")
+    autofix_markdown_file(new, wrapnumber=79)
+    assert new.read_text() == reference
+
+
+def test_cpb_preserves_rendered_spacing_while_restoring_source_breaks(
+    tmp_path,
+):
+    import subprocess
+
+    reference = (
+        "A probe inside small RMs\ndispersed in dodecane "
+        "($32.9;\\text{kJ}/\\text{mol}$ : @fig:cycle, blue),\nwhich\n"
+    )
+    current = reference.replace("RMs\ndispersed", "RMs dispersed").replace(
+        "$ :", "$:"
+    )
+    path = tmp_path / "source.md"
+    subprocess.run(["git", "init", str(tmp_path)], check=True,
+                   capture_output=True)
+    path.write_text(reference)
+    subprocess.run(["git", "-C", str(tmp_path), "add", "source.md"],
+                   check=True, capture_output=True)
+    path.write_text(current)
+    autofix_markdown_file(path, wrapnumber=1000, git_index=True)
+    assert path.read_text() == reference.replace("$ :", "$:")
+
+
 @pytest.mark.parametrize("old_prefix,new_prefix", [
     ("", " "), ("  ", ""), (" ", "   "),
 ])
@@ -80,6 +203,10 @@ def test_leading_indentation_edits_do_not_overlap_whitespace_restoration():
     ("> Quote.\n", " > Quote.\n"),
     ("> First.\n continuation.\n", "> First.\n  continuation.\n"),
     ("```\n Code.\n```\n", "```\n  Code.\n```\n"),
+    ("Introduction.\n\n  Indented paragraph.\n",
+     "Introduction.\n\n Indented paragraph.\n"),
+    ("Introduction.\n\n Indented paragraph.\n",
+     "Introduction.\n\n  Indented paragraph.\n"),
 ])
 def test_structural_indentation_is_preserved(reference, current):
     assert all(
@@ -177,6 +304,63 @@ def test_comment_alignment_preserves_reference_whitespace():
     assert restored == reference
 
 
+@pytest.mark.parametrize("ending", ["\n", "\r\n"])
+@pytest.mark.parametrize("body", [
+    r"$$R_c \approx (100\,\text{nm·K})/\Delta T$$",
+    r"$$R_c \approx 100/28 \approx 3.6\,\text{nm}$$",
+    "Attached(punctuation),without spaces.",
+])
+def test_hidden_source_layout_matches_across_attached_punctuation(
+    tmp_path, body, ending,
+):
+    import subprocess
+
+    reference = (
+        "Visible prose.\n<!--\nRS: Calculation:\n" + body + "\n-->\n"
+        "Visible $x$ (reference): preserve this space.\n"
+    ).replace("\n", ending)
+    changed_body = body.replace("$$", "$$\n", 1)
+    if body.endswith("$$"):
+        changed_body = changed_body[:-2] + "\n$$"
+    else:
+        changed_body = body.replace("(", " ( ").replace(
+            "),", " ) ,\n"
+        )
+    current = reference.replace(body, changed_body.replace("\n", ending))
+    restored = current
+    for result in reversed(align_line_breaks(reference, current, width=79)):
+        restored = (
+            restored[:result["start"]] + result["aligned"]
+            + restored[result["stop"]:]
+        )
+    assert restored == reference
+    old, new = tmp_path / "old.md", tmp_path / "new.md"
+    old.write_bytes(reference.encode())
+    new.write_bytes(current.encode())
+    run([str(old), str(new)])
+    # wmatch reads text with universal newline handling.
+    assert new.read_text() == reference.replace(ending, "\n")
+    subprocess.run(["git", "init", str(tmp_path)], check=True,
+                   capture_output=True)
+    new.write_bytes(reference.encode())
+    subprocess.run(["git", "-C", str(tmp_path), "add", "new.md"],
+                   check=True, capture_output=True)
+    subprocess.run(["git", "-C", str(tmp_path), "config", "user.name",
+                    "Test"], check=True)
+    subprocess.run(["git", "-C", str(tmp_path), "config", "user.email",
+                    "test@example.com"], check=True)
+    subprocess.run(["git", "-C", str(tmp_path), "commit", "-m", "Base"],
+                   check=True, capture_output=True)
+    subprocess.run(["git", "-C", str(tmp_path), "tag", "jf_last"],
+                   check=True)
+    new.write_bytes(current.encode())
+    autofix_markdown_file(new, wrapnumber=79, git_ref="jf_last")
+    assert new.read_bytes() == reference.encode()
+    assert not autofix_markdown_file(
+        new, wrapnumber=79, git_ref="jf_last",
+    )["fixes"]
+
+
 def test_literal_comment_delimiters_remain_opaque():
     delimiter = "`"
     reference = f"Use {delimiter}<!-- hidden words -->{delimiter} here.\n"
@@ -203,8 +387,6 @@ def test_literal_comment_delimiters_remain_opaque():
      "$$\n" + r"r(w_0) = \begin{cases}" + "\n"
      + r"m w_0 + \delta & w_0 < 20 \\[8pt]" + "\n"
      + r"c & w_0 \geq 20\end{cases}" + "\n$$\n"),
-    ("Use $<!-- hidden words -->$ here.\n",
-     "Use $<!--hidden words-->$ here.\n"),
 ])
 def test_math_layout_restores_baseline_without_prose_lint(reference, current):
     for result in reversed(align_line_breaks(reference, current, width=79)):
@@ -307,13 +489,17 @@ def test_batched_word_diff_keeps_hunks_isolated(monkeypatch):
         "Other introduction\nsame reference words\nother closing.\n"
     )
     current = (
-        "Changed introduction same reference words changed closing.\n"
+        "Changed words in introduction same reference words "
+        "changed words in closing.\n"
         "\nUnchanged anchor.\n\n"
-        "Updated introduction same reference words updated closing.\n"
+        "Updated words in introduction same reference words "
+        "updated words in closing.\n"
     )
     expected = [
-        "Changed introduction\nsame reference words\nchanged closing.\n",
-        "Updated introduction\nsame reference words\nupdated closing.\n",
+        "Changed words in introduction\nsame reference words\n"
+        "changed words in closing.\n",
+        "Updated words in introduction\nsame reference words\n"
+        "updated words in closing.\n",
     ]
     calls = []
     original_run = line_alignment.subprocess.run
@@ -334,10 +520,26 @@ def test_optional_preservation_break_does_not_strand_a_tiny_fragment():
     )
     current = "X stable reference words rewritten closing.\n"
     (result,) = align_line_breaks(reference, current)
-    # Reference whitespace is restored after "words", but separating "X"
-    # just to preserve the next reference line would make a tiny new row.
-    assert result["aligned"] == (
-        "X stable reference words\nrewritten closing.\n"
+    # Restoring either boundary would strand a short changed fragment.
+    assert result["aligned"] == current
+
+
+@pytest.mark.parametrize("count", [1, 2, 3, 4])
+@pytest.mark.parametrize("side", ["before", "after"])
+def test_optional_break_uses_word_count_for_long_fragments(count, side):
+    reference = "Former opening\nstable reference words\nformer closing.\n"
+    fragment = " ".join(["substantial"] * count)
+    current = (
+        fragment + " stable reference words with a rewritten closing.\n"
+        if side == "before" else
+        "Here is a rewritten opening stable reference words " + fragment
+        + ".\n"
+    )
+    (result,) = align_line_breaks(reference, current)
+    # Four words justify an optional break to preserve a complete old line.
+    # One to three long words must stay with the adjacent reference words.
+    assert ("\nstable reference words\n" in result["aligned"]) == (
+        count > 3
     )
 
 

{pydifftools-0.1.53 → pydifftools-0.1.55}/tests/test_wrap_check.py

@@ -754,6 +754,42 @@ def test_stray_line_break_in_an_unchanged_line_is_rejoined(tmp_path):
     assert "put those breaks back" in report["fixes"][0]["reason"]
 
 
+@pytest.mark.parametrize("count", [3, 4, 5])
+@pytest.mark.parametrize("word", ["a", "substantial"])
+@pytest.mark.parametrize("command", ["cpb", "wmatch"])
+def test_diff_wrap_allows_only_four_words_beyond_width(
+    tmp_path, count, word, command,
+):
+    from pydifftools.match_spaces import run
+
+    first = "Stable reference words fill the first line"
+    width = len(first)
+    reference = first + "\nand the reference sentence finishes here.\n"
+    path = committed_source(tmp_path, reference)
+    current = reference.replace(
+        first, first.replace("Stable", "Edited") + " " + " ".join(
+            [word] * count
+        ),
+    )
+    path.write_text(current)
+    old = tmp_path / "reference.md"
+    old.write_text(reference)
+    for _ in range(2):
+        if command == "cpb":
+            autofix_markdown_file(
+                path, wrapnumber=width, punctuation_slop=0, git_head=True,
+            )
+        else:
+            run([str(old), str(path)], width, 0)
+        result = path.read_text()
+        assert result.split() == current.split()
+        if count <= 4:
+            assert result == current
+        else:
+            assert result != current
+            assert result.splitlines()[0] == first.replace("Stable", "Edited")
+
+
 def test_one_moved_line_break_is_moved_back(tmp_path):
     path = committed_source(tmp_path, HEAD_PARAGRAPH)
     path.write_text(
@@ -843,7 +879,7 @@ def test_rm_esr_restores_full_head_lines_in_rewritten_sentence(
 
     expected = edited.replace(
         "the ESR measurements presented",
-        "the\nESR measurements\npresented",
+        "the ESR measurements\npresented",
     ).replace("tube (1.50", "tube\n(1.50")
     assert path.read_text() == expected
     assert report["fixes"] and report["layout"] == []
@@ -855,25 +891,21 @@ def test_rm_esr_restores_full_head_lines_in_rewritten_sentence(
     matched.write_text(edited)
     run([str(reference), str(matched)])
     assert matched.read_text() == expected
-    # Automatic alignment preserves both unchanged HEAD lines.
-    assert numstat(path) == (8, 8)
+    # Avoid a new two-word row just to preserve the ESR reference line.
+    assert numstat(path) == (8, 9)
 
 
-def test_embedded_head_line_restores_both_boundaries_together(tmp_path):
+def test_embedded_head_line_does_not_strand_short_changed_lines(tmp_path):
     path = committed_source(tmp_path, "Before\nESR measurements\nAfter.\n")
     edited = "Changed before ESR measurements changed after.\n"
     path.write_text(edited)
 
     report = autofix_markdown_file(path, wrapnumber=79, git_head=True)
 
-    expected = (
-        "Changed before\nESR measurements\nchanged after."
-    )
+    expected = edited.rstrip()
     assert path.read_text() == expected + "\n"
     assert report["layout"] == []
-    (fix,) = report["fixes"]
-    assert fix["before"] == edited.rstrip()
-    assert fix["after"] == expected
+    assert report["fixes"] == []
 
 
 @pytest.mark.parametrize("count", [1, 5, 30])
@@ -886,13 +918,13 @@ def test_cpb_and_wmatch_restore_scattered_reference_lines(tmp_path, count):
         for number in range(count)
     ) + "\n"
     current = "\n\n".join(
-        f"Changed intro {number} Stable component {number} "
-        f"changed outro {number}."
+        f"Changed opening intro {number} Stable component {number} "
+        f"changed closing outro {number}."
         for number in range(count)
     ) + "\n"
     expected = "\n\n".join(
-        f"Changed intro {number}\nStable component {number}\n"
-        f"changed outro {number}."
+        f"Changed opening intro {number}\nStable component {number}\n"
+        f"changed closing outro {number}."
         for number in range(count)
     ) + "\n"
     path = committed_source(tmp_path, head)
@@ -1288,14 +1320,16 @@ def test_qt_diff_fixes_fill_pages_with_double_line_breaks(tmp_path):
         for j in range(count)
     ) + "\n"
     current = "\n\n".join(
-        f"Changed intro {j} Stable component {j} changed outro {j}."
+        f"Changed opening intro {j} Stable component {j} "
+        f"changed closing outro {j}."
         for j in range(count)
     ) + "\n"
     path = committed_source(tmp_path, head)
     path.write_text(current)
     report = autofix_markdown_file(path, wrapnumber=79, git_index=True)
     expected = "\n\n".join(
-        f"Changed intro {j}\nStable component {j}\nchanged outro {j}."
+        f"Changed opening intro {j}\nStable component {j}\n"
+        f"changed closing outro {j}."
         for j in range(count)
     ) + "\n"
     # Every hunk must already be applied before the notice opens.

{pydifftools-0.1.53 → pydifftools-0.1.55}/tests/test_wrapping.py

@@ -247,7 +247,9 @@ def test_wmatch_reuses_wr_rules_and_preserves_other_lines(tmp_path, operation):
     )
     new.write_text(changed + "\n" + rest)
     run([str(old), str(new)])
-    expected = wrap_prose(changed + "\n", 40) + rest
+    expected = wrap_prose(changed + "\n", 40).replace(
+        "has enough\nwords\n", "has enough words\n",
+    ) + rest
     assert new.read_text() == expected
     run([str(old), str(new)])
     assert new.read_text() == expected
@@ -304,7 +306,11 @@ def test_wmatch_fallback_width_and_long_word(tmp_path):
     text = "Start " + "extra words " * 20 + long_word + " end.\n"
     new.write_text(text)
     run([str(old), str(new)])
-    assert new.read_text() == wrap_prose(text, 80)
+    expected = wrap_prose(text, 79).replace(
+        "extra words\nextra words\n" + long_word + "\nend.\n",
+        "extra words extra words " + long_word + " end.\n",
+    )
+    assert new.read_text() == expected
     assert long_word in new.read_text()