pyDiffTools 0.1.54__tar.gz → 0.1.56__tar.gz

{pydifftools-0.1.54/pyDiffTools.egg-info → pydifftools-0.1.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDiffTools
-Version: 0.1.54
+Version: 0.1.56
 Summary: Diff tools
 Author: J M Franck
 License: Copyright (c) 2015, jmfranck
@@ -306,7 +306,9 @@ included are (listed in order of fun/utility):
     * ``cpb`` and ``wmatch`` share a matcher that finds changed hunks, aligns
       their words using Git's minimal diff, and restores reference whitespace.
       It then considers extra breaks that preserve an unchanged reference line
-      without stranding a tiny edited fragment, and checks wrapping rules.
+      without stranding an edited fragment of three words or fewer, and checks
+      wrapping rules. When matching a baseline, edited lines may exceed the
+      character width by at most four words before wrapping is required.
 
     * ``--wrapnumber`` sets the maximum width (79 for ``cpb`` and ``wmatch``).
       Wmatch also uses nearby reference widths for large edits, retaining

{pydifftools-0.1.54 → pydifftools-0.1.56}/README.rst

@@ -251,7 +251,9 @@ included are (listed in order of fun/utility):
     * ``cpb`` and ``wmatch`` share a matcher that finds changed hunks, aligns
       their words using Git's minimal diff, and restores reference whitespace.
       It then considers extra breaks that preserve an unchanged reference line
-      without stranding a tiny edited fragment, and checks wrapping rules.
+      without stranding an edited fragment of three words or fewer, and checks
+      wrapping rules. When matching a baseline, edited lines may exceed the
+      character width by at most four words before wrapping is required.
 
     * ``--wrapnumber`` sets the maximum width (79 for ``cpb`` and ``wmatch``).
       Wmatch also uses nearby reference widths for large edits, retaining

{pydifftools-0.1.54 → pydifftools-0.1.56/pyDiffTools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDiffTools
-Version: 0.1.54
+Version: 0.1.56
 Summary: Diff tools
 Author: J M Franck
 License: Copyright (c) 2015, jmfranck
@@ -306,7 +306,9 @@ included are (listed in order of fun/utility):
     * ``cpb`` and ``wmatch`` share a matcher that finds changed hunks, aligns
       their words using Git's minimal diff, and restores reference whitespace.
       It then considers extra breaks that preserve an unchanged reference line
-      without stranding a tiny edited fragment, and checks wrapping rules.
+      without stranding an edited fragment of three words or fewer, and checks
+      wrapping rules. When matching a baseline, edited lines may exceed the
+      character width by at most four words before wrapping is required.
 
     * ``--wrapnumber`` sets the maximum width (79 for ``cpb`` and ``wmatch``).
       Wmatch also uses nearby reference widths for large edits, retaining

{pydifftools-0.1.54 → pydifftools-0.1.56}/pyDiffTools.egg-info/SOURCES.txt

@@ -118,6 +118,7 @@ tests/test_git_mergein.py
 tests/test_git_pdf_diff.py
 tests/test_line_alignment.py
 tests/test_pdf_diff.py
+tests/test_qt_lifecycle.py
 tests/test_rrng.py
 tests/test_source_jump.py
 tests/test_tex_to_qmd.py

{pydifftools-0.1.54 → pydifftools-0.1.56}/pydifftools/flowchart/source_jump.js

@@ -1,11 +1,11 @@
-// Add a small local-only source jump action to cpb and flowchart previews.
+// Add a small local-only source jump action to cpb, qmdb and flowchart previews.
 (function () {
   const endpoint = window.pydifftSourceJumpEndpoint;
   if (!endpoint) {
     return;
   }
   const excludedSourceElements =
-    '.math,.MathJax,mjx-container,.katex,math,' +
+    '.pydifft-obs-prefix,.math,.MathJax,mjx-container,.katex,math,' +
     'script[type^="math/tex"],' +
     'a[href*="#fig:"],a[href*="#fig-"],a[href*="#fig%3A"]';
 
@@ -27,6 +27,7 @@
   });
 
   let phrase = '';
+  let source = null;
 
   // Preserve HTML tag boundaries without adding spaces to words such as
   // H<sub>2</sub>O. Python treats this reserved marker as a formatting gap.
@@ -43,6 +44,9 @@
 
   function showMenu(event, text) {
     phrase = normalizeSourceText(text || '');
+    const sourceElement = event.target && event.target.closest
+      ? event.target.closest('[data-pydifft-source]') : null;
+    source = sourceElement ? sourceElement.dataset.pydifftSource : null;
     if (!phrase) {
       hideMenu();
       return;
@@ -102,6 +106,11 @@
         text += ' ';
         return;
       }
+      if (node.nodeType === Node.ELEMENT_NODE &&
+          (node.tagName === 'BR' || node.tagName === 'IMG')) {
+        text += ' ';
+        return;
+      }
       const tagBoundary = node !== block && node.nodeType === Node.ELEMENT_NODE;
       if (tagBoundary) {
         text += '\uE000';
@@ -144,7 +153,7 @@
     fetch(endpoint, {
       method: 'POST',
       mode: 'no-cors',
-      body: phrase,
+      body: source ? JSON.stringify({source: source, phrase: phrase}) : phrase,
     }).catch(function () {
       // The preview may be closing while the local editor request is sent.
     });

{pydifftools-0.1.54 → pydifftools-0.1.56}/pydifftools/line_alignment.py

@@ -256,6 +256,7 @@ def align_line_breaks(
                 if allowed:
                     for line, message in check_prose(
                         span, width, punctuation_slop, offset,
+                        overflow_words=4,
                     ):
                         issues.setdefault(line, message)
                 offset += span.count("\n")
@@ -462,6 +463,58 @@ def align_line_breaks(
             old_rows = {}
             for number, (row, _, _) in enumerate(old_tokens):
                 old_rows.setdefault(row, [number, number])[1] = number
+            for row, (first, last) in old_rows.items():
+                if (
+                    all(number in reverse for number in range(first, last + 1))
+                    and reverse[last] - reverse[first] == last - first
+                ):
+                    spans.append((
+                        reverse[first], reverse[last],
+                        reference_lines[i1 + row].rstrip(),
+                    ))
+            inherited = {(first, last) for first, last, _ in spans}
+            token_gaps = [
+                before[left[2]:right[1]]
+                for left, right in zip(tokens, tokens[1:])
+            ]
+
+            def creates_short_fragment(proposed, changed):
+                # Inspect only rows beside newly inserted breaks. Token
+                # ranges identify the actual inherited line, even when its
+                # text occurs elsewhere. Stop counting after four words.
+                for number in changed:
+                    if (
+                        "\n" not in proposed[number]
+                        or "\n" in whitespace[number]
+                    ):
+                        continue
+                    for direction, first in ((-1, number), (1, number + 1)):
+                        last = first
+                        words = len(before[
+                            tokens[first][1]:tokens[first][2]
+                        ].split())
+                        while words <= 3 and (
+                            (direction < 0 and first > 0)
+                            or (direction > 0 and last < len(tokens) - 1)
+                        ):
+                            gap = first - 1 if direction < 0 else last
+                            raw = proposed.get(gap, token_gaps[gap])
+                            if "\n" in raw:
+                                break
+                            adjacent = first - 1 if direction < 0 else last + 1
+                            words += len(before[
+                                tokens[adjacent][1]:tokens[adjacent][2]
+                            ].split()) - (not raw)
+                            if words > 3:
+                                break
+                            if direction < 0:
+                                first -= 1
+                            else:
+                                last += 1
+                        if words <= 3 and (first, last) not in inherited:
+                            return True
+                return False
+
             for number in gaps:
                 old_number = matches[hunk].get(number)
                 if old_number is None and number + 1 in matches[hunk]:
@@ -477,14 +530,13 @@ def align_line_breaks(
                         region is not None
                         and start + tokens[number + 1][1] < region[1]
                     )
-                    if (
-                        number not in matches[hunk] and "\n" in raw
-                        and "\n" not in gaps[number] and not inside_region
-                        and len("".join(
-                            before[:tokens[number][2]].split("\n")[-1].split()
-                        )) < 10
+                    if "\n" in raw and "\n" not in gaps[number] and (
+                        not inside_region
                     ):
-                        continue
+                        proposed = dict(whitespace)
+                        proposed[number] = raw
+                        if creates_short_fragment(proposed, (number,)):
+                            continue
                     if inside_region or (
                         current_layout[3][j1 + tokens[number][0]]
                         and current_layout[3][j1 + tokens[number + 1][0]]
@@ -495,21 +547,8 @@ def align_line_breaks(
                             ending + continuation[tokens[number][0]]
                             if "\n" in raw else raw
                         )
-            for row, (first, last) in old_rows.items():
-                if (
-                    all(number in reverse for number in range(first, last + 1))
-                    and reverse[last] - reverse[first] == last - first
-                ):
-                    spans.append(
-                        (
-                            reverse[first],
-                            reverse[last],
-                            reference_lines[i1 + row].rstrip(),
-                        )
-                    )
             # }}}
             # {{{ additional breaks preserve a line without tiny new fragments
-            inherited = {line.rstrip() for line in reference_lines}
             for first, last, old_line in spans:
                 needed = range(
                     max(0, first - 1), min(len(tokens) - 1, last + 1)
@@ -543,12 +582,7 @@ def align_line_breaks(
                     continue
                 if old_line not in {line.rstrip() for line in proposed_rows}:
                     continue
-                if any(
-                    line not in original_rows
-                    and line.rstrip() not in inherited
-                    and 0 < len("".join(line.split())) < 10
-                    for line in proposed_rows
-                ):
+                if creates_short_fragment(proposed, needed):
                     continue
                 whitespace = proposed
             # }}}

{pydifftools-0.1.54 → pydifftools-0.1.56}/pydifftools/match_spaces.py

@@ -1,6 +1,7 @@
 from difflib import SequenceMatcher
 from bisect import bisect_left
 import math
+import re
 from .line_alignment import align_line_breaks
 from .wrapping_options import (
     DEFAULT_WIDTH,
@@ -117,7 +118,12 @@ def match_text(
         return (
             local
             if any(
-                len(line) > (local if joined else 1.5 * local)
+                len(line) > local and (
+                    joined or sum(
+                        match.end() > local
+                        for match in re.finditer(r"\S+", line)
+                    ) > 4
+                )
                 for line in restored.splitlines()
             )
             else fallback_width

{pydifftools-0.1.54 → pydifftools-0.1.56}/pydifftools/notebook/fast_build.py

@@ -21,6 +21,7 @@ import shutil
 import queue
 import yaml
 from pydifftools.command_registry import register_command
+from pydifftools.source_jump import jump_to_source, MAX_SOURCE_JUMP_BYTES
 from pydifftools.browser_lifecycle import (
     browser_window_is_alive,
     close_browser_window,
@@ -61,6 +62,7 @@ CODE_DISPLAY_MODES = {
 }
 # {{{ Rebuild endpoint URL (changeable parameters)
 RERUN_ENDPOINT = "/__pydifft/rerun"
+SOURCE_JUMP_ENDPOINT = "/__pydifft/jump"
 # }}}
 # {{{ Right-click "SOURCE" to rebuild a notebook through the qmdb server
 RERUN_SCRIPT = """
@@ -80,6 +82,7 @@ RERUN_SCRIPT = """
       return;
     }
     e.preventDefault();
+    e.stopImmediatePropagation();
     menu = document.createElement("div");
     menu.textContent = "Rebuild";
     menu.style.cssText = "position:fixed;z-index:2147483647;"
@@ -2210,11 +2213,32 @@ def _ensure_rerun_script(root):
     head.append(script)
 
 
+def _normalize_observation_html(text):
+    """Keep raw observation boundaries intact across paragraphs and figures."""
+    # HTML parsers close unknown inline tags at </p>. A block-capable
+    # container keeps the closing tag bounding all of the observed prose.
+    text = re.sub(
+        r"<obs\b([^>]*)>",
+        r'<div class="pydifft-observation"\1>',
+        text,
+        flags=re.IGNORECASE,
+    )
+    text = re.sub(r"</obs\s*>", "</div>", text, flags=re.IGNORECASE)
+    return text
+
+
 # also used by: tests/notebook/test_fast_build.py, which calls or
 # monkeypatches this notebook-builder entry point.
 def postprocess_html(html_path: Path, include_root: Path, resource_root: Path):
     """Replace placeholder nodes with referenced HTML bodies."""
-    root = lxml_html.fromstring(html_path.read_text())
+    root = lxml_html.fromstring(
+        _normalize_observation_html(html_path.read_text())
+    )
+    # Mark fragments before expansion to retain nested include source paths.
+    source = Path(os.path.relpath(html_path, DISPLAY_DIR)).with_suffix(".qmd")
+    for node in root.xpath("//body") or [root]:
+        if not node.get("data-pydifft-source"):
+            node.set("data-pydifft-source", source.as_posix())
     # keep processing until no include placeholders remain so nested includes
     # are fully expanded in the served HTML
     while True:
@@ -2229,7 +2253,9 @@ def postprocess_html(html_path: Path, include_root: Path, resource_root: Path):
             target = (include_root / target_rel).resolve()
             if target.exists():
                 frag_text = target.read_text()
-                frag = lxml_html.fromstring(frag_text)
+                frag = lxml_html.fromstring(
+                    _normalize_observation_html(frag_text)
+                )
                 body = frag.xpath("body")
                 if body:
                     elems = list(body[0])
@@ -2244,6 +2270,12 @@ def postprocess_html(html_path: Path, include_root: Path, resource_root: Path):
                 start_c = lxml_html.HtmlComment(f"BEGIN include {target_rel}")
                 parent.insert(idx, end_c)
                 for elem in reversed(elems):
+                    if isinstance(elem.tag, str):
+                        elem.set(
+                            "data-pydifft-source",
+                            elem.get("data-pydifft-source")
+                            or Path(target_rel).with_suffix(".qmd").as_posix(),
+                        )
                     parent.insert(idx, elem)
                 parent.insert(idx, start_c)
                 progress = True
@@ -2318,6 +2350,45 @@ def postprocess_html(html_path: Path, include_root: Path, resource_root: Path):
     # Includes contribute their bodies, so their head scripts are lost.
     # Install the handler once on the final page after expanding includes.
     _ensure_rerun_script(root)
+    # {{{ Style observations left raw when images split Pandoc inline lists
+    for obs in root.xpath('//div[@class="pydifft-observation"]'):
+        # Inline display preserves observations embedded in running prose.
+        obs.set("style", obs.get("style", "") + ";display:inline;color:blue;")
+        if not obs.xpath('./span[@class="pydifft-obs-prefix"]'):
+            metadata = " ".join(filter(None, (
+                obs.get("time") or obs.get("date"), obs.get("author")
+            )))
+            if metadata:
+                prefix = lxml_html.Element("span")
+                prefix.set("class", "pydifft-obs-prefix")
+                prefix.set("style", "font-size:85%;color:green;")
+                prefix.text = metadata + ":"
+                prefix.tail = " " + (obs.text or "")
+                obs.text = None
+                obs.insert(0, prefix)
+    # }}}
+    # {{{ Reuse CPB's context menu on every final QMDB page
+    head = root.find("head")
+    if head is None:
+        head = lxml_html.Element("head")
+        root.insert(0, head)
+    for old in root.xpath(
+        '//script[@id="pydifft-source-jump-config" or '
+        '@id="pydifft-source-jump"]'
+    ):
+        old.getparent().remove(old)
+    config = lxml_html.Element("script", id="pydifft-source-jump-config")
+    config.text = (
+        "window.pydifftSourceJumpEndpoint = "
+        + json.dumps(SOURCE_JUMP_ENDPOINT) + ";"
+    )
+    head.append(config)
+    script = lxml_html.Element("script", id="pydifft-source-jump")
+    script.text = (
+        Path(__file__).parents[1] / "flowchart" / "source_jump.js"
+    ).read_text(encoding="utf-8")
+    head.append(script)
+    # }}}
     html_path.write_text(lxml_html.tostring(root, encoding="unicode"))
 
 
@@ -2335,8 +2406,10 @@ def substitute_code_placeholders(
     if code_display not in CODE_DISPLAY_MODES:
         raise ValueError(f"unknown code display mode: {code_display}")
     parser = lxml_html.HTMLParser(encoding="utf-8")
-    tree = lxml_html.parse(str(html_path), parser)
-    root = tree.getroot()
+    root = lxml_html.document_fromstring(
+        _normalize_observation_html(html_path.read_text()), parser=parser
+    )
+    tree = root.getroottree()
     formatter = HtmlFormatter()
     head = root.xpath("//head")
     if head and not root.xpath('//style[@id="pygments-style"]'):
@@ -2379,7 +2452,9 @@ def substitute_code_placeholders(
                 frags = [details]
         # }}}
         if not missing_output and html:
-            frags += lxml_html.fragments_fromstring(html)
+            frags += lxml_html.fragments_fromstring(
+                _normalize_observation_html(html)
+            )
         elif missing_output:
             # Only show the placeholder when the notebook output entry is
             # absent so executed cells that intentionally produce no output
@@ -2499,6 +2574,41 @@ def watch_and_serve(
             super().__init__(*args, directory=str(DISPLAY_DIR), **kwargs)
 
         def do_POST(self):
+            if self.path == SOURCE_JUMP_ENDPOINT:
+                # {{{ Dispatch the shared menu to the fragment's QMD source
+                origin = self.headers.get("Origin")
+                if origin and origin.split("://", 1)[-1] != self.headers.get(
+                    "Host"
+                ):
+                    self.send_error(403)
+                    return
+                try:
+                    length = int(self.headers.get("Content-Length", "0"))
+                    if not 0 < length <= MAX_SOURCE_JUMP_BYTES:
+                        raise ValueError(length)
+                    request = json.loads(self.rfile.read(length))
+                    source = (PROJECT_ROOT / request["source"]).resolve()
+                    source.relative_to(PROJECT_ROOT.resolve())
+                    if source.suffix != ".qmd":
+                        raise ValueError("Expected a QMD source")
+                    phrase = request["phrase"]
+                    if not isinstance(phrase, str):
+                        raise ValueError("Expected source text")
+                except (ValueError, KeyError, TypeError):
+                    self.send_error(400)
+                    return
+                try:
+                    jump_to_source(source, phrase)
+                except (
+                    OSError, subprocess.SubprocessError, ValueError
+                ) as exc:
+                    print(f"pydifft source jump failed: {exc}", flush=True)
+                    self.send_error(500)
+                    return
+                self.send_response(204)
+                self.end_headers()
+                return
+                # }}}
             # {{{ Re-run the notebook behind a right-clicked SOURCE label
             if self.path != RERUN_ENDPOINT:
                 self.send_error(404)

{pydifftools-0.1.54 → pydifftools-0.1.56}/pydifftools/wrap_sentences.py

@@ -880,9 +880,14 @@ def wr(
             fp.write(result)
 
 
-def check_prose(content, wrapnumber, punctuation_slop, line_start=1):
+def check_prose(
+    content, wrapnumber, punctuation_slop, line_start=1, overflow_words=0,
+):
     """Report source lines in `content` that break wr's rules.
 
+    Diff alignment can set overflow_words to tolerate that many words ending
+    beyond the character width. Ordinary wrapping checks use a strict limit.
+
     Checks mirror 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
@@ -953,7 +958,18 @@ def check_prose(content, wrapnumber, punctuation_slop, line_start=1):
                                 + len(words[actual_end])
                                 - positions[fragment_offset]
                             )
-                            if actual_end > wr_end:
+                            # Diff alignment can keep a few extra words to
+                            # avoid moving the sentence tail onto a new line.
+                            # Count against the character limit, independently
+                            # of an earlier preferred punctuation break.
+                            excess = sum(
+                                positions[j] + len(words[j])
+                                - positions[fragment_offset] > wrapnumber
+                                for j in range(fragment_offset, actual_end + 1)
+                            )
+                            if actual_end > wr_end and not (
+                                overflow_words and 0 < excess <= overflow_words
+                            ):
                                 overflow = words[wr_end + 1]
                                 rule = (
                                     "line too long"
@@ -1134,7 +1150,7 @@ def _mask_html_comments(content, initially_open=False):
 
 
 def markdown_lint_issues_from_text(
-    content, wrapnumber=45, punctuation_slop=20
+    content, wrapnumber=45, punctuation_slop=20, overflow_words=0,
 ):
     """Return Markdown writing issues, including unfinished source spans."""
     masked_content = _mask_html_comments(content)
@@ -1149,7 +1165,9 @@ def markdown_lint_issues_from_text(
         for line, width, span in _iter_block_spans(
             markdown_blocks(prose_content), wrapnumber
         )
-        for issue in check_prose(span, width, punctuation_slop, line)
+        for issue in check_prose(
+            span, width, punctuation_slop, line, overflow_words,
+        )
     ]
     issues.extend(
         (issue["line"], issue["message"])
@@ -1523,7 +1541,8 @@ 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
+            content, wrapnumber=wrapnumber, punctuation_slop=punctuation_slop,
+            overflow_words=4 if baseline is not None else 0,
         )
         fixable = {}
         for line_number, message in issues:

{pydifftools-0.1.54 → pydifftools-0.1.56}/pyproject.toml

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

{pydifftools-0.1.54 → pydifftools-0.1.56}/tests/test_forward_search.py

@@ -1,3 +1,4 @@
+import json
 import io
 import queue
 import socket
@@ -380,6 +381,7 @@ def test_second_qmdb_takes_next_ports_and_accepts_rebuild(
     build_calls = []
     http_ports = []
     handlers = []
+    jumps = []
     urls = []
     httpd = FakeHttpServer()
 
@@ -424,6 +426,20 @@ def test_second_qmdb_takes_next_ports_and_accepts_rebuild(
             handler.do_POST()
             assert responses == [202]
             assert built.wait(timeout=2)
+            handler.path = fast_build.SOURCE_JUMP_ENDPOINT
+            for source, status in [
+                ("doc.qmd", 204), ("../outside.qmd", 400),
+                ("doc.html", 400),
+            ]:
+                body = json.dumps({
+                    "source": source, "phrase": "Source text."
+                }).encode()
+                handler.headers["Content-Length"] = str(len(body))
+                handler.rfile = io.BytesIO(body)
+                handler.send_error = responses.append
+                handler.do_POST()
+                assert responses[-1] == status
+            assert jumps == [(tmp_path / "doc.qmd", "Source text.")]
             return False
 
     class Observer:
@@ -445,6 +461,10 @@ def test_second_qmdb_takes_next_ports_and_accepts_rebuild(
         classmethod(lambda cls, **_k: Machine()),
     )
     monkeypatch.setattr(fast_build, "load_rendered_files", lambda: [])
+    monkeypatch.setattr(
+        fast_build, "jump_to_source",
+        lambda source, phrase: jumps.append((source, phrase)),
+    )
     monkeypatch.setattr(fast_build, "ThreadingHTTPServer", fake_http_server)
     monkeypatch.setattr(fast_build, "_serve_forever", lambda _httpd: None)
     monkeypatch.setattr(fast_build, "BrowserReloader", Reloader)