chamomile-flourish 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5d26d2a333d6f0a962ffb7bf18af8b80424fdeac18262392e534fe4a2d65336f
+  data.tar.gz: 617a4eca7cbf2034c8921a293d44707295553400a368e306bfad3de228394635
+SHA512:
+  metadata.gz: 83b89f48310d72d22c5a22681f3c261af4213ca1fc6709bf6abc6ec6c03e3a64cc9cb0f8e7311002634e14968d2b72bc9133fd7fb390f7b73df10cfcfcd8ade7
+  data.tar.gz: f42c0446e12058d4565ff09efef8094ea45b8c15882bf1e90d610ae5a260c084814e725c3e3bbdc98c0bf284de8d2abf0417f004f9beb9b8abd81ef607093974

data/lib/flourish/align.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Flourish
+  module Align
+    class << self
+      def horizontal(lines, width, position)
+        lines.map do |line|
+          line_width = ANSI.printable_width(line)
+          gap = width - line_width
+          next line if gap <= 0
+
+          left_pad = (gap * position).round
+          right_pad = gap - left_pad
+          "#{" " * left_pad}#{line}#{" " * right_pad}"
+        end
+      end
+
+      def vertical(lines, height, position)
+        gap = height - lines.length
+        return lines if gap <= 0
+
+        top_pad = (gap * position).round
+        bottom_pad = gap - top_pad
+
+        result = []
+        top_pad.times { result << "" }
+        result.concat(lines)
+        bottom_pad.times { result << "" }
+        result
+      end
+    end
+  end
+end

data/lib/flourish/ansi.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Flourish
+  module ANSI
+    # Matches CSI sequences, OSC sequences, ESC charset/other sequences
+    ESCAPE_RE = /\e\[[0-9;]*[A-Za-z]|\e\][^\a\e]*(?:\a|\e\\)|\e[()][AB012]|\e./
+
+    class << self
+      def strip(str)
+        str.gsub(ESCAPE_RE, "")
+      end
+
+      def printable_width(str)
+        stripped = strip(str)
+        width = 0
+        stripped.each_char do |ch|
+          width += char_width(ch)
+        end
+        width
+      end
+
+      def height(str)
+        str.count("\n") + 1
+      end
+
+      def size(str)
+        return [0, 1] if str.empty?
+
+        lines = str.split("\n", -1)
+        w = lines.map { |line| printable_width(line) }.max || 0
+        [w, lines.length]
+      end
+
+      def extract_escape(chars, start)
+        return nil unless chars[start] == "\e"
+
+        i = start + 1
+        return nil if i >= chars.length
+
+        if chars[i] == "["
+          seq = +"\e["
+          i += 1
+          while i < chars.length && chars[i].match?(/[0-9;]/)
+            seq << chars[i]
+            i += 1
+          end
+          if i < chars.length && chars[i].match?(/[A-Za-z]/)
+            seq << chars[i]
+            return seq
+          end
+        end
+
+        nil
+      end
+
+      def track_sgr(active_sgr, seq)
+        if ["\e[0m", "\e[m"].include?(seq)
+          active_sgr.clear
+        elsif seq.match?(/\A\e\[\d/)
+          if active_sgr.empty?
+            active_sgr.replace(seq)
+          else
+            active_sgr.replace("#{active_sgr.delete_suffix("\e[0m")}#{seq}")
+          end
+        end
+      end
+
+      def sgr_open_after?(was_open, seq)
+        return false if ["\e[0m", "\e[m"].include?(seq)
+        return true if seq.match?(/\A\e\[\d/)
+
+        was_open
+      end
+
+      private
+
+      def char_width(ch)
+        cp = ch.ord
+        return 2 if cjk?(cp)
+        return 0 if cp < 32 || (cp >= 0x7F && cp < 0xA0)
+
+        1
+      end
+
+      def cjk?(cp)
+        cp.between?(0x1100, 0x115F) || # Hangul Jamo
+          cp == 0x2329 || cp == 0x232A || # Angle brackets
+          cp.between?(0x2E80, 0x303E) ||  # CJK Radicals..CJK Symbols
+          cp.between?(0x3040, 0x33BF) ||  # Hiragana..CJK Compatibility
+          cp.between?(0x3400, 0x4DBF) ||  # CJK Unified Ext A
+          cp.between?(0x4E00, 0xA4CF) ||  # CJK Unified..Yi Radicals
+          cp.between?(0xAC00, 0xD7A3) ||  # Hangul Syllables
+          cp.between?(0xF900, 0xFAFF) ||  # CJK Compatibility Ideographs
+          cp.between?(0xFE10, 0xFE6F) ||  # Vertical forms..Small forms
+          cp.between?(0xFF01, 0xFF60) ||  # Fullwidth forms
+          cp.between?(0xFFE0, 0xFFE6) ||  # Fullwidth signs
+          cp.between?(0x1F300, 0x1F9FF) || # Misc Symbols/Emoji
+          cp.between?(0x20000, 0x2FFFD) || # CJK Ext B..
+          cp.between?(0x30000, 0x3FFFD) # CJK Ext G..
+      end
+    end
+  end
+end

data/lib/flourish/border.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Flourish
+  BorderDef = Data.define(
+    :top, :bottom, :left, :right,
+    :top_left, :top_right, :bottom_left, :bottom_right,
+    :middle_left, :middle_right, :middle, :middle_top, :middle_bottom
+  )
+
+  module Border
+    NORMAL = BorderDef.new(
+      top: "─", bottom: "─", left: "│", right: "│",
+      top_left: "┌", top_right: "┐", bottom_left: "└", bottom_right: "┘",
+      middle_left: "├", middle_right: "┤", middle: "┼", middle_top: "┬", middle_bottom: "┴"
+    ).freeze
+
+    ROUNDED = BorderDef.new(
+      top: "─", bottom: "─", left: "│", right: "│",
+      top_left: "╭", top_right: "╮", bottom_left: "╰", bottom_right: "╯",
+      middle_left: "├", middle_right: "┤", middle: "┼", middle_top: "┬", middle_bottom: "┴"
+    ).freeze
+
+    THICK = BorderDef.new(
+      top: "━", bottom: "━", left: "┃", right: "┃",
+      top_left: "┏", top_right: "┓", bottom_left: "┗", bottom_right: "┛",
+      middle_left: "┣", middle_right: "┫", middle: "╋", middle_top: "┳", middle_bottom: "┻"
+    ).freeze
+
+    DOUBLE = BorderDef.new(
+      top: "═", bottom: "═", left: "║", right: "║",
+      top_left: "╔", top_right: "╗", bottom_left: "╚", bottom_right: "╝",
+      middle_left: "╠", middle_right: "╣", middle: "╬", middle_top: "╦", middle_bottom: "╩"
+    ).freeze
+
+    BLOCK = BorderDef.new(
+      top: "█", bottom: "█", left: "█", right: "█",
+      top_left: "█", top_right: "█", bottom_left: "█", bottom_right: "█",
+      middle_left: "█", middle_right: "█", middle: "█", middle_top: "█", middle_bottom: "█"
+    ).freeze
+
+    OUTER_HALF_BLOCK = BorderDef.new(
+      top: "▀", bottom: "▄", left: "▌", right: "▐",
+      top_left: "▛", top_right: "▜", bottom_left: "▙", bottom_right: "▟",
+      middle_left: "▌", middle_right: "▐", middle: "┼", middle_top: "▀", middle_bottom: "▄"
+    ).freeze
+
+    INNER_HALF_BLOCK = BorderDef.new(
+      top: "▄", bottom: "▀", left: "▐", right: "▌",
+      top_left: "▗", top_right: "▖", bottom_left: "▝", bottom_right: "▘",
+      middle_left: "▐", middle_right: "▌", middle: "┼", middle_top: "▄", middle_bottom: "▀"
+    ).freeze
+
+    HIDDEN = BorderDef.new(
+      top: " ", bottom: " ", left: " ", right: " ",
+      top_left: " ", top_right: " ", bottom_left: " ", bottom_right: " ",
+      middle_left: " ", middle_right: " ", middle: " ", middle_top: " ", middle_bottom: " "
+    ).freeze
+
+    ASCII = BorderDef.new(
+      top: "-", bottom: "-", left: "|", right: "|",
+      top_left: "+", top_right: "+", bottom_left: "+", bottom_right: "+",
+      middle_left: "+", middle_right: "+", middle: "+", middle_top: "+", middle_bottom: "+"
+    ).freeze
+
+    MARKDOWN = ASCII
+  end
+end

data/lib/flourish/color.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Flourish
+  module Color
+    def self.parse(value)
+      return NoColor.new if value.nil? || value == ""
+
+      return parse_hex(value) if value.is_a?(String) && value.start_with?("#")
+
+      code = value.to_i
+      return ANSIColor.new(code: code) if code.between?(0, 15)
+      return ANSI256Color.new(code: code) if code.between?(16, 255)
+
+      NoColor.new
+    end
+
+    def self.parse_hex(hex)
+      hex = hex.delete_prefix("#")
+      case hex.length
+      when 3
+        r = (hex[0] * 2).to_i(16)
+        g = (hex[1] * 2).to_i(16)
+        b = (hex[2] * 2).to_i(16)
+        TrueColor.new(r: r, g: g, b: b)
+      when 6
+        r = hex[0..1].to_i(16)
+        g = hex[2..3].to_i(16)
+        b = hex[4..5].to_i(16)
+        TrueColor.new(r: r, g: g, b: b)
+      else
+        NoColor.new
+      end
+    end
+
+    private_class_method :parse_hex
+
+    NoColor = Data.define do
+      def fg_sequence = nil
+      def bg_sequence = nil
+      def no_color? = true
+    end
+
+    ANSIColor = Data.define(:code) do
+      def fg_sequence
+        if code < 8
+          (30 + code).to_s
+        else
+          (90 + code - 8).to_s
+        end
+      end
+
+      def bg_sequence
+        if code < 8
+          (40 + code).to_s
+        else
+          (100 + code - 8).to_s
+        end
+      end
+
+      def no_color? = false
+    end
+
+    ANSI256Color = Data.define(:code) do
+      def fg_sequence
+        "38;5;#{code}"
+      end
+
+      def bg_sequence
+        "48;5;#{code}"
+      end
+
+      def no_color? = false
+    end
+
+    TrueColor = Data.define(:r, :g, :b) do
+      def fg_sequence
+        "38;2;#{r};#{g};#{b}"
+      end
+
+      def bg_sequence
+        "48;2;#{r};#{g};#{b}"
+      end
+
+      def no_color? = false
+    end
+
+    # Named ANSI color constants (0-15)
+    BLACK = ANSIColor.new(code: 0)
+    RED = ANSIColor.new(code: 1)
+    GREEN = ANSIColor.new(code: 2)
+    YELLOW = ANSIColor.new(code: 3)
+    BLUE = ANSIColor.new(code: 4)
+    MAGENTA = ANSIColor.new(code: 5)
+    CYAN = ANSIColor.new(code: 6)
+    WHITE = ANSIColor.new(code: 7)
+    BRIGHT_BLACK = ANSIColor.new(code: 8)
+    BRIGHT_RED = ANSIColor.new(code: 9)
+    BRIGHT_GREEN = ANSIColor.new(code: 10)
+    BRIGHT_YELLOW = ANSIColor.new(code: 11)
+    BRIGHT_BLUE = ANSIColor.new(code: 12)
+    BRIGHT_MAGENTA = ANSIColor.new(code: 13)
+    BRIGHT_CYAN = ANSIColor.new(code: 14)
+    BRIGHT_WHITE = ANSIColor.new(code: 15)
+  end
+end

data/lib/flourish/color_profile.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Flourish
+  module ColorProfile
+    TRUE_COLOR = :true_color
+    ANSI256 = :ansi256
+    ANSI = :ansi
+    NO_COLOR = :no_color
+
+    # ANSI256 to ANSI16 lookup table
+    ANSI256_TO_ANSI = [
+      0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, # 0-15: identity
+      0, 4, 4, 4, 12, 12,   # 16-21
+      2, 6, 4, 4, 12, 12,   # 22-27
+      2, 2, 6, 4, 12, 12,   # 28-33
+      2, 2, 2, 6, 12, 12,   # 34-39
+      10, 10, 10, 10, 14, 12, # 40-45
+      10, 10, 10, 10, 10, 14, # 46-51
+      1, 5, 4, 4, 12, 12,   # 52-57
+      3, 8, 4, 4, 12, 12,   # 58-63
+      2, 2, 6, 4, 12, 12,   # 64-69
+      2, 2, 2, 6, 12, 12,   # 70-75
+      10, 10, 10, 10, 14, 12, # 76-81
+      10, 10, 10, 10, 10, 14, # 82-87
+      1, 5, 4, 4, 12, 12,   # 88-93
+      3, 3, 8, 4, 12, 12,   # 94-99
+      2, 2, 2, 6, 12, 12,   # 100-105
+      2, 2, 2, 2, 6, 12,    # 106-111
+      10, 10, 10, 10, 14, 12, # 112-117
+      10, 10, 10, 10, 10, 14, # 118-123
+      1, 5, 5, 4, 12, 12,   # 124-129
+      3, 3, 8, 4, 12, 12,   # 130-135
+      3, 3, 3, 8, 12, 12,   # 136-141
+      2, 2, 2, 2, 6, 12,    # 142-147
+      10, 10, 10, 10, 14, 12, # 148-153
+      10, 10, 10, 10, 10, 14, # 154-159
+      9, 5, 5, 5, 13, 12,   # 160-165
+      3, 3, 8, 8, 12, 12,   # 166-171
+      3, 3, 3, 8, 12, 12,   # 172-177
+      3, 3, 3, 3, 8, 12,    # 178-183
+      11, 11, 10, 10, 14, 12, # 184-189
+      10, 10, 10, 10, 10, 14, # 190-195
+      9, 9, 5, 5, 13, 12,   # 196-201
+      9, 9, 9, 13, 13, 12,  # 202-207
+      3, 3, 3, 8, 8, 12,    # 208-213
+      3, 3, 3, 3, 8, 14,    # 214-219
+      11, 11, 11, 11, 7, 12, # 220-225
+      11, 11, 11, 11, 11, 15, # 226-231
+      0, 0, 0, 0, 0, 0,     # 232-237 (grayscale dark)
+      8, 8, 8, 8, 8, 8,     # 238-243
+      7, 7, 7, 7, 7, 7,     # 244-249
+      15, 15, 15, 15, 15, 15, # 250-255 (grayscale light)
+    ].freeze
+
+    class << self
+      def detect
+        return NO_COLOR if ENV.key?("NO_COLOR")
+
+        colorterm = ENV.fetch("COLORTERM", "")
+        return TRUE_COLOR if %w[truecolor 24bit].include?(colorterm)
+
+        term = ENV.fetch("TERM", "")
+        return ANSI256 if term.include?("256color")
+        return ANSI if term.include?("color") || term.include?("ansi")
+
+        ANSI
+      end
+
+      def downsample(color, target_profile)
+        return Color::NoColor.new if target_profile == NO_COLOR
+
+        case color
+        when Color::TrueColor
+          case target_profile
+          when TRUE_COLOR then color
+          when ANSI256 then truecolor_to_256(color)
+          when ANSI then ansi256_to_ansi(truecolor_to_256(color))
+          end
+        when Color::ANSI256Color
+          case target_profile
+          when TRUE_COLOR, ANSI256 then color
+          when ANSI then ansi256_to_ansi(color)
+          end
+        else # ANSIColor, NoColor, etc.
+          color
+        end
+      end
+
+      private
+
+      def truecolor_to_256(color)
+        # Check grayscale ramp first (232-255)
+        if color.r == color.g && color.g == color.b
+          return Color::ANSI256Color.new(code: 16) if color.r < 8
+          return Color::ANSI256Color.new(code: 231) if color.r > 248
+
+          gray_idx = ((color.r.to_f - 8) / 247 * 24).round
+          return Color::ANSI256Color.new(code: 232 + gray_idx)
+        end
+
+        # Map to 6x6x6 color cube (indices 16-231)
+        r_idx = (color.r.to_f / 255 * 5).round
+        g_idx = (color.g.to_f / 255 * 5).round
+        b_idx = (color.b.to_f / 255 * 5).round
+
+        cube_idx = 16 + (36 * r_idx) + (6 * g_idx) + b_idx
+
+        # Compare cube color distance vs nearest grayscale
+        cube_r = r_idx.positive? ? 55 + (r_idx * 40) : 0
+        cube_g = g_idx.positive? ? 55 + (g_idx * 40) : 0
+        cube_b = b_idx.positive? ? 55 + (b_idx * 40) : 0
+        cube_dist = color_distance(color.r, color.g, color.b, cube_r, cube_g, cube_b)
+
+        gray_avg = (color.r + color.g + color.b) / 3
+        gray_idx = ((gray_avg.to_f - 8) / 247 * 24).round.clamp(0, 23)
+        gray_val = 8 + (10 * gray_idx)
+        gray_dist = color_distance(color.r, color.g, color.b, gray_val, gray_val, gray_val)
+
+        if gray_dist < cube_dist
+          Color::ANSI256Color.new(code: 232 + gray_idx)
+        else
+          Color::ANSI256Color.new(code: cube_idx)
+        end
+      end
+
+      def ansi256_to_ansi(color)
+        idx = color.code.clamp(0, 255)
+        Color::ANSIColor.new(code: ANSI256_TO_ANSI[idx])
+      end
+
+      def color_distance(r1, g1, b1, r2, g2, b2)
+        ((r1 - r2)**2) + ((g1 - g2)**2) + ((b1 - b2)**2)
+      end
+    end
+  end
+end

data/lib/flourish/join.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Flourish
+  module Join
+    class << self
+      def horizontal(position, *strs)
+        strs = strs.flatten
+        return "" if strs.empty?
+
+        blocks = strs.map { |s| s.split("\n", -1) }
+        max_height = blocks.map(&:length).max
+
+        # Equalize heights using position for vertical alignment
+        blocks = blocks.map do |lines|
+          if lines.length < max_height
+            Align.vertical(lines, max_height, position)
+          else
+            lines
+          end
+        end
+
+        # Find max width of each block
+        widths = blocks.map do |lines|
+          lines.map { |l| ANSI.printable_width(l) }.max || 0
+        end
+
+        # Join line by line
+        (0...max_height).map do |row|
+          blocks.each_with_index.map do |lines, idx|
+            line = lines[row] || ""
+            # Pad all blocks except the last to their max width
+            if idx < blocks.length - 1
+              line_width = ANSI.printable_width(line)
+              pad = widths[idx] - line_width
+              pad.positive? ? "#{line}#{" " * pad}" : line
+            else
+              line
+            end
+          end.join
+        end.join("\n")
+      end
+
+      def vertical(position, *strs)
+        strs = strs.flatten
+        return "" if strs.empty?
+
+        blocks = strs.map { |s| s.split("\n", -1) }
+
+        # Find max width across all blocks
+        max_width = blocks.flat_map { |lines| lines.map { |l| ANSI.printable_width(l) } }.max || 0
+
+        # Align each block's lines horizontally
+        all_lines = blocks.flat_map do |lines|
+          Align.horizontal(lines, max_width, position)
+        end
+
+        all_lines.join("\n")
+      end
+    end
+  end
+end

data/lib/flourish/place.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Flourish
+  module Place
+    class << self
+      def place(width, height, h_pos, v_pos, str)
+        lines = str.split("\n", -1)
+
+        # Horizontal placement
+        lines = Align.horizontal(lines, width, h_pos)
+
+        # Vertical placement
+        lines = Align.vertical(lines, height, v_pos)
+
+        # Ensure all lines are padded to full width
+        lines.map do |line|
+          line_width = ANSI.printable_width(line)
+          pad = width - line_width
+          pad.positive? ? "#{line}#{" " * pad}" : line
+        end.join("\n")
+      end
+
+      def place_horizontal(width, pos, str)
+        lines = str.split("\n", -1)
+        Align.horizontal(lines, width, pos).join("\n")
+      end
+
+      def place_vertical(height, pos, str)
+        lines = str.split("\n", -1)
+        Align.vertical(lines, height, pos).join("\n")
+      end
+    end
+  end
+end