Appear to have working render-based diff method.

Now capturing a pre-rendered version of the TextArea window and
using changes to the pre-rendered version to generate change regions.

Author: paul-ollis

src/textual/_compositor.py

@@ -1229,6 +1229,7 @@ def update_widgets(self, widgets: set[Widget]) -> None:
         add_region = regions.append
         get_widget = self.visible_widgets.__getitem__
         for widget in self.visible_widgets.keys() & widgets:
+            widget._prepare_for_repaint()
             region, clip = get_widget(widget)
             offset = region.offset
             intersection = clip.intersection

src/textual/app.py

@@ -314,8 +314,8 @@ class App(Generic[ReturnType], DOMNode):
                 scrollbar-background-active: ansi_default;
                 scrollbar-color: ansi_blue;
                 scrollbar-color-active: ansi_bright_blue;
-                scrollbar-color-hover: ansi_bright_blue;    
-                scrollbar-corner-color: ansi_default;           
+                scrollbar-color-hover: ansi_bright_blue;
+                scrollbar-corner-color: ansi_default;
             }
 
             .bindings-table--key {
@@ -336,18 +336,18 @@ class App(Generic[ReturnType], DOMNode):
         }
 
         /* When a widget is maximized */
-        Screen.-maximized-view {                    
+        Screen.-maximized-view {
             layout: vertical !important;
             hatch: right $panel;
             overflow-y: auto !important;
             align: center middle;
             .-maximized {
-                dock: initial !important;                
+                dock: initial !important;
             }
         }
         /* Fade the header title when app is blurred */
-        &:blur HeaderTitle {           
-            text-opacity: 50%;           
+        &:blur HeaderTitle {
+            text-opacity: 50%;
         }
     }
     *:disabled:can-focus {
@@ -399,7 +399,7 @@ class MyApp(App[None]):
 
     ALLOW_SELECT: ClassVar[bool] = True
     """A switch to toggle arbitrary text selection for the app.
-    
+
     Note that this doesn't apply to Input and TextArea which have builtin support for selection.
     """
 
@@ -445,7 +445,7 @@ class MyApp(App[None]):
     """The default value of [Screen.ALLOW_IN_MAXIMIZED_VIEW][textual.screen.Screen.ALLOW_IN_MAXIMIZED_VIEW]."""
 
     CLICK_CHAIN_TIME_THRESHOLD: ClassVar[float] = 0.5
-    """The maximum number of seconds between clicks to upgrade a single click to a double click, 
+    """The maximum number of seconds between clicks to upgrade a single click to a double click,
     a double click to a triple click, etc."""
 
     BINDINGS: ClassVar[list[BindingType]] = [
@@ -472,7 +472,7 @@ class MyApp(App[None]):
 
     ESCAPE_TO_MINIMIZE: ClassVar[bool] = True
     """Use escape key to minimize widgets (potentially overriding bindings).
-    
+
     This is the default value, used if the active screen's `ESCAPE_TO_MINIMIZE` is not changed from `None`.
     """
 
@@ -544,7 +544,7 @@ def __init__(
 
         self._registered_themes: dict[str, Theme] = {}
         """Themes that have been registered with the App using `App.register_theme`.
-        
+
         This excludes the built-in themes."""
 
         for theme in BUILTIN_THEMES.values():
@@ -746,7 +746,7 @@ def __init__(
 
         self.theme_changed_signal: Signal[Theme] = Signal(self, "theme-changed")
         """Signal that is published when the App's theme is changed.
-        
+
         Subscribers will receive the new theme object as an argument to the callback.
         """
 

src/textual/document/_document.py

@@ -3,12 +3,13 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from functools import lru_cache
+from itertools import zip_longest
 from typing import TYPE_CHECKING, Callable, NamedTuple, Tuple, overload
 
 from typing_extensions import Literal, get_args
 
 if TYPE_CHECKING:
-    from tree_sitter import Node, Query
+    from tree_sitter import Query
 
 from textual._cells import cell_len
 from textual.geometry import Size
@@ -27,6 +28,10 @@ class EditResult:
     """The new end Location after the edit is complete."""
     replaced_text: str
     """The text that was replaced."""
+    dirty_lines: range | None = None
+    """The range of lines considered dirty."""
+    alt_dirty_line: tuple[int, range] | None = None
+    """Alternative list of lines considered dirty."""
 
 
 @lru_cache(maxsize=1024)
@@ -146,28 +151,6 @@ def clean_up(self) -> None:
         The default implementation does nothing.
         """
 
-    def query_syntax_tree(
-        self,
-        query: "Query",
-        start_point: tuple[int, int] | None = None,
-        end_point: tuple[int, int] | None = None,
-    ) -> dict[str, list["Node"]]:
-        """Query the tree-sitter syntax tree.
-
-        The default implementation always returns an empty list.
-
-        To support querying in a subclass, this must be implemented.
-
-        Args:
-            query: The tree-sitter Query to perform.
-            start_point: The (row, column byte) to start the query at.
-            end_point: The (row, column byte) to end the query at.
-
-        Returns:
-            A dict mapping captured node names to lists of Nodes with that name.
-        """
-        return {}
-
     def set_syntax_tree_update_callback(
         callback: Callable[[], None],
     ) -> None:
@@ -262,6 +245,10 @@ def newline(self) -> Newline:
         """Get the Newline used in this document (e.g. '\r\n', '\n'. etc.)"""
         return self._newline
 
+    def copy_of_lines(self):
+        """Provide a copy of the document's lines."""
+        return list(self._lines)
+
     def get_size(self, tab_width: int) -> Size:
         """The Size of the document, taking into account the tab rendering width.
 
@@ -321,11 +308,40 @@ def replace_range(self, start: Location, end: Location, text: str) -> EditResult
             destination_column = len(before_selection)
             insert_lines = [before_selection + after_selection]
 
+        try:
+            prev_top_line = lines[top_row]
+        except IndexError:
+            prev_top_line = None
         lines[top_row : bottom_row + 1] = insert_lines
         destination_row = top_row + len(insert_lines) - 1
 
         end_location = (destination_row, destination_column)
-        return EditResult(end_location, replaced_text)
+
+        n_previous_lines = bottom_row - top_row + 1
+        dirty_range = None
+        alt_dirty_line = None
+        if len(insert_lines) != n_previous_lines:
+            dirty_range = range(top_row, len(lines))
+        else:
+            if len(insert_lines) == 1 and prev_top_line is not None:
+                rng = self._build_single_line_range(prev_top_line, insert_lines[0])
+                if rng is not None:
+                    alt_dirty_line = top_row, rng
+            else:
+                dirty_range = range(top_row, bottom_row + 1)
+
+        return EditResult(end_location, replaced_text, dirty_range, alt_dirty_line)
+
+    @staticmethod
+    def _build_single_line_range(a, b):
+        rng = []
+        for i, (ca, cb) in enumerate(zip_longest(a, b)):
+            if ca != cb:
+                rng.append(i)
+        if rng:
+            return range(rng[0], rng[-1] + 1)
+        else:
+            None
 
     def get_text_range(self, start: Location, end: Location) -> str:
         """Get the text that falls between the start and end locations.

src/textual/document/_document_navigator.py

@@ -2,6 +2,8 @@
 from bisect import bisect, bisect_left, bisect_right
 from typing import Any, Sequence
 
+from rich.cells import get_character_cell_size
+
 from textual._cells import cell_len
 from textual.document._document import Location
 from textual.document._wrapped_document import WrappedDocument
@@ -242,6 +244,16 @@ def get_location_left(self, location: Location) -> Location:
         length_of_row_above = len(self._document[row - 1])
         target_row = row if column != 0 else row - 1
         target_column = column - 1 if column != 0 else length_of_row_above
+
+        if target_row < self._document.line_count:
+            line = self._document[target_row]
+            if target_column < len(line):
+                while target_column > 0:
+                    c = line[target_column]
+                    if c == "\t" or get_character_cell_size(c) > 0:
+                        break
+                    target_column -= 1
+
         return target_row, target_column
 
     def get_location_right(self, location: Location) -> Location:
@@ -263,6 +275,15 @@ def get_location_right(self, location: Location) -> Location:
         is_end_of_line = self.is_end_of_document_line(location)
         target_row = row + 1 if is_end_of_line else row
         target_column = 0 if is_end_of_line else column + 1
+
+        if target_row < self._document.line_count:
+            line = self._document[target_row]
+            while target_column < len(line):
+                c = line[target_column]
+                if c == "\t" or get_character_cell_size(c) > 0:
+                    break
+                target_column += 1
+
         return target_row, target_column
 
     def get_location_above(self, location: Location) -> Location:

src/textual/document/_syntax_aware_document.py

@@ -2,12 +2,11 @@
 
 import weakref
 from asyncio import CancelledError, Event, Task, create_task, sleep
-from contextlib import contextmanager
 from functools import partial
-from typing import Callable, ContextManager, NamedTuple
+from typing import Callable, NamedTuple
 
 try:
-    from tree_sitter import Language, Node, Parser, Query, Tree
+    from tree_sitter import Language, Parser, Query, Tree
 
     TREE_SITTER = True
 except ImportError:
@@ -17,35 +16,6 @@
 from textual.document._document import Document, EditResult, Location, _utf8_encode
 
 
-@contextmanager
-def temporary_query_point_range(
-    query: Query,
-    start_point: tuple[int, int] | None,
-    end_point: tuple[int, int] | None,
-) -> ContextManager[None]:
-    """Temporarily change the start and/or end point for a tree-sitter Query.
-
-    Args:
-        query: The tree-sitter Query.
-        start_point: The (row, column byte) to start the query at.
-        end_point: The (row, column byte) to end the query at.
-    """
-    # Note: Although not documented for the tree-sitter Python API, an
-    # end-point of (0, 0) means 'end of document'.
-    default_point_range = [(0, 0), (0, 0)]
-
-    point_range = list(default_point_range)
-    if start_point is not None:
-        point_range[0] = start_point
-    if end_point is not None:
-        point_range[1] = end_point
-    query.set_point_range(point_range)
-    try:
-        yield None
-    finally:
-        query.set_point_range(default_point_range)
-
-
 class SyntaxTreeEdit(NamedTuple):
     """Details of a tree-sitter syntax tree edit operation."""
 
@@ -99,14 +69,15 @@ def __init__(
         self._background_parser = BackgroundSyntaxParser(self)
         self._pending_syntax_edits: list[SyntaxTreeEdit] = []
 
+    @property
+    def current_syntax_tree(self) -> Tree:
+        """The current syntax tree."""
+        return self._syntax_tree
+
     def clean_up(self) -> None:
         """Perform any pre-deletion clean up."""
         self._background_parser.stop()
 
-    def copy_of_lines(self):
-        """Provide a copy of the document's lines."""
-        return list(self._lines)
-
     def apply_pending_syntax_edits(self) -> bool:
         """Apply any pending edits to the syntax tree.
 
@@ -136,29 +107,6 @@ def prepare_query(self, query: str) -> Query | None:
         """
         return self.language.query(query)
 
-    def query_syntax_tree(
-        self,
-        query: Query,
-        start_point: tuple[int, int] | None = None,
-        end_point: tuple[int, int] | None = None,
-    ) -> dict[str, list["Node"]]:
-        """Query the tree-sitter syntax tree.
-
-        The default implementation always returns an empty list.
-
-        To support querying in a subclass, this must be implemented.
-
-        Args:
-            query: The tree-sitter Query to perform.
-            start_point: The (row, column byte) to start the query at.
-            end_point: The (row, column byte) to end the query at.
-
-        Returns:
-            A tuple containing the nodes and text captured by the query.
-        """
-        with temporary_query_point_range(query, start_point, end_point):
-            return query.captures(self._syntax_tree.root_node)
-
     def set_syntax_tree_update_callback(
         self,
         callback: Callable[[], None],
@@ -239,10 +187,14 @@ def reparse(self, timeout_us: int, lines: list[str], syntax_tree=None) -> bool:
                 # The only known cause is a timeout.
                 return False
             else:
+                self._syntax_tree = tree
                 if self._syntax_tree_update_callback is not None:
+
+                    def set_new_tree():
+                        self._syntax_tree = tree
+
                     changed_ranges = self._syntax_tree.changed_ranges(tree)
-                    self._syntax_tree = tree
-                    self._syntax_tree_update_callback(changed_ranges)
+                    self._syntax_tree_update_callback(self._syntax_tree, len(lines))
                 else:
                     self._syntax_tree = tree
                 return True

src/textual/document/_wrapped_document.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from bisect import bisect_right
+from functools import lru_cache
 
 from rich.text import Text
 
@@ -85,6 +86,7 @@ def wrap(self, width: int, tab_width: int | None = None) -> None:
             tab_width: The maximum width to consider for tab characters. If None,
                 reuse the  tab width.
         """
+        self.get_sections.cache_clear()
         self._width = width
         if tab_width:
             self._tab_width = tab_width
@@ -168,6 +170,7 @@ def wrap_range(
             old_end: The old end location of the edit in document-space.
             new_end: The new end location of the edit in document-space.
         """
+        self.get_sections.cache_clear()
         start_line_index, _ = start
         old_end_line_index, _ = old_end
         new_end_line_index, _ = new_end
@@ -403,6 +406,7 @@ def get_target_document_column(
 
         return target_column_index
 
+    @lru_cache(200)
     def get_sections(self, line_index: int) -> list[str]:
         """Return the sections for the given line index.