gchart 0.1.0

data/CHANGELOG.txt

@@ -0,0 +1,3 @@
+== 0.1.0
+
+  * Birthday!

data/Manifest.txt

@@ -0,0 +1,7 @@
+CHANGELOG.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/gchart.rb
+lib/version.rb
+test/test_gchart.rb

data/README.txt

@@ -0,0 +1,72 @@
+= 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 for legends, 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
+  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]])
+  
+  # chart title
+  g = GChart.line(:title => "Awesomeness over Time", :data => [0, 10, 100])
+
+  # 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 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,13 @@
+require "rubygems"
+require "hoe"
+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

data/lib/gchart.rb

@@ -0,0 +1,143 @@
+require File.dirname(__FILE__) + "/version"
+
+require "open-uri"
+require "uri"
+
+class GChart
+  URL   = "http://chart.apis.google.com/chart"
+  TYPES = %w(line linexy bar pie venn scatter).collect { |t| t.to_sym }
+  CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-.".split("")
+  PAIRS = CHARS.collect { |first| CHARS.collect { |second| first + second } }.flatten
+
+  class << self
+    def encode_extended(number) #:nodoc:
+      return "__" if number.nil?
+      PAIRS[number.to_i]
+    end
+    
+    TYPES.each do |type|
+      class_eval <<-END
+        def #{type}(options={}, &block)
+          new(options.merge(:type => #{type.inspect}, &block))
+        end
+      END
+    end
+  end
+
+  # Array of chart data
+  attr_accessor :data
+  
+  # Hash of additional query params
+  attr_accessor :extras
+  
+  # Width (in pixels)
+  attr_accessor :width
+  
+  # Height (in pixels)
+  attr_accessor :height
+  
+  # Orientation. Applies to bar charts
+  attr_accessor :horizontal
+  
+  # Grouping. Applies to bar charts
+  attr_accessor :grouped
+  
+  # Overall chart title
+  attr_accessor :title
+  
+  # Array of RRGGBB colors, one per data set
+  attr_accessor :colors
+  
+  # The chart type
+  attr_reader :type
+  
+  alias_method :horizontal?, :horizontal
+  alias_method :grouped?, :grouped
+  
+  def initialize(options={}, &block)
+    @type = :line
+    @data = []
+    @extras = {}
+    @width = 300
+    @height = 200
+    @horizontal = false
+    @grouped = false
+    
+    options.each { |k, v| send("#{k}=", v) }
+    yield(self) if block_given?
+  end
+
+  # Sets the chart type. Raises +ArgumentError+ if +type+ isn't in +TYPES+.
+  def type=(type)
+    unless TYPES.include?(type)
+      raise ArgumentError, %Q(Invalid type #{type.inspect}. Valid types: #{TYPES.inspect}.)
+    end
+    
+    @type = type
+  end
+  
+  # Returns the chart's size as "WIDTHxHEIGHT".
+  def size
+    "#{width}x#{height}"
+  end
+  
+  # Allows the chart's size to be set as "WIDTHxHEIGHT".
+  def size=(size)
+    self.width, self.height = size.split("x").collect { |n| Integer(n) }
+  end
+  
+  # Returns the chart's URL.
+  def to_url
+    query = google_query_params.collect { |k, v| "#{k}=#{URI.escape(v)}" }.join("&")
+    "#{URL}?#{query}"
+  end
+  
+  # Returns the chart's generated PNG as a blob.
+  def fetch
+    open(to_url) { |data| data.read }
+  end
+  
+  # Writes the chart's generated PNG. If +io_or_file+ quacks like an IO,
+  # +write+ will be called. Otherwise, write to disk. +io_or_file+ defaults
+  # to "chart.png".
+  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+") { |f| f.write(fetch) }
+  end
+  
+  private
+  
+  def google_query_params
+    params = { "cht" => google_chart_type, "chd" => google_data, "chs" => size }
+    params["chtt"] = title.tr("\n", "|").gsub(/\s+/, "+") if title
+    params["chco"] = colors.join(",") if colors
+    params.merge(extras)
+  end
+  
+  def google_chart_type
+    case type
+    when :line
+      "lc"
+    when :linexy
+      "lxy"
+    when :bar
+      "b" + (horizontal? ? "h" : "v") + (grouped? ? "g" : "s")
+    when :pie
+      "p"
+    when :venn
+      "v"
+    when :scatter
+      "s"
+    end
+  end
+  
+  def google_data
+    # we'll just always use the extended encoding for now
+    sets = (Array === data.first ? data : [data]).collect do |set|
+      max = set.max
+      set.collect { |n| GChart.encode_extended(n * (PAIRS.size - 1) / max) }.join
+    end
+    
+    "e:#{sets.join(",")}"
+  end  
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+class GChart
+  VERSION = "0.1.0"  
+end

data/test/test_gchart.rb

@@ -0,0 +1,114 @@
+require "test/unit"
+require "gchart"
+
+class GChart
+  public :google_query_params, :google_chart_type, :google_data
+end
+
+class TestGChart < Test::Unit::TestCase
+  def test_supplies_a_version
+    assert_not_nil(GChart::VERSION)
+  end
+  
+  def test_allows_hash_initialization
+    assert_equal(:line, GChart.new(:type => :line).type)
+  end
+  
+  def test_complains_about_unknown_options
+    assert_raise(NoMethodError) { GChart.new(:monkey => :chimchim) }
+  end
+  
+  def test_allows_block_initialization
+    c = GChart.new do |chart|
+      chart.type = :line
+    end
+    
+    assert_equal(:line, c.type)
+  end
+  
+  def test_allows_all_valid_chart_types
+    GChart::TYPES.each do |type|
+      assert_nothing_raised(ArgumentError) { GChart.new(:type => type) }
+    end
+  end
+  
+  def test_complains_about_invalid_chart_types
+    assert_raise(ArgumentError) { GChart.new(:type => :monkey) }
+  end
+  
+  def test_allows_size_to_be_specified_combined
+    c = GChart.new(:size => "13x14")
+    assert_equal(13, c.width)
+    assert_equal(14, c.height)
+  end
+  
+  def test_defaults
+    c = GChart.new
+    assert_equal(:line, c.type)   
+    assert_equal([], c.data)
+    assert_equal(300, c.width)
+    assert_equal(200, c.height)
+    assert(!c.horizontal?)
+    assert(!c.grouped?)
+  end
+  
+  def test_google_chart_types
+    assert_equal("lc", GChart.new(:type => :line).google_chart_type)
+    assert_equal("lxy", GChart.new(:type => :linexy).google_chart_type)
+    
+    assert_equal("bhg", GChart.new(:type => :bar, :horizontal => true, :grouped => true).google_chart_type)
+    assert_equal("bhs", GChart.new(:type => :bar, :horizontal => true, :grouped => false).google_chart_type)
+    assert_equal("bvs", GChart.new(:type => :bar, :horizontal => false, :grouped => false).google_chart_type)
+    
+    assert_equal("p", GChart.new(:type => :pie).google_chart_type)
+    assert_equal("v", GChart.new(:type => :venn).google_chart_type)
+    assert_equal("s", GChart.new(:type => :scatter).google_chart_type)
+  end
+  
+  def test_google_extended_notation
+    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|
+      assert_equal(encoded, GChart.encode_extended(original))
+    end
+    
+    assert_equal("__", GChart.encode_extended(nil))    
+  end
+  
+  def test_allows_extra_query_params
+    c = GChart.new(:extras => { :foo => :bar })
+    assert(c.google_query_params.include?(:foo))
+  end
+  
+  def test_supports_title
+    chart = GChart.new
+    
+    assert_nil(chart.google_query_params["chtt"])
+    
+    chart.title = "foo"
+    assert_equal("foo", chart.google_query_params["chtt"])
+    
+    chart.title = "a space"
+    assert_equal("a+space", chart.google_query_params["chtt"])
+    
+    chart.title = "a\nnewline"
+    assert_equal("a|newline", chart.google_query_params["chtt"])
+  end
+  
+  def test_supports_colors
+    chart = GChart.new(:colors => ["cccccc", "eeeeee"])
+    assert_equal(chart.google_query_params["chco"], "cccccc,eeeeee")
+  end
+  
+  def test_generates_correct_query_params_and_url_for_simple_example
+    expected = { "cht" => "lc", "chs" => "300x200", "chd" => "e:AAAo..", "chtt" => "test" }
+    
+    chart = GChart.new(:title => "test", :data => [1, 100, 10000])
+    assert_equal(expected, chart.google_query_params)
+    assert_equal("http://chart.apis.google.com/chart?chs=300x200&cht=lc&chtt=test&chd=e:AAAo..", chart.to_url)
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: gchart
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ""
+authors: 
+- John Barnette
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2007-12-10 00:00:00 -08: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.3.0
+    version: 
+description: "== PROBLEMS/TODO  * Add support for legends, 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/version.rb
+- test/test_gchart.rb
+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: 0.9.5
+signing_key: 
+specification_version: 2
+summary: GChart uses the Google Chart API to create pretty pictures.
+test_files: 
+- test/test_gchart.rb