termplot 0.1.0

data/lib/termplot.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "termplot/version"
+require "termplot/cli"
+
+module Termplot
+end
+
+

data/lib/termplot/character_map.rb

@@ -0,0 +1,55 @@
+module Termplot
+  module CharacterMap
+    LINE = {
+      empty:      " ",
+      point:      "─",
+      vert_left:  "│",
+      vert_right: "│",
+      horz_top:   "─",
+      horz_bot:   "─",
+      bot_left:   "└",
+      top_right:  "┐",
+      top_left:   "┌",
+      bot_right:  "┘",
+      tick_right: "┤",
+      extended:   true
+    }
+    DEFAULT = LINE
+
+    HEAVY_LINE = DEFAULT.merge(
+      point:      "━",
+      vert_left:  "┃",
+      vert_right: "┃",
+      horz_top:   "━",
+      horz_bot:   "━",
+      bot_left:   "┗",
+      top_right:  "┓",
+      top_left:   "┏",
+      bot_right:  "┛",
+      tick_right: "┫"
+    )
+
+    BASIC = {
+      empty:      " ",
+      point:      "•",
+      extended:   false
+    }
+    DOTS = BASIC
+
+    X = BASIC.merge(
+      point: "x"
+    )
+
+    STAR = BASIC.merge(
+      point: "*"
+    )
+
+    LINE_STYLES = {
+      "line"       => LINE,
+      "heavy-line" => HEAVY_LINE,
+      "dot"        => DOTS,
+      "star"       => STAR,
+      "x"          => X
+    }
+  end
+end

data/lib/termplot/cli.rb

@@ -0,0 +1,59 @@
+require "optparse"
+require "termplot/consumer"
+
+module Termplot
+  class CLI
+    def self.run
+      opts = self.parse_options
+      Consumer.new(**opts).run
+    end
+
+    private
+    def self.parse_options
+      options = {
+        rows: 19,
+        cols: 80,
+        title: "Series",
+        line_style: "line",
+        color: "red",
+        debug: false
+      }
+      OptionParser.new do |opts|
+        opts.banner = "Usage: termplot [OPTIONS]"
+
+        opts.on("-rROWS", "--rows ROWS", "Number of rows in the chart window (default: 19)") do |v|
+          options[:rows] = v.to_i
+        end
+
+        opts.on("-cCOLS", "--cols COLS", "Number of cols in the chart window (default: 80)") do |v|
+          options[:cols] = v.to_i
+        end
+
+        opts.on("-tTITLE", "--title TITLE", "Title of the series (default: Series)") do |v|
+          options[:title] = v
+        end
+
+        opts.on("--line-style STYLE", "Line style. Options are: line [default], heavy-line, dot, star, x") do |v|
+          options[:line_style] = v.downcase
+        end
+
+        opts.on("--color COLOR", "Series color, specified as ansi 16-bit color name",
+                "(i.e. black, red [default], green, yellow, blue, magenta, cyan, white)",
+                "with light versions specified as light_{color}") do |v|
+          options[:color] = v.downcase
+        end
+
+        opts.on("-d", "--debug", "Enable debug mode, Logs window data to stdout instead of rendering") do |v|
+          options[:debug] = v
+        end
+
+        opts.on("-h", "--help", "Display this help message") do
+          puts opts
+          exit(0)
+        end
+
+      end.parse!
+      options
+    end
+  end
+end

data/lib/termplot/colors.rb

@@ -0,0 +1,55 @@
+module Termplot
+  class Colors
+    class << self
+      COLORS = {
+        black:         0,
+        light_black:   60,
+        red:           1,
+        light_red:     61,
+        green:         2,
+        light_green:   62,
+        yellow:        3,
+        light_yellow:  63,
+        blue:          4,
+        light_blue:    64,
+        magenta:       5,
+        light_magenta: 65,
+        cyan:          6,
+        light_cyan:    66,
+        white:         7,
+        light_white:   67,
+        default:       9
+      }
+
+      MODES = {
+        default:   0,
+        bold:      1,
+        italic:    3,
+        underline: 4,
+        blink:     5,
+        swap:      7,
+        hide:      8
+      }
+
+      COLORS.each do |(color, code)|
+        define_method(color) do |str|
+          escape_color(color) + str + escape_mode(:default)
+        end
+      end
+
+      def fetch(color, default)
+        COLORS.key?(color.to_sym) ? color.to_sym : default.to_sym
+      end
+
+      private
+
+      def escape_color(color)
+        "\e[#{COLORS[color] + 30}m"
+      end
+
+      def escape_mode(mode)
+        "\e[#{MODES[mode]}m"
+      end
+    end
+  end
+end

data/lib/termplot/consumer.rb

@@ -0,0 +1,71 @@
+require "termplot/series"
+require "termplot/renderer"
+require "termplot/shell"
+
+module Termplot
+  class Consumer
+    attr_reader :series, :renderer
+
+    def initialize(cols:, rows:, title:, line_style:, color:, debug:)
+      @renderer = Renderer.new(
+        cols: cols,
+        rows: rows,
+        debug: debug
+      )
+      @series = Series.new(
+        title: title,
+        max_data_points: renderer.inner_width,
+        line_style: line_style,
+        color: color,
+      )
+    end
+
+    def run
+      Shell.init
+      queue = Queue.new
+
+      # Consumer thread will process and render any available input in the
+      # queue. If samples are available faster than it can render, multiple
+      # samples will be shifted from the queue so they can be rendered at once.
+      # If no samples are available but stdin is open, it will sleep until
+      # woken to render new input.
+      consumer = Thread.new do
+        while !queue.closed?
+          num_samples = queue.size
+          if num_samples == 0
+            Thread.stop
+          else
+            num_samples.times do
+              series.add_point(queue.shift)
+            end
+
+            renderer.render(series)
+            series.max_data_points = renderer.inner_width
+          end
+        end
+      end
+
+      # Main thread will accept samples as fast as they become available from stdin,
+      # and wake the consumer thread to process them if its asleep
+      while n = STDIN.gets&.chomp do
+        if numeric?(n)
+          queue << n.to_f
+          consumer.run
+        end
+      end
+
+      # Queue is closed as soon as stdin is closed, and we wait for the consumer
+      # to finish rendering
+      queue.close
+      consumer.run
+      consumer.join
+    end
+
+    private
+
+    FLOAT_REGEXP = /^[-+]?[0-9]*\.?[0-9]+$/
+    def numeric?(n)
+      n =~ FLOAT_REGEXP
+    end
+  end
+end

data/lib/termplot/cursors/buffered_console_cursor.rb

@@ -0,0 +1,70 @@
+require "termplot/cursors/virtual_cursor"
+require "termplot/cursors/control_chars"
+
+module Termplot
+  class BufferedConsoleCursor < VirtualCursor
+    include Termplot::ControlChars
+    attr_reader :buffer
+
+    def initialize(window, buffer)
+      super(window)
+      @buffer = buffer
+    end
+
+    def write(char)
+      if writeable?
+        buffer << char
+        super(char)
+      end
+    end
+
+    def forward(n = 1)
+      moved = super(n)
+      moved.times { buffer << FORWARD }
+    end
+
+    def back(n = 1)
+      moved = super(n)
+      moved.times { buffer << BACK }
+    end
+
+    def up(n=1)
+      moved = super(n)
+      moved.times { buffer << UP }
+    end
+
+    def down(n=1)
+      moved = super(n)
+      moved.times { buffer << DOWN }
+    end
+
+    def beginning_of_line
+      super
+      buffer << CR
+    end
+
+    def new_line
+      buffer << NEWLINE
+    end
+
+    def clear_buffer
+      buffer.clear
+    end
+
+    def flush
+      print buffer.join
+    end
+
+    def position=()
+      raise "Cannot set cursor position directly"
+    end
+
+    def row=()
+      raise "Cannot set cursor position directly"
+    end
+
+    def col=()
+      raise "Cannot set cursor position directly"
+    end
+  end
+end

data/lib/termplot/cursors/console_cursor.rb

@@ -0,0 +1,56 @@
+require "termplot/cursors/virtual_cursor"
+require "termplot/cursors/control_chars"
+
+module Termplot
+  class ConsoleCursor < VirtualCursor
+    include Termplot::ControlChars
+
+    def write(char)
+      if writeable?
+        print(char)
+        super(char)
+      end
+    end
+
+    def forward(n = 1)
+      moved = super(n)
+      moved.times { print FORWARD }
+    end
+
+    def back(n = 1)
+      moved = super(n)
+      moved.times { print BACK }
+    end
+
+    def up(n=1)
+      moved = super(n)
+      moved.times { print UP }
+    end
+
+    def down(n=1)
+      moved = super(n)
+      moved.times { print DOWN }
+    end
+
+    def beginning_of_line
+      super
+      print CR
+    end
+
+    def new_line
+      print NEWLINE
+    end
+
+    def position=()
+      raise "Cannot set cursor position directly"
+    end
+
+    def row=()
+      raise "Cannot set cursor position directly"
+    end
+
+    def col=()
+      raise "Cannot set cursor position directly"
+    end
+  end
+end

data/lib/termplot/cursors/control_chars.rb

@@ -0,0 +1,11 @@
+module Termplot
+  module ControlChars
+    CR = "\r"
+    NEWLINE = "\n"
+    UP = "\e[A"
+    DOWN = "\e[B"
+    FORWARD = "\e\[C"
+    BACK = "\e\[D"
+  end
+end
+

data/lib/termplot/cursors/virtual_cursor.rb

@@ -0,0 +1,76 @@
+module Termplot
+  class VirtualCursor
+    attr_reader :position, :window
+
+    def initialize(window)
+      @window = window
+      @position = 0
+    end
+
+    def write(char)
+      @position += 1 if writeable?
+    end
+
+    def writeable?
+      position < window.buffer.size
+    end
+
+    def forward(n = 1)
+      movable_chars = window.buffer.size - position
+      chars_to_move = [movable_chars, n].min
+      @position += chars_to_move
+      chars_to_move
+    end
+
+    def back(n = 1)
+      chars_to_move = [position, n].min
+      @position -= chars_to_move
+      chars_to_move
+    end
+
+    def up(n=1)
+      return unless row > 0
+      rows_to_move = [n, row].min
+      @position -= rows_to_move * window.cols
+      rows_to_move
+    end
+
+    def row
+      (position / window.cols).floor
+    end
+
+    def col
+      position % window.cols
+    end
+
+    def row=(y)
+      @position = y * window.cols + col
+    end
+
+    def col=(x)
+      beginning_of_line
+      forward(x)
+    end
+
+    def down(n=1)
+      return 0 unless row < (window.rows - 1)
+      rows_to_move = [n, window.rows - 1 - row].min
+      @position += window.cols * rows_to_move
+      rows_to_move
+    end
+
+    def beginning_of_line
+      @position = position - (position % window.cols)
+    end
+
+    def position=(n)
+      @position = n
+    end
+
+    def reset_position
+      return if position == 0
+      up(row) # Go up by row num times
+      beginning_of_line
+    end
+  end
+end