ratatat 1.0.0

data/lib/ratatat/ansi_backend.rb

@@ -0,0 +1,175 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "stringio"
+require "sorbet-runtime"
+
+module Ratatat
+  # ANSI terminal backend for rendering buffer diffs.
+  # Optimizes output by batching cursor moves and style changes.
+  class AnsiBackend
+    extend T::Sig
+
+    # ANSI escape sequences
+    ESC = "\e["
+    RESET = "#{ESC}0m"
+    HIDE_CURSOR = "#{ESC}?25l"
+    SHOW_CURSOR = "#{ESC}?25h"
+    CLEAR_SCREEN = "#{ESC}2J"
+    MOVE_HOME = "#{ESC}H"
+    ALTERNATE_SCREEN = "#{ESC}?1049h"
+    MAIN_SCREEN = "#{ESC}?1049l"
+
+    sig { returns(IO) }
+    attr_reader :io
+
+    sig { params(io: IO).void }
+    def initialize(io: $stdout)
+      @io = io
+      @current_fg = T.let(nil, T.nilable(Color::AnyColor))
+      @current_bg = T.let(nil, T.nilable(Color::AnyColor))
+      @current_modifiers = T.let(Set.new, T::Set[Modifier])
+    end
+
+    # Draw a list of updates from Buffer#diff
+    # updates: Array of [x, y, Cell]
+    sig { params(updates: T::Array[[Integer, Integer, Cell]]).void }
+    def draw(updates)
+      return if updates.empty?
+
+      output = StringIO.new
+      last_x = T.let(nil, T.nilable(Integer))
+      last_y = T.let(nil, T.nilable(Integer))
+
+      updates.each do |x, y, cell|
+        # OPTIMIZATION 1: Skip cursor move if adjacent to previous position
+        unless last_x && last_y && y == last_y && x == last_x + 1
+          output << move_to(x, y)
+        end
+        last_x = x
+        last_y = y
+
+        # OPTIMIZATION 2: Only emit style changes when needed
+        output << style_codes(cell)
+
+        # Write the character
+        output << cell.normalized_symbol
+      end
+
+      # Reset styles at end
+      output << RESET
+      @current_fg = nil
+      @current_bg = nil
+      @current_modifiers = Set.new
+
+      # Single write to terminal
+      @io.write(output.string)
+    end
+
+    # Move cursor to position (ANSI is 1-indexed)
+    sig { params(x: Integer, y: Integer).returns(String) }
+    def move_to(x, y)
+      "#{ESC}#{y + 1};#{x + 1}H"
+    end
+
+    # Enter alternate screen buffer
+    sig { void }
+    def enter_alternate_screen
+      @io.write(ALTERNATE_SCREEN)
+    end
+
+    # Leave alternate screen buffer
+    sig { void }
+    def leave_alternate_screen
+      @io.write(MAIN_SCREEN)
+    end
+
+    # Hide cursor
+    sig { void }
+    def hide_cursor
+      @io.write(HIDE_CURSOR)
+    end
+
+    # Show cursor
+    sig { void }
+    def show_cursor
+      @io.write(SHOW_CURSOR)
+    end
+
+    # Clear entire screen
+    sig { void }
+    def clear
+      @io.write("#{CLEAR_SCREEN}#{MOVE_HOME}")
+    end
+
+    # Flush output buffer
+    sig { void }
+    def flush
+      @io.flush
+    end
+
+    # Reset all styles
+    sig { void }
+    def reset_style
+      @io.write(RESET)
+      @current_fg = nil
+      @current_bg = nil
+      @current_modifiers = Set.new
+    end
+
+    private
+
+    # Generate style escape codes for a cell, optimized to only emit changes
+    sig { params(cell: Cell).returns(String) }
+    def style_codes(cell)
+      codes = T.let([], T::Array[T.any(String, Integer)])
+
+      # Handle modifiers
+      modifier_codes = modifier_diff(cell.modifiers)
+      codes.concat(modifier_codes) unless modifier_codes.empty?
+
+      # Handle foreground color
+      if cell.fg != @current_fg
+        codes << Color.fg_ansi(cell.fg)
+        @current_fg = cell.fg
+      end
+
+      # Handle background color
+      if cell.bg != @current_bg
+        codes << Color.bg_ansi(cell.bg)
+        @current_bg = cell.bg
+      end
+
+      return "" if codes.empty?
+
+      "#{ESC}#{codes.join(";")}m"
+    end
+
+    # Calculate modifier changes and return ANSI codes
+    sig { params(new_modifiers: T::Set[Modifier]).returns(T::Array[Integer]) }
+    def modifier_diff(new_modifiers)
+      return [] if new_modifiers == @current_modifiers
+
+      codes = T.let([], T::Array[Integer])
+
+      # Find modifiers that were turned off
+      @current_modifiers.each do |mod|
+        unless new_modifiers.include?(mod)
+          code = mod.disable_code
+          codes << code if code
+        end
+      end
+
+      # Find modifiers that were turned on
+      new_modifiers.each do |mod|
+        unless @current_modifiers.include?(mod)
+          code = mod.enable_code
+          codes << code if code
+        end
+      end
+
+      @current_modifiers = new_modifiers
+      codes
+    end
+  end
+end

data/lib/ratatat/app.rb

@@ -0,0 +1,342 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Ratatat
+  # Application base class. Subclass and override compose/handlers.
+  class App < Widget
+    extend T::Sig
+
+    BINDINGS = T.let([
+      Binding.new("tab", "focus_next", "Focus next", show: false),
+      Binding.new("shift_tab", "focus_previous", "Focus previous", show: false),
+    ], T::Array[Binding])
+
+    sig { returns(T.nilable(Terminal)) }
+    attr_reader :terminal
+
+    sig { returns(T.nilable(Widget)) }
+    attr_reader :focused
+
+    sig { returns(StyleSheet) }
+    attr_reader :stylesheet
+
+    sig { params(id: T.nilable(String), classes: T::Array[String]).void }
+    def initialize(id: nil, classes: [])
+      super
+      @running = T.let(false, T::Boolean)
+      @message_queue = T.let([], T::Array[Message])
+      @terminal = T.let(nil, T.nilable(Terminal))
+      @input = T.let(nil, T.nilable(Input))
+      @focused = T.let(nil, T.nilable(Widget))
+      @timers = T.let({}, T::Hash[Integer, T::Hash[Symbol, T.untyped]])
+      @timer_id = T.let(0, Integer)
+      @deferred = T.let([], T::Array[T.proc.void])
+      @stylesheet = T.let(load_stylesheet, StyleSheet)
+      @workers = T.let({}, T::Hash[Symbol, Thread])
+      @worker_results = T.let([], T::Array[Worker::Done])
+      @worker_mutex = T.let(Mutex.new, Mutex)
+      @post_refresh_callbacks = T.let([], T::Array[T.proc.void])
+    end
+
+    private
+
+    sig { returns(StyleSheet) }
+    def load_stylesheet
+      if self.class.const_defined?(:CSS, false)
+        css = self.class.const_get(:CSS, false)
+        CSSParser.parse(css)
+      elsif self.class.const_defined?(:CSS_PATH, false)
+        path = self.class.const_get(:CSS_PATH, false)
+        CSSParser.parse_file(path)
+      else
+        StyleSheet.new
+      end
+    end
+
+    public
+
+    sig { returns(T::Boolean) }
+    def running?
+      @running
+    end
+
+    # Post a message to the queue for later processing
+    sig { params(message: Message).void }
+    def post(message)
+      @message_queue << message
+    end
+
+    # Process all pending messages
+    sig { void }
+    def process_messages
+      while (msg = @message_queue.shift)
+        handle_message(msg)
+      end
+    end
+
+    # Request application exit
+    sig { void }
+    def exit
+      post(Quit.new(sender: self))
+    end
+
+    # Set focus to a widget (or nil to clear)
+    sig { params(widget: T.nilable(Widget)).void }
+    def set_focus(widget)
+      return if @focused == widget
+
+      old_focused = @focused
+      old_focused&.instance_variable_set(:@has_focus, false)
+      old_focused&.dispatch(Blur.new(sender: self))
+
+      @focused = widget
+      @focused&.instance_variable_set(:@has_focus, true)
+      @focused&.dispatch(Focus.new(sender: self))
+    end
+
+    # Move focus to next focusable widget
+    sig { void }
+    def focus_next
+      widgets = focusable_widgets
+      return if widgets.empty?
+
+      if @focused.nil?
+        set_focus(widgets.first)
+      else
+        idx = widgets.index(@focused) || -1
+        next_idx = (idx + 1) % widgets.length
+        set_focus(widgets[next_idx])
+      end
+    end
+    alias action_focus_next focus_next
+
+    # Move focus to previous focusable widget
+    sig { void }
+    def focus_previous
+      widgets = focusable_widgets
+      return if widgets.empty?
+
+      if @focused.nil?
+        set_focus(widgets.last)
+      else
+        idx = widgets.index(@focused) || 0
+        prev_idx = (idx - 1) % widgets.length
+        set_focus(widgets[prev_idx])
+      end
+    end
+    alias action_focus_previous focus_previous
+
+    # Schedule a one-shot timer
+    sig { params(delay: Numeric, block: T.proc.void).returns(Integer) }
+    def set_timer(delay, &block)
+      id = next_timer_id
+      @timers[id] = { at: Time.now + delay, block: block, repeat: false }
+      id
+    end
+
+    # Schedule a repeating timer
+    sig { params(period: Numeric, block: T.proc.void).returns(Integer) }
+    def set_interval(period, &block)
+      id = next_timer_id
+      @timers[id] = { at: Time.now + period, block: block, repeat: true, period: period }
+      id
+    end
+
+    # Cancel a timer
+    sig { params(id: Integer).void }
+    def cancel_timer(id)
+      @timers.delete(id)
+    end
+
+    # Schedule callback for next tick
+    sig { params(block: T.proc.void).void }
+    def call_later(&block)
+      @deferred << block
+    end
+
+    # Schedule callback for after next render
+    sig { params(block: T.proc.void).void }
+    def call_after_refresh(&block)
+      @post_refresh_callbacks << block
+    end
+
+    # Process timers and deferred callbacks
+    sig { void }
+    def process_timers
+      now = Time.now
+
+      # Process deferred first
+      pending = @deferred.dup
+      @deferred.clear
+      pending.each(&:call)
+
+      # Process timers
+      @timers.each do |id, timer|
+        next if timer[:at] > now
+
+        timer[:block].call
+
+        if timer[:repeat]
+          timer[:at] = now + timer[:period]
+        else
+          @timers.delete(id)
+        end
+      end
+    end
+
+    # Run a block in a background thread
+    sig { params(name: Symbol, block: T.proc.returns(T.untyped)).void }
+    def run_worker(name, &block)
+      @workers[name] = Thread.new do
+        result = nil
+        error = nil
+        begin
+          result = block.call
+        rescue StandardError => e
+          error = e
+        end
+
+        # Only post result if not cancelled
+        @worker_mutex.synchronize do
+          if @workers.key?(name)
+            @worker_results << Worker::Done.new(sender: self, name: name, result: result, error: error)
+            @workers.delete(name)
+          end
+        end
+      end
+    end
+
+    # Cancel a running worker
+    sig { params(name: Symbol).void }
+    def cancel_worker(name)
+      @worker_mutex.synchronize do
+        thread = @workers.delete(name)
+        thread&.kill
+      end
+    end
+
+    # Process completed workers and post their messages
+    sig { void }
+    def process_workers
+      results = @worker_mutex.synchronize do
+        pending = @worker_results.dup
+        @worker_results.clear
+        pending
+      end
+
+      results.each { |msg| post(msg) }
+    end
+
+    # Main event loop
+    sig { params(poll_interval: Float).void }
+    def run(poll_interval: 0.05)
+      @terminal = Terminal.new
+      @input = Input.new
+      @running = true
+
+      # Handle Ctrl+C gracefully
+      old_sigint = trap("INT") { @running = false }
+
+      @terminal.enter
+      begin
+        # Initialize widget tree
+        send(:do_compose)
+        @children.each { |child| send(:trigger_mount, child) }
+
+        # Call on_mount for the app itself
+        on_mount if respond_to?(:on_mount)
+
+        while @running
+          poll_input
+          process_messages
+          process_timers
+          process_workers
+          render_frame
+          process_post_refresh
+          sleep(poll_interval)
+        end
+      ensure
+        @terminal.exit
+        trap("INT", old_sigint || "DEFAULT")
+      end
+    end
+
+    private
+
+    sig { returns(Integer) }
+    def next_timer_id
+      @timer_id += 1
+    end
+
+    sig { void }
+    def poll_input
+      return unless @input
+
+      event = @input.poll(0.01)
+      return unless event
+
+      post(Key.new(sender: self, key: event.key, modifiers: event.modifiers))
+    end
+
+    sig { void }
+    def render_frame
+      return unless @terminal
+
+      @terminal.draw do |buffer|
+        render(buffer)
+      end
+    end
+
+    sig { void }
+    def process_post_refresh
+      pending = @post_refresh_callbacks.dup
+      @post_refresh_callbacks.clear
+      pending.each(&:call)
+    end
+
+    # Override in subclass to render content
+    sig { params(buffer: Buffer).void }
+    def render(buffer)
+      width = @terminal&.width || 80
+      height = @terminal&.height || 24
+      @children.each do |child|
+        child.render(buffer, x: 0, y: 0, width: width, height: height) if child.respond_to?(:render)
+      end
+    end
+
+    sig { params(message: Message).void }
+    def handle_message(message)
+      case message
+      when Quit
+        @running = false
+      else
+        # Dispatch to children, then self
+        dispatch_to_focused(message)
+      end
+    end
+
+    sig { params(message: Message).void }
+    def dispatch_to_focused(message)
+      @focused&.dispatch(message)
+      dispatch(message) unless message.stopped?
+    end
+
+    # Get all focusable widgets in tree order
+    sig { returns(T::Array[Widget]) }
+    def focusable_widgets
+      result = T.let([], T::Array[Widget])
+      collect_focusable(@children, result)
+      result
+    end
+
+    sig { params(widgets: T::Array[Widget], result: T::Array[Widget]).void }
+    def collect_focusable(widgets, result)
+      widgets.each do |widget|
+        result << widget if widget.can_focus?
+        collect_focusable(widget.children, result)
+      end
+    end
+  end
+end

data/lib/ratatat/binding.rb

@@ -0,0 +1,74 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Ratatat
+  # Represents a key binding that maps keys to actions.
+  class Binding
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :key, :action, :description
+
+    sig { returns(T::Boolean) }
+    attr_reader :show, :priority
+
+    sig { params(key: String, action: String, description: String, show: T::Boolean, priority: T::Boolean).void }
+    def initialize(key, action, description, show: true, priority: false)
+      @key = key
+      @action = action
+      @description = description
+      @show = show
+      @priority = priority
+      @parsed_keys = T.let(parse_keys(key), T::Array[ParsedKey])
+    end
+
+    # Check if this binding matches the given key and modifiers
+    sig { params(key: T.any(Symbol, String), modifiers: T::Set[Symbol]).returns(T::Boolean) }
+    def matches?(key, modifiers)
+      key_str = key.to_s
+      @parsed_keys.any? { |pk| pk.matches?(key_str, modifiers) }
+    end
+
+    private
+
+    # A parsed key with optional modifiers
+    class ParsedKey
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :key
+
+      sig { returns(T::Set[Symbol]) }
+      attr_reader :modifiers
+
+      sig { params(key: String, modifiers: T::Set[Symbol]).void }
+      def initialize(key, modifiers)
+        @key = key
+        @modifiers = modifiers
+      end
+
+      sig { params(key: String, modifiers: T::Set[Symbol]).returns(T::Boolean) }
+      def matches?(key, modifiers)
+        @key == key && @modifiers == modifiers
+      end
+    end
+
+    sig { params(key_spec: String).returns(T::Array[ParsedKey]) }
+    def parse_keys(key_spec)
+      key_spec.split(",").map { |k| parse_single_key(k.strip) }
+    end
+
+    sig { params(key_str: String).returns(ParsedKey) }
+    def parse_single_key(key_str)
+      parts = key_str.split("+")
+      if parts.length == 1
+        ParsedKey.new(parts[0], Set.new)
+      else
+        modifiers = parts[0..-2].map(&:to_sym).to_set
+        ParsedKey.new(T.must(parts.last), modifiers)
+      end
+    end
+  end
+end