pyDiffTools 0.1.53__tar.gz → 0.1.54__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDiffTools
-Version: 0.1.53
+Version: 0.1.54
 Summary: Diff tools
 Author: J M Franck
 License: Copyright (c) 2015, jmfranck

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDiffTools
-Version: 0.1.53
+Version: 0.1.54
 Summary: Diff tools
 Author: J M Franck
 License: Copyright (c) 2015, jmfranck

{pydifftools-0.1.53 → pydifftools-0.1.54}/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)
@@ -348,6 +355,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,6 +470,8 @@ 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
@@ -494,6 +536,11 @@ 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(

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

@@ -92,7 +92,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 = [

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

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

{pydifftools-0.1.53 → pydifftools-0.1.54}/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)):