gruff 0.5.1 → 0.10.0

data/lib/gruff/bezier.rb

@@ -1,25 +1,44 @@
-require File.dirname(__FILE__) + '/base'
-
+# frozen_string_literal: true
+
+require 'gruff/base'
+
+#
+# Gruff::Bezier is a special line graph that have
+# the bezier curve.
+#
+# Here's how to set up a Gruff::Bezier.
+#
+#   dataset = [
+#     +0.00, +0.09, +0.19, +0.29, +0.38, +0.47, +0.56, +0.64, +0.71, +0.78,
+#     +0.84, +0.89, +0.93, +0.96, +0.98, +0.99, +0.99, +0.99, +0.97, +0.94,
+#     +0.90, +0.86, +0.80, +0.74, +0.67, +0.59, +0.51, +0.42, +0.33, +0.23,
+#     +0.14, +0.04, -0.06, -0.16, -0.26, -0.36, -0.45, -0.53, -0.62, -0.69,
+#     -0.76, -0.82, -0.88, -0.92, -0.96, -0.98, -1.00, -1.00, -1.00, -0.99,
+#     -0.96, -0.93, -0.89, -0.84, -0.78, -0.71, -0.64, -0.56, -0.47, -0.38,
+#   ]
+#   g = Gruff::Bezier.new
+#   g.data 'sin', dataset
+#   g.write('bezier.png')
+#
 class Gruff::Bezier < Gruff::Base
   def draw
     super
 
-    return unless @has_data
+    return unless data_given?
 
-    @x_increment = @graph_width / (@column_count - 1).to_f
+    x_increment = @graph_width / (column_count - 1).to_f
 
-    @norm_data.each do |data_row|
-      poly_points = Array.new
-      @d = @d.fill data_row[DATA_COLOR_INDEX]
+    store.norm_data.each do |data_row|
+      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_x = @graph_left + (x_increment * index)
         new_y = @graph_top + (@graph_height - data_point * @graph_height)
 
         if index == 0 && RUBY_PLATFORM != 'java'
-          poly_points << @graph_left
-          poly_points << @graph_bottom - 1
+          poly_points << new_x
+          poly_points << new_y
         end
 
         poly_points << new_x
@@ -27,20 +46,16 @@ class Gruff::Bezier < Gruff::Base
 
         draw_label(new_x, index)
       end
-   
-      @d = @d.fill_opacity 0.0
-      @d = @d.stroke data_row[DATA_COLOR_INDEX]
-      @d = @d.stroke_width clip_value_if_greater_than(@columns / (@norm_data.first[1].size * 4), 5.0)
+
+      stroke_width = clip_value_if_greater_than(@columns / (store.norm_data.first[1].size * 4), 5.0)
 
       if RUBY_PLATFORM == 'java'
-        @d = @d.polyline(*poly_points)
+        Gruff::Renderer::Polyline.new(color: data_row.color, width: stroke_width).render(poly_points)
       else
-        @d = @d.bezier(*poly_points)
+        Gruff::Renderer::Bezier.new(color: data_row.color, width: stroke_width).render(poly_points)
       end
     end
 
-    @d.draw(@base_image)
+    Gruff::Renderer.finish
   end
-   
-
 end

data/lib/gruff/bullet.rb

@@ -1,11 +1,22 @@
-require File.dirname(__FILE__) + '/base'
+# frozen_string_literal: true
+
+require 'gruff/base'
 require 'gruff/themes'
 
+#
+# A bullet graph is a variation of a bar graph.
 # http://en.wikipedia.org/wiki/Bullet_graph
+#
+# Here's how to set up a Gruff::Bullet.
+#
+#   g = Gruff::Bullet.new
+#   g.title = 'Monthly Revenue'
+#   g.data 75, 100, { target: 80, low: 50, high: 90 }
+#   g.write('bullet.png')
+#
 class Gruff::Bullet < Gruff::Base
-
-  def initialize(target_width="400x40")
-    if not Numeric === target_width
+  def initialize(target_width = '400x40')
+    if target_width.is_a?(String)
       geometric_width, geometric_height = target_width.split('x')
       @columns = geometric_width.to_f
       @rows = geometric_height.to_f
@@ -13,6 +24,8 @@ class Gruff::Bullet < Gruff::Base
       @columns = target_width.to_f
       @rows = target_width.to_f / 5.0
     end
+    @columns.freeze
+    @rows.freeze
 
     initialize_ivars
 
@@ -21,32 +34,15 @@ class Gruff::Bullet < Gruff::Base
     @title_font_size = 20
   end
 
-  def data(value, maximum_value, options={})
+  def data(value, maximum_value, options = {})
     @value = value.to_f
-    @maximum_value = maximum_value.to_f
+    self.maximum_value = maximum_value.to_f
     @options = options
-    @options.map { |k, v| @options[k] = v.to_f if v === Numeric }
+    @options.map { |k, v| @options[k] = v.to_f if v.is_a?(Numeric) }
   end
 
-  # def setup_drawing
-  #   # Maybe should be done in one of the following functions for more granularity.
-  #   unless @has_data
-  #     draw_no_data()
-  #     return
-  #   end
-  #
-  #   normalize()
-  #   setup_graph_measurements()
-  #   sort_norm_data() if @sort # Sort norm_data with avg largest values set first (for display)
-  #
-  #   draw_legend()
-  #   draw_line_markers()
-  #   draw_axis_labels()
-  #   draw_title
-  # end
-
   def draw
-    # TODO Left label
+    # TODO: Left label
     # TODO Bottom labels and markers
     # @graph_bottom
     # Calculations are off 800x???
@@ -55,57 +51,50 @@ class Gruff::Bullet < Gruff::Base
 
     draw_title
 
-    @margin       = 30.0
-    @thickness    = @raw_rows / 6.0
-    @right_margin = @margin
-    @graph_left   = @title_width * 1.3 rescue @margin # HACK Need to calculate real width
-    @graph_width  = @raw_columns - @graph_left - @right_margin
-    @graph_height = @thickness * 3.0
+    title_width  = calculate_width(@title_font_size, @title)
+    margin       = 30.0
+    thickness    = @raw_rows / 6.0
+    right_margin = margin
+    graph_left   = (@title && (title_width * 1.3)) || margin
+    graph_width  = @raw_columns - graph_left - right_margin
+    graph_height = thickness * 3.0
 
     # Background
-    @d = @d.fill @colors[0]
-    @d = @d.rectangle(@graph_left, 0, @graph_left + @graph_width, @graph_height)
+    rect_renderer = Gruff::Renderer::Rectangle.new(color: @colors[0])
+    rect_renderer.render(graph_left, 0, graph_left + graph_width, graph_height)
 
     [:high, :low].each_with_index do |indicator, index|
-      next unless @options.has_key?(indicator)
-      @d = @d.fill @colors[index + 1]
-      indicator_width_x  = @graph_left + @graph_width * (@options[indicator] / @maximum_value)
-      @d = @d.rectangle(@graph_left, 0, indicator_width_x, @graph_height)
+      next unless @options.key?(indicator)
+
+      indicator_width_x = graph_left + graph_width * (@options[indicator] / maximum_value)
+
+      rect_renderer = Gruff::Renderer::Rectangle.new(color: @colors[index + 1])
+      rect_renderer.render(graph_left, 0, indicator_width_x, graph_height)
     end
 
-    if @options.has_key?(:target)
-      @d = @d.fill @font_color
-      target_x = @graph_left + @graph_width * (@options[:target] / @maximum_value)
-      half_thickness = @thickness / 2.0
-      @d = @d.rectangle(target_x, half_thickness, target_x + half_thickness, @thickness * 2 + half_thickness)
+    if @options.key?(:target)
+      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)
     end
 
     # Value
-    @d = @d.fill @font_color
-    @d = @d.rectangle(@graph_left, @thickness, @graph_left + @graph_width * (@value / @maximum_value), @thickness * 2)
+    rect_renderer = Gruff::Renderer::Rectangle.new(color: @font_color)
+    rect_renderer.render(graph_left, thickness, graph_left + graph_width * (@value / maximum_value), thickness * 2)
 
-    @d.draw(@base_image)
+    Gruff::Renderer.finish
   end
 
+private
+
   def draw_title
     return unless @title
 
-    @font_height = calculate_caps_height(scale_fontsize(@title_font_size))
-    @title_width = calculate_width(@title_font_size, @title)
-
-    @d.fill        = @font_color
-    @d.font        = @font if @font
-    @d.stroke('transparent')
-    @d.font_weight = NormalWeight
-    @d.pointsize   = scale_fontsize(@title_font_size)
-    @d.gravity     = NorthWestGravity
-    @d             = @d.annotate_scaled(*[
-      @base_image,
-      1.0, 1.0,
-      @font_height/2, @font_height/2,
-      @title,
-      @scale
-    ])
-  end
+    font_height = calculate_caps_height(scale_fontsize(@title_font_size))
 
+    text_renderer = Gruff::Renderer::Text.new(@title, font: @font, size: @title_font_size, color: @font_color)
+    text_renderer.render(1.0, 1.0, font_height / 2, font_height / 2, Magick::NorthWestGravity)
+  end
 end

data/lib/gruff/dot.rb

@@ -1,64 +1,60 @@
-require File.dirname(__FILE__) + '/base'
+# frozen_string_literal: true
 
-##
-# Graph with dots and labels along a vertical access
-# see: 'Creating More Effective Graphs' by Robbins
+require 'gruff/base'
 
+#
+# Graph with dots and labels along a vertical access.
+# see: 'Creating More Effective Graphs' by Robbins
+#
+# Here's how to set up a Gruff::Dot.
+#
+#   g = Gruff::Dot.new
+#   g.title = 'Dot Graph'
+#   g.data :Art, [0, 5, 8, 15]
+#   g.data :Philosophy, [10, 3, 2, 8]
+#   g.data :Science, [2, 15, 8, 11]
+#   g.write('dot.png')
+#
 class Gruff::Dot < Gruff::Base
-
   def draw
     @has_left_labels = true
     super
 
-    return unless @has_data
+    return unless data_given?
 
     # Setup spacing.
     #
     spacing_factor = 1.0
 
-    @items_width = @graph_height / @column_count.to_f
-    @item_width = @items_width * spacing_factor / @norm_data.size
-    @d = @d.stroke_opacity 0.0
-    padding = (@items_width * (1 - spacing_factor)) / 2
+    items_width = @graph_height / column_count.to_f
+    item_width = items_width * spacing_factor / store.length
+    padding = (items_width * (1 - spacing_factor)) / 2
 
-    @norm_data.each_with_index do |data_row, row_index|
-      data_row[DATA_VALUES_INDEX].each_with_index do |data_point, point_index|
+    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.to_f / 2.0).round
 
         if row_index == 0
-          @d = @d.stroke(@marker_color)
-          @d = @d.fill(@marker_color)
-          @d = @d.stroke_width 1.0
-          @d = @d.stroke_opacity 0.1
-          @d = @d.fill_opacity 0.1
-          @d = @d.line(@graph_left, y_pos, @graph_left + @graph_width, y_pos)
-          @d = @d.fill_opacity 1
+          Gruff::Renderer::Line.new(color: @marker_color).render(@graph_left, y_pos, @graph_left + @graph_width, y_pos)
         end
 
-        @d = @d.fill data_row[DATA_COLOR_INDEX]
-        @d = @d.stroke('transparent')
-        @d = @d.circle(x_pos, y_pos, x_pos + (@item_width.to_f/3.0).round, y_pos)
+        Gruff::Renderer::Circle.new(color: data_row.color).render(x_pos, y_pos, x_pos + (item_width.to_f / 3.0).round, y_pos)
 
         draw_label(y_pos, point_index)
       end
-
     end
 
-    @d.draw(@base_image)
+    Gruff::Renderer.finish
   end
 
-  protected
+protected
 
   # Instead of base class version, draws vertical background lines and label
   def draw_line_markers
     return if @hide_line_markers
 
-    @d = @d.stroke_antialias false
-
     # Draw horizontal line markers and annotate with numbers
-    @d = @d.stroke(@marker_color)
-    @d = @d.stroke_width 1
     if @y_axis_increment
       increment = @y_axis_increment
       number_of_lines = (@spread / @y_axis_increment).to_i
@@ -75,31 +71,21 @@ class Gruff::Dot < Gruff::Base
         end
         @marker_count ||= 5
       end
-      # TODO Round maximum marker value to a round number like 100, 0.1, 0.5, etc.
-      @increment = (@spread > 0 && @marker_count > 0) ? significant(@spread / @marker_count) : 1
-
+      # TODO: Round maximum marker value to a round number like 100, 0.1, 0.5, etc.
+      increment = (@spread > 0 && @marker_count > 0) ? significant(@spread / @marker_count) : 1
       number_of_lines = @marker_count
-      increment = @increment
     end
 
     (0..number_of_lines).each do |index|
-      marker_label = @minimum_value + index * increment
-      x = @graph_left + (marker_label - @minimum_value) * @graph_width / @spread
-      @d = @d.line(x, @graph_bottom, x, @graph_bottom + 0.5 * LABEL_MARGIN)
+      marker_label = minimum_value + index * increment
+      x = @graph_left + (marker_label - minimum_value) * @graph_width / @spread
+      Gruff::Renderer::Line.new(color: @marker_color).render(x, @graph_bottom, x, @graph_bottom + 0.5 * LABEL_MARGIN)
 
       unless @hide_line_numbers
-        @d.fill = @font_color
-        @d.font = @font if @font
-        @d.stroke = 'transparent'
-        @d.pointsize = scale_fontsize(@marker_font_size)
-        @d.gravity = CenterGravity
-        # TODO Center text over line
-        @d = @d.annotate_scaled(@base_image,
-                                0, 0, # Width of box to draw text in
-                                x, @graph_bottom + (LABEL_MARGIN * 2.0), # Coordinates of text
-                                label(marker_label, increment), @scale)
-      end # unless
-      @d = @d.stroke_antialias true
+        label = label(marker_label, increment)
+        text_renderer = Gruff::Renderer::Text.new(label, font: @font, size: @marker_font_size, color: @font_color)
+        text_renderer.render(0, 0, x, @graph_bottom + (LABEL_MARGIN * 2.0), Magick::CenterGravity)
+      end
     end
   end
 
@@ -107,19 +93,9 @@ class Gruff::Dot < Gruff::Base
   # Draw on the Y axis instead of the X
 
   def draw_label(y_offset, index)
-    if !@labels[index].nil? && @labels_seen[index].nil?
-      @d.fill = @font_color
-      @d.font = @font if @font
-      @d.stroke = 'transparent'
-      @d.font_weight = NormalWeight
-      @d.pointsize = scale_fontsize(@marker_font_size)
-      @d.gravity = EastGravity
-      @d = @d.annotate_scaled(@base_image,
-                              1, 1,
-                              -@graph_left + LABEL_MARGIN * 2.0, y_offset,
-                              @labels[index], @scale)
-      @labels_seen[index] = 1
+    draw_unique_label(index) do
+      text_renderer = Gruff::Renderer::Text.new(@labels[index], font: @font, size: @marker_font_size, color: @font_color)
+      text_renderer.render(@graph_left - LABEL_MARGIN * 2, 1.0, 0.0, y_offset, Magick::EastGravity)
     end
   end
-
 end

data/lib/gruff/helper/bar_conversion.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+##
+# Original Author: David Stokar
+#
+#   This class perfoms the y coordinats conversion for the bar class.
+#
+#   There are three cases:
+#
+#   1. Bars all go from zero in positive direction
+#   2. Bars all go from zero to negative direction
+#   3. Bars either go from zero to positive or from zero to negative
+#
+# @private
+class Gruff::BarConversion
+  attr_writer :mode
+  attr_writer :zero
+  attr_writer :graph_top
+  attr_writer :graph_height
+  attr_writer :minimum_value
+  attr_writer :spread
+
+  def get_left_y_right_y_scaled(data_point)
+    result = []
+
+    case @mode
+    when 1 then # Case one
+                # minimum value >= 0 ( only positive values )
+      result[0] = @graph_top + @graph_height * (1 - data_point) + 1
+      result[1] = @graph_top + @graph_height - 1
+    when 2 then # Case two
+                # only negative values
+      result[0] = @graph_top + 1
+      result[1] = @graph_top + @graph_height * (1 - data_point) - 1
+    when 3 then # Case three
+                # positive and negative values
+      val = data_point - @minimum_value / @spread
+      result[0] = @graph_top + @graph_height * (1 - (val - @zero)) + 1
+      result[1] = @graph_top + @graph_height * (1 - @zero) - 1
+    else
+      result[0] = 0.0
+      result[1] = 0.0
+    end
+
+    result
+  end
+end

data/lib/gruff/helper/bar_value_label_mixin.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# @private
+module Gruff::Base::BarValueLabelMixin
+  class BarValueLabel
+    attr_accessor :coordinates, :values
+
+    def initialize(size, bar_width)
+      @coordinates = Array.new(size)
+      @values = Hash.new(0)
+      @bar_width = bar_width
+    end
+
+    def prepare_rendering(format)
+      @coordinates.each_with_index do |(left_x, left_y, right_x, _right_y), index|
+        value = @values[index]
+        val = (format || '%.2f') % value
+        y = value >= 0 ? left_y - 30 : left_y + 12
+        yield left_x + (right_x - left_x) / 2, y, val.commify
+      end
+    end
+
+    def prepare_sidebar_rendering(format)
+      @coordinates.each_with_index do |(_left_x, _left_y, right_x, right_y), index|
+        val = (format || '%.2f') % @values[index]
+        yield right_x + 40, right_y - @bar_width / 2, val.commify
+      end
+    end
+  end
+end