QCodeSitter 0.1.0__py3-none-any.whl

QCodeSitter/__init__.py

@@ -0,0 +1,38 @@
+"""A tree-sitter powered code editor widget for Qt
+
+`default_options` and `install_default_behaviors` come from the defaults module,
+which is only imported when one of them is used, because it imports every
+built-in behavior. Using the editor with your own behaviors doesn't need them
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from .code_editor import CodeEditor
+from .editor_options import EditorOptions
+from .tracked_document import TrackedDocument
+from .tree_manager import TreeManager
+
+if TYPE_CHECKING:
+    from .defaults import default_options, install_default_behaviors
+
+_FROM_DEFAULTS = ("default_options", "install_default_behaviors")
+
+
+def __getattr__(name: str) -> Any:
+    if name in _FROM_DEFAULTS:
+        from . import defaults
+
+        return getattr(defaults, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    "CodeEditor",
+    "EditorOptions",
+    "TrackedDocument",
+    "TreeManager",
+    "default_options",
+    "install_default_behaviors",
+]

QCodeSitter/behaviors/__init__.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Collection
+from typing import TYPE_CHECKING, Any
+
+from ..editor_options import check_option_keys
+
+if TYPE_CHECKING:
+    from Qt import QtCore, QtGui, QtWidgets
+
+    from ..code_editor import CodeEditor
+    from ..editor_options import EditorOptions, OptionHandlers
+
+
+class Behavior:
+    """A feature that plugs into a CodeEditor
+
+    Subclasses get their options with `watch_options`, and connect to the
+    editor's signals with `connect` so that `remove` disconnects them, and undo
+    anything else they did to the editor in `on_remove`.
+    Behaviors that handle keys override `handle_key_press`.
+    """
+
+    # The editor passes key presses to the behaviors with the highest priority first.
+    # Behaviors of the same priority get them in the order they were added
+    KEY_PRIORITY = 0
+
+    def __init__(self, editor: CodeEditor) -> None:
+        self.editor: CodeEditor = editor
+        self.options: EditorOptions = editor.options
+        self._option_handlers: dict[str, Callable[[Any], object]] = {}
+        self._connections: list[tuple[QtCore.SignalInstance, Callable[..., Any]]] = []
+        self.shortcut_actions: list[QtGui.QAction] = []
+        self.connect(self.options.optionsUpdated, self._on_options_updated)
+
+    @classmethod
+    def handles_key_presses(cls) -> bool:
+        """Whether the editor should pass key presses to `handle_key_press`"""
+        return cls.handle_key_press is not Behavior.handle_key_press
+
+    def connect(
+        self,
+        signal: QtCore.SignalInstance,
+        slot: Callable[..., Any],
+        conn_type: QtCore.Qt.ConnectionType | None = None,
+    ) -> None:
+        """Connect a signal to a slot until the behavior is removed"""
+        if conn_type is None:
+            signal.connect(slot)
+        else:
+            signal.connect(slot, conn_type)
+        self._connections.append((signal, slot))
+
+    def watch_options(self, handlers: OptionHandlers) -> None:
+        """Call these handlers with their option's value now, and whenever it changes
+
+        Every option has a value except the language and font, whose handlers
+        wait until they are set. Raises a KeyError for unknown option keys
+        """
+        check_option_keys(handlers)
+        self._option_handlers.update(handlers)
+        self.options.apply(handlers, handlers)
+
+    def _on_options_updated(self, keys: Collection[str]) -> None:
+        self.options.apply(self._option_handlers, keys)
+
+    def remove(self) -> None:
+        """Disconnect from the editor, then call `on_remove`
+
+        Subclasses override `on_remove` instead of this
+        """
+        for signal, slot in reversed(self._connections):
+            signal.disconnect(slot)
+        self._connections.clear()
+        self.on_remove()
+
+    def on_remove(self) -> None:
+        """Undo what the behavior did to the editor, besides connecting signals
+
+        This runs after the signals connected with `connect` are
+        disconnected, so the cleanup can't trigger the behavior's own handlers
+        """
+
+    def get_hotkeys(self) -> list[QtGui.QAction]:
+        """The shortcut actions to add to the editor"""
+        return []
+
+    def add_menu_actions(
+        self, menu: QtWidgets.QMenu, pos: QtCore.QPoint | None
+    ) -> None:
+        """Add this behavior's actions to the editor's right click menu, or to a
+        menu outside the editor like a window's menu bar
+
+        The editor puts a separator before each behavior's actions. Use
+        `utils.add_menu_action` to show the hotkey that runs each one without
+        binding it. Actions created here should be parented to the menu
+
+        Args:
+            menu: The menu being built
+            pos: Where a right click opened the menu, in viewport coordinates.
+                None when it wasn't opened at a point in the text, so act on the
+                text cursor instead
+        """
+
+    def handle_key_press(self, event: QtGui.QKeyEvent) -> bool:
+        """Handle a key press, before the editor's own key handling
+
+        This runs inside an edit session. A behavior can handle the key for
+        some cursors and not others: calling `editor.citer.mark_cursor_completed()`
+        for a cursor stops the handlers after this one from editing it.
+
+        Returns:
+            True to consume the key, so the handlers after this one never see it
+        """
+        return False

QCodeSitter/behaviors/auto_bracket.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from Qt import QtGui
+
+from ..tracked_document import len16, utf16_to_index
+from ..utils import KEY, MM, MO, MOD
+from . import Behavior
+
+if TYPE_CHECKING:
+    from ..code_editor import CodeEditor
+
+# Python string prefixes, which still get a pair of quotes when typed before one
+_STRING_PREFIXES = frozenset({"r", "u", "b", "f", "br", "rb", "fr", "rf"})
+
+
+class AutoBracket(Behavior):
+    """Automatically inserts closing brackets, quotes, and other paired characters
+
+    The pairs come from the "auto_bracket_pairs" option
+    """
+
+    def __init__(self, editor: CodeEditor) -> None:
+        super().__init__(editor)
+        self.watch_options({"auto_bracket_pairs": self._set_pairs})
+
+    def _set_pairs(self, pairs: list[str]) -> None:
+        """Set the pairs from strings of an opening and closing character, ie "()" """
+        self.pairs = {pair[0]: pair[1] for pair in pairs}
+        self._closing = set(self.pairs.values())
+        # Characters that open and close themselves, like quotes
+        self._self_closing = {k for k, v in self.pairs.items() if k == v}
+
+    def handle_key_press(self, event: QtGui.QKeyEvent) -> bool:
+        """Handle the cursors next to pairs, and leave the rest to the editor"""
+        text = event.text()
+        if event.key() == KEY.Key_Backspace:
+            if event.modifiers() & MOD.ControlModifier:
+                # Ctrl+Backspace deletes a word, which EditingKeys does
+                return False
+            self._delete_pair()
+        elif text in self._closing or text in self.pairs:
+            if text in self._closing:
+                self._skip_closing(text)
+            if text in self.pairs:
+                self._insert_pair(text)
+        else:
+            return False
+        return self.editor.citer.all_completed()
+
+    def _pair_around(self, text: str, index: int) -> str | None:
+        """Get the empty pair, or pair of triple quotes, that a str index is inside"""
+        before = text[max(0, index - 3) : index]
+        quote = before[:1]
+        if len(before) == 3 and quote in self._self_closing and before == quote * 3:
+            if text[index : index + 3] == before:
+                return before * 2
+        if 0 < index < len(text) and self.pairs.get(text[index - 1]) == text[index]:
+            return text[index - 1 : index + 1]
+        return None
+
+    def _delete_pair(self) -> None:
+        """Backspace both halves of an empty pair"""
+        citer = self.editor.citer
+        for cursor in citer.iterate_cursors():
+            if cursor.hasSelection():
+                continue
+            text = cursor.block().text()
+            pair = self._pair_around(
+                text, utf16_to_index(text, cursor.positionInBlock())
+            )
+            if pair is None:
+                continue
+            half = len16(pair) // 2
+            pos = cursor.position()
+            cursor.setPosition(pos - half)
+            cursor.setPosition(pos + half, MM.KeepAnchor)
+            cursor.removeSelectedText()
+            citer.mark_cursor_completed()
+
+    def _insert_pair(self, open_char: str) -> None:
+        """Insert an opening character and its closing pair
+
+        This runs after _skip_closing, so any cursor right before a matching
+        closing character has already been handled
+        """
+        close_char = self.pairs[open_char]
+        citer = self.editor.citer
+        for cursor in citer.iterate_cursors(complete_all=True):
+            if cursor.hasSelection():
+                # Wrap the selection, and keep it selected inside the pair
+                selected_text = cursor.selectedText()
+                start = cursor.selectionStart() + len16(open_char)
+                cursor.insertText(open_char + selected_text + close_char)
+                cursor.setPosition(start)
+                cursor.setPosition(start + len16(selected_text), MM.KeepAnchor)
+            elif open_char in self._self_closing and self._typing_triple_quote(
+                cursor, open_char
+            ):
+                # Close the docstring, with the cursor inside it
+                cursor.insertText(open_char * 4)
+                cursor.movePosition(MO.Left, MM.MoveAnchor, 3)
+            elif open_char == "'" and self._after_word(cursor):
+                # An apostrophe inside a word, like don't
+                cursor.insertText(open_char)
+            else:
+                cursor.insertText(open_char + close_char)
+                cursor.movePosition(MO.Left, MM.MoveAnchor, 1)
+
+    @staticmethod
+    def _typing_triple_quote(cursor: QtGui.QTextCursor, quote: str) -> bool:
+        """Whether typing this quote makes three in a row"""
+        text = cursor.block().text()
+        index = utf16_to_index(text, cursor.positionInBlock())
+        return index >= 2 and text[index - 2 : index] == quote * 2
+
+    @staticmethod
+    def _after_word(cursor: QtGui.QTextCursor) -> bool:
+        """Whether the cursor follows a word that is not a string prefix"""
+        text = cursor.block().text()
+        index = utf16_to_index(text, cursor.positionInBlock())
+        match = re.search(r"\w*$", text[:index])
+        word = match.group() if match else ""
+        return bool(word) and word.lower() not in _STRING_PREFIXES
+
+    def _skip_closing(self, close_char: str) -> None:
+        """Step over a closing character instead of typing a second one"""
+        citer = self.editor.citer
+        for cursor in citer.iterate_cursors():
+            # Typing over a selection replaces or wraps it instead
+            if cursor.hasSelection():
+                continue
+            cursor.movePosition(MO.Right, MM.KeepAnchor, 1)
+            if cursor.selectedText() == close_char:
+                cursor.setPosition(cursor.position())
+                citer.mark_cursor_completed()
+            else:
+                # Go back to where it started. At the end of the document it never moved
+                cursor.setPosition(cursor.anchor())