gruff 0.13.0 → 0.16.0

data/lib/gruff/bezier.rb

@@ -19,12 +19,10 @@
 #   g.write('bezier.png')
 #
 class Gruff::Bezier < Gruff::Base
-  def draw
-    super
+private
 
-    return unless data_given?
-
-    x_increment = @graph_width / (column_count - 1).to_f
+  def draw_graph
+    x_increment = @graph_width / (column_count - 1)
 
     store.norm_data.each do |data_row|
       poly_points = []
@@ -32,7 +30,7 @@ class Gruff::Bezier < Gruff::Base
       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
@@ -48,9 +46,9 @@ class Gruff::Bezier < Gruff::Base
       stroke_width = clip_value_if_greater_than(@columns / (store.norm_data.first[1].size * 4), 5.0)
 
       if RUBY_PLATFORM == 'java'
-        Gruff::Renderer::Polyline.new(color: data_row.color, width: stroke_width).render(poly_points)
+        Gruff::Renderer::Polyline.new(renderer, color: data_row.color, width: stroke_width).render(poly_points)
       else
-        Gruff::Renderer::Bezier.new(color: data_row.color, width: stroke_width).render(poly_points)
+        Gruff::Renderer::Bezier.new(renderer, color: data_row.color, width: stroke_width).render(poly_points)
       end
     end
   end

data/lib/gruff/box_plot.rb

@@ -0,0 +1,174 @@
+# 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) / normalized_boxes.size
+    bar_width = width * @spacing_factor
+    padding = width - bar_width
+
+    normalized_boxes.each_with_index do |box, index|
+      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 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

@@ -27,12 +27,13 @@ class Gruff::Bullet < Gruff::Base
     self.theme = Gruff::Themes::GREYSCALE
   end
 
-  def initialize_ivars
+  def initialize_attributes
     super
 
-    @title_font_size = 20
+    @title_font.size = 20
+    @title_font.bold = false
   end
-  private :initialize_ivars
+  private :initialize_attributes
 
   def data(value, maximum_value, options = {})
     @value = value.to_f
@@ -51,7 +52,7 @@ class Gruff::Bullet < Gruff::Base
 
     draw_title
 
-    title_width  = calculate_width(@title_font_size, @title)
+    title_width  = calculate_width(@title_font, @title)
     margin       = 30.0
     thickness    = @raw_rows / 6.0
     right_margin = margin
@@ -60,29 +61,29 @@ class Gruff::Bullet < Gruff::Base
     graph_height = thickness * 3.0
 
     # Background
-    rect_renderer = Gruff::Renderer::Rectangle.new(color: @colors[0])
+    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(color: @colors[index + 1])
+      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(color: @font_color)
-      rect_renderer.render(target_x, half_thickness, target_x + half_thickness, thickness * 2 + half_thickness)
+      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)
     end
 
     # Value
-    rect_renderer = Gruff::Renderer::Rectangle.new(color: @font_color)
-    rect_renderer.render(graph_left, thickness, graph_left + graph_width * (@value / maximum_value), thickness * 2)
+    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)
   end
 
 private
@@ -90,9 +91,9 @@ private
   def draw_title
     return if hide_title?
 
-    font_height = calculate_caps_height(scale_fontsize(@title_font_size))
+    font_height = calculate_caps_height(@title_font)
 
-    text_renderer = Gruff::Renderer::Text.new(@title, font: @font, size: @title_font_size, color: @font_color)
-    text_renderer.add_to_render_queue(1.0, 1.0, font_height / 2, font_height / 2, Magick::NorthWestGravity)
+    text_renderer = Gruff::Renderer::Text.new(renderer, @title, font: @title_font)
+    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,112 @@
+# 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
+
+  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'
+
+    @sort = false
+    @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) / normalized_candlesticks.size
+    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) do
+        break if @hide_line_markers
+        break unless @show_vertical_markers
+
+        Gruff::Renderer::Line.new(renderer, color: @marker_color).render(center_x, @graph_bottom, center_x, @graph_top)
+        if @marker_shadow_color
+          Gruff::Renderer::Line.new(renderer, color: @marker_shadow_color)
+                               .render(center_x + 1, @graph_bottom, center_x + 1, @graph_top)
+        end
+      end
+
+      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
+    @candlesticks ||= store.norm_data.map { |data| Gruff::Candlestick::CandlestickData.new(*data.points) }
+  end
+
+  def calculate_spacing
+    @scale * (column_count - 1)
+  end
+
+  # @private
+  class CandlestickData < Struct.new(:low, :high, :open, :close)
+  end
+end

data/lib/gruff/dot.rb

@@ -14,52 +14,52 @@
 #   g.write('dot.png')
 #
 class Gruff::Dot < Gruff::Base
-  def draw
-    @has_left_labels = true
+  def initialize(*)
     super
+    @has_left_labels = true
+  end
 
-    return unless data_given?
+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(color: @marker_color).render(@graph_left, y_pos, @graph_left + @graph_width, y_pos)
+          Gruff::Renderer::Line.new(renderer, color: @marker_color).render(@graph_left, y_pos, @graph_left + @graph_width, y_pos)
         end
 
-        Gruff::Renderer::Circle.new(color: data_row.color).render(x_pos, y_pos, x_pos + (item_width.to_f / 3.0).round, y_pos)
+        Gruff::Renderer::Circle.new(renderer, color: data_row.color).render(x_pos, y_pos, x_pos + (item_width / 3.0), y_pos)
 
         draw_label(y_pos, point_index)
       end
     end
   end
 
-protected
-
   # Instead of base class version, draws vertical background lines and label
   def draw_line_markers
     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
+      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(color: @marker_color, shadow_color: @marker_shadow_color)
-      line_renderer.render(x, @graph_bottom, x, @graph_bottom + 5)
+      Gruff::Renderer::Line.new(renderer, color: @marker_color).render(x, @graph_bottom, x, @graph_bottom + 5)
+      Gruff::Renderer::Line.new(renderer, color: @marker_shadow_color).render(x, @graph_bottom + 1, x, @graph_bottom + 6) if @marker_shadow_color
 
       unless @hide_line_numbers
         label = y_axis_label(marker_label, @increment)
-        text_renderer = Gruff::Renderer::Text.new(label, font: @font, size: @marker_font_size, color: @font_color)
+        text_renderer = Gruff::Renderer::Text.new(renderer, label, font: @marker_font)
         text_renderer.add_to_render_queue(0, 0, x, @graph_bottom + (LABEL_MARGIN * 1.5), Magick::CenterGravity)
       end
     end

data/lib/gruff/font.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# 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
+
+  # Get/set font size.
+  attr_accessor :size
+
+  # Get/set font setting whether render bold text.
+  attr_accessor :bold
+
+  # Get/set font color.
+  attr_accessor :color
+
+  def initialize(path: nil, size: 20.0, bold: false, color: 'white')
+    @path = path
+    @bold = bold
+    @size = size
+    @color = color
+  end
+
+  # Get font weight.
+  # @return [Magick::WeightType] font weight
+  def weight
+    @bold ? Magick::BoldWeight : Magick::NormalWeight
+  end
+
+  # @private
+  def file_path
+    return @path if @path
+
+    @bold ? BOLD_PATH : REGULAR_PATH
+  end
+end

data/lib/gruff/helper/bar_conversion.rb

@@ -41,17 +41,17 @@ class Gruff::BarConversion
     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)
+      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

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,31 +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
+    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)
 
-      x = @value >= 0 ? right_x + 40 : left_x - 40
-      yield x, right_y - bar_width / 2, val
+      x = @value >= 0 ? right_x + 10 : left_x - metrics.width - 10
+      yield x, left_y, val, metrics.width, metrics.height
     end
   end
 
@@ -56,12 +62,12 @@ module Gruff::BarValueLabel
       @bars[index] = bars
     end
 
-    def prepare_rendering(format, bar_width = 0, &block)
+    def prepare_rendering(format, proc_text_metrics, &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)
+        bar_value_label.prepare_rendering(format, proc_text_metrics, &block)
       end
     end
   end

data/lib/gruff/helper/stacked_mixin.rb

@@ -7,17 +7,18 @@ module Gruff::Base::StackedMixin
   # tsal: moved from Base 03 FEB 2007
   def calculate_maximum_by_stack
     # Get sum of each stack
-    max_hash = {}
+    max_hash = Hash.new { |h, k| h[k] = 0.0 }
     store.data.each do |data_set|
       data_set.points.each_with_index do |data_point, i|
-        max_hash[i] = 0.0 unless max_hash[i]
         max_hash[i] += data_point.to_f
       end
     end
 
     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
 end

data/lib/gruff/histogram.rb

@@ -28,19 +28,21 @@ class Gruff::Histogram < Gruff::Bar
     @data = []
   end
 
-  def initialize_ivars
+  def data(name, data_points = [], color = nil)
+    @data << [name, Array(data_points), color]
+  end
+
+private
+
+  def initialize_attributes
     super
     @bin_width = 10
     @minimum_bin = nil
     @maximum_bin = nil
   end
-  private :initialize_ivars
-
-  def data(name, data_points = [], color = nil)
-    @data << [name, data_points, color]
-  end
+  private :initialize_attributes
 
-  def draw
+  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|