gruff 0.14.0 → 0.17.0

data/lib/gruff/bezier.rb

@@ -22,15 +22,17 @@ class Gruff::Bezier < Gruff::Base
 private
 
   def draw_graph
-    x_increment = @graph_width / (column_count - 1).to_f
+    x_increment = @graph_width / (column_count - 1)
 
     store.norm_data.each do |data_row|
+      next if data_row[1].empty?
+
       poly_points = []
 
       data_row[1].each_with_index do |data_point, index|
         # Use incremented x and scaled y
         new_x = @graph_left + (x_increment * index)
-        new_y = @graph_top + (@graph_height - data_point * @graph_height)
+        new_y = @graph_top + (@graph_height - (data_point * @graph_height))
 
         if index == 0 && RUBY_PLATFORM != 'java'
           poly_points << new_x

data/lib/gruff/box_plot.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+#
+# Here's how to set up a Gruff::BoxPlot.
+#
+#   g = Gruff::BoxPlot.new
+#   g.data "A", [2, 3, 5, 6, 8, 10, 11, 15, 17, 20, 28, 29, 33, 34, 45, 46, 49, 61]
+#   g.data "B", [3, 4, 34, 35, 38, 39, 45, 60, 61, 69, 80, 130]
+#   g.data "C", [4, 40, 41, 46, 57, 64, 77, 76, 79, 78, 99, 153]
+#   g.write("box_plot.png")
+#
+class Gruff::BoxPlot < Gruff::Base
+  # Specifies the filling opacity in area graph. Default is +0.2+.
+  attr_writer :fill_opacity
+
+  # Specifies the stroke width in line. Default is +3.0+.
+  attr_writer :stroke_width
+
+  # Can be used to adjust the spaces between the bars.
+  # Accepts values between 0.00 and 1.00 where 0.00 means no spacing at all
+  # and 1 means that each bars' width is nearly 0 (so each bar is a simple
+  # line with no x dimension).
+  #
+  # Default value is +0.8+.
+  def spacing_factor=(space_percent)
+    raise ArgumentError, 'spacing_factor must be between 0.00 and 1.00' unless (space_percent >= 0) && (space_percent <= 1)
+
+    @spacing_factor = (1 - space_percent)
+  end
+
+private
+
+  def initialize_attributes
+    super
+    @fill_opacity = 0.2
+    @stroke_width = 3.0
+    @spacing_factor = 0.8
+  end
+
+  def draw_graph
+    # Setup the BarConversion Object
+    conversion = Gruff::BarConversion.new(
+      top: @graph_top, bottom: @graph_bottom,
+      minimum_value: minimum_value, maximum_value: maximum_value, spread: @spread
+    )
+
+    width = (@graph_width - calculate_spacing) / column_count
+    bar_width = width * @spacing_factor
+    padding = width - bar_width
+
+    normalized_boxes.each_with_index do |box, index|
+      next if box.points.empty?
+
+      left_x = @graph_left + (width * index) + (padding / 2.0)
+      right_x = left_x + bar_width
+      center_x = (left_x + right_x) / 2.0
+
+      first_y, = conversion.get_top_bottom_scaled(box.first_quartile)
+      third_y, = conversion.get_top_bottom_scaled(box.third_quartile)
+      Gruff::Renderer::Rectangle.new(renderer, color: box.color, width: @stroke_width, opacity: @fill_opacity)
+                                .render(left_x, first_y, right_x, third_y)
+
+      median_y, = conversion.get_top_bottom_scaled(box.median)
+      Gruff::Renderer::Line.new(renderer, color: box.color, width: @stroke_width * 2).render(left_x, median_y, right_x, median_y)
+
+      minmax_left_x  = left_x + (bar_width / 4.0)
+      minmax_right_x = right_x - (bar_width / 4.0)
+      min_y, = conversion.get_top_bottom_scaled(box.lower_whisker)
+      Gruff::Renderer::Line.new(renderer, color: box.color, width: @stroke_width).render(minmax_left_x, min_y, minmax_right_x, min_y)
+      Gruff::Renderer::DashLine.new(renderer, color: box.color, width: @stroke_width, dasharray: [@stroke_width, @stroke_width * 2])
+                               .render(center_x, min_y, center_x, first_y)
+
+      max_y, = conversion.get_top_bottom_scaled(box.upper_whisker)
+      Gruff::Renderer::Line.new(renderer, color: box.color, width: @stroke_width).render(minmax_left_x, max_y, minmax_right_x, max_y)
+      Gruff::Renderer::DashLine.new(renderer, color: box.color, width: @stroke_width, dasharray: [@stroke_width, @stroke_width * 2])
+                               .render(center_x, max_y, center_x, third_y)
+
+      box.lower_outliers.each do |outlier|
+        outlier_y, = conversion.get_top_bottom_scaled(outlier)
+        Gruff::Renderer::Dot.new(renderer, :circle, color: box.color, opacity: @fill_opacity).render(center_x, outlier_y, @stroke_width * 2)
+      end
+
+      box.upper_outliers.each do |outlier|
+        outlier_y, = conversion.get_top_bottom_scaled(outlier)
+        Gruff::Renderer::Dot.new(renderer, :circle, color: box.color, opacity: @fill_opacity).render(center_x, outlier_y, @stroke_width * 2)
+      end
+
+      draw_label(center_x, index)
+    end
+  end
+
+  def normalized_boxes
+    @normalized_boxes ||= store.norm_data.map { |data| Gruff::BoxPlot::BoxData.new(data.label, data.points, data.color) }
+  end
+
+  def column_count
+    normalized_boxes.size
+  end
+
+  def calculate_spacing
+    @scale * (column_count - 1)
+  end
+
+  # @private
+  class BoxData < Struct.new(:label, :points, :color)
+    def initialize(label, points, color)
+      super(label, points.sort, color)
+    end
+
+    def min
+      points.first || 0
+    end
+
+    def max
+      points.last || 0
+    end
+
+    def min_whisker
+      [min, first_quartile - (1.5 * interquartile_range)].max
+    end
+
+    def max_whisker
+      [max, third_quartile + (1.5 * interquartile_range)].min
+    end
+
+    def upper_whisker
+      max = max_whisker
+      points.select { |point| point <= max }.max
+    end
+
+    def lower_whisker
+      min = min_whisker
+      points.select { |point| point >= min }.min
+    end
+
+    def median
+      if points.size.zero?
+        0
+      elsif points.size.odd?
+        points[points.size / 2]
+      else
+        (points[points.size / 2] + points[(points.size / 2) - 1]) / 2.0
+      end
+    end
+
+    def first_quartile
+      if points.size.zero?
+        0
+      elsif points.size.odd?
+        points[points.size / 4]
+      else
+        (points[points.size / 4] + points[(points.size / 4) - 1]) / 2.0
+      end
+    end
+
+    def third_quartile
+      if points.size.zero?
+        0
+      elsif points.size.odd?
+        points[(points.size * 3) / 4]
+      else
+        (points[(points.size * 3) / 4] + points[((points.size * 3) / 4) - 1]) / 2.0
+      end
+    end
+
+    def lower_outliers
+      min = lower_whisker
+      points.select { |point| point < min }
+    end
+
+    def upper_outliers
+      max = upper_whisker
+      points.select { |point| point > max }
+    end
+
+    def interquartile_range
+      third_quartile - first_quartile
+    end
+  end
+end

data/lib/gruff/bullet.rb

@@ -64,26 +64,26 @@ class Gruff::Bullet < Gruff::Base
     rect_renderer = Gruff::Renderer::Rectangle.new(renderer, color: @colors[0])
     rect_renderer.render(graph_left, 0, graph_left + graph_width, graph_height)
 
-    [:high, :low].each_with_index do |indicator, index|
+    %i[high low].each_with_index do |indicator, index|
       next unless @options.key?(indicator)
 
-      indicator_width_x = graph_left + graph_width * (@options[indicator] / maximum_value)
+      indicator_width_x = graph_left + (graph_width * (@options[indicator] / maximum_value))
 
       rect_renderer = Gruff::Renderer::Rectangle.new(renderer, color: @colors[index + 1])
       rect_renderer.render(graph_left, 0, indicator_width_x, graph_height)
     end
 
     if @options.key?(:target)
-      target_x = graph_left + graph_width * (@options[:target] / maximum_value)
+      target_x = graph_left + (graph_width * (@options[:target] / maximum_value))
       half_thickness = thickness / 2.0
 
       rect_renderer = Gruff::Renderer::Rectangle.new(renderer, color: @marker_color)
-      rect_renderer.render(target_x, half_thickness, target_x + half_thickness, thickness * 2 + half_thickness)
+      rect_renderer.render(target_x, half_thickness, target_x + half_thickness, (thickness * 2) + half_thickness)
     end
 
     # Value
     rect_renderer = Gruff::Renderer::Rectangle.new(renderer, color: @marker_color)
-    rect_renderer.render(graph_left, thickness, graph_left + graph_width * (@value / maximum_value), thickness * 2)
+    rect_renderer.render(graph_left, thickness, graph_left + (graph_width * (@value / maximum_value)), thickness * 2)
   end
 
 private
@@ -94,6 +94,6 @@ private
     font_height = calculate_caps_height(@title_font)
 
     text_renderer = Gruff::Renderer::Text.new(renderer, @title, font: @title_font)
-    text_renderer.add_to_render_queue(1.0, 1.0, font_height / 2, font_height / 2, Magick::NorthWestGravity)
+    text_renderer.add_to_render_queue(1.0, 1.0, font_height / 2.0, font_height / 2.0, Magick::NorthWestGravity)
   end
 end

data/lib/gruff/candlestick.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+#
+# Here's how to set up a Gruff::Candlestick.
+#
+#   g = Gruff::Candlestick.new
+#   g.data low:  79.30, high:  93.10, open:  79.44, close:  91.20
+#   g.data low:  89.14, high: 106.42, open:  91.28, close: 106.26
+#   g.data low: 107.89, high: 131.00, open: 108.20, close: 129.04
+#   g.data low: 103.10, high: 137.98, open: 132.76, close: 115.81
+#   g.write("candlestick.png")
+#
+class Gruff::Candlestick < Gruff::Base
+  # Allow for vertical marker lines.
+  attr_writer :show_vertical_markers
+
+  # Specifies the filling opacity in area graph. Default is +0.4+.
+  attr_writer :fill_opacity
+
+  # Specifies the stroke width in line. Default is +2.0+.
+  attr_writer :stroke_width
+
+  # Specifies the color with up bar. Default is +'#579773'+.
+  attr_writer :up_color
+
+  # Specifies the color with down bar. Default is +'#eb5242'+.
+  attr_writer :down_color
+
+  # Can be used to adjust the spaces between the bars.
+  # Accepts values between 0.00 and 1.00 where 0.00 means no spacing at all
+  # and 1 means that each bars' width is nearly 0 (so each bar is a simple
+  # line with no x dimension).
+  #
+  # Default value is +0.9+.
+  def spacing_factor=(space_percent)
+    raise ArgumentError, 'spacing_factor must be between 0.00 and 1.00' unless (space_percent >= 0) && (space_percent <= 1)
+
+    @spacing_factor = (1 - space_percent)
+  end
+
+  # The sort feature is not supported in this graph.
+  def sort=(_value)
+    raise 'Not support #sort= in Gruff::Candlestick'
+  end
+
+  # The sort feature is not supported in this graph.
+  def sorted_drawing=(_value)
+    raise 'Not support #sorted_drawing= in Gruff::Candlestick'
+  end
+
+  def data(low:, high:, open:, close:)
+    super('', [low, high, open, close])
+  end
+
+private
+
+  def initialize_attributes
+    super
+    @show_vertical_markers = false
+    @fill_opacity = 0.4
+    @spacing_factor = 0.9
+    @stroke_width = 2.0
+    @up_color = '#579773'
+    @down_color = '#eb5242'
+
+    @hide_legend = true
+  end
+
+  def draw_graph
+    # Setup the BarConversion Object
+    conversion = Gruff::BarConversion.new(
+      top: @graph_top, bottom: @graph_bottom,
+      minimum_value: minimum_value, maximum_value: maximum_value, spread: @spread
+    )
+
+    width = (@graph_width - calculate_spacing) / column_count
+    bar_width = width * @spacing_factor
+    padding = width - bar_width
+
+    normalized_candlesticks.each_with_index do |candlestick, index|
+      left_x = @graph_left + (width * index) + (padding / 2.0)
+      right_x = left_x + bar_width
+      center_x = (left_x + right_x) / 2.0
+      color = candlestick.close >= candlestick.open ? @up_color : @down_color
+
+      draw_label(center_x, index) { draw_marker_vertical_line(center_x) if show_marker_vertical_line? }
+
+      open_y, = conversion.get_top_bottom_scaled(candlestick.open)
+      close_y, = conversion.get_top_bottom_scaled(candlestick.close)
+      Gruff::Renderer::Rectangle.new(renderer, color: color, opacity: @fill_opacity, width: @stroke_width).render(left_x, open_y, right_x, close_y)
+
+      low_y, = conversion.get_top_bottom_scaled(candlestick.low)
+      y = open_y < close_y ? close_y : open_y
+      Gruff::Renderer::Line.new(renderer, color: color, width: @stroke_width).render(center_x, low_y, center_x, y)
+      high_y, = conversion.get_top_bottom_scaled(candlestick.high)
+      y = open_y > close_y ? close_y : open_y
+      Gruff::Renderer::Line.new(renderer, color: color, width: @stroke_width).render(center_x, y, center_x, high_y)
+    end
+  end
+
+  def normalized_candlesticks
+    @normalized_candlesticks ||= store.norm_data.map { |data| Gruff::Candlestick::CandlestickData.new(*data.points) }
+  end
+
+  def column_count
+    normalized_candlesticks.size
+  end
+
+  def calculate_spacing
+    @scale * (column_count - 1)
+  end
+
+  def show_marker_vertical_line?
+    !@hide_line_markers && @show_vertical_markers
+  end
+
+  # @private
+  class CandlestickData < Struct.new(:low, :high, :open, :close)
+  end
+end

data/lib/gruff/dot.rb

@@ -14,32 +14,33 @@
 #   g.write('dot.png')
 #
 class Gruff::Dot < Gruff::Base
-private
-
-  def initialize_attributes
+  def initialize(*)
     super
     @has_left_labels = true
+    @dot_style = 'circle'
   end
 
+private
+
   def draw_graph
     # Setup spacing.
     #
     spacing_factor = 1.0
 
-    items_width = @graph_height / column_count.to_f
+    items_width = @graph_height / column_count
     item_width = items_width * spacing_factor / store.length
     padding = (items_width * (1 - spacing_factor)) / 2
 
     store.norm_data.each_with_index do |data_row, row_index|
       data_row.points.each_with_index do |data_point, point_index|
         x_pos = @graph_left + (data_point * @graph_width)
-        y_pos = @graph_top + (items_width * point_index) + padding + (items_width.to_f / 2.0).round
+        y_pos = @graph_top + (items_width * point_index) + padding + (items_width / 2.0)
 
         if row_index == 0
           Gruff::Renderer::Line.new(renderer, color: @marker_color).render(@graph_left, y_pos, @graph_left + @graph_width, y_pos)
         end
 
-        Gruff::Renderer::Circle.new(renderer, color: data_row.color).render(x_pos, y_pos, x_pos + (item_width.to_f / 3.0).round, y_pos)
+        Gruff::Renderer::Dot.new(renderer, @dot_style, color: data_row.color).render(x_pos, y_pos, item_width / 3.0)
 
         draw_label(y_pos, point_index)
       end
@@ -51,11 +52,9 @@ private
     return if @hide_line_markers
 
     (0..marker_count).each do |index|
-      marker_label = BigDecimal(index.to_s) * BigDecimal(@increment.to_s) + BigDecimal(minimum_value.to_s)
-      x = @graph_left + (marker_label - minimum_value) * @graph_width / @spread
-
-      line_renderer = Gruff::Renderer::Line.new(renderer, color: @marker_color, shadow_color: @marker_shadow_color)
-      line_renderer.render(x, @graph_bottom, x, @graph_bottom + 5)
+      marker_label = (BigDecimal(index.to_s) * BigDecimal(@increment.to_s)) + BigDecimal(minimum_value.to_s)
+      x = @graph_left + ((marker_label - minimum_value) * @graph_width / @spread)
+      draw_marker_vertical_line(x, tick_mark_mode: true)
 
       unless @hide_line_numbers
         label = y_axis_label(marker_label, @increment)
@@ -70,7 +69,7 @@ private
 
   def draw_label(y_offset, index)
     draw_unique_label(index) do
-      draw_label_at(@graph_left - LABEL_MARGIN, 1.0, 0.0, y_offset, @labels[index], Magick::EastGravity)
+      draw_label_at(@graph_left - LABEL_MARGIN, 1.0, 0.0, y_offset, @labels[index], gravity: Magick::EastGravity)
     end
   end
 end

data/lib/gruff/font.rb

@@ -3,7 +3,10 @@
 # Handle font setting to draw texts
 class Gruff::Font
   BOLD_PATH = File.expand_path(File.join(__FILE__, '../../../assets/fonts/Roboto-Bold.ttf')).freeze
+  private_constant :BOLD_PATH
+
   REGULAR_PATH = File.expand_path(File.join(__FILE__, '../../../assets/fonts/Roboto-Regular.ttf')).freeze
+  private_constant :REGULAR_PATH
 
   # Get/set font path.
   attr_accessor :path

data/lib/gruff/helper/bar_conversion.rb

@@ -13,8 +13,6 @@
 #
 # @private
 class Gruff::BarConversion
-  attr_writer :mode
-
   def initialize(top:, bottom:, minimum_value:, maximum_value:, spread:)
     @graph_top = top
     @graph_height = bottom - top
@@ -36,25 +34,23 @@ class Gruff::BarConversion
   end
 
   def get_top_bottom_scaled(data_point)
+    data_point = data_point.to_f
     result = []
 
     case @mode
     when 1
       # minimum value >= 0 ( only positive values )
-      result[0] = @graph_top + @graph_height * (1 - data_point)
+      result[0] = @graph_top + (@graph_height * (1 - data_point))
       result[1] = @graph_top + @graph_height
     when 2
       # only negative values
       result[0] = @graph_top
-      result[1] = @graph_top + @graph_height * (1 - data_point)
+      result[1] = @graph_top + (@graph_height * (1 - data_point))
     when 3
       # positive and negative values
-      val = data_point - @minimum_value / @spread
-      result[0] = @graph_top + @graph_height * (1 - (val - @zero))
-      result[1] = @graph_top + @graph_height * (1 - @zero)
-    else
-      result[0] = 0.0
-      result[1] = 0.0
+      val = data_point - (@minimum_value / @spread)
+      result[0] = @graph_top + (@graph_height * (1 - (val - @zero)))
+      result[1] = @graph_top + (@graph_height * (1 - @zero))
     end
 
     result

data/lib/gruff/helper/bar_mixin.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# @private
+module Gruff::Base::BarMixin
+  def normalized_group_bars
+    @normalized_group_bars ||= begin
+      group_bars = Array.new(column_count) { [] }
+      store.norm_data.each_with_index do |data_row, row_index|
+        data_row.points.each_with_index do |data_point, point_index|
+          group_bars[point_index] << BarData.new(data_point, store.data[row_index].points[point_index], data_row.color)
+        end
+
+        # Adjust the number of each group with empty bar
+        (data_row.points.size..(column_count - 1)).each do |index|
+          group_bars[index] << BarData.new(0, nil, data_row.color)
+        end
+      end
+      group_bars
+    end
+  end
+
+  # @private
+  class BarData < Struct.new(:point, :value, :color)
+  end
+end

data/lib/gruff/helper/bar_value_label.rb

@@ -4,6 +4,20 @@
 module Gruff::BarValueLabel
   using String::GruffCommify
 
+  # @private
+  def self.metrics(value, format, proc_text_metrics)
+    val = begin
+      if format.is_a?(Proc)
+        format.call(value)
+      else
+        sprintf(format || '%.2f', value).commify
+      end
+    end
+
+    metrics = proc_text_metrics.call(val)
+    [val, metrics]
+  end
+
   # @private
   class Base
     attr_reader :coordinate, :value
@@ -16,53 +30,23 @@ module Gruff::BarValueLabel
 
   # @private
   class Bar < Base
-    def prepare_rendering(format, _bar_width = 0)
-      left_x, left_y, right_x, _right_y = @coordinate
-      if format.is_a?(Proc)
-        val = format.call(@value)
-      else
-        val = sprintf(format || '%.2f', @value).commify
-      end
+    def prepare_rendering(format, proc_text_metrics)
+      left_x, left_y, _right_x, _right_y = @coordinate
+      val, metrics = Gruff::BarValueLabel.metrics(@value, format, proc_text_metrics)
 
-      y = @value >= 0 ? left_y - 30 : left_y + 12
-      yield left_x + (right_x - left_x) / 2, y, val
+      y = @value >= 0 ? left_y - metrics.height - 5 : left_y + 5
+      yield left_x, y, val, metrics.width, metrics.height
     end
   end
 
   # @private
   class SideBar < Base
-    def prepare_rendering(format, bar_width = 0)
-      left_x, _left_y, right_x, right_y = @coordinate
-      if format.is_a?(Proc)
-        val = format.call(@value)
-      else
-        val = sprintf(format || '%.2f', @value).commify
-      end
-
-      x = @value >= 0 ? right_x + 40 : left_x - 40
-      yield x, right_y - bar_width / 2, val
-    end
-  end
-
-  # @private
-  class StackedBar
-    def initialize
-      @bars = []
-    end
-
-    def add(bar, index)
-      bars = @bars[index] || []
-      bars << bar
-      @bars[index] = bars
-    end
+    def prepare_rendering(format, proc_text_metrics)
+      left_x, left_y, right_x, _right_y = @coordinate
+      val, metrics = Gruff::BarValueLabel.metrics(@value, format, proc_text_metrics)
 
-    def prepare_rendering(format, bar_width = 0, &block)
-      @bars.each do |bars|
-        value = bars.sum(&:value)
-        bar = bars.last
-        bar_value_label = bar.class.new(bar.coordinate, value)
-        bar_value_label.prepare_rendering(format, bar_width, &block)
-      end
+      x = @value >= 0 ? right_x + 10 : left_x - metrics.width - 10
+      yield x, left_y, val, metrics.width, metrics.height
     end
   end
 end

data/lib/gruff/helper/stacked_mixin.rb

@@ -16,7 +16,25 @@ module Gruff::Base::StackedMixin
 
     max_hash.each_key do |key|
       self.maximum_value = max_hash[key] if max_hash[key] > maximum_value
+      self.minimum_value = max_hash[key] if max_hash[key] < minimum_value
     end
-    self.minimum_value = 0
+
+    raise "Can't handle negative values in stacked graph" if minimum_value < 0
+  end
+
+  def normalized_stacked_bars
+    @normalized_stacked_bars ||= begin
+      stacked_bars = Array.new(column_count) { [] }
+      store.norm_data.each_with_index do |data_row, row_index|
+        data_row.points.each_with_index do |data_point, point_index|
+          stacked_bars[point_index] << BarData.new(data_point, store.data[row_index].points[point_index], data_row.color)
+        end
+      end
+      stacked_bars
+    end
+  end
+
+  # @private
+  class BarData < Struct.new(:point, :value, :color)
   end
 end

data/lib/gruff/histogram.rb

@@ -29,7 +29,7 @@ class Gruff::Histogram < Gruff::Bar
   end
 
   def data(name, data_points = [], color = nil)
-    @data << [name, data_points, color]
+    @data << [name, Array(data_points), color]
   end
 
 private
@@ -44,11 +44,15 @@ private
 
   def setup_data
     @data.each do |(name, data_points, color)|
-      bins, freqs = HistogramArray.new(data_points).histogram(bin_width: @bin_width, min: @minimum_bin, max: @maximum_bin)
-      bins.each_with_index do |bin, index|
-        @labels[index] = bin
+      if data_points.empty?
+        store.add(name, [], color)
+      else
+        bins, freqs = HistogramArray.new(data_points).histogram(bin_width: @bin_width, min: @minimum_bin, max: @maximum_bin)
+        bins.each_with_index do |bin, index|
+          @labels[index] = bin
+        end
+        store.add(name, freqs, color)
       end
-      store.add(name, freqs, color)
     end
 
     super