scruffy 0.0.11 → 0.0.12

data/CHANGES

@@ -2,6 +2,12 @@
 
 Version 0.1.0 will be the first release for general use.
 
+== Version 0.0.12
+(August 10th, 2006)
+This is not a public release.
+
+* Rearranged Layers into a better class/module arrangement.
+
 == Version 0.0.11
 (August 10th, 2006)
 This is not a public release.

data/lib/scruffy/graph.rb

@@ -7,7 +7,7 @@
 # documentation in Scruffy::Graph.
 #
 # For information on creating your own graph types, see the
-# documentation in Scruffy::GraphLayer.
+# documentation in Scruffy::Layers::Base.
 module Scruffy
   
   # ==Scruffy Graphs
@@ -20,7 +20,7 @@ module Scruffy
   #
   # Scruffy::Graph is the primary class you will use to generate your graphs.  A Graph does not
   # define a graph type nor does it directly hold any data.  Instead, a Graph object can be thought
-  # of as a canvas on which other graphs are draw.  (The actual graphs themselves are subclasses of Scruffy::GraphLayer)
+  # of as a canvas on which other graphs are draw.  (The actual graphs themselves are subclasses of Scruffy::Layers::Base)
   # Despite the technical distinction, we will refer to Scruffy::Graph objects as 'graphs' and Scruffy::GraphLayers as
   # 'layers' or 'graph types.'
   #
@@ -34,7 +34,7 @@ module Scruffy
   #
   #   OR
   #
-  #   graph = Scruffy::Graph.new(:title => "Monthly Profits", :theme => Scruffy::Theme::RUBY_BLOG)
+  #   graph = Scruffy::Graph.new(:title => "Monthly Profits", :theme => Scruffy::Themes::RUBY_BLOG)
   #
   # Once you have a Graph object, you can set any Graph-level properties (title, theme, etc), or begin adding
   # graph layers.  You can add a graph layer to a graph by using the Graph#add or Graph#<< methods.  The two
@@ -45,8 +45,8 @@ module Scruffy
   #
   #   OR
   #
-  #   graph << Scruffy::LineLayer.new(:title => 'John', :points => [100, -20, 30, 60])
-  #   graph << Scruffy::LineLayer.new(:title => 'Sara', :points => [120, 50, -80, 20])  
+  #   graph << Scruffy::Layers::Line.new(:title => 'John', :points => [100, -20, 30, 60])
+  #   graph << Scruffy::Layers::Line.new(:title => 'Sara', :points => [120, 50, -80, 20])  
   #
   # Now that we've created our graph and added a layer to it, we're ready to render!  You can render the graph
   # directly to SVG with the Graph#render method:
@@ -85,15 +85,15 @@ module Scruffy
     # Returns a new Graph.  You can optionally pass in a default graph type and an options hash.
     #
     #   Graph.new           # New graph
-    #   Graph.new(:line)    # New graph with default graph type of LineLayer
+    #   Graph.new(:line)    # New graph with default graph type of Line
     #   Graph.new({...})    # New graph with options.
     #
     # Options:
     #
     # title::  Graph's title
     # theme::  A theme hash to use when rendering graph
-    # layers::  An array of GraphLayers for this graph to use
-    # default_type::  A symbol indicating the default type of GraphLayer for this 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
     # point_markers::  Sets the x-axis marker values
@@ -103,7 +103,7 @@ module Scruffy
       raise ArgumentError, "The arguments provided are not supported." if args.size > 0
 
       options ||= {}
-      self.theme = Scruffy::Theme::KEYNOTE
+      self.theme = Scruffy::Themes::KEYNOTE
       self.layers = []
       self.renderer = Scruffy::StandardRenderer.new
 
@@ -133,8 +133,8 @@ module Scruffy
                                        :layers => layers, :min_value => (options[:min_value] || bottom_value), :max_value => (options[:max_value] || top_value) } ) )
     end
     
-    # Adds a GraphLayer to the Graph.  Accepts either a list of arguments used to build a new layer, or
-    # a GraphLayer object.  When passing a list of arguments, all arguments are optional, but the arguments
+    # 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).
     #
@@ -144,10 +144,10 @@ module Scruffy
     #
     #   graph << (:line, "John's Sales", [150, 100])    # Create and add a titled line graph
     #
-    #   graph << BarLayer.new({...})   # Adds BarLayer object to graph
+    #   graph << Scruffy::Layers::Bar.new({...})   # Adds Bar layer to graph
     #
     def <<(*args)
-      if args[0].kind_of?(Scruffy::GraphLayer)
+      if args[0].kind_of?(Scruffy::Layers::Base)
         layers << args[0]
       else
         type = args.first.is_a?(Symbol) ? args.shift : default_type
@@ -160,7 +160,7 @@ module Scruffy
         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::#{to_camelcase(type.to_s)}Layer").new(options.merge({:points => points, :title => title}))
+        layer = Kernel::module_eval("Scruffy::Layers::#{to_camelcase(type.to_s)}").new(options.merge({:points => points, :title => title}))
         layers << layer
       end
       layer

data/lib/scruffy/layers/all_smiles.rb

@@ -0,0 +1,109 @@
+module Scruffy
+  module Layers
+    class AllSmiles < Base
+      attr_accessor :standalone
+    
+      def initialize(options = {})
+        super
+        @standalone = options[:standalone] || false
+      end
+    
+      def draw(svg, coords, options={})
+      
+        hero_smiley = nil
+        coords.each { |c| hero_smiley = c.last if (hero_smiley.nil? || c.last < hero_smiley) }
+      
+        svg.defs {
+          svg.radialGradient(:id => 'SmileyGradient', :cx => '50%', 
+                             :cy => '50%', :r => '50%', :fx => '30%', :fy => '30%') {
+                             
+              svg.stop(:offset => '0%', 'stop-color' => '#FFF')
+              svg.stop(:offset => '20%', 'stop-color' => '#FFC')
+              svg.stop(:offset => '45%', 'stop-color' => '#FF3')
+              svg.stop(:offset => '60%', 'stop-color' => '#FF0')
+              svg.stop(:offset => '90%', 'stop-color' => '#990')
+              svg.stop(:offset => '100%', 'stop-color' => '#220')
+          }
+          svg.radialGradient(:id => 'HeroGradient', :cx => '50%', 
+                             :cy => '50%', :r => '50%', :fx => '30%', :fy => '30%') {
+                             
+              svg.stop(:offset => '0%', 'stop-color' => '#FEE')
+              svg.stop(:offset => '20%', 'stop-color' => '#F0E0C0')
+              svg.stop(:offset => '45%', 'stop-color' => '#8A2A1A')
+              svg.stop(:offset => '60%', 'stop-color' => '#821')
+              svg.stop(:offset => '90%', 'stop-color' => '#210')
+          }
+          svg.radialGradient(:id => 'StarGradient', :cx => '50%', 
+                             :cy => '50%', :r => '50%', :fx => '30%', :fy => '30%') {
+                             
+              svg.stop(:offset => '0%', 'stop-color' => '#FFF')
+              svg.stop(:offset => '20%', 'stop-color' => '#EFEFEF')
+              svg.stop(:offset => '45%', 'stop-color' => '#DDD')
+              svg.stop(:offset => '60%', 'stop-color' => '#BBB')
+              svg.stop(:offset => '90%', 'stop-color' => '#888')
+          }
+        }
+            
+        unless standalone
+          svg.polyline( :points => stringify_coords(coords).join(' '), :fill => 'none', 
+                        :stroke => '#660', 'stroke-width' => scaled(10), 'stroke-dasharray' => "#{scaled(10)}, #{scaled(10)}" )
+        end
+      
+        coords.each do |coord|
+          if standalone
+            svg.line( :x1 => coord.first, :y1 => coord.last, :x2 => coord.first, :y2 => height, :fill => 'none', 
+                          :stroke => '#660', 'stroke-width' => scaled(10), 'stroke-dasharray' => "#{scaled(10)}, #{scaled(10)}" )
+          end
+          svg.circle( :cx => coord.first + scaled(2), :cy => coord.last + scaled(2), :r => scaled(15), 
+                      :fill => 'black', :stroke => 'none', :opacity => 0.4)
+          svg.circle( :cx => coord.first, :cy => coord.last, :r => scaled(15), 
+                      :fill => (complexity == :minimal ? 'yellow' : 'url(#SmileyGradient)'), :stroke => 'black', 'stroke-width' => scaled(1) )
+          svg.line( :x1 => (coord.first - scaled(3)), 
+                    :x2 => (coord.first - scaled(3)),
+                    :y1 => (coord.last),
+                    :y2 => (coord.last  - scaled(7)), :stroke => 'black', 'stroke-width' => scaled(1.4) )
+          svg.line( :x1 => (coord.first + scaled(3)), 
+                    :x2 => (coord.first + scaled(3)),
+                    :y1 => (coord.last),
+                    :y2 => (coord.last  - scaled(7)), :stroke => 'black', 'stroke-width' => scaled(1.4) )
+                  
+        
+          percent = 1.0 - (coord.last.to_f / height.to_f)
+        
+          corners = scaled(8 - (5 * percent))
+          anchor  = scaled((20 * percent) - 5)
+          svg.path( :d => "M#{coord.first - scaled(9)} #{coord.last + corners} Q#{coord.first} #{coord.last + anchor} #{coord.first + scaled(9)} #{coord.last + corners}",
+                    :stroke => 'black', 'stroke-width' => scaled(1.4), :fill => 'none' )
+                  
+                  
+          # top hat
+          if coord.last == hero_smiley
+            svg.ellipse(:cx => coord.first, :cy => (coord.last - scaled(13)), 
+                        :rx => scaled(17), :ry => scaled(6.5), :fill => (complexity == :minimal ? 'purple' : 'url(#HeroGradient)'), :stroke => 'black', 'stroke-width' => scaled(1.4) )
+          
+            svg.path(:d => "M#{coord.first} #{coord.last - scaled(60)} " +
+                           "L#{coord.first + scaled(10)} #{coord.last - scaled(14)} " +
+                           "C#{coord.first + scaled(10)},#{coord.last - scaled(9)} #{coord.first - scaled(10)},#{coord.last - scaled(9)} #{coord.first - scaled(10)},#{coord.last - scaled(14)}" +
+                           "L#{coord.first} #{coord.last - scaled(60)}",
+                      :stroke => 'black', 'stroke-width' => scaled(1.4), :fill => (complexity == :minimal ? 'purple' : 'url(#HeroGradient)'))
+
+            svg.path(:d =>  "M#{coord.first - scaled(4)} #{coord.last - scaled(23)}" +
+                            "l-#{scaled(2.5)} #{scaled(10)} l#{scaled(7.5)} -#{scaled(5)} l-#{scaled(10)} 0 l#{scaled(7.5)} #{scaled(5)} l-#{scaled(2.5)} -#{scaled(10)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
+            svg.path(:d =>  "M#{coord.first + scaled(2)} #{coord.last - scaled(30)}" +
+                            "l-#{scaled(2.5)} #{scaled(10)} l#{scaled(7.5)} -#{scaled(5)} l-#{scaled(10)} 0 l#{scaled(7.5)} #{scaled(5)} l-#{scaled(2.5)} -#{scaled(10)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
+            svg.path(:d =>  "M#{coord.first - scaled(2)} #{coord.last - scaled(33)}" +
+                            "l-#{scaled(1.25)} #{scaled(5)} l#{scaled(3.75)} -#{scaled(2.5)} l-#{scaled(5)} 0 l#{scaled(3.75)} #{scaled(2.5)} l-#{scaled(1.25)} -#{scaled(5)}", :stroke => 'none', :fill => 'white' )
+            svg.path(:d =>  "M#{coord.first - scaled(2.2)} #{coord.last - scaled(32.7)}" +
+                            "l-#{scaled(1.25)} #{scaled(5)} l#{scaled(3.75)} -#{scaled(2.5)} l-#{scaled(5)} 0 l#{scaled(3.75)} #{scaled(2.5)} l-#{scaled(1.25)} -#{scaled(5)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
+            svg.path(:d =>  "M#{coord.first + scaled(4.5)} #{coord.last - scaled(20)}" +
+                            "l-#{scaled(1.25)} #{scaled(5)} l#{scaled(3.75)} -#{scaled(2.5)} l-#{scaled(5)} 0 l#{scaled(3.75)} #{scaled(2.5)} l-#{scaled(1.25)} -#{scaled(5)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
+            svg.path(:d =>  "M#{coord.first} #{coord.last - scaled(40)}" +
+                            "l-#{scaled(1.25)} #{scaled(5)} l#{scaled(3.75)} -#{scaled(2.5)} l-#{scaled(5)} 0 l#{scaled(3.75)} #{scaled(2.5)} l-#{scaled(1.25)} -#{scaled(5)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/scruffy/layers/area.rb

@@ -0,0 +1,34 @@
+module Scruffy
+  module Layers
+    class Area < Base
+      def draw(svg, coords, options={})
+        points_value = "0,#{height} #{stringify_coords(coords).join(' ')} #{width},#{height}"
+
+        # Experimental, for later user.
+        #
+        # svg.defs {
+        #   svg.filter(:id => 'MyFilter', :filterUnits => 'userSpaceOnUse', :x => 0, :y => 0, :width => 200, :height => '120') {
+        #     svg.feGaussianBlur(:in => 'SourceAlpha', :stdDeviation => 4, :result => 'blur')
+        #     svg.feOffset(:in => 'blur', :dx => 4, :dy => 4, :result => 'offsetBlur')
+        #     svg.feSpecularLighting( :in => 'blur', :surfaceScale => 5, :specularConstant => '.75',
+        #                             :specularExponent => 20, 'lighting-color' => '#bbbbbb',
+        #                             :result => 'specOut') {
+        #       svg.fePointLight(:x => '-5000', :y => '-10000', :z => '20000')
+        #     }
+        #     
+        #     svg.feComposite(:in => 'specOut', :in2 => 'SourceAlpha', :operator => 'in', :result => 'specOut')
+        #     svg.feComposite(:in => 'sourceGraphic', :in2 => 'specOut', :operator => 'arithmetic',
+        #                     :k1 => 0, :k2 => 1, :k3 => 1, :k4 => 0, :result => 'litPaint')
+        #                     
+        #     svg.feMerge {
+        #       svg.feMergeNode(:in => 'offsetBlur')
+        #       svg.feMergeNode(:in => 'litPaint')
+        #     }
+        #   }
+        # }
+      
+        svg.polygon(:points => points_value, :fill => color.to_s, :stroke => color.to_s, :opacity => options[:opacity])
+      end
+    end
+  end
+end

data/lib/scruffy/layers/average.rb

@@ -0,0 +1,54 @@
+module Scruffy
+  module Layers
+    class Average < Base
+      def initialize(options = {})
+        super
+      
+        @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
+      end
+
+      protected
+        def generate_coordinates(options = {})
+          key_layer = points.find { |layer| layer.relevant_data? }
+        
+          options[:point_distance] = width / (key_layer.points.size - 1).to_f
+
+          coords = []
+
+          key_layer.points.each_with_index do |layer, idx|
+            sum, objects = points.inject([0, 0]) do |arr, elem|
+              if elem.relevant_data?
+                arr[0] += elem.points[idx]
+                arr[1] += 1
+              end
+              arr
+            end
+
+            average = sum / objects.to_f
+
+            x_coord = options[:point_distance] * idx
+
+            relative_percent = ((average == min_value) ? 0 : ((average - min_value) / (max_value - min_value).to_f))
+            y_coord = (height - (height * relative_percent))
+
+            coords << [x_coord, y_coord].join(',')
+          end
+
+          return coords
+        end
+    
+    end
+  end
+end

data/lib/scruffy/layers/bar.rb

@@ -0,0 +1,30 @@
+module Scruffy
+  module Layers
+    class Bar < Base
+    
+      def draw(svg, coords, options = {})
+        coords.each do |coord|
+          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 )
+        end
+      end
+
+      protected
+        def generate_coordinates(options = {})
+          @bar_width = (width / points.size) * 0.9
+          options[:point_distance] = (width - (width / points.size)) / (points.size - 1).to_f
+
+          coords = (0...points.size).map do |idx| 
+            x_coord = (options[:point_distance] * idx) + (width / points.size * 0.5)
+
+            relative_percent = ((points[idx] == min_value) ? 0 : ((points[idx] - min_value) / (max_value - min_value).to_f))
+            y_coord = (height - (height * relative_percent))
+            [x_coord, y_coord]
+          end
+          coords
+        end
+    end
+  end
+end

data/lib/scruffy/layers/base.rb

@@ -0,0 +1,122 @@
+module Scruffy
+  module Layers
+    # ==Base
+    #
+    # Author:: Brasten Sager
+    # Date:: August 5th, 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.
+    #
+    # When the graph is rendered, the graph renderer calls Base#render.  Base#render sets up
+    # some standard information, and calculates the x,y coordinates of each data point.  The draw() method,
+    # which should have been overridden by the current instance, is then called.  The actual rendering of
+    # the graph takes place there.
+    #
+    # ====Create New Graph Types
+    #
+    # Assuming the information generated by Scruffy::Layers::Base is sufficient, you can create a new graph type
+    # simply by overriding the draw() method.  See Base#draw for arguments.
+    #
+    class Base
+      attr_accessor :title
+      attr_accessor :points
+      attr_accessor :height, :width
+      attr_accessor :min_value, :max_value
+      attr_accessor :preferred_color, :color
+      attr_accessor :opacity
+      attr_accessor :resolver
+      attr_accessor :complexity
+      attr_accessor :relevant_data
+
+      # Returns a new Base object.
+      #
+      # Options:
+      # title::
+      # points:: Array of data points
+      # color:: Color used to render this graph, overrides theme color.
+      # 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
+      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 = {})
+        setup_variables(options)
+        coords = generate_coordinates(options)
+      
+        draw(svg, coords, options)
+      end
+    
+      # The method called by Base#draw to render the graph.
+      #
+      # svg:: a Builder object to use for creating SVG code.
+      # coords:: An array of coordinates relating to the graph's data points.  ie: [[100, 120], [200, 140], [300, 40]]
+      # options:: Optional arguments.
+      def draw(svg, coords, options={})
+        # This is what the various graphs need to implement.
+      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
+      end
+    
+      # The lowest data point on this layer
+      def lowest_point
+        points.sort.first
+      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]
+          @complexity = options[:complexity]
+        end
+
+        def generate_coordinates(options = {}) # :nodoc:
+          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))
+
+            [x_coord, y_coord]
+          end
+        
+          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)
+        end
+
+        def stringify_coords(coords) # :nodoc:
+          coords.map { |c| c.join(',') }
+        end
+    end
+  end
+end

data/lib/scruffy/layers/line.rb

@@ -0,0 +1,13 @@
+module Scruffy
+  module Layers
+    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) )
+
+        coords.each { |coord| svg.circle( :cx => coord.first, :cy => coord.last, :r => scaled(5), 
+                                          :fill => color.to_s ) }
+      end
+    end
+  end
+end

data/lib/scruffy/layers.rb

@@ -0,0 +1,7 @@
+# Layer files
+require 'scruffy/layers/base'
+require 'scruffy/layers/area'
+require 'scruffy/layers/all_smiles'
+require 'scruffy/layers/bar'
+require 'scruffy/layers/line'
+require 'scruffy/layers/average'

data/lib/scruffy/themes.rb

@@ -1,5 +1,5 @@
 module Scruffy
-  module Theme
+  module Themes
     KEYNOTE = {
       :background => [:black, '#4A465A'],
       :marker => :white, 

data/lib/scruffy/version.rb

@@ -1,3 +1,3 @@
 module Scruffy
-  VERSION = '0.0.11'
+  VERSION = '0.0.12'
 end

data/lib/scruffy.rb

@@ -10,15 +10,7 @@ require 'scruffy/themes'
 require 'scruffy/version'
 require 'scruffy/transformer'
 require 'scruffy/resolver'
-
-# Layer files
-require 'scruffy/graph_layers/base'
-require 'scruffy/graph_layers/area'
-require 'scruffy/graph_layers/all_smiles'
-require 'scruffy/graph_layers/bar'
-require 'scruffy/graph_layers/blue_screen'
-require 'scruffy/graph_layers/line'
-require 'scruffy/graph_layers/average'
+require 'scruffy/layers'
 
 # Renderers
 require 'scruffy/renderers/standard'

data/spec/graph_spec.rb

@@ -23,7 +23,7 @@ context "A new Scruffy::Graph" do
   end
   
   specify "should be set to the keynote theme" do
-    @graph.theme.should_equal Scruffy::Theme::KEYNOTE
+    @graph.theme.should_equal Scruffy::Themes::KEYNOTE
   end
   
   specify "should have zero layers" do
@@ -52,8 +52,8 @@ context "A new Scruffy::Graph" do
   end
   
   specify "should accept a new theme" do
-    @graph.theme = Scruffy::Theme::MEPHISTO
-    @graph.theme.should_equal Scruffy::Theme::MEPHISTO
+    @graph.theme = Scruffy::Themes::MEPHISTO
+    @graph.theme.should_equal Scruffy::Themes::MEPHISTO
   end
   
   specify "should accept a new default type" do
@@ -87,7 +87,7 @@ context "A Scruffy::Graph's initialization block" do
   
   specify "should accept just an options hash" do
     lambda { Scruffy::Graph.new({:title => "My Title"}) }.should_not_raise
-    lambda { Scruffy::Graph.new(:title => "My Title", :theme => Scruffy::Theme::KEYNOTE) }.should_not_raise
+    lambda { Scruffy::Graph.new(:title => "My Title", :theme => Scruffy::Themes::KEYNOTE) }.should_not_raise
   end
   
   specify "should accept both a default_type and options hash" do
@@ -111,7 +111,7 @@ context "A Scruffy::Graph's initialization block" do
       options = {:title => "My Title",
                  :theme => {:background => [:black], 
                             :colors => [:red => 'red', :yellow => 'yellow']},
-                 :layers => [ Scruffy::LineLayer.new(:points => [100, 200, 300]) ],
+                 :layers => [ Scruffy::Layers::Line.new(:points => [100, 200, 300]) ],
                  :default_type => :average,
                  :renderer => blank_renderer,
                  :marker_transformer => Scruffy::Transformer::Currency.new,

metadata

@@ -3,7 +3,7 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: scruffy
 version: !ruby/object:Gem::Version 
-  version: 0.0.11
+  version: 0.0.12
 date: 2006-08-10 00:00:00 -07:00
 summary: A powerful, clean graphing library for Ruby.
 require_paths: 
@@ -35,17 +35,17 @@ files:
 - README
 - lib/scruffy.rb
 - lib/scruffy/graph.rb
+- lib/scruffy/layers.rb
 - lib/scruffy/resolver.rb
 - lib/scruffy/themes.rb
 - lib/scruffy/transformer.rb
 - lib/scruffy/version.rb
-- lib/scruffy/graph_layers/all_smiles.rb
-- lib/scruffy/graph_layers/area.rb
-- lib/scruffy/graph_layers/average.rb
-- lib/scruffy/graph_layers/bar.rb
-- lib/scruffy/graph_layers/base.rb
-- lib/scruffy/graph_layers/blue_screen.rb
-- lib/scruffy/graph_layers/line.rb
+- lib/scruffy/layers/all_smiles.rb
+- lib/scruffy/layers/area.rb
+- lib/scruffy/layers/average.rb
+- lib/scruffy/layers/bar.rb
+- lib/scruffy/layers/base.rb
+- lib/scruffy/layers/line.rb
 - lib/scruffy/renderers/standard.rb
 - spec/graph_spec.rb
 test_files: []

data/lib/scruffy/graph_layers/all_smiles.rb

@@ -1,107 +0,0 @@
-module Scruffy
-  class AllSmilesLayer < GraphLayer
-    attr_accessor :standalone
-    
-    def initialize(options = {})
-      super
-      @standalone = options[:standalone] || false
-    end
-    
-    def draw(svg, coords, options={})
-      
-      hero_smiley = nil
-      coords.each { |c| hero_smiley = c.last if (hero_smiley.nil? || c.last < hero_smiley) }
-      
-      svg.defs {
-        svg.radialGradient(:id => 'SmileyGradient', :cx => '50%', 
-                           :cy => '50%', :r => '50%', :fx => '30%', :fy => '30%') {
-                             
-            svg.stop(:offset => '0%', 'stop-color' => '#FFF')
-            svg.stop(:offset => '20%', 'stop-color' => '#FFC')
-            svg.stop(:offset => '45%', 'stop-color' => '#FF3')
-            svg.stop(:offset => '60%', 'stop-color' => '#FF0')
-            svg.stop(:offset => '90%', 'stop-color' => '#990')
-            svg.stop(:offset => '100%', 'stop-color' => '#220')
-        }
-        svg.radialGradient(:id => 'HeroGradient', :cx => '50%', 
-                           :cy => '50%', :r => '50%', :fx => '30%', :fy => '30%') {
-                             
-            svg.stop(:offset => '0%', 'stop-color' => '#FEE')
-            svg.stop(:offset => '20%', 'stop-color' => '#F0E0C0')
-            svg.stop(:offset => '45%', 'stop-color' => '#8A2A1A')
-            svg.stop(:offset => '60%', 'stop-color' => '#821')
-            svg.stop(:offset => '90%', 'stop-color' => '#210')
-        }
-        svg.radialGradient(:id => 'StarGradient', :cx => '50%', 
-                           :cy => '50%', :r => '50%', :fx => '30%', :fy => '30%') {
-                             
-            svg.stop(:offset => '0%', 'stop-color' => '#FFF')
-            svg.stop(:offset => '20%', 'stop-color' => '#EFEFEF')
-            svg.stop(:offset => '45%', 'stop-color' => '#DDD')
-            svg.stop(:offset => '60%', 'stop-color' => '#BBB')
-            svg.stop(:offset => '90%', 'stop-color' => '#888')
-        }
-      }
-            
-      unless standalone
-        svg.polyline( :points => stringify_coords(coords).join(' '), :fill => 'none', 
-                      :stroke => '#660', 'stroke-width' => scaled(10), 'stroke-dasharray' => "#{scaled(10)}, #{scaled(10)}" )
-      end
-      
-      coords.each do |coord|
-        if standalone
-          svg.line( :x1 => coord.first, :y1 => coord.last, :x2 => coord.first, :y2 => height, :fill => 'none', 
-                        :stroke => '#660', 'stroke-width' => scaled(10), 'stroke-dasharray' => "#{scaled(10)}, #{scaled(10)}" )
-        end
-        svg.circle( :cx => coord.first + scaled(2), :cy => coord.last + scaled(2), :r => scaled(15), 
-                    :fill => 'black', :stroke => 'none', :opacity => 0.4)
-        svg.circle( :cx => coord.first, :cy => coord.last, :r => scaled(15), 
-                    :fill => (complexity == :minimal ? 'yellow' : 'url(#SmileyGradient)'), :stroke => 'black', 'stroke-width' => scaled(1) )
-        svg.line( :x1 => (coord.first - scaled(3)), 
-                  :x2 => (coord.first - scaled(3)),
-                  :y1 => (coord.last),
-                  :y2 => (coord.last  - scaled(7)), :stroke => 'black', 'stroke-width' => scaled(1.4) )
-        svg.line( :x1 => (coord.first + scaled(3)), 
-                  :x2 => (coord.first + scaled(3)),
-                  :y1 => (coord.last),
-                  :y2 => (coord.last  - scaled(7)), :stroke => 'black', 'stroke-width' => scaled(1.4) )
-                  
-        
-        percent = 1.0 - (coord.last.to_f / height.to_f)
-        
-        corners = scaled(8 - (5 * percent))
-        anchor  = scaled((20 * percent) - 5)
-        svg.path( :d => "M#{coord.first - scaled(9)} #{coord.last + corners} Q#{coord.first} #{coord.last + anchor} #{coord.first + scaled(9)} #{coord.last + corners}",
-                  :stroke => 'black', 'stroke-width' => scaled(1.4), :fill => 'none' )
-                  
-                  
-        # top hat
-        if coord.last == hero_smiley
-          svg.ellipse(:cx => coord.first, :cy => (coord.last - scaled(13)), 
-                      :rx => scaled(17), :ry => scaled(6.5), :fill => (complexity == :minimal ? 'purple' : 'url(#HeroGradient)'), :stroke => 'black', 'stroke-width' => scaled(1.4) )
-          
-          svg.path(:d => "M#{coord.first} #{coord.last - scaled(60)} " +
-                         "L#{coord.first + scaled(10)} #{coord.last - scaled(14)} " +
-                         "C#{coord.first + scaled(10)},#{coord.last - scaled(9)} #{coord.first - scaled(10)},#{coord.last - scaled(9)} #{coord.first - scaled(10)},#{coord.last - scaled(14)}" +
-                         "L#{coord.first} #{coord.last - scaled(60)}",
-                    :stroke => 'black', 'stroke-width' => scaled(1.4), :fill => (complexity == :minimal ? 'purple' : 'url(#HeroGradient)'))
-
-          svg.path(:d =>  "M#{coord.first - scaled(4)} #{coord.last - scaled(23)}" +
-                          "l-#{scaled(2.5)} #{scaled(10)} l#{scaled(7.5)} -#{scaled(5)} l-#{scaled(10)} 0 l#{scaled(7.5)} #{scaled(5)} l-#{scaled(2.5)} -#{scaled(10)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
-          svg.path(:d =>  "M#{coord.first + scaled(2)} #{coord.last - scaled(30)}" +
-                          "l-#{scaled(2.5)} #{scaled(10)} l#{scaled(7.5)} -#{scaled(5)} l-#{scaled(10)} 0 l#{scaled(7.5)} #{scaled(5)} l-#{scaled(2.5)} -#{scaled(10)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
-          svg.path(:d =>  "M#{coord.first - scaled(2)} #{coord.last - scaled(33)}" +
-                          "l-#{scaled(1.25)} #{scaled(5)} l#{scaled(3.75)} -#{scaled(2.5)} l-#{scaled(5)} 0 l#{scaled(3.75)} #{scaled(2.5)} l-#{scaled(1.25)} -#{scaled(5)}", :stroke => 'none', :fill => 'white' )
-          svg.path(:d =>  "M#{coord.first - scaled(2.2)} #{coord.last - scaled(32.7)}" +
-                          "l-#{scaled(1.25)} #{scaled(5)} l#{scaled(3.75)} -#{scaled(2.5)} l-#{scaled(5)} 0 l#{scaled(3.75)} #{scaled(2.5)} l-#{scaled(1.25)} -#{scaled(5)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
-          svg.path(:d =>  "M#{coord.first + scaled(4.5)} #{coord.last - scaled(20)}" +
-                          "l-#{scaled(1.25)} #{scaled(5)} l#{scaled(3.75)} -#{scaled(2.5)} l-#{scaled(5)} 0 l#{scaled(3.75)} #{scaled(2.5)} l-#{scaled(1.25)} -#{scaled(5)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
-          svg.path(:d =>  "M#{coord.first} #{coord.last - scaled(40)}" +
-                          "l-#{scaled(1.25)} #{scaled(5)} l#{scaled(3.75)} -#{scaled(2.5)} l-#{scaled(5)} 0 l#{scaled(3.75)} #{scaled(2.5)} l-#{scaled(1.25)} -#{scaled(5)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
-
-        end
-
-      end
-    end
-  end
-end

data/lib/scruffy/graph_layers/area.rb

@@ -1,32 +0,0 @@
-module Scruffy
-  class AreaLayer < GraphLayer
-    def draw(svg, coords, options={})
-      points_value = "0,#{height} #{stringify_coords(coords).join(' ')} #{width},#{height}"
-
-      # Experimental, for later user.
-      #
-      # svg.defs {
-      #   svg.filter(:id => 'MyFilter', :filterUnits => 'userSpaceOnUse', :x => 0, :y => 0, :width => 200, :height => '120') {
-      #     svg.feGaussianBlur(:in => 'SourceAlpha', :stdDeviation => 4, :result => 'blur')
-      #     svg.feOffset(:in => 'blur', :dx => 4, :dy => 4, :result => 'offsetBlur')
-      #     svg.feSpecularLighting( :in => 'blur', :surfaceScale => 5, :specularConstant => '.75',
-      #                             :specularExponent => 20, 'lighting-color' => '#bbbbbb',
-      #                             :result => 'specOut') {
-      #       svg.fePointLight(:x => '-5000', :y => '-10000', :z => '20000')
-      #     }
-      #     
-      #     svg.feComposite(:in => 'specOut', :in2 => 'SourceAlpha', :operator => 'in', :result => 'specOut')
-      #     svg.feComposite(:in => 'sourceGraphic', :in2 => 'specOut', :operator => 'arithmetic',
-      #                     :k1 => 0, :k2 => 1, :k3 => 1, :k4 => 0, :result => 'litPaint')
-      #                     
-      #     svg.feMerge {
-      #       svg.feMergeNode(:in => 'offsetBlur')
-      #       svg.feMergeNode(:in => 'litPaint')
-      #     }
-      #   }
-      # }
-      
-      svg.polygon(:points => points_value, :fill => color.to_s, :stroke => color.to_s, :opacity => options[:opacity])
-    end
-  end
-end

data/lib/scruffy/graph_layers/average.rb

@@ -1,52 +0,0 @@
-module Scruffy
-  class AverageLayer < GraphLayer
-    def initialize(options = {})
-      super
-      
-      @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
-    end
-
-    protected
-      def generate_coordinates(options = {})
-        key_layer = points.find { |layer| layer.relevant_data? }
-        
-        options[:point_distance] = width / (key_layer.points.size - 1).to_f
-
-        coords = []
-
-        key_layer.points.each_with_index do |layer, idx|
-          sum, objects = points.inject([0, 0]) do |arr, elem|
-            if elem.relevant_data?
-              arr[0] += elem.points[idx]
-              arr[1] += 1
-            end
-            arr
-          end
-
-          average = sum / objects.to_f
-
-          x_coord = options[:point_distance] * idx
-
-          relative_percent = ((average == min_value) ? 0 : ((average - min_value) / (max_value - min_value).to_f))
-          y_coord = (height - (height * relative_percent))
-
-          coords << [x_coord, y_coord].join(',')
-        end
-
-        return coords
-      end
-    
-  end
-end

data/lib/scruffy/graph_layers/bar.rb

@@ -1,28 +0,0 @@
-module Scruffy
-  class BarLayer < GraphLayer
-    
-    def draw(svg, coords, options = {})
-      coords.each do |coord|
-        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 )
-      end
-    end
-
-    protected
-      def generate_coordinates(options = {})
-        @bar_width = (width / points.size) * 0.9
-        options[:point_distance] = (width - (width / points.size)) / (points.size - 1).to_f
-
-        coords = (0...points.size).map do |idx| 
-          x_coord = (options[:point_distance] * idx) + (width / points.size * 0.5)
-
-          relative_percent = ((points[idx] == min_value) ? 0 : ((points[idx] - min_value) / (max_value - min_value).to_f))
-          y_coord = (height - (height * relative_percent))
-          [x_coord, y_coord]
-        end
-        coords
-      end
-  end
-end

data/lib/scruffy/graph_layers/base.rb

@@ -1,120 +0,0 @@
-module Scruffy
-  # ==GraphLayer
-  #
-  # Author:: Brasten Sager
-  # Date:: August 5th, 2006
-  #
-  # GraphLayer contains the basic functionality needed by the various types of graphs.  The GraphLayer
-  # class is responsible holding layer information such as the title and data points.
-  #
-  # When the graph is rendered, the graph renderer calls GraphLayer#render.  GraphLayer#render sets up
-  # some standard information, and calculates the x,y coordinates of each data point.  The draw() method,
-  # which should have been overridden by the current instance, is then called.  The actual rendering of
-  # the graph takes place there.
-  #
-  # ====Create New Graph Types
-  #
-  # Assuming the information generated by GraphLayer is sufficient, you can create a new graph type
-  # simply by overriding the draw() method.  See GraphLayer#draw for arguments.
-  #
-  class GraphLayer
-    attr_accessor :title
-    attr_accessor :points
-    attr_accessor :height, :width
-    attr_accessor :min_value, :max_value
-    attr_accessor :preferred_color, :color
-    attr_accessor :opacity
-    attr_accessor :resolver
-    attr_accessor :complexity
-    attr_accessor :relevant_data
-
-    # Returns a new GraphLayer.
-    #
-    # Options:
-    # title::
-    # points:: Array of data points
-    # color:: Color used to render this graph, overrides theme color.
-    # 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
-    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 GraphLayer#draw.
-    #
-    # svg:: a Builder object used to create SVG code.
-    def render(svg, options = {})
-      setup_variables(options)
-      coords = generate_coordinates(options)
-      
-      draw(svg, coords, options)
-    end
-    
-    # The method called by GraphLayer#draw to render the graph.
-    #
-    # svg:: a Builder object to use for creating SVG code.
-    # coords:: An array of coordinates relating to the graph's data points.  ie: [[100, 120], [200, 140], [300, 40]]
-    # options:: Optional arguments.
-    def draw(svg, coords, options={})
-      # This is what the various graphs need to implement.
-    end
-    
-    # Returns the value of relevant_data
-    def relevant_data?
-      @relevant_data
-    end
-    
-    # The highest data point on this GraphLayer
-    def highest_point
-      points.sort.last
-    end
-    
-    # The lowest data point on this GraphLayer
-    def lowest_point
-      points.sort.first
-    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]
-        @complexity = options[:complexity]
-      end
-
-      def generate_coordinates(options = {}) # :nodoc:
-        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))
-
-          [x_coord, y_coord]
-        end
-        
-        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)
-      end
-
-      def stringify_coords(coords) # :nodoc:
-        coords.map { |c| c.join(',') }
-      end
-  end
-end

data/lib/scruffy/graph_layers/blue_screen.rb

@@ -1,7 +0,0 @@
-module Scruffy
-  class BlueScreenLayer < GraphLayer
-    def draw(svg, coords, options={})
-      svg.image('xlink:href' => 'http://www.nagilum.com/images/logo-large.png', :width => width, :height => height)
-    end
-  end
-end

data/lib/scruffy/graph_layers/line.rb

@@ -1,11 +0,0 @@
-module Scruffy
-  class LineLayer < GraphLayer
-    def draw(svg, coords, options={})
-      svg.polyline( :points => stringify_coords(coords).join(' '), :fill => 'none', 
-                    :stroke => color.to_s, 'stroke-width' => scaled(4) )
-
-      coords.each { |coord| svg.circle( :cx => coord.first, :cy => coord.last, :r => scaled(5), 
-                                        :fill => color.to_s ) }
-    end
-  end
-end