charming 0.1.0

data/lib/charming/ui/style.rb

@@ -0,0 +1,244 @@
+# 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

data/lib/charming/ui/theme.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Charming
+  module UI
+    class Theme
+      BUILT_IN_ROOT = File.expand_path("themes", __dir__)
+
+      DEFAULT_TOKENS = {
+        text: {foreground: :bright_white},
+        title: {foreground: :bright_cyan, bold: true},
+        muted: {foreground: :bright_black},
+        border: {foreground: :bright_magenta},
+        selected: {reverse: true},
+        info: {foreground: :bright_cyan},
+        warn: {foreground: :yellow}
+      }.freeze
+
+      def self.default
+        @default ||= load_builtin("phosphor")
+      end
+
+      def self.load_file(path)
+        from_hash(JSON.parse(File.read(path)))
+      end
+
+      def self.load_builtin(name)
+        load_file(built_in_path(name))
+      end
+
+      def self.built_in_names
+        Dir.glob(File.join(BUILT_IN_ROOT, "*.json")).map { |path| File.basename(path, ".json") }.sort
+      end
+
+      def self.from_hash(value)
+        raise ArgumentError, "theme file must contain an object" unless value.is_a?(Hash)
+
+        styles = value.fetch("styles") do
+          raise ArgumentError, "theme file must contain styles"
+        end
+
+        palette = value.fetch("palette", {})
+        new(
+          resolve_palette_references(styles, palette),
+          background: resolve_background(value["background"], palette)
+        )
+      end
+
+      def self.resolve_background(value, palette)
+        return unless value
+
+        deep_resolve_colors(value, normalize_colors(palette))
+      end
+
+      def self.built_in_path(name)
+        slug = name.to_s
+        raise ArgumentError, "unknown built-in theme: #{name.inspect}" unless built_in_names.include?(slug)
+
+        File.join(BUILT_IN_ROOT, "#{slug}.json")
+      end
+
+      def self.resolve_palette_references(styles, palette)
+        palette = normalize_colors(palette)
+        deep_resolve_colors(styles, palette)
+      end
+
+      def self.deep_resolve_colors(value, palette)
+        case value
+        when Hash
+          value.transform_values { |item| deep_resolve_colors(item, palette) }
+        when Array
+          value.map { |item| deep_resolve_colors(item, palette) }
+        when String
+          palette.fetch(value, normalize_color(value) || value)
+        else
+          value
+        end
+      end
+
+      def self.normalize_colors(values)
+        values.transform_values { |value| normalize_color(value) }.compact
+      end
+
+      def self.normalize_color(value)
+        return unless value.is_a?(String)
+
+        case value
+        when /\A#([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])(?:[0-9a-fA-F])?\z/
+          "#{$1 * 2}#{$2 * 2}#{$3 * 2}".prepend("#")
+        when /\A#[0-9a-fA-F]{6}(?:[0-9a-fA-F]{2})?\z/
+          value[0, 7]
+        end
+      end
+
+      attr_reader :background
+
+      def initialize(tokens = {}, background: nil)
+        @tokens = symbolize_keys(tokens)
+        @background = background
+      end
+
+      def style(name)
+        spec = @tokens.fetch(name.to_sym) do
+          raise ArgumentError, "unknown theme token: #{name.inspect}"
+        end
+
+        build_style(spec)
+      end
+      alias_method :[], :style
+
+      def method_missing(name, ...)
+        return style(name) if @tokens.key?(name)
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @tokens.key?(name) || super
+      end
+
+      private
+
+      def build_style(spec)
+        return spec if spec.is_a?(Style)
+        return UI.style.foreground(spec) unless spec.is_a?(Hash)
+
+        apply_options(UI.style, symbolize_keys(spec))
+      end
+
+      def apply_options(base_style, spec)
+        styled = apply_colors(base_style, spec)
+        styled = apply_attributes(styled, spec)
+        apply_layout(styled, spec)
+      end
+
+      def apply_colors(base_style, spec)
+        styled = base_style
+        styled = styled.foreground(spec[:foreground] || spec[:fg]) if spec.key?(:foreground) || spec.key?(:fg)
+        styled = styled.background(spec[:background] || spec[:bg]) if spec.key?(:background) || spec.key?(:bg)
+        styled
+      end
+
+      def apply_attributes(base_style, spec)
+        Style::ATTRIBUTES.each_key.reduce(base_style) do |styled, attribute|
+          spec[attribute] ? styled.public_send(attribute) : styled
+        end
+      end
+
+      def apply_layout(base_style, spec)
+        styled = base_style
+        styled = styled.padding(*Array(spec[:padding])) if spec.key?(:padding)
+        styled = apply_border(styled, spec[:border]) if spec.key?(:border)
+        styled = styled.width(spec[:width]) if spec.key?(:width)
+        styled = styled.height(spec[:height]) if spec.key?(:height)
+        styled = styled.align(spec[:align].to_sym) if spec.key?(:align)
+        styled
+      end
+
+      def apply_border(base_style, border_spec)
+        return base_style.border(border_spec) unless border_spec.is_a?(Hash)
+
+        border_spec = symbolize_keys(border_spec)
+        base_style.border(
+          border_spec.fetch(:style, :normal),
+          sides: border_spec[:sides],
+          foreground: border_spec[:foreground] || border_spec[:fg]
+        )
+      end
+
+      def symbolize_keys(value)
+        value.each_with_object({}) do |(key, item), result|
+          result[key.to_sym] = item.is_a?(Hash) ? symbolize_keys(item) : item
+        end
+      end
+    end
+  end
+end

data/lib/charming/ui/themes/phosphor.json

@@ -0,0 +1,100 @@
+{
+  "name": "Phosphor",
+  "id": "phosphor",
+  "background": "background",
+  "palette": {
+    "bright": "#9FE8B0",
+    "muted": "#5A8A68",
+    "subtle": "#788E80",
+    "background": "#111A2C",
+    "selected": "#18233D",
+    "divider": "#2A3752",
+    "amber": "#FFB347",
+    "cyan": "#6FD0E3"
+  },
+  "styles": {
+    "text": {
+      "foreground": "bright",
+      "background": "background"
+    },
+    "muted": {
+      "foreground": "muted",
+      "background": "background"
+    },
+    "title": {
+      "foreground": "amber",
+      "background": "background",
+      "bold": true
+    },
+    "selected": {
+      "foreground": "bright",
+      "background": "selected",
+      "bold": true
+    },
+    "header": {
+      "foreground": "bright",
+      "background": "background",
+      "border": {
+        "style": "normal",
+        "sides": ["bottom"],
+        "foreground": "divider"
+      },
+      "padding": [0, 1]
+    },
+    "header_accent": {
+      "foreground": "amber",
+      "background": "background",
+      "bold": true
+    },
+    "sidebar": {
+      "background": "background",
+      "border": {
+        "style": "normal",
+        "sides": ["right"],
+        "foreground": "divider"
+      },
+      "padding": [1, 1]
+    },
+    "main": {
+      "foreground": "bright",
+      "background": "background",
+      "padding": [1, 2]
+    },
+    "footer": {
+      "foreground": "subtle",
+      "background": "background",
+      "border": {
+        "style": "normal",
+        "sides": ["top"],
+        "foreground": "divider"
+      },
+      "padding": [0, 1]
+    },
+    "modal": {
+      "foreground": "bright",
+      "background": "background",
+      "border": {
+        "style": "rounded",
+        "foreground": "amber"
+      },
+      "padding": [1, 2]
+    },
+    "palette_accent": {
+      "foreground": "amber",
+      "background": "background",
+      "bold": true
+    },
+    "border": {
+      "foreground": "divider",
+      "background": "background"
+    },
+    "info": {
+      "foreground": "cyan",
+      "background": "background"
+    },
+    "warn": {
+      "foreground": "amber",
+      "background": "background"
+    }
+  }
+}

data/lib/charming/ui/width.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "unicode/display_width"
+
+module Charming
+  module UI
+    # Width is a namespace for measuring and normalising the visual width of strings that may contain
+    # ANSI escape sequences. It delegates to `Unicode::DisplayWidth` while automatically stripping
+    # formatting codes so layout primitives can calculate exact character positions.
+    module Width
+      ANSI_PATTERN = /\e\[[0-9;]*m/
+
+      module_function
+
+      def measure(value)
+        Unicode::DisplayWidth.of(strip_ansi(value.to_s))
+      end
+
+      def strip_ansi(value)
+        value.to_s.gsub(ANSI_PATTERN, "")
+      end
+    end
+  end
+end