pyDiffTools 0.1.41__tar.gz → 0.1.43__tar.gz

{pydifftools-0.1.41/pyDiffTools.egg-info → pydifftools-0.1.43}/PKG-INFO

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

{pydifftools-0.1.41 → pydifftools-0.1.43/pyDiffTools.egg-info}/PKG-INFO

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

{pydifftools-0.1.41 → pydifftools-0.1.43}/pydifftools/continuous.py

@@ -132,7 +132,7 @@ def show_markdown_fix_dialog(report):
     from html import escape
 
     from PySide6.QtCore import Qt
-    from PySide6.QtGui import QFontDatabase
+    from PySide6.QtGui import QFontDatabase, QFontMetrics
     from PySide6.QtWidgets import (
         QApplication,
         QDialog,
@@ -145,14 +145,7 @@ def show_markdown_fix_dialog(report):
 
     fixes = report["fixes"]
     warnings = report["warnings"]
-    records = [
-        {"record_type": "fix", **fix}
-        for fix in fixes
-    ] + [
-        {"record_type": "warning", **warning}
-        for warning in warnings
-    ]
-    if not records:
+    if not fixes and not warnings:
         return
 
     dialog = QDialog()
@@ -160,7 +153,53 @@ def show_markdown_fix_dialog(report):
         QApplication.instance() or QApplication([])
     )
     dialog.setWindowTitle("Markdown source fixes")
-    dialog.resize(760, 480)
+    fixed_font = QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont)
+    # {{{ group fixes of one kind onto pages that fill the screen
+    screen_height = dialog.screen().availableGeometry().height()
+    dialog.resize(900, int(screen_height * 0.85))
+    # leave room for the heading, explanation, button and margins
+    page_rows = max(
+        3,
+        int(
+            (screen_height * 0.85 - 120)
+            / QFontMetrics(fixed_font).lineSpacing()
+        ),
+    )
+    groups = {}
+    for fix in fixes:
+        groups.setdefault(fix["reason"], []).append(fix)
+    records = []
+    for reason, group in groups.items():
+        page = []
+        rows = 0
+        for fix in sorted(group, key=lambda fix: fix["line"]):
+            # a blank line separates each fix from the one before it, and a
+            # fix that only drops trailing spaces shows just its old line
+            fix_rows = (
+                len(fix["before"].splitlines() or [""])
+                + (
+                    0
+                    if fix["after"] == fix["before"].rstrip()
+                    else len(fix["after"].splitlines() or [""])
+                )
+                + (1 if page else 0)
+            )
+            if page and rows + fix_rows > page_rows:
+                records.append(
+                    {"record_type": "fix", "reason": reason, "fixes": page}
+                )
+                page = []
+                rows = 0
+                fix_rows -= 1
+            page.append(fix)
+            rows += fix_rows
+        records.append(
+            {"record_type": "fix", "reason": reason, "fixes": page}
+        )
+    records += [
+        {"record_type": "warning", **warning} for warning in warnings
+    ]
+    # }}}
     layout = QVBoxLayout(dialog)
     heading = QLabel()
     heading.setWordWrap(True)
@@ -175,14 +214,10 @@ def show_markdown_fix_dialog(report):
         Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignRight
     )
     line_numbers.setStyleSheet("color: #666; padding-right: 8px;")
-    line_numbers.setFont(
-        QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont)
-    )
+    line_numbers.setFont(fixed_font)
     preview = QTextEdit()
     preview.setReadOnly(True)
-    preview.setFont(
-        QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont)
-    )
+    preview.setFont(fixed_font)
     preview_row.addWidget(line_numbers)
     preview_row.addWidget(preview, 1)
     layout.addLayout(preview_row, 1)
@@ -194,37 +229,60 @@ def show_markdown_fix_dialog(report):
 
     def show_record():
         record = records[index]
-        line = record["line"]
+        page = (
+            f" (page {index + 1} of {len(records)})"
+            if len(records) > 1
+            else ""
+        )
         if record["record_type"] == "fix":
-            heading.setText("I fixed this source line automatically.")
+            count = len(record["fixes"])
+            heading.setText(
+                "I fixed this source line automatically." + page
+                if count == 1
+                else f"I fixed these {count} source lines automatically."
+                + page
+            )
             details.setText(record["reason"])
-            before_lines = record["before"].splitlines() or [""]
-            after_lines = record["after"].splitlines() or [""]
-            source_html = ""
-            numbers = []
-            if "\n" in record["after"]:
-                after_html = "<br>↳ ".join(
-                    escape(value)
-                    for value in record["after"].split("\n")
-                )
-                source_html = (
-                    "<pre style='font-family:monospace; margin:0'>"
-                    + "Before:<br>"
-                    + "<br>".join(escape(value) for value in before_lines)
-                    + "<br><br>After:<br>"
-                    + after_html
-                    + "</pre>"
-                )
-                numbers = [""] + list(
-                    range(line, line + len(before_lines))
-                )
-                numbers += ["", ""]
-                numbers += list(range(line, line + len(after_lines)))
-            line_numbers.setText("<br>".join(str(value) for value in numbers))
-            preview.setHtml(source_html)
+            line_numbers.setVisible(False)
+            # {{{ show each fix as numbered before (−) and after (+) lines
+            entries = []
+            for fix in record["fixes"]:
+                rows = []
+                for offset, value in enumerate(
+                    fix["before"].splitlines() or [""]
+                ):
+                    stripped = value.rstrip(" ")
+                    rows.append(
+                        f"<span style='color:#666'>{fix['line'] + offset:>6}"
+                        "</span> − "
+                        + escape(stripped)
+                        # make stray trailing spaces visible
+                        + "<span style='background:#fbb'>·</span>"
+                        * (len(value) - len(stripped))
+                    )
+                for offset, value in enumerate(
+                    []
+                    if fix["after"] == fix["before"].rstrip()
+                    else fix["after"].split("\n")
+                ):
+                    rows.append(
+                        f"<span style='color:#666'>{fix['line'] + offset:>6}"
+                        "</span> "
+                        + ("+ " if offset == 0 else "↳ ")
+                        + escape(value)
+                    )
+                entries.append("<br>".join(rows))
+            preview.setHtml(
+                "<pre style='font-family:monospace; margin:0'>"
+                + "<br><br>".join(entries)
+                + "</pre>"
+            )
+            # }}}
             button.setText("Next" if index + 1 < len(records) else "Done")
         else:
-            heading.setText("This source span is not closed.")
+            line = record["line"]
+            heading.setText("This source span is not closed." + page)
+            line_numbers.setVisible(True)
             if record["kind"] == "math":
                 delimiter = record["delimiter"]
                 details.setText(
@@ -303,6 +361,7 @@ def run_pandoc(
     comments_to_margin=False,
     no_comments=False,
     comment_filter_session=None,
+    wrapnumber=79,
 ):
     # {{{ automatically fix Markdown source and request edits for
     # unfinished spans
@@ -310,7 +369,7 @@ def run_pandoc(
 
     automatic_fixes_were_made = False
     while True:
-        report = autofix_markdown_file(filename, max_line_length=79)
+        report = autofix_markdown_file(filename, wrapnumber=wrapnumber)
         automatic_fixes_were_made |= bool(report["fixes"])
         if report["fixes"] or report["warnings"]:
             user_says_fixed = show_markdown_fix_dialog(report)
@@ -789,10 +848,14 @@ class Handler(FileSystemEventHandler):
         "no_comments": (
             "Render the HTML without comment tags or comment div blocks."
         ),
+        "wrapnumber": (
+            "Maximum source line width; the automatic Markdown fixes break "
+            "only lines longer than this."
+        ),
     },
     filename_extensions={"filename": ".md"},
 )
-def cpb(filename, comments_to_margin=False, no_comments=False):
+def cpb(filename, comments_to_margin=False, no_comments=False, wrapnumber=79):
     source_path = os.path.normpath(os.path.abspath(filename))
     source_dir = os.path.dirname(source_path)
     html_file = filename.rsplit(".", 1)[0] + ".html"
@@ -836,6 +899,7 @@ def cpb(filename, comments_to_margin=False, no_comments=False):
             comments_to_margin=comments_to_margin,
             no_comments=no_comments,
             comment_filter_session=comment_filter_session,
+            wrapnumber=wrapnumber,
         )
         append_autorefresh(html_file)
         notice = zotero_notice()
@@ -971,6 +1035,7 @@ def cpb(filename, comments_to_margin=False, no_comments=False):
                                 comments_to_margin=comments_to_margin,
                                 no_comments=no_comments,
                                 comment_filter_session=comment_filter_session,
+                                wrapnumber=wrapnumber,
                             )
                             append_autorefresh(html_file)
                         except Exception as exc:

{pydifftools-0.1.41 → pydifftools-0.1.43}/pydifftools/wrap_sentences.py

@@ -658,18 +658,29 @@ def _next_break(words, wrapnumber, punctuation_slop, boundaries, offset):
     Shared by wrap_prose (which then emits that line) and check_prose
     (which replays the same choice to see if a source line agrees).
     """
+    # counts[j] - 1 is the length of the line holding words[: j + 1]
     counts = list(itertools.accumulate(len(word) + 1 for word in words))
-    upto = min(range(len(counts)), key=lambda j: abs(counts[j] - wrapnumber))
+    if counts[-1] - 1 <= wrapnumber:
+        # the rest fits, so there is nothing to break
+        return len(words) - 1
+    # the last word that fits within the width (or the first word, if even
+    # that is too long)
+    upto = max(
+        [j for j, count in enumerate(counts) if count - 1 <= wrapnumber]
+        or [0]
+    )
+    # prefer to end the line on a clause (comma, paren, dash, ...) or at an
+    # inline-math boundary within punctuation_slop characters of that break
     candidates = [
         j
-        for j, word in enumerate(words)
-        if (len(word) > 1 and word[-1] in ",;:)-") or offset + j in boundaries
+        for j, word in enumerate(words[: upto + 1])
+        if (
+            (len(word) > 1 and word[-1] in ",;:)-")
+            or offset + j in boundaries
+        )
+        and counts[upto] - counts[j] < punctuation_slop
     ]
-    if candidates:
-        punct = min(candidates, key=lambda j: abs(counts[j] - wrapnumber))
-        if punct < upto and upto - punct < punctuation_slop:
-            upto = punct
-    return upto
+    return max(candidates) if candidates else upto
 
 
 def wrap_prose(
@@ -805,6 +816,11 @@ def _prepare(filename, cleanoo=False, i=-1):
         "filename": "Input file to wrap. Use '-' to read from stdin.",
         "cleanoo": "Strip LibreOffice markup before wrapping.",
         "i": "Indentation level for wrapped lines.",
+        "wrapnumber": "Maximum line width in characters.",
+        "punctuation_slop": (
+            "End a line early on a clause (comma, paren, dash, ...) when "
+            "that is within this many characters of the widest break."
+        ),
     },
     filename_extensions={"filename": [".md", ".tex"]},
 )
@@ -920,7 +936,16 @@ def check_prose(content, wrapnumber, punctuation_slop, line_start=1):
                                 and not breaks_after[actual_end]
                             ):
                                 actual_end += 1
-                            if actual_end > wr_end:
+                            line_length = (
+                                positions[actual_end]
+                                + len(words[actual_end])
+                                - positions[fragment_offset]
+                            )
+                            # only a line that exceeds the width is too long
+                            if (
+                                actual_end > wr_end
+                                and line_length > wrapnumber
+                            ):
                                 overflow = words[wr_end + 1]
                                 issue_line = para_line + stripped.count(
                                     "\n", 0, positions[actual_end]
@@ -1004,13 +1029,9 @@ def _iter_block_spans(blocks, wrapnumber, line_start=1):
 
 
 def markdown_lint_issues_from_text(
-    content, wrapnumber=45, punctuation_slop=20, max_line_length=None
+    content, wrapnumber=45, punctuation_slop=20
 ):
-    """Return Markdown writing issues, including unfinished source spans.
-
-    With `max_line_length`, a prose line is only too long when it holds
-    more than that many characters, instead of wr's greedy line choice.
-    """
+    """Return Markdown writing issues, including unfinished source spans."""
     def mask_comment(match):
         return "".join("\n" if char == "\n" else " " for char in match[0])
 
@@ -1020,30 +1041,13 @@ def markdown_lint_issues_from_text(
     # trailing spaces are reported separately below, and a double space
     # (a hard line break) must not look like a sentence ending mid-line
     prose_content = re.sub(r"[ \t]+$", "", prose_content, flags=re.M)
-    issues = []
-    prose_lines = prose_content.splitlines()
-    for line, width, span in _iter_block_spans(
-        markdown_blocks(prose_content), wrapnumber
-    ):
-        for issue in check_prose(span, width, punctuation_slop, line):
-            if max_line_length is None or not issue[1].startswith(
-                "line too long:"
-            ):
-                issues.append(issue)
-        if max_line_length is not None:
-            # {{{ flag prose lines longer than the character limit
-            for number in range(line, line + len(span.splitlines())):
-                text = prose_lines[number - 1]
-                # a single unbreakable word cannot be shortened
-                if len(text) > max_line_length and len(
-                    WORD.findall(text)
-                ) > 1:
-                    issues.append((
-                        number,
-                        f"line over {max_line_length} characters: break "
-                        "it at a word boundary",
-                    ))
-            # }}}
+    issues = [
+        issue
+        for line, width, span in _iter_block_spans(
+            markdown_blocks(prose_content), wrapnumber
+        )
+        for issue in check_prose(span, width, punctuation_slop, line)
+    ]
     issues.extend(
         (issue["line"], issue["message"])
         for issue in unclosed_markdown_spans(content)
@@ -1186,10 +1190,15 @@ def apply_markdown_issue_fix(content, line_number, message):
         else:
             span = found.span("gap")
             joined = ""
-        before = content[found.start() : found.end()]
         updated = content[: span[0]] + joined + content[span[1] :]
+        # report the whole source lines around the join
+        line_start = content.rfind("\n", 0, found.start()) + 1
+        line_end = content.find("\n", max(found.end(), span[1]))
+        if line_end == -1:
+            line_end = len(content)
+        before = content[line_start:line_end]
         after = updated[
-            found.start() : span[0] + len(joined) + found.end() - span[1]
+            line_start : line_end - (span[1] - span[0]) + len(joined)
         ]
         return (
             updated,
@@ -1229,25 +1238,7 @@ def apply_markdown_issue_fix(content, line_number, message):
             old_line[:-1],
             "A line ended with a single stray space. I removed it.",
         )
-    if message.startswith("line over "):
-        # {{{ break at the last word boundary that fits the limit
-        limit = int(re.match(r"line over (\d+)", message)[1])
-        gaps = [
-            found.end()
-            for found in WORD.finditer(old_line)
-            if container.end() < found.end() < len(old_line.rstrip())
-        ]
-        fitting = [gap for gap in gaps if gap <= limit]
-        # when even the first word is too long, break right after it
-        split_at = fitting[-1] if fitting else gaps[0]
-        first = old_line[:split_at].rstrip()
-        second = old_line[split_at:].lstrip(" \t")
-        reason = (
-            f"This line was longer than {limit} characters. "
-            "I moved the last words onto a new line."
-        )
-        # }}}
-    elif message.startswith("line too long:"):
+    if message.startswith("line too long:"):
         match = re.search(r"after '(.+?)' \(before '(.+?)'\); move", message)
         if match is None:
             raise ValueError(
@@ -1298,9 +1289,7 @@ def apply_markdown_issue_fix(content, line_number, message):
     return "".join(lines), old_line, after, reason
 
 
-def autofix_markdown_file(
-    filename, wrapnumber=55, punctuation_slop=20, max_line_length=None
-):
+def autofix_markdown_file(filename, wrapnumber=55, punctuation_slop=20):
     """Apply safe source line breaks and report unfinished source spans."""
     with open(filename, encoding="utf-8", newline="") as fp:
         content = fp.read()
@@ -1309,10 +1298,7 @@ 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,
-            max_line_length=max_line_length,
+            content, wrapnumber=wrapnumber, punctuation_slop=punctuation_slop
         )
         fixable = {}
         for line_number, message in issues:
@@ -1358,8 +1344,9 @@ def autofix_markdown_file(
 @register_command(
     "check wrapping and sentence-break rules (for markdown or latex).",
     "check that a file already obeys wr's wrapping rules -- without\n"
-    "rewriting anything. Reports a source line as too long if it holds\n"
-    "more words than wr's own greedy choice would put there, and\n"
+    "rewriting anything. Reports a source line as too long if it is\n"
+    "longer than --wrapnumber characters (and suggests the break wr would\n"
+    "use, which favors ending on a clause a few words early), and\n"
     "reports a sentence that ends in the middle of a source line\n"
     "instead of at a line break. Prints 'file:line: message' for each\n"
     "violation and exits non-zero if any are found. Takes the same\n"

{pydifftools-0.1.41 → pydifftools-0.1.43}/pyproject.toml

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

{pydifftools-0.1.41 → pydifftools-0.1.43}/tests/test_wrap_check.py

@@ -253,49 +253,66 @@ def test_autofix_fixes_every_line_in_one_pass_from_the_end(tmp_path):
     assert markdown_lint_issues_from_text(fixed, wrapnumber=55) == []
 
 
-def test_character_limit_ignores_lines_wr_would_break_sooner():
-    # from RM_ESR: 74 characters, which wr's width-55 rule would break
+def test_only_lines_longer_than_the_width_are_too_long():
+    # from RM_ESR: short lines ending on a clause used to be flagged, since
+    # wr broke at a comma or paren even when the rest of the line fit
     source = (
-        "temperatures not amenable to other methods, as in "
-        "[@Banerjee2009ESREviCoe].\n"
+        "(see @fig:CaldararuTau) indicates that\n"
+        "This is especially true, given that a comparison\n"
     )
 
-    assert markdown_lint_issues_from_text(source, 55) != []
-    assert markdown_lint_issues_from_text(source, max_line_length=79) == []
+    assert markdown_lint_issues_from_text(source, 55) == []
+    assert markdown_lint_issues_from_text(source, 79) == []
+    assert [
+        message.split(":")[0]
+        for _, message in markdown_lint_issues_from_text(source, 40)
+    ] == ["line too long"]
 
 
-@pytest.mark.parametrize("prefix", ["", "- ", "> "])
-def test_character_limit_breaks_at_last_fitting_word(tmp_path, prefix):
-    # from RM_ESR: a sentence that grew past 79 characters
+def test_long_line_breaks_early_on_a_nearby_clause(tmp_path):
+    # from RM_ESR: several clauses on one line that grew past 79
     line = (
-        prefix + "This script determines the field positions and amplitudes "
-        "of the spectral lines for an entire variable-temperature "
-        "experiment.\n"
+        "Finally, it estimates the rotational correlation time, "
+        "*via* the classic Kivelson equation, as a function of temperature.\n"
     )
     path = tmp_path / "source.md"
     path.write_text(line)
 
-    issues = markdown_lint_issues_from_text(line, max_line_length=79)
-    report = autofix_markdown_file(path, max_line_length=79)
+    report = autofix_markdown_file(path, wrapnumber=79)
 
     fixed = path.read_text()
-    assert [message.split(":")[0] for _, message in issues] == [
-        "line over 79 characters"
-    ]
-    assert "79 characters" in report["fixes"][0]["reason"]
+    assert fixed.split() == line.split()
     assert all(len(text) <= 79 for text in fixed.splitlines())
-    assert fixed.replace("\n> ", "\n").split() == line.split()
-    # the first line is filled as far as the limit allows
-    first = fixed.splitlines()[0]
-    next_word = line.split()[len(first.split())]
-    assert len(first) + 1 + len(next_word) > 79
-    assert markdown_lint_issues_from_text(fixed, max_line_length=79) == []
+    # the widest break is after "classic" (72 characters); "time," is 18
+    # characters before that, within the slop, so the line ends on it
+    assert fixed.splitlines()[0].endswith("rotational correlation time,")
+    assert len(report["fixes"]) == 1
+
+
+def test_clause_far_before_the_width_does_not_force_an_early_break():
+    line = (
+        "Finally, it estimates the rotational correlation time of the "
+        "probe and many other ordinary words here.\n"
+    )
+
+    first = wrap_prose(line, 79).splitlines()[0]
 
+    assert first.startswith("Finally, it estimates")
+    assert len(first) > 70
 
-def test_character_limit_skips_a_single_unbreakable_word():
-    source = "https://example.org/" + "x" * 90 + "\n"
 
-    assert markdown_lint_issues_from_text(source, max_line_length=79) == []
+@pytest.mark.parametrize("width", [20, 45, 55, 79])
+def test_wr_never_runs_past_the_width(width):
+    text = (
+        "This script determines the field positions, and amplitudes, of the "
+        "spectral lines (for an entire variable-temperature experiment) -- "
+        "and it implements spline-based smoothing of the spectra.\n"
+    )
+
+    wrapped = wrap_prose(text, width)
+
+    assert all(len(line) <= width for line in wrapped.splitlines())
+    assert markdown_lint_issues_from_text(wrapped, width) == []
 
 
 def test_unclosed_math_is_reported_after_fifty_lines():
@@ -406,19 +423,14 @@ def test_qt_fix_and_reload_windows_show_source_changes(tmp_path):
         )
         seen["preview"] = dialog.findChild(QTextEdit).toPlainText()
         seen["button"] = dialog.findChild(QPushButton).text()
-        seen["line_gutter"] = next(
-            label
-            for label in dialog.findChildren(QLabel)
-            if "#666" in label.styleSheet()
-        ).text()
         seen["heading"] = dialog.findChildren(QLabel)[0].text()
         dialog.findChild(QPushButton).click()
 
     QTimer.singleShot(0, inspect_fix_window)
     show_markdown_fix_dialog(report)
-    assert "↳ of words" in seen["preview"]
+    assert "↳ collection of words" in seen["preview"]
     assert seen["button"] == "Done"
-    assert "1" in seen["line_gutter"]
+    assert re.search(r"^ +1 − This deliberately", seen["preview"], re.M)
     assert "line 1" not in seen["heading"].lower()
 
     def inspect_reload_window():
@@ -437,6 +449,70 @@ def test_qt_fix_and_reload_windows_show_source_changes(tmp_path):
     assert seen["reload_button"] == "I've reloaded"
 
 
+def test_qt_fix_window_groups_fixes_of_one_kind_onto_full_pages(tmp_path):
+    pytest.importorskip("PySide6")
+    from PySide6.QtCore import QTimer
+    from PySide6.QtWidgets import QApplication, QDialog, QPushButton
+    from PySide6.QtWidgets import QLabel, QTextEdit
+
+    from pydifftools.continuous import show_markdown_fix_dialog
+
+    app = QApplication.instance() or QApplication([])
+    # from RM_ESR: many stray trailing spaces plus one other kind of fix
+    source_path = tmp_path / "content.md"
+    source_path.write_text(
+        "".join(f"Sentence number {j} ends here. \n" for j in range(60))
+        + "\n$$\nx = y\n$$ {#eq:tauFromLinewidth}\n"
+    )
+    report = autofix_markdown_file(source_path)
+    assert len(report["fixes"]) == 61
+    pages = []
+
+    def inspect_page():
+        dialog = next(
+            widget
+            for widget in app.topLevelWidgets()
+            if isinstance(widget, QDialog)
+            and widget.isVisible()
+            and widget.windowTitle() == "Markdown source fixes"
+        )
+        preview = dialog.findChild(QTextEdit).toPlainText()
+        pages.append(
+            {
+                "heading": dialog.findChildren(QLabel)[0].text(),
+                "details": dialog.findChildren(QLabel)[1].text(),
+                "entries": preview.split("\n\n"),
+            }
+        )
+        button = dialog.findChild(QPushButton)
+        if button.text() == "Next":
+            QTimer.singleShot(0, inspect_page)
+        button.click()
+
+    QTimer.singleShot(0, inspect_page)
+    show_markdown_fix_dialog(report)
+
+    trailing = [page for page in pages if "stray space" in page["details"]]
+    crossref = [page for page in pages if "crossref" in page["details"]]
+    # one kind per page, many fixes per page, and every fix shown once
+    assert len(trailing) + len(crossref) == len(pages)
+    assert len(crossref) == 1
+    assert 1 < len(trailing) < 60
+    assert all(len(page["entries"]) > 5 for page in trailing[:-1])
+    assert sum(len(page["entries"]) for page in trailing) == 60
+    assert f"(page 1 of {len(pages)})" in pages[0]["heading"]
+    # a trailing-space entry is just the numbered line with its stray space
+    # made visible, while other fixes also show the line after the fix
+    assert re.fullmatch(
+        r" +1 − Sentence number 0 ends here\.·", trailing[0]["entries"][0]
+    )
+    assert re.fullmatch(
+        r" +64 − \$\$ \{#eq:tauFromLinewidth\}\n +64 \+ "
+        r"\$\$\{#eq:tauFromLinewidth\}",
+        crossref[0]["entries"][0],
+    )
+
+
 def test_qt_unclosed_math_window_bolds_source_and_requests_confirmation():
     from PySide6.QtCore import QTimer
     from PySide6.QtWidgets import (

{pydifftools-0.1.41 → pydifftools-0.1.43}/tests/test_wrapping.py

@@ -423,7 +423,8 @@ def test_nested_containers_keep_terms_items_and_paragraphs_separate():
     result = wrap_blocks(markdown_blocks(source), 25)
     assert result.startswith("Term\n:   first definition\n")
     assert "\n    - a nested item with\n" in result
-    assert "\n      > a nested quotation\n" in result
+    # the quotation is 17 wide, so wr never lets it run past that
+    assert "\n      > a nested\n" in result
     assert "\n:   a second definition\n" in result
     assert "\n\nOutside prose" in result
     assert wrap_blocks(markdown_blocks(result), 25) == result