tuile 0.6.0 → 0.8.0

data/lib/tuile/component/list.rb

@@ -23,6 +23,7 @@ module Tuile
         @padded_lines = []
         @blank_padded = StyledString::EMPTY
         @auto_scroll = false
+        @follow = true
         @top_line = 0
         @cursor = Cursor::None.new
         @scrollbar_visibility = :gone
@@ -50,9 +51,18 @@ module Tuile
       attr_accessor :on_cursor_changed
 
       # @return [Boolean] if true and a line is added or new content is set,
-      #   auto-scrolls to the bottom.
+      #   auto-scrolls to the bottom — but only while the viewport is already
+      #   pinned to the last line (see {#following?}). Scroll up to read older
+      #   content and appends stop yanking you back down; scroll back to the
+      #   bottom and tailing resumes.
       attr_reader :auto_scroll
 
+      # @return [Boolean] whether {#auto_scroll} is currently tailing. True
+      #   while the viewport sits at the last line; flips to false the moment
+      #   the user scrolls up, and back to true once they scroll to the bottom
+      #   again. Only consulted when {#auto_scroll} is enabled.
+      def following? = @follow
+
       # @return [Integer] top line of the viewport. 0 or positive.
       attr_reader :top_line
 
@@ -87,10 +97,12 @@ module Tuile
         invalidate
       end
 
-      # Sets the new auto_scroll. If true, immediately scrolls to the bottom.
+      # Sets the new auto_scroll. If true, re-engages tailing and immediately
+      # scrolls to the bottom.
       # @param new_auto_scroll [Boolean]
       def auto_scroll=(new_auto_scroll)
         @auto_scroll = new_auto_scroll
+        @follow = true if new_auto_scroll
         update_top_line_if_auto_scroll
       end
 
@@ -113,6 +125,7 @@ module Tuile
         return unless @top_line != new_top_line
 
         @top_line = new_top_line
+        @follow = at_bottom?
         invalidate
       end
 
@@ -163,6 +176,7 @@ module Tuile
       # @return [void]
       def add_line(line)
         raise ArgumentError, "line is nil" if line.nil?
+
         add_lines [line]
       end
 
@@ -190,11 +204,7 @@ module Tuile
       # @param key [String] a key.
       # @return [Boolean] true if the key was handled.
       def handle_key(key)
-        if !active?
-          false
-        elsif super
-          true
-        elsif key == Keys::PAGE_UP
+        if key == Keys::PAGE_UP
           move_top_line_by(-viewport_lines)
           true
         elsif key == Keys::PAGE_DOWN
@@ -274,7 +284,7 @@ module Tuile
                     end
         (0...rect.height).each do |row|
           line = paintable_line(row + @top_line, row, scrollbar)
-          screen.print TTY::Cursor.move_to(rect.left, row + rect.top), line
+          screen.buffer.set_line(rect.left, row + rect.top, line)
         end
       end
 
@@ -282,6 +292,8 @@ module Tuile
       class Cursor
         # @param position [Integer] the initial cursor position.
         def initialize(position: 0)
+          raise "invalid position #{position}" unless position.is_a? Integer
+
           @position = position
         end
 
@@ -416,8 +428,10 @@ module Tuile
           #   empty.
           # @param position [Integer] initial position.
           def initialize(positions, position: positions[0])
+            raise "positions are empty" if positions.empty?
+
             @positions = positions.sort
-            position = @positions[@positions.rindex { it < position } || 0] unless @positions.include?(position)
+            position = @positions[@positions.rindex { _1 < position } || 0] unless @positions.include?(position)
             super(position: position)
           end
 
@@ -427,7 +441,7 @@ module Tuile
           # @return [Boolean]
           def handle_mouse(line, event, _line_count)
             if event.button == :left
-              prev_pos = @positions.reverse_each.find { it <= line }
+              prev_pos = @positions.reverse_each.find { _1 <= line }
               return go_to_first if prev_pos.nil?
 
               go(prev_pos)
@@ -439,7 +453,7 @@ module Tuile
           # @param line_count [Integer]
           # @return [Array<Integer>]
           def candidate_positions(line_count)
-            @positions.select { it < line_count }
+            @positions.select { _1 < line_count }
           end
 
           # @param _line_count [Integer]
@@ -454,7 +468,7 @@ module Tuile
           # @param line_count [Integer]
           # @return [Boolean]
           def go_down_by(lines, line_count)
-            next_pos = @positions.find { it >= @position + lines }
+            next_pos = @positions.find { _1 >= @position + lines }
             return go_to_last(line_count) if next_pos.nil?
 
             go(next_pos)
@@ -463,7 +477,7 @@ module Tuile
           # @param lines [Integer]
           # @return [Boolean]
           def go_up_by(lines)
-            prev_pos = @positions.reverse_each.find { it <= @position - lines }
+            prev_pos = @positions.reverse_each.find { _1 <= @position - lines }
             return go_to_first if prev_pos.nil?
 
             go(prev_pos)
@@ -622,16 +636,16 @@ module Tuile
       def order_for_search(candidates, current, include_current:, reverse:)
         if reverse
           before, after = if include_current
-                            [candidates.select { it <= current }, candidates.select { it > current }]
+                            [candidates.select { _1 <= current }, candidates.select { _1 > current }]
                           else
-                            [candidates.select { it < current }, candidates.select { it >= current }]
+                            [candidates.select { _1 < current }, candidates.select { _1 >= current }]
                           end
           before.reverse + after.reverse
         else
           after, before = if include_current
-                            [candidates.select { it >= current }, candidates.select { it < current }]
+                            [candidates.select { _1 >= current }, candidates.select { _1 < current }]
                           else
-                            [candidates.select { it > current }, candidates.select { it <= current }]
+                            [candidates.select { _1 > current }, candidates.select { _1 <= current }]
                           end
           after + before
         end
@@ -653,6 +667,10 @@ module Tuile
       # @return [Integer] the max value of {#top_line}.
       def top_line_max = (@lines.size - rect.height).clamp(0, nil)
 
+      # @return [Boolean] whether the viewport is pinned to the last line.
+      #   Drives {#following?}: re-evaluated on every {#top_line=}.
+      def at_bottom? = @top_line == top_line_max
+
       # @return [Integer] the number of visible lines.
       def viewport_lines = rect.height
 
@@ -675,9 +693,14 @@ module Tuile
       # which would leave `top_line` past the last item once a real rect
       # arrives. {#on_width_changed} re-runs this hook when the rect grows so
       # the snap-to-bottom intent is preserved.
+      #
+      # Gated on {#following?}: once the user scrolls up off the bottom the
+      # cursor snap and viewport pin are both skipped, so reading older
+      # content is not interrupted by incoming lines. {#top_line=} re-arms
+      # `@follow` when the viewport returns to the bottom.
       # @return [void]
       def update_top_line_if_auto_scroll
-        return unless @auto_scroll
+        return unless @auto_scroll && @follow
         return if rect.empty?
 
         notify_cursor_changed if @cursor.go_to_last(@lines.size)
@@ -736,15 +759,14 @@ module Tuile
       # @param row_in_viewport [Integer] 0-based row within the viewport.
       # @param scrollbar [VerticalScrollBar, nil] scrollbar instance, or nil
       #   if not shown.
-      # @return [String] paintable ANSI-encoded line exactly `rect.width`
-      #   columns wide; highlighted if cursor is here.
+      # @return [StyledString] paintable line exactly `rect.width` columns wide;
+      #   highlighted if cursor is here.
       def paintable_line(index, row_in_viewport, scrollbar)
         base = index < @lines.size ? @padded_lines[index] : @blank_padded
         is_cursor = (active? || @show_cursor_when_inactive) && index < @lines.size && @cursor.position == index
         styled = is_cursor ? base.with_bg(screen.theme.active_bg_color) : base
-        out = styled.to_ansi
-        out += scrollbar.scrollbar_char(row_in_viewport) if scrollbar
-        out
+        styled += StyledString.plain(scrollbar.scrollbar_char(row_in_viewport)) if scrollbar
+        styled
       end
     end
   end

data/lib/tuile/component/log_window.rb

@@ -15,19 +15,35 @@ module Tuile
       # @param caption [String]
       def initialize(caption = "Log")
         super
-        list = Component::List.new
-        list.auto_scroll = true
-        # Allow scrolling when a long stacktrace is logged.
-        list.cursor = Component::List::Cursor.new
-        self.content = list
+        view = Component::TextView.new
+        # Word-wrap long lines (stacktraces, wide log records) rather than
+        # ellipsizing them as a {List} would — a truncated log line hides the
+        # very detail you opened the log to read.
+        view.auto_scroll = true
+        self.content = view
         self.scrollbar = true
       end
 
+      # Keep the log pane at least half the screen tall even when only a few
+      # lines have been logged: a {Component::Popup} sizes to its content, which
+      # would collapse a near-empty log to two or three rows. Advice consulted
+      # by {Component::Popup#min_height} when this window is a popup's content.
+      # @return [Integer]
+      def popup_min_height = screen.size.height / 2
+
+      # Let a busy log grow past the popup's base 12-row cap (up to the
+      # 4/5-of-screen ceiling {Component::Popup#update_rect} applies) so the
+      # diagnostic stream stays scrollable in a tall window. Advice consulted
+      # by {Component::Popup#max_height} when this window is a popup's content.
+      # @return [Integer]
+      def popup_max_height = screen.size.height
+
       # Appends given line to the log. Can be called from any thread. Does nothing if nil is passed in.
       # @param string [String, nil] the line (or multiple lines) to log.
       # @return [void]
       def log(string)
         return if string.nil?
+
         screen.event_queue.submit do
           content.add_line(string)
         end

data/lib/tuile/component/picker_window.rb

@@ -34,10 +34,10 @@ module Tuile
         raise ArgumentError, "options must not be empty" if options.empty?
 
         super(caption)
-        @options = options.map { Option.new(it[0], it[1]) }
+        @options = options.map { Option.new(_1[0], _1[1]) }
         @block = block
         list = Component::List.new
-        list.lines = @options.map { "#{it.key} #{screen.theme.hint(it.caption)}" }
+        list.lines = @options.map { "#{_1.key} #{screen.theme.hint(_1.caption)}" }
         list.cursor = Component::List::Cursor.new
         list.on_item_chosen = ->(index, _line) { select_option(@options[index].key) }
         self.content = list
@@ -50,12 +50,14 @@ module Tuile
       # @return [Proc, nil]
       attr_accessor :on_pick
 
+      # Handles an option-key press. Reached by bubbling: the inner {List}
+      # (the focused component) sees the key first and handles cursor/Enter
+      # picks; anything it declines bubbles up here, where a key matching an
+      # option's `key` picks that option.
       # @param key [String]
       # @return [Boolean]
       def handle_key(key)
-        return true if super
-
-        if @options.any? { it.key == key }
+        if @options.any? { _1.key == key }
           select_option(key)
           true
         else
@@ -65,7 +67,7 @@ module Tuile
 
       # @return [String]
       def keyboard_hint
-        @options.map { "#{it.key} #{screen.theme.hint(it.caption)}" }.join("  ")
+        @options.map { "#{_1.key} #{screen.theme.hint(_1.caption)}" }.join("  ")
       end
 
       # Opens a picker as a popup. Picking an option fires `block`, then

data/lib/tuile/component/popup.rb

@@ -2,10 +2,20 @@
 
 module Tuile
   class Component
-    # A modal overlay that wraps any {Component} as its content. Popup itself
-    # paints nothing — it's a transparent host that handles modality
-    # ({#open} / {#close} / {#open?}, ESC/q to close), centers itself on the
-    # screen, and auto-sizes to the wrapped content.
+    # An overlay that wraps any {Component} as its content. Popup itself
+    # paints nothing — it's a transparent host that handles its lifecycle
+    # ({#open} / {#close} / {#open?}, ESC/q to close) and auto-sizes to the
+    # wrapped content.
+    #
+    # Modal by default: it centers on the screen, grabs focus, eats keys, and
+    # blocks clicks beneath it. Pass `modal: false` for a non-modal overlay
+    # that floats above the content (still painted on top, still auto-sized)
+    # without taking focus or capturing input — the caller positions it (via
+    # {#rect=}) and drives it from app code. That is the building block for an
+    # autocomplete/slash-command list anchored to a {Component::TextField} or
+    # {Component::TextArea} caret: typing keeps focus (and the cursor) in the
+    # input, an {Component::TextInput#on_change} listener refills the list, and
+    # an {Component::TextInput#on_key} interceptor forwards Up/Down/Enter to it.
     #
     # The wrapped content fills the popup's full {#rect}; if you want a frame
     # and caption, wrap a {Component::Window} (or any subclass — including
@@ -27,14 +37,36 @@ module Tuile
 
       # @param content [Component, nil] initial content; can be set later via
       #   {#content=}. When provided here, the popup auto-sizes to fit.
-      def initialize(content: nil)
+      # @param modal [Boolean] true (default) for a centered, focus-grabbing,
+      #   input-capturing modal; false for a non-modal overlay the caller
+      #   positions and drives (see the class docs).
+      def initialize(content: nil, modal: true)
         super()
+        @modal = modal
         @content = nil
         self.content = content unless content.nil?
       end
 
+      # @return [Boolean] whether this popup is modal. See {#initialize}.
+      def modal? = @modal
+
       def focusable? = true
 
+      # Reassigns the popup's rect, escalating to a full scene repaint when an
+      # open popup shrinks or moves so its new rect no longer covers the cells
+      # it previously painted. A popup overdraws the scene without clipping and
+      # nothing clears underneath it, so {Screen#repaint}'s popup-only fast path
+      # would repaint into the new rect and leave the vacated cells showing
+      # stale content. When the new rect fully covers the old one (the popup
+      # only grew), the fast path is correct and the full repaint is skipped.
+      # @param new_rect [Rect]
+      # @return [void]
+      def rect=(new_rect)
+        old_rect = rect
+        super
+        screen.needs_full_repaint if open? && !new_rect.contains_rect?(old_rect)
+      end
+
       # Mounts this popup on the {Screen}. Recomputes the popup's size from
       # the current content first, so reopening a popup whose content has
       # grown or shrunk while closed picks up the new size.
@@ -70,9 +102,20 @@ module Tuile
         self.rect = rect.centered(screen.size)
       end
 
-      # @return [Integer] max height the popup will grow to fit its content,
-      #   defaults to 12. Override in a subclass to allow taller popups.
-      def max_height = 12
+      # @return [Integer] max height the popup will grow to fit its content.
+      #   Defers to the content's {Component#popup_max_height} advice when it
+      #   gives one, else defaults to 12. Override in a subclass to allow
+      #   taller popups regardless of content.
+      def max_height = @content&.popup_max_height || 12
+
+      # @return [Integer] min height the popup occupies even when its content
+      #   is shorter. Defers to the content's {Component#popup_min_height}
+      #   advice when it gives one, else defaults to 0 (size purely to
+      #   content) — so a {Component::LogWindow} stays readable while only a
+      #   few lines are in without callers wiring up a subclass. Override in a
+      #   subclass to keep any popup from collapsing to a couple of rows.
+      #   Capped at the same 4/5-of-screen ceiling {#update_rect} applies.
+      def min_height = @content&.popup_min_height || 0
 
       # Sets the popup's content and auto-sizes the popup to fit.
       # @param new_content [Component, nil]
@@ -99,11 +142,12 @@ module Tuile
         child_hint.empty? ? prefix : "#{prefix}  #{child_hint}"
       end
 
+      # `q` and ESC close the popup. The popup sits on the focus chain of
+      # whatever it wraps, so the key reaches here by bubbling up from the
+      # focused content after that content declined to handle it.
       # @param key [String]
       # @return [Boolean] true if the key was handled.
       def handle_key(key)
-        return true if super
-
         if [Keys::ESC, "q"].include?(key)
           close
           true
@@ -125,12 +169,24 @@ module Tuile
 
       # Recompute width/height from {#content}'s natural size and recenter
       # if currently open. Called whenever content is (re)assigned.
+      #
+      # Computes the final (centered) rect and assigns it in one step rather
+      # than positioning at the origin and then centering: the intermediate
+      # origin rect rarely covers the previous one, which would make
+      # {#rect=}'s shrink/move detection fire a full repaint on every resize.
       # @return [void]
       def update_rect
+        ceiling = screen.size.height * 4 / 5
         size = @content.content_size.clamp_height(max_height)
-        size = size.clamp(Size.new(screen.size.width * 4 / 5, screen.size.height * 4 / 5))
-        self.rect = Rect.new(0, 0, size.width, size.height)
-        center if open?
+        size = size.clamp(Size.new(screen.size.width * 4 / 5, ceiling))
+        floor = min_height.clamp(0, ceiling)
+        size = Size.new(size.width, floor) if size.height < floor
+        # A non-modal overlay is positioned by the caller, so an open one keeps
+        # its current top-left when its content resizes; a modal popup recenters.
+        origin = open? && !modal? ? Point.new(rect.left, rect.top) : Point.new(0, 0)
+        r = Rect.new(origin.x, origin.y, size.width, size.height)
+        r = r.centered(screen.size) if open? && modal?
+        self.rect = r
       end
     end
   end

data/lib/tuile/component/text_area.rb

@@ -80,7 +80,7 @@ module Tuile
                    chunk = @text[r[:start], r[:length]] || ""
                    chunk + (" " * (rect.width - r[:length]))
                  end
-          screen.print TTY::Cursor.move_to(rect.left, rect.top + screen_row), background(line)
+          screen.buffer.set_line(rect.left, rect.top + screen_row, background(line))
         end
       end
 

data/lib/tuile/component/text_field.rb

@@ -60,7 +60,7 @@ module Tuile
         return if rect.empty?
 
         padded = @text + (" " * (rect.width - @text.length))
-        screen.print TTY::Cursor.move_to(rect.left, rect.top), background(padded)
+        screen.buffer.set_line(rect.left, rect.top, background(padded))
       end
 
       protected

data/lib/tuile/component/text_input.rb

@@ -31,6 +31,7 @@ module Tuile
         @text = +""
         @caret = 0
         @on_change = nil
+        @on_key = nil
         @on_escape = method(:default_on_escape)
       end
 
@@ -49,6 +50,20 @@ module Tuile
       # @return [Proc, Method, nil] one-arg callable, or nil.
       attr_accessor :on_change
 
+      # Optional interceptor consulted before the input's own key handling.
+      # Receives the pressed key; return a truthy value to consume it (the
+      # input then ignores that key), falsy to let normal editing proceed.
+      #
+      # The keyboard analog of {#on_change}: it lets app code layer behavior
+      # onto an input without subclassing. The motivating case is an
+      # autocomplete / slash-command overlay (a non-modal {Component::Popup}):
+      # while it is open the interceptor claims Up/Down/Enter/ESC and forwards
+      # them to the overlay's list, but lets ordinary characters fall through
+      # so typing keeps editing the field (and {#on_change} keeps refilling the
+      # list).
+      # @return [Proc, Method, nil] one-arg callable, or nil.
+      attr_accessor :on_key
+
       # Callback fired when ESC is pressed. Defaults to a closure that clears
       # focus (`screen.focused = nil`) so ESC visibly cancels text entry instead
       # of bubbling to the parent — and, in particular, instead of reaching the
@@ -88,14 +103,15 @@ module Tuile
         invalidate
       end
 
-      # Handles a key. Returns false when the component is inactive. Otherwise
-      # first runs the {Component#handle_key} shortcut search via `super`, then
-      # delegates to {#handle_text_input_key}.
+      # Handles a key. An {#on_key} interceptor (if set) gets first refusal —
+      # a truthy return consumes the key — otherwise it delegates to
+      # {#handle_text_input_key}. Dispatch ({ScreenPane#handle_key}) only routes
+      # keys here when this input is on the focus chain, so there is no
+      # {#active?} gate.
       # @param key [String]
       # @return [Boolean]
       def handle_key(key)
-        return false unless active?
-        return true if super
+        return true if @on_key&.call(key)
 
         handle_text_input_key(key)
       end
@@ -103,13 +119,13 @@ module Tuile
       protected
 
       # Renders `text` on the field's background well, looked up from the
-      # current {Screen#theme} at paint time: {Theme#active_bg} when this
-      # input is on the active (focus) chain, {Theme#input_bg} otherwise —
+      # current {Screen#theme} at paint time: {Theme#active_bg_color} when this
+      # input is on the active (focus) chain, {Theme#input_bg_color} otherwise —
       # visibly a field either way, distinctly highlighted when active.
       # @param text [String]
-      # @return [String] ANSI-rendered text.
+      # @return [StyledString] text on the field's background well.
       def background(text)
-        active? ? screen.theme.active_bg(text) : screen.theme.input_bg(text)
+        StyledString.styled(text, bg: active? ? screen.theme.active_bg_color : screen.theme.input_bg_color)
       end
 
       # Input filter for {#text=}. Subclasses override to truncate or reject

data/lib/tuile/component/text_view.rb

@@ -53,6 +53,7 @@ module Tuile
         @blank_line = StyledString::EMPTY
         @top_line = 0
         @auto_scroll = false
+        @follow = true
         @scrollbar_visibility = :gone
         # The view always has at least one region — an implicit default. It
         # owns whatever hard lines exist that no later region claims. App
@@ -80,9 +81,18 @@ module Tuile
       attr_reader :scrollbar_visibility
 
       # @return [Boolean] if true, mutating the text scrolls the viewport so
-      #   the last line stays in view. Default `false`.
+      #   the last line stays in view — but only while the viewport is already
+      #   pinned to the last line (see {#following?}). Scroll up to read older
+      #   content and appends stop yanking you back down; scroll back to the
+      #   bottom and tailing resumes. Default `false`.
       attr_reader :auto_scroll
 
+      # @return [Boolean] whether {#auto_scroll} is currently tailing. True
+      #   while the viewport sits at the last line; flips to false the moment
+      #   the user scrolls up, and back to true once they scroll to the bottom
+      #   again. Only consulted when {#auto_scroll} is enabled.
+      def following? = @follow
+
       # Replaces the text. Embedded `\n` characters become hard line breaks.
       # A `String` is parsed via {StyledString.parse} (so embedded ANSI is
       # honored); a `StyledString` is used as-is; `nil` is coerced to an
@@ -347,6 +357,7 @@ module Tuile
         return if @top_line == new_top_line
 
         @top_line = new_top_line
+        @follow = at_bottom?
         invalidate
       end
 
@@ -361,11 +372,13 @@ module Tuile
         invalidate
       end
 
-      # Sets `auto_scroll`. If true, immediately scrolls to the bottom.
+      # Sets `auto_scroll`. If true, re-engages tailing and immediately
+      # scrolls to the bottom.
       # @param value [Boolean]
       # @return [void]
       def auto_scroll=(value)
         @auto_scroll = value ? true : false
+        @follow = true if @auto_scroll
         update_top_line_if_auto_scroll
       end
 
@@ -424,7 +437,7 @@ module Tuile
                     end
         (0...rect.height).each do |row|
           line = paintable_line(row + @top_line, row, scrollbar)
-          screen.print TTY::Cursor.move_to(rect.left, rect.top + row), line
+          screen.buffer.set_line(rect.left, rect.top + row, line)
         end
       end
 
@@ -848,14 +861,22 @@ module Tuile
         self.top_line = clamped unless @top_line == clamped
       end
 
+      # Gated on {#following?}: once the user scrolls up off the bottom the
+      # viewport pin is skipped, so reading older content is not interrupted
+      # by incoming lines. {#top_line=} re-arms `@follow` when the viewport
+      # returns to the bottom.
       # @return [void]
       def update_top_line_if_auto_scroll
-        return unless @auto_scroll
+        return unless @auto_scroll && @follow
 
         target = (@physical_lines.size - viewport_lines).clamp(0, nil)
         self.top_line = target if @top_line != target
       end
 
+      # @return [Boolean] whether the viewport is pinned to the last line.
+      #   Drives {#following?}: re-evaluated on every {#top_line=}.
+      def at_bottom? = @top_line == top_line_max
+
       # @return [Boolean]
       def scrollbar_visible?
         return false if rect.empty?
@@ -883,15 +904,14 @@ module Tuile
       # @param index [Integer] 0-based index into `@physical_lines`.
       # @param row_in_viewport [Integer] 0-based row within the viewport.
       # @param scrollbar [VerticalScrollBar, nil]
-      # @return [String] paintable ANSI-encoded line exactly `rect.width`
-      #   columns wide. Body lines come pre-padded from {#rewrap}, so this
-      #   reduces to a memoized {StyledString#to_ansi} read plus an
-      #   ASCII-string concat of the scrollbar glyph when one is present.
+      # @return [StyledString] paintable line exactly `rect.width` columns wide.
+      #   Body lines come pre-padded from {#rewrap}, so this reduces to a lookup
+      #   plus a concat of the scrollbar glyph when one is present.
       def paintable_line(index, row_in_viewport, scrollbar)
         line = @physical_lines[index] || @blank_line
-        return line.to_ansi unless scrollbar
+        return line unless scrollbar
 
-        line.to_ansi + scrollbar.scrollbar_char(row_in_viewport)
+        line + StyledString.plain(scrollbar.scrollbar_char(row_in_viewport))
       end
 
       # A logical section of a {TextView}'s text — a contiguous run of