gitpane 1.0.0__py3-none-any.whl

gitpane/ui/reader/source_text.py

@@ -0,0 +1,134 @@
+"""Keep source characters intact through the line-break normalization Qt applies to a document."""
+
+from __future__ import annotations
+
+import re
+from bisect import bisect_left, bisect_right
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QMimeData
+from PySide6.QtGui import QTextCursor
+from PySide6.QtWidgets import QPlainTextEdit
+
+from gitpane.history.revision_file import utf16_length
+from gitpane.text.text_query import TextQuery
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+
+class SourceTextEdit(QPlainTextEdit):
+    """Map a read-only Qt document back to its literal source for search and copy."""
+
+    def __init__(self) -> None:
+        """Track LF line starts independently of embedded Unicode paragraphs."""
+        super().__init__()
+        self.source_text = ""
+        self.source_lines = [""]
+        self.line_positions = [0]
+        self.collapsed_positions: list[int] = []
+        self.source_cr_positions: list[int] = []
+        self.source_length = 0
+        self.setReadOnly(True)
+        self.setUndoRedoEnabled(False)
+
+    def setPlainText(self, text: str) -> None:
+        """Replace source and its position index before Qt formats the document."""
+        SourceTextEdit.clear(self)
+        self.append_source_text(text)
+
+    def clear(self) -> None:
+        """Discard source mappings together with the document."""
+        self.source_text = ""
+        self.source_lines = [""]
+        self.line_positions = [0]
+        self.collapsed_positions.clear()
+        self.source_cr_positions.clear()
+        self.source_length = 0
+        super().clear()
+
+    def append_source_text(self, text: str) -> None:
+        """Append a batch without splitting CRLF pairs between calls."""
+        source_position = self.source_length
+        document_position = source_position - len(self.collapsed_positions)
+        previous = 0
+        for match in re.finditer("\r\n|\n", text):
+            prefix_length = utf16_length(text[previous:match.start()])
+            source_position += prefix_length
+            document_position += prefix_length
+            if match.group() == "\r\n":
+                self.source_cr_positions.append(source_position)
+                self.collapsed_positions.append(document_position)
+            source_position += len(match.group())
+            document_position += 1
+            self.line_positions.append(document_position)
+            previous = match.end()
+        self.source_length += utf16_length(text)
+        self.source_text += text
+        first_index = 0
+        lines = text.split("\n")
+        last_line_index = len(self.source_lines) - 1
+        self.source_lines[last_line_index] += lines[first_index]
+        self.source_lines.extend(lines[first_index + 1:])
+        cursor = QTextCursor(self.document())
+        cursor.movePosition(QTextCursor.MoveOperation.End)
+        cursor.insertText(text)
+
+    def toPlainText(self) -> str:
+        """Return the literal source, including Unicode separators and CRLF."""
+        return self.source_text
+
+    def logical_line_index(self, position: int) -> int:
+        """Locate the Git LF line containing a Qt cursor or continuation block."""
+        return bisect_right(self.line_positions, position) - 1
+
+    def source_position(self, position: int) -> int:
+        """Translate a document boundary to the original UTF-16 source boundary."""
+        return position + bisect_left(self.collapsed_positions, position)
+
+    def document_position(self, source_position: int) -> int:
+        """Translate an original UTF-16 boundary to Qt's normalized document."""
+        return source_position - bisect_left(self.source_cr_positions, source_position)
+
+    def selected_source_text(self, cursor: QTextCursor) -> str:
+        """Recover exact selected characters that Qt would otherwise normalize."""
+        units_per_character = 2
+        start = self.source_position(cursor.selectionStart()) * units_per_character
+        end = self.source_position(cursor.selectionEnd()) * units_per_character
+        return self.source_text.encode("utf-16-le")[start:end].decode("utf-16-le")
+
+    def createMimeDataFromSelection(self) -> QMimeData:
+        """Copy literal source rather than Qt's substituted paragraph characters."""
+        data = QMimeData()
+        data.setText(self.selected_source_text(self.textCursor()))
+        return data
+
+    def find_source(self, query: str, start: int, backward: bool = False) -> QTextCursor:
+        """Find literal Unicode text across Qt blocks using source UTF-16 offsets."""
+        selected = None
+        for begin, end in self.find_match_range(query, overlap=True):
+            if backward and end <= start:
+                selected = (begin, end)
+            elif not backward and begin >= start:
+                selected = (begin, end)
+                break
+        if selected is None:
+            return QTextCursor()
+        begin, end = selected
+        cursor = QTextCursor(self.document())
+        cursor.setPosition(begin)
+        cursor.setPosition(end, QTextCursor.MoveMode.KeepAnchor)
+        return cursor
+
+    def find_match_range(self, query: str, *, overlap: bool = False, wildcard: bool = False, wildcard_whitespace: bool = True) -> Iterator[tuple[int, int]]:
+        """Map literal or wildcard matches to Qt coordinates while preserving source separators."""
+        if not query:
+            return
+        previous = 0
+        source_position = 0
+        for match_begin, match_end in TextQuery(query, wildcard=wildcard).find_match(self.source_text, overlap=overlap, wildcard_whitespace=wildcard_whitespace):
+            source_position += utf16_length(self.source_text[previous:match_begin])
+            begin = self.document_position(source_position)
+            end = self.document_position(source_position + utf16_length(self.source_text[match_begin:match_end]))
+            previous = match_begin
+            yield begin, end

gitpane/ui/reader/source_view.py

@@ -0,0 +1,151 @@
+"""Read historical source text in a view with line numbers, coloured by bounded syntax decoration."""
+
+from __future__ import annotations
+
+from time import monotonic
+from typing import TYPE_CHECKING
+
+from pygments.lexers import get_lexer_for_filename
+from pygments.styles import get_style_by_name
+from pygments.util import ClassNotFound
+from PySide6.QtCore import QEvent, Qt, QTimer
+from PySide6.QtGui import QPainter, QPalette, QSyntaxHighlighter
+from PySide6.QtWidgets import QWidget
+
+from gitpane.config import FILE_PARSE_BUDGET_MS, LAYOUT_SPACING
+from gitpane.history.revision_file import utf16_length
+from gitpane.ui.look.theme_color import line_number_gutter_color
+from gitpane.ui.reader.source_text import SourceTextEdit
+from gitpane.ui.reader.syntax_span import SyntaxLine, syntax_spans
+
+if TYPE_CHECKING:
+    from PySide6.QtGui import QPaintEvent, QResizeEvent
+
+
+class SourceHighlighter(QSyntaxHighlighter):
+    """Cache syntax per LF line, including Qt continuation paragraphs."""
+
+    def __init__(self, view: SourceFileView) -> None:
+        """Keep formatting separate from the source and its copy/search mapping."""
+        super().__init__(view.document())
+        self.view = view
+        self.lexer = None
+        self.cached_by_line_index: dict[int, tuple[str, SyntaxLine]] = {}
+
+    def highlightBlock(self, text: str) -> None:
+        """Project cached syntax onto the current Qt block without changing text."""
+        if self.lexer is None:
+            return
+        block = self.currentBlock()
+        line_index = self.view.logical_line_index(block.position())
+        source = self.view.source_lines[line_index]
+        cached = self.cached_by_line_index.get(line_index)
+        cached_source, _spans = cached if cached is not None else (None, [])
+        if cached_source != source:
+            cached = (source, syntax_spans(source, self.lexer, self.view.syntax_style))
+            self.cached_by_line_index[line_index] = cached
+        _source, spans = cached
+        block_offset = block.position() - self.view.line_positions[line_index]
+        for start, length, token_format in spans.block_spans(block_offset, utf16_length(text)):
+            self.setFormat(start, length, token_format)
+
+
+class SourceNumberMargin(QWidget):
+    """Number logical source lines outside selectable file content."""
+
+    def __init__(self, view: SourceFileView) -> None:
+        """Follow the source reader's scrolling and font metrics."""
+        super().__init__(view)
+        self.view = view
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        """Paint visible LF line starts without renumbering Unicode continuations."""
+        painter = QPainter(self)
+        painter.fillRect(event.rect(), line_number_gutter_color(self.palette()))
+        painter.setFont(self.view.font())
+        painter.setPen(self.palette().color(QPalette.ColorRole.Text))
+        block = self.view.firstVisibleBlock()
+        while block.isValid():
+            top = round(self.view.blockBoundingGeometry(block).translated(self.view.contentOffset()).top())
+            if top > event.rect().bottom():
+                break
+            line_index = self.view.logical_line_index(block.position())
+            if block.isVisible() and block.position() == self.view.line_positions[line_index]:
+                height = self.view.fontMetrics().height()
+                painter.drawText(0, top, self.width() - LAYOUT_SPACING, height, Qt.AlignmentFlag.AlignRight, str(line_index + 1))
+            block = block.next()
+
+
+class SourceFileView(SourceTextEdit):
+    """Read historical code with literal search, native numbering and safe syntax."""
+
+    def __init__(self) -> None:
+        """Attach source decoration while leaving progressive insertion to its owner."""
+        super().__init__()
+        self.syntax_style = get_style_by_name("default")
+        self.syntax_generation = 0
+        self.highlighter = SourceHighlighter(self)
+        self.number_margin = SourceNumberMargin(self)
+        self.updateRequest.connect(lambda rectangle, distance: self.number_margin.update())
+        self.blockCountChanged.connect(self.refresh_metrics)
+        self.refresh_metrics()
+
+    def set_filename(self, basename: str) -> None:
+        """Choose a lexer by historical filename, falling back to literal plain text."""
+        try:
+            self.highlighter.lexer = get_lexer_for_filename(basename)
+        except ClassNotFound:
+            self.highlighter.lexer = None
+        self.highlighter.cached_by_line_index.clear()
+        self.highlighter.rehighlight()
+
+    def clear(self) -> None:
+        """Discard stale syntax cache and numbering when changing historical files."""
+        self.syntax_generation += 1
+        self.highlighter.cached_by_line_index.clear()
+        super().clear()
+        self.refresh_metrics()
+
+    def refresh_syntax(self) -> None:
+        """Finish syntax for split insertion batches while yielding and honoring cancellation."""
+        self.syntax_generation += 1
+        generation = self.syntax_generation
+        block = self.document().begin()
+
+        def format_blocks() -> None:
+            """Revisit only the current file, under the same budget as text insertion."""
+            nonlocal block
+            if generation != self.syntax_generation:
+                return
+            deadline = monotonic() + FILE_PARSE_BUDGET_MS / 1000
+            while block.isValid() and monotonic() < deadline:
+                self.highlighter.rehighlightBlock(block)
+                block = block.next()
+            if block.isValid():
+                QTimer.singleShot(0, format_blocks)
+
+        format_blocks()
+
+    def refresh_metrics(self) -> None:
+        """Keep numbers aligned with the current font, palette and source line count."""
+        width = self.fontMetrics().horizontalAdvance(str(len(self.line_positions))) + LAYOUT_SPACING * 2
+        self.setViewportMargins(width, 0, 0, 0)
+        self.number_margin.setGeometry(self.contentsRect().left(), self.viewport().geometry().top(), width, self.viewport().height())
+        self.number_margin.update()
+        dark = self.palette().color(QPalette.ColorRole.Base).lightnessF() < 0.5
+        style = get_style_by_name("native" if dark else "default")
+        if style != self.syntax_style:
+            self.syntax_style = style
+            self.highlighter.cached_by_line_index.clear()
+            self.highlighter.rehighlight()
+
+    def resizeEvent(self, event: QResizeEvent) -> None:
+        """Keep the margin aligned when a splitter changes the reader size."""
+        super().resizeEvent(event)
+        self.refresh_metrics()
+
+    def changeEvent(self, event: QEvent) -> None:
+        """Refresh source decoration after native font or palette changes."""
+        super().changeEvent(event)
+        if event.type() in (QEvent.Type.FontChange, QEvent.Type.PaletteChange) and hasattr(self, "number_margin"):
+            self.refresh_metrics()

gitpane/ui/reader/syntax_span.py

@@ -0,0 +1,67 @@
+"""Turn lexer tokens into Qt text format ranges, within a length bound, without generating HTML."""
+
+from __future__ import annotations
+
+from bisect import bisect_right
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from PySide6.QtGui import QColor, QTextCharFormat
+
+from gitpane.config import DIFF_SYNTAX_LIMIT_CHARS
+from gitpane.history.revision_file import utf16_length
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from pygments.lexer import Lexer
+    from pygments.style import Style
+
+
+@dataclass
+class SyntaxLine:
+    """Index token ends so continuation blocks visit only their own syntax ranges."""
+
+    spans: list[tuple[int, int, QTextCharFormat]]
+    end_positions: list[int]
+
+    def block_spans(self, start: int, length: int) -> Iterator[tuple[int, int, QTextCharFormat]]:
+        """Yield clipped ranges using a binary search instead of rescanning the line."""
+        index = bisect_right(self.end_positions, start)
+        end = start + length
+        while index < len(self.spans):
+            offset, token_length, token_format = self.spans[index]
+            if offset >= end:
+                break
+            clipped_start = max(start, offset)
+            clipped_end = min(end, offset + token_length)
+            if clipped_end > clipped_start:
+                yield clipped_start - start, clipped_end - clipped_start, token_format
+            index += 1
+
+
+def syntax_spans(text: str, lexer: Lexer, style: type[Style], prefix_length: int = 0) -> SyntaxLine:
+    """Convert lexer tokens into literal UTF-16 format ranges without generating HTML."""
+    spans = []
+    end_positions = []
+    if len(text) > DIFF_SYNTAX_LIMIT_CHARS:
+        return SyntaxLine(spans, end_positions)
+    previous = prefix_length
+    position = utf16_length(text[:prefix_length])
+    for offset, token, value in lexer.get_tokens_unprocessed(text[prefix_length:]):
+        start = offset + prefix_length
+        position += utf16_length(text[previous:start])
+        length = utf16_length(value)
+        # Lexers can emit specialized tokens absent from a theme; inherit their nearest styled parent.
+        while not style.styles_token(token) and token.parent is not None:
+            token = token.parent
+        token_style = style.style_for_token(token)
+        token_format = QTextCharFormat()
+        if token_style["color"]:
+            token_format.setForeground(QColor("#" + token_style["color"]))
+        token_format.setFontItalic(token_style["italic"])
+        spans.append((position, length, token_format))
+        position += length
+        end_positions.append(position)
+        previous = start + len(value)
+    return SyntaxLine(spans, end_positions)

gitpane/ui/reference/branch_selector.py

@@ -0,0 +1,106 @@
+"""Offer the branches of a reference snapshot in a drop-down list, the checked-out one in bold."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QSignalBlocker, Qt
+from PySide6.QtWidgets import QComboBox, QStyledItemDelegate
+
+from gitpane.config import SHORT_OID_LENGTH
+from gitpane.history.repository_value import ReferenceKind
+from gitpane.ui.look.reference_font import reference_font
+
+if TYPE_CHECKING:
+    from PySide6.QtGui import QWheelEvent
+    from PySide6.QtWidgets import QWidget
+
+    from gitpane.reference.reference_snapshot import ReferenceSnapshot
+
+BRANCH_VISIBLE_ROWS = 20
+BRANCH_MINIMUM_CHARACTERS = 18
+
+
+class BranchSelector(QComboBox):
+    """Keep full references in item data and grouped headers out of keyboard selection."""
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        """Bound toolbar width independently of branch name length and collection size."""
+        super().__init__(parent)
+        self.snapshot: ReferenceSnapshot | None = None
+        self.setItemDelegate(QStyledItemDelegate(self))
+        self.setLabelDrawingMode(QComboBox.LabelDrawingMode.UseDelegate)
+        self.setAccessibleName("Select branch")
+        self.setMinimumContentsLength(BRANCH_MINIMUM_CHARACTERS)
+        self.setSizeAdjustPolicy(QComboBox.SizeAdjustPolicy.AdjustToMinimumContentsLengthWithIcon)
+        self.setMaxVisibleItems(BRANCH_VISIBLE_ROWS)
+        self.setToolTip("Loading references…")
+        self.show_loading()
+        self.currentIndexChanged.connect(lambda: self.setToolTip(self.currentData() or self.currentText()))
+
+    def wheelEvent(self, event: QWheelEvent) -> None:
+        """Let the surrounding form scroll without changing a branch accidentally."""
+        event.ignore()
+
+    def _heading(self, text: str) -> None:
+        self.addItem(text)
+        item = self.model().item(self.count() - 1)
+        item.setFlags(Qt.ItemFlag.NoItemFlags)
+
+    def show_loading(self) -> None:
+        """Retain the real current label while disabling incomplete choices."""
+        if not self.count():
+            self._heading("Loading references…")
+        self.setEnabled(False)
+        self.setToolTip("Loading references…")
+
+    def forget_references(self) -> None:
+        """Drop the branches of the repository shown before and wait, disabled, for the references of the new one.
+
+        Unlike show_loading, the previous current label is not kept: it named a branch of another repository, and it
+        would stay on screen for good if the references of the new repository could not be read.
+        """
+        self.snapshot = None
+        with QSignalBlocker(self):
+            self.clear()
+        self.setAccessibleDescription("")
+        self.show_loading()
+
+    def show_error(self, cause: str) -> None:
+        """Keep the last known HEAD visible and explain why references cannot be used."""
+        self.setEnabled(False)
+        self.setToolTip(cause)
+        self.setAccessibleDescription(cause)
+
+    def populate(self, snapshot: ReferenceSnapshot, selected_ref: str | None = None) -> None:
+        """Group real local and remote branches while retaining exact item identities."""
+        self.snapshot = snapshot
+        with QSignalBlocker(self):
+            self.clear()
+            if snapshot.head_ref is None:
+                label = "Detached HEAD — " + snapshot.head_oid[:SHORT_OID_LENGTH] if snapshot.head_oid else "No HEAD commit"
+                self._heading(label)
+                self.setItemData(self.count() - 1, snapshot.head_oid, Qt.ItemDataRole.ToolTipRole)
+            for kind, empty in ((ReferenceKind.HEADS, "No local branches"), (ReferenceKind.REMOTES, "No remote branches")):
+                self._heading(kind.label)
+                count = 0
+                for reference in sorted(snapshot.references, key=lambda reference: reference.full_name):
+                    if reference.kind != kind:
+                        continue
+                    label = reference.full_name.removeprefix(kind.prefix)
+                    if reference.symbolic_target:
+                        self._heading(label + " → " + reference.symbolic_target)
+                        continue
+                    if reference.target_oid is None:
+                        self._heading(label + " (commit unavailable)")
+                        continue
+                    self.addItem(label, reference.full_name)
+                    self.setItemData(self.count() - 1, reference_font(self.font(), reference), Qt.ItemDataRole.FontRole)
+                    self.setItemData(self.count() - 1, reference.full_name, Qt.ItemDataRole.ToolTipRole)
+                    count += 1
+                if not count:
+                    self._heading(empty)
+            index = self.findData(selected_ref or snapshot.head_ref) if selected_ref or snapshot.head_ref else 0
+            self.setCurrentIndex(index)
+        self.setEnabled(True)
+        self.setToolTip(self.currentData() or self.currentText())