pyDiffTools 0.1.55__tar.gz → 0.1.56__tar.gz

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

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

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

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

{pydifftools-0.1.55 → 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.55 → 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.55 → pydifftools-0.1.56}/pydifftools/line_alignment.py

@@ -463,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]:
@@ -481,16 +533,9 @@ def align_line_breaks(
                     if "\n" in raw and "\n" not in gaps[number] and (
                         not inside_region
                     ):
-                        original_rows = set(render(whitespace).splitlines())
                         proposed = dict(whitespace)
                         proposed[number] = raw
-                        inherited = {line.rstrip() for line in reference_lines}
-                        if any(
-                            line not in original_rows
-                            and line.rstrip() not in inherited
-                            and 0 < len(line.split()) <= 3
-                            for line in render(proposed).splitlines()
-                        ):
+                        if creates_short_fragment(proposed, (number,)):
                             continue
                     if inside_region or (
                         current_layout[3][j1 + tokens[number][0]]
@@ -502,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)
@@ -550,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(line.split()) <= 3
-                    for line in proposed_rows
-                ):
+                if creates_short_fragment(proposed, needed):
                     continue
                 whitespace = proposed
             # }}}

{pydifftools-0.1.55 → 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.55 → pydifftools-0.1.56}/pyproject.toml

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

{pydifftools-0.1.55 → 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)

{pydifftools-0.1.55 → pydifftools-0.1.56}/tests/test_line_alignment.py

@@ -524,6 +524,61 @@ def test_optional_preservation_break_does_not_strand_a_tiny_fragment():
     assert result["aligned"] == current
 
 
+@pytest.mark.parametrize("comma", ["", ","])
+@pytest.mark.parametrize("location", ["elsewhere", "same_hunk"])
+def test_repeated_short_line_does_not_exempt_an_inserted_fragment(
+    comma, location,
+):
+    citation = "(@fig:TEMPOOH_vs_TEMPOSO4(b))"
+    if location == "elsewhere":
+        old_prefix = new_prefix = "which\n\nUnchanged anchor.\n\n"
+    else:
+        old_prefix = "which\noriginal opening words\n"
+        new_prefix = "which changed opening words\n"
+    reference = (
+        old_prefix + citation + comma + "\nlikely arises from larger\n"
+    )
+    current = (
+        new_prefix + citation + ",\nwhich likely arises from larger\n"
+    )
+    results = align_line_breaks(reference, current, width=55)
+    for result in reversed(results):
+        current = (
+            current[:result["start"]] + result["aligned"]
+            + current[result["stop"]:]
+        )
+    assert citation + ",\nwhich likely arises from larger\n" in current
+
+
+def test_matched_short_line_can_still_be_restored():
+    reference = (
+        "Former opening has four words\nwhich\n"
+        "following stable words remain here\n"
+    )
+    current = (
+        "Changed opening has four words which "
+        "following stable words remain here\n"
+    )
+    (result,) = align_line_breaks(reference, current)
+    assert result["aligned"] == reference.replace("Former", "Changed")
+
+
+@pytest.mark.parametrize("fragment,restore", [
+    (r"$\alpha\beta\gamma$", False),
+    ("link){#one two three four}", True),
+])
+def test_fragment_word_count_handles_math_and_attribute_tokens(
+    fragment, restore,
+):
+    reference = "Former opening\nstable reference words\nformer closing.\n"
+    current = (
+        fragment
+        + " stable reference words rewritten closing has four words.\n"
+    )
+    (result,) = align_line_breaks(reference, current)
+    assert ("\nstable reference words\n" in result["aligned"]) == restore
+
+
 @pytest.mark.parametrize("count", [1, 2, 3, 4])
 @pytest.mark.parametrize("side", ["before", "after"])
 def test_optional_break_uses_word_count_for_long_fragments(count, side):

pydifftools-0.1.56/tests/test_qt_lifecycle.py

@@ -0,0 +1,51 @@
+from pathlib import Path
+import subprocess
+import sys
+
+
+def test_qt_windows_are_deleted_before_application_shutdown(tmp_path):
+    conftest = Path(__file__).with_name("conftest.py").read_text()
+    (tmp_path / "conftest.py").write_text(
+        conftest
+        + """
+
+def pytest_sessionfinish(session, exitstatus):
+    from PySide6.QtWidgets import QApplication
+    assert QApplication.instance() is None
+"""
+    )
+    (tmp_path / "test_windows.py").write_text(
+        """
+from PySide6.QtWidgets import QApplication, QPushButton
+from shiboken6 import isValid
+
+retained_windows = []
+retained_applications = []
+
+
+def test_closed_window():
+    application = QApplication.instance() or QApplication([])
+    retained_applications.append(application)
+    window = QPushButton("Close")
+    # Keep both a Python reference and a signal closure alive past the test.
+    window.clicked.connect(lambda: window.close())
+    window.close()
+    retained_windows.append(window)
+    assert isValid(application)
+
+
+def test_previous_window_is_deleted():
+    assert not isValid(retained_windows[0])
+    assert QApplication.instance() is retained_applications[0]
+    assert isValid(retained_applications[0])
+"""
+    )
+    completed = subprocess.run(
+        [sys.executable, "-m", "pytest", "-q", str(tmp_path)],
+        cwd=tmp_path,
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+    assert completed.returncode == 0, completed.stdout + completed.stderr
+    assert "2 passed" in completed.stdout