scruffy 0.1.0 → 0.2.0

data/CHANGES

@@ -1,5 +1,42 @@
 = Scruffy Changelog
 
+== 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)
 
@@ -7,8 +44,6 @@
 * 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.

data/lib/scruffy.rb

@@ -4,14 +4,12 @@ $:.unshift(File.dirname(__FILE__)) unless
 require 'rubygems'
 require_gem 'builder', '>= 2.0'
 
-# Base files
+require 'scruffy/helpers'
 require 'scruffy/graph'
 require 'scruffy/themes'
 require 'scruffy/version'
-require 'scruffy/transformer'
+require 'scruffy/formatters'
 require 'scruffy/rasterizers'
-require 'scruffy/resolver'
 require 'scruffy/layers'
-
-# Renderers
-require 'scruffy/renderers/standard'
+require 'scruffy/components'
+require 'scruffy/renderers'

data/lib/scruffy/components.rb

@@ -0,0 +1,11 @@
+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,46 @@
+module Scruffy
+  module Components
+    class Base
+      attr_reader :id
+      
+      # In terms of percentages:  [10, 10] == 10% by 10%
+      attr_reader :position
+      attr_reader :size
+      attr_reader :options
+      
+      def initialize(id, options = {})
+        @id = id.to_sym
+        @position = options[:position]
+        @size = options[:size]
+        @options = options
+      end
+      
+      def render(svg, bounds, options={})
+        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
+      
+      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,25 @@
+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), 
+                     :fill => (options[:theme].marker || 'white').to_s, 
+                     'text-anchor' => 'middle', 
+                     'font-family' => options[:theme].font_family, 
+                     'text-rendering' => 'optimizeLegibility') 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,14 @@
+module Scruffy
+  module Components
+    class Grid < Base
+      def draw(svg, bounds, options={})
+        markers = options[:markers] || 5
+        
+        (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: 2;")
+        end
+      end
+    end
+  end
+end

data/lib/scruffy/components/label.rb

@@ -0,0 +1,12 @@
+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), :fill => options[:theme].marker, :stroke => 'none', 'stroke-width' => '0',
+                'text-anchor' => (@options[:text_anchor] || 'middle'), 
+                'font-family' => options[:theme].font_family, 'text-rendering' => 'optimizeLegibility')
+      end
+    end
+  end
+end

data/lib/scruffy/components/legend.rb

@@ -0,0 +1,64 @@
+module Scruffy::Components
+
+  class Legend < Base
+    def draw(svg, bounds, options={})
+      legend_info = relevant_legend_info(options[:layers])
+      active_width, points = layout(legend_info)
+
+      offset = (bounds[:width] - active_width) / 2    # Nudge over a bit for true centering
+
+      # Render Legend
+      points.each_with_index do |point, idx|
+        
+        svg.rect( :x => offset + point, 
+                  :y => relative(25), 
+                  :width => relative(60), 
+                  :height => relative(50),
+                  :fill => legend_info[idx][:color])
+                  
+       svg.text(  legend_info[idx][:title], 
+                  :x => offset + point + relative(100), 
+                  :y => relative(80), 
+                  'font-size' => relative(80), 
+                  :fill => (options[:theme].marker || 'white'), 
+                  'font-family' => options[:theme].font_family, 
+                  'text-rendering' => 'optimizeLegibility')
+      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.
+      #
+      # ie: [200, [0, 50, 100, 150]]
+      def layout(legend_info_array)
+        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   # class Legend
+  
+end   # Scruffy::Components

data/lib/scruffy/components/style_info.rb

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

data/lib/scruffy/components/value_markers.rb

@@ -0,0 +1,31 @@
+module Scruffy
+  module Components
+    class ValueMarkers < Base
+      def draw(svg, bounds, options={})
+        markers = options[: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(10),
+                    :fill => ((options.delete(:marker_color_override) || options[:theme].marker) || 'white').to_s,
+                    'text-anchor' => 'end', 
+                    'font-family' => options[:theme].font_family, 
+                    'text-rendering' => 'optimizeLegibility')
+        end
+        
+      end
+    end
+  end
+end

data/lib/scruffy/components/viewport.rb

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

data/lib/scruffy/formatters.rb

@@ -0,0 +1,111 @@
+module Scruffy
+  module Formatters
+    class Base
+      def route_format(target, idx, options = {})
+        args = [target, idx, options]
+        if respond_to?(:format)
+          send :format, *args[0...self.method(:format).arity]
+        elsif respond_to?(:format!)
+          send :format!, *args[0...self.method(:format!).arity]
+          target
+        else
+          raise NameError, "Formatter subclass must container either a format() method or format!() method."
+        end
+      end
+
+      protected
+        def number_with_precision(number, precision=3)
+          sprintf("%01.#{precision}f", number)
+        end
+    end
+    
+    # Default number formatter.  Limits precision, beautifies numbers.
+    class Number < Base
+      attr_accessor :precision, :separator, :delimiter, :precision_limit
+      
+      def initialize(options = {})
+        @precision        = options[:precision] || :none
+        @separator        = options[:separator] || '.'
+        @delimiter        = options[:delimiter] || ','
+        @precision_limit  = options[:precision_limit] || 4
+      end
+      
+      def format(target, idx, options)
+        my_precision = @precision
+        
+        if @precision == :auto
+          my_precision = options[:all_values].inject(0) do |highest, current|
+            cur = current.to_f.to_s.split(".").last.size
+            cur > highest ? cur : highest
+          end
+        
+          my_precision = @precision_limit if my_precision > @precision_limit
+        elsif @precision == :none
+          my_precision = 0
+        end
+        
+        my_separator = @separator
+        my_separator = "" unless my_precision > 0
+        begin
+          parts = number_with_precision(target, my_precision).split('.')
+          
+          number = parts[0].to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{@delimiter}") + my_separator + parts[1].to_s
+          number
+        rescue StandardError => e
+          target
+        end
+      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] || 'red'
+        @special_negatives = options[:special_negatives] || false
+      end
+      
+      def format(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 format(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