gruff 0.14.0-java → 0.17.0-java

data/lib/gruff/line.rb

@@ -25,7 +25,7 @@ class Gruff::Line < Gruff::Base
   attr_writer :line_width
   attr_writer :dot_radius
 
-  # default is +'circle'+, other options include square.
+  # default is +'circle'+, other options include +square+ and +diamond+.
   attr_writer :dot_style
 
   # Hide parts of the graph to fit more data points, or for a different appearance.
@@ -40,6 +40,23 @@ class Gruff::Line < Gruff::Base
   # 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).
+  #
+  #   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)
+  #
+  # 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? || (!args.first.is_a?(Numeric) && !args.first.is_a?(String))
+      super()
+    else
+      super args.shift
+    end
+  end
+
   # Get the value if somebody has defined it.
   def baseline_value
     if @reference_lines.key?(:baseline)
@@ -64,23 +81,6 @@ class Gruff::Line < Gruff::Base
     @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).
-  #
-  #   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)
-  #
-  # 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? || (!args.first.is_a?(Numeric) && !args.first.is_a?(String))
-      super()
-    else
-      super args.shift
-    end
-  end
-
   # This method allows one to plot a dataset with both X and Y data.
   #
   # @overload dataxy(name, x_data_points = [], y_data_points = [], color = nil)
@@ -118,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
@@ -163,7 +165,7 @@ private
   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
 
@@ -174,7 +176,7 @@ private
 
   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)
@@ -187,22 +189,22 @@ private
       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)
@@ -225,12 +227,12 @@ 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)
@@ -253,41 +255,40 @@ private
   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 sort_norm_data
-    super unless store.data.any?(&:x_points)
-  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|
-      if @show_vertical_markers
-        x = @graph_left + @graph_width - index * @graph_width / @marker_x_count
+      draw_marker_vertical_line(@graph_left + @graph_width - (index * @graph_width / @marker_x_count))
+    end
+  end
 
-        Gruff::Renderer::Line.new(renderer, 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(renderer, color: @marker_shadow_color).render(x + 1, @graph_bottom, x + 1, @graph_top)
-        end
+  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/legend.rb

@@ -21,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((store.length * calculate_line_height) + @top_margin + @bottom_margin)
 
         @original_rows = @raw_rows
         @original_columns = @raw_columns
@@ -32,7 +32,7 @@ module Gruff
           @columns += calculate_legend_width + @left_margin
         else
           font = @legend_font.dup
-          font.size = scale_fontsize(font.size)
+          font.size = scale(font.size)
           @rows += store.length * calculate_caps_height(font) * 1.7
         end
 
@@ -45,7 +45,7 @@ module Gruff
 
       def calculate_legend_width
         width = @legend_labels.map { |label| calculate_width(@legend_font, label) }.max
-        scale_fontsize(width + 40 * 1.7)
+        scale(width + (40 * 1.7))
       end
 
       ##
@@ -69,17 +69,17 @@ 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(renderer, label, font: @legend_font)
           x_offset = current_x_offset + (legend_square_width * 1.7)
+          label = truncate_legend_label(legend_label, x_offset)
+          text_renderer = Gruff::Renderer::Text.new(renderer, label, font: @legend_font)
           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(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,13 +90,13 @@ module Gruff
       #
       #   Department of Hu...
 
-      def truncate_legend_label(label)
+      def truncate_legend_label(label, x_offset)
         truncated_label = label.to_s
 
         font = @legend_font.dup
-        font.size = scale_fontsize(font.size)
-        max_width = @columns - @legend_left_margin - @right_margin
-        while calculate_width(font, truncated_label) > max_width && truncated_label.length > 1
+        font.size = scale(font.size)
+        max_width = @columns - scale(x_offset) - @right_margin
+        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/net.rb

@@ -43,6 +43,21 @@ private
     @marker_font.bold = true
   end
 
+  def setup_drawing
+    @center_labels_over_point = false
+    super
+  end
+
+  def setup_graph_measurements
+    super
+
+    @radius = @graph_height / 2.0
+    @circle_radius = @dot_radius || clip_value_if_greater_than(@columns / (store.norm_data.first.points.size * 2.5), 5.0)
+    @stroke_width  = @line_width || clip_value_if_greater_than(@columns / (store.norm_data.first.points.size * 4.0), 5.0)
+    @center_x = @graph_left + (@graph_width / 2.0)
+    @center_y = @graph_top + (@graph_height / 2.0) + 10
+  end
+
   def draw_graph
     store.norm_data.each do |data_row|
       data_row.points.each_with_index do |data_point, index|
@@ -50,15 +65,15 @@ private
 
         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(renderer, color: data_row.color, width: @stroke_width).render(start_x, start_y, end_x, end_y)
 
@@ -70,16 +85,6 @@ private
     end
   end
 
-  def setup_drawing
-    super
-
-    @radius = @graph_height / 2.0
-    @circle_radius = @dot_radius || clip_value_if_greater_than(@columns / (store.norm_data.first.points.size * 2.5), 5.0)
-    @stroke_width  = @line_width || clip_value_if_greater_than(@columns / (store.norm_data.first.points.size * 4), 5.0)
-    @center_x = @graph_left + (@graph_width / 2.0)
-    @center_y = @graph_top + (@graph_height / 2.0) + 10
-  end
-
   # the lines connecting in the center, with the first line vertical
   def draw_line_markers
     return if @hide_line_markers
@@ -89,7 +94,7 @@ private
       rad_pos = index * Math::PI * 2 / column_count
 
       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)
+                           .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)
@@ -99,9 +104,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_at(1.0, 1.0, x, y, amount, Magick::CenterGravity)
+    draw_label_at(1.0, 1.0, x, y, amount, gravity: 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,6 +3,7 @@
 # @private
 module String::GruffCommify
   THOUSAND_SEPARATOR = ','
+  private_constant :THOUSAND_SEPARATOR
 
   refine String do
     # Taken from http://codesnippets.joyent.com/posts/show/330

data/lib/gruff/pie.rb

@@ -9,14 +9,14 @@
 #   g.data 'Hamburgers', 50
 #   g.write("pie_keynote.png")
 #
-# To control where the pie chart starts creating slices, use {#zero_degree=}.
+# To control where the pie chart starts creating slices, use {#start_degree=}.
 #
 class Gruff::Pie < Gruff::Base
-  DEFAULT_TEXT_OFFSET_PERCENTAGE = 0.15
+  DEFAULT_TEXT_OFFSET_PERCENTAGE = 0.1
 
   # Can be used to make the pie start cutting slices at the top (-90.0)
-  # or at another angle. Default is +0.0+, which starts at 3 o'clock.
-  attr_writer :zero_degree
+  # or at another angle. Default is +-90.0+, which starts at 3 o'clock.
+  attr_writer :start_degree
 
   # Set the number output format lambda.
   attr_writer :label_formatting
@@ -26,25 +26,34 @@ class Gruff::Pie < Gruff::Base
   attr_writer :hide_labels_less_than
 
   # Affect the distance between the percentages and the pie chart.
-  # Defaults to +0.15+.
+  # Defaults to +0.1+.
   attr_writer :text_offset_percentage
 
   ## Use values instead of percentages.
   attr_writer :show_values_as_labels
 
-private
+  # Set to +true+ if you want the data sets sorted with largest avg values drawn
+  # first. Default is +true+.
+  attr_writer :sort
 
-  def initialize_store
-    @store = Gruff::Store.new(Gruff::Store::CustomData)
+  # Can be used to make the pie start cutting slices at the top (-90.0)
+  # or at another angle. Default is +-90.0+, which starts at 3 o'clock.
+  # @deprecated Please use +start_degree+ attribute instead.
+  def zero_degree=(value)
+    warn '#zero_degree= is deprecated. Please use `start_degree` attribute instead'
+    @start_degree = value
   end
 
+private
+
   def initialize_attributes
     super
-    @zero_degree = 0.0
+    @start_degree = -90.0
     @hide_labels_less_than = 0.0
     @text_offset_percentage = DEFAULT_TEXT_OFFSET_PERCENTAGE
     @show_values_as_labels = false
     @marker_font.bold = true
+    @sort = true
 
     @hide_line_markers = true
     @hide_line_markers.freeze
@@ -52,6 +61,11 @@ private
     @label_formatting = ->(value, percentage) { @show_values_as_labels ? value.to_s : "#{percentage}%" }
   end
 
+  def setup_drawing
+    @center_labels_over_point = false
+    super
+  end
+
   def draw_graph
     slices.each do |slice|
       if slice.value > 0
@@ -83,7 +97,7 @@ private
   # Spatial Value-Related Methods
 
   def chart_degrees
-    @chart_degrees ||= @zero_degree
+    @chart_degrees ||= @start_degree
   end
 
   attr_reader :graph_height
@@ -127,12 +141,12 @@ private
     if slice.percentage >= @hide_labels_less_than
       x, y = label_coordinates_for slice
       label = @label_formatting.call(slice.value, slice.percentage)
-      draw_label_at(1.0, 1.0, x, y, label, Magick::CenterGravity)
+      draw_label_at(1.0, 1.0, x, y, label, gravity: Magick::CenterGravity)
     end
   end
 
   def label_coordinates_for(slice)
-    angle = chart_degrees + slice.degrees / 2
+    angle = chart_degrees + (slice.degrees / 2.0)
 
     [x_label_coordinate(angle), y_label_coordinate(angle)]
   end

data/lib/gruff/renderer/dash_line.rb

@@ -3,17 +3,18 @@
 module Gruff
   # @private
   class Renderer::DashLine
-    def initialize(renderer, color:, width:)
+    def initialize(renderer, color:, width:, dasharray: [10, 20])
       @renderer = renderer
       @color = color
       @width = width
+      @dasharray = dasharray
     end
 
     def render(start_x, start_y, end_x, end_y)
       @renderer.draw.push
       @renderer.draw.stroke_color(@color)
       @renderer.draw.fill_opacity(0.0)
-      @renderer.draw.stroke_dasharray(10, 20)
+      @renderer.draw.stroke_dasharray(*@dasharray)
       @renderer.draw.stroke_width(@width)
       @renderer.draw.line(start_x, start_y, end_x, end_y)
       @renderer.draw.pop

data/lib/gruff/renderer/dot.rb

@@ -3,37 +3,50 @@
 module Gruff
   # @private
   class Renderer::Dot
-    def initialize(renderer, style, color:, width: 1.0)
+    def initialize(renderer, style, color:, width: 1.0, opacity: 1.0)
       @renderer = renderer
       @style = style
       @color = color
       @width = width
+      @opacity = opacity
     end
 
-    def render(new_x, new_y, circle_radius)
-      # @renderer.draw.push # TODO
+    def render(new_x, new_y, radius)
+      @renderer.draw.push
       @renderer.draw.stroke_width(@width)
       @renderer.draw.stroke(@color)
       @renderer.draw.fill(@color)
-      if @style.to_s == 'square'
-        square(new_x, new_y, circle_radius)
+      @renderer.draw.fill_opacity(@opacity)
+      case @style.to_sym
+      when :square
+        square(new_x, new_y, radius)
+      when :diamond
+        diamond(new_x, new_y, radius)
       else
-        circle(new_x, new_y, circle_radius)
+        circle(new_x, new_y, radius)
       end
-      # @renderer.draw.pop # TODO
+      @renderer.draw.pop
     end
 
-    def circle(new_x, new_y, circle_radius)
-      @renderer.draw.circle(new_x, new_y, new_x - circle_radius, new_y)
+    def circle(new_x, new_y, radius)
+      @renderer.draw.circle(new_x, new_y, new_x - radius, new_y)
     end
 
-    def square(new_x, new_y, circle_radius)
-      offset = (circle_radius * 0.8).to_i
-      corner1 = new_x - offset
-      corner2 = new_y - offset
-      corner3 = new_x + offset
-      corner4 = new_y + offset
+    def square(new_x, new_y, radius)
+      corner1 = new_x - radius
+      corner2 = new_y - radius
+      corner3 = new_x + radius
+      corner4 = new_y + radius
       @renderer.draw.rectangle(corner1, corner2, corner3, corner4)
     end
+
+    def diamond(new_x, new_y, radius)
+      polygon = []
+      polygon += [new_x - radius, new_y]
+      polygon += [new_x, new_y + radius]
+      polygon += [new_x + radius, new_y]
+      polygon += [new_x, new_y - radius]
+      @renderer.draw.polygon(*polygon)
+    end
   end
 end

data/lib/gruff/renderer/line.rb

@@ -5,16 +5,14 @@ module Gruff
   class Renderer::Line
     EPSILON = 0.001
 
-    def initialize(renderer, color:, width: nil, shadow_color: nil)
+    def initialize(renderer, color:, width: nil)
       @renderer = renderer
       @color = color
       @width = width
-      @shadow_color = shadow_color
     end
 
     def render(start_x, start_y, end_x, end_y)
       render_line(start_x, start_y, end_x, end_y, @color)
-      render_line(start_x, start_y + 1, end_x, end_y + 1, @shadow_color) if @shadow_color
     end
 
   private

data/lib/gruff/renderer/rectangle.rb

@@ -3,14 +3,18 @@
 module Gruff
   # @private
   class Renderer::Rectangle
-    def initialize(renderer, color: nil)
+    def initialize(renderer, color: nil, width: 1.0, opacity: 1.0)
       @renderer = renderer
       @color = color
+      @width = width
+      @opacity = opacity
     end
 
     def render(upper_left_x, upper_left_y, lower_right_x, lower_right_y)
       @renderer.draw.push
-      @renderer.draw.stroke('transparent')
+      @renderer.draw.stroke_width(@width)
+      @renderer.draw.stroke(@color) if @width > 1.0
+      @renderer.draw.fill_opacity(@opacity)
       @renderer.draw.fill(@color) if @color
       @renderer.draw.rectangle(upper_left_x, upper_left_y, lower_right_x, lower_right_y)
       @renderer.draw.pop

data/lib/gruff/renderer/renderer.rb

@@ -23,10 +23,6 @@ module Gruff
       end
     end
 
-    def background_image=(image)
-      @image = image
-    end
-
     def background(columns, rows, scale, theme_options)
       case theme_options[:background_colors]
       when Array
@@ -44,8 +40,8 @@ module Gruff
 
     # Make a new image at the current size with a solid +color+.
     def solid_background(columns, rows, color)
-      Magick::Image.new(columns, rows) do
-        self.background_color = color
+      Magick::Image.new(columns, rows) do |img|
+        img.background_color = color
       end
     end
 
@@ -97,8 +93,8 @@ module Gruff
 
     # Use with a theme to make a transparent background
     def render_transparent_background(columns, rows)
-      Magick::Image.new(columns, rows) do
-        self.background_color = 'transparent'
+      Magick::Image.new(columns, rows) do |img|
+        img.background_color = 'transparent'
       end
     end
   end

data/lib/gruff/renderer/text.rb

@@ -25,6 +25,7 @@ module Gruff
     end
 
     def render(width, height, x, y, gravity = Magick::NorthGravity)
+      @renderer.draw.push
       @renderer.draw.rotation = @rotation if @rotation
       @renderer.draw.fill = @font.color
       @renderer.draw.stroke = 'transparent'
@@ -37,9 +38,11 @@ module Gruff
                                      x, y,
                                      @text, @renderer.scale)
       @renderer.draw.rotation = -@rotation if @rotation
+      @renderer.draw.pop
     end
 
     def metrics
+      @renderer.draw.push
       @renderer.draw.font = @font.file_path
       @renderer.draw.font_weight = @font.weight
       @renderer.draw.pointsize = @font.size
@@ -50,7 +53,10 @@ module Gruff
       # So, in here, it just escape % in order to avoid SEGV.
       text = @text.to_s.gsub(/(%+)/) { ('%' * Regexp.last_match(1).size * 2).to_s }
 
-      @renderer.draw.get_type_metrics(@renderer.image, text)
+      metrics = @renderer.draw.get_type_metrics(@renderer.image, text)
+      @renderer.draw.pop
+
+      metrics
     end
   end
 end