gruff 0.15.0-java → 0.18.0-java

data/lib/gruff/helper/stacked_mixin.rb

@@ -16,7 +16,25 @@ module Gruff::Base::StackedMixin
 
     max_hash.each_key do |key|
       self.maximum_value = max_hash[key] if max_hash[key] > maximum_value
+      self.minimum_value = max_hash[key] if max_hash[key] < minimum_value
     end
-    self.minimum_value = 0
+
+    raise "Can't handle negative values in stacked graph" if minimum_value < 0
+  end
+
+  def normalized_stacked_bars
+    @normalized_stacked_bars ||= begin
+      stacked_bars = Array.new(column_count) { [] }
+      store.norm_data.each_with_index do |data_row, row_index|
+        data_row.points.each_with_index do |data_point, point_index|
+          stacked_bars[point_index] << BarData.new(data_point, store.data[row_index].points[point_index], data_row.color)
+        end
+      end
+      stacked_bars
+    end
+  end
+
+  # @private
+  class BarData < Struct.new(:point, :value, :color)
   end
 end

data/lib/gruff/histogram.rb

@@ -29,7 +29,7 @@ class Gruff::Histogram < Gruff::Bar
   end
 
   def data(name, data_points = [], color = nil)
-    @data << [name, data_points, color]
+    @data << [name, Array(data_points), color]
   end
 
 private
@@ -40,15 +40,18 @@ private
     @minimum_bin = nil
     @maximum_bin = nil
   end
-  private :initialize_attributes
 
   def setup_data
     @data.each do |(name, data_points, color)|
-      bins, freqs = HistogramArray.new(data_points).histogram(bin_width: @bin_width, min: @minimum_bin, max: @maximum_bin)
-      bins.each_with_index do |bin, index|
-        @labels[index] = bin
+      if data_points.empty?
+        store.add(name, [], color)
+      else
+        bins, freqs = HistogramArray.new(data_points).histogram(bin_width: @bin_width, min: @minimum_bin, max: @maximum_bin)
+        bins.each_with_index do |bin, index|
+          @labels[index] = bin
+        end
+        store.add(name, freqs, color)
       end
-      store.add(name, freqs, color)
     end
 
     super

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,21 +81,28 @@ 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).
+  # Input the data in the graph.
   #
-  #   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)
+  # Parameters are an array where the first element is the name of the dataset
+  # and the value is an array of values to plot.
   #
-  # 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
+  # Can be called multiple times with different datasets for a multi-valued
+  # graph.
+  #
+  # If the color argument is nil, the next color from the default theme will
+  # be used.
+  #
+  # @param name [String, Symbol] The name of the dataset.
+  # @param data_points [Array] The array of dataset.
+  # @param color [String] The color for drawing graph of dataset.
+  #
+  # @note
+  #   If you want to use a preset theme, you must set it before calling {#data}.
+  #
+  # @example
+  #   data("Bart S.", [95, 45, 78, 89, 88, 76], '#ffcc00')
+  def data(name, data_points = [], color = nil)
+    store.add(name, nil, data_points, color)
   end
 
   # This method allows one to plot a dataset with both X and Y data.
@@ -131,7 +155,7 @@ class Gruff::Line < Gruff::Base
     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 x/y data.
-    store.add(name, y_data_points, color, x_data_points)
+    store.add(name, x_data_points, y_data_points, color)
   end
 
 private
@@ -165,7 +189,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
 
@@ -176,7 +200,8 @@ 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
+    @x_increment = @x_increment.to_f
 
     @reference_lines.each_value do |curr_reference_line|
       draw_horizontal_reference_line(curr_reference_line) if curr_reference_line.key?(:norm_value)
@@ -189,22 +214,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
+            @graph_left + (x_data * @graph_width)
           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)
@@ -227,12 +252,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)
@@ -255,14 +280,14 @@ 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
 
@@ -270,22 +295,21 @@ private
     # 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
-
-        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
-      end
+      draw_marker_vertical_line(@graph_left + @graph_width - (index * @graph_width / @marker_x_count))
     end
   end
 
-  def get_x_coord(x_data_point, width, offset)
-    x_data_point * width + offset
+  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 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,17 +90,21 @@ 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 ? '...' : '')
       end
+
+      def scale(value)
+        value * @scale
+      end
     end
   end
 end

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/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=} 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/circle.rb

@@ -3,15 +3,17 @@
 module Gruff
   # @private
   class Renderer::Circle
-    def initialize(renderer, color:, width: 1.0)
+    def initialize(renderer, color:, width: 1.0, opacity: 1.0)
       @renderer = renderer
       @color = color
       @width = width
+      @opacity = opacity
     end
 
     def render(origin_x, origin_y, perim_x, perim_y)
       @renderer.draw.push
       @renderer.draw.fill(@color)
+      @renderer.draw.fill_opacity(@opacity)
       @renderer.draw.stroke(@color)
       @renderer.draw.stroke_width(@width)
       @renderer.draw.circle(origin_x, origin_y, perim_x, perim_y)

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