bubbles 0.0.5 → 0.1.1

data/lib/bubbles/list.rb

@@ -0,0 +1,365 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Bubbles
+  # List is a feature-rich component for browsing a list of items.
+  # It features optional filtering, pagination, and status messages.
+  #
+  # Example:
+  #   items = [
+  #     { title: "Item 1", description: "Description 1" },
+  #     { title: "Item 2", description: "Description 2" }
+  #   ]
+  #   list = Bubbles::List.new(items, width: 40, height: 10)
+  #
+  #   # In update:
+  #   list, command = list.update(message)
+  #
+  #   # In view:
+  #   list.view
+  #
+  class List
+    UNFILTERED = :unfiltered #: Symbol
+    FILTERING = :filtering #: Symbol
+    FILTER_APPLIED = :filter_applied #: Symbol
+
+    class StatusMessageTimeoutMessage < Bubbletea::Message
+    end
+
+    attr_accessor :width #: Integer
+    attr_accessor :height #: Integer
+    attr_accessor :title #: String
+    attr_accessor :show_title #: bool
+    attr_accessor :show_filter #: bool
+    attr_accessor :show_pagination #: bool
+    attr_accessor :show_status_bar #: bool
+    attr_accessor :status_message_lifetime #: Float
+    attr_accessor :fill_height #: bool
+    attr_accessor :title_style #: Lipgloss::Style?
+    attr_accessor :item_style #: Lipgloss::Style?
+    attr_accessor :selected_item_style #: Lipgloss::Style?
+    attr_accessor :filter_prompt #: String
+    attr_accessor :filter_style #: Lipgloss::Style?
+    attr_accessor :status_bar_style #: Lipgloss::Style?
+    attr_accessor :pagination_style #: Lipgloss::Style?
+
+    attr_reader :filter_state #: Symbol
+    attr_reader :filter_input #: TextInput
+
+    #: (?Array[untyped], ?width: Integer, ?height: Integer) -> void
+    def initialize(items = [], width: 40, height: 10)
+      @width = width
+      @height = height
+
+      @items = items
+      @filtered_items = items.dup
+      @selected = 0
+      @offset = 0
+
+      @title = "List"
+      @show_title = true
+      @show_filter = true
+      @show_pagination = true
+      @show_status_bar = true
+      @fill_height = true
+
+      @filter_state = UNFILTERED
+      @filter_input = TextInput.new
+      @filter_input.prompt = "Filter: "
+      @filter_prompt = "/"
+
+      @paginator = Paginator.new(type: Paginator::DOTS)
+      @status_message = ""
+      @status_message_lifetime = 1.0
+
+      @title_style = nil
+      @item_style = nil
+      @selected_item_style = nil
+      @filter_style = nil
+      @status_bar_style = nil
+      @pagination_style = nil
+
+      update_pagination
+    end
+
+    #: (Array[untyped]) -> void
+    def items=(items)
+      @items = items
+      reset_filter
+    end
+
+    attr_reader :items #: Array[untyped]
+
+    #: () -> Array[untyped]
+    def visible_items
+      @filtered_items
+    end
+
+    #: () -> Integer
+    def selected_index
+      @selected
+    end
+
+    #: () -> untyped
+    def selected_item
+      @filtered_items[@selected]
+    end
+
+    #: (Integer) -> void
+    def select(index)
+      @selected = index.clamp(0, [@filtered_items.length - 1, 0].max)
+      update_offset
+    end
+
+    #: () -> void
+    def select_next
+      select(@selected + 1)
+    end
+
+    #: () -> void
+    def select_prev
+      select(@selected - 1)
+    end
+
+    #: (String) -> Bubbletea::Command
+    def set_status_message(message) # rubocop:disable Naming/AccessorMethodName
+      @status_message = message
+      Bubbletea.tick(@status_message_lifetime) { StatusMessageTimeoutMessage.new }
+    end
+
+    #: () -> void
+    def clear_status_message
+      @status_message = ""
+    end
+
+    #: () -> Bubbletea::Command?
+    def start_filtering
+      @filter_state = FILTERING
+      @filter_input.focus
+    end
+
+    #: () -> void
+    def apply_filter
+      return if @filter_state != FILTERING
+
+      if @filter_input.value.empty?
+        reset_filter
+      else
+        @filter_state = FILTER_APPLIED
+        @filter_input.blur
+
+        do_filter
+      end
+    end
+
+    #: () -> void
+    def reset_filter
+      @filter_state = UNFILTERED
+      @filter_input.reset
+      @filter_input.blur
+      @filtered_items = @items.dup
+      @selected = 0
+
+      update_pagination
+    end
+
+    #: (Bubbletea::Message) -> [List, Bubbletea::Command?]
+    def update(message)
+      commands = [] #: Array[Bubbletea::Command]
+
+      case message
+      when StatusMessageTimeoutMessage
+        clear_status_message
+
+        return [self, nil]
+      when Bubbletea::KeyMessage
+        if @filter_state == FILTERING
+          case message.to_s
+          when "enter"
+            apply_filter
+          when "esc"
+            reset_filter
+          else
+            @filter_input, command = @filter_input.update(message)
+            commands << command if command
+
+            do_filter
+          end
+        else
+          case message.to_s
+          when "up", "k"
+            select_prev
+          when "down", "j"
+            select_next
+          when "home", "g"
+            select(0)
+          when "end", "G"
+            select(@filtered_items.length - 1)
+          when "pgup", "ctrl+b"
+            select(@selected - visible_item_count)
+          when "pgdown", "ctrl+f"
+            select(@selected + visible_item_count)
+          when "/"
+            return [self, start_filtering] if @show_filter
+          when "esc"
+            reset_filter if @filter_state == FILTER_APPLIED
+          end
+        end
+      end
+
+      update_pagination
+
+      [self, commands.empty? ? nil : Bubbletea.batch(*commands)]
+    end
+
+    #: () -> String
+    def view
+      sections = [] #: Array[String]
+
+      if @show_title
+        title = (style = @title_style) ? style.render(@title) : @title
+        sections << title
+        sections << ""
+      end
+
+      if @show_filter && @filter_state != UNFILTERED
+        sections << @filter_input.view
+        sections << ""
+      end
+
+      sections << items_view
+
+      if @show_pagination && @filtered_items.length > visible_item_count
+        sections << ""
+        pagination = @paginator.view
+        sections << ((style = @pagination_style) ? style.render(pagination) : pagination)
+      end
+
+      if @show_status_bar && !@status_message.empty?
+        sections << ""
+        status = (style = @status_bar_style) ? style.render(@status_message) : @status_message
+        sections << status
+      end
+
+      sections.join("\n")
+    end
+
+    private
+
+    #: () -> String
+    def items_view
+      return "No items" if @filtered_items.empty?
+
+      lines = [] #: Array[String]
+      end_index = [@offset + visible_item_count, @filtered_items.length].min
+
+      (@offset...end_index).each do |i|
+        item = @filtered_items[i]
+        is_selected = i == @selected
+
+        line = render_item(item, i, is_selected)
+        lines << line
+      end
+
+      (lines << "" while lines.length < visible_item_count) if @fill_height
+
+      lines.join("\n")
+    end
+
+    #: (untyped, Integer, bool) -> String
+    def render_item(item, _index, selected)
+      text = item_title(item)
+
+      if selected
+        prefix = "> "
+        if (style = @selected_item_style)
+          style.render(prefix + text)
+        else
+          "\e[7m#{prefix}#{text}\e[0m"
+        end
+      else
+        prefix = "  "
+        if (style = @item_style)
+          style.render(prefix + text)
+        else
+          prefix + text
+        end
+      end
+    end
+
+    #: (untyped) -> String
+    def item_title(item)
+      if item.respond_to?(:title)
+        item.title
+      elsif item.is_a?(Hash) && item[:title]
+        item[:title]
+      elsif item.respond_to?(:filter_value)
+        item.filter_value
+      else
+        item.to_s
+      end
+    end
+
+    #: (untyped) -> String
+    def item_filter_value(item)
+      if item.respond_to?(:filter_value)
+        item.filter_value
+      elsif item.respond_to?(:title)
+        item.title
+      elsif item.is_a?(Hash) && item[:title]
+        item[:title]
+      else
+        item.to_s
+      end
+    end
+
+    #: () -> void
+    def do_filter
+      query = @filter_input.value.downcase
+
+      @filtered_items = if query.empty?
+                          @items.dup
+                        else
+                          @items.select do |item|
+                            item_filter_value(item).downcase.include?(query)
+                          end
+                        end
+
+      @selected = 0 if @selected >= @filtered_items.length
+      update_offset
+      update_pagination
+    end
+
+    #: () -> Integer
+    def visible_item_count
+      overhead = 0
+
+      overhead += 2 if @show_title # Title + blank line
+      overhead += 2 if @show_filter && @filter_state != UNFILTERED # Filter + blank line
+      overhead += 2 if @show_pagination && @filtered_items.length > @height - overhead
+      overhead += 2 if @show_status_bar && !@status_message.empty?
+
+      [@height - overhead, 1].max
+    end
+
+    #: () -> void
+    def update_offset
+      visible = visible_item_count
+
+      if @selected < @offset
+        @offset = @selected
+      elsif @selected >= @offset + visible
+        @offset = @selected - visible + 1
+      end
+
+      @offset = @offset.clamp(0, [@filtered_items.length - visible, 0].max)
+    end
+
+    #: () -> void
+    def update_pagination
+      @paginator.per_page = visible_item_count
+      @paginator.update_total_pages(@filtered_items.length)
+      @paginator.page = @offset / [visible_item_count, 1].max
+    end
+  end
+end

data/lib/bubbles/paginator.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Bubbles
+  # Paginator provides pagination logic and rendering.
+  #
+  # Example:
+  #   items = (1..100).to_a
+  #   paginator = Bubbles::Paginator.new(per_page: 10)
+  #   paginator.update_total_pages(items.length)
+  #
+  #   # Get current page items
+  #   start_index, end_index = paginator.slice_bounds(items.length)
+  #   current_items = items[start_index...end_index]
+  #
+  #   # Navigation
+  #   paginator.next_page
+  #   paginator.prev_page
+  #
+  #   # Render pagination indicator
+  #   puts paginator.view
+  #
+  class Paginator
+    ARABIC = :arabic #: Symbol
+    DOTS = :dots #: Symbol
+
+    attr_accessor :type #: Symbol
+    attr_accessor :page #: Integer
+    attr_accessor :per_page #: Integer
+    attr_accessor :total_pages #: Integer
+    attr_accessor :active_dot #: String
+    attr_accessor :inactive_dot #: String
+    attr_accessor :arabic_format #: String
+    attr_accessor :key_style #: Lipgloss::Style?
+    attr_accessor :active_dot_style #: Lipgloss::Style?
+    attr_accessor :inactive_dot_style #: Lipgloss::Style?
+
+    #: (?type: Symbol, ?per_page: Integer) -> void
+    def initialize(type: ARABIC, per_page: 10)
+      @type = type
+      @page = 0
+      @per_page = per_page
+      @total_pages = 1
+
+      @active_dot = "●"
+      @inactive_dot = "○"
+
+      @arabic_format = "%d/%d"
+
+      @key_style = nil
+      @active_dot_style = nil
+      @inactive_dot_style = nil
+    end
+
+    #: (Integer) -> void
+    def update_total_pages(total_items)
+      @total_pages = [(total_items.to_f / @per_page).ceil, 1].max
+      # Clamp current page
+      @page = @page.clamp(0, @total_pages - 1)
+    end
+
+    #: (Integer) -> Integer
+    def items_on_page(total_items)
+      return 0 if total_items <= 0
+
+      start_index = @page * @per_page
+      remaining = total_items - start_index
+
+      [remaining, @per_page].min
+    end
+
+    #: (Integer) -> [Integer, Integer]
+    def slice_bounds(total_items)
+      start_index = @page * @per_page
+      end_index = [start_index + @per_page, total_items].min
+      [start_index, end_index]
+    end
+
+    #: () -> bool
+    def prev_page?
+      @page.positive?
+    end
+
+    #: () -> bool
+    def next_page?
+      @page < @total_pages - 1
+    end
+
+    #: () -> bool
+    def prev_page # rubocop:disable Naming/PredicateMethod
+      return false unless prev_page?
+
+      @page -= 1
+
+      true
+    end
+
+    #: () -> bool
+    def next_page # rubocop:disable Naming/PredicateMethod
+      return false unless next_page?
+
+      @page += 1
+
+      true
+    end
+
+    #: (Integer) -> bool
+    def go_to_page(page) # rubocop:disable Naming/PredicateMethod
+      new_page = page.clamp(0, @total_pages - 1)
+      return false if new_page == @page
+
+      @page = new_page
+
+      true
+    end
+
+    #: () -> String
+    def view
+      case @type
+      when DOTS
+        dots_view
+      else
+        arabic_view
+      end
+    end
+
+    private
+
+    #: () -> String
+    def arabic_view
+      text = format(@arabic_format, @page + 1, @total_pages)
+      (key_style = @key_style) ? key_style.render(text) : text
+    end
+
+    #: () -> String
+    def dots_view
+      dots = (0...@total_pages).map do |i|
+        if i == @page
+          render_active_dot
+        else
+          render_inactive_dot
+        end
+      end
+
+      dots.join(" ")
+    end
+
+    #: () -> String
+    def render_active_dot
+      (style = @active_dot_style) ? style.render(@active_dot) : @active_dot
+    end
+
+    #: () -> String
+    def render_inactive_dot
+      (style = @inactive_dot_style) ? style.render(@inactive_dot) : @inactive_dot
+    end
+  end
+end