QCodeSitter 0.1.0__py3-none-any.whl

QCodeSitter/behaviors/smart_indent.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+from Qt import QtCore, QtGui, QtWidgets
+
+from ..cursors.line_edits import replace_lines_at_cursors
+from ..languages import IndentRules, language_spec
+from ..tracked_document import utf16_to_index
+from ..utils import KEY, MM, MO, add_menu_action, dedent_string, leading_whitespace
+from . import Behavior
+
+CLOSING_BRACKETS = ("]", ")", "}")
+
+
+class SmartIndent(Behavior):
+    """Syntax-aware indentation for Enter, Tab, Shift+Tab, Backspace and closing brackets
+
+    The indent settings come from the options, and the indent rules come from
+    the editor language's LanguageSpec
+    """
+
+    @property
+    def _use_tabs(self) -> bool:
+        return self.options["indent_using_tabs"]
+
+    @property
+    def _width(self) -> int:
+        return self.options["space_indent_width"]
+
+    def add_menu_actions(
+        self, menu: QtWidgets.QMenu, pos: QtCore.QPoint | None
+    ) -> None:
+        add_menu_action(menu, "Indent", self.insert_indent, "Tab")
+        add_menu_action(menu, "Unindent", self.unindent, "Shift+Tab")
+
+    def indent_rules(self) -> IndentRules:
+        spec = language_spec(self.editor.tree_manager.language)
+        return spec.indent_rules(self.editor.tree_manager)
+
+    def handle_key_press(self, event: QtGui.QKeyEvent) -> bool:
+        key = event.key()
+        if key == KEY.Key_Tab:
+            self.insert_indent()
+            return True
+        if key == KEY.Key_Backtab:
+            self.unindent()
+            return True
+        # These only handle some cursors, and leave the rest to the editor
+        if key in (KEY.Key_Return, KEY.Key_Enter):
+            self.smart_newline()
+        elif key == KEY.Key_Backspace:
+            self._smart_backspace()
+        elif event.text() in CLOSING_BRACKETS:
+            self._smart_closing_bracket(event.text())
+        else:
+            return False
+        return self.editor.citer.all_completed()
+
+    def _one_indent(self) -> str:
+        return "\t" if self._use_tabs else " " * self._width
+
+    def _dedent(self, indent: str) -> str:
+        return dedent_string(indent, self._use_tabs, self._width)
+
+    def _newline_indent(
+        self, cursor: QtGui.QTextCursor, rules: IndentRules
+    ) -> tuple[str, int]:
+        """Work out the indentation to insert after a newline at the cursor
+
+        Returns:
+            The text to insert after the newline
+            How far to move the cursor back from the end of that text
+        """
+        block = cursor.block()
+        line_text = block.text()
+        indent = leading_whitespace(line_text)
+        col = cursor.positionInBlock()
+
+        # At the start of a line, move the line down unchanged
+        if col == 0:
+            return "", 0
+
+        # A blank line keeps its indentation
+        if not line_text.strip():
+            return indent, 0
+
+        # Between a pair of brackets, put the closing bracket on its own line
+        # below an indented empty line
+        index = utf16_to_index(line_text, col)
+        if line_text[index - 1 : index + 1] in self.options["indent_bracket_pairs"]:
+            return indent + self._one_indent() + "\n" + indent, len(indent) + 1
+
+        # Look at the character just before the cursor to find the statement we just finished
+        row = block.blockNumber()
+        if rules.should_indent_after(row, col - 1):
+            return indent + self._one_indent(), 0
+        if rules.should_dedent_after(row, col - 1):
+            return self._dedent(indent), 0
+        return indent, 0
+
+    def smart_newline(self) -> None:
+        """Insert a newline indented to suit the code around each cursor"""
+        # Work out every indent before editing, because the edits change the tree
+        citer = self.editor.citer
+        rules = self.indent_rules()
+        indents = []
+        with self.editor.edit_session():
+            for cursor in citer.read_cursors():
+                if cursor.hasSelection():
+                    cursor.setPosition(cursor.selectionStart())
+                indents.append(self._newline_indent(cursor, rules))
+
+            for i, cursor in enumerate(citer.iterate_cursors(complete_all=True)):
+                indent_str, move_back = indents[i]
+                cursor.insertText("\n" + indent_str)
+                if move_back:
+                    cursor.movePosition(MO.Left, MM.MoveAnchor, move_back)
+
+    def insert_indent(self) -> None:
+        """Indent to the next tab stop, or indent every cursor's lines if any selects
+
+        A selection anywhere indents whole lines, so a cursor on a line that
+        another cursor's selection indents doesn't indent it twice
+        """
+        citer = self.editor.citer
+        width = self._width
+        indent = self._one_indent()
+
+        def indent_lines(lines: list[str]) -> list[str]:
+            return [indent + ln if ln.strip() else ln for ln in lines]
+
+        with self.editor.edit_session():
+            if any(cursor.hasSelection() for cursor in citer.read_cursors()):
+                replace_lines_at_cursors(citer, indent_lines)
+                return
+            for cursor in citer.iterate_cursors(complete_all=True):
+                if self._use_tabs:
+                    cursor.insertText("\t")
+                else:
+                    cursor.insertText(" " * (width - cursor.positionInBlock() % width))
+
+    def unindent(self) -> None:
+        """Remove one indent from every line of each cursor's selection or line"""
+        citer = self.editor.citer
+        width = self._width
+        use_tabs = self._use_tabs
+
+        def unindent_line(line: str) -> str:
+            if use_tabs:
+                return line.removeprefix("\t")
+            return line[:width].lstrip(" ") + line[width:]
+
+        with self.editor.edit_session():
+            replace_lines_at_cursors(
+                citer, lambda lines: [unindent_line(ln) for ln in lines]
+            )
+
+    def _smart_backspace(self) -> None:
+        """Backspace over a whole indent when the cursor is in the indentation"""
+        if self._use_tabs:
+            return
+        citer = self.editor.citer
+        width = self._width
+        for cursor in citer.iterate_cursors():
+            col = cursor.positionInBlock()
+            if cursor.hasSelection() or col == 0:
+                continue
+            # Spaces are one code unit each, so col is also the str index
+            if set(cursor.block().text()[:col]) != {" "}:
+                continue
+
+            # Delete back to the previous tab stop
+            cursor.movePosition(MO.Left, MM.KeepAnchor, col % width or width)
+            cursor.removeSelectedText()
+            citer.mark_cursor_completed()
+
+    def _smart_closing_bracket(self, bracket: str) -> None:
+        """Dedent a blank line when a closing bracket is typed on it"""
+        citer = self.editor.citer
+        for cursor in citer.iterate_cursors():
+            if cursor.hasSelection():
+                cursor.removeSelectedText()
+
+            line_text = cursor.block().text()
+            indent = leading_whitespace(line_text)
+            if not indent or line_text.strip():
+                continue
+
+            cursor.movePosition(MO.StartOfLine)
+            cursor.movePosition(MO.EndOfLine, MM.KeepAnchor)
+            cursor.insertText(self._dedent(indent) + bracket)
+            citer.mark_cursor_completed()

QCodeSitter/behaviors/syntax_highlighting.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from Qt import QtGui
+
+from ..languages import highlight_query
+from ..queries import query_byte_range
+from ..syntax_specs import SyntaxSpecs, resolve_capture
+from ..tracked_document import len16
+from . import Behavior
+
+if TYPE_CHECKING:
+    from tree_sitter import Query
+
+    from ..code_editor import CodeEditor
+    from ..tree_manager import TreeManager
+
+
+class TreeSitterHighlighter(QtGui.QSyntaxHighlighter):
+    """Highlights each block with a tree-sitter query over the block's bytes
+
+    The SyntaxHighlighting behavior only rehighlights the rows that changed
+    """
+
+    def __init__(
+        self,
+        tree_manager: TreeManager,
+        query: Query,
+        format_specs: SyntaxSpecs,
+    ) -> None:
+        super().__init__(tree_manager.document)
+        self.tree_manager = tree_manager
+        self._doc = tree_manager.document
+        self.query = query
+        self.formats = self._compile_formats(format_specs)
+
+    def _compile_formats(
+        self, format_specs: SyntaxSpecs
+    ) -> dict[str, QtGui.QTextCharFormat]:
+        """Convert the syntax specs into text formats, keyed by capture name"""
+        out: dict[str, QtGui.QTextCharFormat] = {}
+
+        for name, spec in format_specs.items():
+            fmt = QtGui.QTextCharFormat()
+            if "color" in spec:
+                fmt.setForeground(QtGui.QColor(spec["color"]))
+            if spec.get("bold"):
+                fmt.setFontWeight(QtGui.QFont.Weight.Bold)
+            if spec.get("italic"):
+                fmt.setFontItalic(True)
+            out[name] = fmt
+
+        # Captures in the query without an explicit format fall back to their
+        # parent group. ie: "keyword.return" -> "keyword"
+        for name in self.query_capture_names():
+            if name not in out:
+                fallback = resolve_capture(name, out)
+                if fallback is not None:
+                    out[name] = fallback
+
+        return out
+
+    def query_capture_names(self) -> list[str]:
+        # capture_count is a property, but tree-sitter's stubs call it a method
+        count: int = self.query.capture_count  # type: ignore[assignment]
+        return [self.query.capture_name(i) for i in range(count)]
+
+    def _block_byte_range(
+        self, block: QtGui.QTextBlock, text_len: int
+    ) -> tuple[int, int]:
+        """Get the UTF-16LE byte range of a block, including its newline"""
+        start = self._doc.char_to_byte(block.position())
+        next_block = block.next()
+        if next_block.isValid():
+            return start, self._doc.char_to_byte(next_block.position())
+        return start, start + self._doc.char_to_byte(text_len)
+
+    def highlightBlock(self, text: str) -> None:
+        tree = self.tree_manager.tree
+        block = self.currentBlock()
+        if tree is None or not block.isValid():
+            return
+
+        # Qt positions are UTF-16 code units, but python's len counts code points
+        # so they differ when the text contains characters outside the BMP
+        text_len = len16(text)
+        start_byte, end_byte = self._block_byte_range(block, text_len)
+        # Skip empty blocks, and blocks past the end of a tree that is out of date
+        root = tree.root_node
+        if start_byte >= end_byte or end_byte > root.end_byte:
+            return
+
+        captures = query_byte_range(
+            self.query, root, start_byte, end_byte, self._doc.node_text
+        )
+        block_start = block.position()
+        for capture_name, nodes in captures.items():
+            fmt = self.formats.get(capture_name)
+            if fmt is None:
+                continue
+            for node in nodes:
+                # Block-local UTF-16 positions, clamped to the block
+                local_start = self._doc.byte_to_char(node.start_byte) - block_start
+                local_end = self._doc.byte_to_char(node.end_byte) - block_start
+                local_start, local_end = max(0, local_start), min(text_len, local_end)
+                if local_end > local_start:
+                    self.setFormat(local_start, local_end - local_start, fmt)
+
+
+class SyntaxHighlighting(Behavior):
+    """Tree-sitter syntax highlighting
+
+    The query comes from the editor language's LanguageSpec, and the formats
+    of its captures from the "syntax" option
+    """
+
+    def __init__(self, editor: CodeEditor) -> None:
+        super().__init__(editor)
+        self._syntax: SyntaxSpecs = {}
+        self.highlighter: TreeSitterHighlighter | None = None
+        self.connect(
+            self.editor.tree_manager.languageChanged, self._rebuild_highlighter
+        )
+        self.connect(self.editor.tree_manager.reparsed, self._on_reparsed)
+        self.watch_options({"syntax": self._set_syntax})
+
+    def _set_syntax(self, syntax: SyntaxSpecs) -> None:
+        self._syntax = syntax
+        self._rebuild_highlighter()
+
+    def _rebuild_highlighter(self) -> None:
+        """Highlight with the current language's query and the syntax formats"""
+        self._detach_highlighter()
+        language = self.editor.tree_manager.language
+        query = highlight_query(language) if language is not None else None
+        if query is None or not self._syntax:
+            return
+        self.highlighter = TreeSitterHighlighter(
+            self.editor.tree_manager, query, self._syntax
+        )
+
+    def _detach_highlighter(self) -> None:
+        """Stop the current highlighter from formatting the document
+
+        The QSyntaxHighlighter is parented to the document, so dropping our
+        reference isn't enough to stop it from running.
+        """
+        if self.highlighter is None:
+            return
+        self.highlighter.setDocument(None)
+        self.highlighter.deleteLater()
+        self.highlighter = None
+
+    def _on_reparsed(self) -> None:
+        if self.highlighter is None:
+            return
+        changed_rows = self.editor.tree_manager.changed_rows
+        if changed_rows is None:
+            self.highlighter.rehighlight()
+            return
+
+        # Only rehighlight the rows that changed instead of the whole document
+        # Qt already highlighted the edited blocks with the old tree when the text
+        # changed. That goes one block past the edit when text is removed, so
+        # include that block too
+        doc = self.editor.document()
+        done: set[int] = set()
+        for first, last in changed_rows:
+            block = doc.findBlockByNumber(first)
+            for row in range(first, last + 2):
+                if not block.isValid():
+                    break
+                if row not in done:
+                    done.add(row)
+                    self.highlighter.rehighlightBlock(block)
+                block = block.next()
+
+    def on_remove(self) -> None:
+        # Detaching the highlighter from the document also clears its formats
+        self._detach_highlighter()

QCodeSitter/behaviors/tab_completion/__init__.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from typing import TYPE_CHECKING, TypeVar
+
+from Qt import QtCore, QtGui
+
+from ...languages import language_spec
+from ...tracked_document import len16, utf16_to_index
+from ...utils import KEY, MM, MOD
+from .. import Behavior
+from .popup import CompletionPopup
+from .types import Completion, CompletionContext, Provider
+
+if TYPE_CHECKING:
+    from ...code_editor import CodeEditor
+
+T_Provider = TypeVar("T_Provider", bound=Provider)
+
+MIN_PREFIX_LENGTH = 2
+
+
+def is_identifier_char(char: str) -> bool:
+    """Whether a character can be part of an identifier, like a letter or digit"""
+    return char.isalnum() or char == "_"
+
+
+def identifier_before(line: str, index: int) -> tuple[int, str]:
+    """Get the identifier that ends at a str index in the line
+
+    Returns:
+        The str index where the identifier starts
+        The identifier, like "jo" in "os.path.jo|"
+    """
+    start = index
+    while start > 0 and is_identifier_char(line[start - 1]):
+        start -= 1
+    return start, line[start:index]
+
+
+def context_at_cursor(editor: CodeEditor) -> CompletionContext:
+    """Get the completion context at the editor's primary cursor"""
+    cursor = editor.textCursor()
+    block = cursor.block()
+    line = block.text()
+    index = utf16_to_index(line, cursor.positionInBlock())
+    start, prefix = identifier_before(line, index)
+    return CompletionContext(
+        line_num=block.blockNumber(),
+        index=index,
+        prefix=prefix,
+        start=start,
+        line=line,
+        node=editor.tree_manager.node_at_char(cursor.position()),
+    )
+
+
+def merge_completions(completions: Iterable[Completion]) -> set[Completion]:
+    """Merge the completions of the same name and kind, keeping the highest priority"""
+    best: dict[Completion, Completion] = {}
+    for comp in completions:
+        current = best.get(comp)
+        if current is None or comp.priority > current.priority:
+            best[comp] = comp
+    return set(best.values())
+
+
+class TabCompletion(Behavior):
+    """Shows a completion popup while typing an identifier
+
+    Completions come from the providers added with `add_provider`. Tab or
+    Enter accepts the selected completion, and Up/Down change it.
+    """
+
+    # Tab and Enter accept a completion before SmartIndent can indent with them
+    KEY_PRIORITY = 10
+
+    def __init__(self, editor: CodeEditor) -> None:
+        super().__init__(editor)
+        self._providers: list[Provider] = []
+        # Where the shown completions were asked for, or None before the first time
+        self._last_context: CompletionContext | None = None
+        # Whether the text changed since the cursor last moved, so moving
+        # the cursor around without typing doesn't open the popup
+        self._typing_mode = False
+
+        self.connect(self.editor.cursorPositionChanged, self.on_cursor_changed)
+        self.connect(self.editor.textChanged, self.on_text_changed)
+
+        # Wait for a pause in typing before asking the providers
+        self.debounce_timer = QtCore.QTimer(self.editor)
+        self.debounce_timer.setSingleShot(True)
+        self.debounce_timer.timeout.connect(self.refresh_completions)
+
+        self.completion_popup = CompletionPopup(self.editor)
+        self.watch_options({"colors": self.completion_popup.set_colors})
+
+    def add_provider(self, provider_cls: type[T_Provider]) -> T_Provider:
+        provider = provider_cls(self.editor)
+        self._providers.append(provider)
+        return provider
+
+    def on_remove(self) -> None:
+        self.debounce_timer.stop()
+        self.debounce_timer.deleteLater()
+        self.completion_popup.hide()
+        self.completion_popup.deleteLater()
+
+    def on_text_changed(self) -> None:
+        self._typing_mode = True
+
+    def _showing_completions_for(self, context: CompletionContext) -> bool:
+        """Whether the popup is showing the completions for the identifier at context
+
+        Once the popup hides, the next identifier asks the providers again
+        """
+        return (
+            self.completion_popup.isVisible()
+            and self._last_context is not None
+            and context.line_num == self._last_context.line_num
+            and context.start == self._last_context.start
+        )
+
+    def _hide_or_filter(self) -> CompletionContext | None:
+        """Hide the popup, or filter what it shows, for the identifier at the cursor
+
+        Returns:
+            The cursor's context when the providers need asking for new
+            completions, or None when the popup was hidden or filtered
+        """
+        context = context_at_cursor(self.editor)
+        if not self._should_trigger(context):
+            self.completion_popup.hide()
+            return None
+        if self._showing_completions_for(context):
+            # Still completing the same word, so just filter what's showing
+            self.completion_popup.update_filter(context.prefix)
+            self._last_context = context
+            return None
+        return context
+
+    def on_cursor_changed(self) -> None:
+        if self._hide_or_filter() is not None and self._typing_mode:
+            self.debounce_timer.start(self.options["debounce_delay"])
+        self._typing_mode = False
+
+    def _should_trigger(self, context: CompletionContext) -> bool:
+        """Whether the cursor is at the end of a long enough identifier, in code"""
+        spec = language_spec(self.editor.tree_manager.language)
+        if context.node is not None and context.node.type in spec.no_completion_types:
+            return False
+        if is_identifier_char(context.line[context.index : context.index + 1]):
+            # In the middle of an identifier
+            return False
+        prefix = context.prefix
+        return len(prefix) >= MIN_PREFIX_LENGTH and (
+            prefix[0].isalpha() or prefix[0] == "_"
+        )
+
+    def refresh_completions(self) -> None:
+        """Show the completions for the identifier at the cursor
+
+        This asks the providers for the completions of a new identifier, and
+        only filters the shown ones while still typing the same identifier.
+        It runs once typing pauses for the "debounce_delay" option
+        """
+        # The context might have changed while waiting
+        context = self._hide_or_filter()
+        if context is None:
+            return
+        completions = merge_completions(
+            comp for provider in self._providers for comp in provider.provide(context)
+        )
+        self.completion_popup.show_completions(completions, context.prefix)
+        self._last_context = context
+
+    # ------------------------------------------------------------------
+    # Keys. Each returns whether to consume the key
+    # ------------------------------------------------------------------
+
+    def accept_item(self) -> bool:
+        """Replace the prefix before every cursor with the selected completion
+
+        A cursor with other text before it only gets the rest of the completion.
+        Call it while the popup shows
+        """
+        comp = self.completion_popup.selected_completion()
+        if comp is not None:
+            prefix = self.completion_popup.current_prefix
+            citer = self.editor.citer
+            with self.editor.edit_session():
+                for cursor in citer.iterate_cursors(complete_all=True):
+                    pos = cursor.position()
+                    cursor.setPosition(max(0, pos - len16(prefix)), MM.KeepAnchor)
+                    # Replace the prefix in one edit, so the tree only sees one change
+                    if cursor.selectedText() == prefix:
+                        cursor.insertText(comp.text)
+                    else:
+                        cursor.setPosition(pos)
+                        cursor.insertText(comp.text[len(prefix) :])
+        self.completion_popup.hide()
+        return True
+
+    def select_previous(self) -> bool:
+        self.completion_popup.offset_current(-1)
+        return True
+
+    def select_next(self) -> bool:
+        self.completion_popup.offset_current(1)
+        return True
+
+    def dismiss(self) -> bool:
+        """Hide the popup, and consume the key"""
+        self.completion_popup.hide()
+        return True
+
+    def dismiss_and_pass_key(self) -> bool:
+        """Hide the popup, and let the key through"""
+        self.completion_popup.hide()
+        return False
+
+    def handle_key_press(self, event: QtGui.QKeyEvent) -> bool:
+        # The keys only act on a showing popup, and otherwise go to the next handler
+        if not self.completion_popup.isVisible():
+            return False
+        # Keyed by int, since event.key() is an int and not every key is in the enum
+        actions: dict[int, Callable[[], bool]] = {
+            KEY.Key_Return: self.accept_item,
+            KEY.Key_Enter: self.accept_item,
+            KEY.Key_Tab: self.accept_item,
+            KEY.Key_Up: self.select_previous,
+            KEY.Key_Down: self.select_next,
+            KEY.Key_Escape: self.dismiss,
+            KEY.Key_Backspace: self.dismiss_and_pass_key,
+        }
+        vim_keys = self.options["vim_completion_keys"]
+        if vim_keys and event.modifiers() & MOD.ControlModifier:
+            actions.update(
+                {
+                    KEY.Key_Y: self.accept_item,
+                    KEY.Key_P: self.select_previous,
+                    KEY.Key_N: self.select_next,
+                }
+            )
+        action = actions.get(event.key())
+        return action() if action is not None else False
+
+
+__all__ = [
+    "Completion",
+    "CompletionContext",
+    "CompletionPopup",
+    "Provider",
+    "TabCompletion",
+    "context_at_cursor",
+    "identifier_before",
+]