ruby-googlechart 0.6.4

data/test/google_chart/test_bar_style.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestBarStyle < Test::Unit::TestCase
+  def setup
+    @klass = Class.new(MockChart).class_eval { include GoogleChart::BarStyle }
+  end
+  
+  should 'not display bar style parameter by default' do
+    assert_no_match(/\bchbh=/, @klass.new.to_url)
+  end
+  
+  should 'display with custom bar width' do
+    assert_match(/\bchbh=10\b/, @klass.new(:width => 10).to_url)
+  end
+  
+  should 'display with custom bar width and spacing' do
+    assert_match(/\bchbh=8,6\b/, @klass.new(:width => 8, :spacing => 6).to_url)
+  end
+  
+  should 'display with custom bar width, spacing and group spacing' do
+    assert_match(/\bchbh=10,4,12\b/, @klass.new(:width => 10, :spacing => [4,12]).to_url)
+  end
+end

data/test/google_chart/test_color.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestColor < Test::Unit::TestCase
+  def setup
+    @klass = Class.new(MockChart).class_eval { include GoogleChart::Color }
+  end
+  
+  should 'not display color parameter by default' do
+    assert_no_match(/\bchco=/, @klass.new.to_url)
+  end
+  
+  should 'display single color parameter' do
+    assert_match(/\bchco=ff0000\b/, @klass.new(:color => 'ff0000').to_url)
+  end
+  
+  should 'display multiple color parameters' do
+    assert_match(/\bchco=ff0000,00ff00,0000ff\b/, @klass.new(:color => %w[ff0000 00ff00 0000ff]).to_url)
+  end
+  
+  should 'convert 3-digit colors to 6-digit colors'
+end

data/test/google_chart/test_data.rb

@@ -0,0 +1,142 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestData < Test::Unit::TestCase
+  def setup
+    @klass = Class.new(MockChart).class_eval { include GoogleChart::Data }
+  end
+  
+  should 'use simple encoding by default' do
+    assert_match(/\bchd=s:AB89\b/, @klass.new(:data => [0, 1, 60, 61]).to_url)
+  end
+  
+  should 'raise an ArgumentError if data set is empty' do
+    assert_raise(ArgumentError, /1 non-nil value/) { @klass.new(:data => []) }
+  end
+  
+  should 'raise an ArgumentError if data set contains only nils' do
+    assert_raise(ArgumentError, /1 non-nil value/) { @klass.new(:data => [nil, nil]) }
+  end
+  
+  should 'not raise an ArgumentError if only one of many data sets contains only nils' do
+    assert_nothing_raised(ArgumentError) { @klass.new(:data => [[nil, nil], [nil, 1]]) }
+  end
+  
+  should 'auto-scale between 0 and maximum value among all data sets' do
+    assert_match(/\bchd=s:67,89\b/, @klass.new(:data => [[58, 59], [60, 61]]).to_url)
+  end
+  
+  should 'be able to auto-scale data sets with nils' do
+    assert_match(/\bchd=s:A_9\b/, @klass.new(:data => [0, nil, 100]).to_url)
+  end
+  
+  should 'be able to auto-scale data sets with one empty set' do
+    assert_match(/\bchd=s:__,A9\b/, @klass.new(:data => [[nil, nil], [0, 100]]).to_url)
+  end
+  
+  should 'encode data with high-pass filter when auto-scaling' do
+    assert_match(/\bchd=s:AAB89\b/, @klass.new(:data => [-1, 0, 1, 60, 61]).to_url)
+  end
+  
+  should 'encode data with band-pass filter when manual-scaling' do
+    assert_match(/\bchd=s:AB899\b/, @klass.new(:data => [-5, -1, 99, 100, 102], :scale => -3..100).to_url)
+  end
+  
+  context 'simple encoding' do
+    setup { @chart = @klass.new(:encoding => :simple) }
+    
+    should 'encode dataset with auto-scaling' do
+      @chart.data = [0, 15, 10]
+      assert_match(/\bchd=s:A9o\b/, @chart.to_url)
+    end
+    
+    should 'encode dataset with manual scaling' do
+      @chart.data = [0, 15, 10]
+      @chart.scale = 0..20
+      assert_match(/\bchd=s:Ate\b/, @chart.to_url)
+    end
+    
+    should 'encode multiple datasets' do
+      @chart.data = [[9, 15], [24, 7]]
+      @chart.scale = 0..61
+      assert_match(/\bchd=s:JP,YH\b/, @chart.to_url)
+    end
+    
+    should 'encode floating point data' do
+      @chart.data = [50.5, 33.4]
+      @chart.scale = 0..61
+      assert_match(/\bchd=s:yh\b/, @chart.to_url)
+    end
+    
+    should 'encode missing data' do
+      @chart.data = [50, nil, 33]
+      @chart.scale = 0..61
+      assert_match(/\bchd=s:y_h\b/, @chart.to_url)
+    end
+  end
+  
+  context 'extended encoding' do
+    setup { @chart = @klass.new(:encoding => :extended) }
+    
+    should 'encode dataset with auto-scaling' do
+      @chart.data = [0, 15, 10]
+      assert_match(/\bchd=e:AA\.\.qq\b/, @chart.to_url)
+    end
+    
+    should 'encode dataset with manual scaling' do
+      @chart.data = [15, 10, 0]
+      @chart.scale = 0..20
+      assert_match(/\bchd=e:v\.f\.AA\b/, @chart.to_url)
+    end
+    
+    should 'encode multiple datasets' do
+      @chart.data = [[2281, 3233], [591, 1543]]
+      @chart.scale = 0..4095
+      assert_match(/\bchd=e:jpyh,JPYH\b/, @chart.to_url)
+    end
+    
+    should 'encode floating point data' do
+      @chart.data = [2281.49, 3233.50]
+      @chart.scale = 0..4095
+      assert_match(/\bchd=e:jpyh\b/, @chart.to_url)
+    end
+    
+    should 'encode missing data' do
+      @chart.data = [2281, nil, 3233]
+      @chart.scale = 0..4095
+      assert_match(/\bchd=e:jp__yh\b/, @chart.to_url)
+    end
+  end
+  
+  context 'text encoding' do
+    setup { @chart = @klass.new(:encoding => :text) }
+    
+    should 'encode dataset with auto-scaling' do
+      @chart.data = [0, 15, 10]
+      assert_match(/\bchd=t:0,100,66.7\b/, @chart.to_url)
+    end
+    
+    should 'encode dataset with manual scaling' do
+      @chart.data = [0, 15, 10]
+      @chart.scale = 0..20
+      assert_match(/\bchd=t:0,75,50\b/, @chart.to_url)
+    end
+    
+    should 'encode multiple datasets' do
+      @chart.data = [[6, 14], [5, 23]]
+      @chart.scale = 0..100
+      assert_match(/\bchd=t:6,14\|5,23\b/, @chart.to_url)
+    end
+    
+    should 'rounds floating point data to the nearest tenth' do
+      @chart.data = [5.95, 14.01, 5.23]
+      @chart.scale = 0..100
+      assert_match(/\bchd=t:6,14,5.2\b/, @chart.to_url)
+    end
+    
+    should 'encode missing data' do
+      @chart.data = [6, nil, 14]
+      @chart.scale = 0..100
+      assert_match(/\bchd=t:6,-1,14\b/, @chart.to_url)
+    end
+  end
+end

data/test/google_chart/test_grid_line.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestGridLine < Test::Unit::TestCase
+  def setup
+    @klass = Class.new(MockChart).class_eval { include GoogleChart::GridLine }
+  end
+  
+  should 'not display grid lines by default' do
+    assert_no_match(/\bchg=/, @klass.new.to_url)
+  end
+  
+  should 'display vertical grid lines' do
+    assert_match(/\bchg=5,0\b/, @klass.new(:grid => {:x => 5}).to_url)
+  end
+  
+  should 'display horizontal grid lines' do
+    assert_match(/\bchg=0,5\b/, @klass.new(:grid => {:y => 5}).to_url)
+  end
+  
+  should 'display horizontal and vertical grid lines' do
+    assert_match(/\bchg=6,14\b/, @klass.new(:grid => {:x => 6, :y => 14}).to_url)
+  end
+  
+  should 'display solid grid lines' do
+    assert_match(/\bchg=8,16,1,0\b/, @klass.new(:grid => {:x => 8, :y => 16, :style => :solid}).to_url)
+  end
+  
+  should 'display dashed grid lines' do
+    assert_match(/\bchg=8,16,3,2\b/, @klass.new(:grid => {:x => 8, :y => 16, :style => :dash}).to_url)
+  end
+  
+  should 'display dotted grid lines' do
+    assert_match(/\bchg=8,16,1,2\b/, @klass.new(:grid => {:x => 8, :y => 16, :style => :dot}).to_url)
+  end
+end

data/test/google_chart/test_legend.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestLegend < Test::Unit::TestCase
+  def setup
+    @klass = Class.new(MockChart).class_eval { include GoogleChart::Legend }
+  end
+  
+  should 'not display legend by default' do
+    assert_no_match(/\bchdl=/, @klass.new.to_url)
+  end
+  
+  should 'display legend for single dataset' do
+    assert_match(/\bchdl=Foo\b/, @klass.new(:legend => 'Foo').to_url)
+  end
+  
+  should 'display legend for multiple datasets' do
+    assert_match(/\bchdl=Foo\|Bar\|Baz\b/, @klass.new(:legend => %w[Foo Bar Baz]).to_url)
+  end
+  
+  should 'escape legend text for url' do
+    assert_match(/\bchdl=Foo\+Bar%7CBaz\b/, @klass.new(:legend => 'Foo Bar|Baz').to_url)
+  end
+  
+  should 'convert non-String legend keys to Strings' do
+    assert_match(/\bchdl=foo\|\|1\b/, @klass.new(:legend => ['foo', nil, 1]).to_url)
+  end
+end

data/test/google_chart/test_line_chart.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestLineChart < Test::Unit::TestCase
+  should 'have a default chart type' do
+    assert_match(/\bcht=lc\b/, GoogleChart::LineChart.new.to_url)
+  end
+  
+  should 'support xy chart type' do
+    assert_match(/\bcht=lxy\b/, GoogleChart::LineChart.new(:type => :xy).to_url)
+  end
+  
+  should 'support sparkline chart type' do
+    assert_match(/\bcht=ls\b/, GoogleChart::LineChart.new(:type => :sparkline).to_url)
+  end
+  
+  should 'support line as chart type' do
+    assert_match(/\bcht=lc\b/, GoogleChart::LineChart.new(:type => :line).to_url)
+  end
+  
+  should 'include Axis module' do
+    assert GoogleChart::Axis === GoogleChart::LineChart.new
+  end
+  
+  should 'include Color module' do
+    assert GoogleChart::Color === GoogleChart::LineChart.new
+  end
+  
+  should 'include Data module' do
+    assert GoogleChart::Data === GoogleChart::LineChart.new
+  end
+  
+  should 'include GridLine module' do
+    assert GoogleChart::GridLine === GoogleChart::LineChart.new
+  end
+  
+  should 'include Legend module' do
+    assert GoogleChart::Legend === GoogleChart::LineChart.new
+  end
+  
+  should 'include LineStyle module' do
+    assert GoogleChart::LineStyle === GoogleChart::LineChart.new
+  end
+  
+  should 'include RangeMarker module' do
+    assert GoogleChart::RangeMarker === GoogleChart::LineChart.new
+  end
+  
+  should 'include Title module' do
+    assert GoogleChart::Title === GoogleChart::LineChart.new
+  end
+end

data/test/google_chart/test_line_style.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestLineStyle < Test::Unit::TestCase
+  def setup
+    @klass = Class.new(MockChart).class_eval { include GoogleChart::LineStyle }
+  end
+  
+  should 'not include line styles by default' do
+    assert_no_match(/\bchls=/, @klass.new.to_url)
+  end
+  
+  should 'support solid lines' do
+    assert_match(/\bchls=1,1,0\b/, @klass.new(:style => :solid).to_url)
+  end
+  
+  should 'support dashed lines' do
+    assert_match(/\bchls=1,3,2\b/, @klass.new(:style => :dash).to_url)
+  end
+  
+  should 'support dotted lines' do
+    assert_match(/\bchls=1,1,2\b/, @klass.new(:style => :dot).to_url)
+  end
+  
+  should 'support multiple line styles' do
+    assert_match(/\bchls=1,3,2\|1,1,2\|1,1,0\b/, @klass.new(:style => [:dash, :dot, :solid]).to_url)
+  end
+  
+  should 'support custom line width' do
+    assert_match(/\bchls=2,2,0\b/, @klass.new(:width => 2).to_url)
+  end
+  
+  should 'support named line style with custom width' do
+    assert_match(/\bchls=2,6,4\b/, @klass.new(:style => :dash, :width => 2).to_url)
+  end
+  
+  should 'support multiple line styles and multiple custom widths' do
+    assert_match(/\bchls=2,2,4\|3,9,6\b/, @klass.new(:style => [:dot, :dash], :width => [2, 3]).to_url)
+  end
+  
+  should 'use default line width if there are more styles than widths' do
+    assert_match(/\bchls=2,2,4\|1,3,2\|1,1,0\b/, @klass.new(:style => [:dot, :dash, :solid], :width => 2).to_url)
+  end
+  
+  should 'use default line style if there are more widths than styles' do
+    assert_match(/\bchls=2,2,4\|3,3,0\|2,2,0\b/, @klass.new(:style => :dot, :width => [2, 3, 2]).to_url)
+  end
+end

data/test/google_chart/test_range_marker.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestRangeMarker < Test::Unit::TestCase
+  def setup
+    @klass = Class.new(MockChart).class_eval { include GoogleChart::RangeMarker }
+  end
+  
+  should 'not have range markers by default' do
+    assert_no_match(/\bchm=/, @klass.new.to_url)
+  end
+  
+  should 'display horizontal range markers' do
+    assert_match(/\bchm=r,000000cc,x,0.45,0.55\b/, @klass.new(:ranges => [:h, 0.45, 0.55]).to_url)
+  end
+  
+  should 'display vertical range markers' do
+    assert_match(/\bchm=R,000000cc,x,0.45,0.55\b/, @klass.new(:ranges => [:v, 0.45, 0.55]).to_url)
+  end
+  
+  should 'display multiple range markers' do
+    assert_match(/\bchm=r,000000cc,x,0.1,0.2\|R,000000cc,x,0.3,0.4\b/, @klass.new(:ranges => [[:h, 0.1, 0.2], [:v, 0.3, 0.4]]).to_url)
+  end
+  
+  should 'display range markers with custom colors' do
+    assert_match(/\bchm=r,abcdef,x,0.4,0.6\b/, @klass.new(:ranges => [:h, 'abcdef', 0.4, 0.6]).to_url)
+  end
+end

data/test/google_chart/test_title.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TestTitle < Test::Unit::TestCase
+  def setup
+    @klass = Class.new(MockChart).class_eval { include GoogleChart::Title }
+  end
+  
+  should 'not have a title by default' do
+    assert_no_match(/\bchtt=/, @klass.new.to_url)
+  end
+  
+  should 'url-encode title' do
+    assert_match(/\bchtt=foo\+bar\b/, @klass.new(:title => 'foo bar').to_url)
+  end
+end

data/test/test_google_chart.rb

@@ -0,0 +1,103 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestGoogleChart < Test::Unit::TestCase
+  context '#Line' do
+    context 'with hash parameters' do
+      setup do
+        @url = GoogleChart.Line(:size => '1000x300', :data => [[35, 41], [50, 33]], :scale => 0..61)
+      end
+      
+      should 'return Google Chart URL' do
+        assert_match(%r{\Ahttp://chart\.apis\.google\.com/chart\?}, @url)
+      end
+      
+      should 'include chart type parameter' do
+        assert_match(/\bcht=lc\b/, @url)
+      end
+      
+      should 'include chart size parameter' do
+        assert_match(/\bchs=1000x300\b/, @url)
+      end
+      
+      should 'include chart data parameter' do
+        assert_match(/\bchd=s:jp,yh\b/, @url)
+      end
+    end
+    
+    context 'with block parameters' do
+      setup do
+        @url = GoogleChart.Line do |c|
+          c.size = '800x375'
+          c.data = [[35, 41], [50, 33]]
+          c.scale = 0..61
+        end
+      end
+      
+      should 'return Google Chart URL' do
+        assert_match(%r{\Ahttp://chart\.apis\.google\.com/chart\?}, @url)
+      end
+      
+      should 'include chart type parameter' do
+        assert_match(/\bcht=lc\b/, @url)
+      end
+      
+      should 'include chart size parameter' do
+        assert_match(/\bchs=800x375\b/, @url)
+      end
+      
+      should 'include chart data parameter' do
+        assert_match(/\bchd=s:jp,yh\b/, @url)
+      end
+    end
+  end
+  
+  context '#Bar' do
+    context 'with hash parameters' do
+      setup do
+        @url = GoogleChart.Bar(:size => '1000x300', :data => [[35, 41], [50, 33]], :scale => 0..61)
+      end
+      
+      should 'return Google Chart URL' do
+        assert_match(%r{\Ahttp://chart\.apis\.google\.com/chart\?}, @url)
+      end
+      
+      should 'include chart type parameter' do
+        assert_match(/\bcht=bvg\b/, @url)
+      end
+      
+      should 'include chart size parameter' do
+        assert_match(/\bchs=1000x300\b/, @url)
+      end
+      
+      should 'include chart data parameter' do
+        assert_match(/\bchd=s:jp,yh\b/, @url)
+      end
+    end
+    
+    context 'with block parameters' do
+      setup do
+        @url = GoogleChart.Bar do |c|
+          c.size = '800x375'
+          c.data = [[35, 41], [50, 33]]
+          c.scale = 0..61
+        end
+      end
+      
+      should 'return Google Chart URL' do
+        assert_match(%r{\Ahttp://chart\.apis\.google\.com/chart\?}, @url)
+      end
+      
+      should 'include chart type parameter' do
+        assert_match(/\bcht=bvg\b/, @url)
+      end
+      
+      should 'include chart size parameter' do
+        assert_match(/\bchs=800x375\b/, @url)
+      end
+      
+      should 'include chart data parameter' do
+        assert_match(/\bchd=s:jp,yh\b/, @url)
+      end
+    end
+  end
+end