termplot 0.1.0

data/lib/termplot/renderer.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require "termplot/window"
+require "termplot/character_map"
+require "termplot/colors"
+
+module Termplot
+  class Renderer
+    attr_reader :cols, :rows
+
+    def initialize(cols: 80, rows: 20, debug: false)
+      # Default border size, right border allocation will change dynamically as
+      # data comes in to account for the length of the numbers to be printed in
+      # the axis ticks
+      @border_size = default_border_size
+      @cols = cols > min_cols ? cols : min_cols
+      @rows = rows > min_rows ? rows : min_rows
+      @window = Window.new(cols: @cols, rows: @rows)
+      @decimals = 2
+      @tick_spacing = 3
+      @debug = debug
+      @errors = []
+    end
+
+    def render(series)
+      window.clear
+      errors.clear
+
+      # Calculate width of right hand axis
+      calculate_axis_size(series)
+
+      # Points
+      points = build_points(series)
+      render_points(series, points)
+      window.cursor.reset_position
+
+      # Title bar
+      render_title(series)
+      window.cursor.reset_position
+
+      # Borders
+      render_borders
+      window.cursor.reset_position
+
+      # Draw axis
+      ticks = build_ticks(points)
+      render_axis(ticks)
+
+      # Flush window to screen
+      debug? ?
+        window.flush_debug :
+        window.flush
+
+      if errors.any?
+        window.print_errors(errors)
+      end
+    end
+
+    def inner_width
+      cols -  border_size.left - border_size.right
+    end
+
+    private
+    attr_reader :window, :border_size, :errors, :decimals, :tick_spacing
+
+    def debug?
+      @debug
+    end
+
+    def border_char_map
+      CharacterMap::DEFAULT
+    end
+
+    def inner_height
+      rows - border_size.top - border_size.bottom
+    end
+
+    # At minimum, 2 cols of inner_width for values
+    def min_cols
+      border_size.left + border_size.right + 2
+    end
+
+    # At minimum, 2 rows of inner_height for values
+    def min_rows
+      border_size.top + border_size.bottom + 2
+    end
+
+    Border = Struct.new(:top, :right, :bottom, :left)
+    def default_border_size
+      Border.new(2, 4, 1, 1)
+    end
+
+    # Axis size = length of the longest point value , formatted as a string to
+    # @decimals decimal places, + 2 for some extra buffer + 1 for the border
+    # itself.
+    def calculate_axis_size(series)
+      border_right = series.data.map { |n| n.round(decimals).to_s.length }.max
+      border_right += 3
+
+      # Clamp border_right at cols - 3 to prevent the renderer from crashing
+      # with very large numbers
+      if border_right > cols - 3
+        errors.push(Colors.yellow "Warning: Axis tick values have been clipped, consider using more columns with -c")
+        border_right = cols - 3
+      end
+
+      @border_size = Border.new(2, border_right, 1, 1)
+    end
+
+    Point = Struct.new(:x, :y, :value)
+    def build_points(series)
+      return [] if series.data.empty?
+      points =
+        series.data.last(inner_width).map.with_index do |p, x|
+          # Map from series Y range to inner height
+          y = map_value(p, [series.min, series.max], [0, inner_height - 1])
+
+          # Invert Y value since pixel Y is inverse of cartesian Y
+          y = border_size.top - 1 + inner_height - y.round
+
+          # Add padding for border width
+          Point.new(x + border_size.left, y, p.to_f)
+        end
+
+      points
+    end
+
+    Tick = Struct.new(:y, :label)
+    def build_ticks(points)
+      return [] if points.empty?
+      max_point = points.max_by(&:value)
+      min_point = points.min_by(&:value)
+      point_y_range = points.max_by(&:y).y - points.min_by(&:y).y
+      point_value_range = max_point.value - min_point.value
+      ticks = []
+      ticks.push Tick.new(max_point.y, format_label(max_point.value))
+
+      # Distribute ticks between min and max, maintaining spacinig as much as
+      # possible. tick_spacing is inclusive of the tick row itself.
+      unless max_point.value == min_point.value &&
+             (point_y_range - 2) > tick_spacing
+        num_ticks = (point_y_range - 2) / tick_spacing
+        num_ticks.times do |i|
+          tick_y = max_point.y + (i + 1) * tick_spacing
+          value = max_point.value - point_value_range * ((i + 1) * tick_spacing) / point_y_range
+          ticks.push Tick.new(tick_y, format_label(value))
+        end
+      end
+
+      ticks.push Tick.new(min_point.y, format_label(min_point.value))
+      ticks
+    end
+
+    # Map value from one range to another
+    def map_value(val, from_range, to_range)
+      orig_range = [1, (from_range[1] - from_range[0]).abs].max
+      new_range = [1, (to_range[1] - to_range[0]).abs].max
+
+      ((val.to_f - from_range[0]) / orig_range) * new_range + to_range[0]
+    end
+
+    def render_points(series, points)
+      # Render points
+      points.each_with_index do |point, i|
+        window.cursor.position = point.y * cols + point.x
+        if series.line_style[:extended]
+          prev_point = ((i - 1) >= 0) ? points[i-1] : nil
+          render_connected_line(series, prev_point, point)
+        else
+          window.write(colored(series, series.line_style[:point]))
+        end
+      end
+    end
+
+    def render_connected_line(series, prev_point, point)
+      if prev_point.nil? || (prev_point.y == point.y)
+        window.write(colored(series, series.line_style[:horz_top]))
+      elsif prev_point.y > point.y
+        diff = prev_point.y - point.y
+
+        window.write(colored(series, series.line_style[:top_left]))
+        window.cursor.down
+        window.cursor.back
+
+        (diff - 1).times do
+          window.write(colored(series, series.line_style[:vert_right]))
+          window.cursor.down
+          window.cursor.back
+        end
+
+        window.write(colored(series, series.line_style[:bot_right]))
+      elsif prev_point.y < point.y
+        diff = point.y - prev_point.y
+
+        window.write(colored(series, series.line_style[:bot_left]))
+        window.cursor.up
+        window.cursor.back
+
+        (diff - 1).times do
+          window.write(colored(series, series.line_style[:vert_left]))
+          window.cursor.up
+          window.cursor.back
+        end
+
+        window.write(colored(series, series.line_style[:top_right]))
+      end
+    end
+
+    def render_title(series)
+      legend_marker = colored(series, series.line_style[:point])
+      title = series.title
+
+      legend_position = [1, (border_size.left + 1 + inner_width) / 2 - (title.length + 2) / 2].max
+      if (title.length + 2 + legend_position) > cols
+        errors.push(Colors.yellow "Warning: Title has been clipped, consider using more rows with -r")
+        title = title[0..(cols - legend_position - 2)]
+      end
+
+      window.cursor.forward(legend_position)
+      window.write(legend_marker)
+      window.write(" ")
+      title.chars.each do |char|
+        window.write(char)
+      end
+    end
+
+    def render_borders
+      window.cursor.down(border_size.top - 1)
+      window.cursor.forward(border_size.left - 1)
+      window.write(border_char_map[:top_left])
+      inner_width.times { window.write(border_char_map[:horz_top]) }
+      window.write(border_char_map[:top_right])
+      window.cursor.forward(border_size.right - 1)
+
+      inner_height.times do |y|
+        window.cursor.forward(border_size.left - 1)
+        window.write(border_char_map[:vert_right])
+        window.cursor.forward(inner_width)
+        window.write(border_char_map[:vert_left])
+        window.cursor.forward(border_size.right - 1)
+      end
+
+      # Bottom border
+      # Jump to bottom left corner
+      window.cursor.forward(border_size.left - 1)
+      window.write(border_char_map[:bot_left])
+      inner_width.times { window.write(border_char_map[:horz_top]) }
+      window.write(border_char_map[:bot_right])
+    end
+
+    def render_axis(ticks)
+      window.cursor.down(border_size.top - 1)
+      window.cursor.forward(border_size.left + inner_width + 1)
+
+      # Render ticks
+      ticks.each do |tick|
+        window.cursor.row = tick.y
+        window.cursor.back
+        window.write(border_char_map[:tick_right])
+        tick.label.chars.each do |c|
+          window.write(c)
+        end
+        window.cursor.back(label_chars)
+      end
+    end
+
+    def format_label(num)
+      ("%.2f" % num.round(decimals))[0..label_chars - 1].ljust(label_chars, " ")
+    end
+
+    def label_chars
+      border_size.right - 2
+    end
+
+    def colored(series, text)
+      Colors.send(series.color, text)
+    end
+  end
+end

data/lib/termplot/series.rb

@@ -0,0 +1,37 @@
+module Termplot
+  class Series
+    attr_reader :title, :data, :min, :max, :range, :color, :line_style
+    attr_accessor :max_data_points
+
+    DEFAULT_COLOR = "red"
+    DEFAULT_LINE_STYLE = "line"
+
+    def initialize(max_data_points:, title: "Series", color: DEFAULT_COLOR, line_style: DEFAULT_LINE_STYLE)
+      @data = []
+      @max_data_points = max_data_points
+      @min = 0
+      @max = 0
+      @range = 0
+
+      @title = title
+      @color = Termplot::Colors.fetch(color, DEFAULT_COLOR)
+      @line_style = Termplot::CharacterMap::LINE_STYLES.fetch(
+        line_style,
+        Termplot::CharacterMap::LINE_STYLES[DEFAULT_LINE_STYLE]
+      )
+    end
+
+    def add_point(point)
+      @data.push(point)
+
+      while @data.length > max_data_points do
+        @data.shift
+      end
+
+      @min = data.min
+      @max = data.max
+      @range = (max - min).abs
+      @range = 1 if range.zero?
+    end
+  end
+end

data/lib/termplot/shell.rb

@@ -0,0 +1,31 @@
+require "termios"
+
+module Termplot
+  class Shell
+    class << self
+      attr_reader :termios_settings
+
+      CURSOR_HIDE = "\e[?25l"
+      CURSOR_SHOW = "\e[?25h"
+      def init
+        # Disable echo on stdout tty, prevents printing chars if you type in
+        # between rendering
+        @termios_settings = Termios.tcgetattr($stdout)
+        new_termios_settings = termios_settings.dup
+        new_termios_settings.c_lflag &= ~(Termios::ECHO)
+        Termios.tcsetattr($stdout, Termios::TCSAFLUSH, new_termios_settings)
+
+        print CURSOR_HIDE
+        at_exit { reset }
+        Signal.trap("INT") { exit(0) }
+      end
+
+      def reset
+        # Reset stdout tty to original settings
+        Termios.tcsetattr($stdout, Termios::TCSAFLUSH, termios_settings)
+
+        print CURSOR_SHOW
+      end
+    end
+  end
+end

data/lib/termplot/version.rb

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

data/lib/termplot/window.rb

@@ -0,0 +1,69 @@
+require "termplot/cursors/virtual_cursor"
+require "termplot/cursors/buffered_console_cursor"
+
+module Termplot
+  class Window
+    attr_reader :rows, :cols, :buffer
+    def initialize(cols:, rows:)
+      @rows = rows
+      @cols = cols
+      @buffer = Array.new(cols * rows) { CharacterMap::DEFAULT[:empty] }
+    end
+
+    def cursor
+      @cursor ||= VirtualCursor.new(self)
+    end
+
+    def console_cursor
+      # Console buffer has an extra rows - 1 to account for new line characters
+      # between rows
+      @console_cursor ||=
+        BufferedConsoleCursor.new(self, Array.new(cols * rows + rows - 1))
+    end
+
+    def size
+      rows * cols
+    end
+
+    def write(char)
+      buffer[cursor.position] = char
+      cursor.write(char)
+    end
+
+    def clear
+      cursor.reset_position
+      size.times { write CharacterMap::DEFAULT[:empty] }
+    end
+
+    def flush
+      console_cursor.clear_buffer
+      console_cursor.reset_position
+      buffer.each_slice(cols).with_index do |line, i|
+        line.each do |v|
+          console_cursor.write(v)
+        end
+        console_cursor.new_line
+      end
+      console_cursor.flush
+    end
+
+    def flush_debug(str = "Window")
+      padding = "-" * 10
+      puts "\n#{padding} #{str} #{padding}\n"
+      buffer.each_slice(cols).with_index do |line, y|
+        render_line = line.each_with_index.map do |c, x|
+          y * cols + x == cursor.position ? "𝥺" : c
+        end
+        print render_line
+        puts
+      end
+    end
+
+    # TODO: Refine later and include errors properly in the window
+    def print_errors(errors)
+      print errors.join(Termplot::ControlChars::NEWLINE)
+      print Termplot::ControlChars::NEWLINE
+      errors.length.times { print Termplot::ControlChars::UP }
+    end
+  end
+end

data/termplot.gemspec

@@ -0,0 +1,32 @@
+require_relative 'lib/termplot/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "termplot"
+  spec.version       = Termplot::VERSION
+  spec.authors       = ["Martin Nyaga"]
+  spec.email         = ["nyagamartin72@gmail.com"]
+
+  spec.summary       = %q{Plot time series charts in your terminal}
+  spec.description   = %q{Plot time series charts in your terminal}
+  spec.homepage      = "https://github.com/Martin-Nyaga/termplot"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/Martin-Nyaga/termplot" 
+  spec.metadata["changelog_uri"] = "https://github.com/Martin-Nyaga/termplot" 
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "bin"
+  spec.executables   = "termplot"
+  spec.require_paths = ["lib"]
+
+  # Dependencies
+  spec.add_runtime_dependency "ruby-termios", "~> 1.0"
+end