QCodeSitter 0.1.0__py3-none-any.whl

QCodeSitter/cursors/iterator.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import TYPE_CHECKING
+
+from Qt import QtGui
+
+from .state import CursorState, primary_first
+
+if TYPE_CHECKING:
+    from ..code_editor import CodeEditor
+    from .tracked import TrackedCursor
+
+
+class CursorIterator:
+    """Runs an edit at every cursor, in document order, as one undo step
+
+    Each pass of `iterate_cursors` moves a single cursor to each cursor state.
+    Every state follows the edits made at the other cursors, the way a
+    QTextCursor does.
+
+    A pass can mark a cursor as completed, and later passes in the same
+    `session` skip it. That lets behaviors handle some cursors and leave the
+    rest to the next handler. Replacing the editor's cursors during a session
+    starts over with the new cursors, none of them completed, and ends the
+    pass that replaced them.
+    """
+
+    def __init__(self, editor: CodeEditor) -> None:
+        self.editor = editor
+        # Whether the cursor being yielded was marked completed
+        self._current_completed = False
+        # The cursors of the session, and whether each one is completed
+        self._states: list[CursorState] = []
+        self._completed: list[bool] = []
+        self._primary_index: int = 0
+        # Set while a pass writes its cursors back, which isn't a replacement
+        self._writing_back = False
+        self.active = False
+        editor.cursors.changed.connect(self._on_cursors_changed)
+
+    def snapshot_cursors(self) -> None:
+        """Take the editor's current cursors, and clear their completed flags"""
+        self._states, self._primary_index = self.editor.cursors.in_document_order()
+        self._completed = [False] * len(self._states)
+
+    def _on_cursors_changed(self) -> None:
+        if self.active and not self._writing_back:
+            self.snapshot_cursors()
+
+    @contextmanager
+    def session(self) -> Iterator[None]:
+        """Run several iterate_cursors passes as a single operation
+
+        The cursors are snapshot once at the start, and any cursor completed
+        by one pass is skipped by the passes after it
+        """
+        self.snapshot_cursors()
+        self.active = True
+        try:
+            yield
+        finally:
+            self.active = False
+
+    def mark_cursor_completed(self) -> None:
+        """Mark the current cursor as completed. Only useful inside iterate_cursors"""
+        self._current_completed = True
+
+    def all_completed(self) -> bool:
+        """Whether every cursor in the current session has been completed"""
+        return all(self._completed)
+
+    def read_cursors(self) -> Iterator[QtGui.QTextCursor]:
+        """Yield a cursor at each non-completed cursor state, to read the document
+
+        These are in the same order as `iterate_cursors`, but moving them doesn't
+        move the editor's cursors, and editing with them isn't tracked
+        """
+        if not self.active:
+            self.snapshot_cursors()
+        qt_cursor = QtGui.QTextCursor(self.editor.document())
+        for state, completed in zip(self._states, self._completed):
+            if not completed:
+                yield state.apply(qt_cursor)
+
+    def iterate_cursors(
+        self, join_edit: bool = False, complete_all: bool = False
+    ) -> Iterator[TrackedCursor]:
+        """Yield a cursor at each non-completed cursor state, in one edit block
+
+        Args:
+            join_edit: Join the edits onto the previous undo step
+            complete_all: Mark every yielded cursor completed, for a pass that
+                handles every cursor
+        """
+        if not self.active:
+            # A one-off edit outside of a session works on the current cursors
+            self.snapshot_cursors()
+        states, completed = self._states, self._completed
+
+        document = self.editor.document()
+        qt_cursor = self.editor.textCursor()
+        # Qt moves these with every edit, even one that deletes past them, so
+        # they always hold where each cursor is now
+        trackers = [state.build_cursor(document) for state in states]
+        if join_edit:
+            qt_cursor.joinPreviousEditBlock()
+        else:
+            qt_cursor.beginEditBlock()
+
+        yielded_any = False
+        try:
+            for i, tracker in enumerate(trackers):
+                if completed[i]:
+                    continue
+
+                CursorState.from_cursor(tracker).apply(qt_cursor)
+                self._current_completed = False
+                yield qt_cursor
+                if self._states is not states:
+                    # The loop body replaced the cursors, so the old ones are stale
+                    return
+                CursorState.from_cursor(qt_cursor).apply(tracker)
+                completed[i] = complete_all or self._current_completed
+                yielded_any = True
+        finally:
+            qt_cursor.endEditBlock()
+            # Later edits can move the cursors before them too
+            if self._states is states:
+                for state, tracker in zip(states, trackers):
+                    state.copy_from(tracker)
+
+        if yielded_any:
+            self._writing_back = True
+            try:
+                self.editor.cursors.replace_all(
+                    primary_first(self._states, self._primary_index)
+                )
+            finally:
+                self._writing_back = False

QCodeSitter/cursors/line_edits.py

@@ -0,0 +1,128 @@
+"""Multi-cursor edits that join the cursors sharing a line or a span"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from Qt import QtGui
+
+from ..tracked_document import len16
+from ..utils import MM, MO
+
+if TYPE_CHECKING:
+    from .iterator import CursorIterator
+
+
+def expand_to_lines(cursor: QtGui.QTextCursor) -> None:
+    """Expand a cursor selection to whole lines
+    If there is no selection, expand to the current line
+    """
+    start = cursor.selectionStart()
+    end = cursor.selectionEnd()
+    cursor.setPosition(start)
+    cursor.movePosition(MO.StartOfLine)
+    cursor.setPosition(end, MM.KeepAnchor)
+    cursor.movePosition(MO.EndOfLine, MM.KeepAnchor)
+
+
+def replace_lines(
+    cursor: QtGui.QTextCursor, transform: Callable[[list[str]], list[str]]
+) -> None:
+    """Replace the whole lines under the cursor, and select the new lines
+
+    Args:
+        cursor: The cursor whose selection (or current line) to replace
+        transform: Takes the lines, without their newlines, and returns new ones
+    """
+    expand_to_lines(cursor)
+    start = cursor.selectionStart()
+    lines = cursor.selection().toPlainText().split("\n")
+    new_text = "\n".join(transform(lines))
+    cursor.insertText(new_text)
+    cursor.setPosition(start)
+    cursor.setPosition(start + len16(new_text), MM.KeepAnchor)
+
+
+def edit_joined_spans(
+    citer: CursorIterator,
+    span_of: Callable[[QtGui.QTextCursor], tuple[int, int]],
+    edit_join: Callable[[QtGui.QTextCursor, tuple[int, int], int], None],
+) -> None:
+    """Edit the spans of every cursor, once for each group of spans that overlap or touch
+
+    The first cursor of each join makes the edit, and the other cursors in the
+    join take its selection afterwards, so the cursors merge
+
+    Args:
+        citer: The editor's cursor iterator
+        span_of: Gives the (start, end) span to edit for a cursor. It may move
+            the cursor
+        edit_join: Edits a joined span at the first cursor of the join. The int
+            is how far the edits at the joins before it have moved this cursor
+    """
+    starts = []
+    spans = []
+    for cursor in citer.read_cursors():
+        starts.append(cursor.selectionStart())
+        spans.append(span_of(cursor))
+
+    # A span can start before the span of the cursor before it, but then it
+    # overlaps it, so the joins are still in the order of the cursors
+    joined: list[tuple[int, int]] = []
+    joins = [0] * len(spans)
+    for i in sorted(range(len(spans)), key=lambda i: spans[i][0]):
+        start, end = spans[i]
+        if joined and start <= joined[-1][1]:
+            joined[-1] = (joined[-1][0], max(joined[-1][1], end))
+        else:
+            joined.append((start, end))
+        joins[i] = len(joined) - 1
+
+    # The iterator goes first, so it runs to its end and writes the cursors back
+    edited_join = -1
+    edited = (0, 0)
+    for (i, cursor), join in zip(
+        enumerate(citer.iterate_cursors(complete_all=True)), joins
+    ):
+        if join != edited_join:
+            edit_join(cursor, joined[join], cursor.selectionStart() - starts[i])
+            edited_join = join
+            edited = (cursor.anchor(), cursor.position())
+        else:
+            cursor.setPosition(edited[0])
+            cursor.setPosition(edited[1], MM.KeepAnchor)
+
+
+def replace_lines_at_cursors(
+    citer: CursorIterator, transform: Callable[[list[str]], list[str]]
+) -> None:
+    """Replace the whole lines under every cursor, and select the new lines
+
+    Cursors that share a line are joined, so each line is replaced once. Each
+    cursor in a join selects all of its new lines, so the cursors merge
+
+    Args:
+        citer: The editor's cursor iterator
+        transform: Takes the lines, without their newlines, and returns new ones
+    """
+
+    def line_span(cursor: QtGui.QTextCursor) -> tuple[int, int]:
+        document = cursor.document()
+        first = document.findBlock(cursor.selectionStart()).blockNumber()
+        last = document.findBlock(cursor.selectionEnd()).blockNumber()
+        return first, last
+
+    def replace_join(cursor: QtGui.QTextCursor, span: tuple[int, int], _: int) -> None:
+        # The first cursor of a join is on its first line, wherever the
+        # edits at the joins before it have moved that line to
+        first, last = span
+        start_block = cursor.document().findBlock(cursor.selectionStart())
+        end_block = cursor.document().findBlockByNumber(
+            start_block.blockNumber() + last - first
+        )
+        cursor.setPosition(start_block.position())
+        cursor.setPosition(end_block.position(), MM.KeepAnchor)
+        replace_lines(cursor, transform)
+
+    edit_joined_spans(citer, line_span, replace_join)

QCodeSitter/cursors/multi.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from Qt import QtCore, QtGui
+
+from ..tracked_document import len16, utf16_to_index
+from ..utils import MM, MO, leading_whitespace
+from .state import CursorState, primary_first
+
+if TYPE_CHECKING:
+    from ..code_editor import CodeEditor
+
+
+def _merge_overlapping(cursors: list[CursorState]) -> list[CursorState]:
+    """Merge cursors that overlap, keeping the first cursor first
+
+    Cursors that only touch merge when at least one of them has no selection,
+    so two selections side by side stay separate
+
+    A merged selection covers both selections, and is backward if either was
+    """
+    if len(cursors) <= 1:
+        return cursors
+
+    first = cursors[0]
+    merged: list[CursorState] = []
+    primary_index = 0
+    for cursor in sorted(cursors, key=lambda c: c.selectionStart()):
+        last = merged[-1] if merged else None
+        if last is not None and (
+            cursor.selectionStart() < last.selectionEnd()
+            or (
+                cursor.selectionStart() == last.selectionEnd()
+                and not (cursor.hasSelection() and last.hasSelection())
+            )
+        ):
+            start = last.selectionStart()
+            end = max(last.selectionEnd(), cursor.selectionEnd())
+            if last.is_backward() or cursor.is_backward():
+                merged[-1] = CursorState(end, start)
+            else:
+                merged[-1] = CursorState(start, end)
+        else:
+            merged.append(cursor)
+        if cursor is first:
+            primary_index = len(merged) - 1
+    return primary_first(merged, primary_index)
+
+
+def _smart_home(qt_cursor: QtGui.QTextCursor, mode: MM) -> None:
+    """Move to the first non-whitespace character, or column 0 if already there"""
+    block = qt_cursor.block()
+    line_start = block.position()
+    text = block.text()
+    # Whitespace is never a surrogate pair, so its length is its UTF-16 length
+    indent_end = line_start + len(leading_whitespace(text))
+
+    target = line_start if qt_cursor.position() == indent_end else indent_end
+    qt_cursor.setPosition(target, mode)
+
+
+class MultiCursor(QtCore.QObject):
+    """The editor's cursors, and the commands that add and move them
+
+    Qt only knows about the primary cursor. The others are kept here as
+    CursorStates, and drawn by the MultiCursorPaint behavior. The commands that
+    add cursors return whether they added one.
+    """
+
+    changed = QtCore.Signal()
+
+    def __init__(self, editor: CodeEditor) -> None:
+        super().__init__(editor)
+        self.editor = editor
+        self.secondary: list[CursorState] = []
+
+    def primary(self) -> CursorState:
+        """Snapshot Qt's primary cursor as a CursorState"""
+        return CursorState.from_cursor(self.editor.textCursor())
+
+    def set_primary(self, state: CursorState) -> None:
+        self.editor.setTextCursor(state.apply(self.editor.textCursor()))
+
+    def in_document_order(self) -> tuple[list[CursorState], int]:
+        """Get every cursor sorted by position, and the index of the primary one"""
+        primary = self.primary()
+        ret = sorted([primary, *self.secondary], key=lambda c: c.selectionStart())
+        return ret, ret.index(primary)
+
+    def _primary_first(self) -> list[CursorState]:
+        return primary_first(*self.in_document_order())
+
+    def replace_all(self, cursors: list[CursorState]) -> None:
+        """Replace every cursor, merging any that overlap
+
+        The first cursor becomes the primary, the rest become secondaries.
+        """
+        if not cursors:
+            self.clear_secondary()
+            return
+        merged = _merge_overlapping(cursors)
+        self.set_primary(merged[0])
+        self.secondary = merged[1:]
+        self.changed.emit()
+
+    def clear_secondary(self) -> None:
+        """Leave multi-cursor mode, keeping only the primary cursor"""
+        self.secondary.clear()
+        self.changed.emit()
+
+    def add_next_occurrence(self) -> bool:
+        """Add a cursor selecting the next occurrence of the primary selection
+
+        With no selection, select the word under the cursor first.
+        Returns whether a cursor was added
+        """
+        cursor = self.editor.textCursor()
+        if not cursor.hasSelection():
+            cursor.select(QtGui.QTextCursor.SelectionType.WordUnderCursor)
+            if not cursor.hasSelection():
+                return False
+            self.editor.setTextCursor(cursor)
+
+        search_text = cursor.selectedText()
+        all_cursors = self._primary_first()
+        next_pos = self._find(search_text, max(c.selectionEnd() for c in all_cursors))
+        if next_pos < 0:
+            # Wrap around to the start, but only up to the first cursor
+            next_pos = self._find(search_text, 0)
+            if next_pos < 0 or next_pos >= min(c.selectionStart() for c in all_cursors):
+                return False
+        end = next_pos + len16(search_text)
+        return self._add([*all_cursors, CursorState(next_pos, end)])
+
+    def _find(self, search_text: str, start_pos: int) -> int:
+        """Find the position of search_text after start_pos, or -1 if there is none
+
+        QTextDocument.find only matches within one block, so search the raw
+        text instead. Like selectedText, it separates blocks with U+2029, so
+        multi-line selections match too
+        """
+        text = self.editor.document().toRawText()
+        found = text.find(search_text, utf16_to_index(text, start_pos))
+        return -1 if found < 0 else len16(text[:found])
+
+    def move(self, operation: MO, select: bool = False) -> None:
+        """Move every cursor, like QTextCursor.movePosition
+
+        Args:
+            operation: Where to move each cursor to
+            select: Extend the selections, like holding Shift
+        """
+        mode = MM.KeepAnchor if select else MM.MoveAnchor
+        self._move_each(lambda qt_cursor: qt_cursor.movePosition(operation, mode))
+
+    def smart_home(self, select: bool = False) -> None:
+        """Move every cursor to its line's indent, or to column 0 if it's there"""
+        mode = MM.KeepAnchor if select else MM.MoveAnchor
+        self._move_each(lambda qt_cursor: _smart_home(qt_cursor, mode))
+
+    def _move_each(self, move: Callable[[QtGui.QTextCursor], object]) -> None:
+        qt_cursor = QtGui.QTextCursor(self.editor.document())
+        moved = []
+        for state in self._primary_first():
+            state.apply(qt_cursor)
+            move(qt_cursor)
+            moved.append(CursorState.from_cursor(qt_cursor))
+        self.replace_all(moved)
+
+    def selected_texts(self) -> list[str]:
+        """Get the selected text of every cursor, in document order"""
+        all_cursors, _primary_index = self.in_document_order()
+        qt_cursor = QtGui.QTextCursor(self.editor.document())
+        return [
+            state.apply(qt_cursor).selectedText().replace("
", "\n")
+            for state in all_cursors
+        ]
+
+    def _add_adjacent(self, above: bool) -> bool:
+        """Move the primary cursor up or down a line, leaving a cursor behind"""
+        current_position = self.primary().position
+        block = self.editor.document().findBlock(current_position)
+        adj_block = block.previous() if above else block.next()
+        if not block.isValid() or not adj_block.isValid():
+            return False
+
+        col = min(current_position - block.position(), len16(adj_block.text()))
+        new_primary_pos = adj_block.position() + col
+        return self._add(
+            [
+                CursorState(new_primary_pos, new_primary_pos),
+                *self.secondary,
+                CursorState(current_position, current_position),
+            ]
+        )
+
+    def add_above(self) -> bool:
+        """Move the primary cursor up a line, leaving a cursor behind"""
+        return self._add_adjacent(True)
+
+    def add_below(self) -> bool:
+        """Move the primary cursor down a line, leaving a cursor behind"""
+        return self._add_adjacent(False)
+
+    def add_to_line_ends(self) -> bool:
+        """Replace the selection with a cursor at the end of each of its lines
+
+        Returns whether there are more cursors than before
+        """
+        cursor = self.editor.textCursor()
+        if not cursor.hasSelection():
+            return False
+
+        doc = self.editor.document()
+        block = doc.findBlock(cursor.selectionStart())
+        end_block = doc.findBlock(cursor.selectionEnd())
+        cursors = []
+        while block.isValid():
+            line_end = block.position() + len16(block.text())
+            cursors.append(CursorState(line_end, line_end))
+            if block == end_block:
+                break
+            block = block.next()
+        return self._add(cursors)
+
+    def add_at(self, position: int) -> bool:
+        """Add a cursor at a position, like Alt+Click"""
+        return self._add([*self._primary_first(), CursorState(position, position)])
+
+    def _add(self, cursors: list[CursorState]) -> bool:
+        """Replace every cursor, and return whether there are more than before
+
+        A new cursor that overlaps another one merges into it, as does one
+        that touches another when either of them has no selection
+        """
+        count = len(self.secondary)
+        self.replace_all(cursors)
+        return len(self.secondary) > count

QCodeSitter/cursors/state.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from Qt import QtGui
+
+from ..utils import MM
+
+
+@dataclass
+class CursorState:
+    """A cursor's anchor and position in UTF-16 code units
+
+    The selection methods mirror QTextCursor's names, so code can take either
+    """
+
+    anchor: int
+    position: int
+
+    @classmethod
+    def from_cursor(cls, cursor: QtGui.QTextCursor) -> CursorState:
+        return cls(cursor.anchor(), cursor.position())
+
+    def hasSelection(self) -> bool:
+        return self.anchor != self.position
+
+    def is_backward(self) -> bool:
+        """Whether the selection was made from right to left"""
+        return self.anchor > self.position
+
+    def selectionStart(self) -> int:
+        return min(self.anchor, self.position)
+
+    def selectionEnd(self) -> int:
+        return max(self.anchor, self.position)
+
+    def apply(self, cursor: QtGui.QTextCursor) -> QtGui.QTextCursor:
+        """Move a QTextCursor to this state"""
+        cursor.setPosition(self.anchor)
+        cursor.setPosition(self.position, MM.KeepAnchor)
+        return cursor
+
+    def copy_from(self, cursor: QtGui.QTextCursor) -> None:
+        self.anchor = cursor.anchor()
+        self.position = cursor.position()
+
+    def build_cursor(self, document: QtGui.QTextDocument) -> QtGui.QTextCursor:
+        return self.apply(QtGui.QTextCursor(document))
+
+
+def primary_first(states: list[CursorState], primary_index: int) -> list[CursorState]:
+    """Copy the states, moving the primary cursor's state to the front"""
+    states = states[:]
+    states.insert(0, states.pop(primary_index))
+    return states

QCodeSitter/cursors/tracked.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, NoReturn
+
+from Qt import QtGui
+
+if TYPE_CHECKING:
+    from ..tracked_document import TrackedDocument
+
+
+class TrackedCursor(QtGui.QTextCursor):
+    """A QTextCursor that reports its text edits to its TrackedDocument
+
+    insertText, insertBlock, removeSelectedText, deleteChar and
+    deletePreviousChar are reported, so the tree can follow them. The rich text
+    inserts, like insertHtml, raise instead of editing behind the tree's back
+    """
+
+    def __init__(self, document: TrackedDocument, cursor: QtGui.QTextCursor) -> None:
+        self._doc = document
+        super().__init__(cursor)
+
+    def deleteChar(self) -> None:
+        if self.hasSelection():
+            self.removeSelectedText()
+            return
+        ttc = QtGui.QTextCursor(self)
+        ttc.movePosition(ttc.MoveOperation.NextCharacter, ttc.MoveMode.KeepAnchor)
+        removed = ttc.selectedText()
+        position = self.position()
+        super().deleteChar()
+        self._doc.report_edit(position, removed, "")
+
+    def deletePreviousChar(self) -> None:
+        if self.hasSelection():
+            self.removeSelectedText()
+            return
+        ttc = QtGui.QTextCursor(self)
+        ttc.movePosition(ttc.MoveOperation.PreviousCharacter, ttc.MoveMode.KeepAnchor)
+        removed = ttc.selectedText()
+        position = ttc.position()
+        super().deletePreviousChar()
+        self._doc.report_edit(position, removed, "")
+
+    def removeSelectedText(self) -> None:
+        removed = self.selectedText()
+        position = self.selectionStart()
+        super().removeSelectedText()
+        self._doc.report_edit(position, removed, "")
+
+    def insertBlock(self, *args: Any, **kwargs: Any) -> None:
+        position, removed = self._replaced_span()
+        super().insertBlock(*args, **kwargs)
+        self._doc.report_edit(position, removed, "\n")
+
+    def insertText(
+        self, text: str, format: QtGui.QTextCharFormat | None = None
+    ) -> None:
+        position, removed = self._replaced_span()
+        if format is not None:
+            super().insertText(text, format)
+        else:
+            super().insertText(text)
+        self._doc.report_edit(position, removed, text)
+
+    def _untracked(self, name: str) -> NoReturn:
+        raise NotImplementedError(
+            f"TrackedCursor.{name} would edit the document without updating "
+            "the tree, use insertText"
+        )
+
+    def insertFragment(self, *args: object, **kwargs: object) -> NoReturn:
+        self._untracked("insertFragment")
+
+    def insertFrame(self, *args: object, **kwargs: object) -> NoReturn:
+        self._untracked("insertFrame")
+
+    def insertHtml(self, *args: object, **kwargs: object) -> NoReturn:
+        self._untracked("insertHtml")
+
+    def insertImage(self, *args: object, **kwargs: object) -> NoReturn:
+        self._untracked("insertImage")
+
+    def insertList(self, *args: object, **kwargs: object) -> NoReturn:
+        self._untracked("insertList")
+
+    def insertMarkdown(self, *args: object, **kwargs: object) -> NoReturn:
+        self._untracked("insertMarkdown")
+
+    def insertTable(self, *args: object, **kwargs: object) -> NoReturn:
+        self._untracked("insertTable")
+
+    def _replaced_span(self) -> tuple[int, str]:
+        """Where an insert starts, and the selected text it replaces"""
+        if self.hasSelection():
+            return self.selectionStart(), self.selectedText()
+        return self.position(), ""