QCodeSitter 0.1.0__py3-none-any.whl

QCodeSitter/behaviors/tab_completion/popup.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from collections.abc import Collection
+from typing import TYPE_CHECKING
+
+from Qt import QtCore, QtGui, QtWidgets
+
+from ...gui_colors import GuiColors, gui_color
+from .types import Completion
+
+if TYPE_CHECKING:
+    from ...code_editor import CodeEditor
+
+ROLE = QtCore.Qt.ItemDataRole.UserRole
+
+
+class CompletionPopup(QtWidgets.QListWidget):
+    """A list of completions shown under the cursor, without taking focus"""
+
+    MIN_WIDTH = 200
+    MAX_WIDTH = 500
+    MAX_HEIGHT = 300
+    # Only measure this many items when sizing the popup to its contents
+    MEASURED_ITEMS = 20
+
+    def __init__(self, parent: CodeEditor) -> None:
+        super().__init__(parent)
+        self.editor = parent
+        self.all_completions: list[Completion] = []
+        self.current_prefix: str = ""
+
+        # A Tool window instead of a Popup lets the editor keep receiving key events
+        self.setWindowFlags(
+            QtCore.Qt.WindowType.Tool
+            | QtCore.Qt.WindowType.FramelessWindowHint
+            | QtCore.Qt.WindowType.WindowStaysOnTopHint
+        )
+        self.setAttribute(QtCore.Qt.WidgetAttribute.WA_ShowWithoutActivating)
+        self.setFocusPolicy(QtCore.Qt.FocusPolicy.NoFocus)
+        self.setAutoFillBackground(True)
+
+        self.setMinimumWidth(self.MIN_WIDTH)
+        self.setMaximumWidth(self.MAX_WIDTH)
+        self.setMaximumHeight(self.MAX_HEIGHT)
+        self.setVerticalScrollMode(
+            QtWidgets.QAbstractItemView.ScrollMode.ScrollPerPixel
+        )
+        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+
+    def set_colors(self, colors: GuiColors) -> None:
+        """Color the popup with the "menu", "fg" and "selection" gui colors"""
+        palette = self.palette()
+        role = QtGui.QPalette.ColorRole
+        for roles, name in (
+            ((role.Base, role.Window), "menu"),
+            ((role.Text, role.HighlightedText), "fg"),
+            ((role.Highlight,), "selection"),
+        ):
+            for color_role in roles:
+                palette.setColor(color_role, gui_color(colors, name))
+        self.setPalette(palette)
+
+    def show_completions(
+        self, completions: Collection[Completion], prefix: str
+    ) -> None:
+        """Show a new set of completions, filtered by the prefix"""
+        self.all_completions = sorted(
+            completions, key=lambda c: (-c.priority, c.text.lower())
+        )
+        self.update_filter(prefix)
+
+    def update_filter(self, prefix: str) -> None:
+        """Show the completions that start with a new prefix, without asking the providers"""
+        self.current_prefix = prefix
+        prefix_lower = prefix.lower()
+        self.clear()
+        for comp in self.all_completions:
+            if comp.text.lower().startswith(prefix_lower) and comp.text != prefix:
+                item = QtWidgets.QListWidgetItem(comp.display())
+                item.setData(ROLE, comp)
+                self.addItem(item)
+
+        if self.count() == 0:
+            self.hide()
+            return
+        self.setCurrentRow(0)
+        self._position_at_cursor()
+        self.show()
+
+    def _position_at_cursor(self) -> None:
+        """Size the popup to its items, and put it below the cursor, or above it
+        if there isn't room on the screen"""
+        widths = (
+            self.fontMetrics().horizontalAdvance(self.item(i).text()) + 30
+            for i in range(min(self.count(), self.MEASURED_ITEMS))
+        )
+        self.setFixedWidth(min(max(self.MIN_WIDTH, *widths), self.MAX_WIDTH))
+        self.setFixedHeight(
+            min(self.count() * self.sizeHintForRow(0) + 4, self.MAX_HEIGHT)
+        )
+
+        cursor_rect = self.editor.cursorRect(self.editor.textCursor())
+        popup_pos = self.editor.mapToGlobal(cursor_rect.bottomLeft())
+        screen = QtGui.QGuiApplication.screenAt(
+            self.editor.mapToGlobal(self.editor.rect().center())
+        )
+        if screen is None:
+            screen = QtGui.QGuiApplication.primaryScreen()
+        if popup_pos.y() + self.height() > screen.availableGeometry().bottom():
+            popup_pos = self.editor.mapToGlobal(cursor_rect.topLeft())
+            popup_pos.setY(popup_pos.y() - self.height())
+        self.move(popup_pos)
+
+    def selected_completion(self) -> Completion | None:
+        """The selected completion, or None when nothing is selected"""
+        item = self.currentItem()
+        return None if item is None else item.data(ROLE)
+
+    def offset_current(self, offset: int) -> None:
+        """Move the selection by offset rows, wrapping around the ends"""
+        row = (self.currentRow() + offset) % self.count()
+        self.setCurrentRow(row)
+        self.scrollToItem(self.item(row))

QCodeSitter/behaviors/tab_completion/providers.py

@@ -0,0 +1,66 @@
+"""The built-in completion providers"""
+
+from __future__ import annotations
+
+import inspect
+import sys
+
+from ...languages import identifier_query
+from ...queries import query_byte_range
+from .types import Completion, CompletionContext, Provider
+
+
+class IdentifierProvider(Provider):
+    """Completes the names defined in the document
+
+    The names come from the identifier query of the editor language's LanguageSpec
+    """
+
+    PRIORITY = 3
+
+    def provide(self, context: CompletionContext) -> set[Completion]:
+        tree = self.editor.tree_manager.tree
+        if tree is None:
+            return set()
+        query = identifier_query(tree.language)
+        if query is None:
+            return set()
+
+        doc = self.editor.document()
+        root = tree.root_node
+        captures = query_byte_range(query, root, 0, root.end_byte, doc.node_text)
+        identifiers = set()
+        for capture_name, nodes in captures.items():
+            for node in nodes:
+                name = doc.node_text(node)
+                if name.isidentifier():
+                    identifiers.add(Completion(name, capture_name, self.PRIORITY))
+        return identifiers
+
+
+def _kind_of(value: object) -> str:
+    if inspect.ismodule(value):
+        return "module"
+    if isinstance(value, type):
+        return "class"
+    if callable(value):
+        return "function"
+    return "variable"
+
+
+class MainPythonProvider(Provider):
+    """Completes the names in the running python's __main__ namespace
+
+    Useful when the editor is a console for the python process it runs in
+    """
+
+    PRIORITY = 3
+
+    def provide(self, context: CompletionContext) -> set[Completion]:
+        namespace = vars(sys.modules["__main__"])
+        prefix = context.prefix.lower()
+        return {
+            Completion(name, _kind_of(value), self.PRIORITY)
+            for name, value in namespace.items()
+            if name.lower().startswith(prefix)
+        }

QCodeSitter/behaviors/tab_completion/types.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from tree_sitter import Node
+
+    from ...code_editor import CodeEditor
+
+
+@dataclass(frozen=True)
+class Completion:
+    """A single completion result
+
+    Equal names of the same kind are one completion, whatever their priority
+    """
+
+    text: str  # Completion text (e.g., "path")
+    kind: str  # "function", "class", "variable", "module", etc.
+    # For sorting (higher = more important)
+    priority: int = field(compare=False)
+
+    def display(self) -> str:
+        return f"{self.text} ({self.kind})"
+
+
+@dataclass
+class CompletionContext:
+    """Where the cursor is, and what it is completing
+
+    The columns are str indexes into `line`, not Qt positions
+    """
+
+    line_num: int  # 0-indexed line number
+    index: int  # The cursor's column
+    prefix: str  # The identifier being completed, before the cursor
+    start: int  # The column the prefix starts at
+    line: str  # The text of the cursor's line
+    node: Node | None  # Tree-sitter node at the cursor
+
+
+class Provider:
+    """A source of completions for TabCompletion"""
+
+    def __init__(self, editor: CodeEditor) -> None:
+        self.editor = editor
+
+    def provide(self, context: CompletionContext) -> set[Completion]:
+        """The completions for the identifier at the cursor
+
+        The popup only shows the ones that start with `context.prefix`, so
+        returning more is fine
+        """
+        raise NotImplementedError("A Provider must override the .provide() method")