scruffy 0.2.6 → 0.3.0.beta1

data/lib/scruffy/components/title.rb

@@ -7,7 +7,7 @@ module Scruffy
             :class => 'title',
             :x => (bounds[:width] / 2),
             :y => bounds[:height], 
-            'font-size' => relative(100),
+            'font-size' => options[:theme].title_font_size || relative(100),
             'font-family' => options[:theme].font_family,
             :fill => options[:theme].marker,
             :stroke => 'none', 'stroke-width' => '0',

data/lib/scruffy/components/value_markers.rb

@@ -1,31 +1,24 @@
 module Scruffy
   module Components
     class ValueMarkers < Base
-      attr_accessor :markers
       
+      include Scruffy::Helpers::Marker
+      
+      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]
+        each_marker(markers, options[:min_value], options[:max_value], bounds[:height], options, :value_formatter) do |label, y|
 
-          svg.text( marker_value.to_s, 
+          svg.text( label, 
             :x => bounds[:width], 
-            :y => (bounds[:height] - marker), 
-            'font-size' => relative(8),
+            :y => (bounds[:height] - y), 
+            'font-size' => options[:theme].marker_font_size || relative(8),
             'font-family' => options[:theme].font_family,
-            :fill => ((options.delete(:marker_color_override) || options[:theme].marker) || 'white').to_s,
+            :fill => ((options[:marker_color_override] || options[:theme].marker) || 'white').to_s,
             'text-anchor' => 'end')
         end
-        
       end
     end
   end

data/lib/scruffy/formatters.rb

@@ -81,9 +81,11 @@ module Scruffy::Formatters
     #
     # separator:: decimal separator.  Defaults to '.'
     # delimiter:: delimiter character.  Defaults to ','
-    # precision_limit:: upper limit for auto precision.
+    # 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
@@ -107,16 +109,32 @@ module Scruffy::Formatters
       my_separator = @separator
       my_separator = "" unless my_precision > 0
       begin
-        parts = number_with_precision(target, my_precision).split('.')
+        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 = 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
+    
+    
+    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.
@@ -150,9 +168,12 @@ module Scruffy::Formatters
           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
@@ -191,5 +212,22 @@ module Scruffy::Formatters
       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

data/lib/scruffy/graph.rb

@@ -74,16 +74,18 @@ module Scruffy
   #   doesn't necessarily mean they will make any logical sense together.  We leave those decisions up to you. :)
 
   class Graph
-    extend Forwardable;
+    extend Forwardable
     
     include Scruffy::Helpers::LayerContainer
 
     # Delegating these getters to the internal state object.
-    def_delegators  :internal_state, :title, :theme, :default_type, 
-                    :point_markers, :value_formatter, :rasterizer
+    def_delegators  :internal_state, :title,:x_legend,:y_legend, :theme, :default_type, 
+                    :point_markers,:point_markers_rotation,:point_markers_ticks, :value_formatter, :rasterizer,
+                    :key_formatter
                   
-    def_delegators  :internal_state, :title=, :theme=, :default_type=,
-                    :point_markers=, :value_formatter=, :rasterizer=
+    def_delegators  :internal_state, :title=, :theme=,:x_legend=,:y_legend=, :default_type=,
+                    :point_markers=,:point_markers_rotation=,:point_markers_ticks=, :value_formatter=, :rasterizer=,
+                    :key_formatter=
     
     attr_reader :renderer     # Writer defined below
     
@@ -96,11 +98,15 @@ module Scruffy
     # Options:
     #
     # title::  Graph's title
+    # x_legend :: Title for X Axis
+    # y_legend :: Title for Y Axis
     # theme::  A theme object to use when rendering graph
     # layers::  An array of Layers for this graph to use
     # default_type::  A symbol indicating the default type of Layer for this graph
     # value_formatter::   Sets a formatter used to modify marker values prior to rendering
     # point_markers::  Sets the x-axis marker values
+    # point_markers_rotation::  Sets the angle of rotation for x-axis marker values
+    # point_markers_ticks::  Sets a small tick mark above each marker value.  Helful when used with rotation.    
     # rasterizer::  Sets the rasterizer to use when rendering to an image format.  Defaults to RMagick.
     def initialize(*args)
       self.default_type   = args.shift if args.first.is_a?(Symbol)
@@ -108,12 +114,15 @@ module Scruffy
       raise ArgumentError, "The arguments provided are not supported." if args.size > 0
 
       options ||= {}
-      self.theme = Scruffy::Themes::Keynote.new
+      
+      
+      self.theme = Scruffy::Themes::Standard.new
       self.renderer = Scruffy::Renderers::Standard.new
-      self.rasterizer = Scruffy::Rasterizers::RMagickRasterizer.new
+      self.rasterizer = Scruffy::Rasterizers::MiniMagickRasterizer.new
       self.value_formatter = Scruffy::Formatters::Number.new
+      self.key_formatter = Scruffy::Formatters::Number.new
 
-      %w(title theme layers default_type value_formatter point_markers rasterizer).each do |arg|
+      %w(title x_legend y_legend theme layers default_type value_formatter point_markers point_markers_rotation point_markers_ticks rasterizer key_formatter).each do |arg|
         self.send("#{arg}=".to_sym, options.delete(arg.to_sym)) unless options[arg.to_sym].nil?
       end
       
@@ -128,6 +137,7 @@ module Scruffy
     # theme:: Theme used to render graph for this render only.
     # min_value:: Overrides the calculated minimum value used for the graph.
     # max_value:: Overrides the calculated maximum value used for the graph.
+    # renderer:: Provide a Renderer object to use instead of the default. 
     #
     # For other image formats:
     # as:: File format to render to ('PNG', 'JPG', etc)
@@ -135,14 +145,20 @@ module Scruffy
     def render(options = {})
       options[:theme]               ||= theme
       options[:value_formatter]     ||= value_formatter
+      options[:key_formatter]       ||= key_formatter
       options[:point_markers]       ||= point_markers
+      options[:point_markers_rotation]       ||= point_markers_rotation
+      options[:point_markers_ticks]       ||= point_markers_ticks
       options[:size]                ||= (options[:width] ? [options[:width], (options.delete(:width) * 0.6).to_i] : [600, 360])
       options[:title]               ||= title
+      options[:x_legend]               ||= x_legend
+      options[:y_legend]               ||= y_legend
       options[:layers]              ||= layers
-      options[:min_value]           ||= bottom_value(:padded)
-      options[:max_value]           ||= top_value
+      options[:min_value]           ||= bottom_value(options[:padding] ? options[:padding] : nil)
+      options[:max_value]           ||= top_value(options[:padding] ? options[:padding] : nil)
+      options[:min_key]             ||= bottom_key
+      options[:max_key]             ||= top_key
       options[:graph]               ||= self
-      
 
       # Removed for now.
       # Added for making smaller fonts more legible, but may not be needed after all.

data/lib/scruffy/graph_state.rb

@@ -11,10 +11,15 @@ module Scruffy
   class GraphState
 
     attr_accessor :title
+    attr_accessor :x_legend
+    attr_accessor :y_legend
     attr_accessor :theme
     attr_accessor :default_type
     attr_accessor :point_markers
+    attr_accessor :point_markers_rotation
+    attr_accessor :point_markers_ticks
     attr_accessor :value_formatter
+    attr_accessor :key_formatter
     attr_accessor :rasterizer
     
     def initialize

data/lib/scruffy/helpers.rb

@@ -9,4 +9,5 @@ module Scruffy::Helpers; end
 require 'scruffy/helpers/canvas'
 require 'scruffy/helpers/layer_container'
 require 'scruffy/helpers/point_container'
+require 'scruffy/helpers/marker_helper'
 #require 'scruffy/helpers/meta'

data/lib/scruffy/helpers/layer_container.rb

@@ -67,7 +67,9 @@ module Scruffy::Helpers
     # If padding is set to :padded, a 15% padding is added to the highest value.
     def top_value(padding=nil) # :nodoc:
       topval = layers.inject(0) { |max, layer| (max = ((max < layer.top_value) ? layer.top_value : max)) unless layer.top_value.nil?; max }
-      padding == :padded ? (topval - ((topval - bottom_value) * 0.15)) : topval
+      below_zero = (topval <= 0)
+      topval = padding == :padded ? (topval + ((topval - bottom_value) * 0.15)) : topval
+      (below_zero && topval > 0) ? 0 : topval
     end
   
     # Returns the lowest value in any of this container's layers.
@@ -76,15 +78,37 @@ module Scruffy::Helpers
     # If the lowest value is greater than zero, then the padding will not cross the zero line, preventing
     # negative values from being introduced into the graph purely due to padding.
     def bottom_value(padding=nil) # :nodoc:
-      botval = layers.inject(top_value) { |min, layer| (min = ((min > layer.bottom_value) ? layer.bottom_value : min)) unless layer.bottom_value.nil?; min }
-      above_zero = (botval > 0)
-      botval = (botval - ((top_value - botval) * 0.15))
+      botval = layers.inject(0) do |min, layer| 
+        (min = ((min > layer.bottom_value) ? layer.bottom_value : min)) unless layer.bottom_value.nil?
+        min 
+      end
+      above_zero = (botval >= 0)
+      botval = (botval - ((top_value - botval) * 0.15)) if padding == :padded
     
       # Don't introduce negative values solely due to padding.
       # A user-provided value must be negative before padding will extend into negative values.
       (above_zero && botval < 0) ? 0 : botval
     end
 
+    def bottom_key(padding=nil)
+      return 0 unless layers.any?
+      min = layers[0].bottom_key
+      layers.each do |layer|
+        min = layer.bottom_key if min.nil? && !layer.bottom_key.nil?
+        (min = ((min > layer.bottom_key) ? layer.bottom_key : min)) unless layer.bottom_key.nil?
+      end
+      min
+    end
+    
+    def top_key(padding=nil)
+      return 1 unless layers.any?
+      max = layers[0].top_key
+      layers.each do |layer|
+        max = layer.top_key if max.nil? && !layer.top_key.nil?
+        (max = ((max < layer.top_key) ? layer.top_key : max)) unless layer.top_key.nil?
+      end
+      max
+    end
 
     protected
       def to_camelcase(type)  # :nodoc:

data/lib/scruffy/helpers/marker_helper.rb

@@ -0,0 +1,25 @@
+module Scruffy::Helpers
+  
+  module Marker
+    
+    def each_marker(markers, min, max, width, options, format_key)
+       all_values = []
+
+      (0...markers).each do |idx|
+        percent = idx.to_f / (markers-1)
+        all_values << min + (max - min) * percent
+      end
+
+      all_values.size.times do |idx|
+        dx = width/(markers - 1)
+        
+        location = idx.to_f * dx #+ dx/2
+        marker_value = all_values[idx]
+        marker_value = options[format_key].route_format(marker_value, idx, options.merge({:all_values => all_values})) if options[format_key]
+
+        yield marker_value, location
+      end  
+
+    end
+  end
+end

data/lib/scruffy/helpers/point_container.rb

@@ -8,27 +8,27 @@ module Scruffy::Helpers
   # Allows all standard point operations to be called on both Array and Hash
   module PointContainer
     def self.extended point_set
-      point_set.extend(const_get(point_set.class.to_s))
+      point_set.extend(const_get("#{point_set.class.to_s}_ext"))
     end
 
-    def sortable_values
-      values.find_all { |v| v.respond_to? :<=> }
+    def sortable(values)
+      values.find_all { |v| v.respond_to?(:<=>) && !v.nil? }
     end
     
-    def summable_values
-      values.find_all { |v| v.respond_to? :+ }
+    def summable(values)
+      values.find_all { |v| v.respond_to?(:+) && !v.nil? }
     end
     
     def maximum_value
-      sortable_values.sort.last
+      sortable(values).sort.last
     end
     
     def minimum_value
-      sortable_values.sort.first
+      sortable(values).sort.first
     end
     
     def sum
-      summable_values.inject(0) { |sum, i| sum += i }
+      summable(values).inject(0) { |sum, i| sum += i }
     end
     
     def inject_with_index memo
@@ -40,24 +40,53 @@ module Scruffy::Helpers
       end
     end
     
-    module Array
+    def minimum_key
+      sortable(keys).sort.first
+    end
+      
+    def maximum_key
+      sortable(keys).sort.last
+    end
+    
+    module Array_ext
       def values
-        self
+        return self unless is_coordinate_list?
+        collect { |x,y| y}
+      end
+      
+      def keys
+        return [0,size-1] unless is_coordinate_list?
+        collect { |x,y| x}
+      end
+      
+      def is_coordinate_list?
+        if any? && first.is_a?(Array) && first.size == 2
+          return true
+        end
+        return false
+      end
+      
+      def each_point(&block)
+        if is_coordinate_list?
+          each{|x,y|block.call(x,y)}
+        else
+          size.times{|k|block.call(k,self[k])}
+        end
       end
     end
     
-    module Hash
-      def minimum_key
-        self.keys.sort.first
+    module Hash_ext
+      def is_coordinate_list?
+        true
       end
       
-      def maximum_key
-        self.keys.sort.last
+      def each_point(&block)
+        keys.sort.each{|k|block.call(k,self[k])}
       end
       
       def inject memo
-        (minimum_key..maximum_key).each do |i|
-          memo = yield memo, self[i]
+        keys.sort.each do |k|
+          memo = yield memo, self[k]
         end
         memo
       end

data/lib/scruffy/layers.rb

@@ -15,10 +15,15 @@ end
 
 require 'scruffy/layers/base'
 require 'scruffy/layers/area'
+require 'scruffy/layers/multi_area'
 require 'scruffy/layers/all_smiles'
 require 'scruffy/layers/bar'
+require 'scruffy/layers/box'
 require 'scruffy/layers/line'
 require 'scruffy/layers/average'
 require 'scruffy/layers/stacked'
+require 'scruffy/layers/multi'
+require 'scruffy/layers/multi_bar'
 require 'scruffy/layers/pie'
-require 'scruffy/layers/pie_slice'
+require 'scruffy/layers/pie_slice'
+require 'scruffy/layers/scatter'

data/lib/scruffy/layers/bar.rb

@@ -8,20 +8,36 @@ module Scruffy::Layers
   class Bar < Base
   
     # Draw bar graph.
+    # Now handles positive and negative values gracefully.
     def draw(svg, coords, options = {})
-      coords.each do |coord|
-        x, y, bar_height = (coord.first-(@bar_width * 0.5)), coord.last, (height - coord.last)
-
-        svg.g(:transform => "translate(-#{relative(0.5)}, -#{relative(0.5)})") {
-          svg.rect( :x => x, :y => y, :width => @bar_width + relative(1), :height => bar_height + relative(1), 
-                    :style => "fill: black; fill-opacity: 0.15; stroke: none;" )
-          svg.rect( :x => x+relative(0.5), :y => y+relative(2), :width => @bar_width + relative(1), :height => bar_height - relative(0.5), 
-                    :style => "fill: black; fill-opacity: 0.15; stroke: none;" )
-
-        }
+      coords.each_with_index do |coord,idx|
+        next if coord.nil?
+        x, y, bar_height = (coord.first), coord.last, 1#(height - coord.last)
+        
+          valh = max_value + min_value * -1 #value_height
+          maxh = max_value * height / valh #positive area height
+          minh = min_value * height / valh #negative area height
+          #puts "height = #{height} and max_value = #{max_value} and min_value = #{min_value} and y = #{y} and point = #{points[idx]}"
+          if points[idx] > 0
+            bar_height = points[idx]*maxh/max_value
+          else
+            bar_height = points[idx]*minh/min_value
+          end
+        
+        #puts " y = #{y} and point = #{points[idx]}"  
+        unless options[:border] == false
+          svg.g(:transform => "translate(-#{relative(0.5)}, -#{relative(0.5)})") {
+            svg.rect( :x => x, :y => y, :width => @bar_width + relative(1), :height => bar_height + relative(1), 
+                      :style => "fill: black; fill-opacity: 0.15; stroke: none;" )
+            svg.rect( :x => x+relative(0.5), :y => y+relative(2), :width => @bar_width + relative(1), :height => bar_height - relative(0.5), 
+                      :style => "fill: black; fill-opacity: 0.15; stroke: none;" )
+          }
+        end
+        
+        current_colour = color.is_a?(Array) ? color[idx % color.size] : color
         
         svg.rect( :x => x, :y => y, :width => @bar_width, :height => bar_height, 
-                  :fill => color.to_s, 'style' => "opacity: #{opacity}; stroke: none;" )
+          :fill => current_colour.to_s, 'style' => "opacity: #{opacity}; stroke: none;" )
       end
     end
 
@@ -34,13 +50,18 @@ module Scruffy::Layers
       # Unfortunately this just mean that bar-graphs and most other graphs
       # end up on different points.  Maybe adding a padding to the coordinates
       # should be a graph-wide thing?
+      #
+      # Update : x-axis coords for lines and area charts should now line
+      # up with the center of bar charts.
+      
       def generate_coordinates(options = {})
-        @bar_width = (width / points.size) * 0.9
+        @bar_width = (width / points.size) * 0.95
         options[:point_distance] = (width - (width / points.size)) / (points.size - 1).to_f
 
         #TODO more array work with index, try to rework to be accepting of hashes
-        coords = (0...points.size).map do |idx| 
-          x_coord = (options[:point_distance] * idx) + (width / points.size * 0.5)
+        coords = (0...points.size).map do |idx|
+          next if points[idx].nil? 
+          x_coord = (options[:point_distance] * idx) + (width / points.size * 0.5) - (@bar_width * 0.5)
 
           relative_percent = ((points[idx] == min_value) ? 0 : ((points[idx] - min_value) / (max_value - min_value).to_f))
           y_coord = (height - (height * relative_percent))