srawlins-scruffy 0.2.9

data/lib/scruffy/rasterizers.rb

@@ -0,0 +1,14 @@
+# ===Scruffy Rasterizers
+#
+# Author:: Brasten Sager
+# Date:: August 10th, 2006
+#
+# These handle the job of rasterizing SVG images to other image formats.
+# At the moment, only RMagickRasterizer exists, but others may soon follow.
+#
+# I'm somewhat interesting in finding a way to integrate Apache Batik, as it's
+# SVG rendering seems to be superior to ImageMagick's.
+module Scruffy::Rasterizers; end
+
+require 'scruffy/rasterizers/rmagick_rasterizer.rb'
+require 'scruffy/rasterizers/batik_rasterizer.rb'

data/lib/scruffy/rasterizers/batik_rasterizer.rb

@@ -0,0 +1,39 @@
+module Scruffy::Rasterizers
+  # == Scruffy::Rasterizers::BatikRasterizer
+  #
+  # Author:: Brasten Sager
+  # Date:: August 14th, 2006
+  #
+  # Purely experimental.  Can be used to rasterize SVG graphs with
+  # Apache Batik.
+  class BatikRasterizer
+    # Returns new BatikRasterizer.
+    #
+    # Options:
+    # command:: Command needed to execute Batik. (ie: 'java -classpath {...}')
+    # temp_folder:: Folder for storing temporary files being passed between Scruffy and Batik.
+    def initialize(options={})
+      @command = options[:command]
+      @temp_folder = options[:temp_folder]
+    end
+    
+    # Rasterize graph.
+    #
+    # Options:
+    # as:: Image format to generate (PNG, JPG, et al.)
+    def rasterize(svg, options={})
+      File.open(@temp_folder + '/temp_svg.svg', 'w') { |file|
+        file.write(svg)
+      }
+      
+      `#{@command} -d #{@temp_folder} -m image/#{options[:as].downcase} #{@temp_folder}/temp_svg.svg`
+      
+      image = ""
+      File.open(@temp_folder + '/temp_svg.' + options[:as].downcase, 'r') { |file|
+        image = file.read
+      }
+      
+      image
+    end
+  end
+end

data/lib/scruffy/rasterizers/rmagick_rasterizer.rb

@@ -0,0 +1,27 @@
+module Scruffy::Rasterizers
+
+  # == RMagickRasterizer
+  #
+  # Author:: Brasten Sager
+  # Date:: August 14th, 2006
+  #
+  # The RMagickRasterizer converts SVG graphs to images using ImageMagick.
+  class RMagickRasterizer
+    def rasterize(svg, options={})
+      # I know this seems weird, I'm open to suggestions.
+      # I didn't want RMagick required unless absolutely necessary.
+      require 'RMagick'
+
+      image = Magick::Image::from_blob(svg)[0]
+
+      # Removed for now
+      # image.resize!(options[:size][0], options[:size][1], Magick::BoxFilter, 1.25) if options[:actual_size]
+
+      if options[:to]
+        image.write(options[:to]) { self.format = options[:as] }
+      end
+
+      image.to_blob { self.format = options[:as] }
+    end
+  end
+end

data/lib/scruffy/renderers.rb

@@ -0,0 +1,24 @@
+# ===Scruffy Renderers
+#
+# Author:: Brasten Sager
+# Date:: August 14th, 2006
+#
+# Renderers piece the entire graph together from a collection
+# of components.  Creating new renderers allows you to create
+# entirely new layouts for your graphs.
+#
+# Scruffy::Renderers::Base contains the basic functionality needed
+# by a layout.  The easiest way to create a new layout is by subclassing
+# Base.
+module Scruffy::Renderers; end
+
+require 'scruffy/renderers/base'
+require 'scruffy/renderers/empty'
+require 'scruffy/renderers/standard'
+require 'scruffy/renderers/axis_legend'
+require 'scruffy/renderers/legend_to_right'
+require 'scruffy/renderers/reversed'
+require 'scruffy/renderers/cubed'
+require 'scruffy/renderers/split'
+require 'scruffy/renderers/cubed3d'
+require 'scruffy/renderers/pie'

data/lib/scruffy/renderers/base.rb

@@ -0,0 +1,95 @@
+require 'builder'
+module Scruffy::Renderers
+  # ===Scruffy::Renderers::Base
+  #
+  # Author:: Brasten Sager
+  # Date:: August 14th, 2006
+  #
+  # Provides all the base functionality needed to render a graph, but
+  # does not provide a default layout.
+  #
+  # For a basic layout, see Scruffy::Renderers::Standard.
+  class Base
+    include Scruffy::Helpers::Canvas
+    
+    attr_accessor :options
+
+    def initialize(options = {})
+      self.components = []
+      self.options = options
+      define_layout
+    end
+
+    # Renders the graph and all components.
+    def render(options = {})
+      options[:graph_id]    ||= 'scruffy_graph'
+      options[:complexity]  ||= (global_complexity || :normal)
+
+      # Allow subclasses to muck with components prior to renders.
+      rendertime_renderer = self.clone
+      rendertime_renderer.instance_eval { before_render if respond_to?(:before_render) }
+
+      svg = Builder::XmlMarkup.new(:indent => 2)
+      unless options[:no_doctype_header]
+        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'
+      end
+      svg.svg(:xmlns => "http://www.w3.org/2000/svg", 'xmlns:xlink' => "http://www.w3.org/1999/xlink", :width => options[:size].first, :height => options[:size].last) {
+        svg.g(:id => options[:graph_id]) {
+          rendertime_renderer.components.each do |component|
+            component.render(svg, 
+                             bounds_for( options[:size], component.position, component.size ), 
+                             options)
+          end
+        }
+      }
+      svg.target!
+    end
+    
+    def before_render
+      if self.options
+        set_values(self.options[:values])    if (self.options[:values] && self.options[:values] != :hide)
+        hide_grid     if (self.options[:grid] == :hide)
+        hide_values   if (self.options[:values] == :hide)
+        hide_labels   if (self.options[:labels] == :hide)
+      end
+    end
+    
+    def method_missing(sym, *args)
+      self.options = {} if self.options.nil?
+      
+      if args.size > 0
+        self.options[sym] = args[0]
+      else
+        return self.options[sym]
+      end
+    end
+
+    protected
+      def hide_grid
+        grids.each { |grid| grid.visible = false }
+      end
+    
+      def set_values(val)
+        values.each { |value| value.markers = val }
+        grids.each { |grid| grid.markers = val }
+      end
+    
+      def hide_values
+        values.each { |value| value.visible = false }
+      end
+    
+      def hide_labels
+        labels.each { |label| label.visible = false }
+      end    
+
+    private
+      def global_complexity
+        if Kernel.const_defined? "SCRUFFY_COMPLEXITY"
+          SCRUFFY_COMPLEXITY
+        else
+          nil
+        end
+      end
+  end   # base
+end

data/lib/scruffy/renderers/cubed.rb

@@ -0,0 +1,44 @@
+module Scruffy::Renderers
+  # ===Scruffy::Renderers::Cubed
+  #
+  # Author:: Brasten Sager
+  # Date:: August 14th, 2006
+  #
+  # Graph layout consisting of four separate graphs arranged in a 2x2 grid.
+  class Cubed < Empty
+    VIEWPORT_SIZE = [35, 30]
+    VIEWPORTS     = { :top_left => [10, 25],
+                      :top_right => [55, 25],
+                      :bottom_left => [10, 65],
+                      :bottom_right => [55, 65] }
+    
+    # Returns a Cubed instance.
+    def define_layout
+      super do |components|
+        components << Scruffy::Components::Title.new(:title, :position => [5, 2], :size => [90, 7])
+                      
+        VIEWPORTS.each_pair do |category, position|
+          components << Scruffy::Components::Viewport.new(category, :position => position, 
+                                                          :size => VIEWPORT_SIZE, &graph_block(category))
+        end
+
+        components << Scruffy::Components::Legend.new(:legend, :position => [5, 13], :size => [90, 5])
+      end
+    end
+
+    private
+      # Returns a typical graph layout.
+      #
+      # These are squeezed into viewports.
+      def graph_block(graph_filter)
+        block = Proc.new { |components|
+          components << Scruffy::Components::Grid.new(:grid, :position => [10, 0], :size => [90, 89])
+          components << Scruffy::Components::ValueMarkers.new(:value_markers, :position => [0, 2], :size => [8, 89])
+          components << Scruffy::Components::DataMarkers.new(:data_markers, :position => [10, 92], :size => [90, 8])
+          components << Scruffy::Components::Graphs.new(:graphs, :position => [10, 0], :size => [90, 89], :only => graph_filter)
+        }
+        
+        block
+      end
+  end
+end

data/lib/scruffy/renderers/cubed3d.rb

@@ -0,0 +1,53 @@
+module Scruffy::Renderers
+  # ===Scruffy::Renderers::Cubed3d
+  #
+  # Author:: Brasten Sager
+  # Date:: August 17th, 2006
+  #
+  # A 3-dimensional cube effect.
+  class Cubed3d < Empty
+    VIEWPORT_SIZE = [25, 45]
+    VIEWPORTS     = { :top_left => [10, 25],
+                      :top_right => [55, 25],
+                      :bottom_left => [10, 65],
+                      :bottom_right => [55, 65] }
+    
+    # Returns a Cubed instance.
+    def define_layout
+      super do |components|
+        components << Scruffy::Components::Title.new(:title, :position => [5, 2], :size => [90, 7])
+                      
+        components << Scruffy::Components::Viewport.new(:one, :position => [10, 50], 
+                                                        :size => VIEWPORT_SIZE, :skewY => '-25', 
+                                                        &graph_block(:one))
+        components << Scruffy::Components::Viewport.new(:two, :position => [30, 50], 
+                                                        :size => VIEWPORT_SIZE, :skewY => '-25', 
+                                                        &graph_block(:two))
+        components << Scruffy::Components::Viewport.new(:three, :position => [50, 50], 
+                                                        :size => VIEWPORT_SIZE, :skewY => '-25', 
+                                                        &graph_block(:three))
+        components << Scruffy::Components::Viewport.new(:four, :position => [70, 50], 
+                                                        :size => VIEWPORT_SIZE, :skewY => '-25', 
+                                                        &graph_block(:four))
+
+
+        components << Scruffy::Components::Legend.new(:legend, :position => [5, 13], :size => [90, 5])
+      end
+    end
+
+    private
+      # Returns a typical graph layout.
+      #
+      # These are squeezed into viewports.
+      def graph_block(graph_filter)
+        block = Proc.new { |components|
+          components << Scruffy::Components::Grid.new(:grid, :position => [10, 0], :size => [90, 89])
+          components << Scruffy::Components::ValueMarkers.new(:value_markers, :position => [0, 2], :size => [8, 89])
+          components << Scruffy::Components::DataMarkers.new(:data_markers, :position => [10, 92], :size => [90, 8])
+          components << Scruffy::Components::Graphs.new(:graphs, :position => [10, 0], :size => [90, 89], :only => graph_filter)
+        }
+        
+        block
+      end
+  end
+end

data/lib/scruffy/renderers/empty.rb

@@ -0,0 +1,22 @@
+module Scruffy::Renderers
+  # ===Scruffy::Renderers::Empty
+  #
+  # Author:: Brasten Sager
+  # Date:: August 17th, 2006
+  #
+  # An Empty graph isn't completely empty, it adds a background componenet
+  # to itself before handing other all other layout responsibilities to it's
+  # subclasses or caller.
+  class Empty < Base
+
+    # Returns a renderer with just a background.
+    #
+    # If a block is provided, the components array is passed to
+    # the block, allowing callers to add components during initialize.
+    def define_layout
+      self.components << Scruffy::Components::Background.new(:background, :position => [0,0], :size =>[100, 100])      
+
+      yield(self.components) if block_given?
+    end
+  end
+end

data/lib/scruffy/renderers/pie.rb

@@ -0,0 +1,20 @@
+module Scruffy::Renderers
+  # ===Scruffy::Renderers::Base
+  # 
+  # Author:: A.J. Ostman
+  # Date:: August 14th, 2006
+  # 
+  # Provides a more appropriate rendering for Pie Charts.
+  # Does not show grid or Data markers, but does add Pie Value Markers.
+  class Pie < Base
+
+    def initialize
+      self.components = []
+      self.components << Scruffy::Components::Background.new(:background, :position => [0,0], :size =>[100, 100])
+      self.components << Scruffy::Components::Graphs.new(:graphs, :position => [-15, 12], :size => [90, 88])
+      self.components << Scruffy::Components::Title.new(:title, :position => [5, 2], :size => [90, 7])
+      self.components << Scruffy::Components::Legend.new(:legend, :position => [60, 15], :size => [40, 88], :vertical_legend => true)
+    end
+  end
+  
+end

data/lib/scruffy/renderers/reversed.rb

@@ -0,0 +1,17 @@
+module Scruffy
+  module Renderers
+    class Reversed < Base
+
+      def define_layout
+        self.components << Scruffy::Components::Background.new(:background, :position => [0,0], :size =>[100, 100])
+        self.components << Scruffy::Components::Title.new(:title, :position => [98, 95], :size => [1, 3], :text_anchor => 'end')
+        #self.components << Scruffy::Components::Grid.new(:grid, :position => [14, 12], :size => [78.5, 70])
+        self.components << Scruffy::Components::ValueMarkers.new(:value_markers, :position => [2, 14], :size => [10, 70])
+        self.components << Scruffy::Components::DataMarkers.new(:data_markers, :position => [14, 3.5], :size => [78.5, 4])
+        self.components << Scruffy::Components::Graphs.new(:graphs, :position => [14, 12], :size => [78.5, 70])
+        self.components << Scruffy::Components::Legend.new(:legend, :position => [3, 90], :size => [55, 6])
+      end
+
+    end
+  end
+end

data/lib/scruffy/renderers/sparkline.rb

@@ -0,0 +1,10 @@
+module Scruffy
+  module Renderers
+    # Experimental, do not use.
+    class Sparkline < Base
+      def define_layout
+        self.components << Scruffy::Components::Graphs.new(:sparkline, :position => [0, 0], :size => [100, 100])                  
+      end
+    end
+  end
+end

data/lib/scruffy/renderers/split.rb

@@ -0,0 +1,48 @@
+module Scruffy
+  module Renderers
+    # Renderer that splits the graphs up into four other little graphs.
+    class Split < Empty
+      def define_layout
+        super do |components|
+          components << Scruffy::Components::Title.new(:title, :position => [5, 2], :size => [90, 7])
+          components << Scruffy::Components::Label.new(:label_one, :text => self.options[:split_label] || '', 
+                                                      :position => [30, 54.5], :size => [40, 3])
+
+          # Viewports
+          components << Scruffy::Components::Viewport.new(:top, :position => [3, 20], 
+                                                         :size => [90, 30], &graph_block(:top))
+          components << Scruffy::Components::Viewport.new(:bottom, :position => [3, 65], 
+                                                         :size => [90, 30], &graph_block(:bottom))
+        
+          components << Scruffy::Components::Legend.new(:legend, :position => [5, 11], :size => [90, 4])
+        end
+      end
+
+      protected
+        def labels
+          [component(:top).component(:labels), component(:bottom).component(:labels)]
+        end
+    
+        def values
+          [component(:top).component(:values), component(:bottom).component(:values)]
+        end
+      
+        def grids
+          [component(:top).component(:grid), component(:bottom).component(:grid)]
+        end
+      
+
+      private
+        def graph_block(graph_filter)
+          block = Proc.new { |components|
+            components << Scruffy::Components::Grid.new(:grid, :position => [10, 0], :size => [90, 89])
+            components << Scruffy::Components::ValueMarkers.new(:values, :position => [0, 2], :size => [8, 89])
+            components << Scruffy::Components::DataMarkers.new(:labels, :position => [10, 92], :size => [90, 8])
+            components << Scruffy::Components::Graphs.new(:graphs, :position => [10, 0], :size => [90, 89], :only => graph_filter)
+          }
+          
+          block
+        end
+    end
+  end
+end

data/lib/scruffy/renderers/standard.rb

@@ -0,0 +1,37 @@
+module Scruffy::Renderers
+  class Standard < Empty
+    
+    def define_layout
+      super do |components|
+        components << Scruffy::Components::Title.new(:title, :position => [5, 2], :size => [90, 7])
+        components << Scruffy::Components::Viewport.new(:view, :position => [2, 26], :size => [90, 66]) do |graph|
+          graph << Scruffy::Components::ValueMarkers.new(:values, :position => [0, 2], :size => [8, 89])
+          graph << Scruffy::Components::Grid.new(:grid, :position => [10, 0], :size => [90, 89], :stroke_width => 1)
+          graph << Scruffy::Components::VGrid.new(:vgrid, :position => [10, 0], :size => [90, 89], :stroke_width => 1)
+          graph << Scruffy::Components::DataMarkers.new(:labels, :position => [10, 92], :size => [90, 8])
+          graph << Scruffy::Components::Graphs.new(:graphs, :position => [10, 0], :size => [90, 89])
+        end
+        components << Scruffy::Components::Legend.new(:legend, :position => [5, 13], :size => [90, 6])
+      end
+    end
+    
+    protected
+      def hide_values
+        super
+        component(:view).position[0] = -10
+        component(:view).size[0] = 100
+      end
+    
+      def labels
+        [component(:view).component(:labels)]
+      end
+    
+      def values
+        [component(:view).component(:values)]
+      end
+      
+      def grids
+        [component(:view).component(:grid),component(:view).component(:vgrid)]
+      end
+  end
+end