charming 0.1.0 → 0.1.1

data/lib/charming/components/command_palette.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  module Components
-    # CommandPalette renders a fuzzy-searchable command picker UI. It wraps a TextInput for search
-    # input and a List for result display, dispatching key events between them. Users type to filter
-    # the registered commands by label match, navigate with up/down/home/end keys (delegated to List),
-    # confirm a selection with Enter (returns [:selected, command]), or cancel with Escape (returns :cancelled).
-    # State is serializable as a hash of value/cursor/selected_index for session persistence.
-    class CommandPalette < Component
-      Command = Data.define(:label, :value)
-
-      # A single command palette entry: a human-readable +label+ and a callable or
-      # method symbol +value+ that gets executed when the user selects it.
-      attr_reader :commands, :input
-
-      # Initializes the dropdown widget with a list of Command entries and search
-      # parameters for building the underlying TextInput (placeholder text, cursor
-      # position, value) and List (display height, initial selection). Returns void;
-      # the state is later serializable via +state+ for session persistence.
-      def initialize(commands:, placeholder: "Search commands", height: nil, value: "", cursor: nil, selected_index: 0, theme: nil)
-        super(theme: theme)
-        @commands = commands
-        @height = height
-        @input = TextInput.new(value: value, placeholder: placeholder, cursor: cursor)
-        @list = build_list(selected_index: selected_index)
-      end
-
-      # Returns the currently displayed Command entry in the List at the time of calling.
-      # Returns nil if no entry is highlighted (i.e., user has opened the palette but not
-      # moved the selection). Useful for retrieving the result after key handling.
-      def selected_command
-        list.selected_item
-      end
-
-      # Collects the current state of the TextInput and List into a serializable hash
-      # suitable for round-trip storage in session. Returns {value:, cursor:, selected_index:}.
-      def state
-        {
-          value: input.value,
-          cursor: input.cursor,
-          selected_index: list.selected_index
-        }
-      end
-
-      # Handles key events by routing them to the appropriate sub-component: Escape kills the
-      # palette returning :cancelled; up/down/home/end keys go to the List selection handler
-      # via handle_list_key; all other keys (including typed characters) are passed to the TextInput
-      # which manages cursor position and input filtering. If a list key match fails, falls through
-      # to the TextInput handler. Returns nil/nil if no handler consumed the event, or :cancelled when
-      # Escape is pressed.
-      def handle_key(event)
-        key = Charming.key_of(event)
-        return :cancelled if key == :escape
-
-        return handle_list_key(event) if list_key?(key)
-
-        handle_input_key(event)
-      end
-
-      # Renders the command palette as a vertically-stacked text representation: the search TextInput
-      # row on line 1, and then the filtered List results (or "No commands found") on subsequent lines.
-      # Returns a multiline string suitable for terminal rendering.
-      def render
-        [input.render, render_results].join("\n")
-      end
-
-      private
-
-      attr_reader :height, :list
-
-      # Delegates key handling entirely to the internal List widget, which manages up/down/home/end selection.
-      # Returns whatever the List's handle_key returns (typically nil or the symbol from the subclass).
-      def handle_list_key(event)
-        list.handle_key(event)
-      end
-
-      # Passes the key event to the TextInput for cursor position and search text management.
-      # If the input returns :handled, rebuilds the List so that filtering is re-evaluated against
-      # the new input value. Returns nil/nil if no handler consumed the event.
-      def handle_input_key(event)
-        result = input.handle_key(event)
-        @list = build_list if result == :handled
-        result
-      end
-
-      # Checks whether the given key is a List-navigation key (up/down/home/end). Returns true for those keys
-      # so they can be dispatched via +handle_list_key+ rather than falling through to TextInput.
-      def list_key?(key)
-        %i[up down home end enter].include?(key)
-      end
-
-      # Renders the filtered results section below the search input. If no commands match the current filter text,
-      # returns "No commands found"; otherwise renders the List widget's styled display string. Returns a single-line string.
-      def render_results
-        return "No commands found" if filtered_commands.empty?
-
-        list.render
-      end
-
-      # Builds a new List from the currently filtered commands at the given selected_index height and label extractor.
-      # The +selected_index+ parameter defaults to the last known value in +list+ to preserve scroll position across rebuilds.
-      def build_list(selected_index: list&.selected_index || 0)
-        List.new(items: filtered_commands, selected_index: selected_index, height: height, label: :label.to_proc, theme: theme)
-      end
-
-      # Returns the full commands array when input value is empty; otherwise a subset whose labels match case-insensitively
-      # against the current TextInput value. Used to drive the fuzzy search behavior. Returns an Array of Command entries.
-      def filtered_commands
-        return commands if input.value.empty?
-
-        commands.select do |command|
-          command.label.downcase.include?(input.value.downcase)
-        end
-      end
-    end
-  end
-end

data/lib/charming/components/keyboard_handler.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  module Components
-    # KeyboardHandler is a mixin module that provides keyboard event dispatch by mapping symbolic key names
-    # to private method calls. Implementors must define a constant +KEY_ACTIONS+ as a hash where each key is
-    # a symbol (e.g., :up, :down, :enter) and each value is the target method name (e.g., :move_up). Call
-    # +handle_key(event)+ with any event object; it uses Charming.key_of to resolve the raw event to a symbol,
-    # looks up the corresponding action in KEY_ACTIONS, sends that method on self, and returns :handled if an
-    # action was found. Returns nil (via :handled being truthy or not) when no matching key exists.
-    module KeyboardHandler
-      def handle_key(event)
-        key = Charming.key_of(event)
-        action = self.class.const_get(:KEY_ACTIONS)[key]
-        return unless action
-
-        send(action)
-        :handled
-      end
-    end
-  end
-end

data/lib/charming/components/list.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  module Components
-    class List < Component
-      include KeyboardHandler
-
-      # Maps navigation key symbols to instance methods consumed by the KeyboardHandler
-      # mixin: :up moves selection up, :down moves down, :home jumps to first item,
-      # :end jumps to last. See Viewport#KEY_ACTIONS and Table#KEY_ACTIONS for identical pattern.
-      KEY_ACTIONS = {
-        up: :move_up,
-        down: :move_down,
-        home: :move_home,
-        end: :move_end
-      }.freeze
-
-      attr_reader :items, :selected_index
-
-      def initialize(items:, selected_index: 0, height: nil, label: nil, theme: nil)
-        super(theme: theme)
-        @items = items
-        @selected_index = selected_index
-        @height = height
-        @label = label || :to_s.to_proc
-        clamp_position
-      end
-
-      def handle_key(event)
-        return [:selected, selected_item] if Charming.key_of(event) == :enter && selected_item
-
-        super
-      end
-
-      def handle_mouse(event)
-        return nil unless @height
-        return nil unless event.respond_to?(:click?) && event.click?
-
-        clicked = event.y
-        return nil if clicked.negative? || clicked >= visible_items.length
-
-        @selected_index = viewport_start + clicked
-        clamp_position
-        :handled
-      end
-
-      def selected_item
-        items[selected_index]
-      end
-
-      def render
-        visible_items.each_with_index.map do |item, index|
-          render_item(item, viewport_start + index)
-        end.join("\n")
-      end
-
-      private
-
-      def move_up
-        @selected_index -= 1 if selected_index.positive?
-      end
-
-      def move_down
-        @selected_index += 1 if selected_index < items.length - 1
-      end
-
-      def move_home
-        @selected_index = 0
-      end
-
-      def move_end
-        @selected_index = items.length - 1 unless items.empty?
-      end
-
-      def visible_items
-        items[viewport_start, viewport_height] || []
-      end
-
-      def viewport_start
-        return 0 unless @height
-
-        (selected_index - @height + 1).clamp(0, max_viewport_start)
-      end
-
-      def viewport_height
-        @height || items.length
-      end
-
-      def max_viewport_start
-        [items.length - @height, 0].max
-      end
-
-      def render_item(item, index)
-        prefix = (index == selected_index) ? "> " : "  "
-        rendered = "#{prefix}#{@label.call(item)}"
-        (index == selected_index) ? theme.selected.render(rendered) : rendered
-      end
-
-      def clamp_position
-        @selected_index = 0 if items.empty?
-        @selected_index = selected_index.clamp(0, items.length - 1) unless items.empty?
-      end
-    end
-  end
-end

data/lib/charming/components/modal.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  module Components
-    class Modal < Component
-      def initialize(content:, title: nil, help: nil, width: 52, style: nil, theme: nil)
-        super(theme: theme)
-        @content = content
-        @title = title
-        @help = help
-        @width = width
-        @style = style
-      end
-
-      def render
-        box(column(*lines, gap: 1), style: modal_style)
-      end
-
-      private
-
-      attr_reader :content, :title, :help, :width
-
-      def lines
-        [title_line, help_line, render_content].compact
-      end
-
-      def title_line
-        text(title, style: theme.title.align(:center).width(title_width)) if title
-      end
-
-      def help_line
-        text(help, style: theme.muted) if help
-      end
-
-      def render_content
-        content.respond_to?(:render) ? render_component(content) : content.to_s
-      end
-
-      def modal_style
-        @style || theme.modal.width(width)
-      end
-
-      def title_width
-        [width - 8, 0].max
-      end
-    end
-  end
-end

data/lib/charming/components/progressbar.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  module Components
-    class Progressbar < Component
-      attr_accessor :total, :current, :label, :complete, :incomplete, :bar_format
-
-      def initialize(total:, complete: "=", incomplete: " ", bar_format: :classic, label: nil)
-        super()
-        @total = [total.to_i, 0].max
-        @complete = complete.to_s
-        @incomplete = incomplete.to_s
-        @bar_format = bar_format.to_sym
-        @label = label
-        @current = 0
-      end
-
-      def tick(count = 1)
-        update(@current + count)
-        self
-      end
-
-      def update(value)
-        @current = value.to_i.clamp(0, @total)
-        self
-      end
-
-      def complete!
-        @current = @total
-        self
-      end
-
-      def render
-        width = [@total, 1].max
-        completed = completed_width(width)
-        incomplete = width - completed
-        incomplete -= 1 if @current.zero?
-        bar = (@complete * completed) + (@incomplete * incomplete)
-        result = "[" + bar + "]"
-
-        return result unless @label
-
-        "#{result} #{@label}"
-      end
-
-      private
-
-      def completed_width(width)
-        return 0 unless @total.positive?
-
-        ((width * @current) / @total.to_f).round
-      end
-    end
-  end
-end

data/lib/charming/components/spinner.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  module Components
-    class Spinner < Component
-      DEFAULT_FRAMES = ["-", "\\", "|", "/"].freeze
-
-      attr_reader :frames, :index, :label
-
-      def initialize(frames: DEFAULT_FRAMES, index: 0, label: nil)
-        super()
-        raise ArgumentError, "frames cannot be empty" if frames.empty?
-
-        @frames = frames
-        @index = index
-        @label = label
-      end
-
-      def tick
-        @index = (index + 1) % frames.length
-        self
-      end
-
-      def render
-        return frame unless label
-
-        "#{frame} #{label}"
-      end
-
-      private
-
-      def frame
-        frames.fetch(index % frames.length)
-      end
-    end
-  end
-end

data/lib/charming/components/table.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require "tty-table"
-
-module Charming
-  module Components
-    class Table < Component
-      include KeyboardHandler
-
-      KEY_ACTIONS = {
-        up: :move_up,
-        down: :move_down,
-        home: :move_home,
-        end: :move_end
-      }.freeze
-
-      HEADER_HEIGHT = 2
-
-      attr_reader :header, :rows, :selected_index
-
-      def initialize(header:, rows: [], selected_index: 0)
-        super()
-        @header = Array(header).map(&:to_s)
-        @rows = Array(rows)
-        @selected_index = clamp_index(selected_index)
-      end
-
-      def handle_key(event)
-        return nil if rows.empty?
-
-        case Charming.key_of(event)
-        when :enter then [:selected, selected_row]
-        else super
-        end
-      end
-
-      def handle_mouse(event)
-        return nil if rows.empty?
-        return nil unless event.respond_to?(:click?) && event.click?
-
-        clicked = event.y - HEADER_HEIGHT
-        return nil if clicked.negative? || clicked >= rows.length
-
-        @selected_index = clicked
-        :handled
-      end
-
-      def selected_row
-        rows[selected_index]
-      end
-
-      def render
-        return "(empty table)" if header.empty? && rows.empty?
-
-        normalized = rows.map { |row| normalize_row(row) }
-        lines = TTY::Table.new(header: header, rows: normalized)
-          .render(:unicode)
-          .lines(chomp: true)
-
-        compact_layout(lines)
-      end
-
-      private
-
-      def normalize_row(row)
-        cells = case row
-        when Hash then row.values
-        when String then [row]
-        else Array(row)
-        end
-        return cells if header.length <= 1 || cells.length <= header.length
-
-        kept = cells.first(header.length - 1)
-        merged = cells[(header.length - 1)..].join(" ")
-        kept + [merged]
-      end
-
-      def compact_layout(lines)
-        return lines.join("\n") if lines.length < 4
-
-        top, header_line, _separator, *rest = lines
-        body = rest.first(rows.length)
-        bottom = rest[rows.length]
-
-        highlighted = body.each_with_index.map do |line, index|
-          (index == selected_index) ? "\e[7m#{line}\e[m" : line
-        end
-
-        [top, header_line, *highlighted, bottom].compact.join("\n")
-      end
-
-      def move_up
-        @selected_index -= 1 if selected_index.positive?
-      end
-
-      def move_down
-        @selected_index += 1 if selected_index < rows.length - 1
-      end
-
-      def move_home
-        @selected_index = 0
-      end
-
-      def move_end
-        @selected_index = rows.length - 1
-      end
-
-      def clamp_index(value)
-        return 0 if rows.empty?
-
-        value.to_i.clamp(0, rows.length - 1)
-      end
-    end
-  end
-end

data/lib/charming/components/text_input.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  module Components
-    class TextInput < Component
-      include KeyboardHandler
-
-      # Maps editing keys (left/right/home/end/backspace/delete) to the instance
-      # methods they dispatch via KeyboardHandler. Each symbol key (e.g., :left)
-      # maps to a method (e.g., :move_left) that adjusts cursor position or text content.
-      KEY_ACTIONS = {
-        left: :move_left,
-        right: :move_right,
-        home: :move_home,
-        end: :move_end,
-        backspace: :delete_before_cursor,
-        delete: :delete_at_cursor
-      }.freeze
-
-      attr_reader :value, :cursor
-
-      def initialize(value: "", placeholder: "", width: nil, cursor: nil)
-        super()
-        @value = value.dup
-        @placeholder = placeholder
-        @width = width
-        @cursor = cursor || @value.length
-        clamp_position
-      end
-
-      def handle_key(event)
-        return :handled if character_event?(event) && insert(event.char)
-
-        super
-      end
-
-      def render
-        rendered = render_value
-        @width ? style.width(@width).render(rendered) : rendered
-      end
-
-      private
-
-      attr_reader :placeholder
-
-      def character_event?(event)
-        event.respond_to?(:char) && event.char && event.char.length == 1 && printable?(event.char)
-      end
-
-      def printable?(char)
-        !char.match?(/[[:cntrl:]]/)
-      end
-
-      def insert(char)
-        @value = value[0...cursor] + char + value[cursor..]
-        @cursor += char.length
-      end
-
-      def move_left
-        @cursor -= 1 if cursor.positive?
-      end
-
-      def move_right
-        @cursor += 1 if cursor < value.length
-      end
-
-      def move_home
-        @cursor = 0
-      end
-
-      def move_end
-        @cursor = value.length
-      end
-
-      def delete_before_cursor
-        return if cursor.zero?
-
-        @value = value[0...(cursor - 1)] + value[cursor..]
-        @cursor -= 1
-      end
-
-      def delete_at_cursor
-        return if cursor >= value.length
-
-        @value = value[0...cursor] + value[(cursor + 1)..]
-      end
-
-      def render_value
-        return cursor_marker + placeholder if value.empty?
-
-        value[0...cursor] + cursor_marker + value[cursor..]
-      end
-
-      def cursor_marker
-        "|"
-      end
-
-      def clamp_position
-        @cursor = cursor.clamp(0, value.length)
-      end
-    end
-  end
-end