ramhoj-scruffy 0.2.6

data/lib/scruffy/graph_state.rb

@@ -0,0 +1,24 @@
+# ===GraphState
+#
+# Author:: Brasten Sager
+# Date:: September 27th, 2007
+#
+# State object for holding all of the graph's
+# settings.  Attempting to clean up the
+# graph interface a bit.
+
+module Scruffy
+  class GraphState
+
+    attr_accessor :title
+    attr_accessor :theme
+    attr_accessor :default_type
+    attr_accessor :point_markers
+    attr_accessor :value_formatter
+    attr_accessor :rasterizer
+    
+    def initialize
+      
+    end
+  end
+end

data/lib/scruffy/helpers.rb

@@ -0,0 +1,12 @@
+# ==Scruffy Helpers
+#
+# Author:: Brasten Sager
+# Date:: August 16th, 2006
+#
+# Modules which provide helper methods for various situations.
+module Scruffy::Helpers; end
+
+require 'scruffy/helpers/canvas'
+require 'scruffy/helpers/layer_container'
+require 'scruffy/helpers/point_container'
+#require 'scruffy/helpers/meta'

data/lib/scruffy/helpers/canvas.rb

@@ -0,0 +1,41 @@
+module Scruffy::Helpers
+  
+  # ==Scruffy::Helpers::Canvas
+  # 
+  # Author:: Brasten Sager
+  # Date:: August 16th, 2006
+  # 
+  # Provides common methods for canvas objects.  Primarily used for providing
+  # spacial-type calculations where necessary.
+  module Canvas
+    attr_accessor :components
+    
+    def reset_settings!
+      self.options = {}
+    end
+    
+    def component(id, components=self.components)
+      components.find {|elem| elem.id == id}
+    end
+    
+    def remove(id, components=self.components)
+      components.delete(component(id))
+    end
+    
+    protected
+    # Converts percentage values into actual pixel values based on the known
+    # render size.
+    # 
+    # Returns a hash consisting of :x, :y, :width, and :height elements.
+    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 # canvas
+  
+end # scruffy::helpers

data/lib/scruffy/helpers/layer_container.rb

@@ -0,0 +1,95 @@
+module Scruffy::Helpers
+  
+  # ==Scruffy::Helpers::LayerContainer
+  #
+  # Author:: Brasten Sager
+  # Date:: August 16th, 2006
+  #
+  # Adds some common functionality to any object which needs to act as a
+  # container for graph layers.  The best example of this is the Scruffy::Graph
+  # object itself, but this module is also used by Scruffy::Layer::Stacked.
+  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)
+        
+        # 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?
+              
+        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
+    end
+    
+    alias :add :<<
+    
+
+    # Layer Writer
+    def layers=(val)
+      @layers = val
+    end
+    
+    # Layer Reader
+    def layers
+      @layers ||= []
+    end
+    
+    # Returns the highest value in any of this container's layers.
+    #
+    # If padding is set to :padded, a 15% padding is added to the highest value.
+    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
+  
+    # Returns the lowest value in any of this container's layers.
+    #
+    # If padding is set to :padded, a 15% padding is added below the lowest value.
+    # If the lowest value is greater than zero, then the padding will not cross the zero line, preventing
+    # negative values from being introduced into the graph purely due to padding.
+    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/helpers/meta.rb

@@ -0,0 +1,5 @@
+# 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

@@ -0,0 +1,24 @@
+# ==Scruffy::Layers
+#
+# Author:: Brasten Sager
+# Date:: August 10th, 2006
+#
+# See documentation in Scruffy::Layers::Base
+#
+module Scruffy::Layers
+
+  # Should be raised whenever a predictable error during rendering occurs,
+  # particularly if you do not want to terminate the graph rendering process.
+  class RenderError < StandardError; end
+  
+end
+
+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'
+require 'scruffy/layers/stacked'
+require 'scruffy/layers/pie'
+require 'scruffy/layers/pie_slice'

data/lib/scruffy/layers/all_smiles.rb

@@ -0,0 +1,137 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::AllSmiles
+  #
+  # Author:: Brasten Sager
+  # Date:: August 8th, 2006
+  #
+  # The AllSmiles graph consists of smiley faces for data points, with smiles or frowns depending upon
+  # their relative location on the graph.  The highest point is crowned with a wizard hat.  The Wizard
+  # Smiley eventually become 'Scruffy', our mascot.
+  #
+  # I don't know why.
+  #
+  # This graph only looks decent in SVG mode.  If you're rasterizing the graph with ImageMagick, you
+  # must use the :complexity => :minimal option on Graph#render.  This will make the graph look really
+  # nasty, but still better than if you try to rasterize with all the gradients in place.
+  class AllSmiles < Base
+    attr_accessor :standalone
+
+    # Returns a new AllSmiles graph.
+    #
+    # Options:
+    # standalone:: If set to true, dashed lines under smilies run vertically, like bar graphs.
+    #              If false (default), dashed lines run from smiley to smiley, like a line-graph.
+    def initialize(options = {})
+      super
+      @standalone = options[:standalone] || false
+    end
+  
+    # Renders graph.
+    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
+    
+      # Draw smilies.
+      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) )
+                
+      
+        # Some minor mathematics for the smile/frown
+        percent = 1.0 - (coord.last.to_f / height.to_f)
+        corners = scaled(8 - (5 * percent))
+        anchor  = scaled((20 * percent) - 5)
+        
+        # Draw the mouth
+        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' )
+                
+                
+        # Wizard hat for hero smiley.
+        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
+
+    # Legacy (4 days old).  Removed scaled from layout engine, 
+    # changed to #relative, with different math involved.
+    # Translate here so I don't have to entirely redo this graph.
+    def scaled(pt)
+      relative(pt) / 2
+    end
+  end
+end

data/lib/scruffy/layers/area.rb

@@ -0,0 +1,46 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::Area
+  #
+  # Author:: Brasten Sager
+  # Date:: August 6th, 2006
+  #
+  # Standard area graph.
+  class Area < Base
+    
+    # Render area graph.
+    def draw(svg, coords, options={})
+      # svg.polygon wants a long string of coords. 
+      points_value = "0,#{height} #{stringify_coords(coords).join(' ')} #{width},#{height}"
+
+      # Experimental, for later user.
+      # This was supposed to add some fun filters, 3d effects and whatnot.
+      # 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') {
+      #     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.g(:transform => "translate(0, -#{relative(2)})") {
+        svg.polygon(:points => points_value, :style => "fill: black; stroke: black; fill-opacity: 0.06; stroke-opacity: 0.06;")
+      }
+
+      svg.polygon(:points => points_value, :fill => color.to_s, :stroke => color.to_s, 'style' => "opacity: #{opacity}")
+    end
+  end
+end