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

@@ -230,7 +230,7 @@ def __rich_console__(
             if y != last_y:
                 yield new_line
 
-    def render_segments(self, console: Console) -> str:
+    def render_segments(self, console: Console, prints=None) -> str:
         """Render the update to raw data, suitable for writing to terminal.
 
         Args:
@@ -261,11 +261,15 @@ def render_segments(self, console: Console) -> str:
                 if x2 > x >= x1 and end <= x2:
                     append(move_to(x, y).segment.text)
                     append(strip.render(console))
+                    if prints is not None:
+                        prints.append(f"    {y=} {x2, x, x1} {strip.text!r}")
                     continue
 
                 strip = strip.crop(x1, min(end, x2) - x)
                 append(move_to(x1, y).segment.text)
                 append(strip.render(console))
+                if prints is not None:
+                    prints.append(f"    {y=} {x=} {strip.text!r}")
 
             if y != last_y:
                 append("\n")
@@ -1229,6 +1233,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/_styles_cache.py

@@ -260,6 +260,33 @@ def render(
             x1, x2 = crop.column_span
             strips = [strip.crop(x1, x2) for strip in strips]
 
+        try:
+            prints = _paul_prints
+        except NameError:
+            pass
+        else:
+            if prints is not None:
+                if 1 in crop.line_range:
+                    # prints.append(f"STYLE strip[1] {strips[1 - crop.line_range.start].text!r}")
+                    # prints.append(f"               crop={crop}")
+
+                    if 0:
+                        import io
+                        import traceback
+
+                        f = io.StringIO()
+                        traceback.print_stack(file=f, limit=10)
+                        lines = []
+                        for line in f.getvalue().splitlines():
+                            if line.lstrip().startswith('File "/home'):
+                                line = line.replace(
+                                    '"/home/paul/np/os/python/textual/textual/fork/'
+                                    "src/textual/",
+                                    '"',
+                                )
+                            lines.append(line)
+                        prints.append("\n".join(lines))
+
         return strips
 
     def render_line(

src/textual/app.py

@@ -313,8 +313,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 {
@@ -335,18 +335,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 {
@@ -398,7 +398,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.
     """
 
@@ -444,7 +444,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]] = [
@@ -471,7 +471,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`.
     """
 
@@ -543,7 +543,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():
@@ -745,7 +745,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.
         """
 
@@ -3595,6 +3595,13 @@ def _display(self, screen: Screen, renderable: RenderableType | None) -> None:
                                 write(chunk)
                         else:
                             self._driver.write(terminal_sequence)
+                            try:
+                                prints = _paul_ext_prints
+                            except NameError:
+                                pass
+                            else:
+                                if 0 and prints is not None:
+                                    prints.append(f"Seq: {terminal_sequence[:400]!r}")
                 finally:
                     self._end_update()
 

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: