termplot 0.1.0 → 0.3.1

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

data/lib/termplot/widgets/statistics.rb

@@ -0,0 +1,21 @@
+module Termplot
+  module Widgets
+    module Statistics
+      def count
+        data.count
+      end
+
+      def mean
+        return 0 if data.empty?
+        data.sum(0.0) / count
+      end
+
+      def standard_deviation
+        return 0 if data.empty?
+        data_mean = mean
+        variance = data.map { |x| (data_mean - x) ** 2 }.sum / count
+        Math.sqrt(variance)
+      end
+    end
+  end
+end

data/lib/termplot/widgets/statistics_widget.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "termplot/window"
+require "termplot/renderable"
+require "termplot/window"
+require "termplot/character_map"
+require "termplot/renderers"
+
+module Termplot
+  module Widgets
+    class StatisticsWidget < BaseWidget
+      def render_to_window
+        errors.clear
+        window.clear
+        window.cursor.reset_position
+
+        render_statistics
+        window.cursor.reset_position
+
+        # Title bar
+        Termplot::Renderers::TextRenderer.new(
+          bordered_window: bordered_window,
+          text: title,
+          row: 0,
+          align: :center,
+          errors: errors
+        ).render
+
+        window.cursor.reset_position
+
+        # Borders
+        Termplot::Renderers::BorderRenderer.new(
+          bordered_window: bordered_window
+        ).render
+
+        window.cursor.reset_position
+      end
+
+      private
+      def default_border_size
+        Border.new(2, 1, 1, 1)
+      end
+
+      def min_cols
+        20
+      end
+
+      def min_rows
+        5 + default_border_size.top + default_border_size.bottom
+      end
+
+      def render_statistics
+        titles, values = formatted_stats
+
+        window.cursor.down(bordered_window.border_size.top)
+        window.cursor.beginning_of_line
+        window.cursor.forward(bordered_window.border_size.left)
+
+        title_color = "blue"
+        value_color = "green"
+
+        justified_stats = titles.zip(values).map do |(title, value)|
+          field_size = [title.size, value.size].max
+          title = Colors.send(title_color, title.ljust(field_size, " "))
+          value = Colors.send(value_color, value.ljust(field_size, " "))
+          [title, value]
+        end
+
+        col_separator = " #{border_char_map[:vert_right]} "
+        stats_table = justified_stats.transpose.map { |row| row.join(col_separator) }
+
+        start_row = bordered_window.inner_height > 2 ? bordered_window.border_size.top - 1 + bordered_window.inner_height / 2 : bordered_window.border_size.top
+
+        stats_table.each_with_index do |row, index|
+          Termplot::Renderers::TextRenderer.new(
+            bordered_window: bordered_window,
+            text: row,
+            row: start_row + index,
+            errors: errors,
+            align: :center
+          ).render
+        end
+      end
+
+      def formatted_stats
+        titles = %w[Samples Min Max Mean Stdev]
+
+        values = [:count, :min, :max, :mean, :standard_deviation].map do |stat|
+          format_number(dataset.send(stat))
+        end
+
+        [titles, values]
+      end
+
+      def format_number(n)
+        "%.#{decimals}f" % n.round(decimals)
+      end
+
+      def border_char_map
+        CharacterMap::DEFAULT
+      end
+    end
+  end
+end

data/lib/termplot/widgets/time_series_widget.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "termplot/window"
+require "termplot/character_map"
+require "termplot/colors"
+require "termplot/renderable"
+require "termplot/renderers"
+
+module Termplot
+  module Widgets
+    class TimeSeriesWidget < BaseWidget
+      DEFAULT_COLOR = "yellow"
+      DEFAULT_LINE_STYLE = "line"
+
+      attr_reader :color, :line_style, :tick_spacing
+
+      def post_initialize(opts)
+        @color = Termplot::Colors.fetch(opts[:color], DEFAULT_COLOR)
+        @line_style = Termplot::CharacterMap::LINE_STYLES.fetch(
+          opts[:line_style],
+          Termplot::CharacterMap::LINE_STYLES[DEFAULT_LINE_STYLE]
+        )
+
+        @tick_spacing = 3
+      end
+
+      def render_to_window
+        errors.clear
+        window.clear
+
+        # Calculate width of right hand axis
+        calculate_axis_size
+
+        # Points
+        points = build_points
+        render_points(points)
+        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
+
+        # Draw axis
+        ticks = build_ticks(points)
+        render_axis(ticks)
+      end
+
+      private
+      def max_count
+        bordered_window.inner_width
+      end
+
+      # Axis size = length of the longest point value , formatted as a string to
+      # @decimals decimal places, + 2 for some extra buffer + 1 for the border
+      # itself.
+      def calculate_axis_size
+        return if dataset.empty?
+        border_right = dataset.map { |n| n.round(decimals).to_s.length }.max
+        border_right += 3
+
+        # Clamp border_right at cols - 3 to prevent the renderer from crashing
+        # with very large numbers
+        if border_right > cols - 3
+          errors.push(Colors.yellow("Warning: Axis tick values have been clipped, consider using more columns with -c"))
+          border_right = cols - 3
+        end
+
+        @bordered_window.border_size = Border.new(2, border_right, 1, 1)
+      end
+
+      def border_char_map
+        CharacterMap::DEFAULT
+      end
+
+      def default_border_size
+        Border.new(2, 4, 1, 1)
+      end
+
+      # At minimum, 2 cols of inner_width for values
+      def min_cols
+        default_border_size.left + default_border_size.right + 2
+      end
+
+      # At minimum, 2 rows of inner_height for values
+      def min_rows
+        default_border_size.top + default_border_size.bottom + 2
+      end
+
+      Point = Struct.new(:x, :y, :value)
+      def build_points
+        return [] if dataset.empty?
+
+        dataset.map.with_index do |p, x|
+          # Map from series Y range to inner height
+          y = map_value(p, [dataset.min, dataset.max], [0, bordered_window.inner_height - 1])
+
+          # Invert Y value since pixel Y is inverse of cartesian Y
+          y = bordered_window.border_size.top - 1 + bordered_window.inner_height - y.round
+
+          # Add padding for border width
+          Point.new(x + bordered_window.border_size.left, y, p.to_f)
+        end
+      end
+
+      def render_points(points)
+        # Render points
+        points.each_with_index do |point, i|
+          window.cursor.position = point.y * cols + point.x
+
+          if line_style[:extended]
+            prev_point = ((i - 1) >= 0) ? points[i - 1] : nil
+            render_connected_line(prev_point, point)
+          elsif line_style[:filled]
+            render_filled_point(point)
+          else
+            window.write(colored(line_style[:point]))
+          end
+        end
+      end
+
+      def render_connected_line(prev_point, point)
+        if prev_point.nil? || (prev_point.y == point.y)
+          window.write(colored(line_style[:horz_top]))
+        elsif prev_point.y > point.y
+          diff = prev_point.y - point.y
+
+          window.write(colored(line_style[:top_left]))
+          window.cursor.down
+          window.cursor.back
+
+          (diff - 1).times do
+            window.write(colored(line_style[:vert_right]))
+            window.cursor.down
+            window.cursor.back
+          end
+
+          window.write(colored(line_style[:bot_right]))
+        elsif prev_point.y < point.y
+          diff = point.y - prev_point.y
+
+          window.write(colored(line_style[:bot_left]))
+          window.cursor.up
+          window.cursor.back
+
+          (diff - 1).times do
+            window.write(colored(line_style[:vert_left]))
+            window.cursor.up
+            window.cursor.back
+          end
+
+          window.write(colored(line_style[:top_right]))
+        end
+      end
+
+      def render_filled_point(point)
+        diff = (bordered_window.inner_height + bordered_window.border_size.bottom) - point.y
+        diff.times { window.cursor.down }
+
+        diff.times do
+          window.write(Colors.send("#{color}_bg", colored(line_style[:point])))
+          window.cursor.up
+          window.cursor.back
+        end
+
+        window.write(colored(line_style[:point]))
+      end
+
+      Tick = Struct.new(:y, :label)
+      def build_ticks(points)
+        return [] if points.empty?
+        max_point = points.max_by(&:value)
+        min_point = points.min_by(&:value)
+        point_y_range = points.max_by(&:y).y - points.min_by(&:y).y
+        ticks = []
+        ticks.push(Tick.new(max_point.y, format_label(max_point.value)))
+
+        # Distribute ticks between min and max, maintaining spacinig as much as
+        # possible. tick_spacing is inclusive of the tick row itself.
+        if max_point.value != min_point.value && (point_y_range - 2) > tick_spacing
+          num_ticks = (point_y_range - 2) / tick_spacing
+
+          num_ticks.times do |i|
+            tick_y = max_point.y + (i + 1) * tick_spacing
+            value = max_point.value - dataset.range * ((i + 1) * tick_spacing) / point_y_range
+            ticks.push(Tick.new(tick_y, format_label(value)))
+          end
+        end
+
+        ticks.push(Tick.new(min_point.y, format_label(min_point.value)))
+        ticks
+      end
+
+      # Map value from one range to another
+      def map_value(val, from_range, to_range)
+        orig_range = [1, (from_range[1] - from_range[0]).abs].max
+        new_range = [1, (to_range[1] - to_range[0]).abs].max
+
+        ((val.to_f - from_range[0]) / orig_range) * new_range + to_range[0]
+      end
+
+      def title_text
+        colored(line_style[:point]) + " " + title
+      end
+
+      def render_axis(ticks)
+        window.cursor.down(bordered_window.border_size.top - 1)
+        window.cursor.forward(bordered_window.border_size.left + bordered_window.inner_width + 1)
+
+        # Render ticks
+        ticks.each do |tick|
+          window.cursor.row = tick.y
+          window.cursor.back
+          window.write(border_char_map[:tick_right])
+
+          tick.label.chars.each do |c|
+            window.write(c)
+          end
+
+          window.cursor.back(label_chars)
+        end
+      end
+
+      def format_label(num)
+        ("%.#{decimals}f" % num.round(decimals))[0..label_chars - 1].ljust(label_chars, " ")
+      end
+
+      def label_chars
+        bordered_window.border_size.right - 2
+      end
+
+      def colored(text)
+        Colors.send(color, text)
+      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/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
@@ -35,6 +35,7 @@ module Termplot
       size.times { write CharacterMap::DEFAULT[:empty] }
     end
 
+    # Flush rendered window to a string
     def flush
       console_cursor.clear_buffer
       console_cursor.reset_position
@@ -47,16 +48,17 @@ module Termplot
       console_cursor.flush
     end
 
-    def flush_debug(str = "Window")
-      padding = "-" * 10
-      puts "\n#{padding} #{str} #{padding}\n"
+    # Flush to 2d array rather than string
+    def flush_debug
+      debug_arr = []
       buffer.each_slice(cols).with_index do |line, y|
         render_line = line.each_with_index.map do |c, x|
           y * cols + x == cursor.position ? "𝥺" : c
         end
-        print render_line
-        puts
+        debug_arr << render_line
+        debug_arr << "\n"
       end
+      debug_arr
     end
 
     # TODO: Refine later and include errors properly in the window
@@ -65,5 +67,23 @@ module Termplot
       print Termplot::ControlChars::NEWLINE
       errors.length.times { print Termplot::ControlChars::UP }
     end
+
+    def blit(other, start_row, start_col)
+      cursor.position = start_row * cols + start_col
+
+      other.each_row do |row|
+        row.each do |char|
+          write(char)
+        end
+        cursor.down unless cursor.beginning_of_line?
+        cursor.col = start_col
+      end
+    end
+
+    def each_row
+      buffer.each_slice(cols) do |row|
+        yield row
+      end
+    end
   end
 end

data/termplot.gemspec

@@ -10,9 +10,7 @@ Gem::Specification.new do |spec|
   spec.description   = %q{Plot time series charts in your terminal}
   spec.homepage      = "https://github.com/Martin-Nyaga/termplot"
   spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
-
-  # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/Martin-Nyaga/termplot" 
@@ -26,7 +24,4 @@ Gem::Specification.new do |spec|
   spec.bindir        = "bin"
   spec.executables   = "termplot"
   spec.require_paths = ["lib"]
-
-  # Dependencies
-  spec.add_runtime_dependency "ruby-termios", "~> 1.0"
 end