tuile 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd5711addbd65a00c8d471204d50973da93ac9be65ba197114ac04c94cace526
-  data.tar.gz: 4505d93153dc96fd439e5d69a7b1506e985fc9094f8428fe092ebc6247d62b8a
+  metadata.gz: bf132f33d9f0dfd061a502d0b974a9906436bbc585bf363eb0ec7d97a2b223ae
+  data.tar.gz: 2d91fe558079a4b5c43abd3818c3bb47cd50dc4ac3372c4afe011ef33dc97045
 SHA512:
-  metadata.gz: 23c69343d8a0cc87143b12cd1a4a9a11862c770debf9c5381cabfcb59b55786f8be143ef362581e0a79bb1dc7f9ce512f47d755f603cb486bf4058b3487d4399
-  data.tar.gz: '0974d322289b63b43bdd498e172f446d7cc56df656645b8e6826fed388154dda4a287110819d305572dbbf1c1ee23011fc4e0cb208f6459d67535e2df5c1d2b1'
+  metadata.gz: 8258e9e552143470a5642559f6db98e5292e14fa2fa52c30a06e26bf505e44ff1c889da73792bc262def396997861187d02d95d4189ced1f853ab91333e606b5
+  data.tar.gz: 99c03866f8d65ec2c6ca61381078b69616a3e23b3dada3cc11a3d4e2e1fc2973e1d15ac2ac0147e0e583edd20fae247e5be85ad974cf53e245a8cc109b3fe084

data/CHANGELOG.md

@@ -1,5 +1,39 @@
 ## [Unreleased]
 
+## [0.5.0] - 2026-05-21
+
+- Add `Tuile::Color` — a value type wrapping the four color forms ANSI understands (named Symbol, 256-color Integer, RGB Array, or `nil`). Pre-defined constants `Color::RED`, `Color::BRIGHT_BLUE`, … cover the 16 named ANSI colors; `Color.coerce` accepts raw forms transparently.
+- `Component::Label`: add `bg` accessor — applies a background color uniformly across every painted row (text, trailing pad, and blank rows past the last line). Accepts anything `Color.coerce` accepts.
+- Add `Component::TextView::Region` — opaque handle to a contiguous run of hard lines, so apps can stream into logical sections without tracking line indices across sibling mutations. Create with `view.create_region`; mutate via `region.append`/`#<<`/`#text=`/`#add_line`/`#remove_last_n_lines`/`#replace`/`#insert`/`#remove`. Detached handles raise on every reader / mutator (except `#remove`, which is idempotent). `view.text=` / `clear` detach all region handles and install a fresh internal default.
+- Add `Component::TextView#replace(range, str)` and `#insert(at, str)` for mid-buffer hard-line splices (Integer or Range, inclusive/exclusive end, empty range == insertion, `begin == hard-line count` valid for end-insertion).
+- `Component::TextView`: incremental wrap via a per-hard-line row-count cache — mid-buffer mutations now re-wrap only the affected slice instead of the whole buffer. Speeds up the LLM streaming path (mid-document `region.append`, tombstone-style `region.text=`, `view.replace`/`view.insert`). `view.append` on the spatial tail keeps its existing fast path; `view.text=` and `on_width_changed` still do a full rewrap (now rebuilding the cache too).
+- Add `EventQueue#tick(fps) { |n| ... }` returning a `Ticker` backed by `Concurrent::TimerTask`; fires on the event-loop thread with a 0-based monotonic counter. Intended for spinner animations, periodic refresh, or surfacing background-task progress. Auto-cancels on raise.
+- Add `FakeEventQueue#tick` and `FakeTicker` — synchronous test double that drives ticks deterministically.
+- **Breaking:** `StyledString::Style#fg` and `#bg` now return `Color` (or `nil`) instead of the raw `Symbol`/`Integer`/`Array`. `Style.new` and `#merge` continue to accept the raw forms via `Color.coerce`.
+- **Breaking:** Remove `StyledString::Style::COLOR_SYMBOLS` — moved to `Color::COLOR_SYMBOLS`.
+- **Breaking:** `EventQueue#run_loop` now yields submitted `Proc` events to its consumer block instead of dispatching them inline, so a raise from a `submit{}` block is routed through `Screen#on_error` like any other event. Custom `run_loop` consumers must `call` Procs in their case statement.
+
+## [0.4.0] - 2026-05-20
+
+- Add `Screen#register_global_shortcut` for app-level hotkeys; registered shortcuts surface in the status bar via `hint:`.
+- Add `Keys::CTRL_A..CTRL_Z` constants and `Keys.printable?` (extracted from `TextField`/`TextArea`/`Screen`).
+- Extract `Component::TextInput` as the shared base of `TextField` and `TextArea`; add `#empty?`.
+- `TextField`/`TextArea`: default `on_escape` to clear focus.
+- `Screen#run_event_loop` accepts `capture_mouse:` (default `true`); pass `false` to skip xterm mouse tracking so the terminal's native select-to-copy keeps working.
+- `StyledString`: add `#with_fg`, mirroring `#with_bg`.
+- `Component::TextView`: add `#<<`, `#add_line`, `#empty?`, and `#remove_last_n_lines` for streaming-tail retraction.
+- `MouseEvent`: map buttons 66/67 to `:scroll_left`/`:scroll_right`.
+- `Component::LogWindow`: extract `#log` helper.
+- `Component::List`: skip `auto_scroll` when rect is empty; re-snap on width change; snap cursor to last line on `auto_scroll`.
+- Document `Component#repaint`'s attached-only call contract.
+- Document keyboard input dispatch order and testing (`FakeScreen`, PTY system tests) in the README.
+- **Breaking:** `Component::TextView#append` is now verbatim — chunks are concatenated onto the current last hard line, embedded `\n` becomes hard breaks, no implicit newline is inserted. Designed for streaming use (e.g. an LLM chat window feeding partial messages straight in). Aliased as `<<` for chainability. The old "add a new entry" behavior is now `Component::TextView#add_line`.
+- **Breaking:** `MouseEvent.parse` raises on malformed input instead of silently truncating.
+- Fix: `Component` gates `invalidate` and `repaint` on `attached?`, dropping the negative-rect relic.
+- Fix: `Popup` recomputes size from content on every `#open`.
+- Fix: `Keys.getkey` reads 5 trailing bytes after ESC, not 6.
+- Fix: `Component::List#add_line` rejects `nil`.
+
 ## [0.3.0] - 2026-05-18
 
 - Add `Component::TextView` — read-only scrollable wrapped prose with word wrap, incremental append, and a lazy text reader.

data/README.md

@@ -146,7 +146,7 @@ posts a size event, runs layout, and invalidates the entire tree. Components
 react by reassigning their child rectangles inside `rect=` — do not install
 your own WINCH handler.
 
-### Focus and shortcuts
+### Focus and keyboard input
 
 `screen.focused = component` walks parent pointers up to the root, marks the
 whole chain `active?`, and deactivates everything else. Click-to-focus and
@@ -154,10 +154,86 @@ whole chain `active?`, and deactivates everything else. Click-to-focus and
 returns true, so clicking a `Label` inside a `Window` does not pull focus
 away from the window's content.
 
-`key_shortcut` is matched against the focused component's whole subtree
-*unless* the focused component owns the hardware cursor (e.g. a `TextField`
-the user is typing into) — that suppression is what lets text fields swallow
-printable keys without sibling shortcuts hijacking them.
+When a key arrives, the screen dispatches it in this order — the first
+mechanism that handles it wins:
+
+1. **Tab / Shift+Tab** advance focus through `tab_stop?` components in the
+   current modal scope (the topmost popup if one is open, otherwise the
+   tiled content). They are intercepted at the screen level before anything
+   else sees them, so a focused `TextField` cannot swallow them.
+
+2. **Global shortcuts** registered via `Screen#register_global_shortcut`.
+   These are app-level hotkeys for actions that don't belong to any
+   specific component — opening a log window, toggling help, etc.:
+
+   ```ruby
+   screen.register_global_shortcut(Tuile::Keys::CTRL_L,
+                                   over_popups: true,
+                                   hint: "^L #{Rainbow('log').cadetblue}") do
+     log_popup.open
+   end
+   screen.unregister_global_shortcut(Tuile::Keys::CTRL_L)
+   ```
+
+   Only unprintable keys are accepted (control characters, ESC, BACKSPACE,
+   arrows, F-keys); printable keys raise so they can't hijack typing into
+   a `TextField`. By default, the shortcut is suppressed while any popup
+   is open and the popup receives the key; pass `over_popups: true` to
+   pre-empt the popup.
+
+   Pass `hint:` to surface the shortcut in the status bar. It's a
+   preformatted string the caller fully owns (color it however the rest
+   of your app does). In the tiled case it appears right after `q quit`
+   and before the active window's hint; while a popup is open, only
+   `over_popups: true` hints show up, prepended before the popup's
+   `q Close`. Omit `hint:` to leave the shortcut silent in the status bar.
+
+3. **`Component#key_shortcut`** — a declarative hotkey attached to a
+   component. The framework walks the focused component's subtree for a
+   match and focuses the winner. Good fit for "press F to focus the filter
+   field" or one-key tab pickers. The lookup is suppressed while the
+   focused component owns the hardware cursor (e.g. a `TextField` the user
+   is typing into) so editing isn't interrupted:
+
+   ```ruby
+   filter_field.key_shortcut = "f"
+   ```
+
+4. **`Component#handle_key`** — override this on your own component when
+   it needs to react to keys directly (a list reacting to arrows, a custom
+   widget handling Enter, …). Return `true` to mark the key handled,
+   `false` to let the dispatcher keep walking. Call `super` to keep the
+   default `key_shortcut` subtree lookup; suppress it only when you
+   deliberately want this component to swallow everything:
+
+   ```ruby
+   class Toggle < Tuile::Component
+     def handle_key(key)
+       if key == " "
+         @on = !@on
+         invalidate
+         true
+       else
+         super
+       end
+     end
+   end
+   ```
+
+If nothing handles the key and it's `q` or `ESC`, the event loop exits.
+
+A component can advertise the keys it responds to by overriding
+`keyboard_hint`. The status bar shows the active window's hint alongside
+the global `q quit` prompt; while a popup is open, the popup's own hint
+replaces it, prefixed with `q Close`:
+
+```ruby
+class FilterWindow < Tuile::Component::Window
+  def keyboard_hint
+    "f #{Rainbow('filter').cadetblue}  Enter #{Rainbow('open').cadetblue}"
+  end
+end
+```
 
 ## Components
 
@@ -352,6 +428,62 @@ Tuile.logger = TTY::Logger.new                  # duck-typed, works directly
 Tuile.logger = Logger.new(Tuile::Component::LogWindow::IO.new(window))
 ```
 
+## Testing
+
+Tuile ships with a `Tuile::FakeScreen` that you install in place of the real
+screen for unit tests. It fixes the viewport at 160×50, disables the UI lock,
+collects every string the framework "would have printed" into an array, and
+uses a synchronous `FakeEventQueue` (submitted blocks run inline; posted
+events are discarded). No terminal IO happens, so the TTY running the tests
+is never painted over.
+
+The standard setup is `Screen.fake` / `Screen.close` as a before/after pair —
+this resets the singleton between examples, so state can't leak across
+tests:
+
+```ruby
+require "tuile"
+
+module Tuile
+  describe Component::Label do
+    before { Screen.fake }
+    after  { Screen.close }
+
+    it "renders text into its rect" do
+      label = Component::Label.new
+      label.rect = Rect.new(0, 0, 5, 1)
+      label.text = "hi"
+      label.repaint
+      assert_equal [TTY::Cursor.move_to(0, 0), "hi   "], Screen.instance.prints
+    end
+  end
+end
+```
+
+Key hooks:
+
+- `Screen.instance.prints` — array of strings the screen would have written
+  to the terminal. Assert against it (or `.join`) for repaint output.
+- `Screen.instance.repaint` — drive a repaint synchronously; production code
+  must not call this, but specs use it to flush the invalidated set after a
+  mutation.
+- `Screen.instance.invalidated?(component)` / `invalidated_clear` — verify
+  that a mutation did (or did not) invalidate something. Setting a property
+  to its current value should typically *not* invalidate.
+- `Screen.instance.clear` — drops accumulated `prints` without resetting
+  invalidation.
+
+Because `FakeEventQueue#submit` runs the block immediately on the calling
+thread, code paths that marshal work back via `screen.event_queue.submit { … }`
+just work in tests. Posted events (`#post`) are dropped — if your test needs
+to drive a real event loop, you are in system-test territory.
+
+For end-to-end tests of a runnable script, spawn it in a pseudo-TTY with
+`PTY.spawn`, wait for a known glyph to confirm the first paint landed, send
+a key, and assert the exit status. `spec/examples/hello_world_spec.rb` is the
+canonical template; PTY-based tests are Linux/macOS only since Ruby's stdlib
+`PTY` isn't on Windows.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then,

data/lib/tuile/color.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Tuile
+  # An immutable terminal color. Accepts the three forms ANSI/SGR understands:
+  #
+  # - a Symbol from {COLOR_SYMBOLS} — 8 standard + 8 bright named colors
+  #   (SGR 30..37 / 90..97 for fg, 40..47 / 100..107 for bg)
+  # - an Integer 0..255 — the 256-color palette (SGR 38;5;N / 48;5;N)
+  # - an Array of three Integers 0..255 — 24-bit RGB (SGR 38;2;R;G;B / 48;2;R;G;B)
+  #
+  # A constant per named color is pre-defined (`Color::RED`, `Color::BRIGHT_BLUE`,
+  # …) so callers can reach for `Color::RED` instead of building one each time.
+  # {.coerce} accepts anything {.new} accepts plus `nil` (terminal default) and
+  # an existing {Color} (returned as-is), so APIs that accept colors typically
+  # take `[Color, nil]` and pass through {.coerce}.
+  #
+  # ```ruby
+  # Color.new(:red)              # named
+  # Color.new(42)                # 256-color palette
+  # Color.new([255, 100, 0])     # RGB
+  # Color::RED                   # constant
+  # Color.coerce(:red)           # accepts raw forms, returns Color
+  # Color.coerce(nil)            # nil → nil
+  # ```
+  #
+  # {#to_ansi} renders a full SGR escape (`"\e[31m"`); {#sgr_codes} returns the
+  # raw numeric codes so callers (notably {StyledString}) can combine them with
+  # other SGR attributes in a single sequence.
+  class Color
+    # Symbolic color names. Order is significant: indices 0..7 map to the
+    # standard ANSI colors (SGR 30..37 fg / 40..47 bg); indices 8..15 map to
+    # bright variants (SGR 90..97 / 100..107).
+    # @return [Array<Symbol>]
+    COLOR_SYMBOLS = %i[
+      black red green yellow blue magenta cyan white
+      bright_black bright_red bright_green bright_yellow
+      bright_blue bright_magenta bright_cyan bright_white
+    ].freeze
+
+    # Coerces the input to a {Color}. `nil` passes through unchanged (callers
+    # use `nil` for the terminal default); an existing {Color} is returned
+    # as-is; otherwise the value is fed to {.new}.
+    #
+    # @param value [Color, Symbol, Integer, Array<Integer>, nil]
+    # @return [Color, nil]
+    # @raise [ArgumentError] when `value` is not one of the accepted forms.
+    def self.coerce(value)
+      case value
+      when nil, Color then value
+      else new(value)
+      end
+    end
+
+    # @param value [Symbol, Integer, Array<Integer>] see class-level docs for
+    #   the three accepted forms.
+    # @raise [ArgumentError] when `value` is not one of the accepted forms.
+    def initialize(value)
+      unless COLOR_SYMBOLS.include?(value) ||
+             (value.is_a?(Integer) && value.between?(0, 255)) ||
+             (value.is_a?(Array) && value.length == 3 &&
+              value.all? { |v| v.is_a?(Integer) && v.between?(0, 255) })
+        raise ArgumentError, "invalid color: #{value.inspect}"
+      end
+
+      @value = value.is_a?(Array) ? value.dup.freeze : value
+      freeze
+    end
+
+    # The underlying raw representation — a Symbol, Integer, or frozen
+    # Array<Integer>.
+    # @return [Symbol, Integer, Array<Integer>]
+    attr_reader :value
+
+    # SGR parameter codes for emitting this color as either a foreground
+    # (`target: :fg`) or background (`target: :bg`). Returned as an array so
+    # callers can splice them into a multi-attribute SGR (e.g. bold + color).
+    #
+    # @param target [Symbol] `:fg` or `:bg`.
+    # @return [Array<Integer>]
+    # @raise [ArgumentError] when `target` is neither `:fg` nor `:bg`.
+    def sgr_codes(target = :fg)
+      base, ext = case target
+                  when :fg then [30, 38]
+                  when :bg then [40, 48]
+                  else raise ArgumentError, "target must be :fg or :bg, got #{target.inspect}"
+                  end
+      case @value
+      when Symbol
+        idx = COLOR_SYMBOLS.index(@value)
+        idx < 8 ? [base + idx] : [base + 60 + (idx - 8)]
+      when Integer then [ext, 5, @value]
+      when Array then [ext, 2, *@value]
+      end
+    end
+
+    # Full SGR escape sequence for this color (e.g. `"\e[31m"`). Useful for
+    # `print`-style direct emission; for composing with other attributes use
+    # {#sgr_codes} instead.
+    #
+    # @param target [Symbol] `:fg` or `:bg`.
+    # @return [String]
+    def to_ansi(target = :fg)
+      "\e[#{sgr_codes(target).join(";")}m"
+    end
+
+    # @param other [Object]
+    # @return [Boolean]
+    def ==(other)
+      other.is_a?(Color) && @value == other.value
+    end
+    alias eql? ==
+
+    # @return [Integer]
+    def hash
+      [self.class, @value].hash
+    end
+
+    # @return [String]
+    def inspect
+      "#<#{self.class.name} #{@value.inspect}>"
+    end
+
+    COLOR_SYMBOLS.each do |sym|
+      const_set(sym.upcase, new(sym))
+    end
+  end
+end

data/lib/tuile/component/label.rb

@@ -11,6 +11,7 @@ module Tuile
       def initialize
         super
         @text = StyledString::EMPTY
+        @bg = nil
         @clipped_lines = []
         @blank_line = ""
       end
@@ -19,6 +20,11 @@ module Tuile
       #   {StyledString}.
       attr_reader :text
 
+      # @return [Color, nil] background color applied uniformly across every
+      #   painted row (including padding past the text). `nil` (default)
+      #   leaves whatever bg the text's own styling carries.
+      attr_reader :bg
+
       # Replaces the text. A `String` is parsed via {StyledString.parse}
       # (embedded ANSI is honored); a `StyledString` is used as-is; `nil` is
       # coerced to an empty {StyledString}. Lines wider than {#rect} are
@@ -35,6 +41,23 @@ module Tuile
         invalidate
       end
 
+      # Sets the background color. Coerced via {Color.coerce}, so a Symbol,
+      # Integer, Array, {Color}, or `nil` all work. `nil` clears the override
+      # — the label paints with whatever bg the text's own styling provides.
+      # Otherwise the bg overlays every span (including the trailing pad and
+      # blank rows past the last text line).
+      #
+      # @param value [Color, Symbol, Integer, Array<Integer>, nil]
+      # @return [void]
+      def bg=(value)
+        new_bg = Color.coerce(value)
+        return if @bg == new_bg
+
+        @bg = new_bg
+        update_clipped_lines
+        invalidate
+      end
+
       # @return [Size] longest hard-line's display width × number of hard
       #   lines. Reported on the *unclipped* text — sizing is intrinsic to
       #   the content, not the viewport. Empty text returns `Size.new(0, 0)`.
@@ -57,7 +80,7 @@ module Tuile
       # wipe.
       # @return [void]
       def repaint
-        return if rect.empty? || rect.left.negative? || rect.top.negative?
+        return if rect.empty?
 
         (0...rect.height).each do |row|
           line = @clipped_lines[row] || @blank_line
@@ -79,12 +102,19 @@ module Tuile
       # Each line is ellipsized to fit, padded with trailing spaces out to
       # the full width, and pre-rendered to ANSI so {#repaint} is just a
       # lookup + screen.print per row. {@blank_line} covers rows past the
-      # last text line.
+      # last text line. When {#bg} is set, every produced line (and the
+      # blank row) has the bg applied uniformly.
       # @return [void]
       def update_clipped_lines
         width = rect.width.clamp(0, nil)
-        @blank_line = " " * width
-        @clipped_lines = @text.lines.map { |line| pad_to(line.ellipsize(width), width).to_ansi }
+        @blank_line = apply_bg(StyledString.plain(" " * width)).to_ansi
+        @clipped_lines = @text.lines.map { |line| apply_bg(pad_to(line.ellipsize(width), width)).to_ansi }
+      end
+
+      # @param line [StyledString]
+      # @return [StyledString]
+      def apply_bg(line)
+        @bg ? line.with_bg(@bg) : line
       end
 
       # @param line [StyledString]

data/lib/tuile/component/list.rb

@@ -167,6 +167,7 @@ module Tuile
       # @param line [String, StyledString, #to_s]
       # @return [void]
       def add_line(line)
+        raise ArgumentError, "line is nil" if line.nil?
         add_lines [line]
       end
 
@@ -326,6 +327,16 @@ module Tuile
           def candidate_positions(_line_count)
             []
           end
+
+          # Overridden so all movement funnels — base {Cursor#go_to_last},
+          # {Cursor#go_to_first}, etc., which all call {#go} — become safe
+          # no-ops on a disabled cursor. The instance is frozen, so a default
+          # mutating {#go} would raise.
+          # @param _new_position [Integer]
+          # @return [Boolean] always false.
+          def go(_new_position)
+            false
+          end
         end
 
         # @return [Integer] 0-based line index of the current cursor position.
@@ -384,6 +395,15 @@ module Tuile
           true
         end
 
+        # Moves the cursor to the last reachable position. For base {Cursor},
+        # the last line; {Limited} clamps to the last allowed position; {None}
+        # is a no-op.
+        # @param line_count [Integer] number of lines in the list.
+        # @return [Boolean] true if the position changed.
+        def go_to_last(line_count)
+          go(line_count - 1)
+        end
+
         protected
 
         # @param lines [Integer]
@@ -404,12 +424,6 @@ module Tuile
           go(0)
         end
 
-        # @param line_count [Integer]
-        # @return [Boolean]
-        def go_to_last(line_count)
-          go(line_count - 1)
-        end
-
         # Cursor which can only land on specific allowed lines.
         class Limited < Cursor
           # @param positions [Array<Integer>] allowed positions. Must not be
@@ -442,6 +456,12 @@ module Tuile
             @positions.select { it < line_count }
           end
 
+          # @param _line_count [Integer]
+          # @return [Boolean]
+          def go_to_last(_line_count)
+            go(@positions.last)
+          end
+
           protected
 
           # @param lines [Integer]
@@ -467,12 +487,6 @@ module Tuile
           def go_to_first
             go(@positions.first)
           end
-
-          # @param _line_count [Integer]
-          # @return [Boolean]
-          def go_to_last(_line_count)
-            go(@positions.last)
-          end
         end
       end
 
@@ -480,11 +494,16 @@ module Tuile
 
       # Rebuilds pre-padded lines when the wrap width changes. The wrap width
       # depends on {#rect}`.width` and the scrollbar gutter, both of which
-      # trigger this hook.
+      # trigger this hook. Also re-evaluates {#auto_scroll}: if items were
+      # appended while the rect was empty (e.g. a {Popup}-wrapped list got
+      # `add_line` calls before the popup was opened), the auto-scroll update
+      # was skipped because there was no viewport — re-run it now that there
+      # is one, so the list snaps to the bottom on first paint.
       # @return [void]
       def on_width_changed
         super
         rebuild_padded_lines
+        update_top_line_if_auto_scroll
       end
 
       private
@@ -638,10 +657,20 @@ module Tuile
         invalidate
       end
 
-      # If auto-scrolling, recalculate the top line.
+      # If auto-scrolling, recalculate the top line and snap the cursor to the
+      # last reachable position. Without the cursor snap the viewport gets
+      # yanked back to wherever the cursor sat on the next arrow press,
+      # negating the auto-scroll. Skipped when {#rect} is empty: without a
+      # viewport the "lines minus viewport" formula yields `@lines.size`,
+      # 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.
       # @return [void]
       def update_top_line_if_auto_scroll
         return unless @auto_scroll
+        return if rect.empty?
+
+        notify_cursor_changed if @cursor.go_to_last(@lines.size)
 
         new_top_line = (@lines.size - viewport_lines).clamp(0, nil)
         return unless @top_line != new_top_line

data/lib/tuile/component/log_window.rb

@@ -23,6 +23,16 @@ module Tuile
         self.scrollbar = true
       end
 
+      # 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
+      end
+
       # IO-shaped adapter that forwards each log line to the owning {LogWindow}.
       # Implements both {#write} (stdlib `Logger`) and {#puts} (loggers that
       # call `output.puts`, e.g. `TTY::Logger`).
@@ -35,17 +45,13 @@ module Tuile
         # @param string [String]
         # @return [void]
         def write(string)
-          @window.screen.event_queue.submit do
-            @window.content.add_line(string.chomp)
-          end
+          @window.log(string.chomp)
         end
 
         # @param string [String]
         # @return [void]
         def puts(string)
-          @window.screen.event_queue.submit do
-            @window.content.add_line(string)
-          end
+          @window.log(string)
         end
 
         # Stdlib `Logger` only treats an object as an IO target when it

data/lib/tuile/component/popup.rb

@@ -30,17 +30,17 @@ module Tuile
       def initialize(content: nil)
         super()
         @content = nil
-        # Off-screen sentinel until the content sets a real size and the popup
-        # is centered on open.
-        @rect = Rect.new(-1, -1, 0, 0)
         self.content = content unless content.nil?
       end
 
       def focusable? = true
 
-      # Mounts this popup on the {Screen}.
+      # 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.
       # @return [void]
       def open
+        update_rect unless @content.nil?
         screen.add_popup(self)
       end
 
@@ -119,7 +119,7 @@ module Tuile
       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(-1, -1, size.width, size.height)
+        self.rect = Rect.new(0, 0, size.width, size.height)
         center if open?
       end
     end