pyDiffTools 0.1.34__tar.gz → 0.1.36__tar.gz

{pydifftools-0.1.34/pyDiffTools.egg-info → pydifftools-0.1.36}/PKG-INFO

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

{pydifftools-0.1.34 → pydifftools-0.1.36/pyDiffTools.egg-info}/PKG-INFO

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

{pydifftools-0.1.34 → pydifftools-0.1.36}/pydifftools/continuous.py

@@ -1,5 +1,6 @@
 """Continuous Pandoc build utility that requires geckodriver."""
 
+import json
 import time
 import subprocess
 import sys
@@ -10,7 +11,6 @@ import shutil
 import threading
 import queue
 import traceback
-import json
 import tempfile
 from pathlib import Path
 import yaml
@@ -61,7 +61,8 @@ def _comment_filter_mode(path, packaged_filters=None):
     return "custom"
 
 
-def _confirm_restore_comment_filter(active_mode):
+# Kept separate so its prompt choices can be unit-tested.
+def confirm_restore_comment_filter(active_mode):
     if active_mode == "none":
         message = (
             "The current lua filter is the one that does not show comments, "
@@ -125,6 +126,176 @@ sys.exit(1)
     raise RuntimeError("pydifft cpb filter dialog failed.")
 
 
+def show_markdown_fix_dialog(report):
+    """Show automatic fixes and any source edits that still need a user."""
+    from html import escape
+
+    from PySide6.QtCore import Qt
+    from PySide6.QtGui import QFontDatabase
+    from PySide6.QtWidgets import (
+        QApplication,
+        QDialog,
+        QHBoxLayout,
+        QLabel,
+        QPushButton,
+        QTextEdit,
+        QVBoxLayout,
+    )
+
+    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:
+        return
+
+    dialog = QDialog()
+    dialog._pydifftools_application = (
+        QApplication.instance() or QApplication([])
+    )
+    dialog.setWindowTitle("Markdown source fixes")
+    dialog.resize(760, 480)
+    layout = QVBoxLayout(dialog)
+    heading = QLabel()
+    heading.setWordWrap(True)
+    details = QLabel()
+    details.setWordWrap(True)
+    layout.addWidget(heading)
+    layout.addWidget(details)
+
+    preview_row = QHBoxLayout()
+    line_numbers = QLabel()
+    line_numbers.setAlignment(
+        Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignRight
+    )
+    line_numbers.setStyleSheet("color: #666; padding-right: 8px;")
+    line_numbers.setFont(
+        QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont)
+    )
+    preview = QTextEdit()
+    preview.setReadOnly(True)
+    preview.setFont(
+        QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont)
+    )
+    preview_row.addWidget(line_numbers)
+    preview_row.addWidget(preview, 1)
+    layout.addLayout(preview_row, 1)
+
+    button = QPushButton()
+    layout.addWidget(button)
+    index = 0
+    user_says_fixed = False
+
+    def show_record():
+        record = records[index]
+        line = record["line"]
+        if record["record_type"] == "fix":
+            heading.setText("I fixed this source line automatically.")
+            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)
+            button.setText("Next" if index + 1 < len(records) else "Done")
+        else:
+            heading.setText("This source span is not closed.")
+            if record["kind"] == "math":
+                delimiter = record["delimiter"]
+                details.setText(
+                    f"This math has no closing {delimiter}. Add {delimiter} "
+                    "where the expression ends, then choose “I've fixed it”."
+                )
+            else:
+                details.setText(
+                    "This HTML comment has no closing -->. Add --> where "
+                    "the comment ends, then choose “I've fixed it”."
+                )
+            offending_lines = record["offending"].splitlines() or [""]
+            line_numbers.setText(
+                "<br>".join(
+                    str(number)
+                    for number in range(line, line + len(offending_lines))
+                )
+            )
+            preview.setHtml(
+                "<pre style='font-family:monospace; margin:0'><b>"
+                + "<br>".join(escape(value) for value in offending_lines)
+                + "</b></pre>"
+            )
+            button.setText("I've fixed it")
+
+    def advance():
+        nonlocal index, user_says_fixed
+        if records[index]["record_type"] == "warning":
+            user_says_fixed = True
+            dialog.accept()
+            return
+        if index + 1 < len(records):
+            index += 1
+            show_record()
+        else:
+            dialog.accept()
+
+    button.clicked.connect(advance)
+    show_record()
+    dialog.exec()
+    return user_says_fixed
+
+
+def show_markdown_reload_dialog():
+    """Ask the user to reload a source file changed by automatic fixes."""
+    from PySide6.QtWidgets import (
+        QApplication,
+        QDialog,
+        QLabel,
+        QPushButton,
+        QVBoxLayout,
+    )
+
+    dialog = QDialog()
+    dialog._pydifftools_application = (
+        QApplication.instance() or QApplication([])
+    )
+    dialog.setWindowTitle("Reload the Markdown source")
+    dialog.resize(440, 150)
+    layout = QVBoxLayout(dialog)
+    message = QLabel(
+        "I fixed the Markdown source. Reload it in your editor to see the "
+        "changes."
+    )
+    message.setWordWrap(True)
+    layout.addWidget(message)
+    button = QPushButton("I've reloaded")
+    button.clicked.connect(dialog.accept)
+    layout.addWidget(button)
+    dialog.exec()
+
+
 def run_pandoc(
     filename,
     html_file,
@@ -132,6 +303,29 @@ def run_pandoc(
     no_comments=False,
     comment_filter_session=None,
 ):
+    # {{{ automatically fix Markdown source and request edits for
+    # unfinished spans
+    from .wrap_sentences import autofix_markdown_file
+
+    automatic_fixes_were_made = False
+    while True:
+        report = autofix_markdown_file(filename, wrapnumber=55)
+        automatic_fixes_were_made |= bool(report["fixes"])
+        if report["fixes"] or report["warnings"]:
+            user_says_fixed = show_markdown_fix_dialog(report)
+            if report["warnings"]:
+                if not user_says_fixed:
+                    raise RuntimeError(
+                        "The Markdown source still has an unclosed math "
+                        "expression or HTML comment."
+                    )
+                continue
+        break
+
+    if automatic_fixes_were_made:
+        show_markdown_reload_dialog()
+    # }}}
+
     if comments_to_margin:
         comment_filter_mode = "margin"
     elif no_comments:
@@ -198,9 +392,12 @@ def run_pandoc(
                 ):
                     show_comments = comment_filter_session["show_comments"]
                 else:
-                    show_comments = _confirm_restore_comment_filter(
+                    # {{{ ask whether to restore comments after detecting a
+                    # locally changed comment filter
+                    show_comments = confirm_restore_comment_filter(
                         active_mode
                     )
+                    # }}}
                     if comment_filter_session is not None:
                         comment_filter_session["show_comments"] = (
                             show_comments

{pydifftools-0.1.34 → pydifftools-0.1.36}/pydifftools/wrap_sentences.py

@@ -826,62 +826,13 @@ def wr(filename, wrapnumber=45, punctuation_slop=20, cleanoo=False, i=-1):
             fp.write(result)
 
 
-def _check_fragment(
-    fragment, frag_start, wrapnumber, punctuation_slop, base_line, stripped
-):
-    """Report line-length violations within one wrap unit (a sentence, or a
-    piece of one split off around a LaTeX structural macro).
-
-    Replays wr's own greedy word-fitting choice (_next_break) but always
-    resumes from the *real* line break already present in the source
-    (never from wr's own suggested break), so a shorter user break, or a
-    word nudged onto the next line, is never flagged -- only a line that
-    holds more words than wr's choice would allow is.
-    """
-    words, positions = [], []
-    for match in re.finditer(r"\S+", fragment):
-        words.append(match.group())
-        positions.append(frag_start + match.start())
-    if not words:
-        return []
-    ends = positions[1:] + [frag_start + len(fragment)]
-    breaks_after = [
-        "\n" in stripped[positions[j] + len(words[j]) : ends[j]]
-        for j in range(len(words))
-    ]
-    boundaries = _math_boundaries(words)
-    issues = []
-    offset = 0
-    while offset < len(words):
-        upto = _next_break(
-            words[offset:], wrapnumber, punctuation_slop, boundaries, offset
-        )
-        wr_end = offset + upto
-        actual_end = offset
-        while actual_end < len(words) - 1 and not breaks_after[actual_end]:
-            actual_end += 1
-        if actual_end > wr_end:
-            overflow = words[wr_end + 1]
-            line = base_line + stripped.count("\n", 0, positions[actual_end])
-            issues.append(
-                (
-                    line,
-                    f"line too long: wr would break after '{words[wr_end]}' "
-                    f"(before '{overflow}'); move '{overflow}' onward to "
-                    "the next line, or shorten this sentence",
-                )
-            )
-        offset = actual_end + 1
-    return issues
-
-
 def check_prose(content, wrapnumber, punctuation_slop, line_start=1):
     """Report source lines in `content` that break wr's rules.
 
     Two checks, mirroring 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
-    would put there (see _check_fragment), and a sentence must not end
+    would put there (see the fragment check below), and a sentence must not end
     in the middle of a source line. A sentence-ending period followed by
     a backslash-space (`\\ `) rather than a plain space -- the standard
     LaTeX/Pandoc way to mark an abbreviation -- is never mistaken for a
@@ -912,16 +863,54 @@ def check_prose(content, wrapnumber, punctuation_slop, line_start=1):
             frag_offset = sentence_start
             for fragment in LATEX_MACRO_SPLIT.split(sentence):
                 if fragment:
-                    issues.extend(
-                        _check_fragment(
-                            fragment,
-                            frag_offset,
-                            wrapnumber,
-                            punctuation_slop,
-                            para_line,
-                            stripped,
-                        )
-                    )
+                    # {{{ check line lengths within this sentence fragment
+                    words, positions = [], []
+                    for match in re.finditer(r"\S+", fragment):
+                        words.append(match.group())
+                        positions.append(frag_offset + match.start())
+                    if words:
+                        ends = positions[1:] + [frag_offset + len(fragment)]
+                        breaks_after = [
+                            "\n"
+                            in stripped[
+                                positions[j] + len(words[j]) : ends[j]
+                            ]
+                            for j in range(len(words))
+                        ]
+                        boundaries = _math_boundaries(words)
+                        fragment_offset = 0
+                        while fragment_offset < len(words):
+                            upto = _next_break(
+                                words[fragment_offset:],
+                                wrapnumber,
+                                punctuation_slop,
+                                boundaries,
+                                fragment_offset,
+                            )
+                            wr_end = fragment_offset + upto
+                            actual_end = fragment_offset
+                            while (
+                                actual_end < len(words) - 1
+                                and not breaks_after[actual_end]
+                            ):
+                                actual_end += 1
+                            if actual_end > wr_end:
+                                overflow = words[wr_end + 1]
+                                issue_line = para_line + stripped.count(
+                                    "\n", 0, positions[actual_end]
+                                )
+                                issues.append(
+                                    (
+                                        issue_line,
+                                        "line too long: wr would break after "
+                                        f"'{words[wr_end]}' (before "
+                                        f"'{overflow}'); move '{overflow}' "
+                                        "onward to the next line, or shorten "
+                                        "this sentence",
+                                    )
+                                )
+                            fragment_offset = actual_end + 1
+                    # }}}
                 frag_offset += len(fragment)
             offset += len(sentence)
             if k < len(separators):
@@ -986,6 +975,241 @@ def _iter_block_spans(blocks, wrapnumber, line_start=1):
         line += span
 
 
+def markdown_lint_issues_from_text(
+    content, wrapnumber=45, punctuation_slop=20
+):
+    """Return Markdown writing issues, including unfinished source spans."""
+    def mask_comment(match):
+        return "".join("\n" if char == "\n" else " " for char in match[0])
+
+    prose_content = re.sub(
+        r"<!--.*?(?:-->|\Z)", mask_comment, content, flags=re.DOTALL
+    )
+    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)
+    )
+    return sorted(issues)
+
+
+def unclosed_markdown_spans(content, math_line_limit=50):
+    """Find unfinished math and HTML comments in Markdown source."""
+    lines = content.splitlines(keepends=True)
+    spans = []
+    fence_char = None
+    fence_size = 0
+    math_start = None
+    math_delimiter = None
+    math_content = []
+    comment_start = None
+    comment_content = []
+    inline_code_delimiter = None
+    token_pattern = re.compile(
+        r"<!--|-->|(?<!\\)\$\$|(?<!\\)\$|`+"
+    )
+
+    for line_number, line in enumerate(lines, 1):
+        fence = re.match(r"^[ \t]*(?P<marker>`{3,}|~{3,})", line)
+        if fence_char is not None:
+            if (
+                fence
+                and fence.group("marker")[0] == fence_char
+                and len(fence.group("marker")) >= fence_size
+            ):
+                fence_char = None
+            continue
+        if fence:
+            fence_char = fence.group("marker")[0]
+            fence_size = len(fence.group("marker"))
+            continue
+
+        for token in token_pattern.finditer(line):
+            value = token.group()
+            if comment_start is not None:
+                if value == "-->":
+                    comment_start = None
+                    comment_content = []
+                continue
+            if math_start is not None:
+                if value == math_delimiter:
+                    math_start = None
+                    math_delimiter = None
+                    math_content = []
+                continue
+            if inline_code_delimiter is not None:
+                if value.startswith("`") and value == inline_code_delimiter:
+                    inline_code_delimiter = None
+                continue
+            if value.startswith("`"):
+                inline_code_delimiter = value
+                continue
+            if value == "<!--":
+                comment_start = line_number
+                comment_content = [line[token.start() :]]
+            elif value in {"$", "$$"}:
+                math_start = line_number
+                math_delimiter = value
+                math_content = [line[token.start() :]]
+        if comment_start is not None and line_number > comment_start:
+            comment_content.append(line)
+        if math_start is not None and line_number > math_start:
+            math_content.append(line)
+
+    if comment_start is not None:
+        spans.append(
+            {
+                "kind": "comment",
+                "line": comment_start,
+                "message": "unclosed HTML comment: add '-->' to close it",
+                "offending": "".join(comment_content).rstrip("\r\n"),
+            }
+        )
+    if (
+        math_start is not None
+        and len(lines) - math_start + 1 >= math_line_limit
+    ):
+        spans.append(
+            {
+                "kind": "math",
+                "line": math_start,
+                "message": (
+                    "unclosed math: add the matching "
+                    f"'{math_delimiter}' to close it"
+                ),
+                "offending": "".join(math_content).rstrip("\r\n"),
+                "delimiter": math_delimiter,
+            }
+        )
+    return spans
+
+
+# Kept public so the automatic source edits can be unit-tested directly.
+def apply_markdown_issue_fix(content, line_number, message):
+    """Insert one source line break for a wrchk Markdown issue."""
+    lines = content.splitlines(keepends=True)
+    index = line_number - 1
+    if index < 0 or index >= len(lines):
+        raise ValueError(
+            f"Markdown issue refers to missing line {line_number}"
+        )
+    old_line = lines[index]
+    ending = ""
+    if old_line.endswith("\r\n"):
+        old_line, ending = old_line[:-2], "\r\n"
+    elif old_line.endswith(("\n", "\r")):
+        old_line, ending = old_line[:-1], old_line[-1:]
+    if not ending:
+        ending = "\n"
+
+    # {{{ keep continuation lines inside their Markdown container
+    container = re.match(
+        r"^((?:[ \t]*>[ \t]?)*)(?:([-+*]|[0-9]+[.)])([ \t]+))?",
+        old_line,
+    )
+    quote_prefix, marker, marker_space = container.groups()
+    if marker:
+        prefix = quote_prefix + " " * (len(marker) + len(marker_space))
+    elif quote_prefix:
+        prefix = quote_prefix
+    else:
+        prefix = re.match(r"^[ \t]*", old_line).group()
+    # }}}
+    if message.startswith("line too long:"):
+        match = re.search(r"before '([^']+)'", message)
+        if match is None:
+            raise ValueError(
+                f"Cannot find the suggested word in {message!r}"
+            )
+        word = re.escape(match.group(1))
+        position = re.search(r"(?<!\S)" + word + r"(?!\S)", old_line)
+        if position is None:
+            raise ValueError(
+                f"Cannot find {match.group(1)!r} on Markdown line "
+                f"{line_number}"
+            )
+        split_at = position.start()
+        first = old_line[:split_at].rstrip()
+        second = old_line[split_at:].lstrip(" \t")
+        reason = (
+            "This line was hard to read because it held too many words. "
+            "I moved the next words onto a new line."
+        )
+    elif message.startswith("sentence ends mid-line"):
+        boundary = SENTENCE_BOUNDARY.search(old_line)
+        if boundary is None or boundary.group(2) != " ":
+            raise ValueError(
+                "Cannot find the sentence break on Markdown line "
+                f"{line_number}"
+            )
+        first = old_line[: boundary.end(1)].rstrip()
+        second = old_line[boundary.end(2) :].lstrip(" \t")
+        reason = (
+            "A sentence ended, but the next sentence continued on the same "
+            "source line. I started it on a new line."
+        )
+    else:
+        raise ValueError(f"No automatic fix is available for {message!r}")
+
+    fixed_line = first + ending + prefix + second + ending
+    lines[index] = fixed_line
+    after = first + "\n" + prefix + second
+    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."""
+    with open(filename, encoding="utf-8", newline="") as fp:
+        content = fp.read()
+    fixes = []
+    for _ in range(1000):
+        issues = markdown_lint_issues_from_text(
+            content, wrapnumber=wrapnumber, punctuation_slop=punctuation_slop
+        )
+        fixable = next(
+            (
+                issue
+                for issue in issues
+                if not issue[1].startswith(
+                    ("unclosed math:", "unclosed HTML comment:")
+                )
+            ),
+            None,
+        )
+        if fixable is None:
+            break
+        line_number, message = fixable
+        updated, before, after, reason = apply_markdown_issue_fix(
+            content, line_number, message
+        )
+        if updated == content:
+            raise RuntimeError(
+                f"Automatic Markdown fix made no change at line {line_number}"
+            )
+        fixes.append(
+            {
+                "line": line_number,
+                "reason": reason,
+                "before": before,
+                "after": after,
+            }
+        )
+        content = updated
+    else:
+        raise RuntimeError("Too many automatic Markdown fixes were needed.")
+
+    if fixes:
+        with open(filename, "w", encoding="utf-8", newline="") as fp:
+            fp.write(content)
+    return {"fixes": fixes, "warnings": unclosed_markdown_spans(content)}
+
+
 @register_command(
     "check wrapping and sentence-break rules (for markdown or latex).",
     "check that a file already obeys wr's wrapping rules -- without\n"
@@ -1005,17 +1229,19 @@ def _iter_block_spans(blocks, wrapnumber, line_start=1):
 def wrchk(filename, wrapnumber=45, punctuation_slop=20, cleanoo=False, i=-1):
     alltext, filetype, _, display_name = _prepare(filename, cleanoo, i)
     if filetype == "markdown":
-        spans = _iter_block_spans(markdown_blocks(alltext), wrapnumber)
+        issues = markdown_lint_issues_from_text(
+            alltext, wrapnumber, punctuation_slop
+        )
     else:
         spans = (
             (line, wrapnumber, content)
             for line, content in _iter_classified_spans(alltext, filetype)
         )
-    issues = [
-        issue
-        for line, width, content in spans
-        for issue in check_prose(content, width, punctuation_slop, line)
-    ]
+        issues = [
+            issue
+            for line, width, content in spans
+            for issue in check_prose(content, width, punctuation_slop, line)
+        ]
     for line, message in issues:
         print(f"{display_name}:{line}: {message}")
     if issues:

{pydifftools-0.1.34 → pydifftools-0.1.36}/pyproject.toml

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