ratatat 1.0.0

data/lib/ratatat/widgets/log.rb

@@ -0,0 +1,97 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Ratatat
+  # Scrolling log viewer widget
+  class Log < Widget
+    extend T::Sig
+
+    CAN_FOCUS = true
+
+    sig { returns(T::Array[String]) }
+    attr_reader :lines
+
+    sig { returns(T::Boolean) }
+    attr_accessor :auto_scroll
+
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :max_lines
+
+    reactive :scroll_offset, default: 0, repaint: true
+
+    sig { params(max_lines: T.nilable(Integer), auto_scroll: T::Boolean, id: T.nilable(String), classes: T::Array[String]).void }
+    def initialize(max_lines: nil, auto_scroll: true, id: nil, classes: [])
+      super(id: id, classes: classes)
+      @lines = T.let([], T::Array[String])
+      @max_lines = max_lines
+      @auto_scroll = auto_scroll
+      @scroll_offset = 0
+      @view_height = T.let(5, Integer)
+    end
+
+    sig { params(text: String).void }
+    def write(text)
+      @lines << text
+      @lines.shift if @max_lines && @lines.length > @max_lines
+      @scroll_offset = [0, @lines.length - @view_height].max if @auto_scroll
+      refresh
+    end
+
+    alias write_line write
+
+    sig { void }
+    def clear
+      @lines.clear
+      @scroll_offset = 0
+      refresh
+    end
+
+    sig { params(message: Key).void }
+    def on_key(message)
+      case message.key
+      when "up", "k"
+        scroll(-1)
+        message.stop
+      when "down", "j"
+        scroll(1)
+        message.stop
+      when "page_up"
+        scroll(-@view_height)
+        message.stop
+      when "page_down"
+        scroll(@view_height)
+        message.stop
+      when "home"
+        @scroll_offset = 0
+        @auto_scroll = false
+        message.stop
+      when "end"
+        @scroll_offset = [0, @lines.length - @view_height].max
+        @auto_scroll = true
+        message.stop
+      end
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def render(buffer, x:, y:, width:, height:)
+      @view_height = height
+
+      # Recalculate scroll position for auto-scroll based on actual view height
+      @scroll_offset = [0, @lines.length - @view_height].max if @auto_scroll
+
+      visible_lines = @lines[@scroll_offset, height] || []
+      visible_lines.each_with_index do |line, i|
+        buffer.put_string(x, y + i, line[0, width] || "")
+      end
+    end
+
+    private
+
+    sig { params(delta: Integer).void }
+    def scroll(delta)
+      max_offset = [0, @lines.length - @view_height].max
+      @scroll_offset = (@scroll_offset + delta).clamp(0, max_offset)
+      @auto_scroll = false if delta < 0
+    end
+  end
+end

data/lib/ratatat/widgets/modal.rb

@@ -0,0 +1,161 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Ratatat
+  # Modal dialog widget
+  class Modal < Widget
+    extend T::Sig
+
+    CAN_FOCUS = true
+
+    # Emitted when modal is closed
+    class Closed < Message; end
+
+    # Emitted when a button is pressed
+    class ButtonPressed < Message
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :button
+
+      sig { returns(Integer) }
+      attr_reader :index
+
+      sig { params(sender: Widget, button: String, index: Integer).void }
+      def initialize(sender:, button:, index:)
+        super(sender: sender)
+        @button = button
+        @index = index
+      end
+    end
+
+    reactive :title, default: "", repaint: true
+    reactive :body, default: "", repaint: true
+    reactive :selected_button, default: 0, repaint: true
+
+    sig { returns(T::Array[String]) }
+    attr_reader :buttons
+
+    sig do
+      params(
+        title: String,
+        body: String,
+        buttons: T::Array[String],
+        id: T.nilable(String),
+        classes: T::Array[String]
+      ).void
+    end
+    def initialize(title: "", body: "", buttons: [], id: nil, classes: [])
+      super(id: id, classes: classes)
+      @title = title
+      @body = body
+      @buttons = buttons
+      @selected_button = 0
+    end
+
+    sig { params(message: Key).void }
+    def on_key(message)
+      case message.key
+      when "escape"
+        close
+        message.stop
+      when "enter"
+        press_button
+        message.stop
+      when "tab"
+        next_button
+        message.stop
+      when "shift_tab"
+        prev_button
+        message.stop
+      end
+    end
+
+    sig { void }
+    def close
+      parent&.dispatch(Closed.new(sender: self))
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def render(buffer, x:, y:, width:, height:)
+      # Draw border
+      draw_border(buffer, x, y, width, height)
+
+      # Draw title
+      title_x = x + (width - @title.length) / 2
+      buffer.put_string(title_x, y, @title) if title_x >= x
+
+      # Draw body
+      if height > 3
+        body_lines = @body.split("\n")
+        body_lines.each_with_index do |line, i|
+          break if i + 2 >= height - 1
+
+          buffer.put_string(x + 2, y + 2 + i, line[0, width - 4])
+        end
+      end
+
+      # Draw buttons at bottom
+      render_buttons(buffer, x, y + height - 2, width) if height > 2 && !@buttons.empty?
+    end
+
+    private
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def draw_border(buffer, x, y, width, height)
+      # Top
+      buffer.put_string(x, y, "┌" + "─" * (width - 2) + "┐")
+
+      # Sides
+      (1...height - 1).each do |i|
+        buffer.put_string(x, y + i, "│")
+        buffer.put_string(x + width - 1, y + i, "│")
+      end
+
+      # Bottom
+      buffer.put_string(x, y + height - 1, "└" + "─" * (width - 2) + "┘")
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer).void }
+    def render_buttons(buffer, x, y, width)
+      btn_strs = @buttons.each_with_index.map do |btn, i|
+        if i == @selected_button
+          "[ #{btn} ]"
+        else
+          "  #{btn}  "
+        end
+      end
+
+      total = btn_strs.join(" ").length
+      start_x = x + (width - total) / 2
+
+      current_x = start_x
+      btn_strs.each do |btn_str|
+        buffer.put_string(current_x, y, btn_str) if current_x >= x
+        current_x += btn_str.length + 1
+      end
+    end
+
+    sig { void }
+    def next_button
+      return if @buttons.empty?
+
+      @selected_button = (@selected_button + 1) % @buttons.length
+    end
+
+    sig { void }
+    def prev_button
+      return if @buttons.empty?
+
+      @selected_button = (@selected_button - 1) % @buttons.length
+    end
+
+    sig { void }
+    def press_button
+      return if @buttons.empty?
+
+      button = @buttons[@selected_button]
+      parent&.dispatch(ButtonPressed.new(sender: self, button: button || "", index: @selected_button)) if button
+    end
+  end
+end

data/lib/ratatat/widgets/progress_bar.rb

@@ -0,0 +1,80 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Ratatat
+  # Progress bar widget
+  class ProgressBar < Widget
+    extend T::Sig
+
+    reactive :total, default: 100.0, repaint: true
+    reactive :completed, default: 0.0, repaint: true
+
+    sig { params(progress: T.nilable(Float), total: Float, completed: Float, id: T.nilable(String), classes: T::Array[String]).void }
+    def initialize(progress: nil, total: 100.0, completed: 0.0, id: nil, classes: [])
+      super(id: id, classes: classes)
+      @total = total
+      @completed = completed
+      self.progress = progress if progress
+    end
+
+    sig { returns(Float) }
+    def progress
+      return 0.0 if total <= 0
+
+      (completed / total).clamp(0.0, 1.0)
+    end
+
+    sig { params(value: Float).void }
+    def progress=(value)
+      self.completed = (value.clamp(0.0, 1.0) * total)
+    end
+
+    sig { params(amount: Float).void }
+    def advance(amount = 1.0)
+      self.completed = completed + amount
+    end
+
+    def validate_completed(value)
+      value.clamp(0.0, total)
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def render(buffer, x:, y:, width:, height:)
+      filled = (progress * width).round
+      empty = width - filled
+
+      bar = "█" * filled + "░" * empty
+      buffer.put_string(x, y, bar)
+    end
+  end
+
+  # Spinning indicator widget
+  class Spinner < Widget
+    extend T::Sig
+
+    FRAMES = T.let(["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"].freeze, T::Array[String])
+
+    reactive :frame, default: 0, repaint: true
+
+    sig { params(id: T.nilable(String), classes: T::Array[String]).void }
+    def initialize(id: nil, classes: [])
+      super(id: id, classes: classes)
+      @frame = 0
+    end
+
+    sig { returns(String) }
+    def current_frame
+      FRAMES[@frame % FRAMES.length] || FRAMES.first || ""
+    end
+
+    sig { void }
+    def advance
+      self.frame = (@frame + 1) % FRAMES.length
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def render(buffer, x:, y:, width:, height:)
+      buffer.put_string(x, y, current_frame)
+    end
+  end
+end

data/lib/ratatat/widgets/radio_set.rb

@@ -0,0 +1,91 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Ratatat
+  # Exclusive selection radio button group
+  class RadioSet < Widget
+    extend T::Sig
+
+    CAN_FOCUS = true
+
+    class Changed < Message
+      extend T::Sig
+
+      sig { returns(Integer) }
+      attr_reader :selected
+
+      sig { returns(String) }
+      attr_reader :value
+
+      sig { params(sender: Widget, selected: Integer, value: String).void }
+      def initialize(sender:, selected:, value:)
+        super(sender: sender)
+        @selected = selected
+        @value = value
+      end
+    end
+
+    sig { returns(T::Array[String]) }
+    attr_reader :options
+
+    reactive :selected, default: 0, repaint: true
+    reactive :highlight, default: 0, repaint: true
+
+    sig { params(options: T::Array[String], selected: Integer, id: T.nilable(String), classes: T::Array[String]).void }
+    def initialize(options: [], selected: 0, id: nil, classes: [])
+      super(id: id, classes: classes)
+      @options = options
+      @selected = selected
+      @highlight = selected
+    end
+
+    sig { returns(T.nilable(String)) }
+    def selected_option
+      @options[@selected]
+    end
+
+    sig { params(message: Key).void }
+    def on_key(message)
+      case message.key
+      when "up", "k"
+        move_selection(-1)
+        message.stop
+      when "down", "j"
+        move_selection(1)
+        message.stop
+      when " ", "enter"
+        emit_changed
+        message.stop
+      end
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def render(buffer, x:, y:, width:, height:)
+      @options.each_with_index do |option, i|
+        break if i >= height
+
+        indicator = i == @selected ? "(*)" : "( )"
+        prefix = i == @highlight ? "> " : "  "
+        text = "#{prefix}#{indicator} #{option}"
+        buffer.put_string(x, y + i, text[0, width])
+      end
+    end
+
+    private
+
+    sig { params(delta: Integer).void }
+    def move_selection(delta)
+      return if @options.empty?
+
+      @selected = (@selected + delta) % @options.length
+      @highlight = @selected
+    end
+
+    sig { void }
+    def emit_changed
+      return if @options.empty?
+
+      parent&.dispatch(Changed.new(sender: self, selected: @selected, value: selected_option || ""))
+    end
+  end
+end

data/lib/ratatat/widgets/scrollable_container.rb

@@ -0,0 +1,88 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Ratatat
+  # Scrollable viewport widget
+  class ScrollableContainer < Widget
+    extend T::Sig
+
+    CAN_FOCUS = true
+
+    sig { returns(Integer) }
+    attr_reader :virtual_width, :virtual_height
+
+    reactive :scroll_x, default: 0, repaint: true
+    reactive :scroll_y, default: 0, repaint: true
+
+    sig { params(virtual_width: Integer, virtual_height: Integer, id: T.nilable(String), classes: T::Array[String]).void }
+    def initialize(virtual_width: 80, virtual_height: 24, id: nil, classes: [])
+      super(id: id, classes: classes)
+      @virtual_width = virtual_width
+      @virtual_height = virtual_height
+      @scroll_x = 0
+      @scroll_y = 0
+      @viewport_width = T.let(80, Integer)
+      @viewport_height = T.let(24, Integer)
+    end
+
+    sig { params(message: Key).void }
+    def on_key(message)
+      case message.key
+      when "up", "k"
+        scroll_vertical(-1)
+        message.stop
+      when "down", "j"
+        scroll_vertical(1)
+        message.stop
+      when "left", "h"
+        scroll_horizontal(-1)
+        message.stop
+      when "right", "l"
+        scroll_horizontal(1)
+        message.stop
+      when "page_up"
+        scroll_vertical(-@viewport_height)
+        message.stop
+      when "page_down"
+        scroll_vertical(@viewport_height)
+        message.stop
+      when "home"
+        @scroll_y = 0
+        message.stop
+      when "end"
+        @scroll_y = [@virtual_height - @viewport_height, 0].max
+        message.stop
+      end
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def render(buffer, x:, y:, width:, height:)
+      @viewport_width = width
+      @viewport_height = height
+
+      # Render children with scroll offset
+      # Children should render to positions that account for scroll
+      children.each do |child|
+        next unless child.respond_to?(:render)
+
+        # For now, simple implementation: child renders at (x - scroll_x, y - scroll_y)
+        # A more sophisticated implementation would use a virtual buffer
+        child.render(buffer, x: x, y: y, width: width, height: height)
+      end
+    end
+
+    private
+
+    sig { params(delta: Integer).void }
+    def scroll_vertical(delta)
+      max_scroll = [@virtual_height - @viewport_height, 0].max
+      @scroll_y = (@scroll_y + delta).clamp(0, max_scroll)
+    end
+
+    sig { params(delta: Integer).void }
+    def scroll_horizontal(delta)
+      max_scroll = [@virtual_width - @viewport_width, 0].max
+      @scroll_x = (@scroll_x + delta).clamp(0, max_scroll)
+    end
+  end
+end

data/lib/ratatat/widgets/select.rb

@@ -0,0 +1,100 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Ratatat
+  # Dropdown-style select widget
+  class Select < Widget
+    extend T::Sig
+
+    CAN_FOCUS = true
+
+    # Emitted when selection changes
+    class Changed < Message
+      extend T::Sig
+
+      sig { returns(Integer) }
+      attr_reader :selected
+
+      sig { returns(String) }
+      attr_reader :value
+
+      sig { params(sender: Widget, selected: Integer, value: String).void }
+      def initialize(sender:, selected:, value:)
+        super(sender: sender)
+        @selected = selected
+        @value = value
+      end
+    end
+
+    reactive :selected, default: 0, repaint: true
+
+    sig { returns(T::Array[String]) }
+    attr_reader :options
+
+    sig do
+      params(
+        options: T::Array[String],
+        selected: Integer,
+        id: T.nilable(String),
+        classes: T::Array[String]
+      ).void
+    end
+    def initialize(options: [], selected: 0, id: nil, classes: [])
+      super(id: id, classes: classes)
+      @options = options
+      @selected = selected
+    end
+
+    sig { returns(T.nilable(String)) }
+    def selected_option
+      @options[@selected]
+    end
+
+    sig { params(message: Key).void }
+    def on_key(message)
+      case message.key
+      when "down", "j"
+        move_selection(1)
+        message.stop
+      when "up", "k"
+        move_selection(-1)
+        message.stop
+      end
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def render(buffer, x:, y:, width:, height:)
+      text = "[#{selected_option || ""}]"
+      buffer.put_string(x, y, text[0, width])
+    end
+
+    private
+
+    sig { params(delta: Integer).void }
+    def move_selection(delta)
+      return if @options.empty?
+
+      old = @selected
+      @selected = (@selected + delta) % @options.length
+      return if old == @selected
+
+      parent&.dispatch(Changed.new(sender: self, selected: @selected, value: selected_option || ""))
+    end
+  end
+
+  # List showing all options with selection marker
+  class SelectionList < Select
+    extend T::Sig
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def render(buffer, x:, y:, width:, height:)
+      @options.each_with_index do |option, i|
+        break if i >= height
+
+        marker = i == @selected ? "> " : "  "
+        text = "#{marker}#{option}"
+        buffer.put_string(x, y + i, text[0, width])
+      end
+    end
+  end
+end

data/lib/ratatat/widgets/sparkline.rb

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Ratatat
+  # Inline sparkline chart widget
+  class Sparkline < Widget
+    extend T::Sig
+
+    # Block characters for different heights (8 levels)
+    BLOCKS = T.let([" ", "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"].freeze, T::Array[String])
+
+    sig { returns(T::Array[Numeric]) }
+    attr_reader :data
+
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :max_data_points
+
+    sig { params(data: T::Array[Numeric], max_data_points: T.nilable(Integer), id: T.nilable(String), classes: T::Array[String]).void }
+    def initialize(data: [], max_data_points: nil, id: nil, classes: [])
+      super(id: id, classes: classes)
+      @data = T.let(data.dup, T::Array[Numeric])
+      @max_data_points = max_data_points
+    end
+
+    sig { params(value: Numeric).void }
+    def push(value)
+      @data << value
+      @data.shift if @max_data_points && @data.length > @max_data_points
+      refresh
+    end
+
+    sig { void }
+    def clear
+      @data.clear
+      refresh
+    end
+
+    sig { params(buffer: Buffer, x: Integer, y: Integer, width: Integer, height: Integer).void }
+    def render(buffer, x:, y:, width:, height:)
+      return if @data.empty?
+
+      min_val = @data.min || 0
+      max_val = @data.max || 0
+      range = max_val - min_val
+
+      @data.each_with_index do |value, i|
+        break if i >= width
+
+        # Normalize to 0-8 range
+        normalized = if range == 0
+                       4 # Middle if all values same
+                     else
+                       ((value - min_val) / range.to_f * 8).round
+                     end
+
+        block = BLOCKS[normalized.clamp(0, 8)] || BLOCKS[0]
+        buffer.put_string(x + i, y, block || " ")
+      end
+    end
+  end
+end