gruff 0.15.0-java → 0.16.0-java

data/lib/gruff/bullet.rb

@@ -67,23 +67,23 @@ class Gruff::Bullet < Gruff::Base
     %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,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,32 +14,32 @@
 #   g.write('dot.png')
 #
 class Gruff::Dot < Gruff::Base
-private
-
-  def initialize_attributes
+  def initialize(*)
     super
     @has_left_labels = true
   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::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
@@ -51,11 +51,11 @@ 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
+      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)
+      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)

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

@@ -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,34 +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
-      val = begin
-        if format.is_a?(Proc)
-          format.call(@value)
-        else
-          sprintf(format || '%.2f', @value).commify
-        end
-      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
-      val = begin
-        if format.is_a?(Proc)
-          format.call(@value)
-        else
-          sprintf(format || '%.2f', @value).commify
-        end
-      end
-      x = @value >= 0 ? right_x + 40 : left_x - 40
-      yield x, right_y - bar_width / 2, val
+    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 + 10 : left_x - metrics.width - 10
+      yield x, left_y, val, metrics.width, metrics.height
     end
   end
 
@@ -59,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

@@ -16,7 +16,9 @@ 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
 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

data/lib/gruff/line.rb

@@ -40,6 +40,23 @@ class Gruff::Line < Gruff::Base
   # The number of vertical lines shown.
   attr_writer :marker_x_count
 
+  # Call with target pixel width of graph (+800+, +400+, +300+), and/or +false+ to omit lines (points only).
+  #
+  #   g = Gruff::Line.new(400) # 400px wide with lines
+  #   g = Gruff::Line.new(400, false) # 400px wide, no lines (for backwards compatibility)
+  #   g = Gruff::Line.new(false) # Defaults to 800px wide, no lines (for backwards compatibility)
+  #
+  # The preferred way is to call {#hide_dots=} or {#hide_lines=} instead.
+  def initialize(*args)
+    raise ArgumentError, 'Wrong number of arguments' if args.length > 2
+
+    if args.empty? || (!args.first.is_a?(Numeric) && !args.first.is_a?(String))
+      super()
+    else
+      super args.shift
+    end
+  end
+
   # Get the value if somebody has defined it.
   def baseline_value
     if @reference_lines.key?(:baseline)
@@ -64,23 +81,6 @@ class Gruff::Line < Gruff::Base
     @reference_lines[:baseline][:color] = new_value
   end
 
-  # Call with target pixel width of graph (+800+, +400+, +300+), and/or +false+ to omit lines (points only).
-  #
-  #   g = Gruff::Line.new(400) # 400px wide with lines
-  #   g = Gruff::Line.new(400, false) # 400px wide, no lines (for backwards compatibility)
-  #   g = Gruff::Line.new(false) # Defaults to 800px wide, no lines (for backwards compatibility)
-  #
-  # The preferred way is to call {#hide_dots=} or {#hide_lines=} instead.
-  def initialize(*args)
-    raise ArgumentError, 'Wrong number of arguments' if args.length > 2
-
-    if args.empty? || (!args.first.is_a?(Numeric) && !args.first.is_a?(String))
-      super()
-    else
-      super args.shift
-    end
-  end
-
   # This method allows one to plot a dataset with both X and Y data.
   #
   # @overload dataxy(name, x_data_points = [], y_data_points = [], color = nil)
@@ -165,7 +165,7 @@ private
   end
 
   def draw_horizontal_reference_line(reference_line)
-    level = @graph_top + (@graph_height - reference_line[:norm_value] * @graph_height)
+    level = @graph_top + (@graph_height - (reference_line[:norm_value] * @graph_height))
     draw_reference_line(reference_line, @graph_left, @graph_left + @graph_width, level, level)
   end
 
@@ -176,7 +176,7 @@ private
 
   def draw_graph
     # Check to see if more than one datapoint was given. NaN can result otherwise.
-    @x_increment = column_count > 1 ? (@graph_width / (column_count - 1).to_f) : @graph_width
+    @x_increment = column_count > 1 ? @graph_width / (column_count - 1) : @graph_width
 
     @reference_lines.each_value do |curr_reference_line|
       draw_horizontal_reference_line(curr_reference_line) if curr_reference_line.key?(:norm_value)
@@ -189,22 +189,22 @@ private
       one_point = contains_one_point_only?(data_row)
 
       data_row.coordinates.each_with_index do |(x_data, y_data), index|
-        if x_data.nil?
-          # use the old method: equally spaced points along the x-axis
-          new_x = @graph_left + (@x_increment * index)
-          draw_label(new_x, index)
-        else
-          new_x = get_x_coord(x_data, @graph_width, @graph_left)
-          @labels.each do |label_pos, _|
-            draw_label(@graph_left + ((label_pos - @minimum_x_value) * @graph_width) / (@maximum_x_value - @minimum_x_value), label_pos)
+        new_x = begin
+          if x_data.nil?
+            # use the old method: equally spaced points along the x-axis
+            @graph_left + (@x_increment * index)
+          else
+            get_x_coord(x_data, @graph_width, @graph_left)
           end
         end
+        draw_label_for_x_data(x_data, new_x, index)
+
         unless y_data # we can't draw a line for a null data point, we can still label the axis though
           prev_x = prev_y = nil
           next
         end
 
-        new_y = @graph_top + (@graph_height - y_data * @graph_height)
+        new_y = @graph_top + (@graph_height - (y_data * @graph_height))
 
         # Reset each time to avoid thin-line errors
         stroke_width  = @line_width || clip_value_if_greater_than(@columns / (store.norm_data.first.y_points.size * 4), 5.0)
@@ -227,12 +227,12 @@ private
 
   def setup_data
     # Update the global min/max values for the x data
-    @maximum_x_value ||= store.max_x
-    @minimum_x_value ||= store.min_x
+    @maximum_x_value = (@maximum_x_value || store.max_x).to_f
+    @minimum_x_value = (@minimum_x_value || store.min_x).to_f
 
     # Deal with horizontal reference line values that exceed the existing minimum & maximum values.
-    possible_maximums = [maximum_value.to_f]
-    possible_minimums = [minimum_value.to_f]
+    possible_maximums = [maximum_value]
+    possible_minimums = [minimum_value]
 
     @reference_lines.each_value do |curr_reference_line|
       if curr_reference_line.key?(:value)
@@ -255,14 +255,14 @@ private
   def normalize
     return unless data_given?
 
-    spread_x = @maximum_x_value.to_f - @minimum_x_value.to_f
+    spread_x = @maximum_x_value - @minimum_x_value
     store.normalize(minimum_x: @minimum_x_value, spread_x: spread_x, minimum_y: minimum_value, spread_y: @spread)
 
     @reference_lines.each_value do |curr_reference_line|
       # We only care about horizontal markers ... for normalization.
       # Vertical markers won't have a :value, they will have an :index
 
-      curr_reference_line[:norm_value] = ((curr_reference_line[:value].to_f - minimum_value) / @spread.to_f) if curr_reference_line.key?(:value)
+      curr_reference_line[:norm_value] = ((curr_reference_line[:value].to_f - minimum_value) / @spread) if curr_reference_line.key?(:value)
     end
   end
 
@@ -270,22 +270,28 @@ private
     # do all of the stuff for the horizontal lines on the y-axis
     super
     return if @hide_line_markers
+    return unless @show_vertical_markers
 
     (0..@marker_x_count).each do |index|
-      if @show_vertical_markers
-        x = @graph_left + @graph_width - index * @graph_width / @marker_x_count
+      x = @graph_left + @graph_width - (index * @graph_width / @marker_x_count)
 
-        Gruff::Renderer::Line.new(renderer, color: @marker_color).render(x, @graph_bottom, x, @graph_top)
-        # If the user specified a marker shadow color, draw a shadow just below it
-        if @marker_shadow_color
-          Gruff::Renderer::Line.new(renderer, color: @marker_shadow_color).render(x + 1, @graph_bottom, x + 1, @graph_top)
-        end
+      Gruff::Renderer::Line.new(renderer, color: @marker_color).render(x, @graph_bottom, x, @graph_top)
+      Gruff::Renderer::Line.new(renderer, color: @marker_shadow_color).render(x + 1, @graph_bottom, x + 1, @graph_top) if @marker_shadow_color
+    end
+  end
+
+  def draw_label_for_x_data(x_data, new_x, index)
+    if x_data.nil?
+      draw_label(new_x, index)
+    else
+      @labels.each do |label_pos, _|
+        draw_label(@graph_left + (((label_pos - @minimum_x_value) * @graph_width) / (@maximum_x_value - @minimum_x_value)), label_pos)
       end
     end
   end
 
   def get_x_coord(x_data_point, width, offset)
-    x_data_point * width + offset
+    (x_data_point * width) + offset
   end
 
   def contains_one_point_only?(data_row)

data/lib/gruff/mini/legend.rb

@@ -21,7 +21,7 @@ module Gruff
 
         @legend_labels = store.data.map(&:label)
 
-        legend_height = scale_fontsize(store.length * calculate_line_height + @top_margin + @bottom_margin)
+        legend_height = scale_fontsize((store.length * calculate_line_height) + @top_margin + @bottom_margin)
 
         @original_rows = @raw_rows
         @original_columns = @raw_columns
@@ -45,7 +45,7 @@ module Gruff
 
       def calculate_legend_width
         width = @legend_labels.map { |label| calculate_width(@legend_font, label) }.max
-        scale_fontsize(width + 40 * 1.7)
+        scale_fontsize(width + (40 * 1.7))
       end
 
       ##
@@ -77,9 +77,9 @@ module Gruff
           # Now draw box with color of this dataset
           rect_renderer = Gruff::Renderer::Rectangle.new(renderer, color: store.data[index].color)
           rect_renderer.render(current_x_offset,
-                               current_y_offset - legend_square_width / 2.0,
+                               current_y_offset - (legend_square_width / 2.0),
                                current_x_offset + legend_square_width,
-                               current_y_offset + legend_square_width / 2.0)
+                               current_y_offset + (legend_square_width / 2.0))
 
           current_y_offset += calculate_line_height
         end

data/lib/gruff/net.rb

@@ -50,15 +50,15 @@ private
 
         rad_pos = index * Math::PI * 2 / column_count
         point_distance = data_point * @radius
-        start_x = @center_x + Math.sin(rad_pos) * point_distance
-        start_y = @center_y - Math.cos(rad_pos) * point_distance
+        start_x = @center_x + (Math.sin(rad_pos) * point_distance)
+        start_y = @center_y - (Math.cos(rad_pos) * point_distance)
 
         next_index = index + 1 < data_row.points.length ? index + 1 : 0
 
         next_rad_pos = next_index * Math::PI * 2 / column_count
         next_point_distance = data_row.points[next_index] * @radius
-        end_x = @center_x + Math.sin(next_rad_pos) * next_point_distance
-        end_y = @center_y - Math.cos(next_rad_pos) * next_point_distance
+        end_x = @center_x + (Math.sin(next_rad_pos) * next_point_distance)
+        end_y = @center_y - (Math.cos(next_rad_pos) * next_point_distance)
 
         Gruff::Renderer::Line.new(renderer, color: data_row.color, width: @stroke_width).render(start_x, start_y, end_x, end_y)
 
@@ -89,7 +89,7 @@ private
       rad_pos = index * Math::PI * 2 / column_count
 
       Gruff::Renderer::Line.new(renderer, color: @marker_color)
-                           .render(@center_x, @center_y, @center_x + Math.sin(rad_pos) * @radius, @center_y - Math.cos(rad_pos) * @radius)
+                           .render(@center_x, @center_y, @center_x + (Math.sin(rad_pos) * @radius), @center_y - (Math.cos(rad_pos) * @radius))
 
       marker_label = @labels[index] ? @labels[index].to_s : '000'
       draw_label(@center_x, @center_y, rad_pos * 360 / (2 * Math::PI), @radius + @circle_radius, marker_label)
@@ -99,8 +99,8 @@ private
   def draw_label(center_x, center_y, angle, radius, amount)
     x_offset = center_x # + 15 # The label points need to be tweaked slightly
     y_offset = center_y # + 0  # This one doesn't though
-    x = x_offset + (radius + LABEL_MARGIN) * Math.sin(deg2rad(angle))
-    y = y_offset - (radius + LABEL_MARGIN) * Math.cos(deg2rad(angle))
+    x = x_offset + ((radius + LABEL_MARGIN) * Math.sin(deg2rad(angle)))
+    y = y_offset - ((radius + LABEL_MARGIN) * Math.cos(deg2rad(angle)))
 
     draw_label_at(1.0, 1.0, x, y, amount, Magick::CenterGravity)
   end

data/lib/gruff/patch/string.rb

@@ -3,6 +3,7 @@
 # @private
 module String::GruffCommify
   THOUSAND_SEPARATOR = ','
+  private_constant :THOUSAND_SEPARATOR
 
   refine String do
     # Taken from http://codesnippets.joyent.com/posts/show/330

data/lib/gruff/pie.rb

@@ -9,14 +9,14 @@
 #   g.data 'Hamburgers', 50
 #   g.write("pie_keynote.png")
 #
-# To control where the pie chart starts creating slices, use {#zero_degree=}.
+# To control where the pie chart starts creating slices, use {#start_degree=}.
 #
 class Gruff::Pie < Gruff::Base
-  DEFAULT_TEXT_OFFSET_PERCENTAGE = 0.15
+  DEFAULT_TEXT_OFFSET_PERCENTAGE = 0.1
 
   # Can be used to make the pie start cutting slices at the top (-90.0)
-  # or at another angle. Default is +0.0+, which starts at 3 o'clock.
-  attr_writer :zero_degree
+  # or at another angle. Default is +-90.0+, which starts at 3 o'clock.
+  attr_writer :start_degree
 
   # Set the number output format lambda.
   attr_writer :label_formatting
@@ -26,25 +26,34 @@ class Gruff::Pie < Gruff::Base
   attr_writer :hide_labels_less_than
 
   # Affect the distance between the percentages and the pie chart.
-  # Defaults to +0.15+.
+  # Defaults to +0.1+.
   attr_writer :text_offset_percentage
 
   ## Use values instead of percentages.
   attr_writer :show_values_as_labels
 
-private
+  # Set to +true+ if you want the data sets sorted with largest avg values drawn
+  # first. Default is +true+.
+  attr_writer :sort
 
-  def initialize_store
-    @store = Gruff::Store.new(Gruff::Store::CustomData)
+  # Can be used to make the pie start cutting slices at the top (-90.0)
+  # or at another angle. Default is +-90.0+, which starts at 3 o'clock.
+  # @deprecated Please use +start_degree+ attribute instead.
+  def zero_degree=(value)
+    warn '#zero_degree= is deprecated. Please use `start_degree` attribute instead'
+    @start_degree = value
   end
 
+private
+
   def initialize_attributes
     super
-    @zero_degree = 0.0
+    @start_degree = -90.0
     @hide_labels_less_than = 0.0
     @text_offset_percentage = DEFAULT_TEXT_OFFSET_PERCENTAGE
     @show_values_as_labels = false
     @marker_font.bold = true
+    @sort = true
 
     @hide_line_markers = true
     @hide_line_markers.freeze
@@ -83,7 +92,7 @@ private
   # Spatial Value-Related Methods
 
   def chart_degrees
-    @chart_degrees ||= @zero_degree
+    @chart_degrees ||= @start_degree
   end
 
   attr_reader :graph_height
@@ -132,7 +141,7 @@ private
   end
 
   def label_coordinates_for(slice)
-    angle = chart_degrees + slice.degrees / 2
+    angle = chart_degrees + (slice.degrees / 2.0)
 
     [x_label_coordinate(angle), y_label_coordinate(angle)]
   end