charming 0.1.0 → 0.1.1

data/lib/charming/components/viewport.rb

@@ -1,191 +0,0 @@
-# frozen_string_literal: true
-
-require "unicode/display_width"
-
-module Charming
-  module Components
-    class Viewport < Component
-      include KeyboardHandler
-
-      ANSI_PATTERN = /\e\[[0-9;]*m/
-      KEY_ACTIONS = {
-        up: :scroll_up,
-        down: :scroll_down,
-        page_up: :page_up,
-        page_down: :page_down,
-        home: :scroll_home,
-        end: :scroll_end,
-        left: :scroll_left,
-        right: :scroll_right
-      }.freeze
-
-      attr_reader :offset, :column
-
-      def initialize(content:, width: nil, height: nil, offset: 0, column: 0)
-        super()
-        @content = content
-        @width = width
-        @height = height
-        @offset = offset
-        @column = column
-        clamp_position
-      end
-
-      def render
-        visible_lines.map { |line| render_line(line) }.join("\n")
-      end
-
-      def handle_mouse(event)
-        return nil unless height
-
-        if event.scroll?
-          scroll_delta = (event.button_name == :scroll_up) ? -1 : 1
-          @offset += scroll_delta
-          clamp_position
-          return :handled
-        end
-
-        return nil unless event.click?
-
-        clicked_row = event.y
-        return nil if clicked_row < offset || clicked_row >= offset + viewport_height
-
-        @offset = clicked_row
-        clamp_position
-        :handled
-      end
-
-      private
-
-      attr_reader :content, :width, :height
-
-      def scroll_up
-        @offset -= 1
-        clamp_position
-      end
-
-      def scroll_down
-        @offset += 1
-        clamp_position
-      end
-
-      def page_up
-        @offset -= page_size
-        clamp_position
-      end
-
-      def page_down
-        @offset += page_size
-        clamp_position
-      end
-
-      def scroll_home
-        @offset = 0
-        @column = 0
-      end
-
-      def scroll_end
-        @offset = max_offset
-        @column = max_column
-      end
-
-      def scroll_left
-        @column -= 1
-        clamp_position
-      end
-
-      def scroll_right
-        @column += 1
-        clamp_position
-      end
-
-      def clamp_position
-        @offset = offset.clamp(0, max_offset)
-        @column = column.clamp(0, max_column)
-      end
-
-      def visible_lines
-        lines = content_lines.slice(offset, viewport_height) || []
-        return lines unless height
-
-        lines + Array.new([height - lines.length, 0].max, "")
-      end
-
-      def render_line(line)
-        return line unless width
-
-        pad_line(clip_line(line), width)
-      end
-
-      def clip_line(line)
-        clipped = clip_tokens(line.to_s)
-        needs_reset?(clipped) ? "#{clipped}\e[0m" : clipped
-      end
-
-      def clip_tokens(line)
-        state = {cursor: 0, output: +""}
-        line.scan(/#{ANSI_PATTERN}|./mo) do |token|
-          ansi?(token) ? append_ansi(state, token) : append_character(state, token)
-        end
-        state.fetch(:output)
-      end
-
-      def append_ansi(state, token)
-        state.fetch(:output) << token
-      end
-
-      def append_character(state, char)
-        char_width = Unicode::DisplayWidth.of(char)
-        cursor = state.fetch(:cursor)
-        state.fetch(:output) << char if visible?(cursor, char_width)
-        state[:cursor] = cursor + char_width
-      end
-
-      def visible?(cursor, char_width)
-        cursor >= column && cursor + char_width <= column + width
-      end
-
-      def needs_reset?(value)
-        value.match?(ANSI_PATTERN) && !value.end_with?("\e[0m")
-      end
-
-      def pad_line(line, target_width)
-        line + (" " * [target_width - UI::Width.measure(line), 0].max)
-      end
-
-      def content_lines
-        rendered_content.lines(chomp: true)
-      end
-
-      def rendered_content
-        content.respond_to?(:render) ? content.render.to_s : content.to_s
-      end
-
-      def viewport_height
-        height || content_lines.length
-      end
-
-      def page_size
-        [viewport_height, 1].max
-      end
-
-      def max_offset
-        [content_lines.length - viewport_height, 0].max
-      end
-
-      def max_column
-        return 0 unless width
-
-        [content_width - width, 0].max
-      end
-
-      def content_width
-        content_lines.map { |line| UI::Width.measure(line) }.max || 0
-      end
-
-      def ansi?(token)
-        token.match?(ANSI_PATTERN)
-      end
-    end
-  end
-end

data/lib/charming/key_event.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  # KeyEvent represents a terminal key press parsed by the backend. *key* is the normalized semantic
-  # action name (e.g., `:up`, `:down`, `:q`), while *char*, *ctrl*, *alt*, and *shift* capture raw
-  # input details for custom bindings.
-  KeyEvent = Data.define(:key, :char, :ctrl, :alt, :shift) do
-    # Constructs a key event with the required *key* symbol, plus optional *char* string and modifier booleans.
-    def initialize(key:, char: nil, ctrl: false, alt: false, shift: false)
-      super(key: key.to_sym, char: char, ctrl: ctrl, alt: alt, shift: shift)
-    end
-  end
-end

data/lib/charming/mouse_event.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  # MOUSE_BUTTON_MAP encodes terminal mouse button codes to semantic symbols. The constant is frozen and private.
-  MOUSE_BUTTON_MAP = {
-    0 => :left, 1 => :middle, 2 => :right, 3 => :release,
-    64 => :scroll_up, 65 => :scroll_down,
-    66 => :scroll_up, 67 => :scroll_down
-  }.freeze
-  private_constant :MOUSE_BUTTON_MAP
-
-  # MouseEvent represents a mouse input event. *button* encodes which button or action was triggered (left,
-  # right, scroll), while *x* and *y* provide the cursor position. Modifier booleans (*ctrl*, *alt*, *shift*)
-  # capture key state at the time of the event.
-  MouseEvent = Data.define(:button, :x, :y, :ctrl, :alt, :shift) do
-    def initialize(button:, x:, y:, ctrl: false, alt: false, shift: false)
-      super
-    end
-
-    # Returns the semantic symbol for *button* — one of `left`, `right`, `scroll_up`, etc. or `:unknown`.
-    def button_name
-      MOUSE_BUTTON_MAP.fetch(button, :unknown)
-    end
-
-    # Returns `true` when the current event is a click (left, middle, or right button).
-    def click?
-      %i[left middle right].include?(button_name)
-    end
-
-    # Returns `true` when the button name maps to either direction of scroll.
-    def scroll?
-      %i[scroll_up scroll_down].include?(button_name)
-    end
-
-    # Returns `true` when the current event is a mouse release action.
-    def release?
-      button_name == :release
-    end
-  end
-end

data/lib/charming/resize_event.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  # ResizeEvent represents a terminal window resize. *width* and *height* carry the new terminal dimensions
-  # in screen cells, replacing the previous Screen dimensions for all subsequent rendering.
-  ResizeEvent = Data.define(:width, :height)
-end

data/lib/charming/task.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  Task = Data.define(:name, :block) do
-    def call = block.call
-  end
-end

data/lib/charming/task_event.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  # TaskEvent represents background task completion. *name* is the declared task identifier, *value* carries
-  # the return result and *error* captures any exception raised during execution. The `error?` predicate
-  # simplifies error handling in controller handlers.
-  TaskEvent = Data.define(:name, :value, :error) do
-    def initialize(name:, value: nil, error: nil)
-      super
-    end
-
-    # Returns `true` when the task finished with a non-nil exception.
-    def error?
-      !error.nil?
-    end
-  end
-end

data/lib/charming/timer_event.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  # TimerEvent represents a timed dispatch from the runtime loop. *name* is the declared timer identifier;
-  # *now* is the monotonically rising clock value at emission for throttle comparisons.
-  TimerEvent = Data.define(:name, :now)
-end

data/lib/charming/ui/border.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  module UI
-    class Border
-      attr_reader :top_left, :top_right, :bottom_left, :bottom_right, :horizontal, :vertical
-
-      def initialize(corners:, edges:)
-        @top_left, @top_right, @bottom_left, @bottom_right = corners
-        @horizontal, @vertical = edges
-      end
-
-      def self.fetch(name)
-        STYLES.fetch(name.to_sym)
-      end
-    end
-
-    Border::STYLES = {
-      normal: Border.new(
-        corners: ["+", "+", "+", "+"], edges: ["-", "|"]
-      ),
-      rounded: Border.new(
-        corners: ["╭", "╮", "╰", "╯"], edges: ["─", "│"]
-      ),
-      thick: Border.new(
-        corners: ["┏", "┓", "┗", "┛"], edges: ["━", "┃"]
-      ),
-      double: Border.new(
-        corners: ["╔", "╗", "╚", "╝"], edges: ["═", "║"]
-      )
-    }.freeze
-  end
-end

data/lib/charming/ui/style.rb

@@ -1,244 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  module UI
-    class Style
-      ATTRIBUTES = {
-        bold: 1,
-        faint: 2,
-        italic: 3,
-        underline: 4,
-        reverse: 7,
-        strikethrough: 9
-      }.freeze
-
-      COLORS = {
-        black: 30,
-        red: 31,
-        green: 32,
-        yellow: 33,
-        blue: 34,
-        magenta: 35,
-        cyan: 36,
-        white: 37,
-        bright_black: 90,
-        bright_red: 91,
-        bright_green: 92,
-        bright_yellow: 93,
-        bright_blue: 94,
-        bright_magenta: 95,
-        bright_cyan: 96,
-        bright_white: 97
-      }.freeze
-
-      def initialize(options = {})
-        @options = {
-          attributes: [],
-          padding: [0, 0, 0, 0],
-          align: :left
-        }.merge(options)
-      end
-
-      def foreground(color)
-        with(foreground: color)
-      end
-      alias_method :fg, :foreground
-
-      def background(color)
-        with(background: color)
-      end
-      alias_method :bg, :background
-
-      ATTRIBUTES.each_key do |attribute|
-        define_method(attribute) do
-          with(attributes: (@options.fetch(:attributes) + [attribute]).uniq)
-        end
-      end
-
-      def padding(*values)
-        with(padding: expand_box_values(values))
-      end
-
-      def border(style = :normal, sides: nil, foreground: nil)
-        with(border: style, border_sides: sides, border_foreground: foreground)
-      end
-
-      def width(value)
-        with(width: value)
-      end
-
-      def height(value)
-        with(height: value)
-      end
-
-      def align(value)
-        with(align: value)
-      end
-
-      def render(value)
-        lines = apply_dimensions(value.to_s.lines(chomp: true))
-        lines = apply_padding(lines)
-        lines = apply_border(lines)
-        apply_ansi(lines.join("\n"))
-      end
-
-      private
-
-      def with(changes)
-        self.class.new(@options.merge(changes))
-      end
-
-      def apply_dimensions(lines)
-        content_width = target_content_width(lines)
-        dimensioned = lines.map { |line| align_line(fit_line(line, content_width), content_width) }
-        apply_height(dimensioned, content_width)
-      end
-
-      def target_content_width(lines)
-        explicit_width = @options[:width]
-        natural_width = lines.map { |line| Width.measure(line) }.max || 0
-        explicit_width || natural_width
-      end
-
-      def fit_line(line, width)
-        return line if Width.measure(line) <= width
-
-        UI.visible_slice(line, 0, width)
-      end
-
-      def apply_height(lines, width)
-        height = @options[:height]
-        return lines unless height
-
-        visible = lines.first(height)
-        visible + Array.new([height - visible.length, 0].max) { " " * width }
-      end
-
-      def apply_padding(lines)
-        top, right, bottom, left = @options.fetch(:padding)
-        inner_width = lines.map { |line| Width.measure(line) }.max || 0
-        empty = " " * (left + inner_width + right)
-        padded = lines.map do |line|
-          pad_line(line, inner_width, left, right)
-        end
-
-        Array.new(top, empty) + padded + Array.new(bottom, empty)
-      end
-
-      def apply_border(lines)
-        border_name = @options[:border]
-        return lines unless border_name
-
-        border = Border.fetch(border_name)
-        sides = Array(@options[:border_sides] || %i[top right bottom left]).map(&:to_sym)
-        width = lines.map { |line| Width.measure(line) }.max || 0
-        horizontal = border.horizontal * width
-        body = lines.map { |line| border_line(line, width, border, sides) }
-
-        [top_border(border, horizontal, sides), *body, bottom_border(border, horizontal, sides)].compact
-      end
-
-      def pad_line(line, inner_width, left, right)
-        (" " * left) + line + (" " * (inner_width - Width.measure(line) + right))
-      end
-
-      def border_line(line, width, border, sides)
-        left = sides.include?(:left) ? render_border(border.vertical) : ""
-        right = sides.include?(:right) ? render_border(border.vertical) : ""
-
-        "#{left}#{line}#{" " * (width - Width.measure(line))}#{right}"
-      end
-
-      def top_border(border, horizontal, sides)
-        return unless sides.include?(:top)
-        return render_border(horizontal) unless full_horizontal_border?(sides)
-
-        render_border("#{border.top_left}#{horizontal}#{border.top_right}")
-      end
-
-      def bottom_border(border, horizontal, sides)
-        return unless sides.include?(:bottom)
-        return render_border(horizontal) unless full_horizontal_border?(sides)
-
-        render_border("#{border.bottom_left}#{horizontal}#{border.bottom_right}")
-      end
-
-      def full_horizontal_border?(sides)
-        sides.include?(:left) && sides.include?(:right)
-      end
-
-      def render_border(value)
-        border_foreground = @options[:border_foreground]
-        return value unless border_foreground
-
-        Style.new(foreground: border_foreground, background: @options[:background]).render(value)
-      end
-
-      def apply_ansi(value)
-        codes = ansi_codes
-        return value if codes.empty?
-
-        start = "\e[#{codes.join(";")}m"
-        value.split("\n", -1).map { |line| "#{start}#{line.gsub("\e[0m", "\e[0m#{start}")}\e[0m" }.join("\n")
-      end
-
-      def ansi_codes
-        @options.fetch(:attributes).map { |attribute| ATTRIBUTES.fetch(attribute) } +
-          color_codes(@options[:foreground], foreground: true) +
-          color_codes(@options[:background], foreground: false)
-      end
-
-      def color_codes(color, foreground:)
-        return [] unless color
-        return indexed_color_code(color, foreground: foreground) if color.is_a?(Integer)
-        return named_color_code(color, foreground: foreground) if COLORS.key?(color.to_sym)
-        return truecolor_codes(color, foreground: foreground) if color.to_s.start_with?("#")
-
-        raise ArgumentError, "unknown color: #{color.inspect}"
-      end
-
-      def named_color_code(color, foreground:)
-        code = COLORS.fetch(color.to_sym)
-        [foreground ? code : code + 10]
-      end
-
-      def indexed_color_code(color, foreground:)
-        raise ArgumentError, "indexed color must be between 0 and 255" unless color.between?(0, 255)
-
-        [foreground ? 38 : 48, 5, color]
-      end
-
-      def truecolor_codes(color, foreground:)
-        hex = color.to_s.delete_prefix("#")
-        raise ArgumentError, "truecolor must be #rrggbb" unless hex.match?(/\A[0-9a-fA-F]{6}\z/)
-
-        [foreground ? 38 : 48, 2, hex[0..1].to_i(16), hex[2..3].to_i(16), hex[4..5].to_i(16)]
-      end
-
-      def align_line(line, width)
-        remaining = width - Width.measure(line)
-        return line if remaining <= 0
-
-        case @options.fetch(:align)
-        when :right
-          (" " * remaining) + line
-        when :center
-          left = remaining / 2
-          (" " * left) + line + (" " * (remaining - left))
-        else
-          line + (" " * remaining)
-        end
-      end
-
-      def expand_box_values(values)
-        case values.length
-        when 1 then [values[0], values[0], values[0], values[0]]
-        when 2 then [values[0], values[1], values[0], values[1]]
-        when 4 then values
-        else
-          raise ArgumentError, "padding expects 1, 2, or 4 values"
-        end
-      end
-    end
-  end
-end