ratatat 1.0.0

data/lib/ratatat/message.rb

@@ -0,0 +1,147 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Ratatat
+  # Base class for all messages in the event system.
+  # Messages flow up the widget tree (bubbling) unless stopped.
+  class Message
+    extend T::Sig
+
+    sig { returns(T.untyped) }
+    attr_reader :sender
+
+    sig { returns(Time) }
+    attr_reader :time
+
+    sig { returns(T::Boolean) }
+    attr_accessor :bubble
+
+    sig { params(sender: T.untyped, bubble: T::Boolean).void }
+    def initialize(sender:, bubble: true)
+      @sender = sender
+      @time = T.let(Time.now, Time)
+      @bubble = bubble
+      @stopped = T.let(false, T::Boolean)
+      @prevented = T.let(false, T::Boolean)
+    end
+
+    sig { void }
+    def stop
+      @stopped = true
+    end
+
+    sig { returns(T::Boolean) }
+    def stopped?
+      @stopped
+    end
+
+    sig { void }
+    def prevent_default
+      @prevented = true
+    end
+
+    sig { returns(T::Boolean) }
+    def prevented?
+      @prevented
+    end
+  end
+
+  # Keyboard input message
+  class Key < Message
+    extend T::Sig
+
+    sig { returns(T.any(Symbol, String)) }
+    attr_reader :key
+
+    sig { returns(T::Set[Symbol]) }
+    attr_reader :modifiers
+
+    sig { params(sender: T.untyped, key: T.any(Symbol, String), modifiers: T::Set[Symbol], bubble: T::Boolean).void }
+    def initialize(sender:, key:, modifiers: Set.new, bubble: true)
+      super(sender: sender, bubble: bubble)
+      @key = key
+      @modifiers = modifiers
+    end
+
+    sig { returns(T::Boolean) }
+    def ctrl? = @modifiers.include?(:ctrl)
+
+    sig { returns(T::Boolean) }
+    def alt? = @modifiers.include?(:alt)
+
+    sig { returns(T::Boolean) }
+    def shift? = @modifiers.include?(:shift)
+  end
+
+  # Terminal resize message
+  class Resize < Message
+    extend T::Sig
+
+    sig { returns(Integer) }
+    attr_reader :width, :height
+
+    sig { params(sender: T.untyped, width: Integer, height: Integer, bubble: T::Boolean).void }
+    def initialize(sender:, width:, height:, bubble: true)
+      super(sender: sender, bubble: bubble)
+      @width = width
+      @height = height
+    end
+  end
+
+  # Application quit message
+  class Quit < Message
+    extend T::Sig
+
+    sig { params(sender: T.untyped).void }
+    def initialize(sender:)
+      super(sender: sender, bubble: false)
+    end
+  end
+
+  # Widget gained focus
+  class Focus < Message
+    extend T::Sig
+
+    sig { params(sender: T.untyped).void }
+    def initialize(sender:)
+      super(sender: sender, bubble: false)
+    end
+  end
+
+  # Widget lost focus
+  class Blur < Message
+    extend T::Sig
+
+    sig { params(sender: T.untyped).void }
+    def initialize(sender:)
+      super(sender: sender, bubble: false)
+    end
+  end
+
+  # Worker namespace for background task messages
+  module Worker
+    # Worker completed message
+    class Done < Message
+      extend T::Sig
+
+      sig { returns(Symbol) }
+      attr_reader :name
+
+      sig { returns(T.untyped) }
+      attr_reader :result
+
+      sig { returns(T.nilable(Exception)) }
+      attr_reader :error
+
+      sig { params(sender: T.untyped, name: Symbol, result: T.untyped, error: T.nilable(Exception)).void }
+      def initialize(sender:, name:, result: nil, error: nil)
+        super(sender: sender, bubble: true)
+        @name = name
+        @result = result
+        @error = error
+      end
+    end
+  end
+end

data/lib/ratatat/reactive.rb

@@ -0,0 +1,79 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Ratatat
+  # Provides the reactive property DSL for widgets
+  module Reactive
+    extend T::Sig
+
+    # Class methods added when Reactive is extended
+    module ClassMethods
+      extend T::Sig
+
+      # Define a reactive property
+      sig { params(name: Symbol, default: T.untyped, repaint: T::Boolean).void }
+      def reactive(name, default: nil, repaint: true)
+        # Store reactive metadata
+        @_reactives ||= {}
+        @_reactives[name] = { default: default, repaint: repaint }
+
+        # Define getter
+        define_method(name) do
+          ivar = :"@#{name}"
+          if instance_variable_defined?(ivar)
+            instance_variable_get(ivar)
+          else
+            self.class.reactive_default(name)
+          end
+        end
+
+        # Define setter
+        define_method(:"#{name}=") do |value|
+          ivar = :"@#{name}"
+          old_value = send(name)
+
+          # Run validator if defined
+          validator = :"validate_#{name}"
+          value = send(validator, value) if respond_to?(validator, true)
+
+          # Skip if unchanged
+          return if old_value == value
+
+          # Store new value
+          instance_variable_set(ivar, value)
+
+          # Call watcher if defined
+          watcher = :"watch_#{name}"
+          send(watcher, old_value, value) if respond_to?(watcher, true)
+
+          # Trigger repaint if configured
+          if self.class.reactive_repaint?(name) && respond_to?(:refresh, true)
+            send(:refresh)
+          end
+        end
+      end
+
+      sig { params(name: Symbol).returns(T.untyped) }
+      def reactive_default(name)
+        @_reactives&.dig(name, :default)
+      end
+
+      sig { params(name: Symbol).returns(T::Boolean) }
+      def reactive_repaint?(name)
+        @_reactives&.dig(name, :repaint) != false
+      end
+
+      sig { returns(T::Hash[Symbol, T::Hash[Symbol, T.untyped]]) }
+      def reactives
+        @_reactives || {}
+      end
+    end
+
+    sig { params(base: T::Class[T.anything]).void }
+    def self.extended(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/ratatat/styles.rb

@@ -0,0 +1,293 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Ratatat
+  # Style properties for widgets
+  class Styles
+    extend T::Sig
+
+    PROPERTIES = T.let(%i[
+      foreground background
+      width height min_width max_width min_height max_height
+      padding margin
+      bold italic underline
+      border border_title
+      text_align
+    ].freeze, T::Array[Symbol])
+
+    sig { returns(T.nilable(T.any(Symbol, Color::Rgb, Color::Indexed))) }
+    attr_accessor :foreground, :background
+
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :width, :height, :min_width, :max_width, :min_height, :max_height
+
+    sig { returns(T.nilable(T::Array[Integer])) }
+    attr_accessor :padding, :margin
+
+    sig { returns(T.nilable(T::Boolean)) }
+    attr_accessor :bold, :italic, :underline
+
+    sig { returns(T.nilable(Symbol)) }
+    attr_accessor :border, :text_align
+
+    sig { returns(T.nilable(String)) }
+    attr_accessor :border_title
+
+    sig { params(props: T.untyped).void }
+    def initialize(**props)
+      props.each do |key, value|
+        send(:"#{key}=", value) if respond_to?(:"#{key}=")
+      end
+    end
+
+    sig { params(other: Styles).returns(Styles) }
+    def merge(other)
+      result = Styles.new
+      PROPERTIES.each do |prop|
+        my_value = send(prop)
+        other_value = other.send(prop)
+        result.send(:"#{prop}=", other_value.nil? ? my_value : other_value)
+      end
+      result
+    end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def to_h
+      PROPERTIES.each_with_object({}) do |prop, hash|
+        value = send(prop)
+        hash[prop] = value unless value.nil?
+      end
+    end
+  end
+
+  # Manages style rules and computes styles for widgets
+  class StyleSheet
+    extend T::Sig
+
+    Rule = T.type_alias { { selector: String, styles: Styles, specificity: Integer } }
+
+    sig { void }
+    def initialize
+      @rules = T.let([], T::Array[Rule])
+    end
+
+    sig { params(selector: String, props: T.untyped).void }
+    def add_rule(selector, **props)
+      @rules << {
+        selector: selector,
+        styles: Styles.new(**props),
+        specificity: compute_specificity(selector)
+      }
+    end
+
+    sig { params(widget: Widget).returns(Styles) }
+    def compute(widget)
+      matching = @rules.select { |rule| matches?(widget, rule[:selector]) }
+      sorted = matching.sort_by { |rule| rule[:specificity] }
+
+      result = Styles.new
+      sorted.each do |rule|
+        result = result.merge(rule[:styles])
+      end
+      result
+    end
+
+    private
+
+    sig { params(selector: String).returns(Integer) }
+    def compute_specificity(selector)
+      # Handle combinator selectors
+      parts = parse_combinator_parts(selector)
+      return parts.sum { |part| compute_simple_specificity(part[:selector]) }
+    end
+
+    sig { params(selector: String).returns(Integer) }
+    def compute_simple_specificity(selector)
+      # Strip :not() for specificity calculation
+      selector = selector.gsub(/:not\([^)]+\)/, "")
+
+      # Parse compound selector parts
+      parts = parse_compound_selector(selector)
+      specificity = 0
+
+      parts.each do |part|
+        if part.start_with?("#")
+          specificity += 100
+        elsif part.start_with?(".")
+          specificity += 10
+        else
+          specificity += 1
+        end
+      end
+
+      # Add pseudo-class specificity
+      specificity += 10 if selector.include?(":")
+      specificity
+    end
+
+    sig { params(selector: String).returns(T::Array[{ selector: String, combinator: T.nilable(Symbol) }]) }
+    def parse_combinator_parts(selector)
+      parts = T.let([], T::Array[{ selector: String, combinator: T.nilable(Symbol) }])
+
+      # Split by child combinator first
+      if selector.include?(" > ")
+        segments = selector.split(" > ")
+        segments.each_with_index do |seg, i|
+          # Each segment might have descendant selectors
+          if seg.include?(" ")
+            sub_parts = seg.strip.split(/\s+/)
+            sub_parts.each_with_index do |sub, j|
+              combinator = j < sub_parts.length - 1 ? :descendant : (i < segments.length - 1 ? :child : nil)
+              parts << { selector: sub, combinator: combinator }
+            end
+          else
+            parts << { selector: seg.strip, combinator: i < segments.length - 1 ? :child : nil }
+          end
+        end
+      elsif selector.include?(" ")
+        # Only descendant combinators
+        segments = selector.split(/\s+/)
+        segments.each_with_index do |seg, i|
+          parts << { selector: seg, combinator: i < segments.length - 1 ? :descendant : nil }
+        end
+      else
+        parts << { selector: selector, combinator: nil }
+      end
+
+      parts
+    end
+
+    sig { params(selector: String).returns(T::Array[String]) }
+    def parse_compound_selector(selector)
+      # Remove pseudo-classes for parsing
+      selector = selector.gsub(/:[a-z-]+(\([^)]*\))?/, "")
+
+      parts = T.let([], T::Array[String])
+
+      # Extract ID
+      if selector.include?("#")
+        id_match = selector.match(/#([a-zA-Z0-9_-]+)/)
+        parts << "##{id_match[1]}" if id_match
+      end
+
+      # Extract classes
+      selector.scan(/\.([a-zA-Z0-9_-]+)/).each do |match|
+        parts << ".#{match[0]}"
+      end
+
+      # Extract type (must be at start, before # or .)
+      type_match = selector.match(/^([a-zA-Z][a-zA-Z0-9_]*)/)
+      if type_match && !type_match[1].nil?
+        type_name = T.must(type_match[1])
+        parts.unshift(type_name) unless type_name.empty?
+      end
+
+      parts
+    end
+
+    sig { params(widget: Widget, selector: String).returns(T::Boolean) }
+    def matches?(widget, selector)
+      parts = parse_combinator_parts(selector)
+
+      # Single selector (no combinators)
+      return matches_simple?(widget, parts[0][:selector]) if parts.length == 1
+
+      # Combinator selector - check from right to left
+      current = widget
+      (parts.length - 1).downto(0) do |i|
+        part = parts[i]
+        return false unless matches_simple?(current, part[:selector])
+
+        # Move up the tree based on combinator
+        if i > 0
+          prev_combinator = parts[i - 1][:combinator]
+          case prev_combinator
+          when :child
+            current = current.parent
+            return false if current.nil?
+          when :descendant
+            # Find any ancestor matching the next selector
+            found = false
+            ancestor = current.parent
+            while ancestor
+              if matches_simple?(ancestor, parts[i - 1][:selector])
+                current = ancestor
+                found = true
+                break
+              end
+              ancestor = ancestor.parent
+            end
+            return false unless found
+            next # Skip the normal iteration since we handled it
+          end
+        end
+      end
+
+      true
+    end
+
+    sig { params(widget: Widget, selector: String).returns(T::Boolean) }
+    def matches_simple?(widget, selector)
+      # Handle :not() pseudo-class
+      not_match = selector.match(/:not\(([^)]+)\)/)
+      if not_match
+        not_selector = not_match[1]
+        return false if matches_simple?(widget, not_selector)
+        selector = selector.gsub(/:not\([^)]+\)/, "")
+      end
+
+      # Parse base and pseudo-class
+      base, pseudo = parse_simple_selector(selector)
+
+      # Check compound selector
+      base_matches = matches_compound?(widget, base)
+      return false unless base_matches
+
+      # Check pseudo-class if present
+      return true unless pseudo
+
+      case pseudo
+      when "focus"
+        widget.has_focus?
+      when "disabled"
+        widget.disabled == true
+      when "hover"
+        widget.hover == true
+      else
+        false
+      end
+    end
+
+    sig { params(selector: String).returns([String, T.nilable(String)]) }
+    def parse_simple_selector(selector)
+      # Match pseudo-class but not :not()
+      if selector.match?(/:[a-z]+$/)
+        parts = selector.split(":")
+        [parts[0..-2].join(":"), parts.last]
+      else
+        [selector, nil]
+      end
+    end
+
+    sig { params(widget: Widget, selector: String).returns(T::Boolean) }
+    def matches_compound?(widget, selector)
+      return true if selector.empty?
+
+      parts = parse_compound_selector(selector)
+      return true if parts.empty?
+
+      parts.all? do |part|
+        if part.start_with?("#")
+          widget.id == part[1..]
+        elsif part.start_with?(".")
+          widget.classes.include?(part[1..])
+        else
+          # Type selector
+          widget.class.name&.split("::")&.last == part
+        end
+      end
+    end
+  end
+end

data/lib/ratatat/terminal.rb

@@ -0,0 +1,168 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "io/console"
+require "sorbet-runtime"
+
+module Ratatat
+  # Terminal abstraction with double buffering for flicker-free rendering.
+  # Manages two buffers (current and previous) and computes diffs.
+  class Terminal
+    extend T::Sig
+
+    sig { returns(AnsiBackend) }
+    attr_reader :backend
+
+    sig { returns(Integer) }
+    attr_reader :width, :height
+
+    sig { params(backend: T.nilable(AnsiBackend), io: IO).void }
+    def initialize(backend: nil, io: $stdout)
+      @backend = T.let(backend || AnsiBackend.new(io: io), AnsiBackend)
+      size = detect_size
+      @width = T.let(size[0], Integer)
+      @height = T.let(size[1], Integer)
+      @buffers = T.let([Buffer.new(@width, @height), Buffer.new(@width, @height)], [Buffer, Buffer])
+      @current = T.let(0, Integer)
+      @cursor_hidden = T.let(false, T::Boolean)
+    end
+
+    # Get current buffer (the one being drawn to)
+    sig { returns(Buffer) }
+    def current_buffer
+      @buffers[@current]
+    end
+
+    # Get previous buffer (last rendered frame)
+    sig { returns(Buffer) }
+    def previous_buffer
+      @buffers[1 - @current]
+    end
+
+    # Draw a frame. Yields the current buffer for drawing.
+    # After the block, computes diff and renders to terminal.
+    sig { params(blk: T.proc.params(buffer: Buffer).void).void }
+    def draw(&blk)
+      # Check for resize
+      check_resize
+
+      # Clear current buffer
+      current_buffer.clear
+
+      # Let caller draw to buffer
+      blk.call(current_buffer)
+
+      # Compute diff and render
+      flush
+    end
+
+    # Compute diff between buffers and render to terminal
+    sig { void }
+    def flush
+      updates = previous_buffer.diff(current_buffer)
+      @backend.draw(updates)
+      @backend.flush
+      swap_buffers
+    end
+
+    # Force a full redraw (no diffing)
+    sig { void }
+    def force_redraw
+      @backend.clear
+      previous_buffer.clear
+      flush
+    end
+
+    # Swap current and previous buffers
+    sig { void }
+    def swap_buffers
+      # Copy current to previous for next frame's diff
+      previous_buffer.cells.each_with_index do |_, i|
+        previous_buffer.cells[i] = T.must(current_buffer.cells[i])
+      end
+    end
+
+    # Get current terminal size
+    sig { returns([Integer, Integer]) }
+    def size
+      [@width, @height]
+    end
+
+    # Check if terminal was resized and update buffers
+    sig { void }
+    def check_resize
+      new_width, new_height = detect_size
+      return if new_width == @width && new_height == @height
+
+      @width = new_width
+      @height = new_height
+      @buffers.each { |buf| buf.resize(@width, @height) }
+    end
+
+    # Enter raw mode and alternate screen
+    sig { void }
+    def enter
+      @backend.enter_alternate_screen
+      @backend.hide_cursor
+      @backend.clear
+      @cursor_hidden = true
+      enable_raw_mode
+    end
+
+    # Exit raw mode and restore terminal
+    sig { void }
+    def exit
+      @backend.show_cursor if @cursor_hidden
+      @backend.reset_style
+      @backend.leave_alternate_screen
+      @backend.flush
+      disable_raw_mode
+      @cursor_hidden = false
+    end
+
+    # Show cursor at position
+    sig { params(x: T.nilable(Integer), y: T.nilable(Integer)).void }
+    def show_cursor(x = nil, y = nil)
+      if x && y
+        @backend.io.write(@backend.move_to(x, y))
+      end
+      @backend.show_cursor
+      @cursor_hidden = false
+    end
+
+    # Hide cursor
+    sig { void }
+    def hide_cursor
+      @backend.hide_cursor
+      @cursor_hidden = true
+    end
+
+    private
+
+    sig { returns([Integer, Integer]) }
+    def detect_size
+      if $stdout.respond_to?(:winsize)
+        rows, cols = $stdout.winsize
+        [cols || 80, rows || 24]
+      else
+        [80, 24]
+      end
+    rescue StandardError
+      [80, 24]
+    end
+
+    sig { void }
+    def enable_raw_mode
+      $stdin.raw! if $stdin.respond_to?(:raw!)
+    rescue StandardError
+      # Ignore if we can't enter raw mode
+    end
+
+    sig { void }
+    def disable_raw_mode
+      $stdin.cooked! if $stdin.respond_to?(:cooked!)
+    rescue StandardError
+      # Ignore if we can't restore mode
+    end
+  end
+end

data/lib/ratatat/version.rb

@@ -0,0 +1,3 @@
+module Ratatat
+  VERSION = "1.0.0"
+end