tuile 0.5.0 → 0.7.0

data/lib/tuile/component/list.rb

@@ -14,20 +14,16 @@ module Tuile
     #
     # Cursor is supported; call {#cursor=} to change cursor behavior. The
     # cursor responds to arrows, `jk`, Home/End, Ctrl+U/D and scrolls the
-    # list automatically. The cursor highlight overlays a dark background
-    # while preserving each span's foreground color.
+    # list automatically. The cursor highlight overlays
+    # {Theme#active_bg_color} while preserving each span's foreground color.
     class List < Component
-      # 256-color SGR index for the cursor-row background highlight. Matches
-      # what `Rainbow(...).bg(:darkslategray)` emits.
-      # @return [Integer]
-      CURSOR_BG = 59
-
       def initialize
         super
         @lines = []
         @padded_lines = []
         @blank_padded = StyledString::EMPTY
         @auto_scroll = false
+        @follow = true
         @top_line = 0
         @cursor = Cursor::None.new
         @scrollbar_visibility = :gone
@@ -55,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
 
@@ -92,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
 
@@ -118,6 +125,7 @@ module Tuile
         return unless @top_line != new_top_line
 
         @top_line = new_top_line
+        @follow = at_bottom?
         invalidate
       end
 
@@ -135,11 +143,11 @@ module Tuile
         raise TypeError, "expected Array, got #{lines.inspect}" unless lines.is_a? Array
 
         @lines = parse_input_lines(lines)
-        @content_size = nil
         rebuild_padded_lines
         update_top_line_if_auto_scroll
         notify_cursor_changed
         invalidate
+        self.content_size = compute_content_size
       end
 
       # Without a block, returns the current lines. With a block, fully
@@ -168,6 +176,7 @@ module Tuile
       # @return [void]
       def add_line(line)
         raise ArgumentError, "line is nil" if line.nil?
+
         add_lines [line]
       end
 
@@ -181,20 +190,11 @@ module Tuile
         screen.check_locked
         new_lines = parse_input_lines(lines)
         @lines += new_lines
-        @content_size = nil
         @padded_lines += new_lines.map { |line| pad_to_row(line) }
         update_top_line_if_auto_scroll
         notify_cursor_changed
         invalidate
-      end
-
-      # @return [Size]
-      def content_size
-        @content_size ||= begin
-          content_w = @lines.map(&:display_width).max || 0
-          width = @lines.empty? ? 0 : content_w + 2
-          Size.new(width, @lines.size)
-        end
+        grow_content_size(new_lines)
       end
 
       def focusable? = true
@@ -431,7 +431,7 @@ module Tuile
           # @param position [Integer] initial position.
           def initialize(positions, position: positions[0])
             @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
 
@@ -441,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)
@@ -453,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]
@@ -468,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)
@@ -477,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)
@@ -508,6 +508,30 @@ module Tuile
 
       private
 
+      # Natural size from scratch: longest line's display width plus the two
+      # single-space gutters {#pad_to_row} adds, × line count. An empty list
+      # is {Size::ZERO} (no gutters for no content).
+      # @return [Size]
+      def compute_content_size
+        content_w = @lines.map(&:display_width).max || 0
+        width = @lines.empty? ? 0 : content_w + 2
+        Size.new(width, @lines.size)
+      end
+
+      # Incremental {#content_size} update for appends: folds just the
+      # appended lines into the running maximum, keeping {#add_lines}
+      # O(appended) instead of re-scanning the whole list (LogWindow appends
+      # a line per log statement).
+      # @param appended [Array<StyledString>] the just-appended lines
+      #   (already concatenated onto {@lines}).
+      # @return [void]
+      def grow_content_size(appended)
+        return if appended.empty?
+
+        appended_w = appended.map(&:display_width).max + 2
+        self.content_size = Size.new([content_size.width, appended_w].max, @lines.size)
+      end
+
       # Coerces and flattens a list of input entries into trimmed
       # {StyledString} lines. Each entry becomes a {StyledString} (String
       # via {StyledString.parse}, StyledString passed through, anything else
@@ -612,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
@@ -643,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
 
@@ -665,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)
@@ -731,7 +764,7 @@ module Tuile
       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(CURSOR_BG) : base
+        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

data/lib/tuile/component/log_window.rb

@@ -28,6 +28,7 @@ module Tuile
       # @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} #{Rainbow(it.caption).cadetblue}" }
+        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
@@ -55,7 +55,7 @@ module Tuile
       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 +65,7 @@ module Tuile
 
       # @return [String]
       def keyboard_hint
-        @options.map { "#{it.key} #{Rainbow(it.caption).cadetblue}" }.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

@@ -35,6 +35,21 @@ module Tuile
 
       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.
@@ -81,10 +96,20 @@ module Tuile
         update_rect unless new_content.nil?
       end
 
+      # Re-sizes (and recenters, when open) whenever the wrapped content's
+      # natural size changes — e.g. a {Label}'s `text=`, a {List}'s
+      # `add_line`, or a nested {Window} whose own content grew (the window
+      # recomputes its {Component#content_size} and the change bubbles here).
+      # @param _child [Component]
+      # @return [void]
+      def on_child_content_size_changed(_child)
+        update_rect
+      end
+
       # Hint for the status bar: own "q Close" plus the wrapped content's hint.
       # @return [String]
       def keyboard_hint
-        prefix = "q #{Rainbow("Close").cadetblue}"
+        prefix = "q #{screen.theme.hint("Close")}"
         child_hint = @content&.keyboard_hint.to_s
         child_hint.empty? ? prefix : "#{prefix}  #{child_hint}"
       end
@@ -115,12 +140,18 @@ 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
         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?
+        r = Rect.new(0, 0, size.width, size.height)
+        r = r.centered(screen.size) if open?
+        self.rect = r
       end
     end
   end

data/lib/tuile/component/text_area.rb

@@ -70,7 +70,6 @@ module Tuile
       def repaint
         return if rect.empty?
 
-        bg = active? ? ACTIVE_BG_SGR : INACTIVE_BG_SGR
         rows = display_rows
         (0...rect.height).each do |screen_row|
           row_idx = screen_row + @top_display_row
@@ -81,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), bg, line, Ansi::RESET
+          screen.print TTY::Cursor.move_to(rect.left, rect.top + screen_row), background(line)
         end
       end
 

data/lib/tuile/component/text_field.rb

@@ -59,9 +59,8 @@ module Tuile
       def repaint
         return if rect.empty?
 
-        bg = active? ? ACTIVE_BG_SGR : INACTIVE_BG_SGR
         padded = @text + (" " * (rect.width - @text.length))
-        screen.print TTY::Cursor.move_to(rect.left, rect.top), bg, padded, Ansi::RESET
+        screen.print TTY::Cursor.move_to(rect.left, rect.top), background(padded)
       end
 
       protected

data/lib/tuile/component/text_input.rb

@@ -88,21 +88,6 @@ module Tuile
         invalidate
       end
 
-      # 256-color SGR for the focused-button highlight (matches what
-      # `Rainbow(...).bg(:darkslategray)` emits, which is what
-      # {Component::Button#repaint} uses for its focused state).
-      # @return [String]
-      ACTIVE_BG_SGR = "\e[48;5;59m"
-      # 256-color SGR for the unfocused field's "well": index 238 sits in
-      # the grayscale ramp (~#444444), bright enough to stand out against
-      # non-pure-black terminal themes (Gruvbox/Solarized/OneDark base
-      # backgrounds sit in the #1d–#2d range), and still distinctly darker
-      # than the active highlight at index 59 (~#5f5f5f). Rainbow's
-      # RGB-to-256 mapping snaps everything dark to palette index 16
-      # (terminal black), so we emit the escape directly to reach the ramp.
-      # @return [String]
-      INACTIVE_BG_SGR = "\e[48;5;238m"
-
       # 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}.
@@ -117,6 +102,16 @@ 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 —
+      # visibly a field either way, distinctly highlighted when active.
+      # @param text [String]
+      # @return [String] ANSI-rendered text.
+      def background(text)
+        active? ? screen.theme.active_bg(text) : screen.theme.input_bg(text)
+      end
+
       # Input filter for {#text=}. Subclasses override to truncate or reject
       # invalid input. Default coerces to String.
       # @param new_text [String]

data/lib/tuile/component/text_view.rb

@@ -50,10 +50,10 @@ module Tuile
         @physical_lines = []
         @hard_line_wrap_counts = []
         @text = StyledString::EMPTY
-        @content_size = Size::ZERO
         @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
@@ -81,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
@@ -110,10 +119,10 @@ module Tuile
         @regions = [Region.send(:new, self, @hard_lines.size)]
         return if content_unchanged
 
-        @content_size = compute_content_size
         rewrap
         update_top_line_if_auto_scroll
         invalidate
+        self.content_size = compute_content_size
       end
 
       # Creates a new empty {Region} at the spatial tail of the document
@@ -180,9 +189,9 @@ module Tuile
 
         tail_region.send(:line_count=, tail_region.line_count + added)
         @text = nil
-        @content_size = compute_content_size
         update_top_line_if_auto_scroll
         invalidate
+        self.content_size = compute_content_size
       end
 
       # Verbatim append, returning `self` for chainability (`view << a << b`).
@@ -254,10 +263,10 @@ module Tuile
         end
 
         @text = nil
-        @content_size = compute_content_size
         @top_line = top_line_max if @top_line > top_line_max
         update_top_line_if_auto_scroll
         invalidate
+        self.content_size = compute_content_size
       end
 
       # Replaces a contiguous range of hard lines with the parsed content
@@ -315,10 +324,10 @@ module Tuile
         splice_hard_lines(from, length, new_hard_lines)
         update_region_counts(from, length, new_hard_lines.size)
         @text = nil
-        @content_size = compute_content_size
         @top_line = top_line_max if @top_line > top_line_max
         update_top_line_if_auto_scroll
         invalidate
+        self.content_size = compute_content_size
       end
 
       # Inserts `str` at hard-line index `at`. Equivalent to
@@ -348,6 +357,7 @@ module Tuile
         return if @top_line == new_top_line
 
         @top_line = new_top_line
+        @follow = at_bottom?
         invalidate
       end
 
@@ -362,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
 
@@ -529,10 +541,10 @@ module Tuile
         splice_hard_lines(start, old_count, new_lines)
         region.send(:line_count=, new_lines.size)
         @text = nil
-        @content_size = compute_content_size
         @top_line = top_line_max if @top_line > top_line_max
         update_top_line_if_auto_scroll
         invalidate
+        self.content_size = compute_content_size
       end
 
       # Region-scoped {#replace}. Validates `range` against
@@ -555,10 +567,10 @@ module Tuile
         splice_hard_lines(abs_from, length, new_hard_lines)
         region.send(:line_count=, region.line_count - length + new_hard_lines.size)
         @text = nil
-        @content_size = compute_content_size
         @top_line = top_line_max if @top_line > top_line_max
         update_top_line_if_auto_scroll
         invalidate
+        self.content_size = compute_content_size
       end
 
       # Verbatim append into `region`.
@@ -595,10 +607,10 @@ module Tuile
           region.send(:line_count=, region.line_count + rest.size)
         end
         @text = nil
-        @content_size = compute_content_size
         @top_line = top_line_max if @top_line > top_line_max
         update_top_line_if_auto_scroll
         invalidate
+        self.content_size = compute_content_size
       end
 
       # Drops the last `n` hard lines from `region`'s tail via
@@ -617,10 +629,10 @@ module Tuile
         splice_hard_lines(drop_from, to_drop, [])
         region.send(:line_count=, region.line_count - to_drop)
         @text = nil
-        @content_size = compute_content_size
         @top_line = top_line_max if @top_line > top_line_max
         update_top_line_if_auto_scroll
         invalidate
+        self.content_size = compute_content_size
       end
 
       # Drops `region` from {@regions}: its hard lines are removed via
@@ -643,10 +655,10 @@ module Tuile
         return unless had_lines
 
         @text = nil
-        @content_size = compute_content_size
         @top_line = top_line_max if @top_line > top_line_max
         update_top_line_if_auto_scroll
         invalidate
+        self.content_size = compute_content_size
       end
 
       # Adjusts region line counts after a {@hard_lines} splice that
@@ -849,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?