scruffy 0.2.2 → 0.2.3

data/lib/scruffy/helpers/layer_container.rb

@@ -30,15 +30,20 @@ module Scruffy::Helpers
       else
         type = args.first.is_a?(Symbol) ? args.shift : @default_type
         title = args.shift if args.first.is_a?(String)
-        points = args.first.is_a?(Array) ? args.shift : []
+        
+        # Layer handles PointContainer mixin, don't do it here
+        points = [Array, Hash].include?(args.first.class) ? args.shift : []
         options = args.first.is_a?(Hash) ? args.shift : {}
         
         title ||= ''
         
         raise ArgumentError, 
                 'You must specify a graph type (:area, :bar, :line, etc) if you do not have a default type specified.' if type.nil?
-        
-        layer = Kernel::module_eval("Scruffy::Layers::#{to_camelcase(type.to_s)}").new(options.merge({:points => points, :title => title}), &block)
+              
+        class_name = "Scruffy::Layers::#{to_camelcase(type.to_s)}"
+        layer_class = Kernel::module_eval(class_name)
+        options = {:points => points, :title => title}.merge options
+        layer = layer_class.new(options, &block)
         layers << layer
       end
       layer

data/lib/scruffy/helpers/meta.rb

@@ -1,5 +1,5 @@
-module Scruffy::MetaAttributes
-    def singleton_class
-      (class << self; self; end)
-    end
-end
+# module Scruffy::Helpers::MetaAttributes
+#     def singleton_class
+#       (class << self; self; end)
+#     end
+# end

data/lib/scruffy/helpers/point_container.rb

@@ -0,0 +1,70 @@
+module Scruffy::Helpers
+  
+  # ==Scruffy::Helpers::PointContainer
+  #
+  # Author:: Mat Schaffer
+  # Date:: March 22nd, 2007
+  #
+  # Allows all standard point operations to be called on both Array and Hash
+  module PointContainer
+    def self.extended point_set
+      point_set.extend(const_get(point_set.class.to_s))
+    end
+
+    def sortable_values
+      values.find_all { |v| v.respond_to? :<=> }
+    end
+    
+    def summable_values
+      values.find_all { |v| v.respond_to? :+ }
+    end
+    
+    def maximum_value
+      sortable_values.sort.last
+    end
+    
+    def minimum_value
+      sortable_values.sort.first
+    end
+    
+    def sum
+      summable_values.inject(0) { |sum, i| sum += i }
+    end
+    
+    def inject_with_index memo
+      index = 0
+      inject(memo) do |memo, item|
+        ret = yield memo, item, index
+        index = index.succ
+        ret
+      end
+    end
+    
+    module Array
+      def values
+        self
+      end
+    end
+    
+    module Hash
+      def minimum_key
+        self.keys.sort.first
+      end
+      
+      def maximum_key
+        self.keys.sort.last
+      end
+      
+      def inject memo
+        (minimum_key..maximum_key).each do |i|
+          memo = yield memo, self[i]
+        end
+        memo
+      end
+      
+      def size
+        maximum_key - minimum_key + 1
+      end
+    end
+  end
+end

data/lib/scruffy/layers.rb

@@ -20,3 +20,5 @@ require 'scruffy/layers/bar'
 require 'scruffy/layers/line'
 require 'scruffy/layers/average'
 require 'scruffy/layers/stacked'
+require 'scruffy/layers/pie'
+require 'scruffy/layers/pie_slice'

data/lib/scruffy/layers/average.rb

@@ -12,12 +12,16 @@ module Scruffy::Layers
   # for some reason, creating a massive black line.  Any help resolving this would
   # be useful.
   class Average < Base
+    attr_reader :layers
     
     # Returns new Average graph.
     def initialize(options = {})
       # Set self's relevant_data to false.  Otherwise we get stuck in a
       # recursive loop.
       super(options.merge({:relevant_data => false}))
+      
+      # The usual :points argument is actually layers for Average, name it as such
+      @layers = options[:points] 
     end
     
     # Render average graph.
@@ -30,12 +34,13 @@ module Scruffy::Layers
       # Override default generate_coordinates method to iterate through the layers and
       # generate coordinates based on the average data points.
       def generate_coordinates(options = {})
-        key_layer = points.find { |layer| layer.relevant_data? }
+        key_layer = layers.find { |layer| layer.relevant_data? }
       
         options[:point_distance] = width / (key_layer.points.size - 1).to_f
 
         coords = []
 
+        #TODO this will likely break with the new hash model
         key_layer.points.each_with_index do |layer, idx|
           sum, objects = points.inject([0, 0]) do |arr, elem|
             if elem.relevant_data?

data/lib/scruffy/layers/bar.rb

@@ -38,6 +38,7 @@ module Scruffy::Layers
         @bar_width = (width / points.size) * 0.9
         options[:point_distance] = (width - (width / points.size)) / (points.size - 1).to_f
 
+        #TODO more array work with index, try to rework to be accepting of hashes
         coords = (0...points.size).map do |idx| 
           x_coord = (options[:point_distance] * idx) + (width / points.size * 0.5)
 

data/lib/scruffy/layers/base.rb

@@ -2,7 +2,9 @@ module Scruffy::Layers
   # ==Scruffy::Layers::Base
   #
   # Author:: Brasten Sager
-  # Date:: August 5th, 2006
+  # Extended By:: A.J. Ostman
+  # Created:: August 5th, 2006
+  # Last Modified:: August 27, 2006
   #
   # Scruffy::Layers::Base contains the basic functionality needed by the various types of graphs.  The Base
   # class is responsible holding layer information such as the title and data points.
@@ -49,9 +51,11 @@ module Scruffy::Layers
     #                 included in any graph data aggregations, such as averaging data points.
     def initialize(options = {})
       @title              = options.delete(:title) || ''
-      @points             = options.delete(:points) || []
       @preferred_color    = options.delete(:preferred_color)
       @relevant_data      = options.delete(:relevant_data) || true
+      @points             = options.delete(:points) || []
+      @points.extend Scruffy::Helpers::PointContainer unless @points.kind_of? Scruffy::Helpers::PointContainer
+      
       @options            = options
     end
   
@@ -98,15 +102,20 @@ module Scruffy::Layers
     def relevant_data?
       @relevant_data
     end
-  
+
     # The highest data point on this layer, or nil if relevant_data == false
     def top_value
-      @relevant_data ? points.sort.last : nil
+      @relevant_data ? points.maximum_value : nil
     end
   
     # The lowest data point on this layer, or nil if relevant_data == false
     def bottom_value
-      @relevant_data ? points.sort.first: nil
+       @relevant_data ? points.minimum_value : nil
+    end
+
+    # The sum of all values
+    def sum_values
+      points.sum
     end
 
     protected
@@ -125,17 +134,19 @@ module Scruffy::Layers
       # in pie charting and bar charts).
       def generate_coordinates(options = {})
         options[:point_distance] = width / (points.size - 1).to_f
-      
-        coords = (0...points.size).map do |idx| 
-          x_coord = options[:point_distance] * idx
 
-          relative_percent = ((points[idx] == min_value) ? 0 : ((points[idx] - min_value) / (max_value - min_value).to_f))
-          y_coord = (height - (height * relative_percent))
+        points.inject_with_index([]) do |memo, point, idx|
+          x_coord = options[:point_distance] * idx
 
-          [x_coord, y_coord]
+          if point
+            relative_percent = ((point == min_value) ? 0 : ((point - min_value) / (max_value - min_value).to_f))
+            y_coord = (height - (height * relative_percent))
+  
+            memo << [x_coord, y_coord]
+          end
+          
+          memo
         end
-      
-        coords
       end
     
       # Converts a percentage into a pixel value, relative to the height.
@@ -143,8 +154,21 @@ module Scruffy::Layers
       # Example:
       #   relative(5)   # On a 100px high layer, this returns 5.  200px high layer, this returns 10, etc.
       def relative(pct)
-        @height * (pct / 100.to_f)
+        # Default to Relative Height
+        relative_height(pct)
+      end
+
+      def relative_width(pct)
+        if pct # Added to handle nils
+          @width * (pct / 100.to_f)
+        end
       end
+      
+      def relative_height(pct)
+        if pct # Added to handle nils
+          @height * (pct / 100.to_f)
+        end
+      end      
 
       # Some SVG elements take a long string of multiple coordinates.  This is here
       # to make that a little easier.

data/lib/scruffy/layers/pie.rb

@@ -0,0 +1,123 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::Pie
+  # 
+  # Author:: A.J. Ostman
+  # Date:: August 15, 2006
+  # 
+  # Provides a container for pie slice.
+  class Pie < Base
+    include Scruffy::Helpers::LayerContainer
+  
+    # Basic Example:
+    # 
+    #   graph = Scruffy::Graph.new
+    #   graph.title = "Snack Preference"
+    #   graph.renderer = Scruffy::Renderers::Pie.new
+    #   graph.add :pie, 'Example', {'Apples' => 90, 'Orange' => 60, 'Taco' => 30}
+    #
+    # Or, using a block to add slices:
+    # 
+    #     graph = Scruffy::Graph.new
+    #     graph.title = "Snack Preference"
+    #     graph.renderer = Scruffy::Renderers::Pie.new
+    #     graph.add :pie do |pie|
+    #       pie.add :pie_slice, 'Apple', [90]
+    #       pie.add :pie_slice, 'Orange', [60]
+    #       pie.add :pie_slice, 'Taco', [30]
+    #     end
+    # 
+    # Another Example:
+    #   graph.title = "Scruff-Pac!"
+    #   graph.renderer = Scruffy::Renderers::Pie.new
+    #   graph.add :pie, :diameter => 40, :degree_offset => 30 do |pie|
+    #     pie.add :pie_slice, '', [160], :preferred_color => "yellow", :shadow => true,
+    #             :shadow_x => -1, :shadow_y => 1, :shadow_color=>"black", :shadow_opacity => 0.4
+    #     pie.add :pie_slice, '', [50], :preferred_color => "green", :explode => 5, :diameter => 20,
+    #           :shadow => true, :shadow_x => -1, :shadow_y => 1, :shadow_color => "black", :shadow_opacity => 0.4
+    #   end
+    # 
+    #   graph.add :pie, :diameter => 3, :center_x => 48, :center_y=> 37, :degree_offset => 20 do |pie|
+    #     pie.add :pie_slice, '', [160], :preferred_color => "blue", :stroke => "black"
+    #   end
+    
+    
+    # Setup Constants
+    RADIANS = Math::PI/180
+
+    attr_accessor :diameter
+    attr_accessor :percent_used
+    attr_accessor :degree_offset
+    attr_accessor :scaler
+    attr_accessor :center_x, :center_y
+
+    
+    # The initialize method passes itself to the block, and since Pie is a
+    # LayerContainer, layers (pie slice) can be added just as if they were being
+    # added to Graph.
+    def initialize(options = {}, &block)
+      super(options)
+
+      # Allow for population of data with a block during initialization.
+      if block
+        block.call(self)
+      else
+        # Otherwise, just iterate over the points, adding the slices
+        if @points.class == Hash
+          @points.keys.each {|k|
+            self.add :pie_slice, k.to_s, [@points[k]]}
+        end
+        if @points.class == Array
+          @points.each {|v|
+            self.add :pie_slice, '', [v]}
+        end
+      end
+    end
+
+    
+    # Overrides Base#render to fiddle with layers' points to achieve a stacked
+    # effect.
+    def render(svg, options = {})
+      # #current_points = points.dup
+
+      @scaler = 1
+      total = 0
+      
+      layers.each do |layer|
+        total += layer.sum_values
+      end 
+      
+      @scaler = 100.0 / total
+      
+      @percent_used = 30
+      
+      layers.each do |layer|
+        layer_options = options.dup
+        layer_options = layer_options.merge(@options)
+        layer_options = layer_options.merge(layer.options)
+        layer_options[:scaler] = @scaler
+        layer_options[:percent_used] = @percent_used
+        @percent_used += @scaler * layer.sum_values
+        layer_options[:color] = layer.preferred_color || layer.color || options[:theme].next_color          
+        
+        layer.render(svg, layer_options)
+      end
+    end
+
+    # A stacked graph has many data sets.  Return legend information for all of them.
+    def legend_data
+      if relevant_data?
+        retval = []
+        layers.each do |layer|
+          retval << layer.legend_data
+        end
+        retval
+      else
+        nil
+      end
+    end
+ 
+    def points=(val)
+      throw ArgumentsError, "Pie layers cannot accept points, only pie slices."
+    end
+  end
+end

data/lib/scruffy/layers/pie_slice.rb

@@ -0,0 +1,114 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::PieSlice
+  #
+  # Author:: A.J. Ostman
+  # Date:: August 14th, 2006
+  #
+  # Basic Pie Chart Slice..
+    
+  class PieSlice < Base
+  
+    # Setup Constants
+    RADIANS = Math::PI / 180 
+    MARKER_OFFSET_RATIO = 1.2
+    MARKER_FONT_SIZE = 6
+    
+    attr_accessor :diameter
+    attr_accessor :percent_used
+    attr_accessor :degree_offset
+    attr_accessor :scaler
+    attr_accessor :center_x, :center_y
+    
+    def draw(svg, coords, options = {})
+      # Scaler is the multiplier to normalize the values to a percentage across the Pie Chart
+      @scaler = options[:scaler] || 1
+      
+      # Degree Offset is degrees by which the pie chart is twisted when it begins
+      @degree_offset = options[:degree_offset] || @options[:degree_offset] || 0
+      
+      # Percent Used keeps track of where in the pie chart we are
+      @percent_used = options[:percent_used] || @options[:percent_used] || 0
+      
+      # Diameter of the pie chart defaults to 80% of the height
+      @diameter = relative(options[:diameter]) || relative(@options[:diameter]) || relative(80.0)
+      
+      # Stroke
+      stroke = options[:stroke] || @options[:stroke] || "none"
+
+      # Shadow
+      shadow = options[:shadow] || @options[:shadow_] || false
+      shadow_x = relative(options[:shadow_x]) || relative(@options[:shadow_x]) || relative(-0.5)
+      shadow_y = relative(options[:shadow_y]) || relative(@options[:shadow_y]) || relative(0.5)
+      shadow_color = options[:shadow_color] || @options[:shadow_color] || "white"
+      shadow_opacity = options[:shadow_opacity] || @options[:shadow_opacity] || 0.06
+      
+      # Coordinates for the center of the pie chart. 
+      @center_x = relative_width(options[:center_x]) || relative_width(@options[:center_x]) || relative_width(50)
+      @center_y = relative_height(options[:center_y]) || relative_height(@options[:center_y]) || relative_height(50)
+      radius = @diameter / 2.0
+      
+      # Graphing calculated using percent of graph. 
+      # We later multiply by 3.6 to convert to 360 degree system.
+      percent = @scaler * sum_values
+      
+
+      # Calculate the Radian Start Point
+      radians_start = ((@percent_used * 3.6) + @degree_offset) * RADIANS
+      # Calculate the Radian End Point
+      radians_end = ((@percent_used + percent) * 3.6 + @degree_offset) * RADIANS
+
+      radians_mid_point = radians_start + ((radians_end - radians_start) / 2)
+      
+      if options[:explode]
+          @center_x = @center_x + (Math.sin(radians_mid_point) * relative(options[:explode]))
+          @center_y = @center_y - (Math.cos(radians_mid_point) * relative(options[:explode]))
+      end
+  
+
+      # Calculate the beginning coordinates
+      x_start = @center_x + (Math.sin(radians_start) * radius)
+      y_start = @center_y - (Math.cos(radians_start) * radius)
+      
+      # Calculate the End Coords
+      x_end = @center_x + (Math.sin(radians_end) * radius)
+      y_end = @center_y - (Math.cos(radians_end) * radius)
+
+      
+
+      # If percentage is really really close to 100% then draw a circle instead!
+      if percent >= 99.9999
+        
+        if shadow
+          svg.circle(:cx => "#{@center_x + shadow_x}", :cy => "#{@center_y + shadow_y}", :r=>"#{radius}",:stroke => "none", 
+                     :fill => shadow_color.to_s,  :style => "fill-opacity: #{shadow_opacity.to_s};")
+        end
+        
+        svg.circle(:cx => "#{@center_x}", :cy => "#{@center_y}", :r=>"#{radius}",:stroke => stroke, :fill => color.to_s)
+
+      else  
+        if shadow
+          svg.path(:d =>  "M#{@center_x + shadow_x},#{@center_y + shadow_y} L#{x_start + shadow_x},#{y_start + shadow_y} A#{radius},#{radius} 0, #{percent >= 50 ? '1' : '0'}, 1, #{x_end + shadow_x} #{y_end + shadow_y} Z", 
+                 :fill => shadow_color.to_s, :style => "fill-opacity: #{shadow_opacity.to_s};")
+        end
+        
+        svg.path(:d =>  "M#{@center_x},#{@center_y} L#{x_start},#{y_start} A#{radius},#{radius} 0, #{percent >= 50 ? '1' : '0'}, 1, #{x_end} #{y_end} Z", 
+               :stroke => stroke, :fill => color.to_s)
+      end
+      
+      text_x = @center_x + (Math.sin(radians_mid_point) * radius * MARKER_OFFSET_RATIO)
+      text_y = @center_y - (Math.cos(radians_mid_point) * radius * MARKER_OFFSET_RATIO)
+
+      svg.text("#{sprintf('%d', percent)}%", :x => text_x, :y => text_y + relative(MARKER_FONT_SIZE / 2), 
+                     'font-size' => relative(MARKER_FONT_SIZE), 
+                     :fill => (options[:theme].marker || 'black').to_s, 
+                     'text-anchor' => 'middle')
+    end
+
+      protected
+        def generate_coordinates(options = {})
+            # Coordinate Generation didn't make much sense here. 
+            # Overridden just because Brasten said this would be overridden.
+        end
+    end
+  
+end