teejayvanslyke-gruff 0.3.6

data/lib/gruff/side_stacked_bar.rb

@@ -0,0 +1,77 @@
+require File.dirname(__FILE__) + '/base'
+require File.dirname(__FILE__) + '/side_bar'
+require File.dirname(__FILE__) + '/stacked_mixin'
+
+##
+# New gruff graph type added to enable sideways stacking bar charts 
+# (basically looks like a x/y flip of a standard stacking bar chart)
+#
+# alun.eyre@googlemail.com 
+
+class Gruff::SideStackedBar < Gruff::SideBar
+  include StackedMixin
+
+  # Spacing factor applied between bars
+  attr_accessor :bar_spacing
+  
+  def draw
+    @has_left_labels = true
+    get_maximum_by_stack
+    super
+
+    return unless @has_data
+
+    # Setup spacing.
+    #
+    # Columns sit stacked.
+    @bar_spacing ||= 0.9
+
+    @bar_width = @graph_height / @column_count.to_f
+    @d = @d.stroke_opacity 0.0
+    height = Array.new(@column_count, 0)
+    length = Array.new(@column_count, @graph_left)
+    padding = (@bar_width * (1 - @bar_spacing)) / 2
+
+    @norm_data.each_with_index do |data_row, row_index|
+      @d = @d.fill data_row[DATA_COLOR_INDEX]
+
+      data_row[DATA_VALUES_INDEX].each_with_index do |data_point, point_index|
+
+    	  ## using the original calcs 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]) 
+    	  temp2 = @graph_left + @graph_width - height[point_index] 
+    	  difference = temp2 - temp1
+
+    	  left_x = length[point_index] #+ 1
+              left_y = @graph_top + (@bar_width * point_index) + padding
+    	  right_x = left_x + difference
+              right_y = left_y + @bar_width * @bar_spacing
+    	  length[point_index] += difference
+        height[point_index] += (data_point * @graph_width - 2)
+
+        @d = @d.rectangle(left_x, left_y, right_x, right_y)
+
+        # Calculate center based on bar_width and current row
+        label_center = @graph_top + (@bar_width * point_index) + (@bar_width * @bar_spacing / 2.0)
+        draw_label(label_center, point_index)
+      end
+
+    end
+
+    @d.draw(@base_image)    
+  end
+
+  protected
+
+  def larger_than_max?(data_point, index=0)
+    max(data_point, index) > @maximum_value
+  end
+
+  def max(data_point, index)
+    @data.inject(0) {|sum, item| sum + item[DATA_VALUES_INDEX][index]}
+  end
+
+end

data/lib/gruff/spider.rb

@@ -0,0 +1,130 @@
+
+require File.dirname(__FILE__) + '/base'
+
+# Experimental!!! See also the Net graph.
+#
+# Submitted by Kevin Clark http://glu.ttono.us/
+class Gruff::Spider < Gruff::Base
+  
+  # Hide all text
+  attr_reader :hide_text
+  attr_accessor :hide_axes
+  attr_reader :transparent_background
+  
+  def transparent_background=(value)
+    @transparent_background = value
+    @base_image = render_transparent_background if value
+  end
+
+  def hide_text=(value)
+    @hide_title = @hide_text = value
+  end
+  
+  def initialize(max_value, target_width = 800)
+    super(target_width)
+    @max_value = max_value
+    @hide_legend = true;
+  end
+  
+  def draw
+    @hide_line_markers = true
+    
+    super
+
+    return unless @has_data
+
+    # Setup basic positioning
+    diameter = @graph_height
+    radius = @graph_height / 2.0
+    top_x = @graph_left + (@graph_width - diameter) / 2.0
+    center_x = @graph_left + (@graph_width / 2.0)
+    center_y = @graph_top + (@graph_height / 2.0) - 25 # Move graph up a bit
+    
+    @unit_length = radius / @max_value
+    
+        
+    total_sum = sums_for_spider
+    prev_degrees = 0.0
+    additive_angle = (2 * Math::PI)/ @data.size
+    
+    current_angle = 0.0
+
+    # Draw axes
+    draw_axes(center_x, center_y, radius, additive_angle) unless hide_axes    
+    
+    # Draw polygon
+    draw_polygon(center_x, center_y, additive_angle)
+    
+     
+    @d.draw(@base_image)
+  end
+
+private
+  
+  def normalize_points(value)
+    value * @unit_length
+  end
+  
+  def draw_label(center_x, center_y, angle, radius, amount)
+    r_offset = 50      # The distance out from the center of the pie to get point
+    x_offset = center_x      # The label points need to be tweaked slightly
+    y_offset = center_y + 0  # This one doesn't though
+    x = x_offset + ((radius + r_offset) * Math.cos(angle))
+    y = y_offset + ((radius + r_offset) * Math.sin(angle))
+    
+    # Draw label
+    @d.fill = @marker_color
+    @d.font = @font if @font
+    @d.pointsize = scale_fontsize(legend_font_size)
+    @d.stroke = 'transparent'
+    @d.font_weight = BoldWeight
+    @d.gravity = CenterGravity
+    @d.annotate_scaled( @base_image, 
+                      0, 0,
+                      x, y, 
+                      amount, @scale)
+  end
+  
+  def draw_axes(center_x, center_y, radius, additive_angle, line_color = nil)
+    return if hide_axes
+    
+    current_angle = 0.0
+    
+    @data.each do |data_row|
+      @d.stroke(line_color || data_row[DATA_COLOR_INDEX])
+      @d.stroke_width 5.0
+    
+      x_offset = radius * Math.cos(current_angle)
+      y_offset = radius * Math.sin(current_angle)
+
+      @d.line(center_x, center_y,
+              center_x + x_offset,
+              center_y + y_offset)
+            
+      draw_label(center_x, center_y, current_angle, radius, data_row[DATA_LABEL_INDEX].to_s) unless hide_text
+            
+      current_angle += additive_angle
+    end
+  end
+  
+  def draw_polygon(center_x, center_y, additive_angle, color = nil)
+    points = []
+    current_angle = 0.0
+    @data.each do |data_row|
+      points << center_x + normalize_points(data_row[DATA_VALUES_INDEX].first) * Math.cos(current_angle)
+      points << center_y + normalize_points(data_row[DATA_VALUES_INDEX].first) * Math.sin(current_angle)
+      current_angle += additive_angle
+    end
+    
+    @d.stroke_width 1.0
+    @d.stroke(color || @marker_color)
+    @d.fill(color || @marker_color)
+    @d.fill_opacity 0.4
+    @d.polygon(*points)
+  end
+  
+  def sums_for_spider
+    @data.inject(0.0) {|sum, data_row| sum += data_row[DATA_VALUES_INDEX].first}
+  end
+
+end

data/lib/gruff/stacked_area.rb

@@ -0,0 +1,67 @@
+
+require File.dirname(__FILE__) + '/base'
+require File.dirname(__FILE__) + '/stacked_mixin'
+
+class Gruff::StackedArea < Gruff::Base
+  include StackedMixin
+  attr_accessor :last_series_goes_on_bottom
+  
+  def draw
+    get_maximum_by_stack
+    super
+
+    return unless @has_data
+
+    @x_increment = @graph_width / (@column_count - 1).to_f
+    @d = @d.stroke 'transparent'
+
+    height = Array.new(@column_count, 0)
+
+    data_points = nil
+    iterator = last_series_goes_on_bottom ? :reverse_each : :each
+    @norm_data.send(iterator) do |data_row|
+      prev_data_points = data_points
+      data_points = Array.new
+        
+      @d = @d.fill data_row[DATA_COLOR_INDEX]
+
+      data_row[DATA_VALUES_INDEX].each_with_index do |data_point, index|
+        # Use incremented x and scaled y
+        new_x = @graph_left + (@x_increment * index)
+        new_y = @graph_top + (@graph_height - data_point * @graph_height - height[index])
+
+        height[index] += (data_point * @graph_height)
+        
+        data_points << new_x
+        data_points << new_y
+          
+        draw_label(new_x, index)
+
+      end
+
+      if prev_data_points
+        poly_points = data_points.dup
+        (prev_data_points.length/2 - 1).downto(0) do |i|
+          poly_points << prev_data_points[2*i] 
+          poly_points << prev_data_points[2*i+1]
+        end
+        poly_points << data_points[0] 
+        poly_points << data_points[1] 
+      else
+        poly_points = data_points.dup
+        poly_points << @graph_right
+        poly_points << @graph_bottom - 1
+        poly_points << @graph_left
+        poly_points << @graph_bottom - 1
+        poly_points << data_points[0] 
+        poly_points << data_points[1] 
+      end
+      @d = @d.polyline(*poly_points)
+
+    end
+
+    @d.draw(@base_image)
+  end
+   
+ 
+end

data/lib/gruff/stacked_bar.rb

@@ -0,0 +1,57 @@
+
+require File.dirname(__FILE__) + '/base'
+require File.dirname(__FILE__) + '/stacked_mixin'
+
+class Gruff::StackedBar < Gruff::Base
+    include StackedMixin
+
+    # Spacing factor applied between bars
+    attr_accessor :bar_spacing
+    
+    # Draws a bar graph, but multiple sets are stacked on top of each other.
+    def draw
+      get_maximum_by_stack
+      super
+      return unless @has_data
+
+      # Setup spacing.
+      #
+      # Columns sit stacked.
+      @bar_spacing ||= 0.9
+      @bar_width = @graph_width / @column_count.to_f
+      padding = (@bar_width * (1 - @bar_spacing)) / 2
+    
+      @d = @d.stroke_opacity 0.0
+      
+      height = Array.new(@column_count, 0)
+    
+      @norm_data.each_with_index do |data_row, row_index|      
+        data_row[DATA_VALUES_INDEX].each_with_index do |data_point, point_index|
+          @d = @d.fill data_row[DATA_COLOR_INDEX]
+          
+          # Calculate center based on bar_width and current row
+          label_center = @graph_left + (@bar_width * point_index) + (@bar_width * @bar_spacing / 2.0)
+          draw_label(label_center, point_index)
+
+          next if (data_point == 0)
+          # Use incremented x and scaled y
+          left_x = @graph_left + (@bar_width * point_index) + padding
+          left_y = @graph_top + (@graph_height -
+                                 data_point * @graph_height - 
+                                 height[point_index]) + 1
+          right_x = left_x + @bar_width * @bar_spacing
+          right_y = @graph_top + @graph_height - height[point_index] - 1
+          
+          # update the total height of the current stacked bar
+          height[point_index] += (data_point * @graph_height ) 
+          
+          @d = @d.rectangle(left_x, left_y, right_x, right_y)
+          
+        end
+
+      end
+    
+      @d.draw(@base_image)    
+    end
+
+end

data/lib/gruff/stacked_mixin.rb

@@ -0,0 +1,23 @@
+
+module Gruff::Base::StackedMixin
+  # Used by StackedBar and child classes.
+  #
+  # tsal: moved from Base 03 FEB 2007
+  DATA_VALUES_INDEX = Gruff::Base::DATA_VALUES_INDEX
+  def get_maximum_by_stack
+    # Get sum of each stack
+    max_hash = {}
+    @data.each do |data_set|
+      data_set[DATA_VALUES_INDEX].each_with_index do |data_point, i|
+        max_hash[i] = 0.0 unless max_hash[i]
+        max_hash[i] += data_point.to_f
+      end
+    end
+  
+    # @maximum_value = 0
+    max_hash.keys.each do |key|
+      @maximum_value = max_hash[key] if max_hash[key] > @maximum_value
+    end
+    @minimum_value = 0
+  end
+end

data/lib/gruff.rb

@@ -0,0 +1,28 @@
+# Extra full path added to fix loading errors on some installations.
+
+%w(
+  base
+  area
+  bar
+  line
+  dot
+  pie
+  spider
+  net
+  stacked_area
+  stacked_bar
+  side_stacked_bar
+  side_bar
+  accumulator_bar
+
+  scene
+
+  mini/legend
+  mini/bar
+  mini/pie
+  mini/side_bar
+).each do |filename|
+  require File.dirname(__FILE__) + "/gruff/#{filename}"
+end
+
+# TODO bullet

data/rails_generators/gruff/gruff_generator.rb

@@ -0,0 +1,63 @@
+class GruffGenerator < Rails::Generator::NamedBase
+
+  attr_reader   :controller_name,
+                :controller_class_path,
+                :controller_file_path,
+                :controller_class_nesting,
+                :controller_class_nesting_depth,
+                :controller_class_name,
+                :controller_singular_name,
+                :controller_plural_name,
+                :parent_folder_for_require
+  alias_method  :controller_file_name,  :controller_singular_name
+  alias_method  :controller_table_name, :controller_plural_name
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+
+    # Take controller name from the next argument.
+    @controller_name = runtime_args.shift
+
+    base_name, @controller_class_path, @controller_file_path, @controller_class_nesting, @controller_class_nesting_depth = extract_modules(@controller_name)
+    @controller_class_name_without_nesting, @controller_singular_name, @controller_plural_name = inflect_names(base_name)
+
+    if @controller_class_nesting.empty?
+      @controller_class_name = @controller_class_name_without_nesting
+    else
+      @controller_class_name = "#{@controller_class_nesting}::#{@controller_class_name_without_nesting}"
+    end    
+  end
+
+  def manifest
+    record do |m|
+      # Check for class naming collisions.
+      m.class_collisions controller_class_path, "#{controller_class_name}Controller",
+                                                "#{controller_class_name}ControllerTest"
+
+      # Controller, helper, views, and test directories.
+      m.directory File.join('app/controllers', controller_class_path)
+      m.directory File.join('test/functional', controller_class_path)
+
+      m.template 'controller.rb',
+                  File.join('app/controllers',
+                            controller_class_path,
+                            "#{controller_file_name}_controller.rb")
+
+      # For some reason this doesn't take effect if done in initialize()
+      @parent_folder_for_require = @controller_class_path.join('/').gsub(%r%app/controllers/?%, '')
+      @parent_folder_for_require += @parent_folder_for_require.blank? ? '' : '/'
+
+      m.template 'functional_test.rb',
+                  File.join('test/functional',
+                            controller_class_path,
+                            "#{controller_file_name}_controller_test.rb")
+
+    end
+  end
+
+  protected
+    # Override with your own usage banner.
+    def banner
+      "Usage: #{$0} gruff ControllerName"
+    end
+end

data/rails_generators/gruff/templates/controller.rb

@@ -0,0 +1,32 @@
+class <%= controller_class_name %>Controller < ApplicationController
+
+  # To make caching easier, add a line like this to config/routes.rb:
+  # map.graph "graph/:action/:id/image.png", :controller => "graph"
+  #
+  # Then reference it with the named route:
+  #   image_tag graph_url(:action => 'show', :id => 42)
+
+  def show
+    g = Gruff::Line.new
+    # Uncomment to use your own theme or font
+    # See http://colourlovers.com or http://www.firewheeldesign.com/widgets/ for color ideas
+#     g.theme = {
+#       :colors => ['#663366', '#cccc99', '#cc6633', '#cc9966', '#99cc99'],
+#       :marker_color => 'white',
+#       :background_colors => ['black', '#333333']
+#     }
+#     g.font = File.expand_path('artwork/fonts/VeraBd.ttf', RAILS_ROOT)
+
+    g.title = "Gruff-o-Rama"
+    
+    g.data("Apples", [1, 2, 3, 4, 4, 3])
+    g.data("Oranges", [4, 8, 7, 9, 8, 9])
+    g.data("Watermelon", [2, 3, 1, 5, 6, 8])
+    g.data("Peaches", [9, 9, 10, 8, 7, 9])
+
+    g.labels = {0 => '2004', 2 => '2005', 4 => '2006'}
+
+    send_data(g.to_blob, :disposition => 'inline', :type => 'image/png', :filename => "gruff.png")
+  end
+
+end

data/rails_generators/gruff/templates/functional_test.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '<%= '/..' * controller_class_name.split("::").length %>/test_helper'
+require '<%= parent_folder_for_require %><%= controller_file_name %>_controller'
+
+# Re-raise errors caught by the controller.
+class <%= controller_class_name %>Controller; def rescue_action(e) raise e end; end
+
+class <%= controller_class_name %>ControllerTest < Test::Unit::TestCase
+
+  #fixtures :data
+
+  def setup
+    @controller = <%= controller_class_name %>Controller.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+  end
+
+  # TODO Replace this with your actual tests
+  def test_show
+    get :show
+    assert_response :success
+    assert_equal 'image/png', @response.headers['Content-Type']
+  end
+  
+end

data/test/gruff_test_case.rb

@@ -0,0 +1,123 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+# require 'rubygems'
+
+require 'test/unit'
+require 'gruff'
+require 'fileutils'
+# require 'test_timer'
+
+TEST_OUTPUT_DIR = File.dirname(__FILE__) + "/output"
+FileUtils.mkdir_p(TEST_OUTPUT_DIR)
+
+class GruffTestCase < Test::Unit::TestCase
+
+  def setup
+    @datasets = [
+      [:Jimmy, [25, 36, 86, 39, 25, 31, 79, 88]],
+      [:Charles, [80, 54, 67, 54, 68, 70, 90, 95]],
+      [:Julie, [22, 29, 35, 38, 36, 40, 46, 57]],
+      [:Jane, [95, 95, 95, 90, 85, 80, 88, 100]],
+      [:Philip, [90, 34, 23, 12, 78, 89, 98, 88]],
+      ["Arthur", [5, 10, 13, 11, 6, 16, 22, 32]],
+      ]
+
+    @labels = {
+        0 => '5/6', 
+        1 => '5/15', 
+        2 => '5/24', 
+        3 => '5/30', 
+        4 => '6/4', 
+        5 => '6/12', 
+        6 => '6/21', 
+        7 => '6/28', 
+      }      
+  end
+
+  def setup_single_dataset
+    @datasets = [
+      [:Jimmy, [25, 36, 86]]
+      ]
+
+    @labels = {
+        0 => 'You', 
+        1 => 'Average', 
+        2 => 'Lifetime' 
+      }      
+  end
+
+  def setup_wide_dataset
+    @datasets = [
+      ["Auto", 25],
+      ["Food", 5],
+      ["Entertainment", 15]
+      ]
+
+    @labels = { 0 => 'This Month' }
+  end
+
+  def test_dummy
+    assert true
+  end
+
+protected
+
+  # Generate graphs at several sizes.
+  #
+  # Also writes the graph to disk.
+  #
+  #   graph_sized 'bar_basic' do |g|
+  #     g.data('students', [1, 2, 3, 4])
+  #   end
+  #
+  def graph_sized(filename, sizes=['', 400])
+    class_name = self.class.name.gsub(/^TestGruff/, '')
+    Array(sizes).each do |size|
+      g = instance_eval("Gruff::#{class_name}.new #{size}")
+      g.title = "#{class_name} Graph"
+      yield g      
+      write_test_file g, "#{filename}_#{size}.png"
+    end
+  end
+
+  def write_test_file(graph, filename)
+    graph.write([TEST_OUTPUT_DIR, filename].join("/"))
+  end
+
+  ##
+  # Example:
+  #
+  #   setup_basic_graph Gruff::Pie, 400
+  #
+  def setup_basic_graph(*args)
+    klass, size = Gruff::Bar, 400
+    # Allow args to be klass, size or just klass or just size.
+    #
+    # TODO Refactor
+    case args.length
+    when 1
+      case args[0]
+      when Fixnum
+        size = args[0]
+        klass = eval("Gruff::#{self.class.name.gsub(/^TestGruff/, '')}") 
+      when String
+        size = args[0]
+        klass = eval("Gruff::#{self.class.name.gsub(/^TestGruff/, '')}") 
+      else
+        klass = args[0]
+      end
+    when 2
+      klass, size = args[0], args[1]
+    end
+    
+    g = klass.new(size)
+    g.title = "My Bar Graph"
+    g.labels = @labels
+
+
+    @datasets.each do |data|
+      g.data(data[0], data[1])
+    end
+    g
+  end
+
+end

data/test/test_accumulator_bar.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + "/gruff_test_case"
+
+class TestGruffAccumulatorBar < GruffTestCase
+
+  # TODO Delete old output files once when starting tests
+
+  def setup
+    @datasets = [
+      (1..20).to_a.map { rand(10) }
+    ]
+  end
+
+  def test_accumulator
+    g = Gruff::AccumulatorBar.new 500
+    g.title = "Your Savings"
+    g.hide_legend = true
+
+    # g.font = File.expand_path(File.dirname(__FILE__) + "/../assets/fonts/ATMA____.TTF")
+
+    g.marker_font_size = 18
+    
+    g.theme = {
+      :colors => ['#aedaa9', '#12a702'], # 3077a9 blue, aedaa9 light green
+      :marker_color => '#dddddd',
+      :font_color => 'black',      
+      :background_colors => "white"
+      # :background_image => File.expand_path(File.dirname(__FILE__) + "/../assets/backgrounds/43things.png")
+    }
+
+    # Attempt at negative numbers
+    # g.data 'Savings', (1..20).to_a.map { rand(10) * (rand(2) > 0 ? 1 : -1) }
+    g.data 'Savings', (1..12).to_a.map { rand(100) }
+    g.labels = (0..11).to_a.inject({}) {|memo, index| {index => '12-26'}.merge(memo)}
+
+    g.maximum_value = 1000
+    g.minimum_value = 0
+
+    g.write("test/output/accum_bar.png")
+  end
+
+  def test_too_many_args
+    assert_raise(Gruff::IncorrectNumberOfDatasetsException) {
+      g = Gruff::AccumulatorBar.new
+      g.data 'First', [1,1,1]
+      g.data 'Too Many', [1,1,1]
+      g.write("test/output/_SHOULD_NOT_ACTUALLY_BE_WRITTEN.png")
+    }
+  end
+
+end