bubbles 0.0.5 → 0.1.0

data/lib/bubbles/timer.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Bubbles
+  # Timer is a countdown timer component.
+  #
+  # Example:
+  #   timer = Bubbles::Timer.new(60.0)  # 60 second countdown
+  #
+  #   # In your model's init:
+  #   def init
+  #     [self, @timer.init]
+  #   end
+  #
+  #   # In your model's update:
+  #   def update(message)
+  #     case message
+  #     when Bubbles::Timer::TickMessage, Bubbles::Timer::StartStopMessage
+  #       @timer, command = @timer.update(message)
+  #       [self, command]
+  #     when Bubbles::Timer::TimeoutMessage
+  #       # Timer finished!
+  #       [self, nil]
+  #     end
+  #   end
+  #
+  class Timer
+    class TickMessage < Bubbletea::Message
+      attr_reader :id #: Integer
+      attr_reader :tag #: Integer
+      attr_reader :timeout #: bool
+
+      #: (id: Integer, tag: Integer, ?timeout: bool) -> void
+      def initialize(id:, tag:, timeout: false)
+        super()
+
+        @id = id
+        @tag = tag
+        @timeout = timeout
+      end
+    end
+
+    class TimeoutMessage < Bubbletea::Message
+      attr_reader :id #: Integer
+
+      #: (id: Integer) -> void
+      def initialize(id:)
+        super()
+
+        @id = id
+      end
+    end
+
+    class StartStopMessage < Bubbletea::Message
+      attr_reader :id #: Integer
+      attr_reader :running #: bool
+
+      #: (id: Integer, running: bool) -> void
+      def initialize(id:, running:)
+        super()
+
+        @id = id
+        @running = running
+      end
+    end
+
+    # @rbs self.@next_id: Integer
+    # @rbs self.@id_mutex: Mutex
+    @next_id = 0
+    @id_mutex = Mutex.new
+
+    class << self
+      #: () -> Integer
+      def next_id
+        @id_mutex.synchronize do
+          @next_id += 1
+        end
+      end
+    end
+
+    attr_reader :timeout #: Float
+    attr_reader :interval #: Float
+    attr_reader :id #: Integer
+
+    #: (Float, ?interval: Float) -> void
+    def initialize(timeout, interval: 1.0)
+      @timeout = timeout.to_f
+      @interval = interval.to_f
+      @id = self.class.next_id
+      @tag = 0
+      @running = false
+    end
+
+    #: () -> Bubbletea::Command?
+    def init
+      @running = true
+      tick
+    end
+
+    #: () -> bool
+    def running?
+      @running && @timeout.positive?
+    end
+
+    #: () -> bool
+    def timed_out?
+      @timeout <= 0
+    end
+
+    #: (Bubbletea::Message) -> [Timer, Bubbletea::Command?]
+    def update(message)
+      case message
+      when StartStopMessage
+        return [self, nil] if message.id.positive? && message.id != @id
+
+        @running = message.running
+        [self, @running ? tick : nil]
+
+      when TickMessage
+        return [self, nil] unless @running
+        return [self, nil] if message.id.positive? && message.id != @id
+        return [self, nil] if message.tag.positive? && message.tag != @tag
+
+        @timeout -= @interval
+        @tag += 1
+
+        [self, Bubbletea.batch(tick, timeout_command)]
+      else
+        [self, nil]
+      end
+    end
+
+    #: () -> String
+    def view
+      format_duration(@timeout)
+    end
+
+    #: () -> Bubbletea::Command
+    def start
+      start_stop(true)
+    end
+
+    #: () -> Bubbletea::Command
+    def stop
+      start_stop(false)
+    end
+
+    #: () -> Bubbletea::Command
+    def toggle
+      start_stop(!@running)
+    end
+
+    private
+
+    #: (bool) -> Bubbletea::Command
+    def start_stop(running)
+      current_id = @id
+      Bubbletea.send_message(StartStopMessage.new(id: current_id, running: running))
+    end
+
+    #: () -> Bubbletea::Command?
+    def tick
+      return nil unless running?
+
+      current_id = @id
+      current_tag = @tag
+
+      Bubbletea.tick(@interval) { TickMessage.new(id: current_id, tag: current_tag) }
+    end
+
+    #: () -> Bubbletea::Command?
+    def timeout_command
+      return nil unless timed_out?
+
+      current_id = @id
+      Bubbletea.send_message(TimeoutMessage.new(id: current_id))
+    end
+
+    #: (Float) -> String
+    def format_duration(seconds)
+      return "0s" if seconds <= 0
+
+      total_seconds = seconds.to_i
+      hours = total_seconds / 3600
+      minutes = (total_seconds % 3600) / 60
+      secs = total_seconds % 60
+
+      parts = [] #: Array[String]
+      parts << "#{hours}h" if hours.positive?
+      parts << "#{minutes}m" if minutes.positive? || hours.positive?
+      parts << "#{secs}s"
+
+      parts.join
+    end
+  end
+end

data/lib/bubbles/version.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
 module Bubbles
-  VERSION = "0.0.5"
+  VERSION = "0.1.0" #: String
 end

data/lib/bubbles/viewport.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Bubbles
+  # Viewport is a scrollable content pane.
+  #
+  # Example:
+  #   viewport = Bubbles::Viewport.new(width: 80, height: 24)
+  #   viewport.content = "Long text content..."
+  #
+  #   # In update:
+  #   viewport, command = viewport.update(message)
+  #
+  #   # In view:
+  #   viewport.view
+  #
+  class Viewport
+    attr_accessor :width #: Integer
+    attr_accessor :height #: Integer
+    attr_accessor :style #: Lipgloss::Style?
+    attr_accessor :mouse_wheel_enabled #: bool
+    attr_accessor :mouse_wheel_delta #: Integer
+
+    attr_reader :y_offset #: Integer
+    attr_reader :x_offset #: Integer
+
+    #: (?width: Integer, ?height: Integer) -> void
+    def initialize(width: 80, height: 24)
+      @width = width
+      @height = height
+      @style = nil
+
+      @mouse_wheel_enabled = true
+      @mouse_wheel_delta = 3
+      @horizontal_step = 0
+
+      @y_offset = 0
+      @x_offset = 0
+
+      @lines = [] #: Array[String]
+      @longest_line_width = 0
+    end
+
+    #: () -> nil
+    def init
+      nil
+    end
+
+    #: () -> bool
+    def at_top?
+      @y_offset <= 0
+    end
+
+    #: () -> bool
+    def at_bottom?
+      @y_offset >= max_y_offset
+    end
+
+    #: () -> bool
+    def past_bottom?
+      @y_offset > max_y_offset
+    end
+
+    #: () -> Float -- scroll percentage (0.0 to 1.0)
+    def scroll_percent
+      return 1.0 if @height >= @lines.length
+
+      y = @y_offset.to_f
+      h = @height.to_f
+      t = @lines.length.to_f
+
+      v = y / (t - h)
+
+      v.clamp(0.0, 1.0).to_f
+    end
+
+    #: (String) -> void
+    def content=(content)
+      content = content.gsub("\r\n", "\n")
+      @lines = content.split("\n", -1)
+      @longest_line_width = @lines.map { |l| strip_ansi(l).length }.max || 0
+
+      goto_bottom if @y_offset > @lines.length - 1
+    end
+
+    #: () -> String
+    def content
+      @lines.join("\n")
+    end
+
+    #: (Integer) -> Integer
+    def y_offset=(offset)
+      @y_offset = offset.clamp(0, max_y_offset)
+    end
+
+    #: (Integer) -> Integer
+    def x_offset=(offset)
+      max_x = [@longest_line_width - @width, 0].max
+      @x_offset = offset.clamp(0, max_x)
+    end
+
+    #: (Integer) -> Integer
+    def horizontal_step=(step)
+      @horizontal_step = [step, 0].max
+    end
+
+    #: (Integer) -> Array[String]
+    def scroll_down(line_count)
+      return [] if at_bottom? || line_count.zero? || @lines.empty?
+
+      self.y_offset = @y_offset + line_count
+      visible_lines
+    end
+
+    #: (Integer) -> Array[String]
+    def scroll_up(line_count)
+      return [] if at_top? || line_count.zero? || @lines.empty?
+
+      self.y_offset = @y_offset - line_count
+      visible_lines
+    end
+
+    #: (Integer) -> void
+    def scroll_left(column_count)
+      self.x_offset = @x_offset - column_count
+    end
+
+    #: (Integer) -> void
+    def scroll_right(column_count)
+      self.x_offset = @x_offset + column_count
+    end
+
+    #: () -> Array[String]
+    def page_down
+      return [] if at_bottom?
+
+      scroll_down(@height)
+    end
+
+    #: () -> Array[String]
+    def page_up
+      return [] if at_top?
+
+      scroll_up(@height)
+    end
+
+    #: () -> Array[String]
+    def half_page_down
+      return [] if at_bottom?
+
+      scroll_down(@height / 2)
+    end
+
+    #: () -> Array[String]
+    def half_page_up
+      return [] if at_top?
+
+      scroll_up(@height / 2)
+    end
+
+    #: () -> Array[String]
+    def goto_top
+      return [] if at_top?
+
+      self.y_offset = 0
+      visible_lines
+    end
+
+    #: () -> Array[String]
+    def goto_bottom
+      self.y_offset = max_y_offset
+      visible_lines
+    end
+
+    #: () -> Integer
+    def total_line_count
+      @lines.length
+    end
+
+    #: () -> Integer
+    def visible_line_count
+      visible_lines.length
+    end
+
+    #: (Bubbletea::Message) -> [Viewport, Bubbletea::Command?]
+    def update(message)
+      case message
+      when Bubbletea::KeyMessage
+        handle_key(message)
+      when Bubbletea::MouseMessage
+        handle_mouse(message) if @mouse_wheel_enabled
+      end
+
+      [self, nil]
+    end
+
+    #: () -> String
+    def view
+      lines = visible_lines
+      content = lines.join("\n")
+
+      content += "\n" * (@height - lines.length) if lines.length < @height
+
+      if (style = @style)
+        style.width(@width).height(@height).render(content)
+      else
+        content
+      end
+    end
+
+    private
+
+    #: (Bubbletea::KeyMessage) -> void
+    def handle_key(message)
+      case message.to_s
+      when "pgdown", "ctrl+f"
+        page_down
+      when "pgup", "ctrl+b"
+        page_up
+      when "ctrl+d"
+        half_page_down
+      when "ctrl+u"
+        half_page_up
+      when "down", "j"
+        scroll_down(1)
+      when "up", "k"
+        scroll_up(1)
+      when "left", "h"
+        scroll_left(@horizontal_step) if @horizontal_step.positive?
+      when "right", "l"
+        scroll_right(@horizontal_step) if @horizontal_step.positive?
+      when "home", "g"
+        goto_top
+      when "end", "G"
+        goto_bottom
+      end
+    end
+
+    #: (Bubbletea::MouseMessage) -> void
+    def handle_mouse(message)
+      # Mouse wheel support would go here
+      # Depends on bubbletea-ruby mouse message support
+    end
+
+    #: () -> Integer
+    def max_y_offset
+      frame_size = if (style = @style) && style.respond_to?(:vertical_frame_size)
+                     style.send(:vertical_frame_size).to_i
+                   else
+                     0
+                   end
+
+      [0, @lines.length - @height + frame_size].max
+    end
+
+    #: () -> Array[String]
+    def visible_lines
+      h = @height
+      if (style = @style) && style.respond_to?(:vertical_frame_size)
+        h -= style.send(:vertical_frame_size).to_i
+      end
+
+      return [] if @lines.empty?
+
+      top = [0, @y_offset].max
+      bottom = (@y_offset + h).clamp(top, @lines.length)
+      lines = @lines[top...bottom] || []
+
+      if @x_offset.positive? || @longest_line_width > @width
+        w = @width
+        if (style = @style) && style.respond_to?(:horizontal_frame_size)
+          w -= style.send(:horizontal_frame_size).to_i
+        end
+
+        lines = lines.map do |line|
+          cut_string(line, @x_offset, @x_offset + w)
+        end
+      end
+
+      lines
+    end
+
+    #: (String, Integer, Integer) -> String
+    def cut_string(string, start_column, end_column)
+      plain = strip_ansi(string)
+      return "" if start_column >= plain.length
+
+      plain[start_column...end_column] || ""
+    end
+
+    #: (String) -> String
+    def strip_ansi(string)
+      string.gsub(/\e\[[0-9;]*[A-Za-z]/, "")
+    end
+  end
+end

data/lib/bubbles.rb

@@ -1,39 +1,22 @@
-require 'fileutils'
-require 'pathname'
-require 'logger'
-require 'securerandom'
-require 'yaml'
-require 'json'
-require 'forwardable'
-require 'aws-sdk'
-require "bubbles/version"
-require "bubbles/config"
-require "bubbles/command_queue"
-require "bubbles/bubblicious_file"
-require "bubbles/dir_watcher"
-require 'bubbles/common_uploader_interface'
-require "bubbles/uploaders/s3"
-require "bubbles/uploaders/s3_ensure_connection"
-require "bubbles/uploaders/local_dir"
+# frozen_string_literal: true
 
-module Bubbles
-  extend self
-
-  def config
-    @config ||= Config.new
-  end
+require "bubbletea"
 
-  def run
-    command_queue = Bubbles::CommandQueue.new(config: config)
+require_relative "bubbles/version"
+require_relative "bubbles/spinner"
+require_relative "bubbles/timer"
+require_relative "bubbles/stopwatch"
+require_relative "bubbles/key"
+require_relative "bubbles/help"
+require_relative "bubbles/paginator"
+require_relative "bubbles/progress"
+require_relative "bubbles/cursor"
+require_relative "bubbles/text_input"
+require_relative "bubbles/text_area"
+require_relative "bubbles/viewport"
+require_relative "bubbles/list"
+require_relative "bubbles/table"
+require_relative "bubbles/file_picker"
 
-    command_queue << Bubbles::DirWatcher.new({
-      config: config,
-      command_queue: command_queue
-    })
-
-    loop do
-      command_queue.call_next
-      sleep config.sleep_interval
-    end
-  end
+module Bubbles
 end

data/sig/bubbles/cursor.rbs

@@ -0,0 +1,87 @@
+# Generated from lib/bubbles/cursor.rb with RBS::Inline
+
+module Bubbles
+  # Cursor provides cursor functionality for text input components.
+  #
+  # Example:
+  #   cursor = Bubbles::Cursor.new
+  #   cursor.char = "a"
+  #   cursor.focus
+  #
+  #   # In update:
+  #   cursor, command = cursor.update(message)
+  #
+  #   # In view:
+  #   cursor.view
+  class Cursor
+    MODE_BLINK: Symbol
+
+    MODE_STATIC: Symbol
+
+    MODE_HIDE: Symbol
+
+    DEFAULT_BLINK_SPEED: Float
+
+    class InitialBlinkMessage < Bubbletea::Message
+    end
+
+    class BlinkMessage < Bubbletea::Message
+      attr_reader id: Integer
+
+      attr_reader tag: Integer
+
+      # : (id: Integer, tag: Integer) -> void
+      def initialize: (id: Integer, tag: Integer) -> void
+    end
+
+    class BlinkCanceledMessage < Bubbletea::Message
+    end
+
+    # : () -> Integer
+    def self.next_id: () -> Integer
+
+    attr_reader id: Integer
+
+    attr_reader mode: Symbol
+
+    attr_accessor char: String
+
+    attr_accessor blink_speed: Float
+
+    attr_accessor style: Lipgloss::Style?
+
+    attr_accessor text_style: Lipgloss::Style?
+
+    # : () -> void
+    def initialize: () -> void
+
+    # : () -> bool
+    def blink?: () -> bool
+
+    # : () -> bool
+    def focused?: () -> bool
+
+    # : (Bubbletea::Message) -> [Cursor, Bubbletea::Command?]
+    def update: (Bubbletea::Message) -> [ Cursor, Bubbletea::Command? ]
+
+    # : (Symbol) -> Bubbletea::Command?
+    def set_mode: (Symbol) -> Bubbletea::Command?
+
+    # : () -> Bubbletea::Command?
+    def focus: () -> Bubbletea::Command?
+
+    # : () -> void
+    def blur: () -> void
+
+    # : () -> String
+    def view: () -> String
+
+    # : () -> Bubbletea::SendMessage
+    def self.blink: () -> Bubbletea::SendMessage
+
+    private
+
+    # : () -> Bubbletea::Command?
+    def blink_command: () -> Bubbletea::Command?
+  end
+end