charming 0.1.0 → 0.1.1

data/lib/charming/presentation/components/progressbar.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Charming
+  module Presentation
+    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
+end

data/lib/charming/presentation/components/spinner.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Charming
+  module Presentation
+    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
+end

data/lib/charming/presentation/components/table.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "tty-table"
+
+module Charming
+  module Presentation
+    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, keymap: :vim)
+          super()
+          @header = Array(header).map(&:to_s)
+          @rows = Array(rows)
+          @selected_index = clamp_index(selected_index)
+          @keymap = keymap
+        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
+end

data/lib/charming/presentation/components/text_area.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module Charming
+  module Presentation
+    module Components
+      class TextArea < Component
+        attr_reader :value, :cursor, :offset, :preferred_column
+
+        def initialize(value: "", placeholder: "", width: nil, height: nil, cursor: nil, offset: 0, preferred_column: nil)
+          super()
+          @value = value.dup
+          @placeholder = placeholder
+          @width = width
+          @height = height
+          @cursor = cursor || @value.length
+          @offset = offset
+          @preferred_column = preferred_column
+          clamp_position
+          ensure_cursor_visible
+        end
+
+        def handle_key(event)
+          key = Charming.key_of(event)
+          return :handled if newline_event?(event) && insert("\n")
+          return :handled if character_event?(event) && insert(event.char)
+
+          case key
+          when :left then move_left
+          when :right then move_right
+          when :up then move_up
+          when :down then move_down
+          when :home then move_home
+          when :end then move_end
+          when :backspace then delete_before_cursor
+          when :delete then delete_at_cursor
+          when :page_up then page_up
+          when :page_down then page_down
+          else return nil
+          end
+
+          :handled
+        end
+
+        def render
+          visible_lines.map { |line| render_line(line) }.join("\n")
+        end
+
+        private
+
+        attr_reader :placeholder, :width, :height
+
+        def newline_event?(event)
+          key = Charming.key_of(event)
+          return true if key == :enter && event.respond_to?(:shift) && event.shift
+          return true if key == :j && event.respond_to?(:ctrl) && event.ctrl
+
+          false
+        end
+
+        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(text)
+          @value = value[0...cursor].to_s + text + value[cursor..].to_s
+          @cursor += text.length
+          reset_preferred_column
+          ensure_cursor_visible
+        end
+
+        def move_left
+          @cursor -= 1 if cursor.positive?
+          reset_preferred_column
+          ensure_cursor_visible
+        end
+
+        def move_right
+          @cursor += 1 if cursor < value.length
+          reset_preferred_column
+          ensure_cursor_visible
+        end
+
+        def move_up
+          move_vertical(-1)
+        end
+
+        def move_down
+          move_vertical(+1)
+        end
+
+        def move_home
+          row, = cursor_position
+          @cursor = line_start(row)
+          reset_preferred_column
+          ensure_cursor_visible
+        end
+
+        def move_end
+          row, = cursor_position
+          @cursor = line_start(row) + line_length(row)
+          reset_preferred_column
+          ensure_cursor_visible
+        end
+
+        def delete_before_cursor
+          return if cursor.zero?
+
+          @value = value[0...(cursor - 1)].to_s + value[cursor..].to_s
+          @cursor -= 1
+          reset_preferred_column
+          ensure_cursor_visible
+        end
+
+        def delete_at_cursor
+          return if cursor >= value.length
+
+          @value = value[0...cursor].to_s + value[(cursor + 1)..].to_s
+          reset_preferred_column
+          ensure_cursor_visible
+        end
+
+        def page_up
+          @offset -= viewport_height
+          clamp_offset
+        end
+
+        def page_down
+          @offset += viewport_height
+          clamp_offset
+        end
+
+        def move_vertical(delta)
+          row, column = cursor_position
+          target_row = (row + delta).clamp(0, lines.length - 1)
+          @preferred_column ||= column
+          @cursor = line_start(target_row) + [@preferred_column, line_length(target_row)].min
+          ensure_cursor_visible
+        end
+
+        def reset_preferred_column
+          @preferred_column = cursor_position.last
+        end
+
+        def cursor_position
+          before = value[0...cursor].to_s
+          row = before.count("\n")
+          last_newline = before.rindex("\n")
+          column = last_newline ? before.length - last_newline - 1 : before.length
+          [row, column]
+        end
+
+        def line_start(row)
+          lines.first(row).sum(&:length) + row
+        end
+
+        def line_length(row)
+          lines.fetch(row, "").length
+        end
+
+        def lines
+          value.empty? ? [""] : value.split("\n", -1)
+        end
+
+        def rendered_lines
+          return [cursor_marker + placeholder] if value.empty?
+
+          (value[0...cursor].to_s + cursor_marker + value[cursor..].to_s).split("\n", -1)
+        end
+
+        def visible_lines
+          ensure_cursor_visible
+          rendered = rendered_lines.slice(offset, viewport_height) || []
+          return rendered unless height
+
+          rendered + Array.new([height - rendered.length, 0].max, "")
+        end
+
+        def render_line(line)
+          return line unless width
+
+          clipped = UI.visible_slice(line, 0, width)
+          clipped + (" " * [width - UI::Width.measure(clipped), 0].max)
+        end
+
+        def ensure_cursor_visible
+          row, = cursor_position
+          @offset = row if row < offset
+          @offset = row - viewport_height + 1 if row >= offset + viewport_height
+          clamp_offset
+        end
+
+        def clamp_position
+          @cursor = cursor.clamp(0, value.length)
+          clamp_offset
+        end
+
+        def clamp_offset
+          @offset = offset.clamp(0, max_offset)
+        end
+
+        def max_offset
+          [lines.length - viewport_height, 0].max
+        end
+
+        def viewport_height
+          height || lines.length
+        end
+
+        def cursor_marker
+          "|"
+        end
+      end
+    end
+  end
+end

data/lib/charming/presentation/components/text_input.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Charming
+  module Presentation
+    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
+end