QCodeSitter 0.1.0__tar.gz → 0.2.0__tar.gz

qcodesitter-0.2.0/.github/workflows/publish.yml

@@ -0,0 +1,22 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write  # PyPI trusted publishing, no API token needed
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0  # setuptools-scm needs the tags to compute the version
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.13"
+      - run: python -m pip install build
+      - run: python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1

qcodesitter-0.2.0/.gitignore

@@ -0,0 +1,11 @@
+.benchmarks
+.claude
+.desloppify
+.hypothesis
+.pytest_cache
+.ruff_cache
+.tokensave
+.venv
+USEFUL
+__pycache__
+*.egg-info

{qcodesitter-0.1.0/src/QCodeSitter.egg-info → qcodesitter-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QCodeSitter
-Version: 0.1.0
+Version: 0.2.0
 Summary: A tree-sitter powered code editor widget for Qt
 Author-email: Tyler Fox <tyler@blur.com>
 License-Expression: MIT

qcodesitter-0.2.0/build_venv_and_kickoff.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+set -e
+
+# Resolve the directory this script lives in
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+VENV_DIR="$SCRIPT_DIR/.venv"
+
+# Pick a Python executable. Default to the py launcher
+if command -v py >/dev/null 2>&1; then
+    PYTHON="py -3.13"
+elif command -v python3 >/dev/null 2>&1; then
+    PYTHON=python3
+elif command -v python >/dev/null 2>&1; then
+    PYTHON=python
+else
+    echo "Error: Python not found on PATH"
+    exit 1
+fi
+
+activate_venv() {
+    if [[ -f "$VENV_DIR/bin/activate" ]]; then
+        # macOS / Linux
+        source "$VENV_DIR/bin/activate"
+    elif [[ -f "$VENV_DIR/Scripts/activate" ]]; then
+        # Windows (Git Bash / MSYS)
+        source "$VENV_DIR/Scripts/activate"
+    else
+        echo "Error: Could not find virtualenv activate script"
+        exit 1
+    fi
+}
+
+# Create virtual environment if it doesn't exist
+if [[ ! -d "$VENV_DIR" ]]; then
+    echo "Building Virtualenv..."
+    $PYTHON -m venv "$VENV_DIR"
+
+    activate_venv
+    # Upgrade pip and install PySide6
+    python -m pip install --upgrade pip
+    pip install PySide6 Preditor[cli]
+    pip install -e "${SCRIPT_DIR}[preditor]"
+else
+    activate_venv
+fi
+
+python "${SCRIPT_DIR}/examples/demo.py"

qcodesitter-0.2.0/examples/demo.py

@@ -0,0 +1,26 @@
+"""Open a window with a fully featured editor. Run with `python examples/demo.py`"""
+
+import sys
+
+from Qt import QtWidgets
+
+from QCodeSitter import CodeEditor, default_options, install_default_behaviors
+
+
+def build_window() -> QtWidgets.QMainWindow:
+    win = QtWidgets.QMainWindow()
+    editor = CodeEditor(default_options(), parent=win)
+    install_default_behaviors(editor, optional=True)
+    win.setCentralWidget(editor)
+    return win
+
+
+def main() -> None:
+    app = QtWidgets.QApplication(sys.argv)
+    win = build_window()
+    win.show()
+    app.exec()
+
+
+if __name__ == "__main__":
+    main()

{qcodesitter-0.1.0 → qcodesitter-0.2.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["setuptools>=77"]
+requires = ["setuptools>=77", "setuptools-scm>=8"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "QCodeSitter"
-version = "0.1.0"
+dynamic = ["version"]  # from the git tag, via setuptools-scm
 description = "A tree-sitter powered code editor widget for Qt"
 requires-python = ">=3.10"
 # Qt.py needs a Qt binding: install one yourself, or use the pyside6 extra.
@@ -45,6 +45,8 @@ where = ["src"]
 [tool.setuptools.package-data]
 QCodeSitter = ["py.typed"]
 
+[tool.setuptools_scm]
+
 [tool.mypy]
 python_version = "3.10"
 

{qcodesitter-0.1.0 → qcodesitter-0.2.0}/src/QCodeSitter/behaviors/highlight_matching_selection.py

@@ -22,6 +22,8 @@ class HighlightMatchingSelection(Behavior):
         super().__init__(editor)
         self.watch_options({"colors": self._set_colors})
         self.connect(self.editor.selectionChanged, self.highlight_occurrences)
+        # Ctrl+D adds cursors without changing the primary selection
+        self.connect(self.editor.cursors.changed, self.highlight_occurrences)
 
     def _set_colors(self, colors: GuiColors) -> None:
         self._match_hl = gui_color(colors, "match_hl")
@@ -41,6 +43,12 @@ class HighlightMatchingSelection(Behavior):
             fmt.setBackground(self._match_hl)
             doc = self.editor.document()
             search_cursor = QtGui.QTextCursor(doc)
+            # Qt or MultiCursorPaint already draws the cursors' own selections, and
+            # a highlight over them would hide which occurrences are selected
+            selected = {
+                (state.selectionStart(), state.selectionEnd())
+                for state in (cursor, *self.editor.cursors.secondary)
+            }
             case_sensitive = QtGui.QTextDocument.FindFlag.FindCaseSensitively
 
             while True:
@@ -48,9 +56,8 @@ class HighlightMatchingSelection(Behavior):
                 if search_cursor.isNull():
                     break
 
-                # Qt already highlights the selection itself
                 found = (search_cursor.selectionStart(), search_cursor.selectionEnd())
-                if found != (cursor.selectionStart(), cursor.selectionEnd()):
+                if found not in selected:
                     selection = QtWidgets.QTextEdit.ExtraSelection()
                     selection.cursor = search_cursor
                     selection.format = fmt

qcodesitter-0.2.0/src/QCodeSitter/behaviors/line_commands.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..cursors.state import CursorState, primary_first
+from ..tracked_document import len16
+from ..utils import MM, add_menu_action, make_shortcut_action
+from . import Behavior
+
+if TYPE_CHECKING:
+    from Qt import QtCore, QtGui, QtWidgets
+
+MOVE_UP = ("Move Lines Up", "Ctrl+Shift+Up")
+MOVE_DOWN = ("Move Lines Down", "Ctrl+Shift+Down")
+DUPLICATE = ("Duplicate", "Ctrl+Shift+D")
+
+
+class LineCommands(Behavior):
+    """Move the lines under the cursors up or down, and duplicate the selection
+    or the current line, like PrEditor's QScintilla keys
+    """
+
+    def _commands(self):
+        return (
+            (*MOVE_UP, lambda: self.move_lines(up=True)),
+            (*MOVE_DOWN, lambda: self.move_lines(up=False)),
+            (*DUPLICATE, self.duplicate),
+        )
+
+    def get_hotkeys(self) -> list[QtGui.QAction]:
+        return [
+            make_shortcut_action(self.editor, shortcut, slot, label)
+            for label, shortcut, slot in self._commands()
+        ]
+
+    def add_menu_actions(
+        self, menu: QtWidgets.QMenu, pos: QtCore.QPoint | None
+    ) -> None:
+        for label, shortcut, slot in self._commands():
+            add_menu_action(menu, label, slot, shortcut)
+
+    def duplicate(self) -> None:
+        """Copy each selection after itself and select the copy, or copy the
+        line of a cursor without a selection below it
+        """
+        with self.editor.edit_session():
+            for cursor in self.editor.citer.iterate_cursors(complete_all=True):
+                if cursor.hasSelection():
+                    text = cursor.selection().toPlainText()
+                    end = cursor.selectionEnd()
+                    cursor.setPosition(end)
+                    cursor.insertText(text)
+                    cursor.setPosition(end)
+                    cursor.setPosition(end + len16(text), MM.KeepAnchor)
+                else:
+                    block = cursor.block()
+                    column = cursor.positionInBlock()
+                    cursor.setPosition(block.position() + len16(block.text()))
+                    cursor.insertText("\n" + block.text())
+                    cursor.setPosition(block.next().position() + column)
+
+    def move_lines(self, up: bool) -> None:
+        """Swap the lines under the cursors with the line above or below them
+
+        Nothing moves if any of the lines is already at the edge of the document
+        """
+        doc = self.editor.document()
+        states, primary_index = self.editor.cursors.in_document_order()
+
+        # Group the cursors whose lines touch, as (first line, last line, states)
+        groups: list[tuple[int, int, list[CursorState]]] = []
+        for state in states:
+            first = doc.findBlock(state.selectionStart()).blockNumber()
+            end_block = doc.findBlock(state.selectionEnd())
+            last = end_block.blockNumber()
+            # A selection ending at the start of a line doesn't take that line
+            if last > first and state.selectionEnd() == end_block.position():
+                last -= 1
+            if groups and first <= groups[-1][1] + 1:
+                groups[-1] = (groups[-1][0], max(groups[-1][1], last), groups[-1][2])
+                groups[-1][2].append(state)
+            else:
+                groups.append((first, last, [state]))
+
+        if up and groups[0][0] == 0:
+            return
+        if not up and groups[-1][1] == doc.blockCount() - 1:
+            return
+
+        moved: list[CursorState] = []
+        with self.editor.edit_session():
+            cursor = self.editor.textCursor()
+            cursor.beginEditBlock()
+            try:
+                for first, last, group in groups:
+                    span_first, span_last = (
+                        (first - 1, last) if up else (first, last + 1)
+                    )
+                    start_block = doc.findBlockByNumber(span_first)
+                    end_block = doc.findBlockByNumber(span_last)
+                    cursor.setPosition(start_block.position())
+                    cursor.setPosition(
+                        end_block.position() + len16(end_block.text()), MM.KeepAnchor
+                    )
+                    lines = cursor.selection().toPlainText().split("\n")
+                    # The swapped line's length plus its newline is how far the others move
+                    if up:
+                        lines.append(lines.pop(0))
+                        shift = -len16(lines[-1]) - 1
+                    else:
+                        lines.insert(0, lines.pop())
+                        shift = len16(lines[0]) + 1
+                    # The text keeps its length, so the later groups stay put
+                    cursor.insertText("\n".join(lines))
+                    moved += [
+                        CursorState(s.anchor + shift, s.position + shift) for s in group
+                    ]
+            finally:
+                cursor.endEditBlock()
+            self.editor.cursors.replace_all(primary_first(moved, primary_index))

{qcodesitter-0.1.0 → qcodesitter-0.2.0}/src/QCodeSitter/behaviors/multi_cursor_paint.py

@@ -67,7 +67,7 @@ class MultiCursorPaint(Behavior):
         states = [*self.editor.cursors.secondary, self.editor.cursors.primary()]
 
         fmt = QtGui.QTextCharFormat()
-        fmt.setBackground(self.secondary_selection_color.lighter(150))
+        fmt.setBackground(self.secondary_selection_color)
         doc = self.editor.document()
         selections = []
         for state in states:

{qcodesitter-0.1.0 → qcodesitter-0.2.0}/src/QCodeSitter/behaviors/syntax_highlighting.py

@@ -81,6 +81,12 @@ class TreeSitterHighlighter(QtGui.QSyntaxHighlighter):
         block = self.currentBlock()
         if tree is None or not block.isValid():
             return
+        if self.tree_manager.reparse_pending:
+            # Qt highlights every block between the first and last edit of an
+            # edit block. Keep their formats, the reparse redoes the edited rows
+            for fmt_range in block.layout().formats():
+                self.setFormat(fmt_range.start, fmt_range.length, fmt_range.format)
+            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

{qcodesitter-0.1.0 → qcodesitter-0.2.0}/src/QCodeSitter/cursors/multi.py

@@ -126,13 +126,34 @@ class MultiCursor(QtCore.QObject):
         search_text = cursor.selectedText()
         all_cursors = self._primary_first()
         next_pos = self._find(search_text, max(c.selectionEnd() for c in all_cursors))
+        length = len16(search_text)
         if next_pos < 0:
-            # Wrap around to the start, but only up to the first cursor
+            # Wrap around to the start, skipping occurrences that have a cursor
+            taken = {c.selectionStart() for c in all_cursors}
             next_pos = self._find(search_text, 0)
-            if next_pos < 0 or next_pos >= min(c.selectionStart() for c in all_cursors):
+            while next_pos in taken:
+                next_pos = self._find(search_text, next_pos + length)
+            if next_pos < 0:
                 return False
-        end = next_pos + len16(search_text)
-        return self._add([*all_cursors, CursorState(next_pos, end)])
+        end = next_pos + length
+        added = self._add([*all_cursors, CursorState(next_pos, end)])
+        if added:
+            self._scroll_to(end)
+        return added
+
+    def _scroll_to(self, position: int) -> None:
+        """Scroll to show a position, leaving the primary cursor where it is"""
+        # Qt only scrolls to the primary cursor, so borrow it to find the scroll
+        editor = self.editor
+        primary = editor.textCursor()
+        bars = (editor.horizontalScrollBar(), editor.verticalScrollBar())
+        editor.setTextCursor(
+            CursorState(position, position).build_cursor(editor.document())
+        )
+        values = [bar.value() for bar in bars]
+        editor.setTextCursor(primary)
+        for bar, value in zip(bars, values):
+            bar.setValue(value)
 
     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

{qcodesitter-0.1.0 → qcodesitter-0.2.0}/src/QCodeSitter/defaults.py

@@ -12,6 +12,7 @@ from .behaviors.code_folding import CodeFolding
 from .behaviors.comment_toggle import CommentToggle
 from .behaviors.highlight_matching_brackets import HighlightMatchingBrackets
 from .behaviors.highlight_matching_selection import HighlightMatchingSelection
+from .behaviors.line_commands import LineCommands
 from .behaviors.line_numbers import LineNumbers
 from .behaviors.multi_cursor_paint import MultiCursorPaint
 from .behaviors.overscroll import Overscroll
@@ -38,6 +39,7 @@ DEFAULT_BEHAVIORS: tuple[type[Behavior], ...] = (
     MultiCursorPaint,
     CodeFolding,
     CommentToggle,
+    LineCommands,
 )
 
 # The built-in behaviors that are off by default

{qcodesitter-0.1.0 → qcodesitter-0.2.0}/src/QCodeSitter/gui_colors.py

@@ -31,7 +31,7 @@ GUI_COLOR_DEFAULTS: GuiColors = {
     "primary_cursor": "#FFFFFFFF",
     "secondary_cursor": "#B4B4B4",
     "selection": "#094771",
-    "secondary_selection": "#B4B4B4",
+    "secondary_selection": "#264F78",
 }
 
 # Gui color name -> its default, made from the other colors

{qcodesitter-0.1.0 → qcodesitter-0.2.0}/src/QCodeSitter/themes.py

@@ -36,6 +36,7 @@ DARK_THEME: Theme = {
         "red":             "#FF5555",
         "orange":          "#FFB86C",
         "yellow":          "#F1FA8C",
+        "faint_yellow":    "#40F1FA8C",
         "green":           "#50fa7b",
         "purple":          "#BD93F9",
         "cyan":            "#8BE9FD",
@@ -72,14 +73,14 @@ DARK_THEME: Theme = {
         "gutter_fg":           "xlight_slate",
         "hl_dim":              "mid_light_slate",
         "manual_fold":         "orange",
-        "match_hl":            "bright_yellow",
+        "match_hl":            "faint_yellow",
         "menu":                "dark_slate",
         "outside_bg":          "dark_slate",
         "pair_hl":             "mid_gray",
         "primary_cursor":      "bright_white",
         "secondary_cursor":    "half_mid_gray",
         "selection":           "mid_light_slate",
-        "secondary_selection": "half_mid_gray",
+        "secondary_selection": "light_slate",
     },
 
     "syntax" : {
@@ -173,14 +174,14 @@ LIGHT_THEME: Theme = {
         "gutter_fg":           "fg",
         "hl_dim":              "filled_blue",
         "manual_fold":         "yellow",
-        "match_hl":            "filled_green",
+        "match_hl":            "bg_green",
         "menu":                "bg4",
         "outside_bg":          "bg_grey",
         "pair_hl":             "bg_yellow",
         "primary_cursor":      "true_black",
         "secondary_cursor":    "true_black",
         "selection":           "filled_blue",
-        "secondary_selection": "blue",
+        "secondary_selection": "filled_blue",
     },
 
     "syntax" : {

{qcodesitter-0.1.0 → qcodesitter-0.2.0}/src/QCodeSitter/tree_manager.py

@@ -26,8 +26,8 @@ class TreeManager(QtCore.QObject):
         # Whether an edit was made while paused, so unpausing has to reparse
         self._reparse_pending = False
 
-        # The (first, last) rows touched by edits since the last parse
-        self._edit_rows: tuple[int, int] | None = None
+        # The (first, last) rows of each edit since the last parse
+        self._edit_rows: list[tuple[int, int]] = []
         # The (first, last) row ranges that changed in the last parse
         # None means the whole document changed
         self.changed_rows: list[tuple[int, int]] | None = None
@@ -42,6 +42,11 @@ class TreeManager(QtCore.QObject):
     def is_paused(self) -> bool:
         return self._pause_depth > 0
 
+    @property
+    def reparse_pending(self) -> bool:
+        """Whether edits are held by a pause, and the tree is out of date"""
+        return self._pause_depth > 0 and self._reparse_pending
+
     def set_language(self, language: Language | None) -> None:
         """Change the language, and parse the document again"""
         self._set_parser(language)
@@ -51,7 +56,7 @@ class TreeManager(QtCore.QObject):
     def _set_parser(self, language: Language | None) -> None:
         self.parser = Parser(language) if language is not None else None
         self.tree = None
-        self._edit_rows = None
+        self._edit_rows = []
         self.changed_rows = None
 
     def treesitter_source_callback(self, _byte_offset: int, ts_point: Point) -> bytes:
@@ -73,7 +78,7 @@ class TreeManager(QtCore.QObject):
     def parse_from_scratch(self) -> None:
         """Parse the whole document from scratch. Without a language there is no tree"""
         self.tree = self._parse(self.parser) if self.parser is not None else None
-        self._edit_rows = None
+        self._edit_rows = []
         self.changed_rows = None
         self.reparsed.emit()
 
@@ -97,20 +102,22 @@ class TreeManager(QtCore.QObject):
     def _track_edit_rows(
         self, start_row: int, old_end_row: int, new_end_row: int
     ) -> None:
-        """Grow the span of edited rows to include this edit
+        """Add this edit's rows to the edited spans
 
-        The span is kept in the current document's rows, so rows after
-        the edit shift by the number of lines it added or removed
+        Spans are kept separate, so edits far apart (ie: multi-cursor) don't
+        mark every row between them. They're kept in the current document's
+        rows, so earlier spans shift by the lines this edit added or removed
         """
-        if self._edit_rows is None:
-            self._edit_rows = (start_row, new_end_row)
-            return
-        lo, hi = self._edit_rows
-        if hi > old_end_row:
-            hi += new_end_row - old_end_row
-        else:
-            hi = new_end_row
-        self._edit_rows = (min(lo, start_row), hi)
+        delta = new_end_row - old_end_row
+
+        def shift(row: int) -> int:
+            if row > old_end_row:
+                return row + delta
+            # A row inside a removed range collapses to the edit's end
+            return min(row, new_end_row) if row > start_row else row
+
+        self._edit_rows = [(shift(lo), shift(hi)) for lo, hi in self._edit_rows]
+        self._edit_rows.append((start_row, new_end_row))
 
     def apply_edit(
         self,
@@ -145,7 +152,7 @@ class TreeManager(QtCore.QObject):
             return
 
         if self.parser is None:
-            self._edit_rows = None
+            self._edit_rows = []
             return
 
         old_tree = self.tree
@@ -159,10 +166,9 @@ class TreeManager(QtCore.QObject):
                 (r.start_point.row, r.end_point.row)
                 for r in old_tree.changed_ranges(self.tree)
             ]
-            if self._edit_rows is not None:
-                rows.append(self._edit_rows)
+            rows.extend(self._edit_rows)
             self.changed_rows = rows
-        self._edit_rows = None
+        self._edit_rows = []
         self.reparsed.emit()
 
     def node_at_byte(self, byte_offset: int) -> Node | None:

{qcodesitter-0.1.0 → qcodesitter-0.2.0/src/QCodeSitter.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QCodeSitter
-Version: 0.1.0
+Version: 0.2.0
 Summary: A tree-sitter powered code editor widget for Qt
 Author-email: Tyler Fox <tyler@blur.com>
 License-Expression: MIT

{qcodesitter-0.1.0 → qcodesitter-0.2.0}/src/QCodeSitter.egg-info/SOURCES.txt

@@ -1,6 +1,11 @@
+.gitignore
 LICENSE.txt
 README.md
+build_venv_and_kickoff.sh
 pyproject.toml
+tox.ini
+.github/workflows/publish.yml
+examples/demo.py
 src/QCodeSitter/__init__.py
 src/QCodeSitter/code_editor.py
 src/QCodeSitter/defaults.py
@@ -19,6 +24,8 @@ src/QCodeSitter.egg-info/SOURCES.txt
 src/QCodeSitter.egg-info/dependency_links.txt
 src/QCodeSitter.egg-info/entry_points.txt
 src/QCodeSitter.egg-info/requires.txt
+src/QCodeSitter.egg-info/scm_file_list.json
+src/QCodeSitter.egg-info/scm_version.json
 src/QCodeSitter.egg-info/top_level.txt
 src/QCodeSitter/behaviors/__init__.py
 src/QCodeSitter/behaviors/auto_bracket.py
@@ -26,6 +33,7 @@ src/QCodeSitter/behaviors/code_folding.py
 src/QCodeSitter/behaviors/comment_toggle.py
 src/QCodeSitter/behaviors/highlight_matching_brackets.py
 src/QCodeSitter/behaviors/highlight_matching_selection.py
+src/QCodeSitter/behaviors/line_commands.py
 src/QCodeSitter/behaviors/line_numbers.py
 src/QCodeSitter/behaviors/multi_cursor_paint.py
 src/QCodeSitter/behaviors/overscroll.py
@@ -49,4 +57,35 @@ src/QCodeSitter/languages/base.py
 src/QCodeSitter/languages/python.py
 src/QCodeSitter/languages/python_highlights.py
 src/QCodeSitter/queries/__init__.py
-src/QCodeSitter/queries/predicates.py
+src/QCodeSitter/queries/predicates.py
+tests/__init__.py
+tests/conftest.py
+tests/helpers.py
+tests/behaviors/__init__.py
+tests/behaviors/test_behaviors.py
+tests/behaviors/test_code_folding.py
+tests/behaviors/test_comment_toggle.py
+tests/behaviors/test_gutters.py
+tests/behaviors/test_highlight_matching.py
+tests/behaviors/test_tab_completion.py
+tests/editor/__init__.py
+tests/editor/test_clipboard.py
+tests/editor/test_cursors.py
+tests/editor/test_editing_keys.py
+tests/editor/test_editor_core.py
+tests/editor/test_line_edits.py
+tests/editor/test_multi_cursor.py
+tests/editor/test_options.py
+tests/editor/test_shortcuts.py
+tests/editor/test_utils.py
+tests/fuzz/__init__.py
+tests/fuzz/test_fuzz.py
+tests/integration/__init__.py
+tests/integration/test_demo.py
+tests/integration/test_preditor_interface.py
+tests/syntax/__init__.py
+tests/syntax/test_incremental.py
+tests/syntax/test_languages.py
+tests/syntax/test_queries.py
+tests/syntax/test_syntax.py
+tests/syntax/test_themes.py