tuile 0.8.0 → 0.9.0

data/book/08-testing.md

@@ -0,0 +1,186 @@
+# 8. Testing a Tuile app
+
+Every chapter so far has, quietly, also been about this one. When chapter
+2 said components *invalidate* rather than paint, and write into a back
+*buffer* rather than to the terminal — that was a testing decision as much
+as a rendering one. When chapter 4 insisted everything runs on one thread
+through a queue you could swap out — same. A Tuile app is testable without
+a terminal not because someone bolted on a test mode, but because the
+framework never actually needed the terminal. It needed a `Screen`, a
+buffer, and an event queue, and each of those has an in-memory double that
+behaves like the real thing minus the I/O.
+
+So this chapter is the payoff. It shows how to exercise a UI in a plain
+unit test — instantiate a component, poke it, and read back exactly what
+it drew — and, when that isn't enough, how to drive the whole real script
+through a pseudo-terminal.
+
+## The fake screen, and why it resets
+
+The singleton `Screen` from chapter 4 is the thing tests replace. Two
+class methods bracket every example:
+
+```ruby
+before { Screen.fake }
+after  { Screen.close }
+```
+
+`Screen.fake` installs a {Tuile::FakeScreen} as the process singleton — a
+`Screen` subclass with the terminal amputated. It has a fixed 160×50
+viewport (so geometry is deterministic, independent of whoever's terminal
+runs the suite), it writes nothing to any TTY, its `check_locked` is a
+no-op so you can mutate the UI freely from the test thread without holding
+the UI lock, and its event queue is the synchronous {Tuile::FakeEventQueue}
+(more on that below). It also pins the color scheme to `:dark`, skipping
+the OSC 11 probe from chapter 6 — a probe would otherwise write an escape
+query to the test runner's terminal and swallow its input.
+
+`Screen.close` matters as much as `fake` does, and the reason is the
+singleton itself. Because there is exactly one `Screen` per process
+(chapter 4), a screen left standing after one example is the *same* screen
+the next example sees — its tree, its focus, its invalidation set, all
+leaked forward. `close` tears the singleton down so each example starts
+from nothing. Skip the `after` and you get the classic singleton test
+smell: passes in isolation, fails in suite, order-dependent. The pair is
+not boilerplate you can trim.
+
+## Asserting what got painted
+
+Here's where the back buffer earns its keep. Recall from chapter 2 that
+components don't emit escape sequences — they write styled cells into
+`Screen#buffer`, and only a flush turns that into wire bytes. In a test
+that means the buffer *is* the rendered screen, sitting in memory, fully
+inspectable, before any diffing or I/O. You assert against it directly.
+
+The rhythm is: build the component, give it a `rect`, repaint, read the
+buffer back over that rect.
+
+```ruby
+label = Component::Label.new
+label.rect = Rect.new(0, 0, 10, 1)
+label.text = "hi"
+label.repaint
+
+assert_equal ["hi        "], Screen.instance.buffer.region_text(label.rect)
+```
+
+{Tuile::Buffer#region_text} returns the plain text of each row in the
+rect, one string per row (trailing pad included — the label fills its
+width). Its sibling {Tuile::Buffer#region_ansi} returns the same rows *with
+their SGR styling* rendered back into ANSI, which is what you assert
+against when the test is about *color* — that a focused field painted its
+active-background, say, or that a theme flip changed a hint's hue. And
+{Tuile::Buffer#cell} gives you a single cell's grapheme and style for a
+pinpoint check. Everything is scoped to a `rect`, so you assert about a
+component's own region without caring what surrounds it.
+
+What you do *not* assert content against is `prints`. On a FakeScreen,
+`prints` captures only what actually went "to the wire" — cursor
+positioning, housekeeping escapes, and the assembled frame string. Content
+lives in the buffer; cursor behavior lives in `prints`. Keeping the two
+apart is deliberate, and mixing them up is the most common way a first
+Tuile test goes wrong.
+
+## Driving the system
+
+There are two altitudes at which you feed input, and picking the right one
+is most of writing a good Tuile test.
+
+**Low: call the component directly.** {Tuile::Component#handle_key} and
+`handle_mouse` are public, and calling them straight tests a component's
+own logic in isolation — no focus, no dispatch, just "given this key, does
+the list move its cursor?" `handle_key` returns whether it consumed the
+key, so you assert on that too:
+
+```ruby
+list.handle_key(Keys::DOWN_ARROW)          # exercises the cursor directly
+list.handle_mouse(MouseEvent.new(:left, 5, 2))
+```
+
+**High: go through the screen.** {Tuile::Screen#handle_key} runs the *full*
+dispatch pipeline from chapter 5 — Tab cycling, global shortcuts, the
+subtree `key_shortcut` search, then the focus chain. When your test is
+about routing — that a shortcut jumps focus, that a modal popup traps Tab,
+that a focused text field swallows a key its sibling would otherwise claim
+— you drive `Screen.instance.handle_key` and let the real machinery run.
+Set focus the way production does, with `screen.focused = component` or
+`component.focus`.
+
+Two more test-only hooks close the loop. After you mutate something, call
+`Screen.instance.repaint` to flush the pending invalidations into the
+buffer — the coalesced repaint that chapter 2 said happens once per tick,
+triggered by hand because there's no loop running to trigger it. (This is
+a *test* affordance; production code never calls `repaint`, it just
+invalidates and lets the loop coalesce.) And to check invalidation itself
+— that a setter did, or deliberately didn't, mark its component dirty —
+`Screen.instance.invalidated?(component)` and `invalidated_clear` let you
+assert on the set directly.
+
+## Why background code just works
+
+Chapter 4's rule was that background threads marshal UI work back with
+`screen.event_queue.submit { … }`. That rule has a happy consequence for
+tests: under the {Tuile::FakeEventQueue}, `submit` **runs its block
+synchronously, right now, on the calling thread.** There is no loop, no
+thread, no waiting. So code that in production hands work across the
+thread boundary — a `LogWindow#log`, a worker posting a result — executes
+inline the moment the test calls it, and the effect is visible on the very
+next line. Posted *events* are simply discarded (a test isn't running the
+loop that would consume them), and `check_locked` passing for free means
+none of this trips the lock guard.
+
+The one thing with no clock is animation. `tick` on the fake returns a
+timeless ticker that fires only when the test tells it to: call
+`event_queue.tick_once` to pump every registered ticker one frame. A test
+that wants to advance an animation five frames calls `tick_once` five
+times — frame cadence is the test's to decide, since there's no real time
+passing.
+
+## End to end, through a real terminal
+
+Unit tests with the fake cover component logic and rendering, which is
+most of what you write. But some things only exist when the *real* app
+runs: the event loop actually looping, raw-mode key decoding, the WINCH
+trap, a live color-scheme flip. For those, Tuile's own suite spawns the
+real example script in a pseudo-terminal and talks to it like a user
+would. The `spec/examples/` tests are the template.
+
+The shape is always the same. Spawn the script under `PTY.spawn`; read its
+output until a glyph you know it paints appears — that single wait proves a
+lot at once (the tree built, a repaint ran, and the loop is now parked in
+the key wait); write a keystroke; assert the process exits cleanly.
+
+```ruby
+PTY.spawn("bundle", "exec", "ruby", "-Ilib", "examples/hello_world.rb") do |reader, writer, pid|
+  buffer = String.new
+  Timeout.timeout(10) do
+    buffer << reader.readpartial(4096) until buffer.include?("Hello, world!")
+  end
+  writer.write("q")
+  Timeout.timeout(5) { Process.wait(pid) }
+  assert_equal 0, $CHILD_STATUS.exitstatus
+end
+```
+
+This is the only place the whole stack is exercised together, and it's
+where you'd test something like the mode-2031 flip from chapter 6:
+wait for the dark-theme hint to paint, write the terminal's
+`\e[?997;2n` light report into the PTY, then wait for the *light* hint —
+which passes only if the entire chain (key-thread drain, event parse,
+theme reassignment, full repaint) actually ran end to end. The cost is
+that PTY tests are slower, terminal-dependent, and Linux/macOS only
+(Ruby's stdlib `PTY` isn't on Windows), so they stay a thin top layer over
+a broad base of fake-screen unit tests — the classic pyramid.
+
+---
+
+That closes the book. You've followed Tuile from the outside in and back
+out: a tree of components (chapter 1) that repaint through a back buffer
+without flicker (chapter 2), sized top-down by their parents (chapter 3),
+driven by a single-threaded event loop (chapter 4), with keys routed by
+focus (chapter 5) and accents drawn from a terminal-following theme
+(chapter 6); then the library you assemble from (chapter 7), and finally
+the fakes that let you test all of it with no terminal in sight (this
+one). The recurring lesson is the one the name promises: small pieces, each
+doing an obvious thing, composed. The framework is small because the ideas
+are few — and now they're all yours to build on.

data/book/README.md

@@ -0,0 +1,79 @@
+# The Tuile guide
+
+A short, sequential guide to building terminal UIs with Tuile. Each
+chapter builds on the vocabulary the previous one established, so
+reading order matters — the layout chapter assumes the component tree
+from chapter 1, focus assumes the event loop, and so on. Don't jump
+into chapter 5 without chapters 1 and 2 first.
+
+If you want the reference instead of the narrative, every public class
+and module is documented with YARD headers in the sources. Run
+`bundle exec rake yard` for a browsable local site, or — once the gem
+is published — see <https://rubydoc.info/gems/tuile>. The division of
+labour: this guide teaches concepts and the *why*; the rdoc carries the
+precise per-method technical truth. When the guide needs a signature it
+links to the rdoc rather than restating it.
+
+## How the guide is shaped
+
+Chapters 1–2 are the **base vocabulary** — the component tree and the
+repaint model that every later chapter leans on. Chapter 3 is the heart
+of Tuile's design: layout is top-down and absolute, and the chapter
+argues *why that is enough* — the "C64" case for hand-placed
+coordinates on a character grid — rather than reaching for the
+negotiated min/pref/max machinery of desktop and web toolkits.
+
+Chapters 4–6 are the **runtime**: the single-threaded event loop and
+how to do background work safely, focus and keyboard dispatch, and
+theming (including live OS light/dark flips). Chapters 7–8 close out
+**narratively** — a tour of the shipped component toolbox framed around
+when and why to reach for each, and how to test a Tuile app end to end.
+Those two lean on the rdoc for the exact APIs; the guide keeps to the
+walkthroughs and use-cases.
+
+The book grows organically — a chapter exists when a concept has earned
+one, not to fill an outline.
+
+## Chapters
+
+1. **[Your first Tuile app](01-first-app.md).** Install, then a
+   hello-world walkthrough. Establishes the base vocabulary the rest of
+   the guide leans on: the singleton `Tuile::Screen`, the tree of
+   `Tuile::Component`s under `ScreenPane`, and the "build a tree, run
+   the loop" shape of every Tuile program.
+2. **[How the screen repaints](02-repaint.md).** Why components never
+   write to the terminal directly. `invalidate` → the back buffer →
+   a minimal diff → one synchronized flush per tick. The "cover your
+   own `rect`" contract, and why the whole model is flicker-free
+   without damage tracking or clipping.
+3. **[Layout: the parent sets the size](03-layout.md).** The heart of
+   the design. Top-down, absolute, integer coordinates; a parent
+   assigns its children's `rect` and components never negotiate a size.
+   The C64 argument for *why simple layouting is enough* on a character
+   grid, `Layout::Absolute` and the `rect=` override, `Fraction` for
+   sizing a popup against the screen, and resize as a discrete
+   recompute. Geometry primitives (`Point` / `Size` / `Rect`) live here.
+4. **[The event loop and background work](04-event-loop.md).** The
+   single-threaded rule: all UI mutation happens on the loop thread.
+   The event queue, marshalling work back from a background thread with
+   `submit`, and how terminal resize (`SIGWINCH`) is plumbed through the
+   same queue rather than handled off the signal.
+5. **[Focus and the keyboard](05-focus.md).** The focus chain and
+   `focusable?`, and the order in which a keystroke is offered to the
+   tree — Tab, global shortcuts, a component's `key_shortcut`, then
+   `handle_key`. How a focused text field swallows printable keys, and
+   how `keyboard_hint` drives the status bar.
+6. **[Theming](06-theming.md).** Semantic color tokens read at paint
+   time, light/dark auto-detection at startup and live OS appearance
+   flips, pairing variants in a `ThemeDef`, app-specific custom tokens,
+   and rebuilding theme-derived content in `on_theme_changed`.
+7. **[The component library](07-components.md).** A narrative tour of
+   the shipped toolbox — Window, List, the text inputs and views,
+   Popup, and the window conveniences — framed around *when and why*
+   you reach for each. Signatures stay in the rdoc.
+8. **[Testing a Tuile app](08-testing.md).** The testing approach:
+   `FakeScreen`, asserting against the painted buffer, driving
+   invalidation, and PTY-based end-to-end tests of runnable scripts.
+
+All eight chapters are currently **stubs** — the skeleton is in place so
+the numbering is stable; prose lands chapter by chapter.

data/examples/hello_world.rb

@@ -14,8 +14,7 @@ require "tuile"
 # Tuile::Screen.instance during invalidate/repaint hooks.
 screen = Tuile::Screen.new
 
-label = Tuile::Component::Label.new
-label.text = "Hello, world!"
+label = Tuile::Component::Label.new("Hello, world!")
 
 window = Tuile::Component::Window.new("Tuile")
 window.content = label

data/lib/tuile/buffer.rb

@@ -8,7 +8,7 @@ module Tuile
   # string needed to bring a terminal — one that already matches the buffer's
   # state as of the previous flush — up to date. Only cells that actually
   # changed are emitted, so nothing flickers regardless of terminal/multiplexer
-  # synchronized-output support. See `ideas/back-buffer.md`.
+  # synchronized-output support.
   #
   # Coordinates are 0-based `(x, y)` = `(column, row)`, matching
   # {Component#rect} and `TTY::Cursor.move_to`.
@@ -40,6 +40,19 @@ module Tuile
   # nothing for, since the glyph itself advances the cursor two columns).
   # Overwriting either half of a wide glyph blanks the orphaned half, so the
   # grid never holds a dangling continuation or a headless one.
+  #
+  # ## Future direction
+  #
+  # Components paint through this drawing surface ({#set_line} / {#set_char})
+  # without knowing whether it is the one global buffer or a private one — that
+  # indirection is deliberate, so per-component back buffers plus a z-order
+  # compositor could drop in without touching component code. It is not worth
+  # doing yet: the diff already drops unchanged cells from the wire, and an
+  # occluded component that didn't change is never repainted at all, so a
+  # compositor would only save residual `repaint` CPU. It pays off in exactly
+  # one regime — high repeat-rate scroll (held arrow / mouse wheel) of a large
+  # component on a large screen, where re-rendering the content each repeat is
+  # the dominant cost.
   class Buffer
     # One screen cell: a single grapheme cluster, the {StyledString::Style} it's
     # drawn in, and a dirty flag. Mutable by design (see {Buffer} "Dirty
@@ -100,6 +113,23 @@ module Tuile
     DEFAULT_STYLE = StyledString::Style::DEFAULT
     private_constant :DEFAULT_STYLE
 
+    # Memo for {.display_width}: a grapheme's display width is fixed, and a TTY
+    # paints from a small, recurring alphabet (ASCII, box-drawing rules, a few
+    # emoji), so the per-grapheme width lookup — the dominant cost of a repaint
+    # (see `benchmark/display_width.rb`) — collapses to a Hash read after the
+    # first sighting. Shared across all buffers and unbounded, but bounded in
+    # practice by the font's glyph set; safe to share because all painting runs
+    # on the single UI thread (see AGENTS.md "Threading rule").
+    # @return [Hash{String => Integer}]
+    WIDTH_CACHE = Hash.new { |h, g| h[g] = Unicode::DisplayWidth.of(g) }
+    private_constant :WIDTH_CACHE
+
+    # Memoized {Unicode::DisplayWidth.of}. Use this for every paint-path width
+    # lookup instead of calling the gem directly.
+    # @param grapheme [String] one grapheme cluster.
+    # @return [Integer] its display width in columns (0 for combining marks).
+    def self.display_width(grapheme) = WIDTH_CACHE[grapheme]
+
     # @param size [Size] grid dimensions in columns × rows.
     def initialize(size)
       allocate_grid(size)
@@ -140,20 +170,7 @@ module Tuile
     # @param style [StyledString::Style]
     # @return [void]
     def set_char(x, y, grapheme, style = DEFAULT_STYLE)
-      return unless in_bounds?(x, y)
-
-      w = Unicode::DisplayWidth.of(grapheme)
-      return if w <= 0
-
-      if w == 2 && !in_bounds?(x + 1, y)
-        repair_orphans(x, y)
-        return write_cell(x, y, " ", style)
-      end
-
-      repair_orphans(x, y)
-      repair_orphans(x + 1, y) if w == 2
-      write_cell(x, y, grapheme, style)
-      write_cell(x + 1, y, "", style) if w == 2
+      put_char(x, y, grapheme, Buffer.display_width(grapheme), style)
     end
 
     # Writes a {StyledString} starting at `(x, y)`, advancing by each grapheme's
@@ -168,12 +185,13 @@ module Tuile
       col = x
       styled.spans.each do |span|
         span.text.grapheme_clusters.each do |g|
-          w = Unicode::DisplayWidth.of(g)
+          w = Buffer.display_width(g)
           next if w <= 0 # combining mark with no base in this run: skip
 
           break if col >= @width # rest of the line is clipped
 
-          set_char(col, y, g, span.style)
+          # Reuse the width we just computed: put_char skips re-measuring `g`.
+          put_char(col, y, g, w, span.style)
           col += w
         end
       end
@@ -313,6 +331,38 @@ module Tuile
 
     private
 
+    # Core of {#set_char} with the grapheme's display width already known.
+    # {#set_line} computes each width once while advancing the column and passes
+    # it straight through, so the paint hot path measures every grapheme exactly
+    # once (and that once is a {.display_width} memo read). See {#set_char} for
+    # the wide-glyph / clipping / out-of-bounds contract.
+    # @param x [Integer] column.
+    # @param y [Integer] row.
+    # @param grapheme [String] one grapheme cluster.
+    # @param w [Integer] `grapheme`'s display width (0, 1, or 2).
+    # @param style [StyledString::Style]
+    # @return [void]
+    def put_char(x, y, grapheme, w, style)
+      return unless in_bounds?(x, y)
+      return if w <= 0
+
+      if w == 2 && !in_bounds?(x + 1, y)
+        blank_left_partner(x, y)
+        return write_cell(x, y, " ", style)
+      end
+
+      # Repair only the glyphs we'd leave half-overwritten on our flanks: a wide
+      # glyph whose right half sits at `x`, or one whose left half sits at the
+      # last cell we write. The cells we fully rewrite need no pre-blanking —
+      # pre-blanking the continuation only to re-empty it would churn it
+      # spuriously dirty, which misplaces the next flush onto the glyph's right
+      # half (see bug/, balloon corruption).
+      blank_left_partner(x, y)
+      blank_right_partner(x + w - 1, y)
+      write_cell(x, y, grapheme, style)
+      write_cell(x + 1, y, "", style) if w == 2
+    end
+
     # (Re)allocates a blank grid of `size` with clean dirty state. Callers
     # follow with {#mark_all_dirty} when the terminal doesn't match the new
     # grid — construction and {#resize} both do.
@@ -342,11 +392,19 @@ module Tuile
         c = @cells[base + x]
         if c.dirty
           c.dirty = false
-          unless run_open
-            out << TTY::Cursor.move_to(x, y)
-            run_open = true
-          end
+          # A continuation cell (right half of a wide glyph) renders nothing of
+          # its own and must never open a run: positioning the cursor onto its
+          # column would land the next glyph on the wide glyph's left half,
+          # corrupting it. When the wide glyph itself is dirty it is emitted from
+          # its origin cell and advances the cursor across this column; when the
+          # glyph is intact this column needs no output at all. (A continuation
+          # can be left spuriously dirty by an in-place wide-glyph repaint, so we
+          # can't assume its origin was emitted in this same run.)
           unless c.continuation?
+            unless run_open
+              out << TTY::Cursor.move_to(x, y)
+              run_open = true
+            end
             out << style.sgr_to(c.style) << c.grapheme
             style = c.style
           end
@@ -393,20 +451,31 @@ module Tuile
       @any_dirty = true
     end
 
-    # If `(x, y)` is half of a wide glyph, blanks the *other* half, so a write
-    # that lands on either half doesn't strand the remaining one.
+    # If `(x, y)` holds the right half (continuation) of a wide glyph, blanks the
+    # orphaned left half at `x - 1`. Called before a write lands on `x`, so the
+    # wide glyph to the left isn't left headless.
     # @param x [Integer] column
     # @param y [Integer] row
     # @return [void]
-    def repair_orphans(x, y)
-      return unless in_bounds?(x, y)
+    def blank_left_partner(x, y)
+      return unless in_bounds?(x, y) && @cells[index(x, y)].continuation? && in_bounds?(x - 1, y)
 
-      c = @cells[index(x, y)]
-      if c.continuation?
-        write_cell(x - 1, y, " ", DEFAULT_STYLE) if in_bounds?(x - 1, y)
-      elsif Unicode::DisplayWidth.of(c.grapheme) == 2 && in_bounds?(x + 1, y)
-        write_cell(x + 1, y, " ", DEFAULT_STYLE)
-      end
+      write_cell(x - 1, y, " ", DEFAULT_STYLE)
+    end
+
+    # If the cell just right of `(x, y)` is a continuation (the right half of a
+    # wide glyph whose origin is `(x, y)`), blanks it. Called before a write
+    # lands on `x`, so overwriting a wide origin doesn't strand its continuation.
+    # A continuation can only ever belong to the wide glyph immediately to its
+    # left, so the empty-grapheme test is exact — and cheaper than re-measuring
+    # the origin's width.
+    # @param x [Integer] column
+    # @param y [Integer] row
+    # @return [void]
+    def blank_right_partner(x, y)
+      return unless in_bounds?(x + 1, y) && @cells[index(x + 1, y)].continuation?
+
+      write_cell(x + 1, y, " ", DEFAULT_STYLE)
     end
   end
 end

data/lib/tuile/component/button.rb

@@ -12,7 +12,7 @@ module Tuile
     # {Component#handle_mouse}.
     #
     # Assign a {#rect} (typically by the surrounding {Layout}) wide enough to
-    # show `[ caption ]`; {#content_size} reports that natural width.
+    # show `[ caption ]` — that natural width is `caption.length + 4`.
     class Button < Component
       # @param caption [String] the button's label.
       # @yield optional `on_click` callback; same as assigning {#on_click=}.
@@ -20,7 +20,6 @@ module Tuile
         super()
         @caption = caption.to_s
         @on_click = on_click
-        self.content_size = natural_size
       end
 
       # @return [String] the button's label.
@@ -39,7 +38,6 @@ module Tuile
 
         @caption = new_caption
         invalidate
-        self.content_size = natural_size
       end
 
       def focusable? = true
@@ -76,12 +74,6 @@ module Tuile
         styled = active? ? StyledString.styled(label, bg: screen.theme.active_bg_color) : StyledString.plain(label)
         screen.buffer.set_line(rect.left, rect.top, styled)
       end
-
-      private
-
-      # Natural width is `caption.length + 4` to fit `[ caption ]`; height 1.
-      # @return [Size]
-      def natural_size = Size.new(@caption.length + 4, 1)
     end
   end
 end

data/lib/tuile/component/info_window.rb

@@ -21,9 +21,11 @@ module Tuile
       # Opens the info window as a popup.
       # @param caption [String]
       # @param lines [Array<String>] the content, may contain formatting.
+      # @param size [Size, Fraction] the popup's size, applied top-down; the
+      #   list wraps and scrolls within it. Defaults to {Fraction::HALF}.
       # @return [Popup] the opened popup.
-      def self.open(caption, lines)
-        Popup.open(content: InfoWindow.new(caption, lines))
+      def self.open(caption, lines, size: Fraction::HALF)
+        Popup.open(content: InfoWindow.new(caption, lines), size: size)
       end
     end
   end

data/lib/tuile/component/label.rb

@@ -8,12 +8,17 @@ module Tuile
     # embedded ANSI is honored) or a {StyledString} directly. {#text}
     # always returns the {StyledString}.
     class Label < Component
-      def initialize
-        super
+      # @param text [String, StyledString, nil] initial text, coerced the same
+      #   way {#text=} coerces it (a `String` is parsed via
+      #   {StyledString.parse}; `nil` is an empty label). Equivalent to
+      #   constructing empty and assigning {#text=}.
+      def initialize(text = nil)
+        super()
         @text = StyledString::EMPTY
         @bg = nil
         @clipped_lines = []
         @blank_line = ""
+        self.text = text unless text.nil?
       end
 
       # @return [StyledString] the current text. Defaults to an empty
@@ -38,7 +43,6 @@ module Tuile
         @text = new_text
         update_clipped_lines
         invalidate
-        self.content_size = compute_content_size
       end
 
       # Sets the background color. Coerced via {Color.coerce}, so a Symbol,
@@ -84,18 +88,6 @@ module Tuile
 
       private
 
-      # Natural size: longest hard-line's display width × number of hard
-      # lines. Computed on the *unclipped* text — sizing is intrinsic to the
-      # content, not the viewport. Empty text yields {Size::ZERO}.
-      # @return [Size]
-      def compute_content_size
-        return Size::ZERO if @text.empty?
-
-        hard_lines = @text.lines
-        width = hard_lines.map(&:display_width).max || 0
-        Size.new(width, hard_lines.size)
-      end
-
       # Recomputes {@clipped_lines} for the current text and rect width.
       # Each line is ellipsized to fit and padded with trailing spaces out to
       # the full width, so {#repaint} is just a lookup + {Buffer#set_line} per

data/lib/tuile/component/layout.rb

@@ -56,15 +56,6 @@ module Tuile
         on_child_removed(child)
       end
 
-      # @return [Size]
-      def content_size
-        return Size::ZERO if @children.empty?
-
-        right  = @children.map { |c| c.rect.left + c.rect.width  }.max
-        bottom = @children.map { |c| c.rect.top  + c.rect.height }.max
-        Size.new(right - rect.left, bottom - rect.top)
-      end
-
       # Dispatches the event to the child under the mouse cursor.
       # @param event [MouseEvent]
       # @return [void]

data/lib/tuile/component/list.rb

@@ -147,7 +147,6 @@ module Tuile
         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
@@ -194,7 +193,6 @@ module Tuile
         update_top_line_if_auto_scroll
         notify_cursor_changed
         invalidate
-        grow_content_size(new_lines)
       end
 
       def focusable? = true
@@ -508,30 +506,6 @@ 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

data/lib/tuile/component/log_window.rb

@@ -24,20 +24,6 @@ module Tuile
         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]