termplot 0.2.1 → 0.3.0

data/lib/termplot/file_config.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "termplot/dsl/panels"
+
+module Termplot
+  class FileConfig
+    attr_reader :options, :rows, :cols, :widget_configs
+    def initialize(options)
+      @options = options
+      @path = options.file
+      @rows = options.rows
+      @cols = options.cols
+      @widget_configs = nil
+    end
+
+    def parse_config
+      code = File.read(path)
+      top_level_panel = Termplot::DSL::Col.new(options)
+      top_level_panel.instance_eval(code)
+
+      @widget_configs = resolve_widget_positions(top_level_panel)
+      self
+    end
+
+    def positioned_widgets
+      widget_configs.map(&:positioned_widget)
+    end
+
+    private
+    attr_reader :path
+
+    def resolve_widget_positions(top_level_panel)
+      top_level_panel.set_dimensions(rows, cols, 0, 0)
+      top_level_panel.flatten
+    end
+  end
+end

data/lib/termplot/message_broker.rb

@@ -0,0 +1,108 @@
+require "forwardable"
+
+module Termplot
+  class MessageBrokerPool
+    def initialize
+      @brokers = []
+      @mutex = Mutex.new
+      @on_message_callbacks = []
+    end
+
+    def broker(sender:, receiver:)
+      mutex.synchronize do
+        broker = MessageBroker.new(sender: sender, receiver: receiver)
+        broker.on_message do |v|
+          on_message_callbacks.each do |block|
+            block.call(v)
+          end
+        end
+        brokers.push(broker)
+        broker
+      end
+    end
+
+    def on_message(&block)
+      mutex.synchronize do
+        on_message_callbacks.push(block)
+      end
+    end
+
+    def closed?
+      mutex.synchronize do
+        brokers.count > 0 &&
+          brokers.all?(:closed?)
+      end
+    end
+
+    def shutdown
+      mutex.synchronize do
+        brokers.each(&:close)
+      end
+    end
+
+    def flush_messages
+      mutex.synchronize do
+        brokers.each(&:flush_queue)
+      end
+    end
+
+    def pending_message_count
+      mutex.synchronize do
+        brokers.inject(0) do |sum, broker|
+          sum + broker.pending_message_count
+        end
+      end
+    end
+
+    def empty?
+      pending_message_count == 0
+    end
+
+    private
+    attr_reader :brokers, :mutex, :on_message_callbacks
+  end
+
+  # Broker messages in a thread-safe way between a sender and a receiver.
+  class MessageBroker
+    def initialize(sender:, receiver:)
+      @sender = sender
+      @receiver = receiver
+      @queue = Queue.new
+      @on_message_callbacks = []
+
+      register_callbacks
+    end
+
+    def on_message(block = Proc.new)
+      on_message_callbacks.push(block)
+    end
+
+    def pending_message_count
+      queue.size
+    end
+
+    def flush_queue
+      num_samples = queue.size
+      num_samples.times do
+        receiver << queue.shift
+      end
+    end
+
+    def close
+      queue.close
+    end
+
+    private
+    attr_reader :sender, :receiver, :queue, :on_message_callbacks
+
+    def register_callbacks
+      on_message_callbacks.push -> (value) { queue << value }
+
+      sender.on_message do |value|
+        on_message_callbacks.each do |block|
+          block.call(value)
+        end
+      end
+    end
+  end
+end

data/lib/termplot/options.rb

@@ -3,31 +3,70 @@
 require "optparse"
 require "termplot/character_map"
 require "termplot/colors"
+require "termplot/producer_options"
+require "termplot/shell"
 
 module Termplot
   class Options
     attr_reader :rows,
-      :cols,
-      :title,
-      :line_style,
-      :color,
-      :debug,
-      :command,
-      :interval
+                :cols,
+                :full_screen,
+                :debug,
+                :file,
+                :command,
+                :interval,
+                :type,
+                :title,
+                :line_style,
+                :color
 
     def initialize
-      @rows       = 19
-      @cols       = 80
-      @title      = "Series"
-      @line_style = "line"
-      @color      = "red"
-      @debug      = false
-      @command    = nil
-      @interval   = 1000
+      self.class.default_options.each do |(option, value)|
+        instance_variable_set("@#{option}", value)
+      end
+    end
+
+    # 3 input modes supported:
+    # - Read from stdin and render a single chart (default)
+    # - Run a single command at an interval and render a single chart
+    # - Read configuration from a file, run multiple commands at an interval and
+    #   render multiple charts in a dashboard
+    def input_mode
+      return :file    unless @file.nil?
+      return :command unless @command.nil?
+      :stdin
+    end
+
+    def self.default_options
+      {
+        # General options
+        rows: 19,
+        cols: 100,
+        full_screen: false,
+        debug: false,
+
+        # Input modes
+        file: nil,
+        command: nil,
+        interval: 1000,
+
+        # Widget (only necessary for stdin/command input modes)
+        type: "timeseries",
+
+        # General - All/multiple widget types
+        title: "Series",
+        color: "green",
+
+        # Timeseries
+        line_style: "heavy-line",
+      }
     end
 
-    def mode
-      @command.nil? ? :stdin : :command
+    def to_h
+      self.class.default_options.inject({}) do |hash, (k, _)|
+        hash[k] = instance_variable_get("@#{k}")
+        hash
+      end
     end
 
     def parse_options!
@@ -40,12 +79,19 @@ module Termplot
 
         parse_rows(opts)
         parse_cols(opts)
-        parse_title(opts)
-        parse_line_style(opts)
-        parse_color(opts)
+        parse_full_screen(opts)
+
+        parse_file(opts)
         parse_command(opts)
         parse_interval(opts)
 
+        parse_type(opts)
+
+        parse_title(opts)
+        parse_color(opts)
+
+        parse_line_style(opts)
+
         opts.on("-h", "--help", "Display this help message") do
           puts opts
           exit(0)
@@ -55,6 +101,10 @@ module Termplot
       self
     end
 
+    def producer_options
+      ProducerOptions.new(command: command, interval: interval)
+    end
+
     private
 
     def parse_rows(opts)
@@ -71,6 +121,20 @@ module Termplot
       end
     end
 
+    def parse_full_screen(opts)
+      opts.on("--full-screen", "Render to the full available terminal size") do |v|
+        @rows, @cols = Shell.get_dimensions
+        @full_screen = true
+      end
+    end
+
+    def parse_file(opts)
+      opts.on("-f FILE", "--file FILE",
+              "Read a dashboard configuration from a file") do |v|
+        @file = v
+      end
+    end
+
     def parse_title(opts)
       opts.on("-tTITLE", "--title TITLE",
               "Title of the series (default: '#{@title}')") do |v|
@@ -114,6 +178,22 @@ module Termplot
       end
     end
 
+    def parse_type(opts)
+      widget_types = %w( timeseries stats hist )
+      widget_types_with_default = with_default(widget_types, @type)
+      opts.on("--type TYPE",
+              "The type of chart to render. ",
+              "Options are: #{widget_types_with_default.join(", ")}") do |v|
+        @type = v
+      end
+
+      widget_types.each do |type|
+        opts.on("--#{type}", "Shorthand for --type #{type}") do |_|
+          @type = type
+        end
+      end
+    end
+
     def parse_debug
       if ARGV.delete("--debug") || ARGV.delete("-d")
         @debug = true

data/lib/termplot/positioned_widget.rb

@@ -0,0 +1,8 @@
+require "forwardable"
+
+module Termplot
+  PositionedWidget = Struct.new(:row, :col, :widget, keyword_init: true) do
+    extend Forwardable
+    def_delegators :widget, :window, :errors, :render_to_window
+  end
+end

data/lib/termplot/producer_options.rb

@@ -0,0 +1,3 @@
+module Termplot
+  ProducerOptions = Struct.new(:command, :interval, keyword_init: true)
+end

data/lib/termplot/producers.rb

@@ -1,7 +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"
+    autoload :BaseProducer, "termplot/producers/base_producer"
+    autoload :CommandProducer, "termplot/producers/command_producer"
+    autoload :StdinProducer, "termplot/producers/stdin_producer"
   end
 end

data/lib/termplot/producers/base_producer.rb

@@ -1,31 +1,28 @@
 module Termplot
   module Producers
     class BaseProducer
-      def initialize(queue, options)
+      def initialize(options)
         @options = options
-        @queue = queue
-        @consumer = nil
+        @on_message_handler = -> {}
       end
 
-      def register_consumer(consumer)
-        @consumer = consumer
+      def on_message(&block)
+        @on_message_handler = block
       end
 
-      def shift
-        queue.shift
+      def run
+        raise "Must be implemented"
       end
 
-      def closed?
-        queue.closed?
-      end
+      private
+      attr_reader :options, :on_message_handler
 
-      def close
-        queue.close
+      def produce(value)
+        if numeric?(value)
+          on_message_handler.call(value.to_f)
+        end
       end
 
-      private
-      attr_reader :queue, :consumer, :options
-
       FLOAT_REGEXP = /^[-+]?[0-9]*\.?[0-9]+$/
       def numeric?(n)
         n =~ FLOAT_REGEXP

data/lib/termplot/producers/command_producer.rb

@@ -1,26 +1,42 @@
+require "tempfile"
+require "fileutils"
+
 module Termplot
   module Producers
     class CommandProducer < BaseProducer
       def run
-        command = sanitize_command("/bin/bash -c '#{options.command}'")
+        temp_executable = make_executable(options.command)
         loop do
-          n = `#{command}`
+          n = `#{temp_executable.path}`.chomp
           # TODO: Error handling...
 
-          if numeric?(n)
-            queue << n.to_f
-            consumer&.run
-          end
+          produce(n)
 
           # Interval is in ms
           sleep(options.interval / 1000.0)
         end
+      ensure
+        temp_executable.unlink
       end
 
       private
-        def sanitize_command(command)
-          command.gsub(/\$/, '\\$')
-        end
+      def make_executable(command)
+        file = Tempfile.new
+        file.write <<~COMMAND
+          #! #{ENV['SHELL']}
+          echo $(#{sanitize_command(command)})
+        COMMAND
+        file.close
+
+        FileUtils.chmod("a=xrw", file.path)
+        file
+      end
+
+      # TODO: Proper sanitization, probably using Shellwords?
+      def sanitize_command(command)
+        # command.gsub('"', "'")
+        command
+      end
     end
   end
 end

data/lib/termplot/producers/stdin_producer.rb

@@ -3,10 +3,7 @@ module Termplot
     class StdinProducer < BaseProducer
       def run
         while n = STDIN.gets&.chomp do
-          if numeric?(n)
-            queue << n.to_f
-            consumer&.run
-          end
+          produce(n)
         end
       end
     end

data/lib/termplot/renderable.rb

@@ -0,0 +1,35 @@
+module Termplot
+  module Renderable
+    # Included in any module that has the ivars:
+    #   :window
+    #   :errors
+    #   :debug
+    # And methods:
+    #   #render_tO_window
+    # Provides rendering to string and stdout
+    def render
+      rendered_string = render_to_string
+      if debug?
+        rendered_string.each do |row|
+          print row
+        end
+      else
+        print rendered_string
+        STDOUT.flush
+      end
+
+      if errors.any?
+        window.print_errors(errors)
+      end
+    end
+
+    def render_to_string
+      render_to_window
+      debug? ? window.flush_debug : window.flush
+    end
+
+    def debug?
+      @debug
+    end
+  end
+end