ramhoj-scruffy 0.2.6

data/README.txt

@@ -0,0 +1,66 @@
+= scruffy, unofficial release
+
+This is a fork from based on the official 0.2.5 release. See below for 
+further a longer description.  
+
+== DESCRIPTION:
+
+* scruffy.rubyforge.org
+
+Author:: Brasten Sager (brasten@nagilum.com)
+Date:: July 8, 2008
+Release:: 0.2.5
+
+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.
+
+
+== FORK DESCRIPTION
+
+* http://github.com/delano/scruffy/
+
+Author:: Delano Mandelbaum (delano@solutious.com)
+Author:: Kalin Harvey
+Date:: December 12, 2008
+
+We love scruffy. Our motivation for creating a forking is to make it useful for hi-resolution 
+graphs and charts. We would love to get our changes in to the official release but until
+that time they will be available at the GitHub URI above. 
+
+CHANGES.txt contains everything we've been up to. 
+
+
+== FEATURES
+
+* Renders to SVG or bitmap (PNG, JPG)
+
+== PROBLEMS:
+
+* 0.2.3 version has missing legend text when rendering to bitmap. This is strange because the text is there in the SVG before it goes to RMagick.
+
+== SYNOPSIS:
+
+    graph = Scruffy::Graph.new
+    graph.title = "Sample Line Graph"
+    graph.renderer = Scruffy::Renderers::Standard.new
+
+    graph.add :line, 'Example', [20, 100, 70, 30, 106]
+
+    graph.render :to => "line_test.svg"
+    graph.render  :width => 300, :height => 200,
+      :to => "line_test.png", :as => 'png'
+
+== REQUIREMENTS:
+
+* Needs RMagick and Magic installed, if you wish to render to bitmap.
+
+== INSTALL:
+
+* sudo gem install scruffy
+
+
+== LICENSE:
+
+See Licence.txt

data/lib/scruffy.rb

@@ -0,0 +1,25 @@
+# ===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::Layers::Base.
+module Scruffy
+end
+  
+require 'builder'
+
+require 'scruffy/helpers'
+require 'scruffy/graph_state'
+require 'scruffy/graph'
+require 'scruffy/themes'
+require 'scruffy/version'
+require 'scruffy/formatters'
+require 'scruffy/rasterizers'
+require 'scruffy/layers'
+require 'scruffy/components'
+require 'scruffy/renderers'

data/lib/scruffy/components.rb

@@ -0,0 +1,21 @@
+# ===Scruffy Components
+#
+# Author:: Brasten Sager
+# Date:: August 16th, 2006
+#
+# Components make up the visual elements of a Scruffy graph.
+#
+# For examples, see Scruffy::Components::Base.
+module Scruffy::Components; end
+
+require 'scruffy/components/base'
+require 'scruffy/components/title'
+require 'scruffy/components/background'
+require 'scruffy/components/graphs'
+require 'scruffy/components/grid'
+require 'scruffy/components/value_markers'
+require 'scruffy/components/data_markers'
+require 'scruffy/components/legend'
+require 'scruffy/components/style_info'
+require 'scruffy/components/viewport'
+require 'scruffy/components/label'

data/lib/scruffy/components/background.rb

@@ -0,0 +1,24 @@
+module Scruffy
+  module Components
+    class Background < Base
+      def draw(svg, bounds, 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])
+            }
+          }
+        end
+        
+        # Render background (maybe)
+        svg.rect(:width => bounds[:width], :height => bounds[:height], :x => "0", :y => "0", :fill => fill) unless fill.nil?
+      end
+    end
+  end
+end

data/lib/scruffy/components/base.rb

@@ -0,0 +1,57 @@
+module Scruffy
+  module Components
+    # ===Scruffy::Components::Base
+    # 
+    # Common attributes for all components, and a standard render method
+    # that calls draw after setting up the drawing transformations.
+    class Base
+      attr_reader :id
+      
+      # In terms of percentages:  [10, 10] == 10% by 10%
+      attr_accessor :position
+      attr_accessor :size
+      attr_accessor :options
+      attr_accessor :visible
+      
+      # Options:
+      # stroke_width:: numeric value for width of line (0.1 - 10, default: 1)
+      def initialize(id, options = {})
+        @id = id.to_sym
+        @position = options[:position] || [0, 0]
+        @size = options[:size] || [100, 100]
+        @visible = options[:visible] || true
+        
+        @options = options
+      end
+      
+      def render(svg, bounds, options={})
+        if @visible
+          unless bounds.nil?
+            @render_height = bounds[:height]
+        
+            svg.g(:id => id.to_s, 
+                  :transform => "translate(#{bounds.delete(:x)}, #{bounds.delete(:y)})") {
+
+              draw(svg, bounds, options.merge(@options))
+            }
+          else
+            process(svg, options.merge(@options))
+          end
+        end
+      end
+      
+      def draw(svg, bounds, options={})
+        # Override this if visual component
+      end
+
+      def process(svg, options={})
+        # Override this NOT a visual component
+      end
+      
+      protected
+        def relative(pct)
+          @render_height * ( pct / 100.to_f )
+        end
+    end
+  end
+end

data/lib/scruffy/components/data_markers.rb

@@ -0,0 +1,26 @@
+module Scruffy
+  module Components
+
+    class DataMarkers < Base
+
+      def draw(svg, bounds, options={})
+        unless options[:point_markers].nil?
+          point_distance = bounds[: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 => bounds[:height], 
+              'font-size' => relative(90),
+              'font-family' => options[:theme].font_family,
+              :fill => (options[:theme].marker || 'white').to_s, 
+              'text-anchor' => 'middle') unless options[:point_markers][idx].nil?
+          end
+        end
+      end   # draw
+      
+    end   # class
+
+  end
+end

data/lib/scruffy/components/graphs.rb

@@ -0,0 +1,48 @@
+module Scruffy
+  module Components
+    
+    # Component for displaying Graphs layers.
+    #
+    # Is passed all graph layers from the Graph object.
+    #
+    # (This may change as the capability for Graph filtering and such fills out.)
+    class Graphs < Base
+      STACKED_OPACITY = 0.85;
+      
+      def draw(svg, bounds, options={})
+        # If Graph is limited to a category, reject layers outside of it's scope.
+        applicable_layers = options[:layers].reject do |l| 
+          if @options[:only]
+            (l.options[:category].nil? && l.options[:categories].nil?) ||
+            (!l.options[:category].nil? && l.options[:category] != @options[:only]) || 
+            (!l.options[:categories].nil? && !l.options[:categories].include?(@options[:only]))
+          else 
+            false
+          end
+        end
+
+        applicable_layers.each_with_index do |layer, idx|
+          layer_options = {}
+          layer_options[:index]       = idx
+          layer_options[:min_value]   = options[:min_value]
+          layer_options[:max_value]   = options[:max_value]
+          layer_options[:complexity]  = options[:complexity]
+          layer_options[:size]        = [bounds[:width], bounds[:height]]
+          layer_options[:color]       = layer.preferred_color || layer.color || options[:theme].next_color
+          layer_options[:opacity]     = opacity_for(idx)
+          layer_options[:theme]       = options[:theme]
+
+          svg.g(:id => "component_#{id}_graph_#{idx}", :class => 'graph_layer') {
+            layer.render(svg, layer_options)
+          }
+        end # applicable_layers
+      end # draw
+
+      protected
+        def opacity_for(idx)
+          (idx == 0) ? 1.0 : (@options[:stacked_opacity] || STACKED_OPACITY)
+        end
+
+    end #class
+  end
+end

data/lib/scruffy/components/grid.rb

@@ -0,0 +1,19 @@
+module Scruffy
+  module Components
+    class Grid < Base
+      attr_accessor :markers
+      
+      def draw(svg, bounds, options={})
+        markers = (options[:markers] || self.markers) || 5
+        
+        stroke_width = options[:stroke_width]
+        
+        (0...markers).each do |idx|
+          marker = ((1 / (markers - 1).to_f) * idx) * bounds[:height]
+          svg.line(:x1 => 0, :y1 => marker, :x2 => bounds[:width], :y2 => marker, :style => "stroke: #{options[:theme].marker.to_s}; stroke-width: #{stroke_width};")
+        end
+      end
+    end
+  end
+end
+

data/lib/scruffy/components/label.rb

@@ -0,0 +1,17 @@
+module Scruffy
+  module Components
+    class Label < Base
+      def draw(svg, bounds, options={})
+        svg.text(@options[:text],
+          :class => 'text',
+          :x => (bounds[:width] / 2),
+          :y => bounds[:height], 
+          'font-size' => relative(100),
+          'font-family' => options[:theme].font_family,
+          :fill => options[:theme].marker,
+          :stroke => 'none', 'stroke-width' => '0',
+          'text-anchor' => (@options[:text_anchor] || 'middle'))
+      end
+    end
+  end
+end

data/lib/scruffy/components/legend.rb

@@ -0,0 +1,105 @@
+module Scruffy::Components
+
+  class Legend < Base
+    FONT_SIZE = 80
+    
+    def draw(svg, bounds, options={})
+      vertical = options[:vertical_legend]
+      legend_info = relevant_legend_info(options[:layers])
+      @line_height, x, y, size = 0
+      if vertical
+        set_line_height = 0.08 * bounds[:height]
+        @line_height = bounds[:height] / legend_info.length
+        @line_height = set_line_height if @line_height >
+          set_line_height
+      else
+        set_line_height = 0.90 * bounds[:height]
+        @line_height = set_line_height
+      end
+
+      text_height = @line_height * FONT_SIZE / 100
+      # #TODO how does this related to @points?
+      active_width, points = layout(legend_info, vertical)
+
+      offset = (bounds[:width] - active_width) / 2    # Nudge over a bit for true centering
+
+      # Render Legend
+      points.each_with_index do |point, idx|
+        if vertical
+          x = 0
+          y = point
+          size = @line_height * 0.5
+        else
+          x = offset + point
+          y = 0
+          size = relative(50)
+        end
+        
+        # "#{x} #{y} #{@line_height} #{size}"
+        
+        svg.rect(:x => x, 
+          :y => y, 
+          :width => size, 
+          :height => size,
+          :fill => legend_info[idx][:color])
+
+        svg.text(legend_info[idx][:title], 
+          :x => x + @line_height, 
+          :y => y + text_height * 0.75,
+          'font-size' => text_height, 
+          'font-family' => options[:theme].font_family,
+          :style => "color: #{options[:theme].marker || 'white'}",
+          :fill => (options[:theme].marker || 'white'))
+      end
+    end   # draw
+    
+    protected
+    # Collects Legend Info from the provided Layers.
+    # 
+    # Automatically filters by legend's categories.
+    def relevant_legend_info(layers, categories=(@options[:category] ? [@options[:category]] : @options[:categories]))
+      legend_info = layers.inject([]) do |arr, layer|
+        if categories.nil? ||
+            (categories.include?(layer.options[:category]) ||
+              (layer.options[:categories] && (categories & layer.options[:categories]).size > 0) )
+
+          data = layer.legend_data
+          arr << data if data.is_a?(Hash)
+          arr = arr + data if data.is_a?(Array)
+        end
+        arr
+      end
+    end   # relevant_legend_info
+      
+    # Returns an array consisting of the total width needed by the legend
+    # information, as well as an array of @x-coords for each element. If
+    # vertical, then these are @y-coords, and @x is 0
+    # 
+    # ie: [200, [0, 50, 100, 150]]
+    def layout(legend_info_array, vertical = false)
+      if vertical
+        longest = 0
+        legend_info_array.each {|elem|
+          cur_length = relative(50) * elem[:title].length
+          longest = longest < cur_length ? cur_length : longest
+        }
+        y_positions = []
+        (0..legend_info_array.length - 1).each {|y|
+          y_positions << y * @line_height
+        }
+        [longest, y_positions]
+      else
+        legend_info_array.inject([0, []]) do |enum, elem|
+          enum[0] += (relative(50) * 2) if enum.first != 0      # Add spacer between elements
+          enum[1] << enum.first                                 # Add location to points
+          enum[0] += relative(50)                               # Add room for color box
+          enum[0] += (relative(50) * elem[:title].length)       # Add room for text
+
+          [enum.first, enum.last]
+        end        
+      end
+    end
+
+  end   # class Legend
+  
+end   # Scruffy::Components

data/lib/scruffy/components/style_info.rb

@@ -0,0 +1,22 @@
+module Scruffy
+  module Components
+    # Component used for adding CSS styling to SVG graphs.
+    #
+    # In hindsight, ImageMagick and Mozilla SVG's handling of CSS styling is
+    # extremely inconsistant, so use this at your own risk.
+    class StyleInfo < Base
+      def initialize(*args)
+        super
+        
+        @visible = false
+      end
+      def process(svg, options={})
+        svg.defs {
+          svg.style(:type => "text/css") {
+            svg.cdata!("\n#{options[:selector]} {\n    #{options[:style]}\n}\n")
+          }
+        }
+      end
+    end
+  end
+end

data/lib/scruffy/components/title.rb

@@ -0,0 +1,19 @@
+module Scruffy
+  module Components
+    class Title < Base
+      def draw(svg, bounds, options={})
+        if options[:title]
+          svg.text(options[:title],
+            :class => 'title',
+            :x => (bounds[:width] / 2),
+            :y => bounds[:height], 
+            'font-size' => relative(100),
+            'font-family' => options[:theme].font_family,
+            :fill => options[:theme].marker,
+            :stroke => 'none', 'stroke-width' => '0',
+            'text-anchor' => (@options[:text_anchor] || 'middle'))
+        end
+      end
+    end
+  end
+end