scruffy 0.2.0 → 0.2.1

data/lib/scruffy/layers/bar.rb

@@ -1,30 +1,43 @@
-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)
+module Scruffy::Layers
+  # ==Scruffy::Layers::Bar
+  #
+  # Author:: Brasten Sager
+  # Date:: August 6th, 2006
+  #
+  # Standard bar graph.  
+  class Bar < Base
+  
+    # Draw bar graph.
+    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, 'style' => "opacity: #{opacity}" )
-        end
+        svg.rect( :x => x, :y => y, :width => @bar_width, :height => bar_height, 
+                  :fill => color.to_s, 'style' => "opacity: #{opacity}; stroke: none;" )
       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
+    protected
+    
+      # Due to the size of the bar graph, X-axis coords must 
+      # be squeezed so that the bars do not hang off the ends
+      # of the graph.
+      #
+      # Unfortunately this just mean that bar-graphs and most other graphs
+      # end up on different points.  Maybe adding a padding to the coordinates
+      # should be a graph-wide thing?
+      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)
+        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
+          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
-    end
+        coords
+      end
   end
 end

data/lib/scruffy/layers/base.rb

@@ -1,144 +1,156 @@
-module Scruffy
-  # ==Scruffy::Layers
+module Scruffy::Layers
+  # ==Scruffy::Layers::Base
   #
   # Author:: Brasten Sager
-  # Date:: August 10th, 2006
+  # Date:: August 5th, 2006
   #
-  # See documentation in Scruffy::Layers::Base
+  # 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.
   #
-  module Layers
-    # ==Scruffy::Layers::Base
-    #
-    # Author:: Brasten Sager
-    # Date:: August 5th, 2006
+  # 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
+    # The following attributes are user-definable at any time.
+    # title, points, relevant_data, preferred_color, options
+    attr_accessor :title
+    attr_accessor :points
+    attr_accessor :relevant_data
+    attr_accessor :preferred_color
+    attr_accessor :options          # On-the-fly values for easy customization / acts as attributes.
+    
+    # The following attributes are set during the layer's render process,
+    # and act more as a record of what just happened for later processes.
+    # height, width, min_value, max_value, color, opacity, complexity
+    attr_reader :height, :width
+    attr_reader :min_value, :max_value
+    attr_reader :color
+    attr_reader :opacity
+    attr_reader :complexity
+
+    # Returns a new Base object.
     #
-    # 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.
+    # Any options other that those specified below are stored in the @options variable for
+    # possible later use.  This would be a good place to store options needed for a custom
+    # graph.
     #
-    # 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.
+    # Options:
+    # title:: Name/title of data group
+    # points:: Array of data points
+    # preferred_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.delete(:title) || ''
+      @points             = options.delete(:points) || []
+      @preferred_color    = options.delete(:preferred_color)
+      @relevant_data      = options.delete(:relevant_data) || true
+      @options            = options
+    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.
     #
-    # ====Create New Graph Types
+    # 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={})
+      raise RenderError, "You must override the Base#draw method."
+    end
+  
+    # Returns a hash with information to be used by the legend.
     #
-    # 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.
+    # 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?)
     #
-    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
-      attr_accessor :options          # On-the-fly values for easy customization / acts as attributes.
-
-      # 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.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.
-      # 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 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, or nil if relevant_data == false
-      def top_value
-        @relevant_data ? points.sort.last : nil
-      end
-    
-      # The lowest data point on this layer, or nil if relevant_data == false
-      def bottom_value
-        @relevant_data ? points.sort.first: nil
+    # 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, or nil if relevant_data == false
+    def top_value
+      @relevant_data ? points.sort.last : nil
+    end
+  
+    # 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))
-          @width, @height = options.delete(:size)
-          @min_value, @max_value = options[:min_value], options[:max_value]
-          @opacity = options[:opacity] || 1.0
-          @complexity = options[:complexity]
-        end
+    protected
+      # Sets up several variables that almost every graph layer will need to render
+      # itself.
+      def setup_variables(options = {})
+        @color = (preferred_color || options.delete(:color))
+        @width, @height = options.delete(:size)
+        @min_value, @max_value = options[:min_value], options[:max_value]
+        @opacity = options[:opacity] || 1.0
+        @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
+      # Optimistic generation of coordinates for layer to use.  These coordinates are
+      # just a best guess, and can be overridden or thrown away (for example, this is overridden
+      # 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))
+          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
+          [x_coord, y_coord]
         end
       
-        # Converts a percentage into a pixel value, related to the height.
-        def relative(pct)
-          @height * (pct / 100.to_f)
-        end
+        coords
+      end
+    
+      # Converts a percentage into a pixel value, relative to the height.
+      #
+      # 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)
+      end
 
-        def stringify_coords(coords) # :nodoc:
-          coords.map { |c| c.join(',') }
-        end
-    end
+      # Some SVG elements take a long string of multiple coordinates.  This is here
+      # to make that a little easier.
+      def stringify_coords(coords) # :nodoc:
+        coords.map { |c| c.join(',') }
+      end
   end
-end
+
+end # scruffy::layers

data/lib/scruffy/layers/line.rb

@@ -1,13 +1,19 @@
-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' => relative(2) )
+module Scruffy::Layers
+  # ==Scruffy::Layers::Line
+  #
+  # Author:: Brasten Sager
+  # Date:: August 7th, 2006
+  #
+  # Line graph.
+  class Line < Base
+    
+    # Renders line graph.
+    def draw(svg, coords, options={})
+      svg.polyline( :points => stringify_coords(coords).join(' '), :fill => 'none', 
+                    :stroke => color.to_s, 'stroke-width' => relative(2) )
 
-        coords.each { |coord| svg.circle( :cx => coord.first, :cy => coord.last, :r => relative(2.5), 
-                                          :fill => color.to_s ) }
-      end
+      coords.each { |coord| svg.circle( :cx => coord.first, :cy => coord.last, :r => relative(2.5), 
+                                        :fill => color.to_s ) }
     end
   end
 end

data/lib/scruffy/layers/sparkline_bar.rb

@@ -0,0 +1,38 @@
+module Scruffy
+  module Layers
+    # Experimental, do not use.
+    class SparklineBar < Base
+    
+      def draw(svg, coords, options = {})
+        zero_point = @height / 2.0
+
+        coords.each do |coord|
+          x, y, bar_height = (coord.first-(@bar_width * 0.5)), coord.last, (height - coord.last)
+
+          bar_color = (y > zero_point) ? 'black' : 'red'
+          bar_height = (bar_height - zero_point)
+          
+          #y = (bar_height < 0) ? 
+
+          # svg.rect( :x => x, :y => zero_point, :width => @bar_width, :height => , 
+          #           :fill => bar_color, :stroke => 'none', 'style' => "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/stacked.rb

@@ -1,75 +1,90 @@
-module Scruffy
-  module Layers
-    class Stacked < Base
-      include Scruffy::Helpers::LayerContainer
-      
-      def initialize(options={}, &block)
-        super(options)
+module Scruffy::Layers
+  # ==Scruffy::Layers::Stacked
+  #
+  # Author:: Brasten Sager
+  # Date:: August 12th, 2006
+  #
+  # Provides a generic way for stacking graphs.  This may or may not
+  # do what you'd expect under every situation, but it at least kills
+  # a couple birds with one stone (stacked bar graphs and stacked area
+  # graphs work fine).
+  class Stacked < Base
+    include Scruffy::Helpers::LayerContainer
+    
+    # Returns new Stacked graph.
+    #
+    # You can provide a block for easily adding layers during (just after) initialization.
+    # Example:
+    #   Stacked.new do |stacked|
+    #     stacked << Scruffy::Layers::Line.new( ... )
+    #     stacked.add(:bar, 'My Bar', [...])
+    #   end
+    #
+    # The initialize method passes itself to the block, and since stacked is a LayerContainer,
+    # layers can be added just as if they were being added to Graph.
+    def initialize(options={}, &block)
+      super(options)
 
-        block.call(self)    # Allow for population of data with a block during initialization.
-      end
+      block.call(self)    # Allow for population of data with a block during initialization.
+    end
+    
+    # Overrides Base#render to fiddle with layers' points to achieve a stacked effect.
+    def render(svg, options = {})
+      current_points = points.dup
       
-      # 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
         
-        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
+        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
+    # 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
 
-      # The highest data point on this layer, or nil if relevant_data == false
-      def top_value
-        @relevant_data ? points.sort.last : nil
+    # 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
-    
-      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
+      
+      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
-
-        summed_points
       end
 
-      def points=(val)
-        throw ArgumentsError, "Stacked layers cannot accept points, only other layers."
-      end
+      summed_points
+    end
+
+    def points=(val)
+      throw ArgumentsError, "Stacked layers cannot accept points, only other layers."
     end
   end
 end