gruff 0.8.0-java → 0.9.0-java

data/lib/gruff/bezier.rb

@@ -1,20 +1,21 @@
-require File.dirname(__FILE__) + '/base'
+# frozen_string_literal: true
+
+require 'gruff/base'
 
 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'
@@ -28,18 +29,15 @@ 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,12 @@
-require File.dirname(__FILE__) + '/base'
+# frozen_string_literal: true
+
+require 'gruff/base'
 require 'gruff/themes'
 
 # http://en.wikipedia.org/wiki/Bullet_graph
 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 +14,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
 
@@ -23,30 +26,13 @@ class Gruff::Bullet < Gruff::Base
 
   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,54 +41,50 @@ class Gruff::Bullet < Gruff::Base
 
     draw_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
+    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)
+      next unless @options.key?(indicator)
+
+      indicator_width_x = graph_left + graph_width * (@options[indicator] / maximum_value)
 
-      @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)
+      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,50 +1,40 @@
-require File.dirname(__FILE__) + '/base'
+# frozen_string_literal: true
+
+require 'gruff/base'
 
-##
 # Graph with dots and labels along a vertical access
 # see: 'Creating More Effective Graphs' by Robbins
-
 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
@@ -53,11 +43,7 @@ protected
   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
@@ -74,31 +60,21 @@ protected
         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
 
@@ -106,19 +82,9 @@ protected
   # 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(1, 1, -@graph_left + LABEL_MARGIN * 2.0, y_offset, Magick::EastGravity)
     end
   end
-
 end

data/lib/gruff/{bar_conversion.rb → helper/bar_conversion.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ##
 # Original Author: David Stokar
 #
@@ -9,6 +11,7 @@
 #   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
@@ -17,30 +20,28 @@ class Gruff::BarConversion
   attr_writer :minimum_value
   attr_writer :spread
 
-  def get_left_y_right_y_scaled(data_point, result)
+  def get_left_y_right_y_scaled(data_point)
+    result = []
+
     case @mode
     when 1 then # Case one
-                # minimum value >= 0 ( only positiv values )
+                # 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 negativ values
+                # only negative values
       result[0] = @graph_top + 1
       result[1] = @graph_top + @graph_height * (1 - data_point) - 1
     when 3 then # Case three
-                # positiv and negativ values
+                # positive and negative values
       val = data_point - @minimum_value / @spread
-      if data_point >= @zero
-        result[0] = @graph_top + @graph_height * (1 - (val - @zero)) + 1
-        result[1] = @graph_top + @graph_height * (1 - @zero) - 1
-      else
-        result[0] = @graph_top + @graph_height * (1 - (val - @zero)) + 1
-        result[1] = @graph_top + @graph_height * (1 - @zero) - 1
-      end
+      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
-  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

data/lib/gruff/{stacked_mixin.rb → helper/stacked_mixin.rb}

@@ -1,22 +1,23 @@
+# frozen_string_literal: true
+
+# @private
 module Gruff::Base::StackedMixin
   # Used by StackedBar and child classes.
   #
   # tsal: moved from Base 03 FEB 2007
-  DATA_VALUES_INDEX = Gruff::Base::DATA_VALUES_INDEX
   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|
+    store.data.each do |data_set|
+      data_set.points.each_with_index do |data_point, i|
         max_hash[i] = 0.0 unless max_hash[i]
         max_hash[i] += data_point.to_f
       end
     end
 
-    # @maximum_value = 0
     max_hash.each_key do |key|
-      @maximum_value = max_hash[key] if max_hash[key] > @maximum_value
+      self.maximum_value = max_hash[key] if max_hash[key] > maximum_value
     end
-    @minimum_value = 0
+    self.minimum_value = 0
   end
 end

data/lib/gruff/line.rb

@@ -1,6 +1,7 @@
-require File.dirname(__FILE__) + '/base'
+# frozen_string_literal: true
+
+require 'gruff/base'
 
-##
 # Here's how to make a Line graph:
 #
 #   g = Gruff::Line.new
@@ -9,79 +10,74 @@ require File.dirname(__FILE__) + '/base'
 #   g.data 'Hamburgers', [50, 19, 99, 29]
 #   g.write("test/output/line.png")
 #
-# There are also other options described below, such as #baseline_value, #baseline_color, #hide_dots, and #hide_lines.
-
+# There are also other options described below, such as {#baseline_value}, {#baseline_color},
+# {#hide_dots}, and {#hide_lines}.
 class Gruff::Line < Gruff::Base
-
-  # Allow for reference lines ( which are like baseline ... just allowing for more & on both axes )
+  # Allow for reference lines ( which are like baseline ... just allowing for more & on both axes ).
   attr_accessor :reference_lines
   attr_accessor :reference_line_default_color
   attr_accessor :reference_line_default_width
 
-  # Allow for vertical marker lines
+  # Allow for vertical marker lines.
   attr_accessor :show_vertical_markers
 
-  # Dimensions of lines and dots; calculated based on dataset size if left unspecified
+  # Dimensions of lines and dots; calculated based on dataset size if left unspecified.
   attr_accessor :line_width
   attr_accessor :dot_radius
 
-  # default is a circle, other options include square
+  # default is +'circle'+, other options include square.
   attr_accessor :dot_style
 
   # Hide parts of the graph to fit more datapoints, or for a different appearance.
   attr_accessor :hide_dots, :hide_lines
 
-  #accessors for support of xy data
+  # accessors for support of xy data.
   attr_accessor :minimum_x_value
+
+  # accessors for support of xy data.
   attr_accessor :maximum_x_value
 
   # Get the value if somebody has defined it.
   def baseline_value
     if @reference_lines.key?(:baseline)
       @reference_lines[:baseline][:value]
-    else
-      nil
     end
   end
 
   # Set a value for a baseline reference line..
   def baseline_value=(new_value)
-    @reference_lines[:baseline] ||= Hash.new
+    @reference_lines[:baseline] ||= {}
     @reference_lines[:baseline][:value] = new_value
   end
 
   def baseline_color
     if @reference_lines.key?(:baseline)
       @reference_lines[:baseline][:color]
-    else
-      nil
     end
   end
 
   def baseline_color=(new_value)
-    @reference_lines[:baseline] ||= Hash.new
+    @reference_lines[:baseline] ||= {}
     @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).
+  # 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) # 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)
   #
-  #  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.
+  # 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? || ((not Numeric === args.first) && (not String === args.first))
+    if args.empty? || (!args.first.is_a?(Numeric) && !args.first.is_a?(String))
       super()
     else
       super args.shift
     end
 
-    @reference_lines = Hash.new
+    @reference_lines = {}
     @reference_line_default_color = 'red'
     @reference_line_default_width = 5
 
@@ -92,83 +88,67 @@ class Gruff::Line < Gruff::Base
     @dot_style = 'circle'
 
     @show_vertical_markers = false
+
+    @store = Gruff::Store.new(Gruff::Store::XYData)
   end
 
   # This method allows one to plot a dataset with both X and Y data.
   #
-  # Parameters are as follows:
-  #   name: string, the title of the dataset
-  #   x_data_points: an array containing the x data points for the graph
-  #   y_data_points: an array containing the y data points for the graph
-  #   color: hex number indicating the line color as an RGB triplet
+  # @overload dataxy(name, x_data_points = [], y_data_points = [], color = nil)
+  #   @param name [String] the title of the dataset.
+  #   @param x_data_points [Array] an array containing the x data points for the graph.
+  #   @param y_data_points [Array] an array containing the y data points for the graph.
+  #   @param color [String] hex number indicating the line color as an RGB triplet.
   #
-  #   or
+  # @overload dataxy(name, xy_data_points = [], color = nil)
+  #   @param name [String] the title of the dataset.
+  #   @param xy_data_points [Array] an array containing both x and y data points for the graph.
+  #   @param color [String] hex number indicating the line color as an RGB triplet.
   #
-  #   name: string, the title of the dataset
-  #   xy_data_points: an array containing both x and y data points for the graph
-  #   color: hex number indicating the line color as an RGB triplet
-  #
-  #  Notes:
-  #   -if (x_data_points.length != y_data_points.length) an error is
+  # @note
+  #   - if (x_data_points.length != y_data_points.length) an error is
   #     returned.
-  #   -if the color argument is nil, the next color from the default theme will
+  #   - if the color argument is nil, the next color from the default theme will
   #     be used.
-  #   -if you want to use a preset theme, you must set it before calling
-  #     dataxy().
+  #   - if you want to use a preset theme, you must set it before calling {#dataxy}.
   #
-  # Example:
+  # @example
   #   g = Gruff::Line.new
   #   g.title = "X/Y Dataset"
   #   g.dataxy("Apples", [1,3,4,5,6,10], [1, 2, 3, 4, 4, 3])
   #   g.dataxy("Bapples", [1,3,4,5,7,9], [1, 1, 2, 2, 3, 3])
   #   g.dataxy("Capples", [[1,1],[2,3],[3,4],[4,5],[5,7],[6,9]])
-  #   #you can still use the old data method too if you want:
+  #
+  #   # you can still use the old data method too if you want:
   #   g.data("Capples", [1, 1, 2, 2, 3, 3])
-  #   #labels will be drawn at the x locations of the keys passed in.
+  #
+  #   # labels will be drawn at the x locations of the keys passed in.
   #   In this example the lables are drawn at x positions 2, 4, and 6:
   #   g.labels = {0 => '2003', 2 => '2004', 4 => '2005', 6 => '2006'}
-  #   The 0 => '2003' label will be ignored since it is outside the chart range.
+  #   # The 0 => '2003' label will be ignored since it is outside the chart range.
   def dataxy(name, x_data_points = [], y_data_points = [], color = nil)
-    raise ArgumentError, 'x_data_points is nil!' if x_data_points.length == 0
+    # make sure it's an array
+    x_data_points = Array(x_data_points)
+    y_data_points = Array(y_data_points)
+
+    raise ArgumentError, 'x_data_points is nil!' if x_data_points.empty?
 
     if x_data_points.all? { |p| p.is_a?(Array) && p.size == 2 }
-      y_data_points = x_data_points.map { |p| p[1] }
-      x_data_points = x_data_points.map { |p| p[0] }
+      x_data_points, y_data_points = x_data_points.transpose
     end
 
     raise ArgumentError, 'x_data_points.length != y_data_points.length!' if x_data_points.length != y_data_points.length
 
-    # call the existing data routine for the y data.
-    self.data(name, y_data_points, color)
-
-    x_data_points = Array(x_data_points) # make sure it's an array
-    # append the x data to the last entry that was just added in the @data member
-    @data.last[DATA_VALUES_X_INDEX] = x_data_points
-
-    # Update the global min/max values for the x data
-    x_data_points.each do |x_data_point|
-      next if x_data_point.nil?
-
-      # Setup max/min so spread starts at the low end of the data points
-      if @maximum_x_value.nil? && @minimum_x_value.nil?
-        @maximum_x_value = @minimum_x_value = x_data_point
-      end
-
-      @maximum_x_value = (x_data_point > @maximum_x_value) ?
-          x_data_point : @maximum_x_value
-      @minimum_x_value = (x_data_point < @minimum_x_value) ?
-          x_data_point : @minimum_x_value
-    end
+    # call the existing data routine for the x/y data.
+    store.add(name, y_data_points, color, x_data_points)
   end
 
   def draw_reference_line(reference_line, left, right, top, bottom)
-    @d = @d.push
-    @d.stroke_color(reference_line[:color] || @reference_line_default_color)
-    @d.fill_opacity 0.0
-    @d.stroke_dasharray(10, 20)
-    @d.stroke_width(reference_line[:width] || @reference_line_default_width)
-    @d.line(left, top, right, bottom)
-    @d = @d.pop
+    config = {
+      color: reference_line[:color] || @reference_line_default_color,
+      width: reference_line[:width] || @reference_line_default_width
+    }
+    Gruff::Renderer::DashLine.new(config).render(left, top, right, bottom)
   end
 
   def draw_horizontal_reference_line(reference_line)
@@ -184,10 +164,10 @@ class Gruff::Line < Gruff::Base
   def draw
     super
 
-    return unless @has_data
+    return unless data_given?
 
     # 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).to_f) : @graph_width
 
     @reference_lines.each_value do |curr_reference_line|
       draw_horizontal_reference_line(curr_reference_line) if curr_reference_line.key?(:norm_value)
@@ -195,70 +175,51 @@ class Gruff::Line < Gruff::Base
     end
 
     if @show_vertical_markers
-      (0..@column_count).each do |column|
+      (0..column_count).each do |column|
         x = @graph_left + @graph_width - column.to_f * @x_increment
 
-        @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.
-        x += 0.001 unless defined?(JRUBY_VERSION)
-        # EMXIF
-
-        @d = @d.line(x, @graph_bottom, x, @graph_top)
+        Gruff::Renderer::Line.new(color: @marker_color).render(x, @graph_bottom, x, @graph_top)
         #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(x + 1, @graph_bottom, x + 1, @graph_top)
+        if @marker_shadow_color
+          Gruff::Renderer::Line.new(color: @marker_shadow_color).render(x + 1, @graph_bottom, x + 1, @graph_top)
         end
       end
     end
 
-    @norm_data.each do |data_row|
+    store.norm_data.each do |data_row|
       prev_x = prev_y = nil
 
-      @one_point = contains_one_point_only?(data_row)
+      one_point = contains_one_point_only?(data_row)
 
-      data_row[DATA_VALUES_INDEX].each_with_index do |data_point, index|
-        x_data = data_row[DATA_VALUES_X_INDEX]
-        if x_data == nil
+      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[index], @graph_width, @graph_left)
+          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)
           end
         end
-        unless data_point # we can't draw a line for a null data point, we can still label the axis though
+        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 - data_point * @graph_height)
+        new_y = @graph_top + (@graph_height - y_data * @graph_height)
 
         # Reset each time to avoid thin-line errors
-        @d = @d.stroke data_row[DATA_COLOR_INDEX]
-        @d = @d.fill data_row[DATA_COLOR_INDEX]
-        @d = @d.stroke_opacity 1.0
-        @d = @d.stroke_width line_width ||
-                                 clip_value_if_greater_than(@columns / (@norm_data.first[DATA_VALUES_INDEX].size * 4), 5.0)
-
-        circle_radius = dot_radius ||
-            clip_value_if_greater_than(@columns / (@norm_data.first[DATA_VALUES_INDEX].size * 2.5), 5.0)
-
-        if !@hide_lines && !prev_x.nil? && !prev_y.nil?
-          @d = @d.line(prev_x, prev_y, new_x, new_y)
-        elsif @one_point
-          # Show a circle if there's just one_point
-          @d = DotRenderers.renderer(@dot_style).render(@d, new_x, new_y, circle_radius)
+        stroke_width  = line_width || clip_value_if_greater_than(@columns / (store.norm_data.first.y_points.size * 4), 5.0)
+        circle_radius = dot_radius || clip_value_if_greater_than(@columns / (store.norm_data.first.y_points.size * 2.5), 5.0)
+
+        if !@hide_lines && prev_x && prev_y
+          Gruff::Renderer::Line.new(color: data_row.color, width: stroke_width)
+                               .render(prev_x, prev_y, new_x, new_y)
         end
 
-        unless @hide_dots
-          @d = DotRenderers.renderer(@dot_style).render(@d, new_x, new_y, circle_radius)
+        if one_point || !@hide_dots
+          Gruff::Renderer::Dot.new(@dot_style, color: data_row.color, width: stroke_width).render(new_x, new_y, circle_radius)
         end
 
         prev_x = new_x
@@ -266,13 +227,19 @@ class Gruff::Line < Gruff::Base
       end
     end
 
-    @d.draw(@base_image)
+    Gruff::Renderer.finish
   end
 
+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
+
     # 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.to_f]
+    possible_minimums = [minimum_value.to_f]
 
     @reference_lines.each_value do |curr_reference_line|
       if curr_reference_line.key?(:value)
@@ -281,37 +248,28 @@ class Gruff::Line < Gruff::Base
       end
     end
 
-    @maximum_value = possible_maximums.max
-    @minimum_value = possible_minimums.min
+    self.maximum_value = possible_maximums.max
+    self.minimum_value = possible_minimums.min
 
     super
   end
 
-  def normalize(force = false)
-    super(force)
+  def normalize
+    return unless data_given?
+
+    spread_x = @maximum_x_value.to_f - @minimum_x_value.to_f
+    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)
-    end
-
-    #normalize the x data if it is specified
-    @data.each_with_index do |data_row, index|
-      norm_x_data_points = []
-      if data_row[DATA_VALUES_X_INDEX] != nil
-        data_row[DATA_VALUES_X_INDEX].each do |x_data_point|
-          norm_x_data_points << ((x_data_point.to_f - @minimum_x_value.to_f) /
-              (@maximum_x_value.to_f - @minimum_x_value.to_f))
-        end
-        @norm_data[index] << norm_x_data_points
-      end
+      curr_reference_line[:norm_value] = ((curr_reference_line[:value].to_f - minimum_value) / @spread.to_f) if curr_reference_line.key?(:value)
     end
   end
 
   def sort_norm_data
-    super unless @data.any? { |d| d[DATA_VALUES_X_INDEX] }
+    super unless store.data.any?(&:x_points)
   end
 
   def get_x_coord(x_data_point, width, offset)
@@ -319,46 +277,6 @@ class Gruff::Line < Gruff::Base
   end
 
   def contains_one_point_only?(data_row)
-    # Spin through data to determine if there is just one_value present.
-    one_point = false
-    data_row[DATA_VALUES_INDEX].each do |data_point|
-      unless data_point.nil?
-        if one_point
-          # more than one point, bail
-          return false
-        end
-
-        # there is at least one data point
-        one_point = true
-      end
-    end
-    one_point
-  end
-
-  module DotRenderers
-    class Circle
-      def render(d, new_x, new_y, circle_radius)
-        d.circle(new_x, new_y, new_x - circle_radius, new_y)
-      end
-    end
-
-    class Square
-      def render(d, new_x, new_y, circle_radius)
-        offset = (circle_radius * 0.8).to_i
-        corner_1 = new_x - offset
-        corner_2 = new_y - offset
-        corner_3 = new_x + offset
-        corner_4 = new_y + offset
-        d.rectangle(corner_1, corner_2, corner_3, corner_4)
-      end
-    end
-
-    def self.renderer(style)
-      if style.to_s == 'square'
-        Square.new
-      else
-        Circle.new
-      end
-    end
+    data_row.y_points.compact.count == 1
   end
 end