gruff 0.6.0-java → 0.11.0-java

data/gruff.gemspec

@@ -1,30 +1,38 @@
 # -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib')
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'date'
 require 'gruff/version'
 
 Gem::Specification.new do |s|
-  s.name = %q{gruff}
+  s.name = 'gruff'
   s.version = Gruff::VERSION
   s.authors = ['Geoffrey Grosenbach', 'Uwe Kubosch']
   s.date = Date.today.to_s
-  s.description = %q{Beautiful graphs for one or multiple datasets. Can be used on websites or in documents.}
-  s.email = %q{boss@topfunky.com}
-  s.files = `git ls-files`.split($/).reject{|f| f =~ /^test#{File::ALT_SEPARATOR || File::SEPARATOR}output/}
-  s.homepage = %q{https://github.com/topfunky/gruff}
-  s.require_paths = %w(lib)
-  s.summary = %q{Beautiful graphs for one or multiple datasets.}
+  s.description = 'Beautiful graphs for one or multiple datasets. Can be used on websites or in documents.'
+  s.email = 'boss@topfunky.com'
+  s.files = `git ls-files`.split($/).reject { |f| f =~ /^test/ }
+  s.homepage = 'https://github.com/topfunky/gruff'
+  s.require_paths = %w[lib]
+  s.summary = 'Beautiful graphs for one or multiple datasets.'
+  s.license = 'MIT'
   s.test_files = s.files.grep(%r{^(test|spec|features)/})
   s.executables = s.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   s.specification_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+
   if defined? JRUBY_VERSION
     s.platform = 'java'
-    s.add_dependency 'rmagick4j', '>= 0.3.9'
+    s.add_dependency 'rmagick4j'
   else
-    s.add_dependency 'rmagick', '>= 2.13.4'
+    s.add_dependency 'rmagick'
+    s.add_development_dependency 'rubocop', '~> 0.81.0'
   end
-  s.add_development_dependency('rake')
-  s.add_development_dependency('test-unit')
-  s.license = 'MIT'
+  s.add_dependency 'histogram'
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest-reporters'
+  s.add_development_dependency 'yard', '~> 0.9.25'
 end

data/init.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 # For Rails
 require 'gruff'

data/lib/gruff.rb

@@ -1,8 +1,14 @@
+# frozen_string_literal: true
+
+require 'rmagick'
 require 'gruff/version'
 
 # Extra full path added to fix loading errors on some installations.
 
-%w(
+%w[
+  patch/rmagick
+  patch/string
+
   themes
   base
   area
@@ -10,6 +16,7 @@ require 'gruff/version'
   bezier
   bullet
   dot
+  histogram
   line
   net
   pie
@@ -23,10 +30,27 @@ require 'gruff/version'
 
   scene
 
+  renderer/renderer
+  renderer/rectangle
+  renderer/circle
+  renderer/dash_line
+  renderer/line
+  renderer/polyline
+  renderer/polygon
+  renderer/bezier
+  renderer/ellipse
+  renderer/dot
+  renderer/text
+
+  store/store
+  store/base_data
+  store/custom_data
+  store/xy_data
+
   mini/legend
   mini/bar
   mini/pie
   mini/side_bar
-).each do |filename|
+].each do |filename|
   require "gruff/#{filename}"
 end

data/lib/gruff/accumulator_bar.rb

@@ -1,18 +1,28 @@
-require File.dirname(__FILE__) + '/base'
+# frozen_string_literal: true
 
-##
-# A special bar graph that shows a single dataset as a set of
-# stacked bars. The bottom bar shows the running total and 
-# the top bar shows the new value being added to the array.
+require 'gruff/base'
 
+#
+# Gruff::AccumulatorBar is a special bar graph that shows a
+# single dataset as a set of stacked bars.
+# The bottom bar shows the running total and the top bar shows
+# the new value being added to the array.
+#
+# Here's how to set up a Gruff::AccumulatorBar.
+#
+#   g = Gruff::AccumulatorBar.new
+#   g.title = 'Your Savings'
+#   g.data 'First', [1, 1, 1]
+#   g.write('accumulator_bar.png')
+#
 class Gruff::AccumulatorBar < Gruff::StackedBar
   def draw
-    raise(Gruff::IncorrectNumberOfDatasetsException) unless @data.length == 1
+    raise(Gruff::IncorrectNumberOfDatasetsException) unless store.length == 1
 
-    accum_array = @data.first[DATA_VALUES_INDEX][0..-2].inject([0]) { |a, v| a << a.last + v}
+    accum_array = store.data.first.points[0..-2].reduce([0]) { |a, v| a << a.last + v }
     data 'Accumulator', accum_array
     set_colors
-    @data.reverse!
+    store.reverse!
     super
   end
 end

data/lib/gruff/area.rb

@@ -1,37 +1,54 @@
+# frozen_string_literal: true
 
-require File.dirname(__FILE__) + '/base'
+require 'gruff/base'
 
+#
+# Gruff::Area provides an area graph which displays graphically
+# quantitative data.
+#
+# Here's how to set up a Gruff::Area.
+#
+#   g = Gruff::Area.new
+#   g.title = 'Area Graph'
+#   g.data :Jimmy, [25, 36, 86, 39, 25, 31, 79, 88]
+#   g.data :Charles, [80, 54, 67, 54, 68, 70, 90, 95]
+#   g.data :Julie, [22, 29, 35, 38, 36, 40, 46, 57]
+#   g.write('area.png')
+#
 class Gruff::Area < Gruff::Base
-  def initialize(*)
+  # Specifies the filling opacity in area graph. Default is +0.85+.
+  attr_writer :fill_opacity
+
+  # Specifies the stroke width in line around area graph. Default is +2.0+.
+  attr_writer :stroke_width
+
+  def initialize_ivars
     super
     @sorted_drawing = true
+    @fill_opacity = 0.85
+    @stroke_width = 2.0
   end
+  private :initialize_ivars
 
   def draw
     super
 
-    return unless @has_data
+    return unless data_given?
 
-    @x_increment = @graph_width / (@column_count - 1).to_f
-    @d = @d.stroke 'transparent'
+    x_increment = @graph_width / (column_count - 1).to_f
 
-    @norm_data.each do |data_row|
-      poly_points = Array.new
-      prev_x = prev_y = 0.0
-      @d = @d.fill data_row[DATA_COLOR_INDEX]
+    store.norm_data.each do |data_row|
+      poly_points = []
 
-      data_row[DATA_VALUES_INDEX].each_with_index do |data_point, index|
+      data_row.points.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)
 
         poly_points << new_x
         poly_points << new_y
 
         draw_label(new_x, index)
-
-        prev_x = new_x
-        prev_y = new_y
       end
 
       # Add closing points, draw polygon
@@ -40,12 +57,9 @@ class Gruff::Area < Gruff::Base
       poly_points << @graph_left
       poly_points << @graph_bottom - 1
 
-      @d = @d.polyline(*poly_points)
-
+      Gruff::Renderer::Polygon.new(color: data_row.color, width: @stroke_width, opacity: @fill_opacity).render(poly_points)
     end
 
-    @d.draw(@base_image)
+    Gruff::Renderer.finish
   end
-   
- 
 end

data/lib/gruff/bar.rb

@@ -1,24 +1,55 @@
-require File.dirname(__FILE__) + '/base'
-require File.dirname(__FILE__) + '/bar_conversion'
-
+# frozen_string_literal: true
+
+require 'gruff/base'
+require 'gruff/helper/bar_conversion'
+
+#
+# Gruff::Bar provide a bar graph that presents categorical data
+# with rectangular bars.
+#
+# Here's how to set up a Gruff::Bar.
+#
+#   g = Gruff::Bar.new
+#   g.title = 'Bar Graph With Manual Colors'
+#   g.spacing_factor = 0.1
+#   g.group_spacing = 20
+#   g.data :Art, [0, 5, 8, 15], '#990000'
+#   g.data :Philosophy, [10, 3, 2, 8], '#009900'
+#   g.data :Science, [2, 15, 8, 11], '#990099'
+#   g.write('bar.png')
+#
 class Gruff::Bar < Gruff::Base
+  # Spacing factor applied between bars.
+  attr_writer :bar_spacing
+
+  # Spacing factor applied between a group of bars belonging to the same label.
+  attr_writer :group_spacing
 
-  # Spacing factor applied between bars
-  attr_accessor :bar_spacing
+  # Set the number output format for labels using sprintf.
+  # Default is +"%.2f"+.
+  attr_writer :label_formatting
 
-  def initialize(*args)
+  # Output the values for the bars on a bar graph.
+  # Default is +false+.
+  attr_writer :show_labels_for_bar_values
+
+  def initialize_ivars
     super
     @spacing_factor = 0.9
+    @group_spacing = 10
+    @label_formatting = nil
+    @show_labels_for_bar_values = false
   end
+  private :initialize_ivars
 
   def draw
     # Labels will be centered over the left of the bar if
-    # there are more labels than columns. This is basically the same 
+    # there are more labels than columns. This is basically the same
     # as where it would be for a line graph.
-    @center_labels_over_point = (@labels.keys.length > @column_count ? true : false)
-    
+    @center_labels_over_point = (@labels.keys.length > column_count)
+
     super
-    return unless @has_data
+    return unless data_given?
 
     draw_bars
   end
@@ -28,9 +59,10 @@ class Gruff::Bar < Gruff::Base
   # 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.
+  # 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 and space_percent <= 1)
+    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
 
@@ -41,68 +73,67 @@ protected
     #
     # Columns sit side-by-side.
     @bar_spacing ||= @spacing_factor # space between the bars
-    @bar_width = @graph_width / (@column_count * @data.length).to_f
-    padding = (@bar_width * (1 - @bar_spacing)) / 2
 
-    @d = @d.stroke_opacity 0.0
+    bar_width = (@graph_width - calculate_spacing) / (column_count * store.length).to_f
+    padding = (bar_width * (1 - @bar_spacing)) / 2
 
     # Setup the BarConversion Object
-    conversion = Gruff::BarConversion.new()
+    conversion = Gruff::BarConversion.new
     conversion.graph_height = @graph_height
     conversion.graph_top = @graph_top
 
     # Set up the right mode [1,2,3] see BarConversion for further explanation
-    if @minimum_value >= 0 then
-      # all bars go from zero to positiv
+    if minimum_value >= 0
+      # all bars go from zero to positive
       conversion.mode = 1
+    elsif maximum_value <= 0
+      # all bars go from 0 to negative
+      conversion.mode = 2
     else
-      # all bars go from 0 to negativ
-      if @maximum_value <= 0 then
-        conversion.mode = 2
-      else
-        # bars either go from zero to negativ or to positiv
-        conversion.mode = 3
-        conversion.spread = @spread
-        conversion.minimum_value = @minimum_value
-        conversion.zero = -@minimum_value/@spread
-      end
+      # bars either go from zero to negative or to positive
+      conversion.mode = 3
+      conversion.spread = @spread
+      conversion.minimum_value = minimum_value
+      conversion.zero = -minimum_value / @spread
     end
 
     # iterate over all normalised data
-    @norm_data.each_with_index do |data_row, row_index|
+    store.norm_data.each_with_index do |data_row, row_index|
+      data_row.points.each_with_index do |data_point, point_index|
+        group_spacing = @group_spacing * @scale * point_index
 
-      data_row[DATA_VALUES_INDEX].each_with_index do |data_point, point_index|
         # Use incremented x and scaled y
         # x
-        left_x = @graph_left + (@bar_width * (row_index + point_index + ((@data.length - 1) * point_index))) + padding
-        right_x = left_x + @bar_width * @bar_spacing
+        left_x = @graph_left + (bar_width * (row_index + point_index + ((store.length - 1) * point_index))) + padding + group_spacing
+        right_x = left_x + bar_width * @bar_spacing
         # y
-        conv = []
-        conversion.get_left_y_right_y_scaled( data_point, conv )
+        left_y, right_y = conversion.get_left_y_right_y_scaled(data_point)
 
         # create new bar
-        @d = @d.fill data_row[DATA_COLOR_INDEX]
-        @d = @d.rectangle(left_x, conv[0], right_x, conv[1])
+        rect_renderer = Gruff::Renderer::Rectangle.new(color: data_row.color)
+        rect_renderer.render(left_x, left_y, right_x, right_y)
 
         # Calculate center based on bar_width and current row
-        label_center = @graph_left + 
-                      (@data.length * @bar_width * point_index) + 
-                      (@data.length * @bar_width / 2.0)
+        label_center = @graph_left + group_spacing + (store.length * bar_width * point_index) + (store.length * bar_width / 2.0)
 
         # Subtract half a bar width to center left if requested
-        draw_label(label_center - (@center_labels_over_point ? @bar_width / 2.0 : 0.0), point_index)
+        draw_label(label_center, point_index)
         if @show_labels_for_bar_values
-          val = (@label_formatting || '%.2f') % @norm_data[row_index][3][point_index]
-          draw_value_label(left_x + (right_x - left_x)/2, conv[0]-30, val.commify, true)
+          raw_value = store.data[row_index].points[point_index]
+          val = (@label_formatting || '%.2f') % raw_value
+          y = raw_value >= 0 ? left_y - 30 : left_y + 12
+          draw_value_label(left_x + (right_x - left_x) / 2, y, val.commify, true)
         end
       end
-
     end
 
     # Draw the last label if requested
-    draw_label(@graph_right, @column_count) if @center_labels_over_point
+    draw_label(@graph_right, column_count, Magick::NorthWestGravity) if @center_labels_over_point
 
-    @d.draw(@base_image)
+    Gruff::Renderer.finish
   end
 
+  def calculate_spacing
+    @scale * @group_spacing * (column_count - 1)
+  end
 end

data/lib/gruff/base.rb

@@ -1,9 +1,8 @@
-require 'rubygems'
+# frozen_string_literal: true
+
 require 'rmagick'
 require 'bigdecimal'
 
-require File.dirname(__FILE__) + '/deprecated'
-
 ##
 # = Gruff. Graphs.
 #
@@ -16,245 +15,206 @@ require File.dirname(__FILE__) + '/deprecated'
 # David Stokar, Paul Rogers, Dave Woodward, Frank Oxener, Kevin Clark, Cies
 # Breijs, Richard Cowin, and a cast of thousands.
 #
-# See Gruff::Base#theme= for setting themes.
-
+# See {Gruff::Base#theme=} for setting themes.
 module Gruff
   class Base
-
-    include Magick
-    include Deprecated
-
-    # Draw extra lines showing where the margins and text centers are
-    DEBUG = false
-
-    # Used for navigating the array of data to plot
-    DATA_LABEL_INDEX = 0
-    DATA_VALUES_INDEX = 1
-    DATA_COLOR_INDEX = 2
-    DATA_VALUES_X_INDEX = 3
-
-    # Space around text elements. Mostly used for vertical spacing
+    # Space around text elements. Mostly used for vertical spacing.
     LEGEND_MARGIN = TITLE_MARGIN = 20.0
-    LABEL_MARGIN = 10.0
+    LABEL_MARGIN = 15.0
     DEFAULT_MARGIN = 20.0
 
-    DEFAULT_TARGET_WIDTH = 800
-
-    THOUSAND_SEPARATOR = ','
+    DEFAULT_TARGET_WIDTH = 800.0
 
-    # Blank space above the graph
-    attr_accessor :top_margin
+    # Blank space above the graph. Default is +20+.
+    attr_writer :top_margin
 
-    # Blank space below the graph
-    attr_accessor :bottom_margin
+    # Blank space below the graph. Default is +20+.
+    attr_writer :bottom_margin
 
-    # Blank space to the right of the graph
-    attr_accessor :right_margin
+    # Blank space to the right of the graph. Default is +20+.
+    attr_writer :right_margin
 
-    # Blank space to the left of the graph
-    attr_accessor :left_margin
+    # Blank space to the left of the graph. Default is +20+.
+    attr_writer :left_margin
 
-    # Blank space below the title
-    attr_accessor :title_margin
+    # Blank space below the title. Default is +20+.
+    attr_writer :title_margin
 
-    # Blank space below the legend
-    attr_accessor :legend_margin
+    # Blank space below the legend. Default is +20+.
+    attr_writer :legend_margin
 
     # A hash of names for the individual columns, where the key is the array
     # index for the column this label represents.
     #
     # Not all columns need to be named.
     #
-    # Example: 0 => 2005, 3 => 2006, 5 => 2007, 7 => 2008
-    attr_accessor :labels
+    # @example
+    #   { 0 => 2005, 3 => 2006, 5 => 2007, 7 => 2008 }
+    attr_writer :labels
 
     # Used internally for spacing.
     #
     # By default, labels are centered over the point they represent.
-    attr_accessor :center_labels_over_point
+    attr_writer :center_labels_over_point
 
-    # Used internally for horizontal graph types.
-    attr_accessor :has_left_labels
+    # Used internally for horizontal graph types. Default is +false+.
+    attr_writer :has_left_labels
 
-    # A label for the bottom of the graph
-    attr_accessor :x_axis_label
+    # Set a label for the bottom of the graph.
+    attr_writer :x_axis_label
 
-    # A label for the left side of the graph
-    attr_accessor :y_axis_label
+    # Set a label for the left side of the graph.
+    attr_writer :y_axis_label
 
-    # attr_accessor :x_axis_increment
+    # Set increment of the vertical marking lines.
+    attr_writer :x_axis_increment
 
-    # Manually set increment of the horizontal marking lines
-    attr_accessor :y_axis_increment
+    # Set increment of the horizontal marking lines.
+    attr_writer :y_axis_increment
 
-    # Height of staggering between labels (Bar graph only)
-    attr_accessor :label_stagger_height
+    # Height of staggering between labels (Bar graph only).
+    attr_writer :label_stagger_height
 
-    # Truncates labels if longer than max specified
-    attr_accessor :label_max_size
+    # Truncates labels if longer than max specified.
+    attr_writer :label_max_size
 
-    # How truncated labels visually appear if they exceed label_max_size
-    # :absolute - does not show trailing dots to indicate truncation. This is
-    #   the default.
-    # :trailing_dots - shows trailing dots to indicate truncation (note
-    #   that label_max_size must be greater than 3).
-    attr_accessor :label_truncation_style
+    # How truncated labels visually appear if they exceed {#label_max_size=}.
+    #
+    # - +:absolute+ - does not show trailing dots to indicate truncation. This is the default.
+    # - +:trailing_dots+ - shows trailing dots to indicate truncation (note that {#label_max_size=}
+    #   must be greater than 3).
+    attr_writer :label_truncation_style
 
     # Get or set the list of colors that will be used to draw the bars or lines.
     attr_accessor :colors
 
-    # The large title of the graph displayed at the top
-    attr_accessor :title
+    # Set the large title of the graph displayed at the top.
+    attr_writer :title
 
-    # Font used for titles, labels, etc. Works best if you provide the full
-    # path to the TTF font file.  RMagick must be built with the Freetype
-    # libraries for this to work properly.
-    #
-    # Tries to find Bitstream Vera (Vera.ttf) in the location specified by
-    # ENV['MAGICK_FONT_PATH']. Uses default RMagick font otherwise.
-    #
-    # The font= method below fulfills the role of the writer, so we only need
-    # a reader here.
-    attr_reader :font
+    # Same as {#font=} but for the title.
+    attr_writer :title_font
 
-    # Same as font but for the title.
-    attr_reader :title_font
-    
-    # Specifies whether to draw the title bolded or not.
-    attr_accessor :bold_title
+    # Specifies whether to draw the title bolded or not. Default is +true+.
+    attr_writer :bold_title
 
-    attr_accessor :font_color
+    # Specifies the text color.
+    attr_writer :font_color
 
-    # Prevent drawing of line markers
-    attr_accessor :hide_line_markers
+    # Prevent drawing of line markers. Default is +false+.
+    attr_writer :hide_line_markers
 
-    # Prevent drawing of the legend
-    attr_accessor :hide_legend
+    # Prevent drawing of the legend. Default is +false+.
+    attr_writer :hide_legend
 
-    # Prevent drawing of the title
-    attr_accessor :hide_title
+    # Prevent drawing of the title. Default is +false+.
+    attr_writer :hide_title
 
-    # Prevent drawing of line numbers
-    attr_accessor :hide_line_numbers
+    # Prevent drawing of line numbers. Default is +false+.
+    attr_writer :hide_line_numbers
 
-    # Message shown when there is no data. Fits up to 20 characters. Defaults
-    # to "No Data."
-    attr_accessor :no_data_message
+    # Set a message shown when there is no data. Fits up to 20 characters. Defaults
+    # to +"No Data."+.
+    attr_writer :no_data_message
 
-    # The font size of the large title at the top of the graph
-    attr_accessor :title_font_size
+    # Set the font size of the large title at the top of the graph. Default is +36+.
+    attr_writer :title_font_size
 
     # Optionally set the size of the font. Based on an 800x600px graph.
-    # Default is 20.
+    # Default is +20+.
     #
     # Will be scaled down if the graph is smaller than 800px wide.
-    attr_accessor :legend_font_size
-
-    # Display the legend under the graph
-    attr_accessor :legend_at_bottom
+    attr_writer :legend_font_size
 
-    # The font size of the labels around the graph
-    attr_accessor :marker_font_size
+    # Display the legend under the graph. Default is +false+.
+    attr_writer :legend_at_bottom
 
-    # The color of the auxiliary lines
-    attr_accessor :marker_color
-    attr_accessor :marker_shadow_color
-
-    # The number of horizontal lines shown for reference
-    attr_accessor :marker_count
-
-    # You can manually set a minimum value instead of having the values
-    # guessed for you.
-    #
-    # Set it after you have given all your data to the graph object.
-    attr_accessor :minimum_value
+    # The font size of the labels around the graph. Default is +21+.
+    attr_writer :marker_font_size
 
-    # You can manually set a maximum value, such as a percentage-based graph
-    # that always goes to 100.
-    #
-    # If you use this, you must set it after you have given all your data to
-    # the graph object.
-    attr_accessor :maximum_value
+    # Set the color of the auxiliary lines.
+    attr_writer :marker_color
 
-    # Set to true if you want the data sets sorted with largest avg values drawn
-    # first.
-    attr_accessor :sort
+    # Set the shadow color of the auxiliary lines.
+    attr_writer :marker_shadow_color
 
-    # Set to true if you want the data sets drawn with largest avg values drawn
-    # first.  This does not affect the legend.
-    attr_accessor :sorted_drawing
+    # Set the number of horizontal lines shown for reference.
+    attr_writer :marker_count
 
-    # Experimental
-    attr_accessor :additional_line_values
+    # Set to +true+ if you want the data sets sorted with largest avg values drawn
+    # first. Default is +false+.
+    attr_writer :sort
 
-    # Experimental
-    attr_accessor :stacked
+    # Set to +true+ if you want the data sets drawn with largest avg values drawn
+    # first. This does not affect the legend. Default is +false+.
+    attr_writer :sorted_drawing
 
     # Optionally set the size of the colored box by each item in the legend.
-    # Default is 20.0
+    # Default is +20.0+.
     #
     # Will be scaled down if graph is smaller than 800px wide.
-    attr_accessor :legend_box_size
-
-    # Output the values for the bars on a bar graph
-    # Default is false
-    attr_accessor :show_labels_for_bar_values
+    attr_writer :legend_box_size
 
-    # Set the number output format for labels using sprintf
-    # Default is "%.2f"
-    attr_accessor :label_formatting
+    # With Side Bars use the data label for the marker value to the left of the bar.
+    # Default is +false+.
+    attr_writer :use_data_label
 
-    # With Side Bars use the data label for the marker value to the left of the bar
-    # Default is false
-    attr_accessor :use_data_label
     # If one numerical argument is given, the graph is drawn at 4/3 ratio
-    # according to the given width (800 results in 800x600, 400 gives 400x300,
+    # according to the given width (+800+ results in 800x600, +400+ gives 400x300,
     # etc.).
     #
-    # Or, send a geometry string for other ratios ('800x400', '400x225').
+    # Or, send a geometry string for other ratios ( +'800x400'+, +'400x225'+).
     #
-    # Looks for Bitstream Vera as the default font. Expects an environment var
-    # of MAGICK_FONT_PATH to be set. (Uses RMagick's default font otherwise.)
-    def initialize(target_width=DEFAULT_TARGET_WIDTH)
-      if Numeric === target_width
+    # @param target_width [Numeric, String] The graph image width.
+    #
+    def initialize(target_width = DEFAULT_TARGET_WIDTH)
+      if target_width.is_a?(String)
+        @columns, @rows = target_width.split('x').map(&:to_f)
+      else
         @columns = target_width.to_f
         @rows = target_width.to_f * 0.75
-      else
-        geometric_width, geometric_height = target_width.split('x')
-        @columns = geometric_width.to_f
-        @rows = geometric_height.to_f
       end
+      @columns.freeze
+      @rows.freeze
 
+      initialize_graph_scale
       initialize_ivars
+      initialize_store
 
-      reset_themes
       self.theme = Themes::KEYNOTE
     end
 
-    # Set instance variables for this object.
+    def initialize_graph_scale
+      @raw_columns = DEFAULT_TARGET_WIDTH
+      @raw_rows = DEFAULT_TARGET_WIDTH * (@rows / @columns)
+      @raw_columns.freeze
+      @raw_rows.freeze
+
+      @scale = @columns / @raw_columns
+      @scale.freeze
+    end
+    protected :initialize_graph_scale
+
+    def initialize_store
+      @store = Gruff::Store.new(Gruff::Store::BaseData)
+    end
+    protected :initialize_store
+
+    # Initialize instance variable of attribures
     #
     # Subclasses can override this, call super, then set values separately.
     #
     # This makes it possible to set defaults in a subclass but still allow
     # developers to change this values in their program.
     def initialize_ivars
-      # Internal for calculations
-      @raw_columns = 800.0
-      @raw_rows = 800.0 * (@rows/@columns)
-      @column_count = 0
       @marker_count = nil
       @maximum_value = @minimum_value = nil
-      @has_data = false
-      @data = Array.new
-      @labels = Hash.new
-      @labels_seen = Hash.new
+      @labels = {}
       @sort = false
+      @sorted_drawing = false
       @title = nil
+      @title_font = nil
 
-      @scale = @columns / @raw_columns
-
-      vera_font_path = File.expand_path('Vera.ttf', ENV['MAGICK_FONT_PATH'])
-      @font = File.exists?(vera_font_path) ? vera_font_path : nil
+      @font = nil
       @bold_title = true
 
       @marker_font_size = 21.0
@@ -269,90 +229,100 @@ module Gruff
 
       @no_data_message = 'No Data'
 
-      @hide_line_markers = @hide_legend = @hide_title = @hide_line_numbers = @legend_at_bottom = @show_labels_for_bar_values = false
+      @hide_line_markers = @hide_legend = @hide_title = @hide_line_numbers = @legend_at_bottom = false
       @center_labels_over_point = true
       @has_left_labels = false
       @label_stagger_height = 0
       @label_max_size = 0
       @label_truncation_style = :absolute
 
-      @additional_line_values = []
-      @additional_line_colors = []
-      @theme_options = {}
-
+      @use_data_label = false
+      @x_axis_increment = nil
       @x_axis_label = @y_axis_label = nil
       @y_axis_increment = nil
-      @stacked = nil
-      @norm_data = nil
     end
+    protected :initialize_ivars
 
     # Sets the top, bottom, left and right margins to +margin+.
+    #
+    # @param margin [Numeric] The margin size.
+    #
     def margins=(margin)
       @top_margin = @left_margin = @right_margin = @bottom_margin = margin
     end
 
     # Sets the font for graph text to the font at +font_path+.
+    #
+    # @param font_path [String] The path to font.
+    #
     def font=(font_path)
       @font = font_path
-      @d.font = @font
-    end
-
-    # Sets the title font to the font at +font_path+
-    def title_font=(font_path)
-      @title_font = font_path
+      Gruff::Renderer.font = @font
     end
 
     # Add a color to the list of available colors for lines.
     #
-    # Example:
-    #  add_color('#c0e9d3')
+    # @param colorname [String] The color.
+    #
+    # @example
+    #   add_color('#c0e9d3')
     def add_color(colorname)
       @colors << colorname
     end
 
     # Replace the entire color list with a new array of colors. Also
-    # aliased as the colors= setter method.
+    # aliased as the {#colors=} setter method.
     #
     # If you specify fewer colors than the number of datasets you intend
-    # to draw, 'increment_color' will cycle through the array, reusing
-    # colors as needed.
+    # to draw, it will cycle through the array, reusing colors as needed.
     #
-    # Note that (as with the 'theme' method), you should set up your color
-    # list before you send your data (via the 'data' method).  Calls to the
-    # 'data' method made prior to this call will use whatever color scheme
+    # Note that (as with the {#theme=} method), you should set up your color
+    # list before you send your data (via the {#data} method).  Calls to the
+    # {#data} method made prior to this call will use whatever color scheme
     # was in place at the time data was called.
     #
-    # Example:
-    #  replace_colors ['#cc99cc', '#d9e043', '#34d8a2']
-    def replace_colors(color_list=[])
+    # @param color_list [Array] The array of colors.
+    #
+    # @example
+    #   replace_colors ['#cc99cc', '#d9e043', '#34d8a2']
+    def replace_colors(color_list = [])
       @colors = color_list
-      @color_index = 0
     end
 
     # You can set a theme manually. Assign a hash to this method before you
     # send your data.
     #
-    #  graph.theme = {
-    #    :colors => %w(orange purple green white red),
-    #    :marker_color => 'blue',
-    #    :background_colors => ['black', 'grey', :top_bottom]
-    #  }
+    #   graph.theme = {
+    #     colors: %w(orange purple green white red),
+    #     marker_color: 'blue',
+    #     background_colors: ['black', 'grey'],
+    #     background_direction: :top_bottom
+    #   }
     #
-    # :background_image => 'squirrel.png' is also possible.
+    # +background_image: 'squirrel.png'+ is also possible.
+    #
+    # +background_direction+ accepts one of following parameters.
+    # - +:top_bottom+
+    # - +:bottom_top+
+    # - +:left_right+
+    # - +:right_left+
+    # - +:topleft_bottomright+
+    # - +:topright_bottomleft+
     #
     # (Or hopefully something better looking than that.)
     #
+    # @param options [Hash] The optional setting for theme
+    #
     def theme=(options)
       reset_themes
 
       defaults = {
-          :colors => %w(black white),
-          :additional_line_colors => [],
-          :marker_color => 'white',
-          :marker_shadow_color => nil,
-          :font_color => 'black',
-          :background_colors => nil,
-          :background_image => nil
+        colors: %w[black white],
+        marker_color: 'white',
+        marker_shadow_color: nil,
+        font_color: 'black',
+        background_colors: nil,
+        background_image: nil
       }
       @theme_options = defaults.merge options
 
@@ -360,35 +330,42 @@ module Gruff
       @marker_color = @theme_options[:marker_color]
       @marker_shadow_color = @theme_options[:marker_shadow_color]
       @font_color = @theme_options[:font_color] || @marker_color
-      @additional_line_colors = @theme_options[:additional_line_colors]
 
-      render_background
+      Gruff::Renderer.setup(@columns, @rows, @font, @scale, @theme_options)
     end
 
+    # Apply Apple's keynote theme.
     def theme_keynote
       self.theme = Themes::KEYNOTE
     end
 
+    # Apply 37signals theme.
     def theme_37signals
       self.theme = Themes::THIRTYSEVEN_SIGNALS
     end
 
+    # Apply Rails theme.
     def theme_rails_keynote
       self.theme = Themes::RAILS_KEYNOTE
     end
 
+    # Apply Odeo theme.
     def theme_odeo
       self.theme = Themes::ODEO
     end
 
+    # Apply pastel theme.
     def theme_pastel
       self.theme = Themes::PASTEL
     end
 
+    # Apply greyscale theme.
     def theme_greyscale
       self.theme = Themes::GREYSCALE
     end
 
+    # Input the data in the graph.
+    #
     # Parameters are an array where the first element is the name of the dataset
     # and the value is an array of values to plot.
     #
@@ -398,62 +375,65 @@ module Gruff
     # If the color argument is nil, the next color from the default theme will
     # be used.
     #
-    # NOTE: If you want to use a preset theme, you must set it before calling
-    # data().
+    # @param name [String, Symbol] The name of the dataset.
+    # @param data_points [Array] The array of dataset.
+    # @param color [String] The color for drawing graph of dataset.
+    #
+    # @note
+    #   If you want to use a preset theme, you must set it before calling {#data}.
     #
-    # Example:
+    # @example
     #   data("Bart S.", [95, 45, 78, 89, 88, 76], '#ffcc00')
-    def data(name, data_points=[], color=nil)
-      data_points = Array(data_points) # make sure it's an array
-      @data << [name, data_points, color]
-                                       # Set column count if this is larger than previous counts
-      @column_count = (data_points.length > @column_count) ? data_points.length : @column_count
-
-      # Pre-normalize
-      data_points.each do |data_point|
-        next if data_point.nil?
-
-        # Setup max/min so spread starts at the low end of the data points
-        if @maximum_value.nil? && @minimum_value.nil?
-          @maximum_value = @minimum_value = data_point
-        end
+    def data(name, data_points = [], color = nil)
+      store.add(name, data_points, color)
+    end
 
-        # TODO Doesn't work with stacked bar graphs
-        # Original: @maximum_value = larger_than_max?(data_point, index) ? max(data_point, index) : @maximum_value
-        @maximum_value = larger_than_max?(data_point) ? data_point : @maximum_value
-        @has_data = true if @maximum_value >= 0
+    # You can manually set a minimum value instead of having the values
+    # guessed for you.
+    #
+    # Set it after you have given all your data to the graph object.
+    def minimum_value
+      @minimum_value || store.min
+    end
+    attr_writer :minimum_value
 
-        @minimum_value = less_than_min?(data_point) ? data_point : @minimum_value
-        @has_data = true if @minimum_value < 0
-      end
+    # You can manually set a maximum value, such as a percentage-based graph
+    # that always goes to 100.
+    #
+    # If you use this, you must set it after you have given all your data to
+    # the graph object.
+    def maximum_value
+      @maximum_value || store.max
     end
+    attr_writer :maximum_value
 
-    # Writes the graph to a file. Defaults to 'graph.png'
+    # Writes the graph to a file. Defaults to +'graph.png'+
     #
-    # Example:
+    # @param file_name [String] The file name of output image.
+    #
+    # @example
     #   write('graphs/my_pretty_graph.png')
-    def write(filename='graph.png')
+    def write(file_name = 'graph.png')
       draw
-      @base_image.write(filename)
+      Gruff::Renderer.write(file_name)
     end
 
     # Return the graph as a rendered binary blob.
-    def to_blob(fileformat='PNG')
+    #
+    # @param image_format [String] The image format of binary blob.
+    def to_blob(image_format = 'PNG')
       draw
-      @base_image.to_blob do
-        self.format = fileformat
-      end
+      Gruff::Renderer.to_blob(image_format)
     end
 
-
-    protected
+  protected
 
     # Overridden by subclasses to do the actual plotting of the graph.
     #
     # Subclasses should start by calling super() for this method.
     def draw
       # Maybe should be done in one of the following functions for more granularity.
-      unless @has_data
+      unless data_given?
         draw_no_data
         return
       end
@@ -461,14 +441,6 @@ module Gruff
       setup_data
       setup_drawing
 
-      debug {
-        # Outer margin
-        @d.rectangle(@left_margin, @top_margin,
-                     @raw_columns - @right_margin, @raw_rows - @bottom_margin)
-        # Graph area box
-        @d.rectangle(@graph_left, @graph_top, @graph_right, @graph_bottom)
-      }
-
       draw_legend
       draw_line_markers
       draw_axis_labels
@@ -478,10 +450,9 @@ module Gruff
     # Perform data manipulation before calculating chart measurements
     def setup_data # :nodoc:
       if @y_axis_increment && !@hide_line_markers
-        @maximum_value = [@y_axis_increment, @maximum_value, (@maximum_value.to_f / @y_axis_increment).round * @y_axis_increment].max
-        @minimum_value = [@minimum_value, (@minimum_value.to_f / @y_axis_increment).round * @y_axis_increment].min
+        self.maximum_value = [@y_axis_increment, maximum_value, (maximum_value.to_f / @y_axis_increment).round * @y_axis_increment].max
+        self.minimum_value = [minimum_value, (minimum_value.to_f / @y_axis_increment).round * @y_axis_increment].min
       end
-      make_stacked if @stacked
     end
 
     # Calculates size of drawable area and generates normalized data.
@@ -491,6 +462,7 @@ module Gruff
     # * title
     def setup_drawing
       calculate_spread
+      calculate_increment
       sort_data if @sort # Sort data with avg largest values set first (for display)
       set_colors
       normalize
@@ -498,126 +470,71 @@ module Gruff
       sort_norm_data if @sorted_drawing # Sort norm_data with avg largest values set first (for display)
     end
 
-    # Make copy of data with values scaled between 0-100
-    def normalize(force=false)
-      if @norm_data.nil? || force
-        @norm_data = []
-        return unless @has_data
-
-        @data.each do |data_row|
-          norm_data_points = []
-          data_row[DATA_VALUES_INDEX].each do |data_point|
-            if data_point.nil?
-              norm_data_points << nil
-            else
-              norm_data_points << ((data_point.to_f - @minimum_value.to_f) / @spread)
-            end
-          end
-          if @show_labels_for_bar_values
-            @norm_data << [data_row[DATA_LABEL_INDEX], norm_data_points, data_row[DATA_COLOR_INDEX], data_row[DATA_VALUES_INDEX]]
-          else
-            @norm_data << [data_row[DATA_LABEL_INDEX], norm_data_points, data_row[DATA_COLOR_INDEX]]
-          end
+    attr_reader :store
+
+    def data_given?
+      @data_given ||= begin
+        if store.empty?
+          false
+        else
+          minimum_value <= store.min || maximum_value >= store.max
         end
       end
     end
 
+    def column_count
+      store.columns
+    end
+
+    # Make copy of data with values scaled between 0-100
+    def normalize
+      store.normalize(minimum: minimum_value, spread: @spread)
+    end
+
     def calculate_spread # :nodoc:
-      @spread = @maximum_value.to_f - @minimum_value.to_f
+      @spread = maximum_value.to_f - minimum_value.to_f
       @spread = @spread > 0 ? @spread : 1
     end
 
+    def hide_title?
+      @hide_title || @title.nil? || @title.empty?
+    end
+
     ##
     # Calculates size of drawable area, general font dimensions, etc.
 
     def setup_graph_measurements
-      @marker_caps_height = @hide_line_markers ? 0 :
-          calculate_caps_height(@marker_font_size)
-      @title_caps_height = (@hide_title || @title.nil?) ? 0 :
-          calculate_caps_height(@title_font_size) * @title.lines.to_a.size
-      @legend_caps_height = @hide_legend ? 0 :
-          calculate_caps_height(@legend_font_size)
-
-      if @hide_line_markers
-        (@graph_left,
-            @graph_right_margin,
-            @graph_bottom_margin) = [@left_margin, @right_margin, @bottom_margin]
-      else
-        if @has_left_labels
-          longest_left_label_width = calculate_width(@marker_font_size,
-                                                     labels.values.inject('') { |value, memo| (value.to_s.length > memo.to_s.length) ? value : memo }) * 1.25
-        else
-          longest_left_label_width = calculate_width(@marker_font_size,
-                                                     label(@maximum_value.to_f, @increment))
-        end
-
-        # Shift graph if left line numbers are hidden
-        line_number_width = @hide_line_numbers && !@has_left_labels ?
-            0.0 :
-            (longest_left_label_width + LABEL_MARGIN * 2)
-
-        @graph_left = @left_margin +
-            line_number_width +
-            (@y_axis_label.nil? ? 0.0 : @marker_caps_height + LABEL_MARGIN * 2)
-
-        # Make space for half the width of the rightmost column label.
-        # Might be greater than the number of columns if between-style bar markers are used.
-        last_label = @labels.keys.sort.last.to_i
-        extra_room_for_long_label = (last_label >= (@column_count-1) && @center_labels_over_point) ?
-            calculate_width(@marker_font_size, @labels[last_label]) / 2.0 :
-            0
-        @graph_right_margin = @right_margin + extra_room_for_long_label
-
-        @graph_bottom_margin = @bottom_margin +
-            @marker_caps_height + LABEL_MARGIN
-      end
+      @marker_caps_height = setup_marker_caps_height
+      @title_caps_height = setup_title_caps_height
+      @legend_caps_height = setup_legend_caps_height
 
-      @graph_right = @raw_columns - @graph_right_margin
-      @graph_width = @raw_columns - @graph_left - @graph_right_margin
+      margin_on_right = graph_right_margin
+      @graph_right = @raw_columns - margin_on_right
+      @graph_left = setup_left_margin
+      @graph_top = setup_top_margin
+      @graph_bottom = setup_bottom_margin
 
-      # When @hide title, leave a title_margin space for aesthetics.
-      # Same with @hide_legend
-      @graph_top = @legend_at_bottom ? @top_margin : (@top_margin +
-          (@hide_title ? title_margin : @title_caps_height + title_margin) +
-          (@hide_legend ? legend_margin : @legend_caps_height + legend_margin))
-
-      x_axis_label_height = @x_axis_label.nil? ? 0.0 :
-          @marker_caps_height + LABEL_MARGIN
-      # FIXME: Consider chart types other than bar
-      @graph_bottom = @raw_rows - @graph_bottom_margin - x_axis_label_height - @label_stagger_height
+      @graph_width = @raw_columns - @graph_left - margin_on_right
       @graph_height = @graph_bottom - @graph_top
     end
 
     # Draw the optional labels for the x axis and y axis.
     def draw_axis_labels
-      unless @x_axis_label.nil?
+      if @x_axis_label
         # X Axis
         # Centered vertically and horizontally by setting the
         # height to 1.0 and the width to the width of the graph.
-        x_axis_label_y_coordinate = @graph_bottom + LABEL_MARGIN * 2 + @marker_caps_height
-
-        # TODO Center between graph area
-        @d.fill = @font_color
-        @d.font = @font if @font
-        @d.stroke('transparent')
-        @d.pointsize = scale_fontsize(@marker_font_size)
-        @d.gravity = NorthGravity
-        @d = @d.annotate_scaled(@base_image,
-                                @raw_columns, 1.0,
-                                0.0, x_axis_label_y_coordinate,
-                                @x_axis_label, @scale)
-        debug { @d.line 0.0, x_axis_label_y_coordinate, @raw_columns, x_axis_label_y_coordinate }
+        x_axis_label_y_coordinate = @graph_bottom + LABEL_MARGIN + @marker_caps_height
+
+        # TODO: Center between graph area
+        text_renderer = Gruff::Renderer::Text.new(@x_axis_label, font: @font, size: @marker_font_size, color: @font_color)
+        text_renderer.add_to_render_queue(@raw_columns, 1.0, 0.0, x_axis_label_y_coordinate)
       end
 
-      unless @y_axis_label.nil?
+      if @y_axis_label
         # Y Axis, rotated vertically
-        @d.rotation = -90.0
-        @d.gravity = CenterGravity
-        @d = @d.annotate_scaled(@base_image,
-                                1.0, @raw_rows,
-                                @left_margin + @marker_caps_height / 2.0, 0.0,
-                                @y_axis_label, @scale)
-        @d.rotation = 90.0
+        text_renderer = Gruff::Renderer::Text.new(@y_axis_label, font: @font, size: @marker_font_size, color: @font_color, rotation: -90)
+        text_renderer.add_to_render_queue(1.0, @raw_rows, @left_margin + @marker_caps_height / 2.0, 0.0, Magick::CenterGravity)
       end
     end
 
@@ -625,210 +542,108 @@ module Gruff
     def draw_line_markers
       return if @hide_line_markers
 
-      @d = @d.stroke_antialias false
-
-      if @y_axis_increment.nil?
-        # Try to use a number of horizontal lines that will come out even.
-        #
-        # TODO Do the same for larger numbers...100, 75, 50, 25
-        if @marker_count.nil?
-          (3..7).each do |lines|
-            if @spread % lines == 0.0
-              @marker_count = lines
-              break
-            end
-          end
-          @marker_count ||= 4
-        end
-        @increment = (@spread > 0 && @marker_count > 0) ? significant(@spread / @marker_count) : 1
-      else
-        # TODO Make this work for negative values
-        @marker_count = (@spread / @y_axis_increment).to_i
-        @increment = @y_axis_increment
-      end
-      @increment_scaled = @graph_height.to_f / (@spread / @increment)
+      increment_scaled = @graph_height.to_f / (@spread / @increment)
 
       # Draw horizontal line markers and annotate with numbers
       (0..@marker_count).each do |index|
-        y = @graph_top + @graph_height - index.to_f * @increment_scaled
-
-        @d = @d.fill(@marker_color)
-
-        # FIXME(uwe): Workaround for Issue #66
-        #             https://github.com/topfunky/gruff/issues/66
-        #             https://github.com/rmagick/rmagick/issues/82
-        #             Remove if the issue gets fixed.
-        y += 0.001 unless defined?(JRUBY_VERSION)
-        # EMXIF
-
-        @d = @d.line(@graph_left, y, @graph_right, y)
-        #If the user specified a marker shadow color, draw a shadow just below it
-        unless @marker_shadow_color.nil?
-          @d = @d.fill(@marker_shadow_color)
-          @d = @d.line(@graph_left, y + 1, @graph_right, y + 1)
-        end
+        y = @graph_top + @graph_height - index.to_f * increment_scaled
 
-        marker_label = BigDecimal(index.to_s) * BigDecimal(@increment.to_s) +
-            BigDecimal(@minimum_value.to_s)
+        line_renderer = Gruff::Renderer::Line.new(color: @marker_color, shadow_color: @marker_shadow_color)
+        line_renderer.render(@graph_left, y, @graph_right, y)
 
         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 = EastGravity
-
-          # Vertically center with 1.0 for the height
-          @d = @d.annotate_scaled(@base_image,
-                                  @graph_left - LABEL_MARGIN, 1.0,
-                                  0.0, y,
-                                  label(marker_label, @increment), @scale)
+          marker_label = BigDecimal(index.to_s) * BigDecimal(@increment.to_s) + BigDecimal(minimum_value.to_s)
+          label = label(marker_label, @increment)
+          text_renderer = Gruff::Renderer::Text.new(label, font: @font, size: @marker_font_size, color: @font_color)
+          text_renderer.add_to_render_queue(@graph_left - LABEL_MARGIN, 1.0, 0.0, y, Magick::EastGravity)
         end
       end
-
-      # # Submitted by a contibutor...the utility escapes me
-      # i = 0
-      # @additional_line_values.each do |value|
-      #   @increment_scaled = @graph_height.to_f / (@maximum_value.to_f / value)
-      #
-      #   y = @graph_top + @graph_height - @increment_scaled
-      #
-      #   @d = @d.stroke(@additional_line_colors[i])
-      #   @d = @d.line(@graph_left, y, @graph_right, y)
-      #
-      #
-      #   @d.fill = @additional_line_colors[i]
-      #   @d.font = @font if @font
-      #   @d.stroke('transparent')
-      #   @d.pointsize = scale_fontsize(@marker_font_size)
-      #   @d.gravity = EastGravity
-      #   @d = @d.annotate_scaled( @base_image,
-      #                     100, 20,
-      #                     -10, y - (@marker_font_size/2.0),
-      #                     "", @scale)
-      #   i += 1
-      # end
-
-      @d = @d.stroke_antialias true
     end
 
-    ##
     # Return the sum of values in an array.
     #
     # Duplicated to not conflict with active_support in Rails.
-
     def sum(arr)
-      arr.inject(0) { |i, m| m + i }
+      arr.reduce(0) { |i, m| m + i }
     end
 
-    ##
     # Return a calculation of center
-
     def center(size)
       (@raw_columns - size) / 2
     end
 
-    ##
     # Draws a legend with the names of the datasets matched
     # to the colors used to draw them.
-
     def draw_legend
       return if @hide_legend
 
-      @legend_labels = @data.collect { |item| item[DATA_LABEL_INDEX] }
-
+      legend_labels = store.data.map(&:label)
       legend_square_width = @legend_box_size # small square with color of this item
+      label_widths = calculate_legend_label_widths_for_each_line(legend_labels, legend_square_width)
 
-      # May fix legend drawing problem at small sizes
-      @d.font = @font if @font
-      @d.pointsize = @legend_font_size
-
-      label_widths = [[]] # Used to calculate line wrap
-      @legend_labels.each do |label|
-        metrics = @d.get_type_metrics(@base_image, label.to_s)
-        label_width = metrics.width + legend_square_width * 2.7
-        label_widths.last.push label_width
-
-        if sum(label_widths.last) > (@raw_columns * 0.9)
-          label_widths.push [label_widths.last.pop]
+      current_x_offset = center(sum(label_widths.first))
+      current_y_offset = begin
+        if @legend_at_bottom
+          @graph_height + @title_margin
+        else
+          hide_title? ? @top_margin + @title_margin : @top_margin + @title_margin + @title_caps_height
         end
       end
 
-      current_x_offset = center(sum(label_widths.first))
-      current_y_offset = @legend_at_bottom ? @graph_height + title_margin : (@hide_title ?
-          @top_margin + title_margin :
-          @top_margin + title_margin + @title_caps_height)
-
-      @legend_labels.each_with_index do |legend_label, index|
+      legend_labels.each_with_index do |legend_label, index|
+        next if legend_label.empty?
 
         # Draw label
-        @d.fill = @font_color
-        @d.font = @font if @font
-        @d.pointsize = scale_fontsize(@legend_font_size)
-        @d.stroke('transparent')
-        @d.font_weight = NormalWeight
-        @d.gravity = WestGravity
-        @d = @d.annotate_scaled(@base_image,
-                                @raw_columns, 1.0,
-                                current_x_offset + (legend_square_width * 1.7), current_y_offset,
-                                legend_label.to_s, @scale)
+        text_renderer = Gruff::Renderer::Text.new(legend_label, font: @font, size: @legend_font_size, color: @font_color)
+        text_renderer.add_to_render_queue(@raw_columns, 1.0, current_x_offset + (legend_square_width * 1.7), current_y_offset, Magick::WestGravity)
 
         # Now draw box with color of this dataset
-        @d = @d.stroke('transparent')
-        @d = @d.fill @data[index][DATA_COLOR_INDEX]
-        @d = @d.rectangle(current_x_offset,
-                          current_y_offset - legend_square_width / 2.0,
-                          current_x_offset + legend_square_width,
-                          current_y_offset + legend_square_width / 2.0)
-
-        @d.pointsize = @legend_font_size
-        metrics = @d.get_type_metrics(@base_image, legend_label.to_s)
-        current_string_offset = metrics.width + (legend_square_width * 2.7)
+        rect_renderer = Gruff::Renderer::Rectangle.new(color: store.data[index].color)
+        rect_renderer.render(current_x_offset,
+                             current_y_offset - legend_square_width / 2.0,
+                             current_x_offset + legend_square_width,
+                             current_y_offset + legend_square_width / 2.0)
+
+        width = calculate_width(@legend_font_size, legend_label)
+        current_x_offset += width + (legend_square_width * 2.7)
+        label_widths.first.shift
 
         # Handle wrapping
-        label_widths.first.shift
         if label_widths.first.empty?
-          debug { @d.line 0.0, current_y_offset, @raw_columns, current_y_offset }
-
           label_widths.shift
           current_x_offset = center(sum(label_widths.first)) unless label_widths.empty?
-          line_height = [@legend_caps_height, legend_square_width].max + legend_margin
-          if label_widths.length > 0
+          line_height = [@legend_caps_height, legend_square_width].max + @legend_margin
+          unless label_widths.empty?
             # Wrap to next line and shrink available graph dimensions
             current_y_offset += line_height
             @graph_top += line_height
             @graph_height = @graph_bottom - @graph_top
           end
-        else
-          current_x_offset += current_string_offset
         end
       end
-      @color_index = 0
     end
 
     # Draws a title on the graph.
     def draw_title
-      return if (@hide_title || @title.nil?)
-
-      @d.fill = @font_color
-      @d.font = @title_font || @font if @title_font || @font
-      @d.stroke('transparent')
-      @d.pointsize = scale_fontsize(@title_font_size)
-      @d.font_weight = if @bold_title then BoldWeight else NormalWeight end
-      @d.gravity = NorthGravity
-      @d = @d.annotate_scaled(@base_image,
-                              @raw_columns, 1.0,
-                              0, @top_margin,
-                              @title, @scale)
+      return if hide_title?
+
+      font = @title_font || @font
+      font_weight = @bold_title ? Magick::BoldWeight : Magick::NormalWeight
+      font_size = @title_font_size
+
+      metrics = Renderer::Text.metrics(@title, font_size, font_weight)
+      if metrics.width > @raw_columns
+        font_size = font_size * (@raw_columns / metrics.width) * 0.95
+      end
+      text_renderer = Gruff::Renderer::Text.new(@title, font: font, size: font_size, color: @font_color, weight: font_weight)
+      text_renderer.add_to_render_queue(@raw_columns, 1.0, 0, @top_margin)
     end
 
     # Draws column labels below graph, centered over x_offset
     #--
     # TODO Allow WestGravity as an option
-    def draw_label(x_offset, index)
-      return if @hide_line_markers
-
-      if !@labels[index].nil? && @labels_seen[index].nil?
+    def draw_label(x_offset, index, gravity = Magick::NorthGravity)
+      draw_unique_label(index) do
         y_offset = @graph_bottom + LABEL_MARGIN
 
         # TESTME
@@ -836,138 +651,42 @@ module Gruff
         # TODO: See if index.odd? is the best stragegy
         y_offset += @label_stagger_height if index.odd?
 
-        label_text = @labels[index]
-
-        # TESTME
-        # FIXME: Consider chart types other than bar
-        if label_text.size > @label_max_size
-          if @label_truncation_style == :trailing_dots
-            if @label_max_size > 3
-              # 4 because '...' takes up 3 chars
-              label_text = "#{label_text[0 .. (@label_max_size - 4)]}..."
-            end
-          else # @label_truncation_style is :absolute (default)
-            label_text = label_text[0 .. (@label_max_size - 1)]
-          end
-
-        end
+        label_text = truncate_label_text(@labels[index].to_s)
 
         if x_offset >= @graph_left && x_offset <= @graph_right
-          @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 = NorthGravity
-          @d = @d.annotate_scaled(@base_image,
-                                  1.0, 1.0,
-                                  x_offset, y_offset,
-                                  label_text, @scale)
+          text_renderer = Gruff::Renderer::Text.new(label_text, font: @font, size: @marker_font_size, color: @font_color)
+          text_renderer.add_to_render_queue(1.0, 1.0, x_offset, y_offset, gravity)
         end
+      end
+    end
+
+    def draw_unique_label(index)
+      return if @hide_line_markers
+
+      @labels_seen ||= {}
+      if !@labels[index].nil? && @labels_seen[index].nil?
+        yield
         @labels_seen[index] = 1
-        debug { @d.line 0.0, y_offset, @raw_columns, y_offset }
       end
     end
 
     # Draws the data value over the data point in bar graphs
-    def draw_value_label(x_offset, y_offset, data_point, bar_value=false)
+    def draw_value_label(x_offset, y_offset, data_point, bar_value = false)
       return if @hide_line_markers && !bar_value
 
-      #y_offset = @graph_bottom + LABEL_MARGIN
-
-      @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 = NorthGravity
-      @d = @d.annotate_scaled(@base_image,
-                              1.0, 1.0,
-                              x_offset, y_offset,
-                              data_point.to_s, @scale)
-
-      debug { @d.line 0.0, y_offset, @raw_columns, y_offset }
+      text_renderer = Gruff::Renderer::Text.new(data_point, font: @font, size: @marker_font_size, color: @font_color)
+      text_renderer.add_to_render_queue(1.0, 1.0, x_offset, y_offset)
     end
 
     # Shows an error message because you have no data.
     def draw_no_data
-      @d.fill = @font_color
-      @d.font = @font if @font
-      @d.stroke('transparent')
-      @d.font_weight = NormalWeight
-      @d.pointsize = scale_fontsize(80)
-      @d.gravity = CenterGravity
-      @d = @d.annotate_scaled(@base_image,
-                              @raw_columns, @raw_rows/2.0,
-                              0, 10,
-                              @no_data_message, @scale)
-    end
-
-    # Finds the best background to render based on the provided theme options.
-    #
-    # Creates a @base_image to draw on.
-    def render_background
-      case @theme_options[:background_colors]
-      when Array
-        @base_image = render_gradiated_background(@theme_options[:background_colors][0], @theme_options[:background_colors][1], @theme_options[:background_direction])
-      when String
-        @base_image = render_solid_background(@theme_options[:background_colors])
-      else
-        @base_image = render_image_background(*@theme_options[:background_image])
-      end
-    end
-
-    # Make a new image at the current size with a solid +color+.
-    def render_solid_background(color)
-      Image.new(@columns, @rows) {
-        self.background_color = color
-      }
-    end
-
-    # Use with a theme definition method to draw a gradiated background.
-    def render_gradiated_background(top_color, bottom_color, direct = :top_bottom)
-      case direct
-      when :bottom_top
-        gradient_fill = GradientFill.new(0, 0, 100, 0, bottom_color, top_color)
-      when :left_right
-        gradient_fill = GradientFill.new(0, 0, 0, 100, top_color, bottom_color)
-      when :right_left
-        gradient_fill = GradientFill.new(0, 0, 0, 100, bottom_color, top_color)
-      when :topleft_bottomright
-        gradient_fill = GradientFill.new(0, 100, 100, 0, top_color, bottom_color)
-      when :topright_bottomleft
-        gradient_fill = GradientFill.new(0, 0, 100, 100, bottom_color, top_color)
-      else
-        gradient_fill = GradientFill.new(0, 0, 100, 0, top_color, bottom_color)
-      end
-      Image.new(@columns, @rows, gradient_fill)
-    end
-
-    # Use with a theme to use an image (800x600 original) background.
-    def render_image_background(image_path)
-      image = Image.read(image_path)
-      if @scale != 1.0
-        image[0].resize!(@scale) # TODO Resize with new scale (crop if necessary for wide graph)
-      end
-      image[0]
-    end
-
-    # Use with a theme to make a transparent background
-    def render_transparent_background
-      Image.new(@columns, @rows) do
-        self.background_color = 'transparent'
-      end
+      text_renderer = Gruff::Renderer::Text.new(@no_data_message, font: @font, size: 80, color: @font_color)
+      text_renderer.render(@raw_columns, @raw_rows, 0, 0, Magick::CenterGravity)
     end
 
     # Resets everything to defaults (except data).
     def reset_themes
-      @color_index = 0
-      @labels_seen = {}
       @theme_options = {}
-
-      @d = Draw.new
-      # Scale down from 800x600 used to calculate drawing.
-      @d = @d.scale(@scale, @scale)
     end
 
     def scale(value) # :nodoc:
@@ -983,17 +702,9 @@ module Gruff
       (value > max_value) ? max_value : value
     end
 
-    # Overridden by subclasses such as stacked bar.
-    def larger_than_max?(data_point) # :nodoc:
-      data_point > @maximum_value
-    end
-
-    def less_than_min?(data_point) # :nodoc:
-      data_point < @minimum_value
-    end
-
     def significant(i) # :nodoc:
       return 1.0 if i == 0 # Keep from going into infinite loop
+
       inc = BigDecimal(i.to_s)
       factor = BigDecimal('1.0')
       while inc < 10
@@ -1009,6 +720,8 @@ module Gruff
       res = inc.floor * factor
       if res.to_i.to_f == res
         res.to_i
+      elsif res.to_f == res
+        res.to_f
       else
         res
       end
@@ -1016,69 +729,89 @@ module Gruff
 
     # Sort with largest overall summed value at front of array.
     def sort_data
-      @data = @data.sort_by { |a| -a[DATA_VALUES_INDEX].inject(0) { |sum, num| sum + num.to_f } }
+      store.sort_data!
     end
 
-    # Set the color for each data set unless it was gived in the data(...) call.
+    # Set the color for each data set unless it was given in the data(...) call.
     def set_colors
-      @data.each { |a| a[DATA_COLOR_INDEX] ||= increment_color }
+      store.change_colors(@colors)
     end
 
     # Sort with largest overall summed value at front of array so it shows up
     # correctly in the drawn graph.
     def sort_norm_data
-      @norm_data =
-          @norm_data.sort_by { |a| -a[DATA_VALUES_INDEX].inject(0) { |sum, num| sum + num.to_f } }
+      store.sort_norm_data!
     end
 
-    # Used by StackedBar and child classes.
-    #
-    # May need to be moved to the StackedBar class.
-    def get_maximum_by_stack
-      # Get sum of each stack
-      max_hash = {}
-      @data.each do |data_set|
-        data_set[DATA_VALUES_INDEX].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
+  private
 
-      # @maximum_value = 0
-      max_hash.keys.each do |key|
-        @maximum_value = max_hash[key] if max_hash[key] > @maximum_value
-      end
-      @minimum_value = 0
+    def setup_marker_caps_height
+      @hide_line_markers ? 0 : calculate_caps_height(@marker_font_size)
     end
 
-    def make_stacked # :nodoc:
-      stacked_values = Array.new(@column_count, 0)
-      @data.each do |value_set|
-        value_set[DATA_VALUES_INDEX].each_with_index do |value, index|
-          stacked_values[index] += value
-        end
-        value_set[DATA_VALUES_INDEX] = stacked_values.dup
-      end
+    def setup_title_caps_height
+      hide_title? ? 0 : calculate_caps_height(@title_font_size) * @title.lines.to_a.size
     end
 
-    private
+    def setup_legend_caps_height
+      @hide_legend ? 0 : calculate_caps_height(@legend_font_size)
+    end
 
-    # Takes a block and draws it if DEBUG is true.
-    #
-    # Example:
-    #   debug { @d.rectangle x1, y1, x2, y2 }
-    def debug
-      if DEBUG
-        @d = @d.fill 'transparent'
-        @d = @d.stroke 'turquoise'
-        @d = yield
+    def graph_right_margin
+      @hide_line_markers ? @right_margin : @right_margin + extra_room_for_long_label
+    end
+
+    def extra_room_for_long_label
+      # Make space for half the width of the rightmost column label.
+      # Might be greater than the number of columns if between-style bar markers are used.
+      last_label = @labels.keys.max.to_i
+      (last_label >= (column_count - 1) && @center_labels_over_point) ? calculate_width(@marker_font_size, @labels[last_label]) / 2.0 : 0
+    end
+
+    def setup_left_margin
+      return @left_margin if @hide_line_markers
+
+      if @has_left_labels
+        longest_left_label_width = calculate_width(@marker_font_size,
+                                                   @labels.values.reduce('') { |value, memo| (value.to_s.length > memo.to_s.length) ? value : memo }) * 1.25
+      else
+        longest_left_label_width = calculate_width(@marker_font_size,
+                                                   label(maximum_value.to_f, @increment))
       end
+      # Shift graph if left line numbers are hidden
+      line_number_width = @hide_line_numbers && !@has_left_labels ? 0.0 : (longest_left_label_width + LABEL_MARGIN * 2)
+
+      @left_margin + line_number_width + (@y_axis_label.nil? ? 0.0 : @marker_caps_height + LABEL_MARGIN * 2)
+    end
+
+    def setup_top_margin
+      return @top_margin if @legend_at_bottom
+
+      # When @hide title, leave a title_margin space for aesthetics.
+      # Same with @hide_legend
+      @top_margin +
+        (hide_title? ? @title_margin : @title_caps_height + @title_margin) +
+        (@hide_legend ? @legend_margin : @legend_caps_height + @legend_margin)
+    end
+
+    def setup_bottom_margin
+      graph_bottom_margin = @hide_line_markers ? @bottom_margin : @bottom_margin + @marker_caps_height + LABEL_MARGIN
+
+      x_axis_label_height = @x_axis_label.nil? ? 0.0 : @marker_caps_height + LABEL_MARGIN
+      # FIXME: Consider chart types other than bar
+      @raw_rows - graph_bottom_margin - x_axis_label_height - @label_stagger_height
     end
 
-    # Returns the next color in your color list.
-    def increment_color
-      @color_index = (@color_index + 1) % @colors.length
-      @colors[@color_index - 1]
+    def truncate_label_text(text)
+      return text if text.size <= @label_max_size
+
+      if @label_truncation_style == :trailing_dots
+        # 4 because '...' takes up 3 chars
+        text = "#{text[0..(@label_max_size - 4)]}..." if @label_max_size > 3
+      else
+        text = text[0..(@label_max_size - 1)]
+      end
+      text
     end
 
     # Return a formatted string representing a number value that should be
@@ -1098,7 +831,7 @@ module Gruff
                 else
                   value.to_s
                 end
-              elsif (@spread.to_f % (@marker_count.to_f==0 ? 1 : @marker_count.to_f) == 0) || !@y_axis_increment.nil?
+              elsif (@spread.to_f % (@marker_count.to_f == 0 ? 1 : @marker_count.to_f) == 0) || !@y_axis_increment.nil?
                 value.to_i.to_s
               elsif @spread > 10.0
                 sprintf('%0i', value)
@@ -1109,19 +842,34 @@ module Gruff
               end
 
       parts = label.split('.')
-      parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{THOUSAND_SEPARATOR}")
+      parts[0] = parts[0].commify
       parts.join('.')
     end
 
+    def calculate_legend_label_widths_for_each_line(legend_labels, legend_square_width)
+      # May fix legend drawing problem at small sizes
+      label_widths = [[]] # Used to calculate line wrap
+      legend_labels.each do |label|
+        width = calculate_width(@legend_font_size, label)
+        label_width = width + legend_square_width * 2.7
+        label_widths.last.push label_width
+
+        if sum(label_widths.last) > (@raw_columns * 0.9)
+          label_widths.push [label_widths.last.pop]
+        end
+      end
+
+      label_widths
+    end
+
     # Returns the height of the capital letter 'X' for the current font and
     # size.
     #
     # Not scaled since it deals with dimensions that the regular scaling will
     # handle.
     def calculate_caps_height(font_size)
-      @d.pointsize = font_size
-      @d.font = @font if @font
-      @d.get_type_metrics(@base_image, 'X').height
+      metrics = Renderer::Text.metrics('X', font_size)
+      metrics.height
     end
 
     # Returns the width of a string at this pointsize.
@@ -1129,58 +877,41 @@ module Gruff
     # Not scaled since it deals with dimensions that the regular
     # scaling will handle.
     def calculate_width(font_size, text)
-      return 0 if text.nil?
-      @d.pointsize = font_size
-      @d.font = @font if @font
-      @d.get_type_metrics(@base_image, text.to_s).width
-    end
+      text = text.to_s
+      return 0 if text.empty?
 
-    # Used for degree => radian conversions
-    def deg2rad(angle)
-      angle * (Math::PI/180.0)
-    end
-
-  end # Gruff::Base
-
-  class IncorrectNumberOfDatasetsException < StandardError;
-  end
-
-end # Gruff
-
-module Magick
-
-  class Draw
-
-    # Additional method to scale annotation text since Draw.scale doesn't.
-    def annotate_scaled(img, width, height, x, y, text, scale)
-      scaled_width = (width * scale) >= 1 ? (width * scale) : 1
-      scaled_height = (height * scale) >= 1 ? (height * scale) : 1
-
-      self.annotate(img,
-                    scaled_width, scaled_height,
-                    x * scale, y * scale,
-                    text.gsub('%', '%%'))
+      metrics = Renderer::Text.metrics(text, font_size)
+      metrics.width
     end
 
-    if defined? JRUBY_VERSION
-      # FIXME(uwe):  We should NOT need to implement this method.
-      #              Remove this method as soon as RMagick4J Issue #16 is fixed.
-      #              https://github.com/Serabe/RMagick4J/issues/16
-      def fill=(fill)
-        fill = {:white => '#FFFFFF'}[fill.to_sym] || fill
-        @draw.fill = Magick4J.ColorDatabase.query_default(fill)
-        self
+    def calculate_increment
+      if @y_axis_increment.nil?
+        # Try to use a number of horizontal lines that will come out even.
+        #
+        # TODO Do the same for larger numbers...100, 75, 50, 25
+        if @marker_count.nil?
+          (3..7).each do |lines|
+            if @spread % lines == 0.0
+              @marker_count = lines
+              break
+            end
+          end
+          @marker_count ||= 4
+        end
+        @increment = (@spread > 0 && @marker_count > 0) ? significant(@spread / @marker_count) : 1
+      else
+        # TODO: Make this work for negative values
+        @marker_count = (@spread / @y_axis_increment).to_i
+        @increment = @y_axis_increment
       end
-      # EMXIF
     end
 
+    # Used for degree => radian conversions
+    def deg2rad(angle)
+      angle * (Math::PI / 180.0)
+    end
   end
 
-end # Magick
-
-class String
-  #Taken from http://codesnippets.joyent.com/posts/show/330
-  def commify(delimiter=',')
-    self.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
+  class IncorrectNumberOfDatasetsException < StandardError
   end
 end