pyDiffTools 0.1.57__tar.gz → 0.1.59__tar.gz

{pydifftools-0.1.57/pyDiffTools.egg-info → pydifftools-0.1.59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDiffTools
-Version: 0.1.57
+Version: 0.1.59
 Summary: Diff tools
 Author: J M Franck
 License: Copyright (c) 2015, jmfranck
@@ -274,10 +274,20 @@ included are (listed in order of fun/utility):
   retaining the exact command of an existing global ``gd`` alias. If none
   is configured, it installs ``!f() { pydifft gd "$@"; }; f``.
   Configure ``difftool.mygvim.cmd`` for the GUI diff tool.
-- ``pydifft --add_to_git gd pd tree mergein`` installs any selected subset
+- ``pydifft --add_to_git gd pd tree mergein reattach`` installs any selected subset
   of these global Git aliases in one invocation. Installation appears
   alongside the subcommands in root help; the former per-command
   ``--install`` and ``--add-to-git`` flags have been removed.
+- ``pydifft reattach [--path DIRECTORY]`` attaches detached checkouts to
+  branches pointing at exactly their current commits, including initialized
+  submodules recursively. Remote-only matches create local tracking branches.
+  It never resets existing branches or pulls newer commits. With several
+  matches it prefers the origin default branch when possible, otherwise it
+  reports ambiguity and leaves the checkout detached. A local branch with
+  the required name pointing elsewhere is preserved. ``--dry-run`` previews
+  changes, ``--no-recursive`` limits the operation to one repository, and
+  ``--fetch`` refreshes remote refs before matching. Install the global
+  ``git reattach`` alias with ``pydifft --add_to_git reattach``.
 - ``pydifft mergein BRANCH [--remote REMOTE]`` updates an incoming local
   branch without switching branches, then merges it into the current
   branch. Install ``git mergein`` with ``pydifft --add_to_git mergein``.

{pydifftools-0.1.57 → pydifftools-0.1.59}/README.rst

@@ -219,10 +219,20 @@ included are (listed in order of fun/utility):
   retaining the exact command of an existing global ``gd`` alias. If none
   is configured, it installs ``!f() { pydifft gd "$@"; }; f``.
   Configure ``difftool.mygvim.cmd`` for the GUI diff tool.
-- ``pydifft --add_to_git gd pd tree mergein`` installs any selected subset
+- ``pydifft --add_to_git gd pd tree mergein reattach`` installs any selected subset
   of these global Git aliases in one invocation. Installation appears
   alongside the subcommands in root help; the former per-command
   ``--install`` and ``--add-to-git`` flags have been removed.
+- ``pydifft reattach [--path DIRECTORY]`` attaches detached checkouts to
+  branches pointing at exactly their current commits, including initialized
+  submodules recursively. Remote-only matches create local tracking branches.
+  It never resets existing branches or pulls newer commits. With several
+  matches it prefers the origin default branch when possible, otherwise it
+  reports ambiguity and leaves the checkout detached. A local branch with
+  the required name pointing elsewhere is preserved. ``--dry-run`` previews
+  changes, ``--no-recursive`` limits the operation to one repository, and
+  ``--fetch`` refreshes remote refs before matching. Install the global
+  ``git reattach`` alias with ``pydifft --add_to_git reattach``.
 - ``pydifft mergein BRANCH [--remote REMOTE]`` updates an incoming local
   branch without switching branches, then merges it into the current
   branch. Install ``git mergein`` with ``pydifft --add_to_git mergein``.

{pydifftools-0.1.57 → pydifftools-0.1.59/pyDiffTools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyDiffTools
-Version: 0.1.57
+Version: 0.1.59
 Summary: Diff tools
 Author: J M Franck
 License: Copyright (c) 2015, jmfranck
@@ -274,10 +274,20 @@ included are (listed in order of fun/utility):
   retaining the exact command of an existing global ``gd`` alias. If none
   is configured, it installs ``!f() { pydifft gd "$@"; }; f``.
   Configure ``difftool.mygvim.cmd`` for the GUI diff tool.
-- ``pydifft --add_to_git gd pd tree mergein`` installs any selected subset
+- ``pydifft --add_to_git gd pd tree mergein reattach`` installs any selected subset
   of these global Git aliases in one invocation. Installation appears
   alongside the subcommands in root help; the former per-command
   ``--install`` and ``--add-to-git`` flags have been removed.
+- ``pydifft reattach [--path DIRECTORY]`` attaches detached checkouts to
+  branches pointing at exactly their current commits, including initialized
+  submodules recursively. Remote-only matches create local tracking branches.
+  It never resets existing branches or pulls newer commits. With several
+  matches it prefers the origin default branch when possible, otherwise it
+  reports ambiguity and leaves the checkout detached. A local branch with
+  the required name pointing elsewhere is preserved. ``--dry-run`` previews
+  changes, ``--no-recursive`` limits the operation to one repository, and
+  ``--fetch`` refreshes remote refs before matching. Install the global
+  ``git reattach`` alias with ``pydifft --add_to_git reattach``.
 - ``pydifft mergein BRANCH [--remote REMOTE]`` updates an incoming local
   branch without switching branches, then merges it into the current
   branch. Install ``git mergein`` with ``pydifft --add_to_git mergein``.

{pydifftools-0.1.57 → pydifftools-0.1.59}/pyDiffTools.egg-info/SOURCES.txt

@@ -70,6 +70,7 @@ pydifftools/git_gd.py
 pydifftools/git_gd_history.py
 pydifftools/git_gd_image.py
 pydifftools/git_gd_qt.py
+pydifftools/git_reattach.py
 pydifftools/html_comments.py
 pydifftools/html_uncomments.py
 pydifftools/line_alignment.py
@@ -116,6 +117,7 @@ tests/test_git_gd_image.py
 tests/test_git_gd_qt.py
 tests/test_git_mergein.py
 tests/test_git_pdf_diff.py
+tests/test_git_reattach.py
 tests/test_line_alignment.py
 tests/test_pdf_diff.py
 tests/test_qt_lifecycle.py

{pydifftools-0.1.57 → pydifftools-0.1.59}/pydifftools/browser_lifecycle.py

@@ -4,8 +4,7 @@ import shutil
 import subprocess
 import sys
 
-# callbacks that run before any dialog needs the user; cpb registers one
-# that closes its live preview, so issues are dealt with before it reopens
+# Optional callbacks for callers that need to prepare for a dialog.
 dialog_callbacks = []
 
 
@@ -97,7 +96,7 @@ def start_browser():
 
 
 def prepare_for_dialog():
-    """Let watch commands close their preview before a dialog appears."""
+    """Notify registered callers before a dialog appears."""
     for callback in list(dialog_callbacks):
         callback()
 
@@ -108,6 +107,10 @@ def browser_window_is_alive(browser):
     # the same shutdown behavior when a user closes the browser window.
     # Do not probe with execute_script here: page navigations can briefly
     # interrupt script execution even while the window is still open.
+    from selenium.common.exceptions import (
+        InvalidSessionIdException, NoSuchWindowException, WebDriverException,
+    )
+
     if browser is None:
         return False
     try:
@@ -115,10 +118,14 @@ def browser_window_is_alive(browser):
         if not handles:
             return False
         return True
-    except Exception:
+    except (InvalidSessionIdException, NoSuchWindowException):
         return False
+    except WebDriverException:
+        # A transient command failure is not evidence of a closed window.
+        return True
 
 
+# also used by: continuous.py, notebook/fast_build.py, flowchart/watch_graph.py
 def close_browser_window(browser):
     # Close a Selenium browser session and ignore errors from already-closed
     # windows so cleanup paths stay simple.
@@ -137,20 +144,93 @@ def forward_search_in_browser(browser, search_text):
     if browser is None or not search_text:
         return False
     found = browser.execute_script(
-        """
-        var searchText = arguments[0];
-        if (!window.find) {
-            return false;
+        r"""
+        const searchText = arguments[0];
+        let didFind = window.find && window.find(searchText);
+        // Match across inline elements, entities, and rendered references.
+        if (!didFind) {
+            const escape = text => text.replace(
+                /[.*+?^${}()|[\]\\]/g, '\\$&'
+            ).replace(/\s+/g, '\\s+');
+            const reference =
+                /\[?@([a-z]{2,4}):(\w(?:[\w:./-]*[\w/-])?)\]?/gi;
+            let pattern = '', cursor = 0, match;
+            let valid = true;
+            while ((match = reference.exec(searchText))) {
+                pattern += escape(searchText.slice(cursor, match.index));
+                const id = match[1].toLowerCase() + ':' + match[2];
+                const link = Array.from(
+                    document.querySelectorAll('a[href]')
+                ).find(a => a.getAttribute('href') === '#' + id);
+                const target = document.getElementById(id);
+                if (!link && !target) {
+                    valid = false;
+                    break;
+                }
+                // Unlinked crossrefs still render a numeric label. For a
+                // reference alone, select its target rather than guessing
+                // which occurrence of that number the user intended.
+                if (!link && searchText.trim() === match[0]) {
+                    const range = document.createRange();
+                    range.selectNodeContents(target);
+                    const selection = window.getSelection();
+                    selection.removeAllRanges();
+                    selection.addRange(range);
+                    didFind = true;
+                    valid = false;
+                    break;
+                }
+                pattern += '(?:(?:eq(?:uation)?|fig(?:ure)?|tab(?:le)?|' +
+                    'sec(?:tion)?|ch(?:apter)?|lst|listing)s?\\.?\\s*)?' +
+                    (link ? escape(link.textContent.trim()) :
+                        '\\(?\\d+(?:[.–-]\\d+)*[a-z]?\\)?');
+                cursor = reference.lastIndex;
+            }
+            pattern += escape(searchText.slice(cursor));
+            if (valid) {
+                const walker = document.createTreeWalker(
+                    document.body, NodeFilter.SHOW_TEXT
+                );
+                const nodes = [], starts = [];
+                let text = '', node;
+                while ((node = walker.nextNode())) {
+                    if (node.parentElement.closest(
+                        'script, style, noscript, [hidden]'
+                    ) || !node.parentElement.getClientRects().length) {
+                        continue;
+                    }
+                    starts.push(text.length);
+                    nodes.push(node);
+                    text += node.textContent;
+                }
+                const result = new RegExp(pattern, 'i').exec(text);
+                if (result && result[0].length) {
+                    const start = result.index;
+                    const end = start + result[0].length;
+                    const first = starts.findIndex((offset, i) =>
+                        offset + nodes[i].length > start
+                    );
+                    const last = starts.findIndex((offset, i) =>
+                        offset + nodes[i].length >= end
+                    );
+                    const range = document.createRange();
+                    range.setStart(nodes[first], start - starts[first]);
+                    range.setEnd(nodes[last], end - starts[last]);
+                    const selection = window.getSelection();
+                    selection.removeAllRanges();
+                    selection.addRange(range);
+                    didFind = true;
+                }
+            }
         }
-        var didFind = window.find(searchText);
         if (didFind && window.getSelection) {
-            var selection = window.getSelection();
+            const selection = window.getSelection();
             if (selection.rangeCount > 0) {
-                var rect = selection.getRangeAt(0).getBoundingClientRect();
+                const rect = selection.getRangeAt(0).getBoundingClientRect();
                 window.scrollBy(0, rect.top - window.innerHeight / 3);
             }
         }
-        return didFind;
+        return Boolean(didFind);
         """,
         search_text,
     )

{pydifftools-0.1.57 → pydifftools-0.1.59}/pydifftools/command_line.py

@@ -1,6 +1,7 @@
 # PYTHON_ARGCOMPLETE_OK
 
 import argparse
+import html
 import sys
 import os
 import gzip
@@ -35,6 +36,7 @@ from .comment_functions import matchingbrackets
 from .copy_files import copy_image_files
 from .searchacro import replace_acros
 from .rearrange_tex import run as rearrange_tex_run
+from .git_reattach import reattach  # registers branch reattachment
 from .git_gd import gd  # registers git difftool review command
 from .pdf_diff import pd, git_pd  # registers PDF diff command
 from .git_aliases import (
@@ -554,26 +556,14 @@ def fs(arguments):
 )
 def mfs(text):
     # Normalize markdown-specific markup so search phrases match rendered text.
-    search_text = text
-    marker_match = re.search(r"(?i)@[a-z]{2,4}:", search_text)
-    if marker_match:
-        search_text = search_text[: marker_match.start()]
-    search_text = re.sub(r"\[@[^\]]+\]", " ", search_text)
-    # Strip paired markup delimiters (bold/italic, strikethrough,
-    # superscript/subscript). These delimiters hug the text they wrap with no
-    # space in the rendered output (e.g. "x^2^" renders as "x2"), so they are
-    # dropped rather than replaced with a space. Plain str.replace is used
-    # (not regex) so this is linear time regardless of how many delimiter
-    # characters appear.
-    search_text = (
-        search_text.replace("**", "")
-        .replace("__", "")
-        .replace("~~", "")
-        .replace("*", "")
-        .replace("_", "")
-        .replace("~", "")
-        .replace("^", "")
-    )
+    search_text = html.unescape(text)
+    search_text = re.sub(r"\[@(?![a-z]{2,4}:)[^\]]+\]", " ", search_text,
+                         flags=re.IGNORECASE)
+    # Keep reference IDs intact while removing surrounding Markdown markup.
+    parts = re.split(r"(?i)(@[a-z]{2,4}:\w(?:[\w:./-]*[\w/-])?)", search_text)
+    for index in range(0, len(parts), 2):
+        parts[index] = re.sub(r"[*_~^]", "", parts[index])
+    search_text = "".join(parts)
     search_text = re.sub(r"\s+", " ", search_text).strip()
     if not search_text:
         search_text = text.strip()
@@ -620,7 +610,8 @@ def mfs(text):
             if not filename.endswith(".md"):
                 continue
             with open(filename, encoding="utf-8") as fp:
-                if search_text in fp.read():
+                source_text = fp.read()
+                if text.strip() in source_text or search_text in source_text:
                     matching_files.append(filename)
         if len(matching_files) == 0:
             raise RuntimeError(
@@ -919,7 +910,7 @@ def build_parser():
     # argparse does not validate REMAINDER choices; main checks them first.
     subparsers.container.add_argument(
         "--add_to_git", nargs=argparse.REMAINDER, choices=list(GIT_ALIASES),
-        help=("Install one or more global Git aliases: gd, pd, tree, mergein "
+        help=("Install one or more global Git aliases: gd, pd, tree, mergein, reattach "
               "(without a subcommand)."),
     )
     for name, spec in _COMMAND_SPECS.items():

{pydifftools-0.1.57 → pydifftools-0.1.59}/pydifftools/continuous.py

@@ -11,6 +11,7 @@ import re
 import shutil
 import threading
 import queue
+import signal
 import traceback
 import tempfile
 from pathlib import Path
@@ -27,7 +28,6 @@ from .comment_migration import prepare_comment_source
 from .browser_lifecycle import (
     browser_window_is_alive,
     close_browser_window,
-    dialog_callbacks,
     forward_search_in_browser,
     prepare_for_dialog,
     start_browser,
@@ -1231,11 +1231,16 @@ def cpb(
         daemon=True,
     )
     chrome = None
-    scroll_position = 0
     observer = None
     observer_started = False
     socket_thread_started = False
     source_jump_server = None
+    previous_sigterm = None
+    if threading.current_thread() is threading.main_thread():
+        def stop_cpb(_signum, _frame):
+            raise KeyboardInterrupt
+
+        previous_sigterm = signal.signal(signal.SIGTERM, stop_cpb)
 
     try:
         # Bind and serve before any build or browser work. This makes the fixed
@@ -1321,29 +1326,18 @@ def cpb(
         # and never be reported as a change.
         chrome.get("file://" + os.path.abspath(html_file))
 
-        def close_for_dialog():
-            # a rebuild needs the user, so close the preview while the
-            # issues are dealt with; it reopens once the rebuild is done
-            nonlocal chrome, scroll_position
-            if chrome is not None:
-                # sessionStorage does not survive quitting the browser.
-                scroll_position = chrome.execute_script(
-                    "return window.scrollY;"
-                )
-                close_browser_window(chrome)
-                chrome = None
-
-        dialog_callbacks.append(close_for_dialog)
         rebuild_pending = False
         stable_signature = None
         stable_since = None
+        listener_warning_shown = False
         while True:
-            if not socket_thread.is_alive():
-                raise RuntimeError(
-                    "The cpb forward-search listener stopped unexpectedly; "
-                    "closing the preview instead of leaving an "
-                    "undiscoverable session."
+            if not socket_thread.is_alive() and not listener_warning_shown:
+                print(
+                    "pydifft cpb: forward-search listener stopped; "
+                    "forward search is unavailable. The preview remains open.",
+                    file=sys.stderr,
                 )
+                listener_warning_shown = True
             # Browser closure is terminal. Source-file and build failures do
             # not affect browser ownership or observer lifetime.
             if not browser_window_is_alive(chrome):
@@ -1352,7 +1346,11 @@ def cpb(
             for queued_search in drain_forward_search_queue(search_queue):
                 search_text = queued_search.strip()
                 if search_text:
-                    forward_search_in_browser(chrome, search_text)
+                    try:
+                        forward_search_in_browser(chrome, search_text)
+                    except WebDriverException as exc:
+                        print(f"pydifft cpb: forward search failed: {exc}",
+                              file=sys.stderr)
 
             saw_source_event = False
             while not change_queue.empty():
@@ -1450,30 +1448,16 @@ def cpb(
                                 traceback.print_exc()
                         else:
                             handled_signature = attempted_signature
-                            if chrome is not None:
-                                if not browser_window_is_alive(chrome):
-                                    break
-                                try:
-                                    chrome.refresh()
-                                except WebDriverException:
-                                    print(
-                                        "pydifft cpb: Browser is no longer "
-                                        "available; stopping without "
-                                        "reopening it.",
-                                        file=sys.stderr,
-                                    )
-                                    break
-                        if chrome is None:
-                            # {{{ reopen the preview a dialog closed
-                            chrome = start_browser()
-                            chrome.get(
-                                "file://" + os.path.abspath(html_file)
-                            )
-                            chrome.execute_script(
-                                "window.scrollTo(0, arguments[0]);",
-                                scroll_position,
-                            )
-                            # }}}
+                            if not browser_window_is_alive(chrome):
+                                break
+                            try:
+                                chrome.refresh()
+                            except WebDriverException as exc:
+                                print(
+                                    "pydifft cpb: preview refresh failed: "
+                                    f"{exc}",
+                                    file=sys.stderr,
+                                )
             # }}}
             time.sleep(MAIN_LOOP_INTERVAL_SECONDS)
     except KeyboardInterrupt:
@@ -1489,7 +1473,8 @@ def cpb(
         if socket_thread_started:
             socket_thread.join()
         close_browser_window(chrome)
-        dialog_callbacks.clear()
+        if previous_sigterm is not None:
+            signal.signal(signal.SIGTERM, previous_sigterm)
 
 
 if __name__ == "__main__":

{pydifftools-0.1.57 → pydifftools-0.1.59}/pydifftools/git_aliases.py

@@ -11,10 +11,12 @@ GIT_ALIASES = {
     "gd": '!f() { pydifft gd "$@"; }; f',
     "pd": '!f() { pydifft pd --git "$@"; }; f',
     "tree": '!f() { pydifft tree "$@"; }; f',
+    "reattach": '!f() { pydifft reattach "$@"; }; f',
     "mergein": '!f() { pydifft mergein "$@"; }; f',
 }
 
 
+# also used by: pydifftools/command_line.py for global CLI alias installation.
 def install_git_alias(name, command, preserve_existing=False):
     """Install an alias and its completion, optionally retaining its value."""
     if preserve_existing:

pydifftools-0.1.59/pydifftools/git_reattach.py

@@ -0,0 +1,145 @@
+"""Attach detached checkouts without changing the selected commits."""
+
+from pathlib import Path
+import subprocess
+
+from .command_registry import register_command
+
+
+def _git(path, *args, allowed=(0,)):
+    result = subprocess.run(
+        ["git", "-C", str(path), *args], capture_output=True, text=True,
+    )
+    if result.returncode not in allowed:
+        raise RuntimeError(result.stderr.strip() or "Git command failed")
+    return result.stdout.rstrip("\n")
+
+
+@register_command(
+    "reattach detached repositories to matching local or remote branches",
+    description=(
+        "Keep each checkout's current commit and attach a branch whose tip "
+        "matches it exactly. Includes initialized submodules recursively. "
+        "A remote-only match creates a local tracking branch. Existing "
+        "branches are never reset. Ambiguous or unmatched checkouts stay "
+        "detached. Cached remote branches are used unless --fetch is given."
+    ),
+    help={
+        "path": "Repository or a directory inside it (default: current).",
+        "no_recursive": "Only inspect this repository, not its submodules.",
+        "fetch": "Fetch remote branches before looking for matches.",
+        "dry_run": "Show proposed switches without changing anything.",
+    },
+)
+def reattach(path=".", no_recursive=False, fetch=False, dry_run=False):
+    """Find exact branch-tip matches, preserving commits and working files."""
+    if fetch and dry_run:
+        raise SystemExit("reattach: --fetch cannot be used with --dry-run")
+    try:
+        root = Path(_git(path, "rev-parse", "--show-toplevel"))
+        paths = [root]
+        if not no_recursive:
+            children = _git(
+                root, "submodule", "foreach", "--quiet", "--recursive",
+                'printf "%s\\0" "$PWD"',
+            )
+            paths.extend(Path(p) for p in children.split("\0") if p)
+        failed = False
+        for checkout in paths:
+            label = str(checkout)
+            try:
+                if _git(
+                    checkout, "symbolic-ref", "--quiet", "HEAD",
+                    allowed=(0, 1),
+                ):
+                    print(f"{label}: already on a branch; unchanged")
+                    continue
+                if fetch:
+                    _git(checkout, "fetch", "--all", "--prune",
+                         "--no-recurse-submodules")
+                head = _git(checkout, "rev-parse", "HEAD")
+                # {{{ ask Git for exact matches, excluding symbolic refs
+                refs = _git(
+                    checkout, "for-each-ref",
+                    "--format=%(refname)%00%(symref)", "--points-at", head,
+                    "refs/heads/", "refs/remotes/",
+                )
+                matches = [
+                    line.split("\0")[0] for line in refs.splitlines()
+                    if line.endswith("\0")
+                ]
+                local = [r for r in matches if r.startswith("refs/heads/")]
+                remote = [r for r in matches
+                          if r.startswith("refs/remotes/")]
+                default = _git(
+                    checkout, "symbolic-ref", "--quiet",
+                    "refs/remotes/origin/HEAD", allowed=(0, 1),
+                )
+                default_name = default.removeprefix("refs/remotes/origin/")
+                branch = None
+                upstream = None
+                if local:
+                    preferred = "refs/heads/" + default_name
+                    if preferred in local:
+                        branch = default_name
+                    elif len(local) == 1:
+                        branch = local[0].removeprefix("refs/heads/")
+                elif remote:
+                    # Derive names from configured remotes, retaining slashes
+                    # in branch names and allowing slashes in remote names.
+                    remotes = sorted(
+                        _git(checkout, "remote").splitlines(),
+                        key=len, reverse=True,
+                    )
+                    candidates = {}
+                    for ref in remote:
+                        for name in remotes:
+                            prefix = f"refs/remotes/{name}/"
+                            if ref.startswith(prefix):
+                                candidates[ref] = ref[len(prefix):]
+                                break
+                    if default in candidates:
+                        upstream = default
+                    elif len(candidates) == 1:
+                        upstream = next(iter(candidates))
+                    elif len(set(candidates.values())) == 1:
+                        name = next(iter(candidates.values()))
+                        preferred = "refs/remotes/origin/" + name
+                        if preferred in candidates:
+                            upstream = preferred
+                    if upstream:
+                        branch = candidates[upstream]
+                        existing = _git(
+                            checkout, "show-ref", "--verify", "--hash",
+                            f"refs/heads/{branch}", allowed=(0, 1, 128),
+                        )
+                        if existing:
+                            print(
+                                f"{label}: local {branch} points elsewhere; "
+                                "left detached without resetting it"
+                            )
+                            continue
+                # }}}
+                if branch is None:
+                    reason = "ambiguous branch matches" if matches else (
+                        "no branch tip matches this commit"
+                    )
+                    print(f"{label}: {reason}; left detached")
+                    continue
+                action = "create tracking branch" if upstream else "switch to"
+                print(f"{label}: {action} {branch}")
+                if not dry_run:
+                    if upstream:
+                        _git(checkout, "switch", "--track", "-c", branch,
+                             upstream)
+                    else:
+                        _git(checkout, "switch", "--no-guess", "--", branch)
+                    if _git(checkout, "rev-parse", "HEAD") != head:
+                        raise RuntimeError("branch moved during reattachment")
+            except RuntimeError as exc:
+                print(f"{label}: {exc}")
+                failed = True
+        if failed:
+            raise SystemExit(1)
+    except (OSError, RuntimeError) as exc:
+        raise SystemExit(f"reattach: {exc}") from None

{pydifftools-0.1.57 → pydifftools-0.1.59}/pydifftools/wrap_sentences.py

@@ -703,7 +703,14 @@ def wrap_prose(
     """Wrap prose with sentence and punctuation rules for both commands."""
     output = []
     # Keep paragraph separators and the boundary newlines next to exclusions.
-    for paragraph in PARAGRAPH_SPLIT.split(text):
+    paragraphs = PARAGRAPH_SPLIT.split(text)
+    if filetype == "markdown":
+        # Hard line breaks are source boundaries, not wrappable whitespace.
+        paragraphs = [
+            part for paragraph in paragraphs
+            for part in re.split(r"( {2,}\r?\n)", paragraph)
+        ]
+    for paragraph in paragraphs:
         if not paragraph.strip():
             output.append(paragraph)
             continue
@@ -1001,7 +1008,9 @@ def check_prose(
             if k < len(separators):
                 sep = separators[k]
                 offset += len(sep)
-                if sep == " " and (
+                if sep == " " and not re.match(
+                    r"[ \t]*\r?\n", stripped[offset:]
+                ) and (
                     k + 1 >= len(sentences) or sentences[k + 1].strip()
                 ):
                     issue_line = para_line + stripped.count(

{pydifftools-0.1.57 → pydifftools-0.1.59}/pyproject.toml

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