gruff 0.13.0-java → 0.16.0-java

data/lib/gruff/line.rb

@@ -37,29 +37,8 @@ class Gruff::Line < Gruff::Base
   # accessors for support of xy data.
   attr_writer :maximum_x_value
 
-  # Get the value if somebody has defined it.
-  def baseline_value
-    if @reference_lines.key?(:baseline)
-      @reference_lines[:baseline][:value]
-    end
-  end
-
-  # Set a value for a baseline reference line..
-  def baseline_value=(new_value)
-    @reference_lines[:baseline] ||= {}
-    @reference_lines[:baseline][:value] = new_value
-  end
-
-  def baseline_color
-    if @reference_lines.key?(:baseline)
-      @reference_lines[:baseline][:color]
-    end
-  end
-
-  def baseline_color=(new_value)
-    @reference_lines[:baseline] ||= {}
-    @reference_lines[:baseline][:color] = new_value
-  end
+  # The number of vertical lines shown.
+  attr_writer :marker_x_count
 
   # Call with target pixel width of graph (+800+, +400+, +300+), and/or +false+ to omit lines (points only).
   #
@@ -78,28 +57,29 @@ class Gruff::Line < Gruff::Base
     end
   end
 
-  def initialize_store
-    @store = Gruff::Store.new(Gruff::Store::XYData)
+  # Get the value if somebody has defined it.
+  def baseline_value
+    if @reference_lines.key?(:baseline)
+      @reference_lines[:baseline][:value]
+    end
   end
-  private :initialize_store
 
-  def initialize_ivars
-    super
-    @reference_lines = {}
-    @reference_line_default_color = 'red'
-    @reference_line_default_width = 5
-
-    @hide_dots = @hide_lines = false
-    @maximum_x_value = nil
-    @minimum_x_value = nil
+  # Set a value for a baseline reference line..
+  def baseline_value=(new_value)
+    @reference_lines[:baseline] ||= {}
+    @reference_lines[:baseline][:value] = new_value
+  end
 
-    @line_width = nil
-    @dot_radius = nil
-    @dot_style = 'circle'
+  def baseline_color
+    if @reference_lines.key?(:baseline)
+      @reference_lines[:baseline][:color]
+    end
+  end
 
-    @show_vertical_markers = false
+  def baseline_color=(new_value)
+    @reference_lines[:baseline] ||= {}
+    @reference_lines[:baseline][:color] = new_value
   end
-  private :initialize_ivars
 
   # This method allows one to plot a dataset with both X and Y data.
   #
@@ -138,12 +118,14 @@ class Gruff::Line < Gruff::Base
   def dataxy(name, x_data_points = [], y_data_points = [], color = nil)
     # 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 }
+      color = y_data_points if y_data_points.is_a?(String)
       x_data_points, y_data_points = x_data_points.transpose
+    else
+      y_data_points = Array(y_data_points)
     end
 
     raise ArgumentError, 'x_data_points.length != y_data_points.length!' if x_data_points.length != y_data_points.length
@@ -152,14 +134,38 @@ class Gruff::Line < Gruff::Base
     store.add(name, y_data_points, color, x_data_points)
   end
 
+private
+
+  def initialize_store
+    @store = Gruff::Store.new(Gruff::Store::XYData)
+  end
+
+  def initialize_attributes
+    super
+    @reference_lines = {}
+    @reference_line_default_color = 'red'
+    @reference_line_default_width = 5
+
+    @hide_dots = @hide_lines = false
+    @maximum_x_value = nil
+    @minimum_x_value = nil
+    @marker_x_count = nil
+
+    @line_width = nil
+    @dot_radius = nil
+    @dot_style = 'circle'
+
+    @show_vertical_markers = false
+  end
+
   def draw_reference_line(reference_line, left, right, top, bottom)
     color = reference_line[:color] || @reference_line_default_color
     width = reference_line[:width] || @reference_line_default_width
-    Gruff::Renderer::DashLine.new(color: color, width: width).render(left, top, right, bottom)
+    Gruff::Renderer::DashLine.new(renderer, color: color, width: width).render(left, top, right, bottom)
   end
 
   def draw_horizontal_reference_line(reference_line)
-    level = @graph_top + (@graph_height - reference_line[:norm_value] * @graph_height)
+    level = @graph_top + (@graph_height - (reference_line[:norm_value] * @graph_height))
     draw_reference_line(reference_line, @graph_left, @graph_left + @graph_width, level, level)
   end
 
@@ -168,65 +174,49 @@ class Gruff::Line < Gruff::Base
     draw_reference_line(reference_line, index, index, @graph_top, @graph_top + @graph_height)
   end
 
-  def draw
-    super
-
-    return unless data_given?
-
+  def draw_graph
     # Check to see if more than one datapoint was given. NaN can result otherwise.
-    @x_increment = (column_count > 1) ? (@graph_width / (column_count - 1).to_f) : @graph_width
+    @x_increment = column_count > 1 ? @graph_width / (column_count - 1) : @graph_width
 
     @reference_lines.each_value do |curr_reference_line|
       draw_horizontal_reference_line(curr_reference_line) if curr_reference_line.key?(:norm_value)
       draw_vertical_reference_line(curr_reference_line) if curr_reference_line.key?(:index)
     end
 
-    if @show_vertical_markers
-      (0..column_count).each do |column|
-        x = @graph_left + @graph_width - column.to_f * @x_increment
-
-        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
-        if @marker_shadow_color
-          Gruff::Renderer::Line.new(color: @marker_shadow_color).render(x + 1, @graph_bottom, x + 1, @graph_top)
-        end
-      end
-    end
-
     store.norm_data.each do |data_row|
       prev_x = prev_y = nil
 
       one_point = contains_one_point_only?(data_row)
 
       data_row.coordinates.each_with_index do |(x_data, y_data), index|
-        if x_data.nil?
-          #use the old method: equally spaced points along the x-axis
-          new_x = @graph_left + (@x_increment * index)
-          draw_label(new_x, index)
-        else
-          new_x = get_x_coord(x_data, @graph_width, @graph_left)
-          @labels.each do |label_pos, _|
-            draw_label(@graph_left + ((label_pos - @minimum_x_value) * @graph_width) / (@maximum_x_value - @minimum_x_value), label_pos)
+        new_x = begin
+          if x_data.nil?
+            # use the old method: equally spaced points along the x-axis
+            @graph_left + (@x_increment * index)
+          else
+            get_x_coord(x_data, @graph_width, @graph_left)
           end
         end
+        draw_label_for_x_data(x_data, new_x, index)
+
         unless y_data # we can't draw a line for a null data point, we can still label the axis though
           prev_x = prev_y = nil
           next
         end
 
-        new_y = @graph_top + (@graph_height - y_data * @graph_height)
+        new_y = @graph_top + (@graph_height - (y_data * @graph_height))
 
         # Reset each time to avoid thin-line errors
         stroke_width  = @line_width || clip_value_if_greater_than(@columns / (store.norm_data.first.y_points.size * 4), 5.0)
         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)
+          Gruff::Renderer::Line.new(renderer, color: data_row.color, width: stroke_width)
                                .render(prev_x, prev_y, new_x, new_y)
         end
 
         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)
+          Gruff::Renderer::Dot.new(renderer, @dot_style, color: data_row.color, width: stroke_width).render(new_x, new_y, circle_radius)
         end
 
         prev_x = new_x
@@ -235,16 +225,14 @@ class Gruff::Line < Gruff::Base
     end
   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
+    @maximum_x_value = (@maximum_x_value || store.max_x).to_f
+    @minimum_x_value = (@minimum_x_value || store.min_x).to_f
 
     # Deal with horizontal reference line values that exceed the existing minimum & maximum values.
-    possible_maximums = [maximum_value.to_f]
-    possible_minimums = [minimum_value.to_f]
+    possible_maximums = [maximum_value]
+    possible_minimums = [minimum_value]
 
     @reference_lines.each_value do |curr_reference_line|
       if curr_reference_line.key?(:value)
@@ -259,26 +247,51 @@ private
     super
   end
 
+  def setup_drawing
+    @marker_x_count ||= column_count - 1
+    super
+  end
+
   def normalize
     return unless data_given?
 
-    spread_x = @maximum_x_value.to_f - @minimum_x_value.to_f
+    spread_x = @maximum_x_value - @minimum_x_value
     store.normalize(minimum_x: @minimum_x_value, spread_x: spread_x, minimum_y: minimum_value, spread_y: @spread)
 
     @reference_lines.each_value do |curr_reference_line|
       # We only care about horizontal markers ... for normalization.
       # Vertical markers won't have a :value, they will have an :index
 
-      curr_reference_line[:norm_value] = ((curr_reference_line[:value].to_f - minimum_value) / @spread.to_f) if curr_reference_line.key?(:value)
+      curr_reference_line[:norm_value] = ((curr_reference_line[:value].to_f - minimum_value) / @spread) if curr_reference_line.key?(:value)
+    end
+  end
+
+  def draw_line_markers
+    # do all of the stuff for the horizontal lines on the y-axis
+    super
+    return if @hide_line_markers
+    return unless @show_vertical_markers
+
+    (0..@marker_x_count).each do |index|
+      x = @graph_left + @graph_width - (index * @graph_width / @marker_x_count)
+
+      Gruff::Renderer::Line.new(renderer, color: @marker_color).render(x, @graph_bottom, x, @graph_top)
+      Gruff::Renderer::Line.new(renderer, color: @marker_shadow_color).render(x + 1, @graph_bottom, x + 1, @graph_top) if @marker_shadow_color
     end
   end
 
-  def sort_norm_data
-    super unless store.data.any?(&:x_points)
+  def draw_label_for_x_data(x_data, new_x, index)
+    if x_data.nil?
+      draw_label(new_x, index)
+    else
+      @labels.each do |label_pos, _|
+        draw_label(@graph_left + (((label_pos - @minimum_x_value) * @graph_width) / (@maximum_x_value - @minimum_x_value)), label_pos)
+      end
+    end
   end
 
   def get_x_coord(x_data_point, width, offset)
-    x_data_point * width + offset
+    (x_data_point * width) + offset
   end
 
   def contains_one_point_only?(data_row)

data/lib/gruff/mini/bar.rb

@@ -16,27 +16,30 @@ module Gruff
   module Mini
     # A class for drawing a small bar graph.
     class Bar < Gruff::Bar
+    private
+
       include Gruff::Mini::Legend
 
-      def initialize_ivars
+      def initialize_attributes
         super
 
         @hide_legend = true
         @hide_title = true
         @hide_line_numbers = true
 
-        @marker_font_size = 50.0
-        @legend_font_size = 60.0
+        @marker_font.size = 50.0
+        @legend_font.size = 60.0
 
         @minimum_value = 0.0
       end
-      private :initialize_ivars
 
-      def draw
+      def setup_data
         expand_canvas_for_vertical_legend
-
         super
+      end
 
+      def draw_graph
+        super
         draw_vertical_legend
       end
     end

data/lib/gruff/mini/legend.rb

@@ -3,6 +3,7 @@
 module Gruff
   module Mini
     # A module to handle the small legend.
+    # @private
     module Legend
       attr_accessor :hide_mini_legend, :legend_position
 
@@ -20,7 +21,7 @@ module Gruff
 
         @legend_labels = store.data.map(&:label)
 
-        legend_height = scale_fontsize(store.length * calculate_line_height + @top_margin + @bottom_margin)
+        legend_height = scale_fontsize((store.length * calculate_line_height) + @top_margin + @bottom_margin)
 
         @original_rows = @raw_rows
         @original_columns = @raw_columns
@@ -30,19 +31,21 @@ module Gruff
           @rows = [@rows, legend_height].max
           @columns += calculate_legend_width + @left_margin
         else
-          @rows += store.length * calculate_caps_height(scale_fontsize(@legend_font_size)) * 1.7
+          font = @legend_font.dup
+          font.size = scale_fontsize(font.size)
+          @rows += store.length * calculate_caps_height(font) * 1.7
         end
 
-        Gruff::Renderer.setup(@columns, @rows, @font, @scale, @theme_options)
+        @renderer = Gruff::Renderer.new(@columns, @rows, @scale, @theme_options)
       end
 
       def calculate_line_height
-        calculate_caps_height(@legend_font_size) * 1.7
+        calculate_caps_height(@legend_font) * 1.7
       end
 
       def calculate_legend_width
-        width = @legend_labels.map { |label| calculate_width(@legend_font_size, label) }.max
-        scale_fontsize(width + 40 * 1.7)
+        width = @legend_labels.map { |label| calculate_width(@legend_font, label) }.max
+        scale_fontsize(width + (40 * 1.7))
       end
 
       ##
@@ -67,16 +70,16 @@ module Gruff
         @legend_labels.each_with_index do |legend_label, index|
           # Draw label
           label = truncate_legend_label(legend_label)
-          text_renderer = Gruff::Renderer::Text.new(label, font: @font, size: @legend_font_size, color: @font_color)
+          text_renderer = Gruff::Renderer::Text.new(renderer, label, font: @legend_font)
           x_offset = current_x_offset + (legend_square_width * 1.7)
           text_renderer.add_to_render_queue(@raw_columns, 1.0, x_offset, current_y_offset, Magick::WestGravity)
 
           # Now draw box with color of this dataset
-          rect_renderer = Gruff::Renderer::Rectangle.new(color: store.data[index].color)
+          rect_renderer = Gruff::Renderer::Rectangle.new(renderer, color: store.data[index].color)
           rect_renderer.render(current_x_offset,
-                               current_y_offset - legend_square_width / 2.0,
+                               current_y_offset - (legend_square_width / 2.0),
                                current_x_offset + legend_square_width,
-                               current_y_offset + legend_square_width / 2.0)
+                               current_y_offset + (legend_square_width / 2.0))
 
           current_y_offset += calculate_line_height
         end
@@ -90,9 +93,10 @@ module Gruff
       def truncate_legend_label(label)
         truncated_label = label.to_s
 
-        font_size = scale_fontsize(@legend_font_size)
+        font = @legend_font.dup
+        font.size = scale_fontsize(font.size)
         max_width = @columns - @legend_left_margin - @right_margin
-        while calculate_width(font_size, truncated_label) > max_width && truncated_label.length > 1
+        while calculate_width(font, truncated_label) > max_width && truncated_label.length > 1
           truncated_label = truncated_label[0..truncated_label.length - 2]
         end
         truncated_label + (truncated_label.length < label.to_s.length ? '...' : '')

data/lib/gruff/mini/pie.rb

@@ -15,25 +15,28 @@ module Gruff
   module Mini
     # A class for drawing a small pie graph.
     class Pie < Gruff::Pie
+    private
+
       include Gruff::Mini::Legend
 
-      def initialize_ivars
+      def initialize_attributes
         super
 
         @hide_legend = true
         @hide_title = true
         @hide_line_numbers = true
 
-        @marker_font_size = 60.0
-        @legend_font_size = 60.0
+        @marker_font.size = 60.0
+        @legend_font.size = 60.0
       end
-      private :initialize_ivars
 
-      def draw
+      def setup_data
         expand_canvas_for_vertical_legend
-
         super
+      end
 
+      def draw_graph
+        super
         draw_vertical_legend
       end
     end

data/lib/gruff/mini/side_bar.rb

@@ -23,24 +23,27 @@ module Gruff
   module Mini
     # A class for drawing a small side bar graph.
     class SideBar < Gruff::SideBar
+    private
+
       include Gruff::Mini::Legend
 
-      def initialize_ivars
+      def initialize_attributes
         super
         @hide_legend = true
         @hide_title = true
         @hide_line_numbers = true
 
-        @marker_font_size = 50.0
-        @legend_font_size = 50.0
+        @marker_font.size = 50.0
+        @legend_font.size = 50.0
       end
-      private :initialize_ivars
 
-      def draw
+      def setup_data
         expand_canvas_for_vertical_legend
-
         super
+      end
 
+      def draw_graph
+        super
         draw_vertical_legend
       end
     end

data/lib/gruff/net.rb

@@ -30,7 +30,9 @@ class Gruff::Net < Gruff::Base
   attr_writer :line_width
   attr_writer :dot_radius
 
-  def initialize_ivars
+private
+
+  def initialize_attributes
     super
 
     @hide_dots = false
@@ -38,42 +40,36 @@ class Gruff::Net < Gruff::Base
     @dot_radius = nil
     @hide_line_numbers = true
     @sorted_drawing = true
+    @marker_font.bold = true
   end
-  private :initialize_ivars
-
-  def draw
-    super
-
-    return unless data_given?
 
+  def draw_graph
     store.norm_data.each do |data_row|
       data_row.points.each_with_index do |data_point, index|
         next if data_point.nil?
 
         rad_pos = index * Math::PI * 2 / column_count
         point_distance = data_point * @radius
-        start_x = @center_x + Math.sin(rad_pos) * point_distance
-        start_y = @center_y - Math.cos(rad_pos) * point_distance
+        start_x = @center_x + (Math.sin(rad_pos) * point_distance)
+        start_y = @center_y - (Math.cos(rad_pos) * point_distance)
 
         next_index = index + 1 < data_row.points.length ? index + 1 : 0
 
         next_rad_pos = next_index * Math::PI * 2 / column_count
         next_point_distance = data_row.points[next_index] * @radius
-        end_x = @center_x + Math.sin(next_rad_pos) * next_point_distance
-        end_y = @center_y - Math.cos(next_rad_pos) * next_point_distance
+        end_x = @center_x + (Math.sin(next_rad_pos) * next_point_distance)
+        end_y = @center_y - (Math.cos(next_rad_pos) * next_point_distance)
 
-        Gruff::Renderer::Line.new(color: data_row.color, width: @stroke_width).render(start_x, start_y, end_x, end_y)
+        Gruff::Renderer::Line.new(renderer, color: data_row.color, width: @stroke_width).render(start_x, start_y, end_x, end_y)
 
         unless @hide_dots
-          circle_renderer = Gruff::Renderer::Circle.new(color: data_row.color, width: @stroke_width)
+          circle_renderer = Gruff::Renderer::Circle.new(renderer, color: data_row.color, width: @stroke_width)
           circle_renderer.render(start_x, start_y, start_x - @circle_radius, start_y)
         end
       end
     end
   end
 
-private
-
   def setup_drawing
     super
 
@@ -92,8 +88,8 @@ private
     (0..column_count - 1).each do |index|
       rad_pos = index * Math::PI * 2 / column_count
 
-      Gruff::Renderer::Line.new(color: @marker_color)
-                           .render(@center_x, @center_y, @center_x + Math.sin(rad_pos) * @radius, @center_y - Math.cos(rad_pos) * @radius)
+      Gruff::Renderer::Line.new(renderer, color: @marker_color)
+                           .render(@center_x, @center_y, @center_x + (Math.sin(rad_pos) * @radius), @center_y - (Math.cos(rad_pos) * @radius))
 
       marker_label = @labels[index] ? @labels[index].to_s : '000'
       draw_label(@center_x, @center_y, rad_pos * 360 / (2 * Math::PI), @radius + @circle_radius, marker_label)
@@ -103,11 +99,9 @@ private
   def draw_label(center_x, center_y, angle, radius, amount)
     x_offset = center_x # + 15 # The label points need to be tweaked slightly
     y_offset = center_y # + 0  # This one doesn't though
-    x = x_offset + (radius + LABEL_MARGIN) * Math.sin(deg2rad(angle))
-    y = y_offset - (radius + LABEL_MARGIN) * Math.cos(deg2rad(angle))
+    x = x_offset + ((radius + LABEL_MARGIN) * Math.sin(deg2rad(angle)))
+    y = y_offset - ((radius + LABEL_MARGIN) * Math.cos(deg2rad(angle)))
 
-    # Draw label
-    text_renderer = Gruff::Renderer::Text.new(amount, font: @font, size: 20, color: @marker_color, weight: Magick::BoldWeight)
-    text_renderer.add_to_render_queue(0, 0, x, y, Magick::CenterGravity)
+    draw_label_at(1.0, 1.0, x, y, amount, Magick::CenterGravity)
   end
 end

data/lib/gruff/patch/rmagick.rb

@@ -23,7 +23,6 @@ module Magick
         def fill=(fill)
           fill = { white: '#FFFFFF' }[fill.to_sym] || fill
           @draw.fill = Magick4J.ColorDatabase.query_default(fill)
-          self
         end
       end
     end

data/lib/gruff/patch/string.rb

@@ -3,9 +3,10 @@
 # @private
 module String::GruffCommify
   THOUSAND_SEPARATOR = ','
+  private_constant :THOUSAND_SEPARATOR
 
   refine String do
-    #Taken from http://codesnippets.joyent.com/posts/show/330
+    # Taken from http://codesnippets.joyent.com/posts/show/330
     def commify(delimiter = THOUSAND_SEPARATOR)
       gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
     end