gruff 0.13.0-java → 0.16.0-java

data/lib/gruff/renderer/text.rb

@@ -5,12 +5,10 @@ module Gruff
   class Renderer::Text
     using Magick::GruffAnnotate
 
-    def initialize(text, font:, size:, color:, weight: Magick::NormalWeight, rotation: nil)
+    def initialize(renderer, text, font:, rotation: nil)
+      @renderer = renderer
       @text = text.to_s
       @font = font
-      @font_size = size
-      @font_color = color
-      @font_weight = weight
       @rotation = rotation
     end
 
@@ -23,50 +21,36 @@ module Gruff
       @y = y
       @gravity = gravity
 
-      Renderer.instance.text_renderers << self
+      @renderer.text_renderers << self
     end
 
     def render(width, height, x, y, gravity = Magick::NorthGravity)
-      draw  = Renderer.instance.draw
-      image = Renderer.instance.image
-      scale = Renderer.instance.scale
-
-      draw.rotation = @rotation if @rotation
-      draw.fill = @font_color
-      draw.stroke = 'transparent'
-      draw.font = @font || Renderer::Text.default_font(@font_weight)
-      draw.font_weight = @font_weight
-      draw.pointsize = @font_size * scale
-      draw.gravity = gravity
-      draw.annotate_scaled(image,
-                           width, height,
-                           x, y,
-                           @text, scale)
-      draw.rotation = -@rotation if @rotation
+      @renderer.draw.rotation = @rotation if @rotation
+      @renderer.draw.fill = @font.color
+      @renderer.draw.stroke = 'transparent'
+      @renderer.draw.font = @font.file_path
+      @renderer.draw.font_weight = @font.weight
+      @renderer.draw.pointsize = @font.size * @renderer.scale
+      @renderer.draw.gravity = gravity
+      @renderer.draw.annotate_scaled(@renderer.image,
+                                     width, height,
+                                     x, y,
+                                     @text, @renderer.scale)
+      @renderer.draw.rotation = -@rotation if @rotation
     end
 
-    def self.metrics(text, font, size, font_weight = Magick::NormalWeight)
-      draw  = Renderer.instance.draw
-      image = Renderer.instance.image
-
-      draw.font = font || Renderer::Text.default_font(font_weight)
-      draw.font_weight = font_weight
-      draw.pointsize = size
+    def metrics
+      @renderer.draw.font = @font.file_path
+      @renderer.draw.font_weight = @font.weight
+      @renderer.draw.pointsize = @font.size
 
       # The old ImageMagick causes SEGV with string which has '%' + alphabet (eg. '%S').
       # This format is used to embed value into a string using image properties.
       # However, gruff use plain image as canvas which does not have any property.
       # So, in here, it just escape % in order to avoid SEGV.
-      text = text.to_s.gsub(/(%+)/) { ('%' * Regexp.last_match(1).size * 2).to_s }
-
-      draw.get_type_metrics(image, text)
-    end
-
-    FONT_BOLD = File.expand_path(File.join(__FILE__, '../../../../assets/fonts/Roboto-Bold.ttf'))
-    FONT_REGULAR = File.expand_path(File.join(__FILE__, '../../../../assets/fonts/Roboto-Regular.ttf'))
+      text = @text.to_s.gsub(/(%+)/) { ('%' * Regexp.last_match(1).size * 2).to_s }
 
-    def self.default_font(font_weight)
-      (font_weight == Magick::BoldWeight) ? FONT_BOLD : FONT_REGULAR
+      @renderer.draw.get_type_metrics(@renderer.image, text)
     end
   end
 end

data/lib/gruff/scatter.rb

@@ -35,27 +35,6 @@ class Gruff::Scatter < Gruff::Base
   attr_writer :x_label_margin
   attr_writer :use_vertical_x_labels
 
-  def initialize_store
-    @store = Gruff::Store.new(Gruff::Store::XYData)
-  end
-  private :initialize_store
-
-  def initialize_ivars
-    super
-
-    @baseline_x_color = @baseline_y_color = 'red'
-    @baseline_x_value = @baseline_y_value = nil
-    @circle_radius = nil
-    @disable_significant_rounding_x_axis = false
-    @show_vertical_markers = false
-    @marker_x_count = nil
-    @maximum_x_value = @minimum_x_value = nil
-    @stroke_width = nil
-    @use_vertical_x_labels = false
-    @x_label_margin = nil
-  end
-  private :initialize_ivars
-
   # Allow enabling vertical lines. When you have a lot of data, they can work great.
   # @deprecated Please use +show_vertical_markers+ attribute instead.
   def enable_vertical_line_markers=(value)
@@ -63,28 +42,6 @@ class Gruff::Scatter < Gruff::Base
     @show_vertical_markers = value
   end
 
-  def draw
-    super
-    return unless data_given?
-
-    # Check to see if more than one datapoint was given. NaN can result otherwise.
-    @x_increment = (@x_spread > 1) ? (@graph_width / (@x_spread - 1).to_f) : @graph_width
-
-    store.norm_data.each do |data_row|
-      data_row.coordinates.each do |x_value, y_value|
-        next if y_value.nil? || x_value.nil?
-
-        new_x = get_x_coord(x_value, @graph_width, @graph_left)
-        new_y = @graph_top + (@graph_height - y_value * @graph_height)
-
-        # Reset each time to avoid thin-line errors
-        stroke_width  = @stroke_width  || clip_value_if_greater_than(@columns / (store.norm_data.first[1].size * 4), 5.0)
-        circle_radius = @circle_radius || clip_value_if_greater_than(@columns / (store.norm_data.first[1].size * 2.5), 5.0)
-        Gruff::Renderer::Circle.new(color: data_row.color, width: stroke_width).render(new_x, new_y, new_x - circle_radius, new_y)
-      end
-    end
-  end
-
   # The first parameter is the name of the dataset.  The next two are the
   # x and y axis data points contain in their own array in that respective
   # order.  The final parameter is the color.
@@ -138,22 +95,59 @@ class Gruff::Scatter < Gruff::Base
 
 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
+  def initialize_store
+    @store = Gruff::Store.new(Gruff::Store::XYData)
+  end
 
+  def initialize_attributes
     super
+
+    @baseline_x_color = @baseline_y_color = 'red'
+    @baseline_x_value = @baseline_y_value = nil
+    @circle_radius = nil
+    @disable_significant_rounding_x_axis = false
+    @show_vertical_markers = false
+    @marker_x_count = nil
+    @maximum_x_value = @minimum_x_value = nil
+    @stroke_width = nil
+    @use_vertical_x_labels = false
+    @x_label_margin = nil
+  end
+
+  def draw_graph
+    store.norm_data.each do |data_row|
+      data_row.coordinates.each do |x_value, y_value|
+        next if y_value.nil? || x_value.nil?
+
+        new_x = get_x_coord(x_value, @graph_width, @graph_left)
+        new_y = @graph_top + (@graph_height - (y_value * @graph_height))
+
+        # Reset each time to avoid thin-line errors
+        stroke_width  = @stroke_width  || clip_value_if_greater_than(@columns / (store.norm_data.first[1].size * 4), 5.0)
+        circle_radius = @circle_radius || clip_value_if_greater_than(@columns / (store.norm_data.first[1].size * 2.5), 5.0)
+        Gruff::Renderer::Circle.new(renderer, color: data_row.color, width: stroke_width).render(new_x, new_y, new_x - circle_radius, new_y)
+      end
+    end
   end
 
-  def setup_drawing
+  def setup_data
     # TODO: Need to get x-axis labels working. Current behavior will be to not allow.
     @labels = {}
 
+    # Update the global min/max values for the x data
+    @maximum_x_value = (@maximum_x_value || store.max_x).to_f
+    @minimum_x_value = (@minimum_x_value || store.min_x).to_f
+
+    if @x_axis_increment
+      # TODO: Make this work for negative values
+      @maximum_x_value = [@maximum_x_value.ceil, @x_axis_increment.to_f].max
+      @minimum_x_value = @minimum_x_value.floor
+    end
+
     super
   end
 
-  def calculate_spread #:nodoc:
+  def calculate_spread
     super
     @x_spread = @maximum_x_value.to_f - @minimum_x_value.to_f
     @x_spread = @x_spread > 0 ? @x_spread : 1
@@ -170,57 +164,64 @@ private
     super
     return if @hide_line_markers
 
-    if @x_axis_increment.nil?
-      # TODO: Do the same for larger numbers...100, 75, 50, 25
-      if @marker_x_count.nil?
-        (3..7).each do |lines|
-          if @x_spread % lines == 0.0
-            @marker_x_count = lines
-            break
-          end
-        end
-        @marker_x_count ||= 4
-      end
-      @x_increment = (@x_spread > 0) ? (@x_spread / @marker_x_count) : 1
-      unless @disable_significant_rounding_x_axis
-        @x_increment = significant(@x_increment)
-      end
-    else
-      # TODO: Make this work for negative values
-      @maximum_x_value = [maximum_value.ceil, @x_axis_increment].max
-      @minimum_x_value = @minimum_x_value.floor
-      calculate_spread
-      normalize
-
-      @marker_x_count = (@x_spread / @x_axis_increment).to_i
-      @x_increment = @x_axis_increment
-    end
-    increment_x_scaled = @graph_width.to_f / (@x_spread / @x_increment)
+    increment_x_scaled = @graph_width / (@x_spread / x_increment)
 
     # Draw vertical line markers and annotate with numbers
-    (0..@marker_x_count).each do |index|
+    (0..marker_x_count).each do |index|
       # TODO: Fix the vertical lines, and enable them by default. Not pretty when they don't match up with top y-axis line
       if @show_vertical_markers
-        x = @graph_left + @graph_width - index.to_f * increment_x_scaled
+        x = @graph_left + @graph_width - (index * increment_x_scaled)
 
-        line_renderer = Gruff::Renderer::Line.new(color: @marker_color, shadow_color: @marker_shadow_color)
-        line_renderer.render(x, @graph_top, x, @graph_bottom)
+        Gruff::Renderer::Line.new(renderer, color: @marker_color).render(x, @graph_top, x, @graph_bottom)
+        Gruff::Renderer::Line.new(renderer, color: @marker_shadow_color).render(x, @graph_top + 1, x, @graph_bottom + 1) if @marker_shadow_color
       end
 
       unless @hide_line_numbers
-        marker_label = BigDecimal(index.to_s) * BigDecimal(@x_increment.to_s) + BigDecimal(@minimum_x_value.to_s)
+        marker_label = (BigDecimal(index.to_s) * BigDecimal(x_increment.to_s)) + BigDecimal(@minimum_x_value.to_s)
         y_offset = @graph_bottom + (@x_label_margin || LABEL_MARGIN)
-        x_offset = get_x_coord(index.to_f, increment_x_scaled, @graph_left)
+        x_offset = get_x_coord(index, increment_x_scaled, @graph_left)
 
-        label = x_axis_label(marker_label, @x_increment)
+        label = x_axis_label(marker_label, x_increment)
         rotation = -90.0 if @use_vertical_x_labels
-        text_renderer = Gruff::Renderer::Text.new(label, font: @font, size: @marker_font_size, color: @font_color, rotation: rotation)
+        text_renderer = Gruff::Renderer::Text.new(renderer, label, font: @marker_font, rotation: rotation)
         text_renderer.add_to_render_queue(1.0, 1.0, x_offset, y_offset)
       end
     end
   end
 
-  def get_x_coord(x_data_point, width, offset) #:nodoc:
-    x_data_point * width + offset
+  def get_x_coord(x_data_point, width, offset)
+    (x_data_point * width) + offset
+  end
+
+  def marker_x_count
+    # TODO: Do the same for larger numbers...100, 75, 50, 25
+    @marker_x_count ||= begin
+      if @x_axis_increment.nil?
+        count = nil
+        (3..7).each do |lines|
+          if @x_spread % lines == 0.0
+            count = lines and break
+          end
+        end
+        count || 4
+      else
+        (@x_spread / @x_axis_increment).to_i
+      end
+    end
+  end
+
+  def x_increment
+    @x_increment ||= begin
+      if @x_axis_increment.nil?
+        increment = @x_spread > 0 ? (@x_spread / marker_x_count) : 1
+        unless @disable_significant_rounding_x_axis
+          increment = significant(increment)
+        end
+      else
+        increment = @x_axis_increment
+      end
+
+      increment
+    end
   end
 end

data/lib/gruff/side_bar.rb

@@ -36,23 +36,13 @@ class Gruff::SideBar < Gruff::Base
   # Prevent drawing of column labels left of a side bar graph.  Default is +false+.
   attr_writer :hide_labels
 
-  def initialize_ivars
-    super
-    @bar_spacing = 0.9
-    @group_spacing = 10
-    @label_formatting = nil
-    @show_labels_for_bar_values = false
-    @hide_labels = false
-  end
-  private :initialize_ivars
+  # Value to avoid completely overwriting the coordinate axis
+  AXIS_MARGIN = 0.5
+  private_constant :AXIS_MARGIN
 
-  def draw
-    @has_left_labels = true
+  def initialize(*)
     super
-
-    return unless data_given?
-
-    draw_bars
+    @has_left_labels = true
   end
 
   # With Side Bars use the data label for the marker value to the left of the bar.
@@ -61,29 +51,55 @@ class Gruff::SideBar < Gruff::Base
     warn '#use_data_label is deprecated. It is no longer effective.'
   end
 
-protected
+private
+
+  def initialize_attributes
+    super
+    @bar_spacing = 0.9
+    @group_spacing = 10
+    @label_formatting = nil
+    @show_labels_for_bar_values = false
+    @hide_labels = false
+  end
 
   def hide_labels?
     @hide_labels
   end
 
   def hide_left_label_area?
-    hide_labels?
+    hide_labels? && @y_axis_label.nil?
   end
 
   def hide_bottom_label_area?
-    @hide_line_markers
+    @hide_line_markers && @x_axis_label.nil? && @legend_at_bottom == false
   end
 
-private
+  def setup_graph_measurements
+    super
+    return if @hide_line_markers
 
-  # Value to avoid completely overwriting the coordinate axis
-  AXIS_MARGIN = 0.5
+    if @show_labels_for_bar_values
+      proc_text_metrics = ->(text) { text_metrics(@marker_font, text) }
+
+      if maximum_value >= 0
+        _, metrics = Gruff::BarValueLabel.metrics(maximum_value, @label_formatting, proc_text_metrics)
+        @graph_right -= metrics.width
+      end
+
+      if minimum_value < 0
+        _, metrics = Gruff::BarValueLabel.metrics(minimum_value, @label_formatting, proc_text_metrics)
+        width = metrics.width + LABEL_MARGIN
+        @graph_left += width - @graph_left if width > @graph_left
+      end
+
+      @graph_width = @graph_right - @graph_left
+    end
+  end
 
-  def draw_bars
+  def draw_graph
     # Setup spacing.
     #
-    bars_width = (@graph_height - calculate_spacing) / column_count.to_f
+    bars_width = (@graph_height - calculate_spacing) / column_count
     bar_width = bars_width / store.length
     padding = (bar_width * (1 - @bar_spacing)) / 2
 
@@ -93,32 +109,29 @@ private
       minimum_value: minimum_value, maximum_value: maximum_value, spread: @spread
     )
 
-    # if we're a side stacked bar then we don't need to draw ourself at all
-    # because sometimes (due to different heights/min/max) you can actually
-    # see both graphs and it looks like crap
-    return if is_a?(Gruff::SideStackedBar)
+    proc_text_metrics = ->(text) { text_metrics(@marker_font, text) }
 
     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
 
         left_y = @graph_top + (bars_width * point_index) + (bar_width * row_index) + padding + group_spacing
-        right_y = left_y + bar_width * @bar_spacing
+        right_y = left_y + (bar_width * @bar_spacing)
 
         left_x, right_x = conversion.get_top_bottom_scaled(data_point).sort
 
-        rect_renderer = Gruff::Renderer::Rectangle.new(color: data_row.color)
+        rect_renderer = Gruff::Renderer::Rectangle.new(renderer, color: data_row.color)
         rect_renderer.render(left_x + AXIS_MARGIN, left_y, right_x + AXIS_MARGIN, right_y)
 
         # Calculate center based on bar_width and current row
-        label_center = left_y + bars_width / 2
+        label_center = left_y + (bars_width / 2.0)
 
         # Subtract half a bar width to center left if requested
         draw_label(label_center, point_index)
         if @show_labels_for_bar_values
           bar_value_label = Gruff::BarValueLabel::SideBar.new([left_x, left_y, right_x, right_y], store.data[row_index].points[point_index])
-          bar_value_label.prepare_rendering(@label_formatting, bar_width) do |x, y, text|
-            draw_value_label(x, y, text, true)
+          bar_value_label.prepare_rendering(@label_formatting, proc_text_metrics) do |x, y, text, text_width, _text_height|
+            draw_value_label(text_width, bar_width * @bar_spacing, x, y, text)
           end
         end
       end
@@ -134,19 +147,19 @@ private
     number_of_lines = 1 if number_of_lines == 0
 
     # TODO: Round maximum marker value to a round number like 100, 0.1, 0.5, etc.
-    increment = significant(@spread.to_f / number_of_lines)
+    increment = significant(@spread / number_of_lines)
     (0..number_of_lines).each do |index|
       line_diff = (@graph_right - @graph_left) / number_of_lines
       x = @graph_right - (line_diff * index) - 1
 
-      line_renderer = Gruff::Renderer::Line.new(color: @marker_color, shadow_color: @marker_shadow_color)
-      line_renderer.render(x, @graph_bottom, x, @graph_top)
+      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, @graph_bottom + 1, x, @graph_top + 1) if @marker_shadow_color
 
       unless @hide_line_numbers
         diff = index - number_of_lines
-        marker_label = BigDecimal(diff.abs.to_s) * BigDecimal(increment.to_s) + BigDecimal(minimum_value.to_s)
+        marker_label = (BigDecimal(diff.abs.to_s) * BigDecimal(increment.to_s)) + BigDecimal(minimum_value.to_s)
         label = x_axis_label(marker_label, @increment)
-        text_renderer = Gruff::Renderer::Text.new(label, font: @font, size: @marker_font_size, color: @font_color)
+        text_renderer = Gruff::Renderer::Text.new(renderer, label, font: @marker_font)
         text_renderer.add_to_render_queue(0, 0, x, @graph_bottom + LABEL_MARGIN, Magick::CenterGravity)
       end
     end

data/lib/gruff/side_stacked_bar.rb

@@ -39,86 +39,77 @@ class Gruff::SideStackedBar < Gruff::SideBar
   # Prevent drawing of column labels left of a side stacked bar graph.  Default is +false+.
   attr_writer :hide_labels
 
-  def initialize_ivars
+  def initialize(*)
+    super
+    @has_left_labels = true
+  end
+
+private
+
+  def initialize_attributes
     super
     @bar_spacing = 0.9
     @segment_spacing = 2.0
     @label_formatting = nil
     @show_labels_for_bar_values = false
     @hide_labels = false
+    @minimum_value = 0.0
   end
-  private :initialize_ivars
 
-  def draw
-    @has_left_labels = true
+  def setup_data
     calculate_maximum_by_stack
     super
   end
 
-protected
-
-  def hide_labels?
-    @hide_labels
-  end
-
-  def hide_left_label_area?
-    hide_labels?
-  end
-
-  def hide_bottom_label_area?
-    @hide_line_markers
-  end
-
-private
-
-  def draw_bars
+  def draw_graph
     # Setup spacing.
     #
     # Columns sit stacked.
-    bar_width = @graph_height / column_count.to_f
+    bar_width = @graph_height / column_count
     height = Array.new(column_count, 0)
     length = Array.new(column_count, @graph_left)
     padding = (bar_width * (1 - @bar_spacing)) / 2
-    stack_bar_value_label = Gruff::BarValueLabel::StackedBar.new
+    stack_bar_value_labels = Gruff::BarValueLabel::StackedBar.new
 
     store.norm_data.each_with_index do |data_row, row_index|
       data_row.points.each_with_index do |data_point, point_index|
         ## using the original calculations from the stacked bar chart to get the difference between
         ## part of the bart chart we wish to stack.
-        temp1 = @graph_left + (@graph_width -
-                                  data_point * @graph_width -
-                                  height[point_index]) + 1
-        temp2 = @graph_left + @graph_width - height[point_index] - 1
+        temp1 = @graph_left + (@graph_width - (data_point * @graph_width) - height[point_index])
+        temp2 = @graph_left + @graph_width - height[point_index]
         difference = temp2 - temp1
+        difference = 0 if difference < 0
 
         left_x = length[point_index]
         left_y = @graph_top + (bar_width * point_index) + padding
-        right_x = left_x + difference - @segment_spacing
-        right_y = left_y + bar_width * @bar_spacing
+        right_x = left_x + difference
+        right_x -= @segment_spacing if row_index != store.columns - 1
+        right_y = left_y + (bar_width * @bar_spacing)
         length[point_index] += difference
-        height[point_index] += (data_point * @graph_width - 2)
+        height[point_index] += (data_point * @graph_width)
 
         bar_value_label = Gruff::BarValueLabel::SideBar.new([left_x, left_y, right_x, right_y], store.data[row_index].points[point_index])
-        stack_bar_value_label.add(bar_value_label, point_index)
+        stack_bar_value_labels.add(bar_value_label, point_index)
 
         # if a data point is 0 it can result in weird really thing lines
         # that shouldn't even be there being drawn on top of the existing
         # bar - this is bad
         if data_point != 0
-          rect_renderer = Gruff::Renderer::Rectangle.new(color: data_row.color)
+          rect_renderer = Gruff::Renderer::Rectangle.new(renderer, color: data_row.color)
           rect_renderer.render(left_x, left_y, right_x, right_y)
           # Calculate center based on bar_width and current row
         end
         # we still need to draw the labels
         # Calculate center based on bar_width and current row
-        label_center = left_y + bar_width / 2
+        label_center = left_y + (bar_width / 2.0)
         draw_label(label_center, point_index)
       end
     end
 
     if @show_labels_for_bar_values
-      stack_bar_value_label.prepare_rendering(@label_formatting, bar_width) do |x, y, text|
-        draw_value_label(x, y, text, true)
+      proc_text_metrics = ->(text) { text_metrics(@marker_font, text) }
+      stack_bar_value_labels.prepare_rendering(@label_formatting, proc_text_metrics) do |x, y, text, text_width, _text_height|
+        draw_value_label(text_width, bar_width * @bar_spacing, x, y, text)
       end
     end
   end