texel-gchart 0.5.0

data/CHANGELOG.txt

@@ -0,0 +1,43 @@
+== 0.5.0 (2008-04-17)
+
+  * Support for Map charts
+  * Support for Sparkline charts
+  * Initial support for Google-o-meter
+
+== UNRELEASED
+
+  * Freeze GChart::VERSION.
+
+== 0.4.2 (2008-01-09)
+
+  * Encoding a flatlined chart doesn't asplode [Jack Danger Canty]
+
+== 0.4.1 (2008-01-02)
+
+  * (bug #16756 fixed) Example in the README is incorrect
+
+== 0.4.0 (2007-12-28)
+
+  * New committer, Abhay Kumar
+  * Implement all three encodings. Fix extended encoding calculation.
+  * Support bar thickness/spacing for bar charts
+  * (bug #16565 fixed) GChart now tells you when your chart is too big.
+  * Pushed some bar chart params logic down where it belongs
+  * Enforce pie chart spec: pie charts only take one set of data
+
+== 0.3.0 (2007-12-24)
+  
+  * Breaking change: labels --> legend
+  * Switched to RSpec, added skeletal specs for all types
+  * Extensive refactoring, pulled chart types into GChart::Base subclasses
+  * (bug) Errors in the static helpers should report a reasonable file and line
+
+== 0.2.0 (2007-12-12)
+
+  * Support for basic :labels
+  * Support for pie3d
+  * Minor doc cleanups
+
+== 0.1.0 (2007-12-10)
+
+  * Birthday!

data/Manifest.txt

@@ -0,0 +1,31 @@
+CHANGELOG.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/gchart.rb
+lib/gchart/bar.rb
+lib/gchart/base.rb
+lib/gchart/line.rb
+lib/gchart/map.rb
+lib/gchart/meter.rb
+lib/gchart/pie.rb
+lib/gchart/pie_3d.rb
+lib/gchart/scatter.rb
+lib/gchart/sparkline.rb
+lib/gchart/venn.rb
+lib/gchart/xy_line.rb
+lib/version.rb
+spec/gchart/bar_spec.rb
+spec/gchart/base_spec.rb
+spec/gchart/line_spec.rb
+spec/gchart/map_spec.rb
+spec/gchart/meter_spec.rb
+spec/gchart/pie_3d_spec.rb
+spec/gchart/pie_spec.rb
+spec/gchart/scatter_spec.rb
+spec/gchart/sparkline_spec.rb
+spec/gchart/venn_spec.rb
+spec/gchart/xy_line_spec.rb
+spec/gchart_spec.rb
+spec/helper.rb
+spec/spec.opts

data/README.txt

@@ -0,0 +1,81 @@
+= GChart
+
+== DESCRIPTION
+  
+GChart exposes the Google Chart API (http://code.google.com/apis/chart) via
+a friendly Ruby interface. It can generate the URL for a given chart
+(for webpage use), or download the generated PNG (for offline use).
+
+== PROBLEMS/TODO
+
+* Add support fills (area or background), grid lines, shape markers, range markers 
+* Support shorthand colors and color names
+* Make venn data specification friendlier
+
+There are lots of missing features. Until they're implemented, you can directly specify
+query parameters using the :extras key, e.g.,
+
+  # provides a legend for each data set
+  g = GChart.line(:data => [[1, 2], [3, 4]], :extras => { "chdl" => "First|Second"})
+
+== SYNOPSIS
+
+  # line chart
+  g = GChart.line(:data => [0, 10, 100])
+  
+  # bar chart
+  g = GChart.bar(:data => [100, 1000, 10000])
+  
+  # pie chart (pie3d for a fancier look)
+  g = GChart.pie(:data => [33, 33, 34])
+  
+  # venn diagram (asize, bsize, csize, ab%, bc%, ca%, abc%)
+  g = GChart.venn(:data => [100, 80, 60, 30, 30, 30, 10])
+  
+  # scatter plot (x coords, y coords [, sizes])
+  g = GChart.scatter(:data => [[1, 2, 3, 4, 5], [5, 4, 3, 2, 1], [1, 2, 3, 4, 5]])
+
+  # map chart
+  g = GChart.map(:area => 'usa', :data => {'NY'=>1,'VA'=>3,'CA'=>2})
+  
+  # meter
+  g = GChart.meter(:data => 70, :label => "70%")
+  
+  # chart title
+  g = GChart.line(:title => "Awesomeness over Time", :data => [0, 10, 100])
+
+  # data set legend
+  g = GChart.line(:data => [[1, 2], [3, 4]], :legend => ["Monkeys", "Ferrets"])
+
+  # data set colors
+  g = GChart.line(:data => [[0, 10, 100], [100, 10, 0]], :colors => ["ff0000", "0000ff"])
+  
+  g.to_url            # generate the chart's URL, or
+  g.fetch             # get the bytes, or
+  g.write("foo.png")  # write to a file (defaults to "chart.png")
+  g.write(stream)     # write to anything that quacks like IO
+
+== LICENSE
+
+(The MIT License)
+
+Copyright 2007-2008 John Barnette (jbarnette@rubyforge.org)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,31 @@
+require "rubygems"
+require "hoe"
+require "spec/rake/spectask"
+
+require "./lib/version.rb"
+
+hoe = Hoe.new("gchart", GChart::VERSION) do |p|
+  p.rubyforge_name = "gchart"
+  p.author = "John Barnette"
+  p.email = "jbarnette@rubyforge.org"
+  p.summary = "GChart uses the Google Chart API to create pretty pictures."
+  p.description = p.paragraphs_of("README.txt", 2..5).join("\n\n")
+  p.url = "http://gchart.rubyforge.org"
+  p.changes = p.paragraphs_of("CHANGELOG.txt", 0..1).join("\n\n")
+end
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList["spec/**/*_spec.rb"]
+  t.spec_opts = ["--options", "spec/spec.opts"]
+end
+
+desc "Run all specs and get coverage statistics"
+Spec::Rake::SpecTask.new('spec:rcov') do |t|
+  t.spec_files = FileList["spec/**/*_spec.rb"]
+  t.rcov = true
+  t.spec_opts = ["--options", "spec/spec.opts"]
+end
+
+Rake::Task[:default].prerequisites.clear
+task :default => :spec

data/lib/gchart.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.dirname(__FILE__) + "/version")
+
+%w(base bar line map meter pie pie_3d scatter sparkline venn xy_line).each do |type|
+  require File.expand_path(File.dirname(__FILE__) + "/gchart/#{type}")
+end
+
+module GChart
+  URL   = "http://chart.apis.google.com/chart"
+  SIMPLE_CHARS = ('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a
+  EXTENDED_CHARS = ('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a + %w[- .]
+  EXTENDED_PAIRS = EXTENDED_CHARS.collect { |first| EXTENDED_CHARS.collect { |second| first + second } }.flatten
+
+  class << self
+    # Convenience constructor for GChart::Line.
+    def line(*args, &block); Line.new(*args, &block) end
+    
+    # Convenience constructor for GChart::XYLine.
+    def xyline(*args, &block); XYLine.new(*args, &block) end
+    
+    # Convenience constructor for GChart::Bar.
+    def bar(*args, &block); Bar.new(*args, &block) end    
+    
+    # Convenience constructor for GChart::Map.
+    def map(*args, &block); Map.new(*args, &block) end    
+
+    # Convenience constructor for GChart::Meter.
+    def meter(*args, &block); Meter.new(*args, &block) end    
+
+    # Convenience constructor for GChart::Pie.
+    def pie(*args, &block); Pie.new(*args, &block) end    
+    
+    # Convenience constructor for GChart::Pie3D.
+    def pie3d(*args, &block); Pie3D.new(*args, &block) end    
+    
+    # Convenience constructor for GChart::Line.
+    def sparkline(*args, &block); Sparkline.new(*args, &block) end
+
+    # Convenience constructor for GChart::Venn.
+    def venn(*args, &block); Venn.new(*args, &block) end    
+    
+    # Convenience constructor for GChart::Scatter.
+    def scatter(*args, &block); Scatter.new(*args, &block) end
+    
+    # Encode +n+ as a string. +n+ is normalized based on +max+.
+    # +encoding+ can currently only be :extended.
+    def encode(encoding, n, max)
+      case encoding
+      when :simple
+        return "_" if n.nil?
+        SIMPLE_CHARS[((n/max.to_f) * (SIMPLE_CHARS.size - 1)).round]
+      when :text
+        return "-1" if n.nil?
+        ((((n/max.to_f) * 1000.0).round)/10.0).to_s
+      when :extended
+        return "__" if n.nil?
+        EXTENDED_PAIRS[max.zero? ? 0 : ((n/max.to_f) * (EXTENDED_PAIRS.size - 1)).round]
+      else
+        raise ArgumentError, "unsupported encoding: #{encoding.inspect}"
+      end
+    end
+  end
+end

data/lib/gchart/bar.rb

@@ -0,0 +1,60 @@
+module GChart
+  class Bar < GChart::Base
+    ORIENTATIONS = [:horizontal, :vertical]
+    
+    attr_accessor :grouped
+    alias_method :grouped?, :grouped
+    
+    attr_reader :orientation
+    
+    attr_reader :thickness
+    attr_reader :spacing
+    
+    def initialize(*args, &block)
+      @grouped = false
+      @orientation = :horizontal
+      super
+    end
+    
+    def orientation=(orientation)
+      unless ORIENTATIONS.include?(orientation)
+        raise ArgumentError, "Invalid orientation: #{orientation.inspect}. " +
+          "Valid orientations: #{ORIENTATIONS.inspect}"
+      end
+      
+      @orientation = orientation
+    end
+    
+    def horizontal?
+      @orientation == :horizontal
+    end
+
+    def vertical?
+      @orientation == :vertical
+    end
+    
+    def thickness=(thickness)
+      raise ArgumentError, "Invalid thickness: #{thickness.inspect}" if thickness.nil? || thickness < 1
+      @thickness = thickness
+    end
+    
+    def spacing=(spacing)
+      raise ArgumentError, "Invalid spacing: #{spacing.inspect}" if spacing.nil? || spacing < 1
+      @spacing = spacing
+    end
+
+    # overrides GChart::Base#query_params
+    def query_params(params={}) #:nodoc:
+      values = []
+      values << thickness if thickness
+      values << spacing if thickness && spacing
+      
+      params["chbh"] = values.join(",") unless values.empty?
+      super(params)
+    end
+  
+    def render_chart_type #:nodoc:
+      "b#{@orientation.to_s[0..0]}#{grouped? ? "g" : "s"}"
+    end
+  end
+end

data/lib/gchart/base.rb

@@ -0,0 +1,133 @@
+require "open-uri"
+require "uri"
+
+module GChart
+  class Base
+    # Array of chart data. See subclasses for specific usage.
+    attr_accessor :data
+    
+    # Hash of additional HTTP query params.
+    attr_accessor :extras
+    
+    # Chart title.
+    attr_accessor :title
+    
+    # Array of rrggbb colors, one per data set.
+    attr_accessor :colors
+    
+    # Array of legend text, one per data set.
+    attr_accessor :legend
+    
+    # Max data value for quantization.
+    attr_accessor :max
+
+    # Chart width, in pixels.
+    attr_reader :width    
+    
+    # Chart height, in pixels.
+    attr_reader :height
+
+    def initialize(options={}, &block)
+      @data = []
+      @extras = {}
+      @width = 300
+      @height = 200
+  
+      options.each { |k, v| send("#{k}=", v) }
+      yield(self) if block_given?
+    end
+
+    # Sets the chart's width, in pixels. Raises +ArgumentError+
+    # if +width+ is less than 1 or greater than 1,000.
+    def width=(width)
+      if width.nil? || width < 1 || width > 1_000
+        raise ArgumentError, "Invalid width: #{width.inspect}"
+      end
+
+      @width = width
+    end
+
+    # Sets the chart's height, in pixels. Raises +ArgumentError+
+    # if +height+ is less than 1 or greater than 1,000.
+    def height=(height)
+      if height.nil? || height < 1 || height > 1_000
+        raise ArgumentError, "Invalid height: #{height.inspect}"         
+      end
+      
+      @height = height
+    end
+
+    # Returns the chart's size as "WIDTHxHEIGHT".
+    def size
+      "#{width}x#{height}"
+    end
+
+    # Sets the chart's size as "WIDTHxHEIGHT". Raises +ArgumentError+
+    # if +width+ * +height+ is greater than 300,000 pixels.
+    def size=(size)
+      self.width, self.height = size.split("x").collect { |n| Integer(n) }
+      
+      if (width * height) > 300_000
+        raise ArgumentError, "Invalid size: #{size.inspect} yields a graph with more than 300,000 pixels"
+      end
+    end
+
+    # Returns the chart's URL.
+    def to_url
+      query = query_params.collect { |k, v| "#{k}=#{URI.escape(v)}" }.join("&")
+      "#{GChart::URL}?#{query}"
+    end
+
+    # Returns the chart's generated PNG as a blob.
+    def fetch
+      open(to_url) { |io| io.read }
+    end
+
+    # Writes the chart's generated PNG to a file. If +io_or_file+ quacks like an IO,
+    # calls +write+ on it instead.
+    def write(io_or_file="chart.png")
+      return io_or_file.write(fetch) if io_or_file.respond_to?(:write)
+      open(io_or_file, "w+") { |io| io.write(fetch) }
+    end
+
+    protected
+    
+    def query_params(raw_params={}) #:nodoc:
+      params = raw_params.merge("cht" => render_chart_type, "chs" => size)
+      
+      render_data(params)
+      render_title(params)
+      render_colors(params)
+      render_legend(params)
+
+      params.merge(extras)
+    end
+
+    def render_chart_type #:nodoc:
+      raise NotImplementedError, "override in subclasses"
+    end
+    
+    def render_data(params) #:nodoc:
+      raw = data && data.first.is_a?(Array) ? data : [data]
+      max = self.max || raw.collect { |s| s.max }.max
+  
+      sets = raw.collect do |set|
+        set.collect { |n| GChart.encode(:extended, n, max) }.join
+      end
+  
+      params["chd"] = "e:#{sets.join(",")}"
+    end
+    
+    def render_title(params) #:nodoc:
+      params["chtt"] = title.tr("\n ", "|+") if title
+    end
+    
+    def render_colors(params) #:nodoc:
+      params["chco"] = colors.join(",") if colors  
+    end
+    
+    def render_legend(params) #:nodoc:
+      params["chdl"] = legend.join("|") if legend
+    end    
+  end
+end

data/lib/gchart/line.rb

@@ -0,0 +1,7 @@
+module GChart
+  class Line < GChart::Base
+    def render_chart_type #:nodoc:
+      "lc"
+    end
+  end
+end

data/lib/gchart/map.rb

@@ -0,0 +1,71 @@
+module GChart
+  class Map < GChart::Base
+    AREAS = %w[africa asia europe middle_east south_america usa world]
+    attr_accessor :area
+    attr_accessor :area_codes
+    attr_accessor :background
+    
+    def initialize(*args, &block)
+      super(*args, &block)
+      # Set some sane defaults so that the only requirement is data
+      @area = 'world' #default
+      @background = 'dfdfff' #make it look like water
+      @colors = ['ffffff','f8fcf8','006c00']
+      #Set the maximum size for maps (this is a better default because
+      # it is also the proper aspect ratio)
+      @width = '440'
+      @height = '220'
+    end
+    
+    # Map data can be in the form {"VA'=>5,'NY'=>1} or [['VA',5],['NY',1]]
+    # Raises +ArgumentError+ if data does not fit these forms.
+    def data=(data)
+      if data.is_a?(Array) && data.any?{ |pair| pair.size != 2 }
+        raise ArgumentError, "Data array must contain [area],[value] pairs"
+      end
+      # 'unzip' the data into separate arrays
+      area_data, values = data.to_a.transpose
+
+      # Reject malformed area codes
+      if area_data.any?{ |code| code !~ /^\w\w$/}
+        raise ArgumentError, "Area data must have exactly two characters" 
+      end
+      @area_codes = area_data.join.upcase
+      super(values)
+    end
+    
+    def render_chart_type #:nodoc:
+      "t"
+    end
+    
+    def area=(area)
+      raise ArgumentError unless AREAS.include? area
+      @area = area
+    end
+    
+    # overrides GChart::Base#query_params
+    def query_params(params={}) #:nodoc:
+      params["chtm"] = area unless area.empty?
+      params["chld"] = area_codes if area_codes
+      params["chf"] = "bg,s,#{@background}" if @background
+      super(params)
+    end
+    
+    # overrides GChart::Base#render_data
+    def render_data(params)
+      super(params)
+      # Maps require at least one data point. Add a "missing value".
+      # It may be better to refactor the base class.
+      params["chd"] << '__' if params["chd"] =~ /e:$/
+    end
+    
+    def render_title(params) #:nodoc:
+      nil #N/A for map
+    end 
+    
+    def render_legend(params) #:nodoc:
+      nil #N/A for map
+    end
+    
+  end
+end

data/lib/gchart/meter.rb

@@ -0,0 +1,29 @@
+module GChart
+  class Meter < GChart::Base
+    attr_accessor :label
+    
+    def render_chart_type #:nodoc:
+      "gom"
+    end
+    
+    # The data for a meter is a single data point expressed as a percent
+    def render_data(params)
+      value = data.is_a?(Array) ? data.flatten.first : data
+      params["chd"] = "t:#{value.to_f}"
+    end
+    
+    def label=(string)
+      return if string.nil?
+      if (string.is_a?(Array) && string.size > 1) or string.include?("|")
+        raise ArgumentError, "Meter can only have one label"
+      end
+      @label = string.to_s
+    end
+    
+    # Commandeer render_legend to render the label
+    def render_legend(params)
+      self.label = legend if self.label.nil? # Can use legend instead of label
+      params["chl"] = label if label
+    end
+  end
+end

data/lib/gchart/pie.rb

@@ -0,0 +1,21 @@
+module GChart
+  class Pie < GChart::Base
+    # A single array of chart data. Raises +ArgumentError+
+    # if more than one data set is provided.
+    def data=(data)
+      if data.is_a?(Array) and data.first.is_a?(Array) and data.size > 1
+        raise ArgumentError, "Pie charts only have one data set" 
+      end
+      
+      super(data)
+    end
+    
+    def render_chart_type #:nodoc:
+      "p"
+    end
+    
+    def render_legend(params) #:nodoc:
+      params["chl"] = legend.join("|") if legend
+    end
+  end
+end

data/lib/gchart/pie_3d.rb

@@ -0,0 +1,7 @@
+module GChart
+  class Pie3D < GChart::Pie
+    def render_chart_type #:nodoc:
+      "p3"
+    end
+  end
+end

data/lib/gchart/scatter.rb

@@ -0,0 +1,7 @@
+module GChart
+  class Scatter < GChart::Base
+    def render_chart_type #:nodoc:
+      "s"
+    end
+  end
+end

data/lib/gchart/sparkline.rb

@@ -0,0 +1,15 @@
+module GChart
+  class Sparkline < GChart::Base
+    # Sparklines are essentially the same as line charts, but without
+    # axis lines. Because they are often placed within text, the default
+    # size should be smaller.
+    def initialize(*args, &block)
+      super(*args, &block)
+      @width = "60"
+      @height = "20"
+    end
+    def render_chart_type #:nodoc:
+      "ls"
+    end
+  end
+end

data/lib/gchart/venn.rb

@@ -0,0 +1,7 @@
+module GChart
+  class Venn < GChart::Base
+    def render_chart_type #:nodoc:
+      "v"
+    end
+  end
+end

data/lib/gchart/xy_line.rb

@@ -0,0 +1,7 @@
+module GChart
+  class XYLine < GChart::Base
+    def render_chart_type #:nodoc:
+      "lxy"
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module GChart
+  VERSION = "0.5.0".freeze  
+end

data/spec/gchart/bar_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe GChart::Bar do
+  before(:each) do
+    @chart = GChart::Bar.new
+  end
+  
+  it "is ungrouped by default" do
+    @chart.grouped.should == false
+    @chart.should_not be_grouped
+  end
+  
+  it "is horizontal by default" do
+    @chart.orientation.should == :horizontal
+    @chart.should be_horizontal
+    @chart.should_not be_vertical
+  end
+  
+  it "renders the correct chart type" do
+    GChart::Bar.new.render_chart_type.should == "bhs"
+    GChart::Bar.new(:grouped => true).render_chart_type.should == "bhg"
+    GChart::Bar.new(:orientation => :vertical).render_chart_type.should == "bvs"
+  end
+end
+
+describe GChart::Bar, "#orientation" do
+  before(:each) { @chart = GChart::Bar.new }
+  
+  it "complains if orientation is invalid" do
+    lambda { @chart.orientation = :monkey }.should raise_error(ArgumentError)
+  end
+end
+
+describe GChart::Bar, "#thickness" do
+  before(:each) { @chart = GChart::Bar.new }
+  
+  it "can be specified" do
+    @chart.thickness = 10
+    @chart.thickness.should == 10
+  end
+  
+  it "complains about negative numbers" do
+    lambda { @chart.thickness = -1 }.should raise_error(ArgumentError)
+  end
+end
+
+describe GChart::Bar, "#spacing" do
+  before(:each) { @chart = GChart::Bar.new }
+  
+  it "can be specified" do
+    @chart.spacing = 2
+    @chart.spacing.should == 2
+  end
+  
+  it "complains about negative numbers" do
+    lambda { @chart.spacing = -1 }.should raise_error(ArgumentError)
+  end
+end
+
+describe GChart::Bar, "#query_params" do
+  before(:each) { @chart = GChart::Bar.new }
+  
+  it "contains the chart's type" do
+    @chart.query_params["cht"].should =~ /b(h|v)(g|s)/
+  end
+  
+  it "contains the chart's bar height" do
+    @chart.thickness = 10
+    @chart.query_params.keys.include?("chbh").should be_true
+    @chart.query_params["chbh"].should == "10"
+    @chart.spacing = 2
+    @chart.query_params.keys.include?("chbh").should be_true
+    @chart.query_params["chbh"].should == "10,2"
+  end
+  
+  it "it does not contain a bar height without a thickness" do
+    @chart.spacing = 2
+    @chart.query_params.keys.include?("chbh").should be_false
+  end
+end

data/spec/gchart/base_spec.rb

@@ -0,0 +1,156 @@
+require "tmpdir"
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe GChart::Base do
+  it "can be initialized with a hash" do
+    GChart::Base.new(:title => "foo").title.should == "foo"
+  end
+
+  it "complains about being initialized with unknown attributes" do
+    lambda { GChart::Base.new(:monkey => :chimchim) }.should raise_error(NoMethodError)
+  end
+
+  it "can be initialized with a block" do
+    chart = GChart::Base.new do |c|
+      c.title = "foo"
+    end
+
+    chart.title.should == "foo"
+  end
+end
+
+describe GChart::Base, "#data" do
+  it "is an empty array by default" do
+    GChart::Base.new.data.should == []
+  end
+end
+
+describe GChart::Base, "#size" do
+  before(:each) { @chart = GChart::Base.new }
+  
+  it "can be accessed as width and height" do
+    @chart.width.should_not be_zero
+    @chart.height.should_not be_zero
+  end
+  
+  it "can be accessed as a combined size" do
+    @chart.size.should == "#{@chart.width}x#{@chart.height}"
+  end
+  
+  it "can be specified as a combined size" do
+    @chart.size = "11x13"
+    @chart.width.should == 11
+    @chart.height.should == 13
+  end
+  
+  it "has a reasonable default value" do
+    @chart.size.should == "300x200"
+  end
+  
+  it "complains about negative numbers" do
+    lambda { @chart.size = "-15x13" }.should raise_error(ArgumentError)
+    lambda { @chart.width = -1 }.should raise_error(ArgumentError)
+    lambda { @chart.height= -1 }.should raise_error(ArgumentError)
+  end
+  
+  it "complains about sizes that are out of bounds (300,000 pixel graph limit, 1000 pixel side limit)" do
+    lambda { @chart.size = "491x611" }.should raise_error(ArgumentError)
+    lambda { @chart.size = "1001x300" }.should raise_error(ArgumentError)
+    lambda { @chart.size = "300x1001" }.should raise_error(ArgumentError)
+  end
+end
+
+describe GChart::Base, "#render_chart_type" do
+  it "raises; subclasses must implement" do
+    lambda { GChart::Base.new.render_chart_type }.should raise_error(NotImplementedError)
+  end
+end
+
+describe GChart::Base, "#query_params" do
+  before(:each) do
+    @chart = GChart::Base.new
+    @chart.stub!(:render_chart_type).and_return("TEST")
+  end
+  
+  it "contains the chart's type" do
+    @chart.query_params["cht"].should == "TEST"
+  end
+  
+  it "contains the chart's data" do
+    @chart.data = [[1, 2, 3], [3, 2, 1]]
+    @chart.query_params["chd"].should == "e:VVqq..,..qqVV"
+  end
+  
+  it "contains the chart's size" do
+    @chart.query_params["chs"].should == "300x200"
+  end
+  
+  it "contains the chart's title" do
+    @chart.title = "foo"
+    @chart.query_params["chtt"].should == "foo"
+  end
+  
+  it "escapes the chart's title" do
+    @chart.title = "foo bar"
+    @chart.query_params["chtt"].should == "foo+bar"
+    
+    @chart.title = "foo\nbar"
+    @chart.query_params["chtt"].should == "foo|bar"
+  end
+  
+  it "contains the chart's colors" do
+    @chart.colors = ["cccccc", "eeeeee"]
+    @chart.query_params["chco"].should == "cccccc,eeeeee"
+  end
+end
+
+describe GChart::Base, "#to_url" do
+  before(:each) do
+    @chart = GChart::Base.new
+    @chart.stub!(:render_chart_type).and_return("TEST")
+  end
+
+  it "generates a URL that points at Google" do
+    @chart.to_url.should =~ %r(http://chart.apis.google.com/chart)
+  end
+end
+
+describe GChart::Base, "#fetch" do
+  # THIS EXPECTATION HITS THE CLOUD!  Comment it out for a faster cycle. :)
+  it "fetches a blob from Google" do
+    blob = GChart.line(:data => [1, 2]).fetch
+    blob.should_not be_nil
+    blob.should =~ /PNG/
+  end
+end
+
+describe GChart::Base, "#write" do
+  before(:each) do
+    @chart = GChart::Base.new
+    @chart.stub!(:fetch).and_return("PAYLOAD")
+  end
+  
+  it "writes to chart.png by default" do
+    Dir.chdir(Dir.tmpdir) do
+      @chart.write
+      File.file?("chart.png").should == true
+    end
+  end
+  
+  it "writes to a specified file" do
+    Dir.chdir(Dir.tmpdir) do
+      @chart.write("foo.png")
+      File.file?("foo.png").should == true
+    end
+  end
+  
+  it "writes to anything that quacks like IO" do
+    result = ""
+    
+    StringIO.open(result, "w+") do |io|
+      @chart.write(io)
+    end
+    
+    result.should == "PAYLOAD"
+  end
+end

data/spec/gchart/line_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe GChart::Line do
+  it "renders the correct chart type" do
+    GChart::Line.new.render_chart_type.should == "lc"
+  end
+end

data/spec/gchart/map_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe GChart::Map do
+  before(:each) { @chart = GChart::Map.new }
+
+  it "initializes to a default area of 'world'" do
+    @chart.area.should == 'world'  
+  end
+  
+  it "defaults to maximum size of 440x220" do
+    @chart.size.should == '440x220'
+  end
+  
+  it "renders the correct chart type" do
+    @chart.render_chart_type.should == "t"
+  end
+end
+
+describe GChart::Map, "#query_params" do
+  before(:each) { @chart = GChart::Map.new }
+  
+  it "contains the chart's type" do
+    @chart.query_params["cht"].should == "t"
+  end
+  
+  it "contains the map's area" do
+    @chart.area = "usa"
+    @chart.query_params.keys.include?("chtm").should be_true
+    @chart.query_params["chtm"].should == "usa"
+  end
+  
+  it "defaults to a blank map" do
+    @chart.query_params["chd"].should =~ /^[es]:__?/
+  end
+  
+  it "checks for a valid area" do
+    lambda { @chart.area = 'usa' }.should_not raise_error(ArgumentError)
+    lambda { @chart.area = 'mars' }.should raise_error(ArgumentError)
+  end
+  
+  it "makes sure the areas have one value" do
+    @chart.data = [['NY',1],['VA',2],['WY',3]]
+    @chart.area_codes.length.should == @chart.data.size * 2
+  end
+end
+
+describe GChart::Map, "#data" do
+  it "accepts data as a hash or pair of arrays" do
+    lambda { GChart::Map.new(:data => {"VA"=>5}) }.should_not raise_error(ArgumentError)
+    lambda { GChart::Map.new(:data => {"VA"=>5, "NY"=>1}) }.should_not raise_error(ArgumentError)
+    lambda { GChart::Map.new(:data => [["VA",5],["NY",1]]) }.should_not raise_error(ArgumentError)
+    lambda { GChart::Map.new(:data => [["VA","NY"],[5,1]]) }.should raise_error(ArgumentError)
+    lambda { GChart::Map.new(:data => [1, 2, 3]) }.should raise_error(ArgumentError)
+    lambda { GChart::Map.new(:data => [[1, 2, 3]]) }.should raise_error(ArgumentError)
+  end
+end

data/spec/gchart/meter_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe GChart::Meter do
+  it "renders the correct chart type" do
+    GChart::Meter.new.render_chart_type.should == "gom"
+  end
+end
+
+describe GChart::Meter, "#query_params" do
+  before(:each) do
+    @meter = GChart::Meter.new
+    @meter.data = 50
+  end  
+  it "encodes the data correctly" do
+    for data in [70, 70.0, "70", "70.0", "70%"] do
+      @meter.data = data
+      @meter.query_params["chd"].should == "t:70.0"
+    end
+  end
+  it "allows a label" do
+    @meter.label = "Label"
+    @meter.query_params.keys.include?("chl").should be_true
+    @meter.query_params["chl"].should == "Label"
+  end
+  it "allows a legend" do
+    @meter.legend = "Legend"
+    @meter.query_params.keys.include?("chl").should be_true
+    @meter.query_params["chl"].should == "Legend"
+  end
+  it "makes label take precedence over legend" do
+    @meter.legend = "Legend"
+    @meter.label = "Label"
+    @meter.query_params.keys.include?("chl").should be_true
+    @meter.query_params["chl"].should == "Label"
+  end
+  it "complains about more than one label" do
+    lambda { @meter.label = "set1" }.should_not raise_error(ArgumentError)
+    lambda { @meter.label = ["set1"] }.should_not raise_error(ArgumentError)
+    lambda { @meter.label = "set1|set2" }.should raise_error(ArgumentError)
+    lambda { @meter.label = ['set1','set2'] }.should raise_error(ArgumentError)    
+  end
+end
+
+describe GChart::Map, "#render_data" do
+  it "allows only one data point" do
+    lambda { @meter.data = "set1" }.should_not raise_error(ArgumentError)
+  end
+end

data/spec/gchart/pie_3d_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe GChart::Pie3D do
+  it "renders the correct chart type" do
+    GChart::Pie3D.new.render_chart_type.should == "p3"
+  end
+end

data/spec/gchart/pie_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe GChart::Pie do
+  it "renders the correct chart type" do
+    GChart::Pie.new.render_chart_type.should == "p"
+  end
+end
+
+describe GChart::Pie, "#query_params" do
+  before(:each) { @chart = GChart::Pie.new }
+  
+  it "contains the chart's type" do
+    @chart.query_params["cht"].should == "p"
+  end
+  
+  it "contains the chart's legend" do
+    @chart.legend = ["foo"]
+    @chart.query_params.keys.include?("chl").should be_true
+    @chart.query_params["chl"].should == "foo"
+  end
+end
+
+describe GChart::Pie, "#data" do
+  it "complains if you provide more than one set of data" do
+    lambda { GChart::Pie.new(:data => [1, 2, 3]) }.should_not raise_error(ArgumentError)
+    lambda { GChart::Pie.new(:data => [[1, 2, 3]]) }.should_not raise_error(ArgumentError)
+    lambda { GChart::Pie.new(:data => [[1, 2, 3], [3, 2, 1]]) }.should raise_error(ArgumentError)
+  end
+end

data/spec/gchart/scatter_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe GChart::Scatter do
+  it "renders the correct chart type" do
+    GChart::Scatter.new.render_chart_type.should == "s"
+  end
+end

data/spec/gchart/sparkline_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe GChart::Sparkline do
+  it "renders the correct chart type" do
+    GChart::Sparkline.new.render_chart_type.should == "ls"
+  end
+  
+  it "defaults to 60x20" do
+    GChart::Sparkline.new.size.should == "60x20"
+  end
+end
+

data/spec/gchart/venn_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe GChart::Venn do
+  it "renders the correct chart type" do
+    GChart::Venn.new.render_chart_type.should == "v"
+  end
+end

data/spec/gchart/xy_line_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../helper")
+
+describe GChart::XYLine do
+  it "renders the correct chart type" do
+    GChart::XYLine.new.render_chart_type.should == "lxy"
+  end
+end

data/spec/gchart_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path("#{File.dirname(__FILE__)}/helper")
+
+describe GChart do
+  it "supplies a version" do
+    GChart::VERSION.should_not be_nil
+  end
+end
+
+describe GChart, ".encode" do
+  it "supports the simple, text, and extended encoding" do
+    lambda { GChart.encode(:simple, 4, 10) }.should_not raise_error(ArgumentError)
+    lambda { GChart.encode(:text, 4, 10) }.should_not raise_error(ArgumentError)
+    lambda { GChart.encode(:extended, 4, 10) }.should_not raise_error(ArgumentError)
+    lambda { GChart.encode(:monkey, 4, 10) }.should raise_error(ArgumentError)
+  end
+  
+  it "implements the simple encoding" do
+    expected = {
+      0 => "A", 19 => "T", 27 => "b", 53 => "1", 61 => "9",
+      12 => "M", 39 => "n", 57 => "5", 45 => "t", 51 => "z"
+    }
+    
+    expected.each do |original, encoded|
+      GChart.encode(:simple, original, 61).should == encoded
+    end
+  end
+  
+  it "implements the text encoding" do
+    expected = {
+      0 => "0.0", 10 => "10.0", 58 => "58.0", 95 => "95.0", 30 => "30.0", 8 => "8.0", 63 => "63.0", 100 => "100.0"
+    }
+    
+    expected.each do |original, encoded|
+      GChart.encode(:text, original, 100).should == encoded
+    end
+  end
+
+  it "implements the extended encoding" do
+    expected = {
+      0 => "AA", 25 => "AZ", 26 => "Aa", 51 => "Az", 52 => "A0", 61 => "A9", 62 => "A-", 63 => "A.",
+      64 => "BA", 89 => "BZ", 90 => "Ba", 115 => "Bz", 116 => "B0", 125 => "B9", 126 => "B-", 127 => "B.",
+      4032 => ".A", 4057 => ".Z", 4058 => ".a", 4083 => ".z", 4084 => ".0", 4093 => ".9", 4094 => ".-", 4095 => ".."
+    }
+    
+    expected.each do |original, encoded|
+      GChart.encode(:extended, original, 4095).should == encoded
+    end
+  end
+  
+  it "encodes nil correctly" do
+    GChart.encode(:simple, nil, 1).should == "_"
+    GChart.encode(:text, nil, 1).should == "-1"
+    GChart.encode(:extended, nil, 1).should == "__"
+  end
+  
+  it "encodes 0 with a max of 0 correctly" do
+    GChart.encode(:extended, 0, 0).should == "AA"
+  end
+end
+
+describe GChart, ".line" do
+  it "can render a basic line URL" do
+    expected = { "cht" => "lc", "chs" => "300x200", "chd" => "e:AAAp..", "chtt" => "test" }
+    chart = GChart.line(:title => "test", :data => [1, 100, 10000])
+
+    chart.query_params.should == expected
+    chart.to_url.should == "http://chart.apis.google.com/chart?chs=300x200&cht=lc&chtt=test&chd=e:AAAp.."
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(File.expand_path("#{File.dirname(__FILE__)}/../lib"))
+
+require "spec"
+require "gchart"
+
+module GChart
+  class Base
+    public :query_params
+    public :render_chart_type, :render_data
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,7 @@
+--colour
+--format
+progress
+--loadby
+mtime
+--reverse
+--backtrace

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: texel-gchart
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- John Barnette
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-03 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.5.3
+    version: 
+description: "== PROBLEMS/TODO  * Add support fills (area or background), grid lines, shape markers, range markers  * Support shorthand colors and color names * Make venn data specification friendlier  There are lots of missing features. Until they're implemented, you can directly specify query parameters using the :extras key, e.g.,  # provides a legend for each data set g = GChart.line(:data => [[1, 2], [3, 4]], :extras => { \"chdl\" => \"First|Second\"})"
+email: jbarnette@rubyforge.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG.txt
+- Manifest.txt
+- README.txt
+files: 
+- CHANGELOG.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/gchart.rb
+- lib/gchart/bar.rb
+- lib/gchart/base.rb
+- lib/gchart/line.rb
+- lib/gchart/map.rb
+- lib/gchart/meter.rb
+- lib/gchart/pie.rb
+- lib/gchart/pie_3d.rb
+- lib/gchart/scatter.rb
+- lib/gchart/sparkline.rb
+- lib/gchart/venn.rb
+- lib/gchart/xy_line.rb
+- lib/version.rb
+- spec/gchart/bar_spec.rb
+- spec/gchart/base_spec.rb
+- spec/gchart/line_spec.rb
+- spec/gchart/map_spec.rb
+- spec/gchart/meter_spec.rb
+- spec/gchart/pie_3d_spec.rb
+- spec/gchart/pie_spec.rb
+- spec/gchart/scatter_spec.rb
+- spec/gchart/sparkline_spec.rb
+- spec/gchart/venn_spec.rb
+- spec/gchart/xy_line_spec.rb
+- spec/gchart_spec.rb
+- spec/helper.rb
+- spec/spec.opts
+has_rdoc: true
+homepage: http://gchart.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: gchart
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: GChart uses the Google Chart API to create pretty pictures.
+test_files: []
+