pyDiffTools 0.1.35__tar.gz → 0.1.36__tar.gz

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

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

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

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

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

@@ -14,7 +14,6 @@ import traceback
 import tempfile
 from pathlib import Path
 import yaml
-import textwrap
 from watchdog.events import FileSystemEventHandler
 from watchdog.observers import Observer
 from watchdog.observers.polling import PollingObserver
@@ -127,126 +126,205 @@ sys.exit(1)
     raise RuntimeError("pydifft cpb filter dialog failed.")
 
 
-def run_pandoc(
-    filename,
-    html_file,
-    comments_to_margin=False,
-    no_comments=False,
-    comment_filter_session=None,
-):
-    # {{{ review Markdown lint issues in a Qt walkthrough
-    def show_markdown_lint(filename, issues):
-        """Walk through cpb's Markdown style issues in a Qt window."""
-        dialog_script = r"""
-    import html
-    import json
-    import sys
+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,
     )
 
-    filename = sys.argv[1]
-    issues = json.loads(sys.argv[2])
-    app = QApplication(sys.argv[:1])
+    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.setWindowTitle("pydifft cpb — Markdown style")
-    dialog.resize(620, 260)
+    dialog._pydifftools_application = (
+        QApplication.instance() or QApplication([])
+    )
+    dialog.setWindowTitle("Markdown source fixes")
+    dialog.resize(760, 480)
     layout = QVBoxLayout(dialog)
     heading = QLabel()
-    heading.setTextFormat(Qt.TextFormat.RichText)
+    heading.setWordWrap(True)
     details = QLabel()
-    details.setTextFormat(Qt.TextFormat.RichText)
     details.setWordWrap(True)
-    fix = QLabel()
-    fix.setTextFormat(Qt.TextFormat.RichText)
-    fix.setWordWrap(True)
     layout.addWidget(heading)
     layout.addWidget(details)
-    layout.addWidget(fix)
-    button = QPushButton("Next")
+
+    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
-
-    def show_issue():
-        global index
-        if index >= len(issues):
-            heading.setText("<b>All listed issues reviewed.</b>")
-            details.setText(
-                "Edit the source if needed, then continue to check it again."
-            )
-            fix.setText("")
-            button.setText("Check again")
-            return
-        line, message = issues[index]
-        heading.setText(
-            f"<b>{html.escape(filename)}:{line}</b> — issue "
-            f"{index + 1} of {len(issues)}"
-        )
-        details.setText(html.escape(message))
-        if message.startswith("sentence ends mid-line"):
-            fix.setText(
-                "Fix: end the sentence on this line, then continue the next "
-                "sentence on a new source line.<br>"
-                "<span style='color:green'>↳ Enter</span> "
-                "<span style='color:green'><i>soft return: this newline "
-                "appears only in the source.</i></span>"
-            )
+    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:
-            fix.setText(
-                "Fix: add a source newline within the sentence so the prose "
-                "wraps at 55 characters or fewer.<br>"
-                "<span style='color:green'>↳ Enter</span> "
-                "<span style='color:green'><i>soft return: this newline "
-                "appears only in the source.</i></span>"
+            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():
-        global index
-        index += 1
-        show_issue()
+        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_issue()
+    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()
-    """
-        result = subprocess.run(
-            [
-                sys.executable,
-                "-c",
-                textwrap.dedent(dialog_script),
-                filename,
-                json.dumps(issues),
-            ],
-            capture_output=True,
-            text=True,
-        )
-        if result.returncode != 0:
-            detail = result.stderr.strip()
-            if detail:
-                raise RuntimeError(
-                    f"cpb Markdown lint dialog failed: {detail}"
-                )
-            raise RuntimeError("cpb Markdown lint dialog failed.")
-    # }}}
-    # Keep cpb's build gate tied to wrchk's Markdown rules. Recheck after each
-    # walkthrough because users can edit the source in their editor while the
-    # Qt window is open.
-    from .wrap_sentences import markdown_lint_issues_from_text
 
+
+def run_pandoc(
+    filename,
+    html_file,
+    comments_to_margin=False,
+    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:
-        with open(filename, encoding="utf-8") as fp:
-            markdown_text = fp.read()
-        issues = markdown_lint_issues_from_text(
-            markdown_text, wrapnumber=55
-        )
-        if not issues:
-            break
-        show_markdown_lint(filename, issues)
+        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"

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

@@ -978,14 +978,236 @@ def _iter_block_spans(blocks, wrapnumber, line_start=1):
 def markdown_lint_issues_from_text(
     content, wrapnumber=45, punctuation_slop=20
 ):
-    """Return lint issues for Markdown text using wrchk's existing rules."""
-    return [
+    """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(content), wrapnumber
+            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(

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

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