pyDiffTools 0.1.43__tar.gz → 0.1.45__tar.gz

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

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

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

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

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

@@ -145,13 +145,14 @@ def show_markdown_fix_dialog(report):
 
     fixes = report["fixes"]
     warnings = report["warnings"]
-    if not fixes and not warnings:
+    layout = report.get("layout", [])
+    if not fixes and not warnings and not layout:
         return
 
+    # a QApplication must exist before any widget is constructed
+    application = QApplication.instance() or QApplication([])
     dialog = QDialog()
-    dialog._pydifftools_application = (
-        QApplication.instance() or QApplication([])
-    )
+    dialog._pydifftools_application = application
     dialog.setWindowTitle("Markdown source fixes")
     fixed_font = QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont)
     # {{{ group fixes of one kind onto pages that fill the screen
@@ -196,6 +197,7 @@ def show_markdown_fix_dialog(report):
         records.append(
             {"record_type": "fix", "reason": reason, "fixes": page}
         )
+    records += [{"record_type": "layout", **notice} for notice in layout]
     records += [
         {"record_type": "warning", **warning} for warning in warnings
     ]
@@ -279,6 +281,40 @@ def show_markdown_fix_dialog(report):
             )
             # }}}
             button.setText("Next" if index + 1 < len(records) else "Done")
+        elif record["record_type"] == "layout":
+            heading.setText(
+                "These line breaks differ from git HEAD in "
+                f"{record['moves']} places." + page
+            )
+            details.setText(
+                "Keeping these lines as they are in git HEAD would need "
+                f"{record['moves']} line breaks moved, so I left them as you "
+                "wrote them. If you did not mean to rearrange these lines, "
+                "lay them out as suggested."
+            )
+            line_numbers.setVisible(False)
+            # {{{ show HEAD, the current source and the suggested layout
+            sections = []
+            for title, text, numbered in (
+                ("git HEAD:", record["head"], False),
+                ("Now:", record["current"], True),
+                ("Suggested:", record["suggested"], True),
+            ):
+                rows = [escape(title)]
+                for offset, value in enumerate(text.split("\n")):
+                    number = record["line"] + offset if numbered else ""
+                    rows.append(
+                        f"<span style='color:#666'>{number:>6}</span> "
+                        + escape(value)
+                    )
+                sections.append("<br>".join(rows))
+            preview.setHtml(
+                "<pre style='font-family:monospace; margin:0'>"
+                + "<br><br>".join(sections)
+                + "</pre>"
+            )
+            # }}}
+            button.setText("Next" if index + 1 < len(records) else "Done")
         else:
             line = record["line"]
             heading.setText("This source span is not closed." + page)
@@ -336,10 +372,10 @@ def show_markdown_reload_dialog():
         QVBoxLayout,
     )
 
+    # a QApplication must exist before any widget is constructed
+    application = QApplication.instance() or QApplication([])
     dialog = QDialog()
-    dialog._pydifftools_application = (
-        QApplication.instance() or QApplication([])
-    )
+    dialog._pydifftools_application = application
     dialog.setWindowTitle("Reload the Markdown source")
     dialog.resize(440, 150)
     layout = QVBoxLayout(dialog)
@@ -369,9 +405,11 @@ def run_pandoc(
 
     automatic_fixes_were_made = False
     while True:
-        report = autofix_markdown_file(filename, wrapnumber=wrapnumber)
+        report = autofix_markdown_file(
+            filename, wrapnumber=wrapnumber, git_head=True
+        )
         automatic_fixes_were_made |= bool(report["fixes"])
-        if report["fixes"] or report["warnings"]:
+        if report["fixes"] or report["warnings"] or report["layout"]:
             user_says_fixed = show_markdown_fix_dialog(report)
             if report["warnings"]:
                 if not user_says_fixed:

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

@@ -1,7 +1,10 @@
+import os
 import re
+import subprocess
 import sys
 import itertools
 from dataclasses import dataclass, field
+from difflib import SequenceMatcher
 
 from .command_registry import register_command
 
@@ -1289,11 +1292,364 @@ 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):
-    """Apply safe source line breaks and report unfinished source spans."""
+def autofix_markdown_file(
+    filename, wrapnumber=55, punctuation_slop=20, git_head=False
+):
+    """Apply safe source line breaks and report unfinished source spans.
+
+    With `git_head`, line breaks in the hunks that differ from the file's
+    git HEAD version are first placed to keep that diff small (see
+    "layout" in the returned report for hunks that would need more than
+    one line break moved).
+    """
     with open(filename, encoding="utf-8", newline="") as fp:
         content = fp.read()
     fixes = []
+    layout = []
+    baseline = None
+    if git_head:
+        directory, basename = os.path.split(os.path.abspath(filename))
+        try:
+            with subprocess.Popen(
+                ["git", "-C", directory, "show", "HEAD:./" + basename],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
+            ) as shown:
+                output = shown.communicate()[0]
+            if shown.returncode == 0:
+                baseline = output.decode("utf-8")
+        except FileNotFoundError:
+            # git is not installed
+            pass
+    if baseline is not None:
+        # {{{ place line breaks in changed hunks to keep the HEAD diff small
+
+        def mask_comment(match):
+            return "".join("\n" if char == "\n" else " " for char in match[0])
+
+        prefix_pattern = re.compile(
+            r"^(?P<quote>(?:[ \t]*>[ \t]?)*)(?P<indent>[ \t]*)"
+            r"(?:(?P<marker>[-+*]|[0-9]+[.)])(?P<space>[ \t]+))?"
+        )
+
+        def line_tokens(text):
+            """Words of each line, after its list or quote prefix."""
+            masked = re.sub(
+                r"<!--.*?(?:-->|\Z)", mask_comment, text, flags=re.DOTALL
+            )
+            result = []
+            start = 0
+            for number, line in enumerate(masked.splitlines(keepends=True)):
+                prefix = prefix_pattern.match(line)
+                result.extend(
+                    (number, start + found.start(), start + found.end())
+                    for found in WORD.finditer(line, prefix.end())
+                )
+                start += len(line)
+            return masked, result
+
+        head_lines = baseline.splitlines(keepends=True)
+        lines = content.splitlines(keepends=True)
+        line_starts = [0]
+        for line in lines:
+            line_starts.append(line_starts[-1] + len(line))
+        masked, tokens = line_tokens(content)
+        prose = [
+            allowed and line.strip() != ""
+            for allowed, line in classify_lines(masked, strict=False)
+        ]
+        prefixes = [prefix_pattern.match(line) for line in lines]
+        continuations = [
+            found["quote"]
+            + found["indent"]
+            + (
+                " " * (len(found["marker"]) + len(found["space"]))
+                if found["marker"]
+                else ""
+            )
+            for found in prefixes
+        ]
+        results = []
+        for operation, i1, i2, j1, j2 in SequenceMatcher(
+            None, head_lines, lines, autojunk=False
+        ).get_opcodes():
+            if operation == "equal" or j1 == j2:
+                continue
+            hunk_start, hunk_end = line_starts[j1], line_starts[j2]
+            hunk_tokens = [token for token in tokens if j1 <= token[0] < j2]
+            head_text = "".join(head_lines[i1:i2])
+            head_masked, head_tokens = line_tokens(head_text)
+            matched = set()
+            for block in SequenceMatcher(
+                None,
+                [head_masked[a:b] for _, a, b in head_tokens],
+                [masked[a:b] for _, a, b in hunk_tokens],
+                autojunk=False,
+            ).get_matching_blocks():
+                matched.update(range(block.b, block.b + block.size))
+            # {{{ find the gaps between prose words where a break may move
+            gaps = []
+            for k in range(len(hunk_tokens) - 1):
+                left_line, _, left_end = hunk_tokens[k]
+                right_line, right_start, _ = hunk_tokens[k + 1]
+                raw = content[left_end:right_start]
+                if not (prose[left_line] and prose[right_line]):
+                    continue
+                if left_line == right_line:
+                    if raw.strip(" \t"):
+                        continue
+                elif (
+                    right_line != left_line + 1
+                    or prefixes[right_line]["marker"]
+                    or prefixes[right_line].group(0)
+                    != continuations[left_line]
+                    or raw.strip(" \t\r\n") != prefixes[right_line][
+                        "quote"
+                    ].strip(" \t")
+                ):
+                    continue
+                gaps.append(
+                    {
+                        "start": left_end,
+                        "stop": right_start,
+                        "newline": "\n" in raw,
+                        "line": left_line,
+                        # breaks between two newly written words are the
+                        # writer's choice; only lint rules move those
+                        "free": k not in matched and k + 1 not in matched,
+                        "sentence": bool(
+                            re.search(
+                                "(" + SENTENCE_END + r")$",
+                                content[max(0, left_end - 4) : left_end],
+                            )
+                        ),
+                    }
+                )
+            # }}}
+            # a hunk this large is a wholesale reflow, not a stray line
+            # break, so leave it to the lint rules alone
+            if not gaps or len(gaps) > 400:
+                continue
+            ending = "\r\n" if "\r\n" in content[hunk_start:hunk_end] else "\n"
+            rendered = {}
+            scores = {}
+
+            def render(flags):
+                """The hunk with each gap a space or a line break, and the
+                (row, column) where each gap starts."""
+                key = tuple(flags)
+                if key not in rendered:
+                    output = []
+                    columns = []
+                    where = [0, 0]  # row and column of the output's end
+
+                    def append(piece):
+                        output.append(piece)
+                        if "\n" in piece:
+                            where[0] += piece.count("\n")
+                            where[1] = len(piece) - piece.rfind("\n") - 1
+                        else:
+                            where[1] += len(piece)
+
+                    position = hunk_start
+                    for gap, flag in zip(gaps, flags):
+                        append(content[position : gap["start"]])
+                        columns.append(tuple(where))
+                        if flag == gap["newline"]:
+                            append(content[gap["start"] : gap["stop"]])
+                        elif flag:
+                            append(ending + continuations[gap["line"]])
+                        else:
+                            append(" ")
+                        position = gap["stop"]
+                    append(content[position:hunk_end])
+                    rendered[key] = ("".join(output), columns)
+                return rendered[key]
+
+            def kept(text):
+                """How many HEAD lines the hunk keeps unchanged.
+
+                Fewer lines alone does not count as closer to HEAD, so
+                rewritten text keeps the writer's line breaks.
+                """
+                if text not in scores:
+                    scores[text] = sum(
+                        block.size
+                        for block in SequenceMatcher(
+                            None,
+                            [line.rstrip() for line in head_text.splitlines()],
+                            [line.rstrip() for line in text.splitlines()],
+                            autojunk=False,
+                        ).get_matching_blocks()
+                    )
+                return scores[text]
+
+            def too_long(flags):
+                """Rendered lines past the width that a gap could break."""
+                text, columns = render(flags)
+                rendered = text.splitlines()
+                return [
+                    number
+                    for number in sorted(
+                        {row for (row, _), flag in zip(columns, flags)
+                         if not flag}
+                    )
+                    if len(rendered[number].rstrip()) > wrapnumber
+                ]
+
+            original = [gap["newline"] for gap in gaps]
+            # {{{ lint first: a break after each sentence, and a break in
+            # each overlong line wherever it keeps the most HEAD lines
+            base = [
+                flag or gap["sentence"] for flag, gap in zip(original, gaps)
+            ]
+            for _ in range(len(gaps)):
+                overlong = too_long(base)
+                if not overlong:
+                    break
+                text, columns = render(base)
+                row = overlong[0]
+                line_text = text.splitlines()[row]
+                prefix = prefix_pattern.match(line_text).group(0)
+                words = WORD.findall(line_text[len(prefix) :])
+                upto = _next_break(
+                    words,
+                    wrapnumber - len(prefix),
+                    punctuation_slop,
+                    _math_boundaries(words),
+                    0,
+                )
+                wr_column = len(prefix) + len(" ".join(words[: upto + 1]))
+                candidates = [
+                    number
+                    for number, ((gap_row, column), flag) in enumerate(
+                        zip(columns, base)
+                    )
+                    if gap_row == row and not flag
+                ]
+                fitting = [
+                    number
+                    for number in candidates
+                    if columns[number][1] <= wrapnumber
+                ] or candidates[:1]
+
+                def with_break(number):
+                    return [
+                        flag or other == number
+                        for other, flag in enumerate(base)
+                    ]
+
+                base = with_break(
+                    min(
+                        fitting,
+                        key=lambda number: (
+                            -kept(render(with_break(number))[0]),
+                            abs(columns[number][1] - wr_column),
+                        ),
+                    )
+                )
+            # }}}
+            # {{{ then join or move breaks next to HEAD's words while that
+            # restores HEAD lines; only the lint rules above may add a break
+            best = list(base)
+            best_kept = kept(render(best)[0])
+            moves = 0
+            for _ in range(len(gaps)):
+                trials = []
+                for number, gap in enumerate(gaps):
+                    if (
+                        not best[number]
+                        or gap["free"]
+                        or gap["sentence"]
+                    ):
+                        continue
+                    joined = list(best)
+                    joined[number] = False
+                    trials.append(joined)
+                    # or slide the break to another gap of the joined line
+                    columns = render(joined)[1]
+                    for other, flag in enumerate(joined):
+                        if (
+                            not flag
+                            and other != number
+                            and columns[other][0] == columns[number][0]
+                        ):
+                            moved = list(joined)
+                            moved[other] = True
+                            trials.append(moved)
+                limit = len(too_long(best))
+                scored = [
+                    (kept(render(trial)[0]), trial)
+                    for trial in trials
+                    if len(too_long(trial)) <= limit
+                ]
+                if not scored:
+                    break
+                trial_kept, trial = max(scored, key=lambda item: item[0])
+                if trial_kept <= best_kept:
+                    break
+                best_kept, best = trial_kept, trial
+                moves += 1
+            # }}}
+            chosen = best if moves == 1 else base
+            results.append(
+                {
+                    "j1": j1,
+                    "j2": j2,
+                    "start": hunk_start,
+                    "stop": hunk_end,
+                    "old": content[hunk_start:hunk_end],
+                    "new": render(chosen)[0],
+                    "linted": base != original,
+                    "moved": moves == 1,
+                    "head": head_text,
+                    "suggested": render(best)[0] if moves > 1 else None,
+                    "moves": moves,
+                }
+            )
+        shift = 0
+        for result in results:
+            line = result["j1"] + 1 + shift
+            if result["new"] != result["old"]:
+                reasons = []
+                if result["linted"]:
+                    reasons.append(
+                        "This edit made a line too long or ended a sentence "
+                        "mid-line. I broke it where it keeps the most lines "
+                        "unchanged from git HEAD."
+                    )
+                if result["moved"]:
+                    reasons.append(
+                        "This edit moved a line break away from where git "
+                        "HEAD has it. I put it back so the unchanged lines "
+                        "stay unchanged."
+                    )
+                fixes.append(
+                    {
+                        "line": line,
+                        "reason": " ".join(reasons),
+                        "before": result["old"].rstrip("\r\n"),
+                        "after": result["new"].rstrip("\r\n"),
+                    }
+                )
+            if result["suggested"] is not None:
+                layout.append(
+                    {
+                        "line": line,
+                        "moves": result["moves"],
+                        "head": result["head"].rstrip("\r\n"),
+                        "current": result["new"].rstrip("\r\n"),
+                        "suggested": result["suggested"].rstrip("\r\n"),
+                    }
+                )
+            shift += result["new"].count("\n") - result["old"].count("\n")
+        for result in reversed(results):
+            content = (
+                content[: result["start"]]
+                + result["new"]
+                + content[result["stop"] :]
+            )
+        # }}}
     # Lint once, fix every flagged line, then lint again, since fixing one
     # issue at a time re-lints the whole file for every single fix.
     for _ in range(100):
@@ -1338,7 +1694,11 @@ def autofix_markdown_file(filename, wrapnumber=55, punctuation_slop=20):
     if fixes:
         with open(filename, "w", encoding="utf-8", newline="") as fp:
             fp.write(content)
-    return {"fixes": fixes, "warnings": unclosed_markdown_spans(content)}
+    return {
+        "fixes": fixes,
+        "warnings": unclosed_markdown_spans(content),
+        "layout": layout,
+    }
 
 
 @register_command(

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

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

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

@@ -1,5 +1,7 @@
+import os
 import re
 import subprocess
+import sys
 
 import pytest
 
@@ -660,3 +662,278 @@ def test_wrchk_latex_document(tmp_path):
         wrchk(str(path), wrapnumber=30, punctuation_slop=20)
     wr(str(path), wrapnumber=30)
     wrchk(str(path), wrapnumber=30)
+
+
+# {{{ keep line breaks close to git HEAD
+# from RM_ESR, wrapped the way the manuscript already is
+HEAD_PARAGRAPH = (
+    "Existing Python libraries enable rapid development of a script\n"
+    "that estimates the correlation time of these spectra.\n"
+    "This script determines the field positions and amplitudes of the\n"
+    "spectral lines for an entire variable-temperature experiment.\n"
+    "It implements spline-based smoothing of the spectra in order to\n"
+    "minimize the impact of any noise as part of this determination.\n"
+)
+
+
+def committed_source(tmp_path, text):
+    """A content.md committed to a fresh git repository."""
+    subprocess.run(["git", "init", "-q", str(tmp_path)], check=True)
+    path = tmp_path / "content.md"
+    path.write_text(text)
+    subprocess.run(
+        ["git", "-C", str(tmp_path), "add", "content.md"], check=True
+    )
+    subprocess.run(
+        [
+            "git", "-C", str(tmp_path), "-c", "user.name=t",
+            "-c", "user.email=t@example.org", "commit", "-q", "-m", "head",
+        ],
+        check=True,
+    )
+    return path
+
+
+def numstat(path):
+    """(added, removed) lines against git HEAD."""
+    output = subprocess.run(
+        ["git", "-C", str(path.parent), "diff", "--numstat", "HEAD"],
+        capture_output=True, text=True, check=True,
+    ).stdout.split()
+    return (int(output[0]), int(output[1])) if output else (0, 0)
+
+
+def test_words_appended_past_the_width_become_one_new_line(tmp_path):
+    path = committed_source(tmp_path, HEAD_PARAGRAPH)
+    path.write_text(
+        HEAD_PARAGRAPH.replace(
+            "of these spectra.\n", "of these spectra across all samples.\n"
+        ).replace(
+            "rapid development of a script\n",
+            "rapid development of a script in a few lines\n",
+        )
+    )
+    # the first edit fits; the second pushes a line past 79 characters
+    path.write_text(
+        path.read_text().replace(
+            "of the\nspectral",
+            "of the three hyperfine lines, and of the\nspectral",
+        )
+    )
+
+    report = autofix_markdown_file(path, wrapnumber=79, git_head=True)
+
+    fixed = path.read_text()
+    assert report["layout"] == []
+    assert markdown_lint_issues_from_text(fixed, 79) == []
+    # the HEAD line stays intact and the added words get one new line
+    assert (
+        "This script determines the field positions and amplitudes of the\n"
+        "three hyperfine lines, and of the\n"
+    ) in fixed
+    assert numstat(path) == (3, 2)
+
+
+def test_stray_line_break_in_an_unchanged_line_is_rejoined(tmp_path):
+    path = committed_source(tmp_path, HEAD_PARAGRAPH)
+    path.write_text(
+        HEAD_PARAGRAPH.replace(
+            "development of a script", "development\nof a script"
+        )
+    )
+
+    report = autofix_markdown_file(path, wrapnumber=79, git_head=True)
+
+    assert path.read_text() == HEAD_PARAGRAPH
+    assert numstat(path) == (0, 0)
+    assert "put it back" in report["fixes"][0]["reason"]
+
+
+def test_one_moved_line_break_is_moved_back(tmp_path):
+    path = committed_source(tmp_path, HEAD_PARAGRAPH)
+    path.write_text(
+        HEAD_PARAGRAPH.replace(
+            "amplitudes of the\nspectral lines",
+            "amplitudes of\nthe spectral lines",
+        )
+    )
+
+    autofix_markdown_file(path, wrapnumber=79, git_head=True)
+
+    assert path.read_text() == HEAD_PARAGRAPH
+
+
+def test_joined_head_lines_past_the_width_get_heads_break_back(tmp_path):
+    path = committed_source(tmp_path, HEAD_PARAGRAPH)
+    path.write_text(
+        HEAD_PARAGRAPH.replace("in order to\nminimize", "in order to minimize")
+    )
+
+    autofix_markdown_file(path, wrapnumber=79, git_head=True)
+
+    assert path.read_text() == HEAD_PARAGRAPH
+
+
+def test_two_moved_line_breaks_in_one_hunk_are_only_reported(tmp_path):
+    path = committed_source(tmp_path, HEAD_PARAGRAPH)
+    edited = HEAD_PARAGRAPH.replace(
+        "amplitudes of the\nspectral lines",
+        "amplitudes\nof the spectral lines",
+    ).replace(
+        "variable-temperature experiment.\nIt implements",
+        "variable-temperature experiment.\nIt\nimplements",
+    )
+    path.write_text(edited)
+
+    report = autofix_markdown_file(path, wrapnumber=79, git_head=True)
+
+    assert path.read_text() == edited
+    ((notice),) = report["layout"]
+    assert notice["moves"] == 2
+    assert notice["line"] == 3
+    assert notice["suggested"] + "\n" in HEAD_PARAGRAPH
+
+
+def test_removed_words_keep_their_line_break(tmp_path):
+    path = committed_source(tmp_path, HEAD_PARAGRAPH)
+    edited = HEAD_PARAGRAPH.replace(
+        "development of a script\nthat", "development\nthat"
+    )
+    path.write_text(edited)
+
+    report = autofix_markdown_file(path, wrapnumber=79, git_head=True)
+
+    assert path.read_text() == edited
+    assert report["fixes"] == [] and report["layout"] == []
+
+
+def test_new_paragraph_keeps_the_writers_line_breaks(tmp_path):
+    path = committed_source(tmp_path, HEAD_PARAGRAPH)
+    new_paragraph = (
+        "\nThese estimates\n"
+        "depend only weakly on the choice of smoothing.\n"
+    )
+    path.write_text(HEAD_PARAGRAPH + new_paragraph)
+
+    report = autofix_markdown_file(path, wrapnumber=79, git_head=True)
+
+    assert path.read_text() == HEAD_PARAGRAPH + new_paragraph
+    assert report["fixes"] == [] and report["layout"] == []
+
+
+def test_whole_file_is_still_linted_against_head(tmp_path):
+    # a problem that git HEAD already has still has to be fixed
+    path = committed_source(
+        tmp_path, HEAD_PARAGRAPH.replace("spectra.\n", "spectra. \n")
+    )
+
+    autofix_markdown_file(path, wrapnumber=79, git_head=True)
+
+    assert path.read_text() == HEAD_PARAGRAPH
+
+
+def test_file_outside_git_is_linted_without_head(tmp_path):
+    path = tmp_path / "content.md"
+    path.write_text(
+        HEAD_PARAGRAPH.replace(
+            "development of a script", "development\nof a script"
+        )
+    )
+
+    report = autofix_markdown_file(path, wrapnumber=79, git_head=True)
+
+    assert report["fixes"] == [] and report["layout"] == []
+
+
+# }}}
+
+
+def test_rewritten_sentence_keeps_its_semantic_line_breaks(tmp_path):
+    # from RM_ESR: a rewrite that breaks at each phrase shares words with
+    # HEAD, but joining its lines would not restore any HEAD line
+    head = (
+        "Peric *et al.* also observed that\n"
+        "even similarly sized nitroxide probes can report\n"
+        "different rotational dynamics in bulk water.\n"
+    )
+    rewrite = (
+        "Peric *et al.* also observed that\n"
+        "the rotational dynamics\n"
+        "of different small nitroxide probes\n"
+        "in bulk water\n"
+        "differ significantly.\n"
+    )
+    path = committed_source(tmp_path, head)
+    path.write_text(rewrite)
+
+    report = autofix_markdown_file(path, wrapnumber=79, git_head=True)
+
+    assert path.read_text() == rewrite
+    assert report["fixes"] == [] and report["layout"] == []
+
+
+def test_qt_layout_notice_shows_head_now_and_suggested(tmp_path):
+    pytest.importorskip("PySide6")
+    from PySide6.QtCore import QTimer
+    from PySide6.QtWidgets import QApplication, QDialog, QLabel
+    from PySide6.QtWidgets import QPushButton, QTextEdit
+
+    from pydifftools.continuous import show_markdown_fix_dialog
+
+    app = QApplication.instance() or QApplication([])
+    path = committed_source(tmp_path, HEAD_PARAGRAPH)
+    path.write_text(
+        HEAD_PARAGRAPH.replace(
+            "amplitudes of the\nspectral lines",
+            "amplitudes\nof the spectral lines",
+        ).replace(
+            "experiment.\nIt implements", "experiment.\nIt\nimplements"
+        )
+    )
+    report = autofix_markdown_file(path, wrapnumber=79, git_head=True)
+    seen = {}
+
+    def inspect():
+        dialog = next(
+            widget
+            for widget in app.topLevelWidgets()
+            if isinstance(widget, QDialog) and widget.isVisible()
+        )
+        seen["heading"] = dialog.findChildren(QLabel)[0].text()
+        seen["preview"] = dialog.findChild(QTextEdit).toPlainText()
+        dialog.findChild(QPushButton).click()
+
+    QTimer.singleShot(0, inspect)
+    show_markdown_fix_dialog(report)
+
+    assert "differ from git HEAD in 2 places" in seen["heading"]
+    head, now, suggested = seen["preview"].split("\n\n")
+    assert head.startswith("git HEAD:")
+    assert re.search(r"^ +3 This script determines .* amplitudes$", now, re.M)
+    assert re.search(r"^ +4 spectral lines for", suggested, re.M)
+
+
+def test_qt_fix_windows_create_their_own_application():
+    # cpb shows these windows without a QApplication; constructing the
+    # dialog first aborted the whole process
+    pytest.importorskip("PySide6")
+    script = (
+        "from PySide6.QtWidgets import QDialog\n"
+        "QDialog.exec = lambda self: 0\n"
+        "from pydifftools.continuous import (\n"
+        "    show_markdown_fix_dialog, show_markdown_reload_dialog)\n"
+        "show_markdown_fix_dialog({'fixes': [{'line': 1, 'reason': 'r',\n"
+        "    'before': 'a ', 'after': 'a'}], 'warnings': []})\n"
+        "show_markdown_reload_dialog()\n"
+        "print('shown')\n"
+    )
+
+    completed = subprocess.run(
+        [sys.executable, "-c", script],
+        capture_output=True,
+        text=True,
+        env={**os.environ, "QT_QPA_PLATFORM": "offscreen"},
+    )
+
+    assert completed.returncode == 0, completed.stderr
+    assert completed.stdout.strip() == "shown"