pyDiffTools 0.1.41__tar.gz → 0.1.42__tar.gz

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

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

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

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

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

@@ -303,6 +303,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 +311,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 +790,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 +841,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 +977,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.42}/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)
@@ -1229,25 +1233,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 +1284,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 +1293,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 +1339,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.42}/pyproject.toml

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

{pydifftools-0.1.41 → pydifftools-0.1.42}/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"
+@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 markdown_lint_issues_from_text(source, max_line_length=79) == []
+    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():
@@ -416,7 +433,7 @@ def test_qt_fix_and_reload_windows_show_source_changes(tmp_path):
 
     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 "line 1" not in seen["heading"].lower()

{pydifftools-0.1.41 → pydifftools-0.1.42}/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