termplot 0.2.1 → 0.3.0

data/lib/termplot/utils/ansi_safe_string.rb

@@ -0,0 +1,68 @@
+module Termplot
+  module Utils
+    class AnsiSafeString
+      include Enumerable
+
+      # Regex to match ANSI escape sequences.
+      ANSI_MATCHER = Regexp.new("(\\[?\\033\\[?[;?\\d]*[\\dA-Za-z][\\];]?)")
+
+      attr_reader :string
+      def initialize(string)
+        @string = string
+      end
+
+      def length
+        sanitized.length
+      end
+
+      def sanitized
+        string.gsub(/#{ANSI_MATCHER}/, "")
+      end
+
+      # Yield each char in the string, folding any escape sequences into the
+      # next char. NOTE: If the string includes only ansi escape sequences,
+      # nothing will be yielded.
+      def each
+        ansi_code_positions = []
+
+        string.scan(ANSI_MATCHER) do |_|
+          ansi_code_positions << Regexp.last_match.offset(0)
+        end
+
+        i = 0
+        current_char = ""
+        while i < string.length
+          if ansi_code_positions.any? { |pos| pos[0] <= i && pos[1] > i }
+            current_char << string[i]
+            i += 1
+          else
+            current_char << string[i]
+
+            # If the next character is a terminating ansi sequence, we need to
+            # fold it into the current character, to prevent emitting an ansi
+            # sequence only as the last character.
+            next_char_is_terminating_ansi_sequence =
+              ansi_code_positions.length > 0 &&
+              ansi_code_positions.last[0] == i + 1 &&
+              ansi_code_positions.last[1] == string.length
+
+            if next_char_is_terminating_ansi_sequence
+              current_char << string[i + 1..-1]
+              i += 1 + (string.length - 1 - i + 1)
+            else
+              yield current_char
+              current_char = ""
+              i += 1
+            end
+          end
+        end
+
+        yield current_char unless current_char.empty?
+      end
+
+      def slice(start, stop)
+        AnsiSafeString.new(to_a[start..stop].join)
+      end
+    end
+  end
+end

data/lib/termplot/version.rb

@@ -1,3 +1,3 @@
 module Termplot
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/termplot/widget_dsl.rb

@@ -0,0 +1,130 @@
+require "termplot/positioned_widget"
+require "termplot/widgets"
+
+module Termplot
+  module DSL
+    module Widgets
+      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
+end

data/lib/termplot/widgets.rb

@@ -0,0 +1,8 @@
+module Termplot
+  module Widgets
+    autoload :BaseWidget, "termplot/widgets/base_widget"
+    autoload :TimeSeriesWidget, "termplot/widgets/time_series_widget"
+    autoload :StatisticsWidget, "termplot/widgets/statistics_widget"
+    autoload :HistogramWidget, "termplot/widgets/histogram_widget"
+  end
+end

data/lib/termplot/widgets/base_widget.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "termplot/widgets/border"
+require "termplot/widgets/dataset"
+
+module Termplot
+  module Widgets
+    class BaseWidget
+      include Renderable
+
+      attr_reader(
+        :cols,
+        :rows,
+        :window,
+        :bordered_window,
+        :errors,
+        :title,
+        :decimals,
+        :dataset
+      )
+
+      def initialize(**opts)
+        @cols = opts[:cols] >= min_cols ? opts[:cols] : min_cols
+        @rows = opts[:rows] >= min_rows ? opts[:rows] : min_rows
+        @window = Window.new(
+          cols: @cols,
+          rows: @rows
+        )
+
+        @bordered_window = BorderedWindow.new(window, default_border_size)
+        @debug = opts[:debug]
+        @errors = []
+
+        @title = opts[:title]
+        @decimals = 2
+
+        @dataset = Dataset.new(max_count)
+
+        post_initialize(opts)
+      end
+
+      def post_initialize(opts)
+        # Implemented by subclasses
+      end
+
+      def <<(point)
+        dataset << point
+        dataset.set_capacity(max_count)
+      end
+
+      def render_to_window
+        raise "Must be implemented"
+      end
+
+      private
+      def max_count
+        10_000
+      end
+
+      BorderedWindow = Struct.new(:window, :border_size) do
+        def inner_width
+          window.cols - border_size.left - border_size.right
+        end
+
+        def inner_height
+          window.rows - border_size.top - border_size.bottom
+        end
+
+        def method_missing(method, *args, &block)
+          if window.respond_to?(method)
+            window.send(method, *args, &block)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/termplot/widgets/border.rb

@@ -0,0 +1,6 @@
+module Termplot
+  module Widgets
+    class Border < Struct.new(:top, :right, :bottom, :left)
+    end
+  end
+end

data/lib/termplot/widgets/dataset.rb

@@ -0,0 +1,50 @@
+require "termplot/widgets/statistics"
+
+module Termplot
+  module Widgets
+    class Dataset
+      include Enumerable
+      include Statistics
+
+      attr_reader :capacity, :min, :max, :range, :data
+
+      def initialize(capacity)
+        @data = []
+        @min = 0
+        @max = 0
+        @range = 0
+        @capacity = capacity
+      end
+
+      def each(&block)
+        data.each(&block)
+      end
+
+      def << (point)
+        data.push(point)
+
+        discard_excess
+
+        @min = data.min
+        @max = data.max
+        @range = (max - min).abs
+        @range = 1 if range.zero?
+      end
+
+      def set_capacity(capacity)
+        @capacity = capacity
+        discard_excess
+      end
+
+      def empty?
+        data.empty?
+      end
+
+      private
+      def discard_excess
+        excess = [0, data.length - capacity].max
+        data.shift(excess)
+      end
+    end
+  end
+end

data/lib/termplot/widgets/histogram_widget.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "termplot/window"
+require "termplot/renderable"
+require "termplot/window"
+require "termplot/character_map"
+require "termplot/renderers"
+require "termplot/colors"
+
+module Termplot
+  module Widgets
+    class HistogramWidget < BaseWidget
+      DEFAULT_COLOR = "green"
+      attr_reader :color
+
+      def post_initialize(opts)
+        @color = opts[:color] || DEFAULT_COLOR
+      end
+
+      def render_to_window
+        errors.clear
+        window.clear
+        window.cursor.reset_position
+
+        bins = calculate_bins
+        bins = bin_data(bins)
+        bins = calculate_bin_coordinates(bins)
+        calculate_axis_size(bins)
+        render_bins(bins)
+        window.cursor.reset_position
+
+        # Title bar
+        Termplot::Renderers::TextRenderer.new(
+          bordered_window: bordered_window,
+          text: title_text,
+          row: 0,
+          errors: errors
+        ).render
+
+        window.cursor.reset_position
+
+        # Borders
+        Termplot::Renderers::BorderRenderer.new(
+          bordered_window: bordered_window
+        ).render
+
+        window.cursor.reset_position
+
+        # Ticks
+        render_ticks(bins)
+        window.cursor.reset_position
+      end
+
+      private
+
+      def default_border_size
+        Border.new(2, 1, 1, 4)
+      end
+
+      def calculate_axis_size(bins)
+        return if bins.empty?
+        border_left = bins.map { |bin| format_tick_label(bin.midpoint).length }.max
+        border_left += 2
+
+        # Clamp border_left to prevent the renderer from crashing
+        # with very large numbers
+        if border_left > cols - 5
+          errors.push(Colors.yellow("Warning: Axis tick values have been clipped, consider using more columns with -c"))
+          border_left = cols - 5
+        end
+
+        @bordered_window.border_size = Border.new(2, 1, 1, border_left)
+      end
+
+      def min_cols
+        default_border_size.left + default_border_size.right + 5
+      end
+
+      def num_bins
+        bordered_window.inner_height
+      end
+
+      def min_rows
+        default_border_size.top + default_border_size.bottom + 1
+      end
+
+      def title_text
+        bin_char + " " + title
+      end
+
+      def render_bins(positioned_bins)
+        positioned_bins.each do |bin|
+          window.cursor.beginning_of_line
+          window.cursor.row = bin.y + bordered_window.border_size.top
+          window.cursor.forward(bordered_window.border_size.left)
+          bin.x.times { window.write(bin_char) }
+          window.write(" ")
+
+          bin.count.to_s.chars.each do |char|
+            window.write(char)
+          end
+        end
+      end
+
+      def render_ticks(positioned_bins)
+        positioned_bins.each do |bin|
+          window.cursor.row = bin.y + bordered_window.border_size.top
+          window.cursor.beginning_of_line
+
+          format_tick_label(bin.midpoint).rjust(bordered_window.border_size.left - 2, " ").chars.first(bordered_window.border_size.left - 2).each do |c|
+            window.write(c)
+          end
+          window.write(" ")
+          window.write(border_char_map[:tick_right])
+        end
+      end
+
+      def border_char_map
+        CharacterMap::DEFAULT
+      end
+
+      def format_tick_label(value)
+        "%.#{decimals}f" % value.round(decimals)
+      end
+
+      PositionedBin = Struct.new(:bin, :x, :y) do
+        extend(Forwardable)
+        def_delegators(:bin, :count, :min, :max, :midpoint)
+      end
+
+      def calculate_bin_coordinates(bins)
+        return [] unless bins.any?
+        max_count = bins.max_by { |bin| bin.count }&.count
+
+        bins.map.with_index do |bin, i|
+          row = i
+          # Save some chars for count
+          col = ((bin.count.to_f / max_count) * (bordered_window.inner_width - 4)).floor
+          PositionedBin.new(bin, col, row)
+        end
+      end
+
+      def bin_data(bins)
+        return [] unless bins.any?
+
+        dataset.each do |value|
+          bin = bins.find { |b| b.min <= value && b.max > value }
+          bin.count += 1 unless bin.nil?
+        end
+
+        bins
+      end
+
+      Bin = Struct.new(:min, :max, :count) do
+        def size
+          max - min
+        end
+
+        def midpoint
+          (max + min) / 2
+        end
+      end
+
+      def calculate_bins
+        return [] if dataset.empty?
+
+        min = dataset.min
+        max = dataset.max
+        bin_size = dataset.range.to_f / num_bins.to_f
+
+        if bin_size.zero?
+          min -= 1
+          max += 1
+          bin_size = 1
+        end
+
+        bins = []
+        while min < max && bins.length < num_bins
+          bins.push(Bin.new(min, min + bin_size, 0))
+          min += bin_size
+        end
+
+        # Correct for floating point errors on max bin
+        if bins.any?
+          bins.last.max = max if bins.last.max < max
+        end
+
+        bins
+      end
+
+      def bin_char
+        Colors.send(color, "▇")
+      end
+    end
+  end
+end