termplot 0.1.0 → 0.3.1

data/lib/termplot/dsl/widgets.rb

@@ -0,0 +1,128 @@
+require "termplot/positioned_widget"
+require "termplot/widgets"
+
+module Termplot
+  module WidgetDSL
+    def timeseries(attrs)
+      attrs = merge_defaults(attrs)
+      children.push(TimeSeriesConfig.new(attrs))
+    end
+
+    def statistics(attrs)
+      attrs = merge_defaults(attrs)
+      children.push(StatisticsConfig.new(attrs))
+    end
+
+    def histogram(attrs)
+      attrs = merge_defaults(attrs)
+      children.push(HistogramConfig.new(attrs))
+    end
+
+    private
+
+    def merge_defaults(attrs)
+      Termplot::Options.default_options.merge(attrs)
+    end
+
+    class WidgetConfig
+      attr_reader(
+        :title,
+        :command,
+        :interval,
+        :col,
+        :row,
+        :cols,
+        :rows,
+        :debug
+      )
+
+      def initialize(opts)
+        @title = opts[:title]
+
+        @command = opts[:command]
+        @interval = opts[:interval]
+        @debug = opts[:debug]
+
+        post_initialize(opts)
+      end
+
+      def post_initialize(opts)
+        # Implemented in subclasses
+      end
+
+      def set_dimensions(rows, cols, start_row, start_col)
+        @rows = rows
+        @cols = cols
+        @row = start_row
+        @col = start_col
+      end
+
+      def flatten
+        self
+      end
+
+      def positioned_widget
+        @positioned_widget ||= PositionedWidget.new(
+          row: row,
+          col: col,
+          widget: widget
+        )
+      end
+
+      def widget
+        raise "Must be implemented"
+      end
+
+      def producer_options
+        ProducerOptions.new(command: command, interval: interval)
+      end
+    end
+
+    class TimeSeriesConfig < WidgetConfig
+      attr_reader :color, :line_style
+      def post_initialize(opts)
+        @color = opts[:color]
+        @line_style = opts[:line_style]
+      end
+
+      def widget
+        @widget ||= Termplot::Widgets::TimeSeriesWidget.new(
+          title: title,
+          line_style: line_style,
+          color: color,
+          cols: cols,
+          rows: rows,
+          debug: debug
+        )
+      end
+    end
+
+    class StatisticsConfig < WidgetConfig
+      def widget
+        @widget ||= Termplot::Widgets::StatisticsWidget.new(
+          title: title,
+          cols: cols,
+          rows: rows,
+          debug: debug
+        )
+      end
+    end
+
+    class HistogramConfig < WidgetConfig
+      attr_reader :color
+      def post_initialize(opts)
+        @color = opts[:color]
+      end
+
+      def widget
+        @widget ||= Termplot::Widgets::HistogramWidget.new(
+          title: title,
+          color: color,
+          cols: cols,
+          rows: rows,
+          debug: debug
+        )
+      end
+    end
+  end
+end

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,111 @@
+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)
+      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
+
+    def closed?
+      queue.closed?
+    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

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "termplot/character_map"
+require "termplot/colors"
+require "termplot/producer_options"
+require "termplot/shell"
+
+module Termplot
+  class Options
+    attr_reader :rows,
+                :cols,
+                :full_screen,
+                :debug,
+                :file,
+                :command,
+                :interval,
+                :type,
+                :title,
+                :line_style,
+                :color
+
+    def initialize
+      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 to_h
+      self.class.default_options.inject({}) do |hash, (k, _)|
+        hash[k] = instance_variable_get("@#{k}")
+        hash
+      end
+    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_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)
+        end
+
+      end.parse!
+      self
+    end
+
+    def producer_options
+      ProducerOptions.new(command: command, interval: interval)
+    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_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|
+        @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_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
+      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/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/base_producer.rb

@@ -0,0 +1,32 @@
+module Termplot
+  module Producers
+    class BaseProducer
+      def initialize(options)
+        @options = options
+        @on_message_handler = -> {}
+      end
+
+      def on_message(&block)
+        @on_message_handler = block
+      end
+
+      def run
+        raise "Must be implemented"
+      end
+
+      private
+      attr_reader :options, :on_message_handler
+
+      def produce(value)
+        if numeric?(value)
+          on_message_handler.call(value.to_f)
+        end
+      end
+
+      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,42 @@
+require "tempfile"
+require "fileutils"
+
+module Termplot
+  module Producers
+    class CommandProducer < BaseProducer
+      def run
+        temp_executable = make_executable(options.command)
+        loop do
+          n = `#{temp_executable.path}`.chomp
+          # TODO: Error handling...
+
+          produce(n)
+
+          # Interval is in ms
+          sleep(options.interval / 1000.0)
+        end
+      ensure
+        temp_executable.unlink
+      end
+
+      private
+      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

@@ -0,0 +1,11 @@
+module Termplot
+  module Producers
+    class StdinProducer < BaseProducer
+      def run
+        while n = STDIN.gets&.chomp do
+          produce(n)
+        end
+      end
+    end
+  end
+end

data/lib/termplot/producers.rb

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