chamomile-petals 0.1.0

data/lib/petals/text_input.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+module Petals
+  # Single-line text input with cursor movement, editing, and echo modes.
+  class TextInput
+    ECHO_NORMAL   = :normal
+    ECHO_PASSWORD = :password
+    ECHO_NONE     = :none
+
+    attr_reader :value, :position, :err, :echo_char
+    attr_accessor :prompt, :placeholder, :char_limit, :width,
+                  :echo_mode, :key_map
+
+    def initialize(prompt: "", placeholder: "", char_limit: 0, width: 0,
+                   echo_mode: ECHO_NORMAL, echo_char: "*", key_map: DEFAULT_KEY_MAP,
+                   validate: nil)
+      @prompt = prompt
+      @placeholder = placeholder
+      @char_limit = char_limit
+      @width = width
+      @echo_mode = echo_mode
+      self.echo_char = echo_char
+      @key_map = key_map
+      @validate = validate
+      @value = ""
+      @position = 0
+      @focused = false
+      @offset = 0
+      @err = nil
+    end
+
+    # Focus management
+
+    def focus
+      @focused = true
+      self
+    end
+
+    def blur
+      @focused = false
+      self
+    end
+
+    def focused?
+      @focused
+    end
+
+    def echo_char=(c)
+      @echo_char = c.to_s[0] || "*"
+    end
+
+    # Value access
+
+    def value=(v)
+      v = v.to_s
+      v = v[0, @char_limit] if @char_limit.positive? && v.length > @char_limit
+      @value = v
+      @position = @position.clamp(0, @value.length)
+      run_validate
+      recalc_offset
+    end
+
+    def position=(p)
+      @position = p.clamp(0, @value.length)
+      recalc_offset
+    end
+
+    # Elm protocol
+
+    def update(msg)
+      return unless @focused
+
+      case msg
+      when Chamomile::KeyMsg
+        handle_key(msg)
+      when Chamomile::PasteMsg
+        handle_paste(msg)
+      end
+
+      nil
+    end
+
+    def view
+      return "#{@prompt}#{@placeholder}" if @value.empty? && !@placeholder.empty? && !@focused
+
+      display = build_display_value
+      visible = visible_portion(display)
+
+      if @focused
+        cursor_pos = @position - @offset
+        if cursor_pos >= 0 && cursor_pos < visible.length
+          before = visible[0, cursor_pos]
+          cursor_char = visible[cursor_pos]
+          after = visible[(cursor_pos + 1)..]
+          "#{@prompt}#{before}\e[7m#{cursor_char}\e[0m#{after}"
+        else
+          # Cursor at end
+          "#{@prompt}#{visible}\e[7m \e[0m"
+        end
+      else
+        "#{@prompt}#{visible}"
+      end
+    end
+
+    private
+
+    def handle_key(msg)
+      kb = KeyBinding
+
+      if kb.key_matches?(msg, @key_map, :line_start)
+        @position = 0
+      elsif kb.key_matches?(msg, @key_map, :line_end)
+        @position = @value.length
+      elsif kb.key_matches?(msg, @key_map, :character_forward)
+        @position += 1 if @position < @value.length
+      elsif kb.key_matches?(msg, @key_map, :character_backward)
+        @position -= 1 if @position.positive?
+      elsif kb.key_matches?(msg, @key_map, :word_forward)
+        @position = next_word_boundary
+      elsif kb.key_matches?(msg, @key_map, :word_backward)
+        @position = prev_word_boundary
+      elsif kb.key_matches?(msg, @key_map, :delete_char_backward)
+        delete_char_backward
+      elsif kb.key_matches?(msg, @key_map, :delete_char_forward)
+        delete_char_forward
+      elsif kb.key_matches?(msg, @key_map, :delete_word_backward)
+        delete_word_backward
+      elsif kb.key_matches?(msg, @key_map, :delete_word_forward)
+        delete_word_forward
+      elsif kb.key_matches?(msg, @key_map, :delete_before_cursor)
+        delete_before_cursor
+      elsif kb.key_matches?(msg, @key_map, :delete_after_cursor)
+        delete_after_cursor
+      elsif printable?(msg)
+        insert_char(msg.key)
+      end
+
+      recalc_offset
+    end
+
+    def handle_paste(msg)
+      text = msg.content.gsub(/[^[:print:]\t]/, "")
+      return if text.empty?
+
+      if @char_limit.positive?
+        available = @char_limit - @value.length
+        return if available <= 0
+
+        text = text[0, available] if text.length > available
+      end
+
+      @value = @value[0, @position].to_s + text + @value[@position..].to_s
+      @position += text.length
+      run_validate
+      recalc_offset
+    end
+
+    def printable?(msg)
+      return false unless msg.key.is_a?(String) && msg.key.length == 1
+      return false unless msg.mod.empty? || msg.mod == [:shift]
+
+      msg.key.match?(/[[:print:]]/)
+    end
+
+    def insert_char(char)
+      return if @char_limit.positive? && @value.length >= @char_limit
+
+      @value = @value[0, @position].to_s + char + @value[@position..].to_s
+      @position += 1
+      run_validate
+    end
+
+    # Deletion operations
+
+    def delete_char_backward
+      return if @position.zero?
+
+      @value = @value[0, @position - 1].to_s + @value[@position..].to_s
+      @position -= 1
+      run_validate
+    end
+
+    def delete_char_forward
+      return if @position >= @value.length
+
+      @value = @value[0, @position].to_s + @value[(@position + 1)..].to_s
+      run_validate
+    end
+
+    def delete_word_backward
+      return if @position.zero?
+
+      target = prev_word_boundary
+      @value = @value[0, target].to_s + @value[@position..].to_s
+      @position = target
+      run_validate
+    end
+
+    def delete_word_forward
+      return if @position >= @value.length
+
+      target = next_word_boundary
+      @value = @value[0, @position].to_s + @value[target..].to_s
+      run_validate
+    end
+
+    def delete_before_cursor
+      return if @position.zero?
+
+      @value = @value[@position..].to_s
+      @position = 0
+      run_validate
+    end
+
+    def delete_after_cursor
+      return if @position >= @value.length
+
+      @value = @value[0, @position].to_s
+      run_validate
+    end
+
+    # Word boundary helpers — whitespace-delimited.
+    # In password/none mode, word ops jump to start/end.
+
+    def next_word_boundary
+      return @value.length if @echo_mode != ECHO_NORMAL
+
+      pos = @position
+      # Skip current non-space chars
+      pos += 1 while pos < @value.length && @value[pos] != " "
+      # Skip spaces
+      pos += 1 while pos < @value.length && @value[pos] == " "
+      pos
+    end
+
+    def prev_word_boundary
+      return 0 if @echo_mode != ECHO_NORMAL
+
+      pos = @position
+      # Skip spaces behind cursor
+      pos -= 1 while pos.positive? && @value[pos - 1] == " "
+      # Skip non-space chars
+      pos -= 1 while pos.positive? && @value[pos - 1] != " "
+      pos
+    end
+
+    # Horizontal scrolling
+
+    def recalc_offset
+      if @width.positive?
+        content_width = @width - @prompt.length
+        content_width = 1 if content_width < 1
+
+        @offset = @position if @position < @offset
+        @offset = @position - content_width + 1 if @position >= @offset + content_width
+        @offset = 0 if @offset.negative?
+      else
+        @offset = 0
+      end
+    end
+
+    def visible_portion(display)
+      if @width.positive?
+        content_width = @width - @prompt.length
+        content_width = 1 if content_width < 1
+        display[@offset, content_width] || ""
+      else
+        display
+      end
+    end
+
+    # Display value based on echo mode
+
+    def build_display_value
+      case @echo_mode
+      when ECHO_PASSWORD
+        @echo_char * @value.length
+      when ECHO_NONE
+        ""
+      else
+        @value
+      end
+    end
+
+    # Validation
+
+    def run_validate
+      @err = @validate&.call(@value)
+    end
+  end
+end

data/lib/petals/timer.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Petals
+  TimerTickMsg = Data.define(:id, :tag, :time)
+  TimerTimeoutMsg = Data.define(:id, :time)
+
+  # Countdown timer with timeout notification and tick-based updates.
+  class Timer
+    @next_id = 0
+    @id_mutex = Mutex.new
+    @id_pid = Process.pid
+
+    def self.next_id
+      @id_mutex.synchronize do
+        if Process.pid != @id_pid
+          @id_pid = Process.pid
+          @next_id = 0
+          @id_mutex = Mutex.new
+        end
+        @next_id += 1
+        "#{@id_pid}-tm-#{@next_id}"
+      end
+    end
+
+    attr_reader :id, :timeout, :interval, :remaining
+
+    def initialize(timeout:, interval: 1.0)
+      @id = self.class.next_id
+      @timeout = timeout.to_f
+      @interval = interval
+      @remaining = @timeout
+      @tag = 0
+      @running = false
+    end
+
+    def start_cmd
+      return nil if @running || timed_out?
+
+      @running = true
+      tick_cmd
+    end
+
+    def stop
+      @running = false
+      @tag += 1
+      self
+    end
+
+    def toggle
+      if @running
+        stop
+        nil
+      else
+        start_cmd
+      end
+    end
+
+    def reset
+      @remaining = @timeout
+      @running = false
+      @tag += 1
+      self
+    end
+
+    def running?
+      @running
+    end
+
+    def timed_out?
+      @remaining <= 0
+    end
+
+    def update(msg)
+      case msg
+      when TimerTickMsg
+        return unless msg.id == @id && msg.tag == @tag
+
+        @remaining = [(@remaining - @interval), 0.0].max
+        @tag += 1
+
+        if @remaining <= 0
+          @running = false
+          timeout_cmd
+        else
+          tick_cmd
+        end
+      end
+    end
+
+    def view
+      total = @remaining.ceil.to_i
+      total = 0 if total.negative?
+      hours = total / 3600
+      minutes = (total % 3600) / 60
+      seconds = total % 60
+
+      if hours.positive?
+        format("%d:%02d:%02d", hours, minutes, seconds)
+      else
+        format("%02d:%02d", minutes, seconds)
+      end
+    end
+
+    private
+
+    def tick_cmd
+      captured_id = @id
+      captured_tag = @tag
+      interval = @interval
+      -> {
+        sleep(interval)
+        TimerTickMsg.new(id: captured_id, tag: captured_tag, time: Time.now)
+      }
+    end
+
+    # Returns a command that produces TimerTimeoutMsg (no sleep — immediate).
+    def timeout_cmd
+      captured_id = @id
+      -> { TimerTimeoutMsg.new(id: captured_id, time: Time.now) }
+    end
+  end
+end

data/lib/petals/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Petals
+  VERSION = "0.1.0"
+end

data/lib/petals/viewport/key_map.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Petals
+  class Viewport
+    DEFAULT_KEY_MAP = KeyBinding.normalize({
+                                             up: [[:up, []], ["k", []]],
+                                             down: [[:down, []], ["j", []]],
+                                             page_up: [[:page_up, []], ["b", []]],
+                                             page_down: [[:page_down, []], ["f", []], [" ", []]],
+                                             half_page_up: [["u", [:ctrl]]],
+                                             half_page_down: [["d", [:ctrl]]],
+                                             goto_top: [["g", []]],
+                                             goto_bottom: [["G", [:shift]]],
+                                             left: [[:left, []], ["h", [:alt]]],
+                                             right: [[:right, []], ["l", [:alt]]],
+                                           })
+  end
+end

data/lib/petals/viewport.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module Petals
+  # Scrollable content pane with key binding and mouse wheel support.
+  class Viewport
+    attr_reader :width, :height, :y_offset, :x_offset
+    attr_accessor :key_map, :mouse_wheel_enabled, :mouse_wheel_delta, :soft_wrap
+
+    def initialize(width: 80, height: 24, key_map: DEFAULT_KEY_MAP)
+      @width = width
+      @height = height
+      @key_map = key_map
+      @lines = []
+      @y_offset = 0
+      @x_offset = 0
+      @mouse_wheel_enabled = true
+      @mouse_wheel_delta = 3
+      @soft_wrap = false
+    end
+
+    def set_width(new_width)
+      @width = new_width
+      clamp_offset
+      @x_offset = @x_offset.clamp(0, [max_horizontal_scroll, 0].max) unless @soft_wrap
+    end
+
+    def set_height(new_height)
+      @height = new_height
+      clamp_offset
+    end
+
+    def set_content(s)
+      @lines = s.split("\n", -1)
+      clamp_offset
+      @x_offset = @x_offset.clamp(0, [max_horizontal_scroll, 0].max) unless @soft_wrap
+      self
+    end
+
+    def content
+      @lines.join("\n")
+    end
+
+    def total_line_count
+      @soft_wrap ? wrapped_lines.length : @lines.length
+    end
+
+    def visible_line_count
+      [total_line_count, @height].min
+    end
+
+    # Vertical scrolling
+
+    def scroll_up(n = 1)
+      self.y_offset = @y_offset - n
+    end
+
+    def scroll_down(n = 1)
+      self.y_offset = @y_offset + n
+    end
+
+    def page_up
+      scroll_up(@height)
+    end
+
+    def page_down
+      scroll_down(@height)
+    end
+
+    def half_page_up
+      scroll_up(@height / 2)
+    end
+
+    def half_page_down
+      scroll_down(@height / 2)
+    end
+
+    def goto_top
+      self.y_offset = 0
+    end
+
+    def goto_bottom
+      self.y_offset = max_scroll
+    end
+
+    def y_offset=(n)
+      @y_offset = n.clamp(0, max_scroll)
+    end
+
+    # Horizontal scrolling
+
+    def scroll_left(n = 1)
+      return if @soft_wrap
+
+      self.x_offset = @x_offset - n
+    end
+
+    def scroll_right(n = 1)
+      return if @soft_wrap
+
+      self.x_offset = @x_offset + n
+    end
+
+    def x_offset=(n)
+      return if @soft_wrap
+
+      @x_offset = n.clamp(0, [max_horizontal_scroll, 0].max)
+    end
+
+    def max_horizontal_scroll
+      return 0 if @lines.empty?
+
+      longest = @lines.map(&:length).max || 0
+      [longest - @width, 0].max
+    end
+
+    # Queries
+
+    def at_top?
+      @y_offset <= 0
+    end
+
+    def at_bottom?
+      @y_offset >= max_scroll
+    end
+
+    def scroll_percent
+      return 1.0 if max_scroll <= 0
+
+      @y_offset.to_f / max_scroll
+    end
+
+    def ensure_visible(line)
+      if line < @y_offset
+        self.y_offset = line
+      elsif line >= @y_offset + @height
+        self.y_offset = line - @height + 1
+      end
+      self
+    end
+
+    # Elm protocol
+
+    def update(msg)
+      case msg
+      when Chamomile::KeyMsg
+        handle_key(msg)
+      when Chamomile::MouseMsg
+        handle_mouse(msg)
+      end
+
+      nil
+    end
+
+    def view
+      if @soft_wrap
+        render_soft_wrap
+      else
+        render_normal
+      end
+    end
+
+    private
+
+    def max_scroll
+      total = @soft_wrap ? wrapped_lines.length : @lines.length
+      [total - @height, 0].max
+    end
+
+    def clamp_offset
+      @y_offset = @y_offset.clamp(0, max_scroll)
+    end
+
+    def render_normal
+      visible = @lines[@y_offset, @height] || []
+      rendered = visible.map { |line| truncate_line(line) }
+      padded = if rendered.length < @height
+                 rendered + Array.new(@height - rendered.length, "")
+               else
+                 rendered
+               end
+      padded.join("\n")
+    end
+
+    def render_soft_wrap
+      all = wrapped_lines
+      visible = all[@y_offset, @height] || []
+      padded = if visible.length < @height
+                 visible + Array.new(@height - visible.length, "")
+               else
+                 visible
+               end
+      padded.join("\n")
+    end
+
+    def truncate_line(line)
+      return "" if @width <= 0
+
+      if @x_offset >= line.length
+        ""
+      else
+        line[@x_offset, @width] || ""
+      end
+    end
+
+    def wrapped_lines
+      @lines.flat_map { |line| wrap_line(line) }
+    end
+
+    def wrap_line(line)
+      return [""] if line.empty? || @width <= 0
+
+      chunks = []
+      pos = 0
+      while pos < line.length
+        chunks << line[pos, @width]
+        pos += @width
+      end
+      chunks
+    end
+
+    def handle_key(msg)
+      kb = KeyBinding
+      if kb.key_matches?(msg, @key_map, :up)
+        scroll_up
+      elsif kb.key_matches?(msg, @key_map, :down)
+        scroll_down
+      elsif kb.key_matches?(msg, @key_map, :page_up)
+        page_up
+      elsif kb.key_matches?(msg, @key_map, :page_down)
+        page_down
+      elsif kb.key_matches?(msg, @key_map, :half_page_up)
+        half_page_up
+      elsif kb.key_matches?(msg, @key_map, :half_page_down)
+        half_page_down
+      elsif kb.key_matches?(msg, @key_map, :goto_top)
+        goto_top
+      elsif kb.key_matches?(msg, @key_map, :goto_bottom)
+        goto_bottom
+      elsif kb.key_matches?(msg, @key_map, :left)
+        scroll_left
+      elsif kb.key_matches?(msg, @key_map, :right)
+        scroll_right
+      end
+    end
+
+    def handle_mouse(msg)
+      return unless @mouse_wheel_enabled
+
+      case msg.button
+      when :wheel_up
+        scroll_up(@mouse_wheel_delta)
+      when :wheel_down
+        scroll_down(@mouse_wheel_delta)
+      end
+    end
+  end
+end

data/lib/petals.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "chamomile"
+require_relative "petals/version"
+require_relative "petals/key_binding"
+require_relative "petals/spinner/types"
+require_relative "petals/spinner"
+require_relative "petals/text_input/key_map"
+require_relative "petals/text_input"
+require_relative "petals/stopwatch"
+require_relative "petals/timer"
+require_relative "petals/paginator/key_map"
+require_relative "petals/paginator"
+require_relative "petals/cursor"
+require_relative "petals/help"
+require_relative "petals/progress"
+require_relative "petals/viewport/key_map"
+require_relative "petals/viewport"
+require_relative "petals/file_picker/key_map"
+require_relative "petals/file_picker"
+require_relative "petals/table/key_map"
+require_relative "petals/table"
+require_relative "petals/text_area/key_map"
+require_relative "petals/text_area"
+require_relative "petals/list/key_map"
+require_relative "petals/list"
+require_relative "petals/render_cache"
+require_relative "petals/log_view"
+require_relative "petals/command_palette"