samhendley-scruffy 0.2.7 → 0.2.8

data/lib/scruffy/components/data_markers.rb

@@ -2,8 +2,19 @@ module Scruffy
   module Components
 
     class DataMarkers < Base
-
+      
+      include Scruffy::Helpers::Marker
+      
+      attr_accessor :markers
+      
       def draw(svg, bounds, options={})
+        if (options[:point_markers].nil? || options[:point_markers].empty?) && options[:calculate_markers]
+          markers = (options[:markers] || self.markers) || 5
+          options[:point_markers] = []
+          each_marker(markers, options[:min_key], options[:max_key], bounds[:width], options, :key_formatter) do |label, x|
+            options[:point_markers] << label
+          end
+        end
         unless options[:point_markers].nil?
           point_distance = bounds[:width] / (options[:point_markers].size - 1).to_f
     

data/lib/scruffy/components/graphs.rb

@@ -26,6 +26,8 @@ module Scruffy
           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

data/lib/scruffy/components/grid.rb

@@ -3,14 +3,31 @@ module Scruffy
     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]
         
-        (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};")
+        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: #{options[:theme].marker.to_s}; stroke-width: #{stroke_width};")
+        end
+      end
+    end
+    
+    class VGrid < Base
+      attr_accessor :markers
+      
+      include Scruffy::Helpers::Marker
+      
+      def draw(svg, bounds, options={})
+        markers = (options[:key_markers] || self.markers) || 5
+        
+        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: #{options[:theme].marker.to_s}; stroke-width: #{stroke_width};")
         end
       end
     end

data/lib/scruffy/components/value_markers.rb

@@ -1,31 +1,23 @@
 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]
-
-          svg.text( marker_value.to_s, 
+        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] - marker), 
+            :y => (bounds[:height] - y), 
             '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

data/lib/scruffy/graph.rb

@@ -80,10 +80,12 @@ module Scruffy
 
     # Delegating these getters to the internal state object.
     def_delegators  :internal_state, :title, :theme, :default_type, 
-                    :point_markers, :value_formatter, :rasterizer
+                    :point_markers, :value_formatter, :rasterizer,
+                    :key_formatter
                   
     def_delegators  :internal_state, :title=, :theme=, :default_type=,
-                    :point_markers=, :value_formatter=, :rasterizer=
+                    :point_markers=, :value_formatter=, :rasterizer=,
+                    :key_formatter=
     
     attr_reader :renderer     # Writer defined below
     
@@ -112,6 +114,7 @@ module Scruffy
       self.renderer = Scruffy::Renderers::Standard.new
       self.rasterizer = Scruffy::Rasterizers::RMagickRasterizer.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|
         self.send("#{arg}=".to_sym, options.delete(arg.to_sym)) unless options[arg.to_sym].nil?
@@ -136,14 +139,16 @@ module Scruffy
     def render(options = {})
       options[:theme]               ||= theme
       options[:value_formatter]     ||= value_formatter
+      options[:key_formatter]       ||= key_formatter
       options[:point_markers]       ||= point_markers
       options[:size]                ||= (options[:width] ? [options[:width], (options.delete(:width) * 0.6).to_i] : [600, 360])
       options[:title]               ||= title
       options[:layers]              ||= layers
-      options[:min_value]           ||= bottom_value(:padded)
+      options[:min_value]           ||= bottom_value #(:padded)
       options[:max_value]           ||= top_value
+      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

@@ -15,6 +15,7 @@ module Scruffy
     attr_accessor :default_type
     attr_accessor :point_markers
     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

@@ -76,15 +76,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 }
+      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))
+      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,23 @@
+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 << (max - min) * percent + min
+      end
+
+      all_values.size.times do |idx|
+        location = idx.to_f * width/(markers-1)
+        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
+    def sortable(values)
       values.find_all { |v| v.respond_to? :<=> }
     end
     
-    def summable_values
+    def summable(values)
       values.find_all { |v| v.respond_to? :+ }
     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

@@ -21,4 +21,5 @@ require 'scruffy/layers/line'
 require 'scruffy/layers/average'
 require 'scruffy/layers/stacked'
 require 'scruffy/layers/pie'
-require 'scruffy/layers/pie_slice'
+require 'scruffy/layers/pie_slice'
+require 'scruffy/layers/scatter'

data/lib/scruffy/layers/base.rb

@@ -68,6 +68,7 @@ module Scruffy::Layers
       options[:relativestroke] ||= false
       
       @options            = options
+      
     end
   
     # Builds SVG code for this graph using the provided Builder object.
@@ -75,7 +76,7 @@ module Scruffy::Layers
     # rendering responsibilities to Base#draw.
     #
     # svg:: a Builder object used to create SVG code.
-    def render(svg, options = {})
+    def render(svg, options)
       setup_variables(options)
       coords = generate_coordinates(options)
     
@@ -123,6 +124,16 @@ module Scruffy::Layers
     def bottom_value
        @relevant_data ? points.minimum_value : nil
     end
+    
+    # The highest data point on this layer, or nil if relevant_data == false
+    def bottom_key
+      @relevant_data ? points.minimum_key : nil
+    end
+  
+    # The lowest data point on this layer, or nil if relevant_data == false
+    def top_key
+       @relevant_data ? points.maximum_key : nil
+    end
 
     # The sum of all values
     def sum_values
@@ -144,20 +155,20 @@ module Scruffy::Layers
       # just a best guess, and can be overridden or thrown away (for example, this is overridden
       # in pie charting and bar charts).
       def generate_coordinates(options = {})
-        options[:point_distance] = width / (points.size - 1).to_f
+        
+        dy = height.to_f / (options[:max_value] - options[:min_value])
+        dx = width.to_f / (options[:max_key] - options[:min_key])
 
-        points.inject_with_index([]) do |memo, point, idx|
-          x_coord = options[:point_distance] * idx
+        ret = []
+        points.each_point do |x, y|
+          if y
+            x_coord = dx * (x.to_f - options[:min_key])
+            y_coord = dy * (y.to_f - options[:min_value])
 
-          if point
-            relative_percent = ((point == min_value) ? 0 : ((point - min_value) / (max_value - min_value).to_f))
-            y_coord = (height - (height * relative_percent))
-  
-            memo << [x_coord, y_coord]
+            ret << [x_coord, height - y_coord]
           end
-          
-          memo
         end
+        return ret
       end
     
       # Converts a percentage into a pixel value, relative to the height.

data/lib/scruffy/layers/scatter.rb

@@ -7,15 +7,23 @@ module Scruffy::Layers
   # Simple scatter graph
   class Scatter < Base
     
+    include Scruffy::Helpers::Marker
+    
     # Renders scatter graph.
     def draw(svg, coords, options={})
-      svg.g(:class => 'shadow', :transform => "translate(#{relative(0.5)}, #{relative(0.5)})") {
-        coords.each { |coord| svg.circle( :cx => coord.first, :cy => coord.last + relative(0.9), :r => relative(2), 
-                                          :style => "stroke-width: #{relative(2)}; stroke: black; opacity: 0.35;" ) }
-      }
+      
+      options.merge!(@options)
+      
+      if options[:shadow]
+        svg.g(:class => 'shadow', :transform => "translate(#{relative(0.5)}, #{relative(0.5)})") {
+          coords.each { |coord| svg.circle( :cx => coord.first, :cy => coord.last + relative(0.9), :r => relative(2), 
+                                            :style => "stroke-width: #{relative(2)}; stroke: black; opacity: 0.35;" ) }
+        }
+      end
 
       coords.each { |coord| svg.circle( :cx => coord.first, :cy => coord.last, :r => relative(2), 
                                         :style => "stroke-width: #{relative(2)}; stroke: #{color.to_s}; fill: #{color.to_s}" ) }
     end
   end
-end
+end
+

data/lib/scruffy/layers/stacked.rb

@@ -31,7 +31,7 @@ module Scruffy::Layers
     # Overrides Base#render to fiddle with layers' points to achieve a stacked effect.
     def render(svg, options = {})
       #TODO ensure this works with new points
-      current_points = points.dup
+      current_points = points
       
       layers.each do |layer|
         real_points = layer.points

data/lib/scruffy/renderers/standard.rb

@@ -7,6 +7,7 @@ module Scruffy::Renderers
         components << Scruffy::Components::Viewport.new(:view, :position => [2, 26], :size => [89, 66]) do |graph|
           graph << Scruffy::Components::ValueMarkers.new(:values, :position => [0, 2], :size => [18, 89])
           graph << Scruffy::Components::Grid.new(:grid, :position => [20, 0], :size => [80, 89], :stroke_width => 1)
+          graph << Scruffy::Components::VGrid.new(:vgrid, :position => [20, 0], :size => [80, 89], :stroke_width => 1)
           graph << Scruffy::Components::DataMarkers.new(:labels, :position => [20, 92], :size => [80, 8])
           graph << Scruffy::Components::Graphs.new(:graphs, :position => [20, 0], :size => [80, 89])
         end
@@ -30,7 +31,7 @@ module Scruffy::Renderers
       end
       
       def grids
-        [component(:view).component(:grid)]
+        [component(:view).component(:grid),component(:view).component(:vgrid)]
       end
   end
 end

data/lib/scruffy/version.rb

@@ -2,7 +2,7 @@ module Scruffy
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 2
-    TINY  = 6
+    TINY  = 8
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/graph_creation_test.rb

@@ -1,5 +1,5 @@
 require 'test/unit'
-require 'scruffy'
+require 'test_helper'
 
 class SimpleTheme < Scruffy::Themes::Base
   def initialize
@@ -12,6 +12,13 @@ class SimpleTheme < Scruffy::Themes::Base
   end
 end
 
+$make_png = true
+begin
+  require 'RMagick'
+rescue LoadError
+  $make_png = nil
+end
+
 class GraphCreationTest < Test::Unit::TestCase
   BASE_DIR = File.dirname(__FILE__)
   WEBSITE_DIR = BASE_DIR + "/../website/images/graphs"
@@ -29,7 +36,7 @@ class GraphCreationTest < Test::Unit::TestCase
     }
 
     graph.render :to => "#{WEBSITE_DIR}/pie_test.svg"
-    graph.render :width => 400, :to => "#{WEBSITE_DIR}/pie_test.png", :as => 'png'
+    graph.render :width => 400, :to => "#{WEBSITE_DIR}/pie_test.png", :as => 'png' if $make_png
   end
   
   def test_create_line
@@ -40,7 +47,7 @@ class GraphCreationTest < Test::Unit::TestCase
     graph.add :line, 'Example', [20, 100, 70, 30, 106]
 
     graph.render :to => "#{WEBSITE_DIR}/line_test.svg"
-    graph.render  :width => 400, :to => "#{WEBSITE_DIR}/line_test.png", :as => 'png'
+    graph.render  :width => 400, :to => "#{WEBSITE_DIR}/line_test.png", :as => 'png' if $make_png
   end
 
   
@@ -50,7 +57,7 @@ class GraphCreationTest < Test::Unit::TestCase
     graph.renderer = Scruffy::Renderers::Standard.new
     graph.add :bar, 'Example', [20, 100, 70, 30, 106]
     graph.render :to => "#{WEBSITE_DIR}/bar_test.svg"
-    graph.render  :width => 400, :to => "#{WEBSITE_DIR}/bar_test.png", :as => 'png'
+    graph.render  :width => 400, :to => "#{WEBSITE_DIR}/bar_test.png", :as => 'png' if $make_png
   end
   
   def test_split
@@ -67,7 +74,7 @@ class GraphCreationTest < Test::Unit::TestCase
     graph.point_markers = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
     
     graph.render :to => "#{WEBSITE_DIR}/split_test.svg"
-    graph.render  :width => 500, :to => "#{WEBSITE_DIR}/split_test.png", :as => 'png'
+    graph.render  :width => 500, :to => "#{WEBSITE_DIR}/split_test.png", :as => 'png' if $make_png
   end
   
   def test_stacking
@@ -81,7 +88,7 @@ class GraphCreationTest < Test::Unit::TestCase
     end
     graph.point_markers = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
     graph.render :to => "#{WEBSITE_DIR}/stacking_test.svg"
-    graph.render  :width => 500, :to => "#{WEBSITE_DIR}/stacking_test.png", :as => 'png'
+    graph.render  :width => 500, :to => "#{WEBSITE_DIR}/stacking_test.png", :as => 'png' if $make_png
   end
   
   def test_multi_layered
@@ -96,6 +103,18 @@ class GraphCreationTest < Test::Unit::TestCase
     graph.add :line, 'Jim', [-10, -20, 50, 92, -21, 56], :categories => [:top_left, :bottom_right]
     graph.point_markers = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
     graph.render :to => "#{WEBSITE_DIR}/multi_test.svg"
-    graph.render  :width => 500, :to => "#{WEBSITE_DIR}/multi_test.png", :as => 'png'
+    graph.render  :width => 500, :to => "#{WEBSITE_DIR}/multi_test.png", :as => 'png' if $make_png
+  end
+  
+  def test_scatter
+    graph = Scruffy::Graph.new
+    graph.title = "Some Kind of Information"
+    graph.renderer = Scruffy::Renderers::Standard.new
+
+    graph.add :scatter, 'Stephanie', {0 => 0, 1 => 1, 2 => 4, 3 => 9, 4 => 8, 5 => 10, 6 => 12, 7 => 3, 8 => 13}    
+    graph.add :line, 'Artiom', {-3 => 2, 1.5 => 6, 2 => 4.5, 15 => -4}, :dots => true   
+    graph.add :scatter, 'Sam', [[-3,15], [1.5,18], [2,9], [15,6]]   
+    graph.render :to => "#{WEBSITE_DIR}/scatter_test.svg"
+    graph.render  :width => 500, :to => "#{WEBSITE_DIR}/scatter_test.png", :as => 'png' if $make_png
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: samhendley-scruffy
 version: !ruby/object:Gem::Version 
-  version: 0.2.7
+  version: 0.2.8
 platform: ruby
 authors: 
 - Brasten Sager
@@ -24,16 +24,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 2.0.0
     version: 
-- !ruby/object:Gem::Dependency 
-  name: hoe
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.7.0
-    version: 
 description: Scruffy is a Ruby library for generating high quality, good looking graphs. It is designed to be easy to use and highly customizable.
 email: 
 - brasten@nagilum.com
@@ -66,6 +56,7 @@ files:
 - lib/scruffy/helpers/point_container.rb
 - lib/scruffy/helpers/layer_container.rb
 - lib/scruffy/helpers/meta.rb
+- lib/scruffy/helpers/marker_helper.rb
 - lib/scruffy/components.rb
 - lib/scruffy/graph_state.rb
 - lib/scruffy/components/style_info.rb
@@ -94,8 +85,10 @@ files:
 - lib/scruffy/layers.rb
 - lib/scruffy.rb
 - LICENCE.txt
+- History.txt
 - README.txt
 - CHANGES.txt
+- Manifest.txt
 has_rdoc: true
 homepage: http://scruffy.rubyforge.org
 post_install_message: