pyDiffTools 0.1.54__tar.gz → 0.1.55__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDiffTools
-Version: 0.1.54
+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.54 → 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.54 → pydifftools-0.1.55/pyDiffTools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDiffTools
-Version: 0.1.54
+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.54 → pydifftools-0.1.55}/pydifftools/line_alignment.py

@@ -256,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")
@@ -477,14 +478,20 @@ def align_line_breaks(
                         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]]
@@ -546,7 +553,7 @@ def align_line_breaks(
                 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.54 → 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,
@@ -117,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.54 → 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.54 → pydifftools-0.1.55}/pyproject.toml

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

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

@@ -489,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
@@ -516,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.54 → 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.54 → 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()