termplot 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1e3e2ddb262dda39fcc498fb8fed6bd84c1023c97a21d1a2aa2a7bb2ba22c59
-  data.tar.gz: 87012dbfb94747ecc1d90530d7a199a74cd118a59e4ea8d2396b283519b1d628
+  metadata.gz: e44e30011841535366e60fe122b1a1975614d2907db4b99fc5e78538ffc1cc8d
+  data.tar.gz: b63812a1a1823e0126eec29b14072ac6a7ee4b95f52a02977ea5e35432e2a905
 SHA512:
-  metadata.gz: fd4bdb6d311d03c7987fc3efcb0c6773d2abd40af2a13a5e7d9743ad4b6af0fce70ccd10414dded74bad0451f742ad50582cbc3e95813f8dfe1cfec115f322d5
-  data.tar.gz: bcc75b035ea812d163c5fb4bdbd7d35f387cce9d9d0b38938ce86acdd7005d2effb4f2b865344c7a6ce03c5de835a1a7a41535c444e4017eae9954105f755be2
+  metadata.gz: 2a15e0921c87254909bfdb11f35c0c3ac5bc85b8bd06c023234ac6c735a73cde92a7bcc2423ad40e5c37ac2718338a502e92e9b85ff6865760bca56e8671cea1
+  data.tar.gz: f4ba5aaea3ce9ef9870becafbfb7c58b79bebb76ab9d96161533f13c824a2e905964f39e99c7b4b1352df5d65b154e2d6b593099cc36ea43aafd25dc2b2d0366

data/README.md

@@ -4,7 +4,7 @@ Termplot is a simple terminal plotting tool for visualising streaming data.
 
 See the demo on Asciinema:
 
-[![Termplot Demo Asciicast](https://asciinema.org/a/3rzeUSXp2fRjnErX0p3SptP5e.png)](https://asciinema.org/a/3rzeUSXp2fRjnErX0p3SptP5e)
+[![Termplot Demo Asciicast](https://asciinema.org/a/370325.svg)](https://asciinema.org/a/3rzeUSXp2fRjnErX0p3SptP5e)
 
 ## Overview
 
@@ -27,26 +27,34 @@ The basic usage is simple:
 ```
 
 `{command}` is any command that will periodically output numbers to standard out
-delimited by a newline. Options and examples are given below. All command line
-options are optional.
+delimited by a newline. You can also instead specify a command to run at a given
+interval to produce the data.
 
-Options:
+Options and examples are given below. All command line options are
+optional.
 
 ```
 Usage: termplot [OPTIONS]
-  -r, --rows ROWS         Number of rows in the chart window (default: 19)
-  -c, --cols COLS         Number of cols in the chart window (default: 80)
-  -t, --title TITLE       Title of the series (default: Series)
+  -r, --rows ROWS          Number of rows in the chart window (default: 19)
 
-      --line-style STYLE  Line style. Options are:
-                            line [default], heavy-line, dot, star, x
+  -c, --cols COLS          Number of cols in the chart window (default: 80)
 
-      --color COLOR       Series color, specified as ansi 16-bit color name:
-                            (i.e. black, red [default], green, yellow, blue,
-                            magenta, cyan, white). Light versions are specified
-                            as light_{color}
+  -t, --title TITLE        Title of the series (default: 'Series')
 
-  -h, --help              Display this help message
+      --line-style STYLE   Line style. Options are: line (default), heavy-line, dot, star, x
+
+      --color COLOR        Series color, specified as ansi 16-bit color name:
+                           (i.e. black, light_black, red (default), light_red, green,
+                           light_green, yellow, light_yellow, blue, light_blue, magenta,
+                           light_magenta, cyan, light_cyan, white, light_white, default)
+
+      --command COMMAND    Enables command mode, where input is received by executing
+                           the specified command in intervals rather than from stdin
+
+      --interval INTERVAL  The interval at which to run the specified command in
+                           command mode in milliseconds (default: 1000)
+
+  -h, --help               Display this help message
 ```
 
 ## Examples
@@ -59,25 +67,21 @@ for i in $(seq 500); do \
   sleep 0.5; \
   done | termplot -t "Sin(x)"
 ```
-![Sine Wave Plot](http://localhost:8080/doc/sin.png)
+![Sine Wave Plot](doc/sin.png)
 
 Total % memory usage:
 ```
-while true; do \
-  free | awk 'NR==2 { print ($3/$2) * 100 }'; \
-  sleep 0.5; \
-  done | termplot -t "Memory (% used)" --color light_magenta --line-style heavy-line
+termplot --command "free | awk 'NR==2 { print ($3/$2) * 100 }'" \
+  -t "Memory (% used)" --color light_magenta --line-style heavy-line
 ```
-![Free Memory % Chart](http://localhost:8080/doc/memory.png)
+![Free Memory % Chart](doc/memory.png)
 
 % CPU usage of a "puma" process:
 ```
-while true; do \
-  ps au | grep puma | awk 'NR==1{ print $3 }'; \
-  sleep 0.5; \
-  done | termplot -t "Ruby CPU(%)" --color yellow --line-style dot -r10 -c 120
+termplot --command "ps au | grep puma | awk 'NR==1{ print $3 }'" \
+  -t "Ruby CPU(%)" --color yellow --line-style dot -r10 -c 120
 ```
-![CPU % Chart](http://localhost:8080/doc/cpu.png)
+![CPU % Chart](doc/cpu.png)
 
 
 ## Notes
@@ -87,10 +91,6 @@ while true; do \
 - The samples received are plotted in sequence order, and there is no notion of
   temporal spacing. So even if the time between samples is inconsistent, they
   will be plotted with the same amount of space between them.
-- The `while true; do {...}; sleep INTERVAL` is pretty typical, I would like to
-  sometime soon implement a `--command "{...}" --interval INTERVAL` which would
-  reduce some of the boilerplate of calling some command at an interval and make
-  it easy to watch and plot.
 
 ## Background
 
@@ -107,12 +107,10 @@ ruby.
 Now with termplot, it's as easy as:
 
 ```
-while true; do \
-  ss -s | head -n1 | cut -d ' ' -f2; sleep 1; \
-  done | termplot -t "TCP Connections"
+termplot --command "ss -s | head -n1 | cut -d' ' -f2" --interval 500 -t "TCP Connections"
 ```
 
-![TCP Connections](http://localhost:8080/doc/tcp.png)
+![TCP Connections](doc/tcp.png)
 
 ## Development
 

data/Rakefile

@@ -1,8 +1,7 @@
 require "bundler/gem_tasks"
 
 task :bin do
-  Bundler.require(:default)
-  exec "bin/termplot", *ARGV[2..-1]
+  exec "ruby", "-Ilib", "bin/termplot", *ARGV[2..-1]
 end
 
 task :sin_test do
@@ -16,3 +15,6 @@ task :sin_test do
   exec cmd
 end
 
+task :command_test do
+  exec "ruby -Ilib bin/termplot --command 'echo $RANDOM' --interval 900"
+end

data/lib/termplot/cli.rb

@@ -1,59 +1,12 @@
-require "optparse"
+# frozen_string_literal: true
+require "termplot/options"
 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
+      opts = Options.new.parse_options!
+      Consumer.new(opts).run
     end
   end
 end

data/lib/termplot/colors.rb

@@ -1,36 +1,36 @@
 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
-      }
+    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
-      }
+    MODES = {
+      default:   0,
+      bold:      1,
+      italic:    3,
+      underline: 4,
+      blink:     5,
+      swap:      7,
+      hide:      8
+    }
 
+    class << self
       COLORS.each do |(color, code)|
         define_method(color) do |str|
           escape_color(color) + str + escape_mode(:default)

data/lib/termplot/consumer.rb

@@ -1,22 +1,24 @@
 require "termplot/series"
 require "termplot/renderer"
 require "termplot/shell"
+require "termplot/producers"
 
 module Termplot
   class Consumer
-    attr_reader :series, :renderer
+    attr_reader :options, :series, :renderer
 
-    def initialize(cols:, rows:, title:, line_style:, color:, debug:)
+    def initialize(options)
+      @options = options
       @renderer = Renderer.new(
-        cols: cols,
-        rows: rows,
-        debug: debug
+        cols: options.cols,
+        rows: options.rows,
+        debug: options.debug
       )
       @series = Series.new(
-        title: title,
+        title: options.title,
         max_data_points: renderer.inner_width,
-        line_style: line_style,
-        color: color,
+        line_style: options.line_style,
+        color: options.color,
       )
     end
 
@@ -27,7 +29,7 @@ module Termplot
       # 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
+      # If no samples are available but the queue is open, it will sleep until
       # woken to render new input.
       consumer = Thread.new do
         while !queue.closed?
@@ -45,27 +47,29 @@ module Termplot
         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
+      # Producer will run in the main thread and will block while producing
+      # samples from some source (which depends on the type of producer).
+      # Samples will be added to the queue as they are available, and the
+      # consumer will be woken to check the queue
+      producer = build_producer(queue)
+      producer.register_consumer(consumer)
+      producer.run
 
-      # Queue is closed as soon as stdin is closed, and we wait for the consumer
-      # to finish rendering
-      queue.close
+      # As soon as producer continues, and we first give the consumer a chance
+      # to finish rendering the queue, then close the queue.
       consumer.run
+      producer.close
       consumer.join
     end
 
     private
 
-    FLOAT_REGEXP = /^[-+]?[0-9]*\.?[0-9]+$/
-    def numeric?(n)
-      n =~ FLOAT_REGEXP
+    def build_producer(queue)
+      producer_class = {
+        command: "Termplot::Producers::CommandProducer",
+        stdin: "Termplot::Producers::StdinProducer"
+      }.fetch(options.mode)
+      Object.const_get(producer_class).new(queue, options)
     end
   end
 end

data/lib/termplot/cursors.rb

@@ -0,0 +1,7 @@
+module Termplot
+  module Cursors
+    autoload :VirtualCursor, "termplot/cursors/virtual_cursor"
+    autoload :ConsoleCursor, "termplot/cursors/console_cursor"
+    autoload :BufferedConsoleCursor, "termplot/cursors/buffered_console_cursor"
+  end
+end

data/lib/termplot/cursors/buffered_console_cursor.rb

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

data/lib/termplot/cursors/console_cursor.rb

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

data/lib/termplot/cursors/virtual_cursor.rb

@@ -1,76 +1,78 @@
 module Termplot
-  class VirtualCursor
-    attr_reader :position, :window
+  module Cursors
+    class VirtualCursor
+      attr_reader :position, :window
 
-    def initialize(window)
-      @window = window
-      @position = 0
-    end
+      def initialize(window)
+        @window = window
+        @position = 0
+      end
 
-    def write(char)
-      @position += 1 if writeable?
-    end
+      def write(char)
+        @position += 1 if writeable?
+      end
 
-    def writeable?
-      position < window.buffer.size
-    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 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 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 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 row
+        (position / window.cols).floor
+      end
 
-    def col
-      position % window.cols
-    end
+      def col
+        position % window.cols
+      end
 
-    def row=(y)
-      @position = y * window.cols + col
-    end
+      def row=(y)
+        @position = y * window.cols + col
+      end
 
-    def col=(x)
-      beginning_of_line
-      forward(x)
-    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 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 beginning_of_line
+        @position = position - (position % window.cols)
+      end
 
-    def position=(n)
-      @position = n
-    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
+      def reset_position
+        return if position == 0
+        up(row) # Go up by row num times
+        beginning_of_line
+      end
     end
   end
 end

data/lib/termplot/options.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "termplot/character_map"
+require "termplot/colors"
+
+module Termplot
+  class Options
+    attr_reader :rows,
+      :cols,
+      :title,
+      :line_style,
+      :color,
+      :debug,
+      :command,
+      :interval
+
+    def initialize
+      @rows       = 19
+      @cols       = 80
+      @title      = "Series"
+      @line_style = "line"
+      @color      = "red"
+      @debug      = false
+      @command    = nil
+      @interval   = 1000
+    end
+
+    def mode
+      @command.nil? ? :stdin : :command
+    end
+
+    def parse_options!
+      # Debug option is parsed manually to prevent it from showing up in the
+      # options help
+      parse_debug
+
+      OptionParser.new do |opts|
+        opts.banner = "Usage: termplot [OPTIONS]"
+
+        parse_rows(opts)
+        parse_cols(opts)
+        parse_title(opts)
+        parse_line_style(opts)
+        parse_color(opts)
+        parse_command(opts)
+        parse_interval(opts)
+
+        opts.on("-h", "--help", "Display this help message") do
+          puts opts
+          exit(0)
+        end
+
+      end.parse!
+      self
+    end
+
+    private
+
+    def parse_rows(opts)
+      opts.on("-r ROWS", "--rows ROWS",
+              "Number of rows in the chart window (default: #{@rows})") do |v|
+        @rows = v.to_i
+      end
+    end
+
+    def parse_cols(opts)
+      opts.on("-c COLS", "--cols COLS",
+              "Number of cols in the chart window (default: #{@cols})") do |v|
+        @cols = v.to_i
+      end
+    end
+
+    def parse_title(opts)
+      opts.on("-tTITLE", "--title TITLE",
+              "Title of the series (default: '#{@title}')") do |v|
+        @title = v
+      end
+    end
+
+    def parse_line_style(opts)
+      line_style_opts = with_default(Termplot::CharacterMap::LINE_STYLES.keys, @line_style)
+      opts.on("--line-style STYLE",
+              "Line style. Options are: #{line_style_opts.join(", ")}") do |v|
+        @line_style = v.downcase
+      end
+    end
+
+    def parse_color(opts)
+      color_opts = Termplot::Colors::COLORS.keys.map(&:to_s).reject do |c|
+        c == :default
+      end
+      color_opts = with_default(color_opts, @color)
+      opts.on("--color COLOR",
+              "Series color, specified as ansi 16-bit color name:",
+              "(i.e. #{color_opts.join(", ")})") do |v|
+        @color = v.downcase
+      end
+    end
+
+    def parse_command(opts)
+      opts.on("--command COMMAND",
+              "Enables command mode, where input is received by executing",
+              "the specified command in intervals rather than from stdin") do |v|
+        @command = v
+      end
+    end
+
+    def parse_interval(opts)
+      opts.on("--interval INTERVAL",
+              "The interval at which to run the specified command in",
+              "command mode in milliseconds (default: #{@interval})") do |v|
+        @interval = v.to_i
+      end
+    end
+
+    def parse_debug
+      if ARGV.delete("--debug") || ARGV.delete("-d")
+        @debug = true
+      end
+    end
+
+    def with_default(opt_arr, default)
+      opt_arr.map do |opt|
+        opt == default ?
+          opt + " (default)" :
+          opt
+      end
+    end
+  end
+end

data/lib/termplot/producers.rb

@@ -0,0 +1,7 @@
+module Termplot
+  module Producers
+    autoload :BaseProducer, "termplot/producers/base_producer.rb"
+    autoload :CommandProducer, "termplot/producers/command_producer.rb"
+    autoload :StdinProducer, "termplot/producers/stdin_producer.rb"
+  end
+end

data/lib/termplot/producers/base_producer.rb

@@ -0,0 +1,35 @@
+module Termplot
+  module Producers
+    class BaseProducer
+      def initialize(queue, options)
+        @options = options
+        @queue = queue
+        @consumer = nil
+      end
+
+      def register_consumer(consumer)
+        @consumer = consumer
+      end
+
+      def shift
+        queue.shift
+      end
+
+      def closed?
+        queue.closed?
+      end
+
+      def close
+        queue.close
+      end
+
+      private
+      attr_reader :queue, :consumer, :options
+
+      FLOAT_REGEXP = /^[-+]?[0-9]*\.?[0-9]+$/
+      def numeric?(n)
+        n =~ FLOAT_REGEXP
+      end
+    end
+  end
+end

data/lib/termplot/producers/command_producer.rb

@@ -0,0 +1,20 @@
+module Termplot
+  module Producers
+    class CommandProducer < BaseProducer
+      def run
+        loop do
+          n = `/bin/bash -c '#{options.command}'`.chomp
+          # TODO: Error handling...
+
+          if numeric?(n)
+            queue << n.to_f
+            consumer&.run
+          end
+
+          # Interval is in ms
+          sleep(options.interval / 1000.0)
+        end
+      end
+    end
+  end
+end

data/lib/termplot/producers/stdin_producer.rb

@@ -0,0 +1,14 @@
+module Termplot
+  module Producers
+    class StdinProducer < BaseProducer
+      def run
+        while n = STDIN.gets&.chomp do
+          if numeric?(n)
+            queue << n.to_f
+            consumer&.run
+          end
+        end
+      end
+    end
+  end
+end

data/lib/termplot/version.rb

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

data/lib/termplot/window.rb

@@ -1,5 +1,5 @@
-require "termplot/cursors/virtual_cursor"
-require "termplot/cursors/buffered_console_cursor"
+require "termplot/control_chars"
+require "termplot/cursors"
 
 module Termplot
   class Window
@@ -11,14 +11,14 @@ module Termplot
     end
 
     def cursor
-      @cursor ||= VirtualCursor.new(self)
+      @cursor ||= Termplot::Cursors::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))
+        Termplot::Cursors::BufferedConsoleCursor.new(self, Array.new(cols * rows + rows - 1))
     end
 
     def size

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: termplot
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Martin Nyaga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-04 00:00:00.000000000 Z
+date: 2020-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-termios
@@ -42,7 +42,6 @@ files:
 - bin/termplot
 - doc/cpu.png
 - doc/demo.cast
-- doc/demo.gif
 - doc/memory.png
 - doc/sin.png
 - doc/tcp.png
@@ -51,10 +50,16 @@ files:
 - lib/termplot/cli.rb
 - lib/termplot/colors.rb
 - lib/termplot/consumer.rb
+- lib/termplot/control_chars.rb
+- lib/termplot/cursors.rb
 - lib/termplot/cursors/buffered_console_cursor.rb
 - lib/termplot/cursors/console_cursor.rb
-- lib/termplot/cursors/control_chars.rb
 - lib/termplot/cursors/virtual_cursor.rb
+- lib/termplot/options.rb
+- lib/termplot/producers.rb
+- lib/termplot/producers/base_producer.rb
+- lib/termplot/producers/command_producer.rb
+- lib/termplot/producers/stdin_producer.rb
 - lib/termplot/renderer.rb
 - lib/termplot/series.rb
 - lib/termplot/shell.rb
@@ -83,8 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Plot time series charts in your terminal