ratatui_ruby 0.4.0 → 0.6.0

data/lib/ratatui_ruby/test_helper.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
-require "timeout"
-require "minitest/mock"
-
 
+require "fileutils"
+require_relative "test_helper/terminal"
+require_relative "test_helper/snapshot"
+require_relative "test_helper/event_injection"
+require_relative "test_helper/style_assertions"
+require_relative "test_helper/test_doubles"
 
 # SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 # SPDX-License-Identifier: AGPL-3.0-or-later
@@ -11,208 +14,78 @@ module RatatuiRuby
   ##
   # Helpers for testing RatatuiRuby applications.
   #
-  # This module provides methods to set up a test terminal, capture buffer content,
-  # and inject events, making it easier to write unit tests for your TUI apps.
+  # Writing TUI tests by hand is tedious. You need a headless terminal, event
+  # injection, snapshot comparisons, and style assertions. Wiring all that up
+  # yourself is error-prone.
+  #
+  # This module bundles everything you need. Include it in your test class and
+  # start writing tests immediately.
+  #
+  # == Included Mixins
   #
-  # == Usage
+  # [Terminal] Sets up a headless terminal and queries its buffer.
+  # [Snapshot] Compares the screen against stored reference files.
+  # [EventInjection] Simulates keypresses, mouse clicks, and resize events.
+  # [StyleAssertions] Checks foreground color, background color, and text modifiers.
+  # [TestDoubles] Provides mocks and stubs for testing views in isolation.
+  #
+  # == Example
   #
   #   require "ratatui_ruby/test_helper"
   #
-  #   class MyTest < Minitest::Test
+  #   class TestMyApp < Minitest::Test
   #     include RatatuiRuby::TestHelper
   #
-  #     def test_rendering
+  #     def test_initial_render
   #       with_test_terminal(80, 24) do
-  #         # ... render your app ...
-  #         assert_includes buffer_content, "Hello World"
+  #         MyApp.new.run_once
+  #         assert_snapshot("initial")
+  #       end
+  #     end
+  #
+  #     def test_themes
+  #       with_test_terminal do
+  #         app = ThemeDemo.new
+  #         app.run_once
+  #         assert_rich_snapshot("default_theme")
+  #
+  #         inject_key("t", modifiers: [:ctrl])
+  #         app.run_once
+  #         assert_rich_snapshot("dark_theme")
+  #
+  #         inject_key("t", modifiers: [:ctrl])
+  #         app.run_once
+  #         assert_rich_snapshot("high_contrast_theme")
+  #       end
+  #     end
+  #
+  #     def test_highlighter_applies_selection_style
+  #       with_test_terminal(40, 5) do
+  #         RatatuiRuby.draw do |frame|
+  #           highlighter = MyApp::UI::Highlighter.new(:yellow)
+  #           highlighter.render_at(frame, 0, 2, "Selected Item")
+  #         end
+  #
+  #         assert_fg_color(:yellow, 0, 2)
+  #         assert_bold(0, 2)
   #       end
   #     end
   #
-  #     def test_key_handling
-  #       inject_event(RatatuiRuby::Event::Key.new(code: "q"))
-  #       result = @app.handle_input
-  #       assert_equal :quit, result
+  #     def test_view_in_isolation
+  #       frame = MockFrame.new
+  #       area = StubRect.new(width: 60, height: 20)
+  #
+  #       MyView.new.call(state, tui, frame, area)
+  #
+  #       widget = frame.rendered_widgets.first[:widget]
+  #       assert_equal "Dashboard", widget.block.title
   #     end
   #   end
   module TestHelper
-    ##
-    # Initializes a test terminal context with specified dimensions.
-    # Restores the original terminal state after the block executes.
-    #
-    # +width+:: width of the test terminal (default: 80)
-    # +height+:: height of the test terminal (default: 24)
-    #
-    # +timeout+:: maximum execution time in seconds (default: 2). Pass nil to disable.
-    #
-    # If a block is given, it is executed within the test terminal context.
-    def with_test_terminal(width = 80, height = 24, timeout: 2)
-      RatatuiRuby.init_test_terminal(width, height)
-      # Flush any lingering events from previous tests
-      while RatatuiRuby.poll_event; end
-
-      RatatuiRuby.stub :init_terminal, nil do
-        RatatuiRuby.stub :restore_terminal, nil do
-          begin
-            @_ratatui_test_terminal_active = true
-            if timeout
-              Timeout.timeout(timeout) do
-                yield
-              end
-            else
-              yield
-            end
-          ensure
-            @_ratatui_test_terminal_active = false
-          end
-        end
-      end
-    ensure
-      RatatuiRuby.restore_terminal
-    end
-
-    ##
-    # Returns the current content of the terminal buffer as an array of strings.
-    # Each string represents a row in the terminal.
-    #
-    #   buffer_content
-    #   # => ["Row 1 text", "Row 2 text", ...]
-    def buffer_content
-      RatatuiRuby.get_buffer_content.split("\n")
-    end
-
-    ##
-    # Returns the current cursor position as a hash with +:x+ and +:y+ keys.
-    #
-    #   cursor_position
-    #   # => { x: 0, y: 0 }
-    def cursor_position
-      x, y = RatatuiRuby.get_cursor_position
-      { x:, y: }
-    end
-
-    ##
-    # Injects an event into the event queue for testing.
-    #
-    # Pass any RatatuiRuby::Event object. The event will be returned by
-    # the next call to RatatuiRuby.poll_event.
-    #
-    # Raises a +RuntimeError+ if called outside of a +with_test_terminal+ block.
-    #
-    # == Examples
-    #
-    #   with_test_terminal do
-    #     # Key events
-    #     inject_event(RatatuiRuby::Event::Key.new(code: "q"))
-    #     inject_event(RatatuiRuby::Event::Key.new(code: "s", modifiers: ["ctrl"]))
-    #
-    #     # Mouse events
-    #     inject_event(RatatuiRuby::Event::Mouse.new(kind: "down", button: "left", x: 10, y: 5))
-    #
-    #     # Resize events
-    #     inject_event(RatatuiRuby::Event::Resize.new(width: 120, height: 40))
-    #
-    #     # Paste events
-    #     inject_event(RatatuiRuby::Event::Paste.new(content: "Hello"))
-    #
-    #     # Focus events
-    #     inject_event(RatatuiRuby::Event::FocusGained.new)
-    #     inject_event(RatatuiRuby::Event::FocusLost.new)
-    #   end
-    def inject_event(event)
-      unless @_ratatui_test_terminal_active
-        raise "Events must be injected inside a `with_test_terminal` block. " \
-              "Calling this method outside the block causes a race condition where the event " \
-              "is flushed before the application starts."
-      end
-
-      case event
-      when RatatuiRuby::Event::Key
-        RatatuiRuby.inject_test_event("key", { code: event.code, modifiers: event.modifiers })
-      when RatatuiRuby::Event::Mouse
-        RatatuiRuby.inject_test_event("mouse", {
-          kind: event.kind,
-          button: event.button,
-          x: event.x,
-          y: event.y,
-          modifiers: event.modifiers
-        })
-      when RatatuiRuby::Event::Resize
-        RatatuiRuby.inject_test_event("resize", { width: event.width, height: event.height })
-      when RatatuiRuby::Event::Paste
-        RatatuiRuby.inject_test_event("paste", { content: event.content })
-      when RatatuiRuby::Event::FocusGained
-        RatatuiRuby.inject_test_event("focus_gained", {})
-      when RatatuiRuby::Event::FocusLost
-        RatatuiRuby.inject_test_event("focus_lost", {})
-      else
-        raise ArgumentError, "Unknown event type: #{event.class}"
-      end
-    end
-
-    ##
-    # Injects multiple Key events into the queue.
-    #
-    # Supports multiple formats for convenience:
-    #
-    # * String: Converted to a Key event with that code.
-    # * Symbol: Parsed as modifier_code (e.g., <tt>:ctrl_c</tt>, <tt>:enter</tt>).
-    # * Hash: Passed to Key.new constructor.
-    # * Key: Passed directly.
-    #
-    # == Examples
-    #
-    #   with_test_terminal do
-    #     inject_keys("a", "b", "c")
-    #     inject_keys(:enter, :esc)
-    #     inject_keys(:ctrl_c, :alt_shift_left)
-    #     inject_keys("j", { code: "k", modifiers: ["ctrl"] })
-    #   end
-    def inject_keys(*args)
-      args.each do |arg|
-        event = case arg
-                when String
-                  RatatuiRuby::Event::Key.new(code: arg)
-                when Symbol
-                  parts = arg.to_s.split("_")
-                  code = parts.pop
-                  modifiers = parts
-                  RatatuiRuby::Event::Key.new(code: code, modifiers: modifiers)
-                when Hash
-                  RatatuiRuby::Event::Key.new(**arg)
-                when RatatuiRuby::Event::Key
-                  arg
-                else
-                  raise ArgumentError, "Invalid key argument: #{arg.inspect}. Expected String, Symbol, Hash, or Key event."
-                end
-        inject_event(event)
-      end
-    end
-    alias inject_key inject_keys
-
-    ##
-    # Returns the cell attributes at the given coordinates.
-    #
-    #   get_cell(0, 0)
-    #   # => { "symbol" => "H", "fg" => :red, "bg" => nil }
-    def get_cell(x, y)
-      RatatuiRuby.get_cell_at(x, y)
-    end
-
-    ##
-    # Asserts that the cell at the given coordinates has the expected attributes.
-    #
-    #   assert_cell_style(0, 0, char: "H", fg: :red)
-    def assert_cell_style(x, y, **expected_attributes)
-      cell = get_cell(x, y)
-      expected_attributes.each do |key, value|
-        actual_value = cell.public_send(key)
-        if value.nil?
-          assert_nil actual_value, "Expected cell at (#{x}, #{y}) to have #{key}=nil, but got #{actual_value.inspect}"
-        else
-          assert_equal value, actual_value, "Expected cell at (#{x}, #{y}) to have #{key}=#{value.inspect}, but got #{actual_value.inspect}"
-        end
-      end
-    end
+    include Terminal
+    include Snapshot
+    include EventInjection
+    include StyleAssertions
+    include TestDoubles
   end
 end
-

data/lib/ratatui_ruby/version.rb

@@ -6,5 +6,5 @@
 module RatatuiRuby
   # The version of the ratatui_ruby gem.
   # See https://semver.org/spec/v2.0.0.html
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

data/lib/ratatui_ruby.rb

@@ -10,6 +10,7 @@ require_relative "ratatui_ruby/schema/layout"
 require_relative "ratatui_ruby/schema/block"
 require_relative "ratatui_ruby/schema/constraint"
 require_relative "ratatui_ruby/schema/list"
+require_relative "ratatui_ruby/schema/list_item"
 require_relative "ratatui_ruby/schema/style"
 require_relative "ratatui_ruby/schema/gauge"
 require_relative "ratatui_ruby/schema/line_gauge"
@@ -34,6 +35,10 @@ require_relative "ratatui_ruby/schema/text"
 require_relative "ratatui_ruby/schema/draw"
 require_relative "ratatui_ruby/event"
 require_relative "ratatui_ruby/cell"
+require_relative "ratatui_ruby/frame"
+require_relative "ratatui_ruby/list_state"
+require_relative "ratatui_ruby/table_state"
+require_relative "ratatui_ruby/scrollbar_state"
 
 begin
   require "ratatui_ruby/ratatui_ruby"
@@ -51,7 +56,13 @@ end
 # Use `RatatuiRuby.run` to start your application.
 module RatatuiRuby
   # Generic error class for RatatuiRuby.
-  class Error < StandardError; end
+  class Error < StandardError
+    # Raised when a terminal operation fails (e.g., I/O error, backend failure).
+    class Terminal < Error; end
+
+    # Raised when an API safety contract is violated (e.g., accessing a Frame outside its valid scope).
+    class Safety < Error; end
+  end
 
   ##
   # Initializes the terminal for TUI mode.
@@ -71,6 +82,23 @@ module RatatuiRuby
     attr_accessor :experimental_warnings
   end
 
+  ##
+  # :singleton-method: restore_terminal
+  # Restores the terminal to its original state.
+  # Leaves alternate screen and disables raw mode.
+  #
+  # (Native method implemented in Rust)
+
+  ##
+  # :singleton-method: inject_test_event
+  # Injects a mock event into the event queue for testing purposes.
+  # [event_type] "key" or "mouse"
+  # [data] a Hash containing event data
+  #
+  #   inject_test_event("key", { code: "a" })
+  #
+  # (Native method implemented in Rust)
+
   ##
   # Warns about usage of an experimental feature unless warnings are suppressed.
   #
@@ -91,60 +119,100 @@ module RatatuiRuby
   private_class_method :_init_terminal
 
   ##
-  # :method: restore_terminal
-  # :call-seq: restore_terminal() -> nil
+  # Draws the given UI node tree to the terminal.
   #
-  # Restores the terminal to its original state.
-  # Leaves alternate screen and disables raw mode.
+  # TUI applications need to render widgets to the screen. Rendering could
+  # happen all at once with a pre-built tree, or incrementally with direct
+  # frame access.
   #
-  # (Native method implemented in Rust)
-
-  ##
-  # :method: draw
-  # :call-seq: draw(node) -> nil
+  # This method handles both. Pass a tree for declarative rendering, or
+  # pass a block to manipulate the frame directly. The block receives a
+  # {Frame} object for imperative drawing.
   #
-  # Draws the given UI node tree to the terminal.
-  # [node] the root node of the UI tree (Paragraph, Layout).
+  # [tree] A widget tree (Paragraph, Layout, etc.) to render. Optional if
+  #        a block is given.
   #
-  # (Native method implemented in Rust)
+  # === Examples
+  #
+  # Legacy declarative style (tree-based):
+  #
+  #   RatatuiRuby.draw(Paragraph.new(text: "Hello"))
+  #
+  # New imperative style (block-based):
+  #
+  #   RatatuiRuby.draw do |frame|
+  #     frame.render_widget(Paragraph.new(text: "Hello"), frame.area)
+  #   end
+  #
+  def self.draw(tree = nil, &block)
+    if tree && block
+      raise ArgumentError, "Cannot provide both a tree and a block to draw"
+    end
+    unless tree || block
+      raise ArgumentError, "Must provide either a tree or a block to draw"
+    end
+
+    if tree
+      _draw(tree)
+    else
+      _draw(&block)
+    end
+  end
+
+  # (Native method _draw implemented in Rust)
+  private_class_method :_draw
 
   ##
-  # :method: poll_event
-  # :call-seq: poll_event() -> Event, nil
-  #
   # Checks for user input.
   #
-  # Returns a discrete event (Key, Mouse, Resize) if one is available in the queue.
-  # Returns nil immediately if the queue is empty (non-blocking).
+  # Interactive apps must respond to input. Loops need to poll without burning CPU.
   #
-  # === Example
+  # This method checks for an event. It returns the event if one is found. It returns {RatatuiRuby::Event::None} if the timeout expires.
+  #
+  # [timeout] Float seconds to wait (default: 0.016).
+  #           Pass <tt>nil</tt> to block indefinitely (wait forever).
+  #           Pass <tt>0.0</tt> for a non-blocking check.
   #
+  # === Examples
+  #
+  #   # Standard loop (approx 60 FPS)
   #   event = RatatuiRuby.poll_event
-  #   puts "Key pressed" if event.is_a?(RatatuiRuby::Event::Key)
   #
-  def self.poll_event
-    raw = _poll_event
-    return nil if raw.nil?
+  #   # Block until event (pauses execution)
+  #   event = RatatuiRuby.poll_event(timeout: nil)
+  #
+  #   # Non-blocking check (returns immediately)
+  #   event = RatatuiRuby.poll_event(timeout: 0.0)
+  #
+  def self.poll_event(timeout: 0.016)
+    raise ArgumentError, "timeout must be non-negative" if timeout && timeout < 0
+
+    raw = _poll_event(timeout)
+    return Event::None.new.freeze if raw.nil?
 
     case raw[:type]
     when :key
-      Event::Key.new(code: raw[:code], modifiers: raw[:modifiers] || [])
+      Event::Key.new(
+        code: raw[:code],
+        modifiers: (raw[:modifiers] || []).freeze,
+        kind: raw[:kind] || :standard
+      ).freeze
     when :mouse
       Event::Mouse.new(
         kind: raw[:kind].to_s,
         x: raw[:x],
         y: raw[:y],
         button: raw[:button].to_s,
-        modifiers: raw[:modifiers] || []
-      )
+        modifiers: (raw[:modifiers] || []).freeze
+      ).freeze
     when :resize
-      Event::Resize.new(width: raw[:width], height: raw[:height])
+      Event::Resize.new(width: raw[:width], height: raw[:height]).freeze
     when :paste
-      Event::Paste.new(content: raw[:content])
+      Event::Paste.new(content: raw[:content]).freeze
     when :focus_gained
-      Event::FocusGained.new
+      Event::FocusGained.new.freeze
     when :focus_lost
-      Event::FocusLost.new
+      Event::FocusLost.new.freeze
     else
       # Fallback for unknown events, though ideally we cover them all
       nil
@@ -155,21 +223,6 @@ module RatatuiRuby
   private_class_method :_poll_event
 
   ##
-  # :method: inject_test_event
-  # :call-seq: inject_test_event(event_type, data) -> nil
-  #
-  # Injects a mock event into the event queue for testing purposes.
-  # [event_type] "key" or "mouse"
-  # [data] a Hash containing event data
-  #
-  #   inject_test_event("key", { code: "a" })
-  #
-  # (Native method implemented in Rust)
-
-  ##
-  # :method: run
-  # :call-seq: run { |session| ... } -> Object
-  #
   # Starts the TUI application lifecycle.
   #
   # Managing generic setup/teardown (raw mode, alternate screen) manualy is error-prone. If your app crashes, the terminal might be left in a broken state.
@@ -184,16 +237,13 @@ module RatatuiRuby
   #   end
   def self.run(focus_events: true, bracketed_paste: true)
     require_relative "ratatui_ruby/session"
-    init_terminal(focus_events: focus_events, bracketed_paste: bracketed_paste)
+    init_terminal(focus_events:, bracketed_paste:)
     yield Session.new
   ensure
     restore_terminal
   end
 
   ##
-  # :method: get_cell_at
-  # :call-seq: get_cell_at(x, y) -> Cell
-  #
   # Inspects the terminal buffer at specific coordinates.
   #
   # When writing tests, you need to verify that your widget drew the correct characters and styles.
@@ -224,6 +274,5 @@ module RatatuiRuby
   private_class_method :_get_cell_at
 
   # Hide native Layout._split helper
-  Layout.singleton_class.send(:private, :_split)
-
+  Layout.singleton_class.__send__(:private, :_split)
 end

data/{examples/sparkline_demo → sig/examples/app_all_events}/app.rbs

@@ -1,9 +1,10 @@
 # SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+#
 # SPDX-License-Identifier: AGPL-3.0-or-later
 
-class SparklineDemoApp
+class AppAllEvents
   # @public
-  def self.new: () -> SparklineDemoApp
+  def self.new: () -> AppAllEvents
 
   # @public
   def run: () -> void

data/sig/examples/app_all_events/model/event_entry.rbs

@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+class EventEntry < Data
+  attr_reader type: Symbol
+  attr_reader sub_key: Symbol | String | nil
+  attr_reader color: Symbol
+  attr_reader timestamp: Timestamp
+  attr_reader data: Hash[Symbol, untyped]
+
+  def self.from_event(type: Symbol, sub_key: Symbol | String | nil, color: Symbol, timestamp: Timestamp, data: Hash[Symbol, untyped]) -> instance
+  def matches_type?: (Symbol check_type) -> bool
+  def matches_sub_type?: (Symbol check_type, Symbol | String check_sub_key) -> bool
+  def matches_kind?: (String kind) -> bool
+  def self.new: (?type: Symbol, ?sub_key: Symbol | String | nil, ?color: Symbol, ?timestamp: Timestamp, ?data: Hash[Symbol, untyped]) -> instance
+end

data/sig/examples/app_all_events/model/events.rbs

@@ -0,0 +1,15 @@
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+class Events
+  def initialize: () -> void
+  def record: (Symbol type, ?time: Time, ?description: String, ?sub_key: Symbol | String | nil, ?data: Hash[Symbol, untyped], ?live_type: Symbol) -> void
+  def live_event: (Symbol type) -> { time: Time, description: String } | nil
+  def live_events: () -> Hash[Symbol, { time: Time, description: String }]
+  def visible: (Integer max_entries) -> Array[EventEntry]
+  def empty?: () -> bool
+  def count: (Symbol type, ?Symbol | nil sub_type) -> Integer
+  def count_by_kind: (String kind) -> Integer
+  def lit?: (Symbol type, ?Symbol | String | nil sub_key) -> bool
+  def entries: () -> Array[EventEntry]
+end

data/sig/examples/app_all_events/model/timestamp.rbs

@@ -0,0 +1,11 @@
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+class Timestamp < Data
+  attr_reader milliseconds: Integer
+
+  def self.now: () -> instance
+  def self.current: () -> Integer
+  def elapsed?: (Integer duration_ms) -> bool
+  def self.new: (?milliseconds: Numeric) -> instance
+end

data/sig/examples/app_all_events/view/app_view.rbs

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+class View::App
+  include View::_View
+
+  def initialize: () -> void
+end

data/sig/examples/app_all_events/view/controls_view.rbs

@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+class View::Controls
+  include View::_View
+end

data/sig/examples/app_all_events/view/counts_view.rbs

@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+class View::Counts
+  include View::_View
+end

data/sig/examples/app_all_events/view/live_view.rbs

@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+class View::Live
+  include View::_View
+end

data/sig/examples/app_all_events/view/log_view.rbs

@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+class View::Log
+  include View::_View
+end

data/sig/examples/app_all_events/view.rbs

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module View
+  interface _View
+    def call(state: ViewState, tui: RatatuiRuby::Session, frame: RatatuiRuby::Frame, area: RatatuiRuby::Rect) -> void
+  end
+end

data/sig/examples/app_all_events/view_state.rbs

@@ -0,0 +1,15 @@
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+class ViewState < Data
+  attr_reader events: Events
+  attr_reader focused: bool
+  attr_reader hotkey_style: RatatuiRuby::Style
+  attr_reader dimmed_style: RatatuiRuby::Style
+  attr_reader lit_style: RatatuiRuby::Style
+  attr_reader border_color: Symbol
+  attr_reader area: RatatuiRuby::Rect?
+
+  def self.build(events: Events, focused: bool, tui: RatatuiRuby::Session, _resize_sub_counter: untyped) -> instance
+  def self.new: (?events: Events, ?focused: bool, ?hotkey_style: RatatuiRuby::Style, ?dimmed_style: RatatuiRuby::Style, ?lit_style: RatatuiRuby::Style, ?border_color: Symbol, ?area: RatatuiRuby::Rect | nil) -> instance
+end

data/{examples/list_demo → sig/examples/app_color_picker}/app.rbs

@@ -3,9 +3,9 @@
 # SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 # SPDX-License-Identifier: AGPL-3.0-or-later
 
-class ListDemoApp
+class AppColorPicker
   # @public
-  def self.new: () -> ListDemoApp
+  def self.new: () -> AppColorPicker
 
   # @public
   def run: () -> void

data/sig/examples/app_login_form/app.rbs

@@ -0,0 +1,11 @@
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+#
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+class AppLoginForm
+  # @public
+  def self.new: () -> AppLoginForm
+
+  # @public
+  def run: () -> void
+end