termchart 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8e5399b740269dde9e659e037b6b54d158e71c4828778f6077686e59d0409a7e
+  data.tar.gz: a4bb881eac513473fd08d2a9314dd9bfd18954b5931c546ee35955473614d490
+SHA512:
+  metadata.gz: '08a3561dca9546457c27d6515ade0a83c59587dbc5dd2deb39617980e4b5e9c201e4ea5700d97267ed0e58f0f7e8c44829e3e1c95b8de504b8cd2aa5c3f0a155'
+  data.tar.gz: 39bb6081e3eee076630fe3806e670fac5bb15440e542f29ca3be06632e043e06d7a806925318a76ee2cc05283b122866c7d0afb003c9e213785b33427cc1acd2

data/lib/termchart/bar.rb

@@ -0,0 +1,110 @@
+module Termchart
+  # Horizontal and vertical bar charts.
+  # Horizontal uses ▏▎▍▌▋▊▉█ eighths for sub-cell width.
+  # Vertical uses ▁▂▃▄▅▆▇█ eighths for sub-cell height.
+  class Bar
+    H_BLOCKS = [" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█"].freeze
+    V_BLOCKS = [" ", "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"].freeze
+
+    attr_accessor :width, :orientation
+
+    def initialize(width: 40, height: nil, orientation: :horizontal)
+      @width       = width
+      @height      = height  # only used for vertical
+      @orientation = orientation
+      @items       = []
+    end
+
+    def add(label, value, color: nil)
+      @items << { label: label.to_s, value: value.to_f, color: color }
+    end
+
+    def render
+      return "" if @items.empty?
+      @orientation == :horizontal ? render_horizontal : render_vertical
+    end
+
+    private
+
+    def render_horizontal
+      max_val = @items.map { |i| i[:value] }.max
+      max_val = 1.0 if max_val.zero?
+      label_w = @items.map { |i| i[:label].length }.max
+      val_w   = @items.map { |i| format_val(i[:value]).length }.max
+      bar_w   = @width - label_w - val_w - 4  # " │" + " " + value
+      bar_w   = 10 if bar_w < 10
+
+      lines = @items.map do |item|
+        frac   = item[:value] / max_val * bar_w
+        full   = frac.floor
+        eighth = ((frac - full) * 8).round.clamp(0, 8)
+        bar    = "█" * full
+        bar   += H_BLOCKS[eighth] if eighth > 0 && full < bar_w
+        pad    = bar_w - visible_len(bar)
+        pad    = 0 if pad < 0
+        bar_str = bar + " " * pad
+        bar_str = colorize(bar_str, item[:color]) if item[:color]
+        lbl = item[:label].ljust(label_w)
+        val = format_val(item[:value]).rjust(val_w)
+        "#{lbl} │#{bar_str} #{val}"
+      end
+      lines.join("\n")
+    end
+
+    def render_vertical
+      max_val = @items.map { |i| i[:value] }.max
+      max_val = 1.0 if max_val.zero?
+      h = @height || 15
+      col_w = [@items.map { |i| i[:label].length }.max, 3].max
+      cols = @items.map do |item|
+        frac   = item[:value] / max_val * h
+        full   = frac.floor
+        eighth = ((frac - full) * 8).round.clamp(0, 8)
+        column = []
+        h.times do |row|
+          row_from_bottom = h - 1 - row
+          if row_from_bottom < full
+            column << "█" * col_w
+          elsif row_from_bottom == full && eighth > 0
+            column << (V_BLOCKS[eighth] * col_w)
+          else
+            column << " " * col_w
+          end
+        end
+        column
+      end
+
+      lines = []
+      h.times do |row|
+        parts = cols.each_with_index.map do |col, i|
+          cell = col[row]
+          @items[i][:color] ? colorize(cell, @items[i][:color]) : cell
+        end
+        lines << parts.join(" ")
+      end
+      # Labels below
+      labels = @items.map { |i| i[:label].center(col_w) }.join(" ")
+      lines << labels
+      lines.join("\n")
+    end
+
+    def format_val(v)
+      v == v.to_i.to_f ? v.to_i.to_s : ("%.2f" % v)
+    end
+
+    def visible_len(str)
+      str.gsub(/\e\[[0-9;]*m/, "").length
+    end
+
+    def colorize(str, color)
+      code = case color
+             when Integer then "38;5;#{color}"
+             when /\A#?([0-9a-fA-F]{6})\z/
+               r, g, b = [$1].pack("H*").unpack("CCC")
+               "38;2;#{r};#{g};#{b}"
+             else "38;5;#{color}"
+             end
+      "\e[#{code}m#{str}\e[0m"
+    end
+  end
+end

data/lib/termchart/candle.rb

@@ -0,0 +1,125 @@
+module Termchart
+  # OHLC candlestick chart.
+  # Uses │ for wicks, █/▌ for bodies. Green (82) up, red (196) down.
+  # Y-axis labels on left.
+  class Candle
+    UP_COLOR   = 82   # green
+    DOWN_COLOR = 196  # red
+
+    attr_accessor :width, :height
+
+    def initialize(width: 60, height: 20)
+      @width  = width
+      @height = height
+      @data   = []
+    end
+
+    # Add OHLC data: array of hashes with keys :o, :h, :l, :c
+    def add(ohlc_data)
+      ohlc_data.each do |d|
+        @data << {
+          o: d[:o].to_f, h: d[:h].to_f,
+          l: d[:l].to_f, c: d[:c].to_f
+        }
+      end
+    end
+
+    def render
+      return "" if @data.empty?
+
+      data_min = @data.map { |d| d[:l] }.min
+      data_max = @data.map { |d| d[:h] }.max
+      data_range = data_max - data_min
+      data_range = 1.0 if data_range.zero?
+
+      # Y-axis label width
+      y_label_w = [format_num(data_max).length, format_num(data_min).length].max + 1
+      chart_w = @width - y_label_w
+      chart_w = 10 if chart_w < 10
+      chart_h = @height
+
+      # Decide how many candles to show (1 char width each, with gaps)
+      max_candles = chart_w / 2  # each candle takes 1 col + 1 gap
+      visible = @data.last(max_candles)
+
+      # Map price to row (0 = top = data_max, chart_h-1 = bottom = data_min)
+      price_to_row = ->(price) {
+        ((data_max - price) / data_range * (chart_h - 1)).round.clamp(0, chart_h - 1)
+      }
+
+      # Build grid
+      canvas = Canvas.new(chart_w, chart_h)
+
+      visible.each_with_index do |d, i|
+        col = i * 2  # 1 col candle, 1 col gap
+        next if col >= chart_w
+
+        up = d[:c] >= d[:o]
+        color = up ? UP_COLOR : DOWN_COLOR
+
+        high_row = price_to_row.call(d[:h])
+        low_row  = price_to_row.call(d[:l])
+        body_top = price_to_row.call([d[:o], d[:c]].max)
+        body_bot = price_to_row.call([d[:o], d[:c]].min)
+
+        # Draw wick above body
+        (high_row...body_top).each do |row|
+          canvas.set(col, row, "│", fg: color)
+        end
+
+        # Draw body
+        if body_top == body_bot
+          # Doji: single line
+          canvas.set(col, body_top, "─", fg: color)
+        else
+          (body_top..body_bot).each do |row|
+            canvas.set(col, row, "█", fg: color)
+          end
+        end
+
+        # Draw wick below body
+        ((body_bot + 1)..low_row).each do |row|
+          canvas.set(col, row, "│", fg: color)
+        end
+      end
+
+      chart_str = canvas.render
+      lines = chart_str.split("\n")
+
+      # Add Y-axis labels
+      result = lines.each_with_index.map do |line, row|
+        if row == 0
+          label = format_num(data_max).rjust(y_label_w - 1) + "┤"
+        elsif row == chart_h - 1
+          label = format_num(data_min).rjust(y_label_w - 1) + "┤"
+        elsif row == chart_h / 2
+          mid = data_min + data_range / 2.0
+          label = format_num(mid).rjust(y_label_w - 1) + "┤"
+        elsif row == chart_h / 4
+          q1 = data_max - data_range / 4.0
+          label = format_num(q1).rjust(y_label_w - 1) + "┤"
+        elsif row == chart_h * 3 / 4
+          q3 = data_min + data_range / 4.0
+          label = format_num(q3).rjust(y_label_w - 1) + "┤"
+        else
+          label = " " * (y_label_w - 1) + "│"
+        end
+        label + line
+      end
+
+      result.join("\n")
+    end
+
+    private
+
+    def format_num(v)
+      if v.abs >= 1000
+        "%.0f" % v
+      elsif v.abs >= 100
+        "%.1f" % v
+      else
+        "%.2f" % v
+      end
+    end
+  end
+end

data/lib/termchart/canvas.rb

@@ -0,0 +1,120 @@
+module Termchart
+  # Character grid where each cell has a character, fg color, and bg color.
+  # render() converts to an ANSI-colored string (rows joined by \n).
+  class Canvas
+    attr_reader :width, :height
+
+    def initialize(width, height)
+      @width  = width
+      @height = height
+      @cells  = Array.new(height) { Array.new(width) { [" ", nil, nil] } }
+    end
+
+    # Set a cell: char, optional fg/bg (256-color int or hex string)
+    def set(x, y, char, fg: nil, bg: nil)
+      return unless x >= 0 && x < @width && y >= 0 && y < @height
+      @cells[y][x] = [char, fg, bg]
+    end
+
+    def get(x, y)
+      return nil unless x >= 0 && x < @width && y >= 0 && y < @height
+      @cells[y][x]
+    end
+
+    def render
+      @cells.map { |row| render_row(row) }.join("\n")
+    end
+
+    private
+
+    def render_row(row)
+      out = +""
+      prev_fg = prev_bg = nil
+      row.each do |char, fg, bg|
+        if fg != prev_fg || bg != prev_bg
+          out << "\e[0m" if prev_fg || prev_bg
+          codes = []
+          codes << fg_code(fg) if fg
+          codes << bg_code(bg) if bg
+          out << "\e[#{codes.join(';')}m" unless codes.empty?
+          prev_fg = fg
+          prev_bg = bg
+        end
+        out << char
+      end
+      out << "\e[0m" if prev_fg || prev_bg
+      out
+    end
+
+    def fg_code(color)
+      case color
+      when Integer then "38;5;#{color}"
+      when /\A#?([0-9a-fA-F]{6})\z/
+        r, g, b = [$1].pack("H*").unpack("CCC")
+        "38;2;#{r};#{g};#{b}"
+      else "38;5;#{color}"
+      end
+    end
+
+    def bg_code(color)
+      case color
+      when Integer then "48;5;#{color}"
+      when /\A#?([0-9a-fA-F]{6})\z/
+        r, g, b = [$1].pack("H*").unpack("CCC")
+        "48;2;#{r};#{g};#{b}"
+      else "48;5;#{color}"
+      end
+    end
+  end
+
+  # Braille canvas: each terminal cell maps to a 2x4 dot grid.
+  # Pixel resolution = width*2 x height*4.
+  # Uses Unicode braille patterns U+2800..U+28FF.
+  class BrailleCanvas < Canvas
+    # Braille dot offsets: dot(px % 2, py % 4) maps to a bit
+    #   col0  col1
+    #   0x01  0x08   row0
+    #   0x02  0x10   row1
+    #   0x04  0x20   row2
+    #   0x40  0x80   row3
+    DOT_MAP = [
+      [0x01, 0x08],
+      [0x02, 0x10],
+      [0x04, 0x20],
+      [0x40, 0x80],
+    ].freeze
+
+    def initialize(width, height)
+      super
+      @dots = Array.new(height) { Array.new(width, 0) }
+    end
+
+    # Set a sub-cell dot. px range: 0..width*2-1, py range: 0..height*4-1
+    def set_dot(px, py, fg: nil)
+      cx = px / 2
+      cy = py / 4
+      return unless cx >= 0 && cx < @width && cy >= 0 && cy < @height
+      dx = px % 2
+      dy = py % 4
+      @dots[cy][cx] |= DOT_MAP[dy][dx]
+      # Store fg color on the cell
+      cell = get(cx, cy)
+      if cell
+        set(cx, cy, cell[0], fg: fg || cell[1], bg: cell[2])
+      end
+    end
+
+    def render
+      # Convert dot patterns to braille characters, then render as Canvas
+      @height.times do |cy|
+        @width.times do |cx|
+          pattern = @dots[cy][cx]
+          char = (0x2800 + pattern).chr(Encoding::UTF_8)
+          cell = get(cx, cy)
+          set(cx, cy, char, fg: cell ? cell[1] : nil, bg: cell ? cell[2] : nil)
+        end
+      end
+      super
+    end
+  end
+end

data/lib/termchart/line.rb

@@ -0,0 +1,136 @@
+module Termchart
+  # Braille line chart with Y-axis labels.
+  # Uses BrailleCanvas for 2x4 sub-cell dot resolution.
+  class Line
+    attr_accessor :width, :height
+
+    def initialize(width: 60, height: 20)
+      @width  = width
+      @height = height
+      @series = []
+    end
+
+    # Add a data series (array of numeric values)
+    def add(values, color: 82, label: nil)
+      @series << { values: values.map(&:to_f), color: color, label: label }
+    end
+
+    def render
+      return "" if @series.empty?
+
+      # Compute global min/max across all series
+      all_vals = @series.flat_map { |s| s[:values] }
+      data_min = all_vals.min
+      data_max = all_vals.max
+      data_range = data_max - data_min
+      data_range = 1.0 if data_range.zero?
+
+      # Reserve space for Y-axis labels
+      y_label_w = format_num(data_max).length + 1
+      chart_w = @width - y_label_w
+      chart_w = 10 if chart_w < 10
+      chart_h = @height
+
+      # Pixel dimensions (braille: 2 dots wide, 4 dots tall per cell)
+      px_w = chart_w * 2
+      px_h = chart_h * 4
+
+      canvas = BrailleCanvas.new(chart_w, chart_h)
+
+      @series.each do |series|
+        vals = series[:values]
+        n = vals.length
+        next if n < 2
+
+        # Map each value to pixel coordinates
+        points = vals.each_with_index.map do |v, i|
+          px = n == 1 ? 0 : (i.to_f / (n - 1) * (px_w - 1)).round
+          py = ((data_max - v) / data_range * (px_h - 1)).round.clamp(0, px_h - 1)
+          [px, py]
+        end
+
+        # Draw lines between consecutive points using Bresenham
+        (0...points.length - 1).each do |i|
+          x0, y0 = points[i]
+          x1, y1 = points[i + 1]
+          bresenham(x0, y0, x1, y1) do |px, py|
+            canvas.set_dot(px, py, fg: series[:color])
+          end
+        end
+      end
+
+      chart_str = canvas.render
+
+      # Add Y-axis labels
+      lines = chart_str.split("\n")
+      result = lines.each_with_index.map do |line, row|
+        if row == 0
+          label = format_num(data_max).rjust(y_label_w - 1) + "┤"
+        elsif row == chart_h - 1
+          label = format_num(data_min).rjust(y_label_w - 1) + "┤"
+        elsif row == chart_h / 2
+          mid = data_min + data_range / 2.0
+          label = format_num(mid).rjust(y_label_w - 1) + "┤"
+        else
+          label = " " * (y_label_w - 1) + "│"
+        end
+        label + line
+      end
+
+      # Legend line
+      if @series.any? { |s| s[:label] }
+        legend = @series.map do |s|
+          name = s[:label] || "data"
+          colorize("━━", s[:color]) + " " + name
+        end.join("  ")
+        result << " " * y_label_w + legend
+      end
+
+      result.join("\n")
+    end
+
+    private
+
+    def bresenham(x0, y0, x1, y1)
+      dx = (x1 - x0).abs
+      dy = -(y1 - y0).abs
+      sx = x0 < x1 ? 1 : -1
+      sy = y0 < y1 ? 1 : -1
+      err = dx + dy
+      loop do
+        yield x0, y0
+        break if x0 == x1 && y0 == y1
+        e2 = 2 * err
+        if e2 >= dy
+          err += dy
+          x0 += sx
+        end
+        if e2 <= dx
+          err += dx
+          y0 += sy
+        end
+      end
+    end
+
+    def format_num(v)
+      if v.abs >= 1000
+        "%.0f" % v
+      elsif v.abs >= 1
+        "%.1f" % v
+      else
+        "%.2f" % v
+      end
+    end
+
+    def colorize(str, color)
+      code = case color
+             when Integer then "38;5;#{color}"
+             when /\A#?([0-9a-fA-F]{6})\z/
+               r, g, b = [$1].pack("H*").unpack("CCC")
+               "38;2;#{r};#{g};#{b}"
+             else "38;5;#{color}"
+             end
+      "\e[#{code}m#{str}\e[0m"
+    end
+  end
+end

data/lib/termchart/spark.rb

@@ -0,0 +1,40 @@
+module Termchart
+  # Sparkline: maps values to 8 eighth-block characters ▁▂▃▄▅▆▇█
+  # Returns a single-line string (with optional ANSI color).
+  module Spark
+    TICKS = %w[▁ ▂ ▃ ▄ ▅ ▆ ▇ █].freeze
+
+    def self.render(values, color: nil)
+      return "" if values.nil? || values.empty?
+      values = values.map(&:to_f)
+      min = values.min
+      max = values.max
+      range = max - min
+      chars = values.map do |v|
+        idx = range.zero? ? 3 : ((v - min) / range * 7).round.clamp(0, 7)
+        TICKS[idx]
+      end
+      line = chars.join
+      color ? colorize(line, color) : line
+    end
+
+    private
+
+    def self.colorize(str, color)
+      code = case color
+             when Integer then "38;5;#{color}"
+             when Symbol  then "38;5;#{NAMED_COLORS[color] || 7}"
+             when /\A#?([0-9a-fA-F]{6})\z/
+               r, g, b = [$1].pack("H*").unpack("CCC")
+               "38;2;#{r};#{g};#{b}"
+             else "38;5;#{color}"
+             end
+      "\e[#{code}m#{str}\e[0m"
+    end
+
+    NAMED_COLORS = {
+      red: 196, green: 82, blue: 33, yellow: 226, cyan: 51,
+      magenta: 201, white: 255, gray: 245, orange: 208
+    }.freeze
+  end
+end

data/lib/termchart/version.rb

@@ -0,0 +1,3 @@
+module Termchart
+  VERSION = "0.1.0"
+end

data/lib/termchart.rb

@@ -0,0 +1,13 @@
+require_relative "termchart/version"
+require_relative "termchart/canvas"
+require_relative "termchart/spark"
+require_relative "termchart/line"
+require_relative "termchart/candle"
+require_relative "termchart/bar"
+
+module Termchart
+  # Convenience: Termchart.spark([1,3,5,2,8], color: :green)
+  def self.spark(values, color: nil)
+    Spark.render(values, color: color)
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: termchart
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Geir Isene
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-02-20 00:00:00.000000000 Z
+dependencies: []
+description: Render sparklines, line charts (braille), candlestick charts, and bar
+  charts as plain strings with ANSI color codes. Zero dependencies, pure Ruby.
+email: g@isene.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/termchart.rb
+- lib/termchart/bar.rb
+- lib/termchart/candle.rb
+- lib/termchart/canvas.rb
+- lib/termchart/line.rb
+- lib/termchart/spark.rb
+- lib/termchart/version.rb
+homepage: https://github.com/isene/termchart
+licenses:
+- Unlicense
+metadata:
+  source_code_uri: https://github.com/isene/termchart
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: Terminal charts with Unicode and ANSI colors
+test_files: []