iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/widgets/diff_view/code.py

@@ -0,0 +1,280 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""The code of a diff: a column that scrolls both ways and draws only the rows on screen."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, ClassVar, NamedTuple
+
+from textual.cache import LRUCache
+from textual.content import Content
+from textual.dom import NoScreen
+from textual.geometry import Region, Size
+from textual.scroll_view import ScrollView
+from textual.strip import Strip
+from textual.style import Style as VisualStyle
+
+from chrys.app.tui.support.gc_freeze import detach_lru_cache, renew_lru_cache
+from chrys.app.tui.widgets import HATCH_GLYPH, normalize_selection_rich_style
+from chrys.app.tui.widgets.diff_view.palette import DiffLook
+from chrys.app.tui.widgets.diff_view.rows import DiffRow
+
+if TYPE_CHECKING:
+    from textual.selection import Selection
+
+    from chrys.app.tui.widgets.diff_view.gutter import GutterColumn
+
+
+class _Frame(NamedTuple):
+    """What every row of one repaint has in common, measured once instead of once per row."""
+
+    scroll_x: int
+    scroll_y: int
+    width: int
+    """The cells a row may fill. The scrollbar gutter is always reserved and lies outside it."""
+    content_width: int
+    selection: Selection | None
+
+
+class CodeColumn(ScrollView):
+    """The code of one side of a diff, or of both in a unified one.
+
+    Textual asks for the lines of the viewport only, so a diff of any length costs what its
+    visible part costs. A rendered row is kept until the scroll position across, the width or the
+    look of the app changes; scrolling down reuses all of them.
+    """
+
+    ALLOW_SELECT = True
+
+    COMPONENT_CLASSES: ClassVar[set[str]] = {"hatch--pattern"}
+
+    DEFAULT_CSS = """
+    CodeColumn > .hatch--pattern {
+        color: $hatch-color;
+    }
+    CodeColumn {
+        overflow: auto auto;
+        scrollbar-size: 1 2;
+        scrollbar-gutter: stable;
+        width: 1fr;
+        height: 1fr;
+    }
+    """
+
+    def __init__(
+        self,
+        rows: Sequence[DiffRow],
+        code_width: int,
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        super().__init__(name=name, id=id, classes=classes)
+        self.rows = rows
+        self.code_width = code_width
+        self.scroll_sync: CodeColumn | None = None
+        """The other side of a split diff, which scrolls along."""
+        self.gutters: list[GutterColumn] = []
+        """The columns beside this one. They follow its scroll position and have none of their own."""
+        self._syncing = False
+        self._strip_cache: LRUCache[int, Strip] = LRUCache(maxsize=2000)
+        self._strips_valid_for: tuple[int, int] | None = None
+        self._look_key: tuple[str, str | None] | None = None
+        self._look: DiffLook | None = None
+        self._frame: _Frame | None = None
+        self._painted: tuple[tuple[_Frame, Region], list[Strip]] | None = None
+
+    # -- caches ------------------------------------------------------------------------------------
+
+    def prepare_for_gc_freeze(self) -> None:
+        """Detach the cyclic strip LRU before the permanent generation changes."""
+        # gc-freeze swaps in an acyclic capacity token; renew restores a real cache before next use.
+        self._strip_cache = detach_lru_cache(self._strip_cache)  # ty: ignore[invalid-assignment]
+        self._painted = None
+
+    def after_gc_freeze(self) -> None:
+        """Recreate the strip LRU after the permanent generation changes."""
+        self._strip_cache = renew_lru_cache(self._strip_cache)
+
+    def abort_gc_freeze(self) -> None:
+        """Restore the strip LRU after an incomplete hook pass."""
+        self._strip_cache = renew_lru_cache(self._strip_cache)
+
+    def _invalidate_render_cache(self) -> None:
+        self._strip_cache.clear()
+        self._strips_valid_for = None
+        self._look_key = None
+        self._look = None
+        self._painted = None
+
+    def notify_style_update(self) -> None:
+        """Forget rendered rows when the theme or a CSS variable changes."""
+        super().notify_style_update()
+        self._invalidate_render_cache()
+        self.refresh()
+
+    def _current_look(self) -> DiffLook:
+        if self._look is None:
+            self._look = DiffLook.of(self)
+        return self._look
+
+    # -- rendering ---------------------------------------------------------------------------------
+
+    def on_mount(self) -> None:
+        self.virtual_size = Size(self.code_width, len(self.rows))
+
+    def _get_render_width(self) -> int:
+        """The width rows are rendered at.
+
+        With ``scrollbar-gutter: stable`` the scrollbar's column is always reserved. Rows fill the
+        scrollable area, and the scrollbar or the widget's background takes the column beside it.
+        """
+        return self.scrollable_content_region.width
+
+    def _begin_frame(self) -> _Frame:
+        """Measure what a repaint depends on, and forget the rows those measurements have outdated."""
+        look_key = (self.app.theme, self.app.console.color_system)
+        if look_key != self._look_key:
+            self._invalidate_render_cache()
+            self._look_key = look_key
+        scroll_x, scroll_y = self.scroll_offset
+        frame = _Frame(
+            round(scroll_x),
+            round(scroll_y),
+            self._get_render_width(),
+            self.content_region.width,
+            self._safe_text_selection(),
+        )
+        if (frame.scroll_x, frame.width) != self._strips_valid_for:
+            self._strip_cache.clear()
+            self._strips_valid_for = (frame.scroll_x, frame.width)
+        return frame
+
+    def _safe_text_selection(self) -> Selection | None:
+        try:
+            return self.text_selection
+        except NoScreen:
+            return None
+
+    def render_lines(self, crop: Region) -> list[Strip]:
+        if not self.is_attached:
+            return [Strip.blank(crop.width) for _ in crop.line_range]
+        frame = self._begin_frame()
+        if frame.selection is None and self._painted is not None and self._painted[0] == (frame, crop):
+            # Nothing moved: a repaint asked for by something else, say the parent scrolling.
+            return self._painted[1]
+        self._frame = frame
+        try:
+            strips = self._render_lines_direct(crop)
+        finally:
+            self._frame = None
+        self._painted = ((frame, crop), strips) if frame.selection is None else None
+        return strips
+
+    def _render_lines_direct(self, crop: Region) -> list[Strip]:
+        """Render the visible rows without Textual's generic style wrapper.
+
+        The column has neither border nor padding, and `render_line` already resolves a row's
+        background and text styles. Going around ``StylesCache.render`` matters when the parent
+        scrolls over a clipped diff: the crop then changes with every frame, and the generic cache
+        would walk every visible row although the rows themselves are all cached.
+        """
+        if self._frame is None:
+            raise RuntimeError("Rendering diff lines requires a prepared frame.")
+        content_width = self._frame.content_width
+        rich_style = self.visual_style.rich_style
+        line_filters = self.get_line_filters()
+        _base_background, background = self.background_colors
+        strips: list[Strip] = []
+        for y in crop.line_range:
+            strip = self.render_line(y)
+            if strip.cell_length != content_width:
+                strip = strip.adjust_cell_length(content_width, rich_style)
+            for line_filter in line_filters:
+                strip = strip.apply_filter(line_filter, background)
+            if crop.column_span != (0, content_width):
+                strip = strip.crop(crop.x, crop.x + crop.width)
+            strips.append(strip)
+        return strips
+
+    def render_line(self, y: int) -> Strip:
+        if not self.is_attached:
+            return Strip.blank(max(0, self.size.width))
+        # Outside a repaint of our own, a caller gets the row as it would be drawn right now.
+        frame = self._begin_frame() if self._frame is None else self._frame
+        index = frame.scroll_y + y
+        if not 0 <= index < len(self.rows):
+            return Strip.blank(frame.width, self.visual_style.rich_style)
+        selected = None if frame.selection is None else frame.selection.get_span(index)
+        if selected is not None:
+            return self._render_row(index, frame, selected)
+        strip = self._strip_cache.get(index)
+        if strip is None:
+            strip = self._strip_cache[index] = self._render_row(index, frame, None)
+        return strip
+
+    def _render_row(self, index: int, frame: _Frame, selected: tuple[int, int] | None) -> Strip:
+        row = self.rows[index]
+        visual_style = self.visual_style
+        width = frame.width
+        if row.code is None:
+            # A break or a filler spans the viewport and stays put when the code scrolls sideways.
+            line = Content.styled(HATCH_GLYPH * width, self._current_look().hatch)
+            strip = Strip(line.render_segments(visual_style), cell_length=line.cell_length)
+            return strip.adjust_cell_length(width, visual_style.rich_style)
+
+        line = row.code
+        if selected is not None:
+            start, end = selected
+            selection_style = normalize_selection_rich_style(self.screen.get_component_rich_style("screen--selection"))
+            line = line.stylize(VisualStyle.from_rich_style(selection_style), start, len(line) if end == -1 else end)
+        # The line's background reaches the edge of the viewport, also where that is wider than the code.
+        if (padding := max(self.code_width, width) - line.cell_length) > 0:
+            line = line.pad_right(padding)
+        line = line.stylize_before(self._current_look().line_style(row.kind))
+        strip = Strip(line.render_segments(visual_style), cell_length=line.cell_length)
+        # Textual finds the character under the pointer from offsets that count characters of the
+        # line, so the strip has to say which one the scroll position brought to its left edge.
+        # The crop is asked, not a rule of our own: where it cuts through wide characters, emoji
+        # sequences and combining marks is its business, and the count must agree with what it left.
+        visible = strip.crop(frame.scroll_x)
+        first_character = len(line) - sum(len(segment.text) for segment in visible)
+        strip = visible.crop(0, width).adjust_cell_length(width, visual_style.rich_style)
+        return strip.apply_offsets(first_character, index)
+
+    # -- scrolling ---------------------------------------------------------------------------------
+
+    def watch_scroll_y(self, old_value: float, new_value: float) -> None:
+        super().watch_scroll_y(old_value, new_value)
+        if self._syncing:
+            return
+        self._syncing = True
+        try:
+            if self.scroll_sync is not None and self.scroll_sync.scroll_offset.y != new_value:
+                self.scroll_sync.scroll_y = new_value
+            # The gutters show other rows only once the position has moved by a whole line.
+            if round(old_value) != round(new_value):
+                for gutter in self.gutters:
+                    gutter.refresh()
+        finally:
+            self._syncing = False
+
+    def watch_scroll_x(self, old_value: float, new_value: float) -> None:
+        super().watch_scroll_x(old_value, new_value)
+        if self._syncing:
+            return
+        self._syncing = True
+        try:
+            if self.scroll_sync is not None and self.scroll_sync.scroll_offset.x != new_value:
+                self.scroll_sync.scroll_x = new_value
+        finally:
+            self._syncing = False
+
+    # -- selection ---------------------------------------------------------------------------------
+
+    def get_selection(self, selection: Selection) -> tuple[str, str] | None:
+        """The selected code. A break or a filler counts as an empty line, which keeps rows and lines in step."""
+        text = "\n".join("" if row.code is None else row.code.plain for row in self.rows)
+        return selection.extract(text), "\n"

chrys/app/tui/widgets/diff_view/compute.py

@@ -0,0 +1,286 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Working out a diff: its hunks, and both texts as highlighted lines.
+
+Nothing here touches a widget, so all of it can run off the event loop.
+"""
+
+from __future__ import annotations
+
+import difflib
+import os
+from collections.abc import Sequence
+from functools import lru_cache
+
+from pygments.lexers import find_lexer_class_for_filename
+from textual import highlight
+from textual.content import Content, Span
+
+from chrys.app.tui.widgets.diff_view.palette import ADDED_EMPHASIS, REMOVED_EMPHASIS
+from chrys.app.tui.widgets.diff_view.rows import Hunk
+from chrys.app.tui.widgets.syntax_theme import NoErrorHighlightTheme
+
+_EMPHASIS_SIMILARITY_CUTOFF = 0.5
+"""Two lines less alike than this are different lines, not one line edited. Picking out the few
+characters they happen to share would be noise on top of backgrounds that already say as much."""
+_EMPHASIS_MAX_LINE_LENGTH = 500
+"""Comparing characters takes time quadratic in the length of a line. Minified code is not worth it."""
+
+_COMMON_LANGUAGE_BY_PATH_KEY = {
+    ".arkts": "typescript",
+    ".bash": "bash",
+    ".bat": "batch",
+    ".c": "c",
+    ".cjs": "javascript",
+    ".cfg": "ini",
+    ".cmake": "cmake",
+    ".cmd": "batch",
+    ".cc": "cpp",
+    ".cpp": "cpp",
+    ".cs": "csharp",
+    ".csproj": "xml",
+    ".css": "css",
+    ".csv": "text",
+    ".csx": "csharp",
+    ".cxx": "cpp",
+    ".d.ts": "typescript",
+    ".dart": "dart",
+    ".dockerignore": "text",
+    ".editorconfig": "ini",
+    ".env": "text",
+    ".ets": "typescript",
+    ".fish": "fish",
+    ".frag": "glsl",
+    ".fs": "fsharp",
+    ".fsi": "fsharp",
+    ".fsproj": "xml",
+    ".fsx": "fsharp",
+    ".gemspec": "ruby",
+    ".gitignore": "text",
+    ".gql": "graphql",
+    ".go": "go",
+    ".gradle": "groovy",
+    ".graphql": "graphql",
+    ".groovy": "groovy",
+    ".h": "c",
+    ".hh": "cpp",
+    ".htm": "html",
+    ".hpp": "cpp",
+    ".html": "html",
+    ".hxx": "cpp",
+    ".ini": "ini",
+    ".ipynb": "json",
+    ".java": "java",
+    ".js": "javascript",
+    ".json": "json",
+    ".jsonc": "javascript",
+    ".jsonl": "json",
+    ".jsx": "jsx",
+    ".kt": "kotlin",
+    ".kts": "kotlin",
+    ".ksh": "bash",
+    ".less": "less",
+    ".lua": "lua",
+    ".md": "markdown",
+    ".mdx": "markdown",
+    ".mjs": "javascript",
+    ".mm": "objective-c++",
+    ".props": "xml",
+    ".proto": "protobuf",
+    ".ps1": "powershell",
+    ".psd1": "powershell",
+    ".psm1": "powershell",
+    ".php": "php",
+    ".py": "python",
+    ".pyi": "python",
+    ".pyw": "python",
+    ".rb": "ruby",
+    ".rs": "rust",
+    ".rst": "restructuredtext",
+    ".sass": "sass",
+    ".scala": "scala",
+    ".scss": "scss",
+    ".sh": "bash",
+    ".sln": "text",
+    ".sql": "sql",
+    ".svg": "xml",
+    ".svelte": "html",
+    ".swift": "swift",
+    ".targets": "xml",
+    ".tcss": "scss",
+    ".tf": "terraform",
+    ".tfvars": "terraform",
+    ".thrift": "thrift",
+    ".tsv": "text",
+    ".toml": "toml",
+    ".ts": "typescript",
+    ".tsx": "tsx",
+    ".txt": "text",
+    ".vb": "vb.net",
+    ".vbproj": "xml",
+    ".vcxproj": "xml",
+    ".vert": "glsl",
+    ".vue": "vue",
+    ".xaml": "xml",
+    ".xml": "xml",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".zsh": "bash",
+    "cargo.toml": "toml",
+    "cmakelists.txt": "cmake",
+    "dockerfile": "docker",
+    "gemfile": "ruby",
+    "go.mod": "text",
+    "go.sum": "text",
+    "makefile": "make",
+    "pipfile": "toml",
+    "rakefile": "ruby",
+    "requirements.txt": "text",
+}
+
+
+def _language_cache_key(path: str) -> str:
+    """Return a stable cache key for filename-based lexer detection."""
+    filename = os.path.basename(path).lower()
+    if not filename:
+        return ""
+    if filename in _COMMON_LANGUAGE_BY_PATH_KEY:
+        return filename
+    if filename.startswith("dockerfile."):
+        return "dockerfile"
+    if filename.startswith("makefile."):
+        return "makefile"
+    if filename.endswith(".d.ts"):
+        return ".d.ts"
+    if filename.endswith(".gradle.kts"):
+        return ".kts"
+    _root, ext = os.path.splitext(filename)
+    return ext or filename
+
+
+@lru_cache(maxsize=256)
+def _language_from_path_key(key: str) -> str | None:
+    """Resolve a Pygments language alias from a path-derived cache key."""
+    if not key:
+        return None
+    if language := _COMMON_LANGUAGE_BY_PATH_KEY.get(key):
+        return language
+    sample = f"file{key}" if key.startswith(".") else key
+    lexer_class = find_lexer_class_for_filename(sample)
+    if lexer_class is None:
+        return None
+    if lexer_class.aliases:
+        return lexer_class.aliases[0]
+    return lexer_class.name
+
+
+def _language_from_path(path: str) -> str | None:
+    """Resolve a language from the file path without content guessing."""
+    return _language_from_path_key(_language_cache_key(path))
+
+
+def _guess_diff_language(code: str, path: str) -> str:
+    """Fast path language detection for diff rendering.
+
+    Diff inputs almost always come from concrete file paths.  Pygments'
+    content-based ``guess_lexer_for_filename`` is much more expensive than
+    filename matching and is usually unnecessary here, so prefer a cached
+    filename/extension lookup and fall back to Textual's heuristic only for
+    unknown paths.
+    """
+    language = _language_from_path(path)
+    if language is not None:
+        return language
+    return highlight.guess_language(code, path)
+
+
+def _highlight_lines(code: str, path: str, language: str, *, shown_end: int | None = None) -> list[Content]:
+    """``code`` as one highlighted `Content` per line.
+
+    With ``shown_end``, only the lines ahead of it are highlighted and the rest stay plain. The
+    highlighted part always starts at the top of the text: a lexer carries state from line to line,
+    and a string or a comment that was opened above a hunk decides what the hunk's lines are.
+    """
+    text_lines = code.splitlines()
+    end = len(text_lines) if shown_end is None else min(shown_end, len(text_lines))
+    lines: list[Content] = []
+    if end:
+        shown = "\n".join(text_lines[:end])
+        lines = highlight.highlight(shown, language=language, path=path, theme=NoErrorHighlightTheme).split("\n")[:end]
+    # Blank lines at the end of what the highlighter is given do not come back from it.
+    lines.extend(Content(line) for line in text_lines[len(lines) :])
+    return lines
+
+
+def compute_hunks(code_before: str, code_after: str) -> list[Hunk]:
+    """The changes between two texts, each with up to three unchanged lines around it."""
+    matcher = difflib.SequenceMatcher(None, code_before.splitlines(), code_after.splitlines())
+    return list(matcher.get_grouped_opcodes())
+
+
+def emphasize_changes(removed: Sequence[Content], added: Sequence[Content]) -> tuple[list[Content], list[Content]]:
+    """Mark the characters that differ between each removed line and the added line paired with it.
+
+    A line is compared with its own counterpart only, so a mark never runs from one line into the
+    next, and a pair too unlike to be one edited line is left unmarked.
+    """
+    pairs = [_emphasize_pair(before, after) for before, after in zip(removed, added, strict=True)]
+    return [before for before, _ in pairs], [after for _, after in pairs]
+
+
+def _emphasize_pair(removed: Content, added: Content) -> tuple[Content, Content]:
+    if max(len(removed.plain), len(added.plain)) > _EMPHASIS_MAX_LINE_LENGTH:
+        return removed, added
+    matcher = difflib.SequenceMatcher(difflib.IS_CHARACTER_JUNK, removed.plain, added.plain, autojunk=False)
+    # The first two are upper bounds on the third, and far cheaper.
+    if any(
+        ratio() < _EMPHASIS_SIMILARITY_CUTOFF
+        for ratio in (matcher.real_quick_ratio, matcher.quick_ratio, matcher.ratio)
+    ):
+        return removed, added
+    removed_spans: list[Span] = []
+    added_spans: list[Span] = []
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag in {"delete", "replace"}:
+            removed_spans.append(Span(i1, i2, REMOVED_EMPHASIS))
+        if tag in {"insert", "replace"}:
+            added_spans.append(Span(j1, j2, ADDED_EMPHASIS))
+    return removed.add_spans(removed_spans), added.add_spans(added_spans)
+
+
+def compute_highlighted_lines(
+    code_before: str,
+    code_after: str,
+    path_before: str,
+    path_after: str,
+    hunks: Sequence[Hunk],
+    *,
+    hunks_only: bool = False,
+) -> tuple[list[Content], list[Content]]:
+    """Both texts as highlighted lines, with the edits inside replaced lines marked.
+
+    With ``hunks_only``, highlighting stops below the last hunk. A diff shows nothing further
+    down, and for a small change near the top of a large file that is nearly all of the work.
+    """
+    last_opcode = hunks[-1][-1] if hunks and hunks_only else None
+    before = _highlight_lines(
+        code_before,
+        path_before,
+        _guess_diff_language(code_before, path_before),
+        shown_end=None if last_opcode is None else last_opcode[2],
+    )
+    after = _highlight_lines(
+        code_after,
+        path_after,
+        _guess_diff_language(code_after, path_after),
+        shown_end=None if last_opcode is None else last_opcode[4],
+    )
+    for hunk in hunks:
+        for tag, i1, i2, j1, j2 in hunk:
+            if tag == "replace":
+                # The lines pair off from the top, which is also how a split diff sets them side by side.
+                paired = min(i2 - i1, j2 - j1)
+                removed, added = emphasize_changes(before[i1 : i1 + paired], after[j1 : j1 + paired])
+                before[i1 : i1 + paired] = removed
+                after[j1 : j1 + paired] = added
+    return before, after