charming 0.1.0 → 0.1.2

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

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/generators/app_generator/app_spec_templates.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  module Generators
-    class AppGenerator
-      module AppSpecTemplates
-        def spec_model
-          %(# frozen_string_literal: true
-
-require "#{app_name.snake_name}"
-
-RSpec.describe #{app_name.class_name}::HomeModel do
-  describe "#title" do
-    it "has the correct default string value" do
-      instance = described_class.new
-      expect(instance.title).to eq("#{app_name.class_name}")
-    end
-
-    it "accepts overridden title values" do
-      instance = described_class.new(title: "Alternative")
-      expect(instance.title).to eq("Alternative")
-    end
-  end
-end
-)
-        end
-
-        def spec_controller
-          %(# frozen_string_literal: true
-
-require "#{app_name.snake_name}"
-
-RSpec.describe #{app_name.class_name}::HomeController do
-  let(:application) { #{app_name.class_name}::Application.new }
-
-  subject(:controller) { described_class.new(application: application) }
-
-  describe "#show" do
-    it "renders the view with the model" do
-      response = controller.dispatch(:show)
-
-      expect(response).to respond_to(:body)
-    end
-  end
-end
-)
-        end
-
-        def spec_view
-          %(# frozen_string_literal: true
-
-require "#{app_name.snake_name}"
-
-RSpec.describe #{app_name.class_name}::HomeView do
-  describe "#render" do
-    it "renders the model title" do
-      view = described_class.new(
-         home: double(title: "#{app_name.class_name}")
-       )
-
-      expect(view.render).to include("#{app_name.class_name}")
-    end
-  end
-end
-)
-        end
-
-        def spec_component
-          %(# frozen_string_literal: true
-
-require "#{app_name.snake_name}"
-
-RSpec.describe #{app_name.class_name}::AppFrameComponent do
-  describe "#render" do
-    it "returns a string" do
-      component = described_class.new(title: "#{app_name.class_name}")
-      expect(component.render).to be_a(String)
-    end
-  end
-end
-)
-        end
-      end
-    end
-  end
-end

data/lib/charming/generators/app_generator/basic_templates.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  module Generators
-    class AppGenerator
-      module BasicTemplates
-        def gemfile
-          %(# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-gemspec
-)
-        end
-
-        def rakefile
-          %(# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-)
-        end
-
-        def readme
-          %(# #{name.class_name}
-
-A Charming terminal user interface.
-
-Run it with:
-
-```sh
-bundle exec #{name.snake_name}
-```
-)
-        end
-
-        def gemspec
-          %(# frozen_string_literal: true
-
-require_relative "lib/#{name.snake_name}/version"
-
-Gem::Specification.new do |spec|
-#{gemspec_attributes}
-#{gemspec_dependencies}
-end
-)
-        end
-
-        def gemspec_attributes
-          %(  spec.name = "#{name.snake_name}"
-  spec.version = #{name.class_name}::VERSION
-  spec.summary = "A Charming terminal user interface."
-  spec.authors = ["TODO: Your name"]
-  spec.email = ["TODO: Your email"]
-  spec.files = Dir.glob("{app,config,exe,lib}/**/*") + %w[README.md]
-  spec.bindir = "exe"
-  spec.executables = ["#{name.snake_name}"]
-  spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 4.0.0"
-  spec.metadata["rubygems_mfa_required"] = "true")
-        end
-
-        def gemspec_dependencies
-          %(
-  spec.add_dependency "charming")
-        end
-      end
-    end
-  end
-end