samhendley-scruffy 0.2.7

data/CHANGES.txt

@@ -0,0 +1,115 @@
+= Scruffy Changelog
+
+== Version 0.2.6
+(December 12th, 2008)
+* Forked from the official 0.2.5 release (http://github.com/delano/scruffy/)
+* Added stroke_width and style attributes to Line
+* Added toggleable shadow and dots attributes to Line
+* Changed the default Line to not include shadow or dots and to have a width of 1 pixel.
+* Added stroke_width for Component::Graph. Default is now 1. 
+* Changed the default theme to one appropriate for hi-res charts
+* Removed website from release
+
+== Version 0.2.3
+(July 4th, 2008)
+* Got pie charts working
+* Added rough capability for legend to run vertically (better for Pie chart)
+* Added some checks in the Pie initializer so that you simply pass a Hash of
+  name => values, instead of adding PieSlices in a block.
+* Added a simplistic unit test that outputs a pie and line chart in PNG & SVG.
+* Quite a lot of hard-wired values in here. Whole thing needs a spring clean.
+
+== Version 0.2.2
+(August 19th, 2006)
+
+* Removed all font-family and text-rendering attributes from elements.
+	- These were causing issues with Batik and Adobe Viewer.  Horrible font problems.
+* Added require 'builder' to renderers/base.rb
+* Added minor shadows to most graph types.  Adds some depth perception.
+* Added graph.layout as an alias of renderer.  (graph.layout looks nicer).
+* Added markers, values, grid options.
+
+== Version 0.2.1
+(August 18th, 2006)
+
+* Mostly documentation.
+* Added Builder 2.0 dependency to gem spec.
+* Removed minimum size hack in RMagickRasterizer, for now.
+
+
+== Version 0.2.0
+(August 14th, 2006)
+
+- Lots of changes, hold on tight:
+
+* Redesigned rendering system to a component-based design.
+  All objects on the canvas are components that can be re-arranged via renderers.
+* Created default renderer for basic Gruff-like layout.
+* Added Reversed and Cubed renderers to demonstrate the customization abilities (plus, they're cool).
+* Added Split renderer.
+* Created Viewport component to help with Cubed.
+	- Viewport lets you scale it's inner components and move around the
+	  graph.  Its components' sizes and positions are relative to the viewport,
+	  not the graph.
+* Set title to respect marker color if available.
+* Respects :to option in Graph#render for SVG output to file.
+* Stacked layer type -- accepts layers which it then uses to create a stacked graph.  Such as Bar graphs
+  and Area graphs.
+* Abstracted out layer_container functionality to helper module (for stacked graph)
+* Renamed value_transformers to value_formatters.
+* Refined Value Formatters.
+	- Created default: Number.
+	- Respects float precision
+	- Allows for "auto-precision", which will use the largest precision (up to a customizable limit)
+	  necessary to portray the values correctly.  ie: 5.1, 6.32, 7.142  becomes   '5.100', '6.320', '7.142'
+* Modified Legend component, Layers, and Graph component to respect categories.
+	- ie:  Creating a Bar layer with :category => :sales and a Graph with :category => :qa will result in
+	  the Bay layer not being displayed.  Allows for more than one Graph viewport on a screen with different
+	  layers.
+* Improved rasterizing at smaller sizes( < 300px) by rasterizing the image at a larger size first, then
+  allowing RMagick to resize the image with specific filtering/blurring.  Actually looks better than just
+  rasterizing the SVG at the small size from the beginning.
+* Fixed Opacity on stacked graphs.
+* Added Style (invisible) components to allow for CSS styling. (Not recommended, however.)
+* Added Label component for arbitrary text.
+* Created Theme object in place of theme hash.
+
+== Version 0.1.0
+(August 11th, 2006)
+
+* First public release!
+* Legend rendering
+* Rasterizing graph to multiple image types (graph.render :as => 'PNG')
+
+== Version 0.0.12
+(August 10th, 2006)
+This is not a public release.
+
+* Rearranged Layers into a better class/module arrangement.
+
+== Version 0.0.11
+(August 10th, 2006)
+This is not a public release.
+
+* Fixed gem issue.
+
+== Version 0.0.10
+(August 10th, 2006)
+
+This is not a public release.
+
+
+* Removed bogus changelog.
+
+
+== Version 0.0.9
+(August 10th, 2006)
+
+This is not a public release.
+
+* Initial release.
+* Standard renderer.
+* Marker transformers: currency, percentages.
+* Basic Graphs: Area, Bar, Line.
+* Advanced Graphs: Average, AllSmiles.
+* Initial documentation.

data/LICENCE.txt

@@ -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.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/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

data/lib/scruffy/components/value_markers.rb

@@ -0,0 +1,32 @@
+module Scruffy
+  module Components
+    class ValueMarkers < Base
+      attr_accessor :markers
+      
+      def draw(svg, bounds, options={})
+        markers = (options[:markers] || self.markers) || 5
+        all_values = []
+
+        (0...markers).each do |idx|
+          marker = ((1 / (markers - 1).to_f) * idx) * bounds[:height]
+          all_values << (options[:max_value] - options[:min_value]) * ((1 / (markers - 1).to_f) * idx) + options[:min_value]
+        end
+        
+        (0...markers).each do |idx|
+          marker = ((1 / (markers - 1).to_f) * idx) * bounds[:height]
+          marker_value = (options[:max_value] - options[:min_value]) * ((1 / (markers - 1).to_f) * idx) + options[:min_value]
+          marker_value = options[:value_formatter].route_format(marker_value, idx, options.merge({:all_values => all_values})) if options[:value_formatter]
+
+          svg.text( marker_value.to_s, 
+            :x => bounds[:width], 
+            :y => (bounds[:height] - marker), 
+            'font-size' => relative(8),
+            'font-family' => options[:theme].font_family,
+            :fill => ((options.delete(:marker_color_override) || options[:theme].marker) || 'white').to_s,
+            'text-anchor' => 'end')
+        end
+        
+      end
+    end
+  end
+end

data/lib/scruffy/components/viewport.rb

@@ -0,0 +1,37 @@
+module Scruffy::Components
+  # Component used to limit other visual components to a certain area on the graph.
+  class Viewport < Base
+    include Scruffy::Helpers::Canvas
+    
+    def initialize(*args, &block)
+      super(*args)
+      
+      self.components = []
+      block.call(self.components) if block
+    end
+
+    def draw(svg, bounds, options={})
+      svg.g(options_for) {
+        self.components.each do |component|
+          component.render(svg, 
+            bounds_for([bounds[:width], bounds[:height]], 
+              component.position, 
+              component.size), 
+            options)
+        end
+      }
+    end
+    
+    private
+    def options_for
+      options = {}
+      %w(skewX skewY).each do |option|
+        if @options[option.to_sym]
+          options[:transform] ||= ''
+          options[:transform] = options[:transform] + "#{option.to_s}(#{@options[option.to_sym]})"
+        end
+      end
+      options
+    end
+  end
+end

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'