scruffy 0.1.0 → 0.2.0

data/lib/scruffy/graph.rb

@@ -73,12 +73,14 @@ module Scruffy
   #   Of course, while you may be able to combine some things such as pie charts and line graphs, that
   #   doesn't necessarily mean they will make any logical sense together.  We leave those decisions up to you. :)
   class Graph
+    include Scruffy::Helpers::LayerContainer
+    
     attr_accessor :title
     attr_accessor :theme
-    attr_accessor :layers
     attr_accessor :default_type
     attr_accessor :point_markers
-    attr_accessor :marker_transformer
+    attr_accessor :value_formatter
+    attr_accessor :rasterizer
     
     attr_reader :renderer     # Writer defined below
     
@@ -94,20 +96,21 @@ module Scruffy
     # theme::  A theme hash to use when rendering graph
     # layers::  An array of Layers for this graph to use
     # default_type::  A symbol indicating the default type of Layer for this graph
-    # renderer::   Sets the renderer to use when rendering graph
-    # marker_transformer::   Sets a transformer used to modify marker values prior to rendering
+    # value_formatter::   Sets a formatter used to modify marker values prior to rendering
     # point_markers::  Sets the x-axis marker values
+    # rasterizer::  Sets the rasterizer to use when rendering to an image format.  Defaults to RMagick.
     def initialize(*args)
       self.default_type   = args.shift if args.first.is_a?(Symbol)
       options             = args.shift.dup if args.first.is_a?(Hash)
       raise ArgumentError, "The arguments provided are not supported." if args.size > 0
 
       options ||= {}
-      self.theme = Scruffy::Themes::KEYNOTE
-      self.layers = []
-      self.renderer = Scruffy::StandardRenderer.new
+      self.theme = Scruffy::Themes::Keynote.new
+      self.renderer = Scruffy::Renderers::Standard.new
+      self.rasterizer = Scruffy::Rasterizers::RMagickRasterizer.new
+      self.value_formatter = Scruffy::Formatters::Number.new
 
-      %w(title theme layers default_type renderer marker_transformer point_markers).each do |arg|
+      %w(title theme layers default_type value_formatter point_markers rasterizer).each do |arg|
         self.send("#{arg}=".to_sym, options.delete(arg.to_sym)) unless options[arg.to_sym].nil?
       end
       
@@ -118,7 +121,7 @@ module Scruffy
     #
     # Options:
     # size:: An array indicating the size you wish to render the graph.  ( [x, y] )
-    # width:: The width of the rendered graph.  A height is calculated at 60% of the width.
+    # width:: The width of the rendered graph.  A height is calculated at 3/4th of the width.
     # theme:: Theme used to render graph for this render only.
     # min_value:: Overrides the calculated minimum value used for the graph.
     # max_value:: Overrides the calculated maximum value used for the graph.
@@ -127,75 +130,42 @@ module Scruffy
     # as:: File format to render to ('PNG', 'JPG', etc)
     # to:: Name of file to save graph to, if desired.  If not provided, image is returned as blob.
     def render(options = {})
-      size  = options.delete(:size) || (options[:width] ? [options[:width], (options.delete(:width) * 0.6).to_i] : [600, 400])
-      options[:theme] ||= @theme
-      options[:marker_transformer] ||= @marker_transformer
-      options[:point_markers] ||= @point_markers
+      options[:theme]               ||= theme
+      options[:value_formatter]     ||= value_formatter
+      options[:point_markers]       ||= point_markers
+      options[:size]                ||= (options[:width] ? [options[:width], (options.delete(:width) * 0.6).to_i] : [600, 360])
+      options[:title]               ||= title
+      options[:layers]              ||= layers
+      options[:min_value]           ||= bottom_value(:padded)
+      options[:max_value]           ||= top_value
+      options[:graph]               ||= self
+      
       
-      svg = self.renderer.render( options.merge({:size => size, :title => title,
-                                                :layers => layers, :min_value => (options[:min_value] || bottom_value), 
-                                                :max_value => (options[:max_value] || top_value) } ) )
+      if options[:as] && (options[:size][0] <= 300 || options[:size][1] <= 200)
+        options[:actual_size] = options[:size]
+        options[:size] = [800, (800.to_f * (options[:actual_size][1].to_f / options[:actual_size][0].to_f))]
+        puts options[:size].inspect
+      end
+      
+      svg = ( options[:renderer].nil? ? self.renderer.render( options ) : options[:renderer].render( options ) )
 
-      options[:as] ? Scruffy::Rasterizers::RMagickRasterizer.new.rasterize(svg, options) : svg
-    end
-    
-    # Adds a Layer to the Graph.  Accepts either a list of arguments used to build a new layer, or
-    # a Scruffy::Layers::Base-derived object.  When passing a list of arguments, all arguments are optional, but the arguments
-    # specified must be provided in a particular order: type (Symbol), title (String), points (Array),
-    # options (Hash).
-    #
-    # Both #add and #<< can be used.
-    #
-    #   graph.add(:line, [100, 200, 150])     # Create and add an untitled line graph
-    #
-    #   graph << (:line, "John's Sales", [150, 100])    # Create and add a titled line graph
-    #
-    #   graph << Scruffy::Layers::Bar.new({...})   # Adds Bar layer to graph
-    #
-    def <<(*args)
-      if args[0].kind_of?(Scruffy::Layers::Base)
-        layers << args[0]
-      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 : []
-        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}))
-        layers << layer
+      options[:size] = options[:actual_size] if options[:actual_size]
+      
+      # SVG to file.
+      if options[:to] && options[:as].nil?
+        File.open(options[:to], 'w') { |file|
+          file.write(svg)
+        }
       end
-      layer
+      
+      options[:as] ? rasterizer.rasterize(svg, options) : svg
     end
     
-    alias :add :<<
     
     def renderer=(val)
       raise ArgumentError, "Renderer must include a #render(options) method." unless (val.respond_to?(:render) && val.method(:render).arity.abs > 0)
       
       @renderer = val
     end
-    
-    protected
-      def to_camelcase(type)  # :nodoc:
-        type.split('_').map { |e| e.capitalize }.join('')
-      end
-    
-      def top_value # :nodoc:
-        layers.inject(0) { |max, layer| (max = ((max < layer.highest_point) ? layer.highest_point : max)) unless layer.highest_point.nil?; max }
-      end
-      
-      def bottom_value # :nodoc:
-        botval = layers.inject(top_value) { |min, layer| (min = ((min > layer.lowest_point) ? layer.lowest_point : min)) unless layer.lowest_point.nil?; min }
-        above_zero = (botval > 0)
-        
-        botval = (botval - ((top_value - botval) * 0.15))
-        botval = 0 if (above_zero && botval < 0)
-        botval
-      end
   end
 end

data/lib/scruffy/helpers.rb

@@ -0,0 +1,2 @@
+require 'scruffy/helpers/canvas'
+require 'scruffy/helpers/layer_container'

data/lib/scruffy/helpers/canvas.rb

@@ -0,0 +1,22 @@
+module Scruffy
+  module Helpers
+    
+    # Helper methods for objects that act as canvases/viewports/etc.
+    #
+    # Primarily used for calculating relative positions.
+    module Canvas
+      
+      protected
+        def bounds_for(canvas_size, position, size)
+          return nil if (position.nil? || size.nil?)
+          bounds = {}
+          bounds[:x] = canvas_size.first * (position.first / 100.to_f)
+          bounds[:y] = canvas_size.last  * (position.last  / 100.to_f)
+          bounds[:width] = canvas_size.first * (size.first / 100.to_f)
+          bounds[:height] = canvas_size.last * (size.last  / 100.to_f)
+          bounds
+        end
+
+    end
+  end
+end

data/lib/scruffy/helpers/layer_container.rb

@@ -0,0 +1,69 @@
+module Scruffy::Helpers
+  module LayerContainer
+    # Adds a Layer to the Graph/Container.  Accepts either a list of arguments used to build a new layer, or
+    # a Scruffy::Layers::Base-derived object.  When passing a list of arguments, all arguments are optional, but the arguments
+    # specified must be provided in a particular order: type (Symbol), title (String), points (Array),
+    # options (Hash).
+    #
+    # Both #add and #<< can be used.
+    #
+    #   graph.add(:line, [100, 200, 150])     # Create and add an untitled line graph
+    #
+    #   graph << (:line, "John's Sales", [150, 100])    # Create and add a titled line graph
+    #
+    #   graph << Scruffy::Layers::Bar.new({...})   # Adds Bar layer to graph
+    #
+    def <<(*args, &block)
+      if args[0].kind_of?(Scruffy::Layers::Base)
+        layers << args[0]
+      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 : []
+        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)
+        layers << layer
+      end
+      layer
+    end
+
+    alias :add :<<
+    
+
+    # Custom Layer Accessors
+    def layers=(val)
+      @layers = val
+    end
+    def layers
+      @layers ||= []
+    end
+    
+    def top_value(padding=nil) # :nodoc:
+      topval = layers.inject(0) { |max, layer| (max = ((max < layer.top_value) ? layer.top_value : max)) unless layer.top_value.nil?; max }
+      padding == :padded ? (topval - ((topval - bottom_value) * 0.15)) : topval
+    end
+  
+    def bottom_value(padding=nil) # :nodoc:
+      botval = layers.inject(top_value) { |min, layer| (min = ((min > layer.bottom_value) ? layer.bottom_value : min)) unless layer.bottom_value.nil?; min }
+      above_zero = (botval > 0)
+      botval = (botval - ((top_value - botval) * 0.15))
+    
+      # Don't introduce negative values solely due to padding.
+      # A user-provided value must be negative before padding will extend into negative values.
+      (above_zero && botval < 0) ? 0 : botval
+    end
+
+
+    protected
+      def to_camelcase(type)  # :nodoc:
+        type.split('_').map { |e| e.capitalize }.join('')
+      end
+
+  end
+end

data/lib/scruffy/layers.rb

@@ -5,3 +5,4 @@ require 'scruffy/layers/all_smiles'
 require 'scruffy/layers/bar'
 require 'scruffy/layers/line'
 require 'scruffy/layers/average'
+require 'scruffy/layers/stacked'

data/lib/scruffy/layers/all_smiles.rb

@@ -104,6 +104,10 @@ module Scruffy
 
         end
       end
+
+      def scaled(pt)
+        relative(pt) / 2
+      end
     end
   end
 end

data/lib/scruffy/layers/area.rb

@@ -5,6 +5,7 @@ module Scruffy
         points_value = "0,#{height} #{stringify_coords(coords).join(' ')} #{width},#{height}"
 
         # Experimental, for later user.
+        # Neither ImageMagick nor Mozilla SVG render this well (at all).  Maybe a future thing.
         #
         # svg.defs {
         #   svg.filter(:id => 'MyFilter', :filterUnits => 'userSpaceOnUse', :x => 0, :y => 0, :width => 200, :height => '120') {
@@ -26,8 +27,8 @@ module Scruffy
         #     }
         #   }
         # }
-      
-        svg.polygon(:points => points_value, :fill => color.to_s, :stroke => color.to_s, :opacity => options[:opacity])
+
+        svg.polygon(:points => points_value, :fill => color.to_s, :stroke => color.to_s, 'style' => "opacity: #{opacity}")
       end
     end
   end

data/lib/scruffy/layers/average.rb

@@ -2,21 +2,12 @@ module Scruffy
   module Layers
     class Average < Base
       def initialize(options = {})
-        super
-      
-        @relevant_data = false
+        super(options.merge({:relevant_data => false}))
       end
+      
       def draw(svg, coords, options = {})
         svg.polyline( :points => coords.join(' '), :fill => 'none', :stroke => 'black',
-                      'stroke-width' => scaled(25), :opacity => '0.4')
-      end
-    
-      def highest_point
-        nil
-      end
-    
-      def lowest_point
-        nil
+                      'stroke-width' => relative(5), 'opacity' => '0.4')
       end
 
       protected

data/lib/scruffy/layers/bar.rb

@@ -7,7 +7,7 @@ module Scruffy
           x, y, bar_height = (coord.first-(@bar_width * 0.5)), coord.last, (height - coord.last)
 
           svg.rect( :x => x, :y => y, :width => @bar_width, :height => bar_height, 
-                    :fill => color.to_s, :stroke => color.to_s, :opacity => opacity )
+                    :fill => color.to_s, :stroke => color.to_s, 'style' => "opacity: #{opacity}" )
         end
       end
 

data/lib/scruffy/layers/base.rb

@@ -35,6 +35,7 @@ module Scruffy
       attr_accessor :resolver
       attr_accessor :complexity
       attr_accessor :relevant_data
+      attr_accessor :options          # On-the-fly values for easy customization / acts as attributes.
 
       # Returns a new Base object.
       #
@@ -45,10 +46,11 @@ module Scruffy
       # relevant_data:: Rarely used - indicates the data on this graph should not 
       #                 included in any graph data aggregations, such as averaging data points.
       def initialize(options = {})
-        @title              = options[:title] || ''
-        @points             = options[:points] || []
-        @preferred_color    = options[:color]
-        @relevant_data      = options[:relevant_data] || true
+        @title              = options.delete(:title) || ''
+        @points             = options.delete(:points) || []
+        @preferred_color    = options.delete(:color)
+        @relevant_data      = options.delete(:relevant_data) || true
+        @options            = options
       end
     
       # Builds SVG code for this graph using the provided Builder object.
@@ -72,28 +74,45 @@ module Scruffy
         # This is what the various graphs need to implement.
       end
     
+      # Returns a hash with information to be used by the legend.
+      #
+      # Alternatively, returns nil if you don't want this layer to be in the legend,
+      # or an array of hashes if this layer should have multiple legend entries (stacked?)
+      #
+      # By default, #legend_data returns nil automatically if relevant_data is set to false
+      # or the @color attribute is nil.  @color is set when the layer is rendered, so legends
+      # must be rendered AFTER layers.
+      def legend_data
+        if relevant_data? && @color
+          {:title => title, 
+           :color => @color,
+           :priority => :normal}
+        else
+          nil
+        end
+      end
+    
       # Returns the value of relevant_data
       def relevant_data?
         @relevant_data
       end
     
-      # The highest data point on this layer
-      def highest_point
-        points.sort.last
+      # The highest data point on this layer, or nil if relevant_data == false
+      def top_value
+        @relevant_data ? points.sort.last : nil
       end
     
-      # The lowest data point on this layer
-      def lowest_point
-        points.sort.first
+      # The lowest data point on this layer, or nil if relevant_data == false
+      def bottom_value
+        @relevant_data ? points.sort.first: nil
       end
-    
+
       protected
         def setup_variables(options = {}) # :nodoc:
           @color = (preferred_color || options.delete(:color))
-          @resolver = options.delete(:resolver)
           @width, @height = options.delete(:size)
           @min_value, @max_value = options[:min_value], options[:max_value]
-          @opacity = options[:opacity]
+          @opacity = options[:opacity] || 1.0
           @complexity = options[:complexity]
         end
 
@@ -112,13 +131,9 @@ module Scruffy
           coords
         end
       
-        # Returns a 'scaled' value of the given integer.
-        # 
-        # Scaled adjusts the given point depending on the height of the graph, where 400px is considered 1:1.
-        #
-        # ie: On a graph that is 800px high, scaled(1) => 2.  For 200px high, scaled(1) => 0.5, and so on...
-        def scaled(point)
-          resolver.to_point(point)
+        # Converts a percentage into a pixel value, related to the height.
+        def relative(pct)
+          @height * (pct / 100.to_f)
         end
 
         def stringify_coords(coords) # :nodoc:

data/lib/scruffy/layers/line.rb

@@ -3,9 +3,9 @@ module Scruffy
     class Line < Base
       def draw(svg, coords, options={})
         svg.polyline( :points => stringify_coords(coords).join(' '), :fill => 'none', 
-                      :stroke => color.to_s, 'stroke-width' => scaled(4) )
+                      :stroke => color.to_s, 'stroke-width' => relative(2) )
 
-        coords.each { |coord| svg.circle( :cx => coord.first, :cy => coord.last, :r => scaled(5), 
+        coords.each { |coord| svg.circle( :cx => coord.first, :cy => coord.last, :r => relative(2.5), 
                                           :fill => color.to_s ) }
       end
     end

data/lib/scruffy/layers/stacked.rb

@@ -0,0 +1,75 @@
+module Scruffy
+  module Layers
+    class Stacked < Base
+      include Scruffy::Helpers::LayerContainer
+      
+      def initialize(options={}, &block)
+        super(options)
+
+        block.call(self)    # Allow for population of data with a block during initialization.
+      end
+      
+      # Builds SVG code for this graph using the provided Builder object.
+      # This method actually generates data needed by this graph, then passes the
+      # rendering responsibilities to Base#draw.
+      #
+      # svg:: a Builder object used to create SVG code.
+      def render(svg, options = {})
+        current_points = points.dup
+        
+        layers.each do |layer|
+          real_points = layer.points
+          layer.points = current_points
+          layer_options = options.dup
+          layer_options[:color] = layer.preferred_color || layer.color || options[:theme].next_color          
+          layer.render(svg, layer_options)
+          options.merge(layer_options)
+          layer.points = real_points
+          
+          layer.points.each_with_index { |val, idx| current_points[idx] -= val }
+        end
+      end
+
+      def legend_data
+        if relevant_data?
+          retval = []
+          layers.each do |layer|
+            retval << layer.legend_data
+          end
+          retval
+        else
+          nil
+        end
+      end
+
+      # The highest data point on this layer, or nil if relevant_data == false
+      def top_value
+        @relevant_data ? points.sort.last : nil
+      end
+    
+      def points
+        longest_arr = layers.inject(nil) do |longest, layer|
+          longest = layer.points if (longest.nil? || longest.size < layer.points.size)
+        end
+        
+        summed_points = (0...longest_arr.size).map do |idx|
+          layers.inject(nil) do |sum, layer|
+            if sum.nil? && !layer.points[idx].nil?
+              sum = layer.points[idx]
+            elsif !layer.points[idx].nil?
+              sum += layer.points[idx]
+            end
+            
+            sum
+          end
+        end
+
+        summed_points
+      end
+
+      def points=(val)
+        throw ArgumentsError, "Stacked layers cannot accept points, only other layers."
+      end
+    end
+  end
+end