pyDiffTools 0.1.34__tar.gz → 0.1.35__tar.gz

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

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

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

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

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

@@ -1,5 +1,6 @@
 """Continuous Pandoc build utility that requires geckodriver."""
 
+import json
 import time
 import subprocess
 import sys
@@ -10,10 +11,10 @@ import shutil
 import threading
 import queue
 import traceback
-import json
 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
@@ -61,7 +62,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, "
@@ -132,6 +134,120 @@ def run_pandoc(
     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
+    from PySide6.QtCore import Qt
+    from PySide6.QtWidgets import (
+        QApplication,
+        QDialog,
+        QLabel,
+        QPushButton,
+        QVBoxLayout,
+    )
+
+    filename = sys.argv[1]
+    issues = json.loads(sys.argv[2])
+    app = QApplication(sys.argv[:1])
+    dialog = QDialog()
+    dialog.setWindowTitle("pydifft cpb — Markdown style")
+    dialog.resize(620, 260)
+    layout = QVBoxLayout(dialog)
+    heading = QLabel()
+    heading.setTextFormat(Qt.TextFormat.RichText)
+    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")
+    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>"
+            )
+        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>"
+            )
+
+    def advance():
+        global index
+        index += 1
+        show_issue()
+
+    button.clicked.connect(advance)
+    show_issue()
+    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
+
+    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)
+
     if comments_to_margin:
         comment_filter_mode = "margin"
     elif no_comments:
@@ -198,9 +314,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.35}/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,19 @@ def _iter_block_spans(blocks, wrapnumber, line_start=1):
         line += span
 
 
+def markdown_lint_issues_from_text(
+    content, wrapnumber=45, punctuation_slop=20
+):
+    """Return lint issues for Markdown text using wrchk's existing rules."""
+    return [
+        issue
+        for line, width, span in _iter_block_spans(
+            markdown_blocks(content), wrapnumber
+        )
+        for issue in check_prose(span, width, punctuation_slop, line)
+    ]
+
+
 @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 +1007,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.35}/pyproject.toml

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