scruffy 0.0.9

data/CHANGES

@@ -0,0 +1,11 @@
+= Scruffy Changelog
+
+== Version 0.0.9
+(August 10th, 2006)
+
+* Initial release.
+* Standard renderer.
+* Marker transformers: currency, percentages.
+* Basic Graphs: Area, Bar, Line.
+* Advanced Graphs: Average, AllSmiles.
+* Initial documentation.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 Brasten Sager (brasten@nagilum.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,9 @@
+==Scruffy Graphs
+
+Author:: Brasten Sager (brasten@nagilum.com)
+Date:: August 5th, 2006
+
+Scruffy is a Ruby library for generating high quality, good looking graphs.  It is designed
+to be easy to use and highly customizable.
+
+For basic usage instructions, refer to the documentation for Scruffy::Graph.

data/Rakefile

@@ -0,0 +1,103 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'lib/scruffy'
+require 'spec'
+require 'diff/lcs'
+require 'spec/rake/spectask'
+
+PKG_NAME = "scruffy"
+PKG_VERSION   = Scruffy::VERSION
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+PKG_FILES = FileList[
+  '[A-Z]*',
+  'lib/**/*.rb', 
+  'spec/**/*.rb'
+]
+
+desc 'Runs all RSpec specs - translated with test2spec from our own tests'
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Deploy docs to RubyForge" 
+task :rdoc_deploy => [:rdoc] do
+  dirs = %w{doc}
+  onserver = "brasten@rubyforge.org:/var/www/gforge-projects/scruffy" 
+  dirs.each do | dir|
+    `scp -r "#{`pwd`.chomp}/#{dir}" "#{onserver}"`
+  end
+end
+
+# Genereate the RDoc documentation
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "Scruffy - Graphing Library for Ruby"
+#  rdoc.options << '--line-numbers --inline-source --main README --accessor adv_attr_accessor=M'
+#  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  rdoc.rdoc_files.include('README', 'CHANGELOG')
+  rdoc.rdoc_files.include('lib/scruffy.rb')
+  rdoc.rdoc_files.include('lib/scruffy/*.rb')
+  rdoc.rdoc_files.include('lib/scruffy/graph_layers/*.rb')
+  rdoc.rdoc_files.include('lib/scruffy/renderers/*.rb')
+}
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.author = "Brasten Sager" 
+  s.email = "brasten@nagilum.com"
+  s.homepage = "http://scruffy.rubyforge.org"
+  s.summary = "A powerful, clean graphing library for Ruby."
+  s.description = <<-EOF
+    Scruffy is a Ruby library for generating powerful graphs.  It is based on
+    SVG, allowing for powerful, clean code, as well as a good foundation for
+    future features.
+  EOF
+
+  s.files = PKG_FILES.to_a
+  s.require_path = 'lib'
+
+  s.has_rdoc = true
+
+  #s.test_files = Dir.glob('test/*_test.rb')
+  s.require_path = 'lib'
+  s.autorequire = 'scruffy'
+  s.rubyforge_project = "scruffy"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+task :verify_user do
+  raise "RUBYFORGE_USER environment variable not set!" unless ENV['RUBYFORGE_USER']
+end
+
+task :verify_password do
+  raise "RUBYFORGE_PASSWORD environment variable not set!" unless ENV['RUBYFORGE_PASSWORD']
+end
+
+desc "Publish gem+tgz+zip on RubyForge. You must make sure lib/version.rb is aligned with the CHANGELOG file"
+task :publish_packages => [:verify_user, :verify_password, :package] do
+  require 'meta_project'
+  require 'rake/contrib/xforge'
+  release_files = FileList[
+    "pkg/#{PKG_FILE_NAME}.gem",
+    "pkg/#{PKG_FILE_NAME}.tgz",
+    "pkg/#{PKG_FILE_NAME}.zip"
+  ]
+
+  Rake::XForge::Release.new(MetaProject::Project::XForge::RubyForge.new(PKG_NAME)) do |xf|
+    # Never hardcode user name and password in the Rakefile!
+    xf.user_name = ENV['RUBYFORGE_USER']
+    xf.password = ENV['RUBYFORGE_PASSWORD']
+    xf.files = release_files.to_a
+    xf.release_name = "Scruffy #{PKG_VERSION}"
+  end
+end

data/lib/scruffy.rb

@@ -0,0 +1,23 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+  
+require 'rubygems'
+require_gem 'builder', '>= 2.0'
+
+# Base files
+require 'scruffy/graph'
+require 'scruffy/themes'
+require 'scruffy/version'
+require 'scruffy/transformer'
+
+# 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'
+
+# Renderers
+require 'scruffy/renderers/standard'

data/lib/scruffy/graph.rb

@@ -0,0 +1,182 @@
+# ===Scruffy Graphing Library for Ruby
+#
+# Author:: Brasten Sager
+# Date:: August 5th, 2006
+#
+# For information on generating graphs using Scruffy, see the
+# documentation in Scruffy::Graph.
+#
+# For information on creating your own graph types, see the
+# documentation in Scruffy::GraphLayer.
+module Scruffy
+  
+  # ==Scruffy Graphs
+  #
+  # Author:: Brasten Sager
+  # Date:: August 5th, 2006
+  #
+  #
+  # ====Graphs vs. Layers (Graph Types)
+  #
+  # 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)
+  # Despite the technical distinction, we will refer to Scruffy::Graph objects as 'graphs' and Scruffy::GraphLayers as
+  # 'layers' or 'graph types.'
+  #
+  #
+  # ==== Creating a Graph
+  #
+  # You can begin building a graph by instantiating a Graph object and optionally passing a hash
+  # of properties.
+  #
+  #   graph = Scruffy::Graph.new
+  #
+  #   OR
+  #
+  #   graph = Scruffy::Graph.new(:title => "Monthly Profits", :theme => Scruffy::Theme::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
+  # methods are identical and used to accommodate syntax preferences.
+  #
+  #   graph.add(:line, 'John', [100, -20, 30, 60])
+  #   graph.add(:line, 'Sara', [120, 50, -80, 20])
+  #
+  #   OR
+  #
+  #   graph << Scruffy::LineLayer.new(:title => 'John', :points => [100, -20, 30, 60])
+  #   graph << Scruffy::LineLayer.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:
+  #
+  #   graph.render    # Renders a 600x400 SVG graph
+  #
+  #   OR
+  #
+  #   graph.render(:size => [1500, 1000])
+  #
+  # And that's your basic Scruffy graph!  Please check the documentation for the various methods and
+  # classes you'll be using, as there are a bunch of options not demonstrated here.
+  #
+  # A couple final things worth noting:
+  # * You can call Graph#render as often as you wish with different rendering options.  In
+  #   fact, you can modify the graph any way you wish between renders.
+  #
+  #
+  # * There are no restrictions to the combination of graph layers you can add.  It is perfectly
+  #   valid to do something like:
+  #     graph.add(:line, [100, 200, 300])
+  #     graph.add(:bar, [200, 150, 150])
+  #
+  #   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
+    attr_accessor :title
+    attr_accessor :theme
+    attr_accessor :layers
+    attr_accessor :default_type
+    attr_accessor :point_markers
+    attr_accessor :renderer
+    attr_accessor :marker_transformer
+    
+    # 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({...})    # New graph with options.
+    #
+    # Options:
+    #
+    # title::  Graph's title
+    # theme::  Theme to use when rendering 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
+    def initialize(*args)
+      @default_type   = args.shift if args.first.is_a?(Symbol)
+      options         = args.shift if args.first.is_a?(Hash)
+      options ||= {}
+      
+      @title = options[:title]
+      @theme = options[:theme] || Scruffy::Theme::KEYNOTE
+      @layers = []
+      @renderer = options[:renderer] || Scruffy::StandardRenderer.new
+      @marker_transformer = options[:marker_transformer]
+      @point_markers = options[:point_markers]
+    end
+    
+    # Renders the graph in it's current state to an SVG object.
+    #
+    # 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.
+    # 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.
+    #
+    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
+      
+      @renderer.render( options.merge({:size => size, :title => title,
+                                       :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
+    # 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 << BarLayer.new({...})   # Adds BarLayer object to graph
+    #
+    def <<(*args)
+      if args[0].kind_of?(Scruffy::GraphLayer)
+        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::#{to_camelcase(type.to_s)}Layer").new(options.merge({:points => points, :title => title}))
+        layers << layer
+      end
+      layer
+    end
+    
+    alias :add :<<
+    
+    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/graph_layers/all_smiles.rb

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

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

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

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

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

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

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

data/lib/scruffy/renderers/standard.rb

@@ -0,0 +1,132 @@
+module Scruffy
+  class StandardRenderer
+    GRAPH_VIEWPORT = { :x => 0.20, :y => 0.30, :width => 0.70, :height => 0.55 }
+    MARKER_ALIGNMENT = { :x => 0.17, :y => 0.31}
+    MARKERS = 5
+
+    def render(options = {})
+      title       = options[:title]
+      theme       = options[:theme]
+      layers      = options[:layers]
+      size        = options[:size]
+      graph_id    = options[:graph_id] || 'scruffy_graph'
+      
+      
+      options[:complexity] ||= (global_complexity || :normal)
+      options[:resolver] ||= Scruffy::Resolver.new(options[:size].last)
+
+      svg = Builder::XmlMarkup.new(:indent => 2)
+      svg.instruct!
+      svg.instruct! 'DOCTYPE', 'svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd"  type'
+      svg.svg(:xmlns => "http://www.w3.org/2000/svg", 'xmlns:xlink' => "http://www.w3.org/1999/xlink", :width => size[0], :height => size[1]) {
+        svg.g(:id => graph_id) {
+          render_background(svg, options)
+          render_markers(svg, options)
+          render_title(svg, options)
+          render_layers(svg, options)
+          
+        }
+      }
+      svg.target!
+    end
+    
+    protected
+      def render_background(svg, options)
+        fill = "#EEEEEE"
+        case options[:theme][:background]
+        when Symbol, String
+          fill = options[:theme][:background].to_s
+        when Array
+          fill = "url(#BackgroundGradient)"
+          svg.defs {
+            svg.linearGradient(:id=>'BackgroundGradient', :x1 => '0%', :y1 => '0%', :x2 => '0%', :y2 => '100%') {
+              svg.stop(:offset => '5%', 'stop-color' => options[:theme][:background][0])
+              svg.stop(:offset => '95%', 'stop-color' => options[:theme][:background][1])
+            }
+          }
+        when Proc
+          theme[:background].call(svg, options)
+          fill = nil
+        end
+        
+        # Render background (maybe)
+        svg.rect(:width => "100%", :height => "100%", :x => "0", :y => "0", :fill => fill) unless fill.nil?
+      end
+      
+      def render_layers(svg, options)
+        svg.g(:id => 'graphs', :transform => "translate(#{GRAPH_VIEWPORT[:x] * options[:size][0]},#{GRAPH_VIEWPORT[:y] * options[:size][1]})") {
+          options[:layers].each_with_index do |layer, idx|
+
+            layer_options = {}
+            layer_options[:index] = idx
+            layer_options[:color] = options[:theme][:colors].values[ (idx % options[:theme][:colors].size) ]
+            layer_options[:size]  = [ GRAPH_VIEWPORT[:width] * options[:size][0], GRAPH_VIEWPORT[:height] * options[:size][1] ]
+            layer_options[:min_value] = options[:min_value]
+            layer_options[:max_value] = options[:max_value]
+            layer_options[:opacity] = (idx > 0) ? 0.6 : 1.0
+            layer_options[:resolver] = options[:resolver]
+            layer_options[:complexity] = options[:complexity]
+            layer_options[:theme] = options[:theme]
+
+            # puts options[:theme][:colors].values
+            # puts layer_options[:color]
+            # puts "#{idx} : #{options[:layers].size} == #{idx % options[:layers].size}"
+
+            svg.g {
+              layer.render(svg, layer_options)
+            }
+          end
+        }
+      end
+      
+      def render_markers(svg, options)
+        svg.g(:id => 'markers', :transform => "translate(#{GRAPH_VIEWPORT[:x] * options[:size][0]},#{GRAPH_VIEWPORT[:y] * options[:size][1]})") {
+          (0...MARKERS).each do |idx|
+            marker = ((1 / (MARKERS - 1).to_f) * idx) * (options[:size].last * GRAPH_VIEWPORT[:height])
+            svg.line(:x1 => 0, :y1 => marker, :x2 => (GRAPH_VIEWPORT[:width] * options[:size].first), :y2 => marker, :style => "stroke: #{options[:theme][:marker].to_s}; stroke-width: #{options[:resolver].to_point(2)};")
+          end
+        }
+
+        svg.g(:id => 'marker-values', :transform => "translate(#{MARKER_ALIGNMENT[:x] * options[:size][0]},#{MARKER_ALIGNMENT[:y] * options[:size][1]})") {
+          (0...MARKERS).each do |idx|
+            marker = ((GRAPH_VIEWPORT[:height]) * options[:size].last) - ((1 / (MARKERS - 1).to_f) * idx) * (options[:size].last * GRAPH_VIEWPORT[:height])
+            marker_value = (options[:max_value] - options[:min_value]) * ((1 / (MARKERS - 1).to_f) * idx) + options[:min_value]
+            marker_value = options[:marker_transformer].route_transform(marker_value, idx, options) if options[:marker_transformer]
+            
+            svg.text(marker_value.to_s, :x => 0, :y => marker, :style => "font-size: #{options[:resolver].to_point(18)}px; fill: #{((options.delete(:marker_color_override) || options[:theme][:marker]) || 'white').to_s}; text-anchor: end;")
+          end
+        }
+
+        unless options[:point_markers].nil?
+          svg.g(:id => 'point-markers', :transform => "translate(#{GRAPH_VIEWPORT[:x] * options[:size][0]},#{(GRAPH_VIEWPORT[:y] + GRAPH_VIEWPORT[:height]) * options[:size][1]})") {
+            point_distance = (options[:size].first * GRAPH_VIEWPORT[:width]) / (options[:point_markers].size - 1).to_f
+
+            (0...options[:point_markers].size).map do |idx| 
+              x_coord = point_distance * idx
+              svg.text(options[:point_markers][idx], :x => x_coord, :y => options[:resolver].to_point(20), 
+                       'font-size' => options[:resolver].to_point(16), 
+                       :fill => (options[:theme][:marker] || 'white').to_s, 
+                       'text-anchor' => 'middle') unless options[:point_markers][idx].nil?
+            end
+          }
+        end
+      end
+      
+      def render_title(svg, options)
+        svg.g(:transform => "translate(0, #{options[:size][1] * 0.09})") {
+          svg.text( options[:title], :x => options[:size][0] / 2, :y => 0, 
+                    'font-size' => options[:resolver].to_point(28), 'text-anchor' => 'middle', 
+                    :fill => 'white')
+        }
+      end
+      
+    private
+      def global_complexity
+        if Kernel.const_defined? "SCRUFFY_COMPLEXITY"
+          SCRUFFY_COMPLEXITY
+        else
+          nil
+        end
+      end
+  end
+end

data/lib/scruffy/resolver.rb

@@ -0,0 +1,14 @@
+module Scruffy
+  class Resolver
+    BASE_SIZE = 400
+    attr_accessor :actual_size
+    
+    def initialize(actual_size)
+      @actual_size = actual_size
+    end
+    
+    def to_point(size)
+      actual_size * (size / BASE_SIZE.to_f)
+    end
+  end
+end

data/lib/scruffy/themes.rb

@@ -0,0 +1,26 @@
+module Scruffy
+  module Theme
+    KEYNOTE = {
+      :background => [:black, '#4A465A'],
+      :marker => :white, 
+      :colors => {:blue => '#6886B4',
+                  :green => '#72AE6E', :red => '#D1695E', 
+                  :purple => '#8A6EAF', :orange => '#EFAA43'}
+      }
+      
+      
+    MEPHISTO = {
+      :background => ['#101010', '#999977'],
+      :marker => :white,
+      :colors => {:orange => '#DD3300', :blue => '#66AABB', :green => '#225533',
+                  :red => '#992200'}
+    }
+    
+    RUBY_BLOG = {
+      :background => ['#670A0A', '#831515'],
+      :marker => '#DBD1C1',
+      :colors => {:teal => '#007777', :purple => '#444477', :pink => '#994444',
+        :green => '#77FFBB', :orange => '#D75A20'}
+    }
+  end
+end

data/lib/scruffy/transformer.rb

@@ -0,0 +1,73 @@
+module Scruffy
+  module Transformer
+    class Base
+      def route_transform(target, idx, options = {})
+        args = [target, idx, options]
+        if respond_to?(:transform)
+          send :transform, *args[0...self.method(:transform).arity]
+        elsif respond_to?(:transform!)
+          send :transform!, *args[0...self.method(:transform).arity]
+          target
+        else
+          raise NameError, "Transformer subclass must container either a transform() method or transform!() method."
+        end
+      end
+
+      protected
+        def number_with_precision(number, precision=3)
+          sprintf("%01.#{precision}f", number)
+        end
+    end
+    
+    class Currency < Base
+      def initialize(options = {})
+        @precision        = options[:precision] || 2
+        @unit             = options[:unit] || '$'
+        @separator        = options[:separator] || '.'
+        @delimiter        = options[:delimiter] || ','
+        @negative_color   = options[:negative_color]
+        @special_negatives = options[:special_negatives] || false
+      end
+      
+      def transform(target, idx, options)
+        @separator = "" unless @precision > 0
+        begin
+          parts = number_with_precision(target, @precision).split('.')
+          if @special_negatives && (target.to_f < 0)
+            number = "(" + @unit + parts[0].to_i.abs.to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{@delimiter}") + @separator + parts[1].to_s + ")"
+          else
+            number = @unit + parts[0].to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{@delimiter}") + @separator + parts[1].to_s
+          end
+          if (target.to_f < 0) && @negative_color
+            options[:marker_color_override] = @negative_color
+          end
+          number
+        rescue
+          target
+        end
+      end
+    end
+    
+    class Percentage < Base
+      def initialize(options = {})
+        @precision    = options[:precision] || 3
+        @separator    = options[:separator] || '.'
+      end
+      
+      def transform(target)
+        begin
+          number = number_with_precision(target, @precision)
+          parts = number.split('.')
+          if parts.at(1).nil?
+            parts[0] + "%"
+          else
+            parts[0] + @separator + parts[1].to_s + "%"
+          end
+        rescue
+          target
+        end
+      end
+    end
+    
+  end
+end

data/lib/scruffy/version.rb

@@ -0,0 +1,3 @@
+module Scruffy
+  VERSION = '0.0.9'
+end

data/spec/graph_spec.rb

@@ -0,0 +1,56 @@
+require 'lib/scruffy'
+
+context "A new Scruffy::Graph" do
+  setup do
+    @graph = Scruffy::Graph.new
+  end
+  
+  specify "should have a blank title" do
+    @graph.title.should_be.nil
+  end
+  
+  specify "should be set to the keynote theme" do
+    @graph.theme.should_equal Scruffy::Theme::KEYNOTE
+  end
+  
+  specify "should have zero layers" do
+    @graph.should_have(0).layers
+  end
+  
+  specify "should not have a default layer type" do
+    @graph.default_type.should_be.nil
+  end
+  
+  specify "should not have any point markers (x-axis values)" do
+    @graph.point_markers.should_be.nil
+  end
+  
+  specify "should not have a marker transformer" do
+    @graph.marker_transformer.should_be.nil
+  end
+  
+  specify "should use a StandardRenderer" do
+    @graph.renderer.should_be_instance_of Scruffy::StandardRenderer
+  end
+  
+  specify "should accept a new title" do
+    @graph.title = "New Title"
+    @graph.title.should_equal "New Title"
+  end
+  
+  specify "should accept a new theme" do
+    @graph.theme = Scruffy::Theme::MEPHISTO
+    @graph.theme.should_equal Scruffy::Theme::MEPHISTO
+  end
+  
+  specify "should accept a new default type" do
+    @graph.default_type = :line
+    @graph.default_type.should_equal :line
+  end
+  
+  specify "should accept new point markers" do
+    markers = ['Jan', 'Feb', 'Mar']
+    @graph.point_markers = markers
+    @graph.point_markers.should_equal markers
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: scruffy
+version: !ruby/object:Gem::Version 
+  version: 0.0.9
+date: 2006-08-10 00:00:00 -07:00
+summary: A powerful, clean graphing library for Ruby.
+require_paths: 
+- lib
+email: brasten@nagilum.com
+homepage: http://scruffy.rubyforge.org
+rubyforge_project: scruffy
+description: Scruffy is a Ruby library for generating powerful graphs.  It is based on SVG, allowing for powerful, clean code, as well as a good foundation for future features.
+autorequire: scruffy
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Brasten Sager
+files: 
+- CHANGES
+- MIT-LICENSE
+- Rakefile
+- README
+- lib/scruffy.rb
+- lib/scruffy/graph.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/renderers/standard.rb
+- spec/graph_spec.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+