tlconnor-scruffy 0.2.17

data/lib/scruffy/components/graphs.rb

@@ -0,0 +1,52 @@
+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[:min_key]     = options[:min_key]
+          layer_options[:max_key]     = options[:max_key]
+          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[:border]      = options[:border]
+          layer_options[:outline]       = layer.preferred_outline || layer.outline || options[:theme].next_outline
+          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,57 @@
+module Scruffy
+  module Components
+    class Grid < Base
+      attr_accessor :markers
+      
+      include Scruffy::Helpers::Marker
+      
+      def draw(svg, bounds, options={})
+        markers = (options[:markers] || self.markers) || 5
+        
+        stroke_width = options[:stroke_width]
+        
+        colour = options[:theme].grid || options[:theme].marker
+        
+        each_marker(markers, options[:min_value], options[:max_value], bounds[:height], options, :value_formatter) do |label, y|
+          svg.line(:x1 => 0, :y1 => y, :x2 => bounds[:width], :y2 => y, :style => "stroke: #{colour.to_s}; stroke-width: #{stroke_width};")
+        end
+        
+        #add a 0 line
+        y = (options[:max_value] * bounds[:height])/(options[:max_value] - options[:min_value])
+        svg.line(:x1 => 0, :y1 => y, :x2 => bounds[:width], :y2 => y, :style => "stroke: #{colour.to_s}; stroke-width: #{stroke_width};")
+        
+      end
+    end
+    
+    class VGrid < Base
+      attr_accessor :markers
+      
+      include Scruffy::Helpers::Marker
+      
+      def draw(svg, bounds, options={})
+        colour = options[:theme].grid || options[:theme].marker
+        
+        if options[:graph].point_markers #get vertical grid lines up with points if there are labels for them
+          point_distance = bounds[:width] / (options[:graph].point_markers.size).to_f
+          stroke_width = options[:stroke_width]
+          (0...options[:graph].point_markers.size).map do |idx| 
+            x = point_distance * idx  + point_distance/2
+            svg.line(:x1 => x, :y1 => 0, :x2 => x, :y2 => bounds[:height], :style => "stroke: #{colour.to_s}; stroke-width: #{stroke_width};")
+          end
+          #add the far right and far left lines
+          svg.line(:x1 => 0, :y1 => 0, :x2 => 0, :y2 => bounds[:height], :style => "stroke: #{colour.to_s}; stroke-width: #{stroke_width};")
+          svg.line(:x1 => bounds[:width], :y1 => 0, :x2 => bounds[:width], :y2 => bounds[:height], :style => "stroke: #{colour.to_s}; stroke-width: #{stroke_width};")
+        else
+            
+          markers =  (options[:key_markers] || self.markers) || 5 #options[:point_markers].size#
+          stroke_width = options[:stroke_width]
+          each_marker(markers, options[:min_key], options[:max_key], bounds[:width], options, :key_formatter) do |label, x|
+            svg.line(:x1 => x, :y1 => 0, :x2 => x, :y2 => bounds[:height], :style => "stroke: #{colour.to_s}; stroke-width: #{stroke_width};")
+          end
+          
+        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,147 @@
+module Scruffy::Components
+  
+  class XLegend < Base
+    def draw(svg, bounds, options={})
+      if options[:title]
+        svg.text(options[:x_legend],
+                 :class => 'title',
+        :x => (bounds[:width] / 2),
+        :y => bounds[:height], 
+            'font-size' => options[:theme].legend_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 #XLegend
+  
+  
+  
+  class YLegend < Base
+    def draw(svg, bounds, options={})
+      if options[:title]
+        svg.text(options[:y_legend],
+                 :class => 'title',
+        :x => (0),
+        :y => 0, 
+            'font-size' => options[:theme].legend_font_size || relative(100),
+            'font-family' => options[:theme].font_family,
+            :transform => "translate(#{bounds[:width] / 2},#{bounds[:height]/2}) rotate(#{-90})",
+        :fill => options[:theme].marker,
+        :stroke => 'none', 'stroke-width' => '0',
+            'text-anchor' => (@options[:text_anchor] || 'middle'))
+      end
+    end
+  end #YLegend
+  
+  
+  
+  
+  
+  
+  
+  
+  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' => options[:theme].title_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,25 @@
+module Scruffy
+  module Components
+    class ValueMarkers < Base
+      
+      include Scruffy::Helpers::Marker
+      
+      attr_accessor :markers
+
+      def draw(svg, bounds, options={})
+        markers = (options[:markers] || self.markers) || 5
+        
+        each_marker(markers, options[:min_value], options[:max_value], bounds[:height], options, :value_formatter) do |label, y|
+
+          svg.text( label, 
+            :x => bounds[:width], 
+            :y => (bounds[:height] - y), 
+            'font-size' => options[:theme].marker_font_size || relative(8),
+            'font-family' => options[:theme].font_family,
+            :fill => ((options[: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/formatters.rb

@@ -0,0 +1,233 @@
+# ===Scruffy Formatters
+#
+# Author:: Brasten Sager
+# Date:: August 16th, 2006
+#
+# Formatters are used to format the values displayed on the y-axis by
+# setting graph.value_formatter.
+#
+# Example:
+#
+#   graph.value_formatter = Scruffy::Formatters::Currency.new(:precision => 0)
+#
+module Scruffy::Formatters
+  
+  # == Scruffy::Formatters::Base
+  #
+  # Author:: Brasten Sager
+  # Date:: August 16th, 2006
+  #
+  # Formatters are used to format the values displayed on the y-axis by
+  # setting graph.value_formatter.
+  class Base
+    
+    # Called by the value marker component.  Routes the format call
+    # to one of a couple possible methods.
+    #
+    # If the formatter defines a #format method, the returned value is used
+    # as the value.  If the formatter defines a #format! method, the value passed is
+    # expected to be modified, and is used as the value.  (This may not actually work,
+    # in hindsight.)
+    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)  #:nodoc:
+        sprintf("%01.#{precision}f", number)
+      end
+  end
+  
+  # Allows you to pass in a Proc for use as a formatter.
+  #
+  # Use:
+  #
+  # graph.value_formatter = Scruffy::Formatters::Custom.new { |value, idx, options| "Displays Returned Value" }
+  class Custom < Base
+    attr_reader :proc
+    
+    def initialize(&block)
+      @proc = block
+    end
+    
+    def format(target, idx, options)
+      proc.call(target, idx, options)
+    end
+  end
+  
+  
+  
+  # Default number formatter.
+  # Limits precision, beautifies numbers.
+  class Number < Base
+    attr_accessor :precision, :separator, :delimiter, :precision_limit
+    
+    # Returns a new Number formatter.
+    #
+    # Options:
+    # precision:: precision to use for value.  Can be set to an integer, :none or :auto.
+    #             :auto will use whatever precision is necessary to portray all the numerical
+    #             information, up to :precision_limit.
+    #
+    #             Example:  [100.1, 100.44, 200.323] will result in [100.100, 100.440, 200.323]
+    #
+    # separator:: decimal separator.  Defaults to '.'
+    # delimiter:: delimiter character.  Defaults to ','
+    # precision_limit:: upper limit for auto precision. (Ignored if roundup is specified)
+    # roundup:: round up the number to the given interval 
+    def initialize(options = {})
+      @precision        = options[:precision] || :none
+      @roundup          = options[:roundup] || :none
+      @separator        = options[:separator] || '.'
+      @delimiter        = options[:delimiter] || ','
+      @precision_limit  = options[:precision_limit] || 4
+    end
+    
+    # Formats the value.
+    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
+        number = ""
+        
+        if @roundup == :none 
+          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
+        else 
+          number = roundup(target.to_f, @roundup).to_i.to_s
+        end
+        
+        number
+      rescue StandardError => e
+        target
+      end
+    end
+    
+    
+    def roundup(target, nearest=100)
+      target % nearest == 0 ? target : target + nearest - (target % nearest)
+    end
+    def rounddown(target, nearest=100)
+      target % nearest == 0 ? target : target - (target % nearest)
+    end
+  end
+  
+
+  
+  # Currency formatter.
+  #
+  # Provides formatting for currencies.
+  class Currency < Base
+    
+    # Returns a new Currency class.
+    #
+    # Options:
+    # precision:: precision of value
+    # unit:: Defaults to '$'
+    # separator:: Defaults to '.'
+    # delimiter:: Defaults to ','
+    # negative_color:: Color of value marker for negative values.  Defaults to 'red'
+    # special_negatives:: If set to true, parenthesizes negative numbers.  ie:  -$150.50 becomes ($150.50).
+    #                     Defaults to false.
+    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
+    
+    # Formats value marker.
+    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
+          number.gsub!(@unit + '-', '-' + @unit)
+        end
+        if (target.to_f < 0) && @negative_color
+          options[:marker_color_override] = @negative_color
+        else
+          options[:marker_color_override] = nil
+        end
+        number
+      rescue
+        target
+      end
+    end
+  end
+  
+  # Percentage formatter.
+  #
+  # Provides formatting for percentages.  
+  class Percentage < Base
+    
+    # Returns new Percentage formatter.
+    #
+    # Options:
+    # precision:: Defaults to 3.
+    # separator:: Defaults to '.'
+    def initialize(options = {})
+      @precision    = options[:precision] || 3
+      @separator    = options[:separator] || '.'
+    end
+    
+    # Formats percentages.
+    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
+  
+ 
+  class Date < Base
+
+    def initialize(format_string, options = {})
+      @format_string = format_string
+    end
+    
+    # Formats percentages.
+    def format(target, idx, options)
+      begin
+        target.strftime(@format_string)
+      rescue
+        target
+      end
+    end
+  end
+
+end