unicode_plot 0.0.1

data/lib/unicode_plot/renderer.rb

@@ -0,0 +1,234 @@
+module UnicodePlot
+  module BorderMaps
+    BORDER_SOLID = {
+      tl: "┌",
+      tr: "┐",
+      bl: "└",
+      br: "┘",
+      t:  "─",
+      l:  "│",
+      b:  "─",
+      r:  "│"
+    }.freeze
+
+    BORDER_BARPLOT = {
+      tl: "┌",
+      tr: "┐",
+      bl: "└",
+      br: "┘",
+      t:  " ",
+      l:  "┤",
+      b:  " ",
+      r:  " ",
+    }.freeze
+  end
+
+  BORDER_MAP = {
+    solid:   BorderMaps::BORDER_SOLID,
+    barplot: BorderMaps::BORDER_BARPLOT,
+  }.freeze
+
+  module BorderPrinter
+    include StyledPrinter
+
+    def print_border_top(out, padding, length, border=:solid, color: :light_black)
+      return if border == :none
+      b = BORDER_MAP[border]
+      print_styled(out, padding, b[:tl], b[:t] * length, b[:tr], color: color)
+    end
+
+    def print_border_bottom(out, padding, length, border=:solid, color: :light_black)
+      return if border == :none
+      b = BORDER_MAP[border]
+      print_styled(out, padding, b[:bl], b[:b] * length, b[:br], color: color)
+    end
+  end
+
+  class Renderer
+    include BorderPrinter
+
+    def self.render(out, plot)
+      new(plot).render(out)
+    end
+
+    def initialize(plot)
+      @plot = plot
+      @out = nil
+    end
+
+    attr_reader :plot
+    attr_reader :out
+
+    def render(out)
+      @out = out
+      init_render
+
+      render_top
+      render_rows
+      render_bottom
+    end
+
+    private
+
+    def render_top
+      # plot the title and the top border
+      print_title(@border_padding, plot.title, p_width: @border_length, color: :bold)
+      puts if plot.title_given?
+
+      if plot.show_labels?
+        topleft_str  = plot.decorations.fetch(:tl, "")
+        topleft_col  = plot.colors_deco.fetch(:tl, :light_black)
+        topmid_str   = plot.decorations.fetch(:t, "")
+        topmid_col   = plot.colors_deco.fetch(:t, :light_black)
+        topright_str = plot.decorations.fetch(:tr, "")
+        topright_col = plot.colors_deco.fetch(:tr, :light_black)
+
+        if topleft_str != "" || topright_str != "" || topmid_str != ""
+            topleft_len  = topleft_str.length
+            topmid_len   = topmid_str.length
+            topright_len = topright_str.length
+            print_styled(out, @border_padding, topleft_str, color: topleft_col)
+            cnt = (@border_length / 2.0 - topmid_len / 2.0 - topleft_len).round
+            pad = cnt > 0 ? " " * cnt : ""
+            print_styled(out, pad, topmid_str, color: topmid_col)
+            cnt = @border_length - topright_len - topleft_len - topmid_len + 2 - cnt
+            pad = cnt > 0 ? " " * cnt : ""
+            print_styled(out, pad, topright_str, "\n", color: topright_col)
+        end
+      end
+
+      print_border_top(out, @border_padding, @border_length, plot.border)
+      print(" " * @max_len_r, @plot_padding, "\n")
+    end
+
+    # render all rows
+    def render_rows
+      (0 ... plot.n_rows).each {|row| render_row(row) }
+    end
+
+    def render_row(row)
+      # Current labels to left and right of the row and their length
+      left_str  = plot.labels_left.fetch(row, "")
+      left_col  = plot.colors_left.fetch(row, :light_black)
+      right_str = plot.labels_right.fetch(row, "")
+      right_col = plot.colors_right.fetch(row, :light_black)
+      left_len  = left_str.length
+      right_len = right_str.length
+
+      unless color?(out)
+        left_str  = nocolor_string(left_str)
+        right_str = nocolor_string(right_str)
+      end
+
+      # print left annotations
+      print(" " * plot.margin)
+      if plot.show_labels?
+        if row == @y_lab_row
+          # print ylabel
+          print_styled(out, plot.ylabel, color: :normal)
+          print(" " * (@max_len_l - plot.ylabel_length - left_len))
+        else
+          # print padding to fill ylabel length
+          print(" " * (@max_len_l - left_len))
+        end
+        # print the left annotation
+        print_styled(out, left_str, color: left_col)
+      end
+
+      # print left border
+      print_styled(out, @plot_padding, @b[:l], color: :light_black)
+
+      # print canvas row
+      plot.print_row(out, row)
+
+      #print right label and padding
+      print_styled(out, @b[:r], color: :light_black)
+      if plot.show_labels?
+        print(@plot_padding)
+        print_styled(out, right_str, color: right_col)
+        print(" " * (@max_len_r - right_len))
+      end
+      puts
+    end
+
+    def render_bottom
+      # draw bottom border and bottom labels
+      print_border_bottom(out, @border_padding, @border_length, plot.border)
+      print(" " * @max_len_r, @plot_padding)
+      if plot.show_labels?
+        botleft_str  = plot.decorations.fetch(:bl, "")
+        botleft_col  = plot.colors_deco.fetch(:bl, :light_black)
+        botmid_str   = plot.decorations.fetch(:b, "")
+        botmid_col   = plot.colors_deco.fetch(:b, :light_black)
+        botright_str = plot.decorations.fetch(:br, "")
+        botright_col = plot.colors_deco.fetch(:br, :light_black)
+
+        if botleft_str != "" || botright_str != "" || botmid_str != ""
+          puts
+          botleft_len  = botleft_str.length
+          botmid_len   = botmid_str.length
+          botright_len = botright_str.length
+          print_styled(out, @border_padding, botleft_str, color: botleft_col)
+          cnt = (@border_length / 2.0 - botmid_len / 2.0 - botleft_len).round
+          pad = cnt > 0 ? " " * cnt : ""
+          print_styled(out, pad, botmid_str, color: botmid_col)
+          cnt = @border_length - botright_len - botleft_len - botmid_len + 2 - cnt
+          pad = cnt > 0 ? " " * cnt : ""
+          print_styled(out, pad, botright_str, color: botright_col)
+        end
+
+        # abuse the print_title function to print the xlabel. maybe refactor this
+        puts if plot.xlabel_given?
+        print_title(@border_padding, plot.xlabel, p_width: @border_length)
+      end
+    end
+
+    def init_render
+      @b = BORDER_MAP[plot.border]
+      @border_length = plot.n_columns
+
+      # get length of largest strings to the left and right
+      @max_len_l = plot.show_labels? && !plot.labels_left.empty? ?
+        plot.labels_left.each_value.map {|l| l.to_s.length }.max :
+        0
+      @max_len_r = plot.show_labels? && !plot.labels_right.empty? ?
+        plot.labels_right.each_value.map {|l| l.to_s.length }.max :
+        0
+      if plot.show_labels? && plot.ylabel_given?
+        @max_len_l += plot.ylabel_length + 1
+      end
+
+      # offset where the plot (incl border) begins
+      @plot_offset = @max_len_l + plot.margin + plot.padding
+
+      # padding-string from left to border
+      @plot_padding = " " * plot.padding
+
+      # padding-string between labels and border
+      @border_padding = " " * @plot_offset
+
+      # compute position of ylabel
+      @y_lab_row = (plot.n_rows / 2.0).round
+    end
+
+    def print_title(padding, title, p_width: 0, color: :normal)
+      return unless title && title != ""
+      offset = (p_width / 2.0 - title.length / 2.0).round
+      offset = [offset, 0].max
+      tpad = " " * offset
+      print_styled(out, padding, tpad, title, color: color)
+    end
+
+    def print(*args)
+      out.print(*args)
+    end
+
+    def puts(*args)
+      out.puts(*args)
+    end
+
+    def nocolor_string(str)
+      str.to_s.gsub(/\e\[[0-9]+m/, "")
+    end
+  end
+end

data/lib/unicode_plot/styled_printer.rb

@@ -0,0 +1,91 @@
+module UnicodePlot
+  module StyledPrinter
+    TEXT_COLORS = {
+      black:         "\033[30m",
+      red:           "\033[31m",
+      green:         "\033[32m",
+      yellow:        "\033[33m",
+      blue:          "\033[34m",
+      magenta:       "\033[35m",
+      cyan:          "\033[36m",
+      white:         "\033[37m",
+      gray:          "\033[90m",
+      light_black:   "\033[90m",
+      light_red:     "\033[91m",
+      light_green:   "\033[92m",
+      light_yellow:  "\033[93m",
+      light_blue:    "\033[94m",
+      light_magenta: "\033[95m",
+      light_cyan:    "\033[96m",
+      normal:        "\033[0m",
+      default:       "\033[39m",
+      bold:          "\033[1m",
+      underline:     "\033[4m",
+      blink:         "\033[5m",
+      reverse:       "\033[7m",
+      hidden:        "\033[8m",
+      nothing:       "",
+    }
+
+    0.upto(255) do |i|
+      TEXT_COLORS[i] = "\033[38;5;#{i}m"
+    end
+
+    TEXT_COLORS.freeze
+
+    DISABLE_TEXT_STYLE = {
+      bold:      "\033[22m",
+      underline: "\033[24m",
+      blink:     "\033[25m",
+      reverse:   "\033[27m",
+      hidden:    "\033[28m",
+      normal:    "",
+      default:   "",
+      nothing:   "",
+    }.freeze
+
+    COLOR_ENCODE = {
+      normal:  0b000,
+      blue:    0b001,
+      red:     0b010,
+      magenta: 0b011,
+      green:   0b100,
+      cyan:    0b101,
+      yellow:  0b110,
+      white:   0b111
+    }.freeze
+
+    COLOR_DECODE = COLOR_ENCODE.map {|k, v| [v, k] }.to_h.freeze
+
+    def print_styled(out, *args, bold: false, color: :normal)
+      return out.print(*args) unless color?(out)
+
+      str = StringIO.open {|sio| sio.print(*args); sio.close; sio.string }
+      color = :nothing if bold && color == :bold
+      enable_ansi = TEXT_COLORS.fetch(color, TEXT_COLORS[:default]) +
+                    (bold ? TEXT_COLORS[:bold] : "")
+      disable_ansi = (bold ? DISABLE_TEXT_STYLE[:bold] : "") +
+                     DISABLE_TEXT_STYLE.fetch(color, TEXT_COLORS[:default])
+      first = true
+      StringIO.open do |sio|
+        str.each_line do |line|
+          sio.puts unless first
+          first = false
+          continue if line.empty?
+          sio.print(enable_ansi, line, disable_ansi)
+        end
+        sio.close
+        out.print(sio.string)
+      end
+    end
+
+    def print_color(out, color, *args)
+      color = COLOR_DECODE[color]
+      print_styled(out, *args, color: color)
+    end
+
+    def color?(out)
+      out&.tty? || false
+    end
+  end
+end

data/lib/unicode_plot/value_transformer.rb

@@ -0,0 +1,43 @@
+module UnicodePlot
+  module ValueTransformer
+    PREDEFINED_TRANSFORM_FUNCTIONS = {
+      log: Math.method(:log),
+      ln: Math.method(:log),
+      log10: Math.method(:log10),
+      lg: Math.method(:log10),
+      log2: Math.method(:log2),
+      lb: Math.method(:log2),
+    }.freeze
+
+    def transform_values(func, values)
+      return values unless func
+
+      unless func.respond_to?(:call)
+        func = PREDEFINED_TRANSFORM_FUNCTIONS[func]
+        unless func.respond_to?(:call)
+          raise ArgumentError, "func must be callable"
+        end
+      end
+
+      case values
+      when Numeric
+        func.(values)
+      else
+        values.map(&func)
+      end
+    end
+
+    module_function def transform_name(func, basename="")
+      return basename unless func
+      case func
+      when String, Symbol
+        name = func
+      when ->(f) { f.respond_to?(:name) }
+        name = func.name
+      else
+        name = "custom"
+      end
+      "#{basename} [#{name}]"
+    end
+  end
+end

data/lib/unicode_plot/version.rb

@@ -0,0 +1,9 @@
+module UnicodePlot
+  VERSION = "0.0.1"
+
+  module Version
+    numbers, TAG = VERSION.split("-", 2)
+    MAJOR, MINOR, MICRO = numbers.split(".", 3).map(&:to_i)
+    STRING = VERSION
+  end
+end

data/test/helper.rb

@@ -0,0 +1,2 @@
+require_relative "helper/fixture"
+require_relative "helper/with_term"

data/test/helper/fixture.rb

@@ -0,0 +1,14 @@
+require 'pathname'
+
+module Helper
+  module Fixture
+    def fixture_dir
+      test_dir = Pathname(File.expand_path("../..", __FILE__))
+      test_dir.join("fixtures")
+    end
+
+    def fixture_path(*components)
+      fixture_dir.join(*components)
+    end
+  end
+end

data/test/helper/with_term.rb

@@ -0,0 +1,23 @@
+require 'stringio'
+
+module Helper
+  module WithTerm
+    def with_term(tty=true)
+      sio = StringIO.new
+      def sio.tty?; true; end if tty
+
+      orig_stdout, $stdout = $stdout, sio
+      orig_env = ENV.to_h.dup
+      ENV['TERM'] = 'xterm-256color'
+
+      result = yield
+      sio.close
+
+      [result, sio.string]
+    ensure
+      $stdout.close
+      $stdout = orig_stdout
+      ENV.replace(orig_env) if orig_env
+    end
+  end
+end

data/test/run-test.rb

@@ -0,0 +1,12 @@
+base_dir = File.expand_path("../..", __FILE__)
+lib_dir = File.join(base_dir, "lib")
+test_dir = File.join(base_dir, "test")
+
+$LOAD_PATH.unshift(lib_dir)
+
+require "test/unit"
+require "unicode_plot"
+
+require_relative "helper"
+
+exit Test::Unit::AutoRunner.run(true, test_dir)

data/test/test-barplot.rb

@@ -0,0 +1,59 @@
+class BarplotTest < Test::Unit::TestCase
+  include Helper::Fixture
+  include Helper::WithTerm
+
+  sub_test_case("UnicodePlot.barplot") do
+    sub_test_case("print to tty") do
+      test("the output is colored") do
+        data = { bar: 23, foo: 37 }
+        plot = UnicodePlot.barplot(data: data)
+        _, output = with_term do
+          plot.render($stdout)
+        end
+        assert_equal(fixture_path("barplot/default.txt").read,
+                     output)
+      end
+    end
+
+    sub_test_case("print to non-tty IO") do
+      test("the output is not colored") do
+        data = { bar: 23, foo: 37 }
+        plot = UnicodePlot.barplot(data: data)
+        output = StringIO.open do |sio|
+          sio.print(plot)
+          sio.close
+          sio.string
+        end
+        assert_equal(fixture_path("barplot/nocolor.txt").read,
+                     output)
+      end
+    end
+
+    sub_test_case("xscale: :log10") do
+      test("default") do
+        plot = UnicodePlot.barplot(
+          [:a, :b, :c, :d, :e],
+          [0, 1, 10, 100, 1000],
+          title: "Logscale Plot",
+          xscale: :log10
+        )
+        _, output = with_term { plot.render($stdout) }
+        assert_equal(fixture_path("barplot/log10.txt").read,
+                     output)
+      end
+
+      test("with custom label") do
+        plot = UnicodePlot.barplot(
+          [:a, :b, :c, :d, :e],
+          [0, 1, 10, 100, 1000],
+          title: "Logscale Plot",
+          xlabel: "custom label",
+          xscale: :log10
+        )
+        _, output = with_term { plot.render($stdout) }
+        assert_equal(fixture_path("barplot/log10_label.txt").read,
+                     output)
+      end
+    end
+  end
+end