gruff 0.13.0-java → 0.16.0-java

data/lib/gruff/pie.rb

@@ -9,59 +9,62 @@
 #   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
 
   # Do not show labels for slices that are less than this percent. Use 0 to always show all labels.
   # Defaults to +0+.
   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
 
-  def initialize_store
-    @store = Gruff::Store.new(Gruff::Store::CustomData)
+  # Set to +true+ if you want the data sets sorted with largest avg values drawn
+  # first. Default is +true+.
+  attr_writer :sort
+
+  # 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 :initialize_store
 
-  def initialize_ivars
+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
-  end
-  private :initialize_ivars
-
-  def options
-    {
-      zero_degree: @zero_degree,
-      hide_labels_less_than: @hide_labels_less_than,
-      text_offset_percentage: @text_offset_percentage,
-      show_values_as_labels: @show_values_as_labels
-    }
-  end
+    @marker_font.bold = true
+    @sort = true
 
-  def draw
-    hide_line_markers
-
-    super
+    @hide_line_markers = true
+    @hide_line_markers.freeze
 
-    return unless data_given?
+    @label_formatting = ->(value, percentage) { @show_values_as_labels ? value.to_s : "#{percentage}%" }
+  end
 
+  def draw_graph
     slices.each do |slice|
       if slice.value > 0
-        Gruff::Renderer::Ellipse.new(color: slice.color, width: radius)
+        Gruff::Renderer::Ellipse.new(renderer, color: slice.color, width: radius)
                                 .render(center_x, center_y, radius / 2.0, radius / 2.0, chart_degrees, chart_degrees + slice.degrees + 0.5)
         process_label_for slice
         update_chart_degrees_with slice.degrees
@@ -69,11 +72,9 @@ class Gruff::Pie < Gruff::Base
     end
   end
 
-private
-
   def slices
     @slices ||= begin
-      slices = store.data.map { |data| slice_class.new(data, options) }
+      slices = store.data.map { |data| Gruff::Pie::PieSlice.new(data.label, data.points.first, data.color) }
 
       slices.sort_by(&:value) if @sort
 
@@ -84,32 +85,19 @@ private
 
   # General Helper Methods
 
-  def hide_line_markers
-    @hide_line_markers = true
-  end
-
   def update_chart_degrees_with(degrees)
     @chart_degrees = chart_degrees + degrees
   end
 
-  def slice_class
-    PieSlice
-  end
-
   # Spatial Value-Related Methods
 
   def chart_degrees
-    @chart_degrees ||= @zero_degree
+    @chart_degrees ||= @start_degree
   end
 
   attr_reader :graph_height
-
   attr_reader :graph_width
 
-  def diameter
-    graph_height
-  end
-
   def half_width
     graph_width / 2.0
   end
@@ -147,13 +135,13 @@ private
   def process_label_for(slice)
     if slice.percentage >= @hide_labels_less_than
       x, y = label_coordinates_for slice
-
-      draw_label(x, y, slice.label)
+      label = @label_formatting.call(slice.value, slice.percentage)
+      draw_label_at(1.0, 1.0, x, y, label, 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
@@ -166,45 +154,24 @@ private
     center_y + (radius_offset * Math.sin(deg2rad(angle)))
   end
 
-  # Drawing-Related Methods
-
-  def draw_label(x, y, value)
-    text_renderer = Gruff::Renderer::Text.new(value, font: @font, size: @marker_font_size, color: @font_color, weight: Magick::BoldWeight)
-    text_renderer.add_to_render_queue(0, 0, x, y, Magick::CenterGravity)
-  end
-
   # Helper Classes
   #
   # @private
-  class PieSlice < Struct.new(:data_array, :options)
+  class PieSlice < Struct.new(:label, :value, :color)
     attr_accessor :total
 
-    def name
-      data_array[0]
-    end
-
-    def value
-      data_array[1].first
-    end
-
-    def color
-      data_array[2]
-    end
-
-    def size
-      @size ||= value / total
-    end
-
     def percentage
-      @percentage ||= (size * 100.0).round
+      (size * 100.0).round
     end
 
     def degrees
-      @degrees ||= size * 360.0
+      size * 360.0
     end
 
-    def label
-      options[:show_values_as_labels] ? value.to_s : "#{percentage}%"
+  private
+
+    def size
+      value / total
     end
   end
 end

data/lib/gruff/renderer/bezier.rb

@@ -3,20 +3,19 @@
 module Gruff
   # @private
   class Renderer::Bezier
-    def initialize(color:, width: 1.0)
+    def initialize(renderer, color:, width: 1.0)
+      @renderer = renderer
       @color = color
       @width = width
     end
 
     def render(points)
-      draw = Renderer.instance.draw
-
-      draw.push
-      draw.stroke(@color)
-      draw.stroke_width(@width)
-      draw.fill_opacity(0.0)
-      draw.bezier(*points)
-      draw.pop
+      @renderer.draw.push
+      @renderer.draw.stroke(@color)
+      @renderer.draw.stroke_width(@width)
+      @renderer.draw.fill_opacity(0.0)
+      @renderer.draw.bezier(*points)
+      @renderer.draw.pop
     end
   end
 end

data/lib/gruff/renderer/circle.rb

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

data/lib/gruff/renderer/dash_line.rb

@@ -3,21 +3,21 @@
 module Gruff
   # @private
   class Renderer::DashLine
-    def initialize(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)
-      draw = Renderer.instance.draw
-
-      draw.push
-      draw.stroke_color(@color)
-      draw.fill_opacity(0.0)
-      draw.stroke_dasharray(10, 20)
-      draw.stroke_width(@width)
-      draw.line(start_x, start_y, end_x, end_y)
-      draw.pop
+      @renderer.draw.push
+      @renderer.draw.stroke_color(@color)
+      @renderer.draw.fill_opacity(0.0)
+      @renderer.draw.stroke_dasharray(*@dasharray)
+      @renderer.draw.stroke_width(@width)
+      @renderer.draw.line(start_x, start_y, end_x, end_y)
+      @renderer.draw.pop
     end
   end
 end

data/lib/gruff/renderer/dot.rb

@@ -3,38 +3,39 @@
 module Gruff
   # @private
   class Renderer::Dot
-    def initialize(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)
-      draw = Renderer.instance.draw
-
-      # draw.push # TODO
-      draw.stroke_width(@width)
-      draw.stroke(@color)
-      draw.fill(@color)
+      # @renderer.draw.push # TODO
+      @renderer.draw.stroke_width(@width)
+      @renderer.draw.stroke(@color)
+      @renderer.draw.fill(@color)
+      @renderer.draw.fill_opacity(@opacity)
       if @style.to_s == 'square'
-        square(draw, new_x, new_y, circle_radius)
+        square(new_x, new_y, circle_radius)
       else
-        circle(draw, new_x, new_y, circle_radius)
+        circle(new_x, new_y, circle_radius)
       end
-      # draw.pop # TODO
+      # @renderer.draw.pop # TODO
     end
 
-    def circle(draw, new_x, new_y, circle_radius)
-      draw.circle(new_x, new_y, new_x - circle_radius, new_y)
+    def circle(new_x, new_y, circle_radius)
+      @renderer.draw.circle(new_x, new_y, new_x - circle_radius, new_y)
     end
 
-    def square(draw, new_x, new_y, circle_radius)
+    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
-      draw.rectangle(corner1, corner2, corner3, corner4)
+      @renderer.draw.rectangle(corner1, corner2, corner3, corner4)
     end
   end
 end

data/lib/gruff/renderer/ellipse.rb

@@ -3,20 +3,19 @@
 module Gruff
   # @private
   class Renderer::Ellipse
-    def initialize(color:, width: 1.0)
+    def initialize(renderer, color:, width: 1.0)
+      @renderer = renderer
       @color = color
       @width = width
     end
 
     def render(origin_x, origin_y, width, height, arc_start, arc_end)
-      draw = Renderer.instance.draw
-
-      draw.push
-      draw.stroke_width(@width)
-      draw.stroke(@color)
-      draw.fill('transparent')
-      draw.ellipse(origin_x, origin_y, width, height, arc_start, arc_end)
-      draw.pop
+      @renderer.draw.push
+      @renderer.draw.stroke_width(@width)
+      @renderer.draw.stroke(@color)
+      @renderer.draw.fill('transparent')
+      @renderer.draw.ellipse(origin_x, origin_y, width, height, arc_start, arc_end)
+      @renderer.draw.pop
     end
   end
 end

data/lib/gruff/renderer/line.rb

@@ -5,15 +5,14 @@ module Gruff
   class Renderer::Line
     EPSILON = 0.001
 
-    def initialize(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
@@ -30,14 +29,12 @@ module Gruff
         end_y += EPSILON
       end
 
-      draw = Renderer.instance.draw
-
-      draw.push
-      draw.stroke(color)
-      draw.fill(color)
-      draw.stroke_width(@width) if @width
-      draw.line(start_x, start_y, end_x, end_y)
-      draw.pop
+      @renderer.draw.push
+      @renderer.draw.stroke(color)
+      @renderer.draw.fill(color)
+      @renderer.draw.stroke_width(@width) if @width
+      @renderer.draw.line(start_x, start_y, end_x, end_y)
+      @renderer.draw.pop
     end
   end
 end

data/lib/gruff/renderer/polygon.rb

@@ -3,22 +3,21 @@
 module Gruff
   # @private
   class Renderer::Polygon
-    def initialize(color:, width: 1.0, opacity: 1.0)
+    def initialize(renderer, color:, width: 1.0, opacity: 1.0)
+      @renderer = renderer
       @color = color
       @width = width
       @opacity = opacity
     end
 
     def render(points)
-      draw = Renderer.instance.draw
-
-      draw.push
-      draw.stroke_width(@width)
-      draw.stroke(@color)
-      draw.fill(@color)
-      draw.fill_opacity(@opacity)
-      draw.polygon(*points)
-      draw.pop
+      @renderer.draw.push
+      @renderer.draw.stroke_width(@width)
+      @renderer.draw.stroke(@color)
+      @renderer.draw.fill(@color)
+      @renderer.draw.fill_opacity(@opacity)
+      @renderer.draw.polygon(*points)
+      @renderer.draw.pop
     end
   end
 end

data/lib/gruff/renderer/polyline.rb

@@ -3,20 +3,19 @@
 module Gruff
   # @private
   class Renderer::Polyline
-    def initialize(color:, width:)
+    def initialize(renderer, color:, width:)
+      @renderer = renderer
       @color = color
       @width = width
     end
 
     def render(points)
-      draw = Renderer.instance.draw
-
-      draw.push
-      draw.stroke(@color)
-      draw.fill('transparent')
-      draw.stroke_width(@width)
-      draw.polyline(*points)
-      draw.pop
+      @renderer.draw.push
+      @renderer.draw.stroke(@color)
+      @renderer.draw.fill('transparent')
+      @renderer.draw.stroke_width(@width)
+      @renderer.draw.polyline(*points)
+      @renderer.draw.pop
     end
   end
 end

data/lib/gruff/renderer/rectangle.rb

@@ -3,18 +3,21 @@
 module Gruff
   # @private
   class Renderer::Rectangle
-    def initialize(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)
-      draw = Renderer.instance.draw
-
-      draw.push
-      draw.stroke('transparent')
-      draw.fill(@color) if @color
-      draw.rectangle(upper_left_x, upper_left_y, lower_right_x, lower_right_y)
-      draw.pop
+      @renderer.draw.push
+      @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
     end
   end
 end

data/lib/gruff/renderer/renderer.rb

@@ -1,53 +1,32 @@
 # frozen_string_literal: true
 
-require 'singleton'
-
 module Gruff
   # @private
   class Renderer
-    include Singleton
-
-    attr_accessor :draw, :image, :scale, :text_renderers
-
-    def self.setup(columns, rows, font, scale, theme_options)
-      draw = Magick::Draw.new
-      draw.font = font if font
-      # Scale down from 800x600 used to calculate drawing.
-      draw.scale(scale, scale)
-
-      image = Renderer.instance.background(columns, rows, scale, theme_options)
+    attr_accessor :text_renderers
+    attr_reader :draw, :image, :scale
 
-      Renderer.instance.draw  = draw
-      Renderer.instance.scale = scale
-      Renderer.instance.image = image
-      Renderer.instance.text_renderers = []
-    end
-
-    def self.setup_transparent_background(columns, rows)
-      image = Renderer.instance.render_transparent_background(columns, rows)
-      Renderer.instance.image = image
-    end
+    def initialize(columns, rows, scale, theme_options)
+      @draw = Magick::Draw.new
+      @text_renderers = []
 
-    def self.background_image=(image)
-      Renderer.instance.image = image
+      @scale = scale
+      @draw.scale(scale, scale)
+      @image = background(columns, rows, scale, theme_options)
     end
 
-    def self.font=(font)
-      draw = Renderer.instance.draw
-      draw.font = font if font
-    end
+    def finish
+      @draw.draw(@image)
 
-    def self.finish
-      draw  = Renderer.instance.draw
-      image = Renderer.instance.image
-
-      draw.draw(image)
-
-      Renderer.instance.text_renderers.each do |renderer|
+      @text_renderers.each do |renderer|
         renderer.render(renderer.width, renderer.height, renderer.x, renderer.y, renderer.gravity)
       end
     end
 
+    def background_image=(image)
+      @image = image
+    end
+
     def background(columns, rows, scale, theme_options)
       case theme_options[:background_colors]
       when Array
@@ -59,10 +38,14 @@ module Gruff
       end
     end
 
+    def transparent_background(columns, rows)
+      @image = render_transparent_background(columns, rows)
+    end
+
     # 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
 
@@ -101,6 +84,8 @@ module Gruff
       end
     end
 
+  private
+
     # Use with a theme to use an image (800x600 original) background.
     def image_background(scale, image_path)
       image = Magick::Image.read(image_path)
@@ -112,8 +97,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