RubyGems - gvis - Versions diffs - 2.0.1 → 2.0.2 - Mend

gvis 2.0.1 → 2.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

data/.gitignore +7 -0
data/Gemfile +4 -0
data/README.md +71 -0
data/Rakefile +15 -19
data/gvis.gemspec +27 -0
data/lib/google_visualization.rb +78 -61
data/lib/gvis.rb +1 -1
data/lib/gvis/data_table.rb +111 -0
data/lib/gvis/version.rb +3 -0
data/test/helper.rb +19 -0
data/test/test_data_table.rb +62 -0
data/test/test_google_visualization.rb +61 -0
data/test/views/_corechart.html.erb +11 -0
data/test/views/_motionchart.html.erb +18 -0
data/test/views/layout.html.erb +13 -0
metadata +98 -12
data/README +0 -64
data/lib/data_table.rb +0 -76

data/.gitignore ADDED Viewed

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.yardoc/*
+doc/*
+coverage/*

data/Gemfile ADDED Viewed

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+# Specify your gem's dependencies in resque-batched-logger.gemspec
+gemspec

data/README.md ADDED Viewed

@@ -0,0 +1,71 @@
+Gvis
+====
+Rails plugin that provides a Ruby wrapper for easily loading the Google Visualization API, and simple generation of the javascript required to plot the graphs
+For a full list of the graphs provided by google's visualization api see the [gallery](http://code.google.com/apis/visualization/documentation/gallery.html)
+For documentation on how to use each graph type see google's [API documentation](http://code.google.com/apis/visualization/documentation/)
+Compatiblity
+------------
+gvis version 2.x - Rails 3.x compatible (And rails 2.x using rails_xss)
+gvis version 1.x - Rails 2.x compatible
+Installation
+============
+Rails 3:
+	# Gemfile
+	gem 'gvis', '>= 2.0.0'
+Rails 2.X:
+	# config/environment.rb
+	config.gem 'gvis', :version => '< 2.0.0'
+Then include the GoogleVisualization module in app/helpers/application_helper.rb
+	module ApplicationHelper
+	  include GoogleVisualization
+	end
+Load the API, and render any graphs by placing these methods inside your layout
+	# app/views/layouts/application.html.erb
+	<head>
+		<%= include_visualization_api %>
+		<%= render_visualizations %>
+		...
+	</head>
+Example
+=======
+Render desired graphs in the view like this:
+	# index.html.erb
+	<% visualization "my_chart", "MotionChart", :width => 600, :height => 400, :html => {:class => "graph_chart"} do |chart| %>
+		<%# Add the columns that the graph will have %>
+		<% chart.string "Fruit" %>
+		<% chart.date "Date" %>
+		<% chart.number "Sales" %>
+		<% chart.number "Expenses" %>
+		<% chart.string "Location" %>
+		<%# Add the data %>
+		<% chart.add_rows([
+			["Apples", Date.new(1998,1,1), 1000,300,'East'],
+			["Oranges", Date.new(1998,1,1), 950,200,'West'],
+			["Bananas", Date.new(1998,1,1), 300,250,'West'],
+			["Apples", Date.new(1998,2,1), 1200,400,'East'],
+			["Oranges", Date.new(1998,2,1), 950,150,'West'],
+			["Bananas", Date.new(1998,2,1), 788,617,'West']
+		]) %>
+	<% end %>
+Copyright (c) 2009 [Jeremy Olliver], released under the MIT license

data/Rakefile CHANGED Viewed

@@ -1,23 +1,19 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-desc 'Default: run unit tests.'
-task :default => :test
+require 'bundler'
+Bundler::GemHelper.install_tasks
-desc 'Test the gvis plugin.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
 end
-desc 'Generate documentation for the gvis plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Gvis'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.rcov_opts << '--exclude /gems/,/Library/,/usr/,spec,lib/tasks' # exclude external gems/libraries
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
 end
+task :default => :test

data/gvis.gemspec ADDED Viewed

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "gvis/version"
+Gem::Specification.new do |s|
+  s.name        = "gvis"
+  s.version     = Gvis::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.author      = "Jeremy Olliver"
+  s.email       = "jeremy.olliver@gmail.com"
+  s.homepage    = "http://github.com/jeremyolliver/gvis"
+  s.summary     = "Easily embed charts with Google Visualization API"
+  s.description = "Easily embed charts with Google Visualization API, using ruby formatted options in your view files"
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+  s.add_dependency 'json'
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'rcov'
+  # Although this runs on rails 3, I'm only specifying this as development dependency for now,
+  # (instead of runtime dependency) since rails can be vendored and need not be installed/required as gems
+  s.add_development_dependency 'actionpack', '> 3.0.0'
+end

data/lib/google_visualization.rb CHANGED Viewed

@@ -1,29 +1,31 @@
-# Provides calls for simplifying the loading and use of the Google Visualization API
+# view helper, and view methods for using the Google Visualization API
 #
-# For use with rails, include this Module in ApplicationHelper
-# See the Readme for usage details
+# For use with rails, include this Module in ApplicationHelper, and call {#include_visualization_api} and {#render_visualizations} within the head tag of your html layout
+# See the Readme[http://github.com/jeremyolliver/gvis#readme] for examples and usage details. For more detailed info on each visualization see the API[http://code.google.com/apis/visualization/documentation/]
 #
-# written by Jeremy Olliver
+# @author Jeremy Olliver
 module GoogleVisualization
   attr_accessor :google_visualizations, :visualization_packages
-  #######################################################################
-  # Place these method calls inside the <head> tag in your layout file. #
-  #######################################################################
+  # @group Layout helper methods
+  # Place these method calls inside the head tag in your layout file.
   # Include the Visualization API code from google.
   # (Omit this call if you prefer to include the API in your own js package)
   def include_visualization_api
     javascript_include_tag("http://www.google.com/jsapi")
   end
-  # This code actually inserts the visualization data
+  # Call this method from the within the head tag (or alternately just before the closing body tag)
+  # This will render the graph's generated by the rendering of your view files
+  # @return [String] a javascript tag that contains the generated javascript to render the graphs
   def render_visualizations
     if @google_visualizations
-      package_list = []
-      @visualization_packages.uniq.each do |p|
-        package_list << "\'#{p.to_s.camelize.downcase}\'"
+      package_list = @visualization_packages.uniq.collect do |p|
+        package = p.to_s.camelize.downcase
+        package = "corechart" if ["areachart", "barchart", "columnchart", "linechart", "piechart"].include?(package)
+        "\'#{package}\'"
       end
       output = %Q(
         <script type="text/javascript">
@@ -32,91 +34,106 @@ module GoogleVisualization
           var chartData = {};
           var visualizationCharts = {};
           function drawCharts() { )
-            @google_visualizations.each do |id, vis|
-              output += generate_visualization(id, vis[0], vis[1], vis[2])
-            end
+      @google_visualizations.each do |id, vis|
+        output += generate_visualization(id, vis[0], vis[1], vis[2])
+      end
       output += "} </script>"
       raw(output + "<!-- Rendered Google Visualizations /-->")
     else
-      raw("<!-- No graphs on this page /-->")
+      raw("<!-- No graphs on this page /-->") if debugging?
     end
   end
-  ########################################################################
-  # Call this method from the view to insert the visualization data here #
-  # Will output a div with given id, and add the chart data to be        #
-  # rendered from the head of the page                                   #
-  ########################################################################
+  # @endgroup Layout helper methods
+  # @group View methods
+  # Call this method from the view to insert the visualization graph/chart here.
+  # This method will output a div with the specified id, and store the chart data to be rendered later via {#render_visualizations}
+  # @param [String] id the id of the chart. corresponds to the id of the div
+  # @param [String] chart_type the kind of chart to render
+  # @param [Hash] options the configuration options for the graph
   def visualization(id, chart_type, options = {}, &block)
     init
     chart_type = chart_type.camelize      # Camelize the chart type, as the Google API follows Camel Case conventions (e.g. ColumnChart, MotionChart)
     options.stringify_keys!               # Ensure consistent hash access
     @visualization_packages << chart_type # Add the chart type to the packages needed to be loaded
     # Initialize the data table (with hashed options), and pass it the block for cleaner adding of attributes within the block
-    table = DataTable.new(options.delete("data"), options.delete("columns"), options)
+    table = Gvis::DataTable.new(options.delete("data"), options.delete("columns"), options)
     if block_given?
       yield table
     end
-    # Extract the html options
-    html_options = options.delete("html") || {}
-    # Add our chart to the list to be rendered in the head tag
-    @google_visualizations.merge!(id => [chart_type, table, options])
-    # Output a div with given id, that our graph will be embedded into
-    html = ""
-    html_options.each do |key, value|
-      html += %Q(#{key}="#{value}" )
-    end
+    html_options = options.delete("html") || {} # Extract the html options
+    @google_visualizations.merge!(id => [chart_type, table, options]) # Store our chart in an instance variable to be rendered in the head tag
+    # Output a div with given id on the page right now, that our graph will be embedded into
+    html = html_options.collect {|key,value| "#{key}=\"#{value}\"" }.join(" ")
     concat raw(%Q(<div id="#{id}" #{html}><!-- /--></div>))
-    nil
+    nil # Return nil just incase this is called with an output erb tag, as we don't to output the html twice
   end
+  # @endgroup View methods
   protected
-  # Initialize instance variables
-  def init
-    @google_visualizations ||= {}
-    @visualization_packages ||=[]
-  end
   ###################################################
   # Internal methods for building the script data   #
   ###################################################
-  def generate_visualization(id, chart, table, options={})
+  # Generates the javascript for initializing each graph/chart
+  # @param [String] id the id for the given chart, this should be unique per html page
+  # @param [String] chart_type the name of the chart type that we're rendering.
+  # @param [DataTable] table the DataTable containing the column definitions and data rows
+  # @param [Hash] options the view formatting options
+  # @return [String] javascript that creates the chart, and adds it to the window variable
+  def generate_visualization(id, chart_type, table, options={})
     # Generate the js chart data
     output = "chartData['#{id}'] = new google.visualization.DataTable();"
     table.columns.each do |col|
       output += "chartData['#{id}'].addColumn('#{table.column_types[col]}', '#{col}');"
     end
-    option_str = make_opts_string(options)
+    option_str = parse_options(options)
     output += %Q(
-      chartData['#{id}'].addRows(#{table.js_format_data});
-      visualizationCharts['#{id}'] = new google.visualization.#{chart.to_s.camelize}(document.getElementById('#{id}'));
+      chartData['#{id}'].addRows(#{table.format_data});
+      visualizationCharts['#{id}'] = new google.visualization.#{chart_type.to_s.camelize}(document.getElementById('#{id}'));
       visualizationCharts['#{id}'].draw(chartData['#{id}'], {#{option_str}});
     )
   end
-  # parse options into an array of key-value pairs
-  #
-  def make_opts_string(opts)
-    option_str = []
-    opts.each do |key, val|
+  # Parse options hash into a string containing a javascript hash key-value pairs
+  # @param [Hash] options the hash to parse
+  # @return [String] a javascript representation of the input
+  def parse_options(options)
+    options.collect do |key, val|
       str = "#{key}: "
       if val.kind_of? Hash
-        str += "{" + make_opts_string(val) + "}"
+        str += "{" + parse_options(val) + "}"
       elsif val.kind_of? Array
         str += "[ " + val.collect { |v| "'#{v}'" }.join(", ") + " ]"
       else
         str += (val.kind_of?(String) ? "'#{val}'" : val.to_s)
       end
+      str
+    end.join(',')
+  end
-      option_str << str
-    end
+  # Convenience method for initializing instance variables
+  def init
+    @google_visualizations ||= {}
+    @visualization_packages ||= []
+  end
-    return option_str.join(',')
+  # Determines if we're in a debugging environment
+  # @return [boolean]
+  def debugging?
+    debugging = ENV["DEBUG"]
+    if defined?(Rails) && Rails.responsd_to?(:env)
+      debugging = true if ["development", "test"].include? Rails.env
+    end
+    debugging
   end
 end

data/lib/gvis.rb CHANGED Viewed

@@ -1,2 +1,2 @@
-require 'data_table'
+require 'gvis/data_table'
 require 'google_visualization'

data/lib/gvis/data_table.rb ADDED Viewed

@@ -0,0 +1,111 @@
+# This is an internal class intended for use by the helper methods present in the {GoogleVisualization} class.
+#
+# Converts Ruby data structures into a string containing a javascript array for use with a google.visualization.DataTable[http://code.google.com/apis/visualization/documentation/reference.html#DataTable] javascript object
+#
+# @author Jeremy Olliver
+module Gvis
+  class DataTable
+    require 'json'
+    COLUMN_TYPES = ["string", "number", "date", "datetime"]
+    attr_accessor :data, :table_columns, :column_types
+    # @param [Array] data optional param that may contain a 2D Array for specifying the data upon initialization
+    # @param [Array] columns optional param for specifying the column structure upon initialization
+    # @param [Hash] options optional param of configuration options for the google.visualization.DataTable javascript object
+    def initialize(data = nil, columns = [], options = {})
+      @table_columns, @column_types = [], {}
+      if columns && columns.any?
+        columns.each do |name, type|
+          register_column(type, name)
+        end
+      end
+      @data = data || []
+    end
+    # A one liner to set all the columns at once
+    # eg: chart.columns = { :signups => "number", :day => "date" }
+    # @param [Hash] cols a hash where keys are column names, and values are a string of the column type
+    def columns=(cols)
+      cols.each do |name, coltype|
+        register_column(coltype, name)
+      end
+    end
+    # @return [Array] The columns stored in this table
+    def columns
+      @table_columns
+    end
+    # Adds a single row to the table
+    # @param [Array] row An array with a single row of data for the table. Should have the same number of entries as there are columns
+    def add_row(row)
+      size = row.size
+      raise ArgumentError.new("Given a row of data with #{size} entries, but there are only #{@table_columns.size} columns in the table") unless size == @table_columns.size
+      @data << row
+    end
+    # Adds multiple rows to the table
+    # @param [Array] rows A 2d Array containing multiple rows of data. Each Array should have the same number of entries as the table has columns
+    def add_rows(rows)
+      sizes = rows.collect {|r| r.size }.uniq
+      expected_size = @table_columns.size
+      errors = sizes.select {|s| s != expected_size }
+      raise ArgumentError.new("Given a row of data with #{errors.to_sentence} entries, but there are only #{expected_size} columns in the table") if errors.any?
+      @data += rows
+    end
+    # Handle the Column definition methods (#string, #number, #date, #datetime)
+    # This allows columns to be defined one at a time, with a dsl similar to AR migrations
+    # e.g. table.string "name"
+    COLUMN_TYPES.each do |col_type|
+      define_method(col_type) do |args|
+        register_column(col_type, *args)
+      end
+    end
+    # Outputs the data within this table as a javascript array ready for use by google.visualization.DataTable
+    # This is where conversions of ruby date objects to javascript Date objects and escaping strings, and formatting options is done
+    # @return [String] a javascript array with the first row defining the table, and subsequent rows holding the table's data
+    def format_data
+      formatted_rows = []
+      @data.each do |row|
+        values = []
+        row.each_with_index do |entry,index|
+          # Format/escape individual values for javascript, checking column types, and the ruby value as a failsafe
+          safe_val = if @column_types[index] == "date" || entry.is_a?(Date)
+            # Format a date object as a javascript date
+            entry.is_a?(String) ? entry : "new Date (#{entry.year},#{entry.month - 1},#{entry.day})"
+          elsif @column_types[index] == "datetime" || entry.is_a?(Time)
+            # Format a Time (datetime) as a javascript date object down to seconds
+            entry.is_a?(String) ? entry : "new Date (#{entry.year},#{entry.month - 1},#{entry.day},#{entry.hour},#{entry.min},#{entry.sec})"
+          else
+            # Non date/time values can be JS escaped/formatted safely with # to_json
+            entry.to_json
+          end
+          values << safe_val
+        end
+        rowstring = "[#{values.join(", ")}]"
+        formatted_rows << rowstring
+      end
+      "[#{formatted_rows.join(', ')}]"
+    end
+    alias :js_format_data :format_data # For backwards compatibility, just in case
+    alias :to_s :format_data
+    private
+    # Registers each column explicitly, with data type, and a name associated
+    # @param [String] type the type of data column being registered, valid input here are entries from DataTable::COLUMN_TYPES
+    # @param [String] name the column name that will be used as a label on the graph
+    def register_column(type, name)
+      type = type.to_s.downcase
+      raise ArgumentError.new("invalid column type #{type}, permitted types are #{COLUMN_TYPES.join(', ')}") unless COLUMN_TYPES.include?(type)
+      @table_columns << name.to_s
+      @column_types.merge!(name.to_s => type)
+    end
+  end
+end

data/lib/gvis/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module Gvis
+  VERSION = "2.0.2"
+end

data/test/helper.rb ADDED Viewed

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'minitest/unit'
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'gvis'
+class MiniTest::Unit::TestCase
+end
+MiniTest::Unit.autorun

data/test/test_data_table.rb ADDED Viewed

@@ -0,0 +1,62 @@
+require 'helper'
+class TestDataTable < MiniTest::Unit::TestCase
+  def setup
+    @table = Gvis::DataTable.new
+  end
+  def test_attributes_methods_and_constants
+    assert defined?(Gvis::DataTable::COLUMN_TYPES)
+    assert_equal ["string", "number", "date", "datetime"], Gvis::DataTable::COLUMN_TYPES
+    defined_attributes = [:data, :table_columns, :column_types]
+    defined_attributes.each do |a|
+      assert @table.respond_to?(a), "DataTable should have attribute #{a} defined"
+    end
+    methods = [:columns, :columns=, :add_row, :add_rows, :format_data] + Gvis::DataTable::COLUMN_TYPES
+    methods.each do |meth|
+      assert @table.respond_to?(meth), "DataTable should respond to instance method ##{meth}"
+    end
+  end
+  def test_defining_columns
+    @table.string "Name"
+    @table.number "age"
+    @table.date "dob"
+    @table.datetime "deceased_at"
+    assert_equal 4, @table.columns.size
+    assert_equal({"Name" => "string", "age" => "number", "dob" => "date", "deceased_at" => "datetime"}, @table.column_types)
+  end
+  def test_single_assign_columns
+    # should be case insensitive on column types
+    @table.columns = [["Name", "String"], ["Surname", "string"], ["age", "number"]]
+    assert_equal 3, @table.columns.size
+    assert_equal({"Name" => "string", "Surname" => "string", "age" => "number"}, @table.column_types)
+  end
+  def test_initializing_with_columns
+    table = Gvis::DataTable.new(nil, [["Name", "String"], ["Surname", "string"], ["age", "number"]])
+    assert_equal 3, table.columns.size
+    assert_equal({"Name" => "string", "Surname" => "string", "age" => "number"}, table.column_types)
+  end
+  def test_adding_rows
+    @table.columns = [["Name", "String"], ["Surname", "string"], ["age", "number"]]
+    @table.add_row(["Jeremy", "Olliver", 23])
+    @table.add_rows([
+      ["Optimus", "Prime", 1000],
+      ["Mega", "Tron", 999]
+    ])
+    assert_equal [["Jeremy", "Olliver", 23], ["Optimus", "Prime", 1000], ["Mega", "Tron", 999]], @table.data
+  end
+  def test_formatting_data
+    @table.columns = [["Name", "String"], ["age", "number"], ["dob", "date"], ["now", "datetime"]]
+    now = Time.utc(2011,1,23,11,30,4)
+    @table.add_rows([["Jeremy Olliver", 23, Date.new(2011,1,1), now], ["Optimus Prime", 1000, Date.new(1980,2,23), now], ["'The MegaTron'", 999, Date.new(1981,1,1), now]])
+    assert_equal %q([["Jeremy Olliver", 23, new Date (2011,0,1), new Date (2011,0,23,11,30,4)], ["Optimus Prime", 1000, new Date (1980,1,23), new Date (2011,0,23,11,30,4)], ["'The MegaTron'", 999, new Date (1981,0,1), new Date (2011,0,23,11,30,4)]]), @table.format_data
+  end
+end

data/test/test_google_visualization.rb ADDED Viewed

@@ -0,0 +1,61 @@
+require 'helper'
+class TestGoogleVisualization < MiniTest::Unit::TestCase
+  require 'action_view'
+  module ApplicationHelper
+    include GoogleVisualization
+  end
+  # Mocking out ActionView
+  class MockView
+    attr_accessor :buffer
+    include ApplicationHelper
+    def concat(s)
+      @buffer ||= ""
+      @buffer << s
+    end
+    def raw(s)
+      s
+    end
+    def render(template)
+      ERB.new(File.read(template)).result(binding)
+      # Render the view file first, then the overall layout
+      ERB.new(File.read("test/views/layout.html.erb")).result(binding)
+    end
+  end
+  def setup
+    @view = MockView.new
+  end
+  def test_attributes_and_methods
+    defined_attributes = [:google_visualizations, :visualization_packages]
+    defined_attributes.each do |a|
+      assert @view.respond_to?(a), "GoogleVisualization should have defined attribute: #{a}"
+    end
+    methods = [:include_visualization_api, :render_visualizations, :visualization]
+    methods.each do |meth|
+      assert @view.respond_to?(meth), "GoogleVisualization should have defined method: ##{meth}"
+    end
+  end
+  def test_support_for_corechart
+    output = @view.render("test/views/_corechart.html.erb")
+    assert_match("'packages':['corechart']", output, "only the corechart package should have been loaded")
+    %w(AreaChart BarChart ColumnChart LineChart PieChart).each do |chart_type|
+      assert_match("<div id=\"#{chart_type}_id\"", output, "The #{chart_type} graph div should exist on the page")
+    end
+  end
+  def test_motion_chart
+    output = @view.render("test/views/_motionchart.html.erb")
+    assert_match("'packages':['motionchart']", output, "the motionchart package should have been loaded")
+    assert_match("<div id=\"my_chart\"", output, "The graph div should exist on the page")
+  end
+end

data/test/views/_corechart.html.erb ADDED Viewed

@@ -0,0 +1,11 @@
+<%
+%w(AreaChart BarChart ColumnChart LineChart PieChart).each do |chart_type|
+  visualization("#{chart_type}_id", "LineChart") do |chart|
+    chart.columns = [["Name", "String"], ["age", "number"]]
+    chart.add_rows([
+      ["Jeremy", 23],
+      ["Ben", 24]
+    ])
+  end
+end
+%>

data/test/views/_motionchart.html.erb ADDED Viewed

@@ -0,0 +1,18 @@
+<% visualization "my_chart", "MotionChart", :width => 600, :height => 400, :html => {:class => "graph_chart"} do |chart| %>
+    <%# Add the columns that the graph will have %>
+    <% chart.string "Fruit" %>
+    <% chart.date "Date" %>
+    <% chart.number "Sales" %>
+    <% chart.number "Expenses" %>
+    <% chart.string "Location" %>
+    <%# Add the data %>
+    <% chart.add_rows([
+        ["Apples", Date.new(1998,1,1), 1000,300,'East'],
+        ["Oranges", Date.new(1998,1,1), 950,200,'West'],
+        ["Bananas", Date.new(1998,1,1), 300,250,'West'],
+        ["Apples", Date.new(1998,2,1), 1200,400,'East'],
+        ["Oranges", Date.new(1998,2,1), 950,150,'West'],
+        ["Bananas", Date.new(1998,2,1), 788,617,'West']
+    ]) %>
+<% end %>

data/test/views/layout.html.erb ADDED Viewed

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Test Application</title>
+  <%= render_visualizations %>
+</head>
+<body>
+<%= @buffer %>
+</body>
+</html>

metadata CHANGED Viewed

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: gvis
 version: !ruby/object:Gem::Version
-  hash: 13
+  hash: 11
   prerelease:
   segments:
   - 2
   - 0
-  - 1
-  version: 2.0.1
+  - 2
+  version: 2.0.2
 platform: ruby
 authors:
 - Jeremy Olliver
@@ -15,10 +15,81 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2011-03-12 00:00:00 +13:00
+date: 2011-04-17 00:00:00 +12:00
 default_executable:
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        hash: 3
+        segments:
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        hash: 3
+        segments:
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency
+  name: minitest
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        hash: 3
+        segments:
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency
+  name: rcov
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        hash: 3
+        segments:
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        hash: 7
+        segments:
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :development
+  version_requirements: *id005
 description: Easily embed charts with Google Visualization API, using ruby formatted options in your view files
 email: jeremy.olliver@gmail.com
 executables: []
@@ -28,12 +99,22 @@ extensions: []
 extra_rdoc_files: []
 files:
-- README
-- Rakefile
+- .gitignore
+- Gemfile
 - MIT-LICENSE
-- lib/gvis.rb
-- lib/data_table.rb
+- README.md
+- Rakefile
+- gvis.gemspec
 - lib/google_visualization.rb
+- lib/gvis.rb
+- lib/gvis/data_table.rb
+- lib/gvis/version.rb
+- test/helper.rb
+- test/test_data_table.rb
+- test/test_google_visualization.rb
+- test/views/_corechart.html.erb
+- test/views/_motionchart.html.erb
+- test/views/layout.html.erb
 has_rdoc: true
 homepage: http://github.com/jeremyolliver/gvis
 licenses: []
@@ -68,5 +149,10 @@ rubygems_version: 1.6.1
 signing_key:
 specification_version: 3
 summary: Easily embed charts with Google Visualization API
-test_files: []
+test_files:
+- test/helper.rb
+- test/test_data_table.rb
+- test/test_google_visualization.rb
+- test/views/_corechart.html.erb
+- test/views/_motionchart.html.erb
+- test/views/layout.html.erb

data/README DELETED Viewed

@@ -1,64 +0,0 @@
-Gvis
-====
-Rails plugin that provides a Ruby wrapper for easily loading the Google Visualization API, and simple generation of the javascript required to plot the graphs
-For a full list of the graphs provided by google's visualization api see: http://code.google.com/apis/visualization/documentation/gallery.html
-For documentation on how to use each graph type see: http://code.google.com/apis/visualization/documentation/
-version 2.X - Rails 3.X
-version 1.X - Rails 2.X
-Installation
-============
-Rails 3:
-# Gemfile
-gem 'gvis', '>= 2.0.0'
-Rails 2.X:
-# config/environment.rb
-config.gem 'gvis', :version => '< 2.0.0'
-# Include the GoogleVisualization module in app/helpers/application_helper.rb
-module ApplicationHelper
-  include GoogleVisualization
-end
-# Load the API, and render any graphs by placing these methods inside your layout
-# app/views/layouts/application.html.erb
-<head>
-	<%= include_visualization_api %>
-	<%= render_visualizations %>
-...
-</head>
-Example
-=======
-# Render desired graphs in the view
-# index.html.erb
-<% visualization "my_chart", "MotionChart", :width => 600, :height => 400, :html => {:class => "graph_chart"} do |chart| %>
-	<%# Add the columns that the graph will have %>
-	<% chart.string "Fruit" %>
-	<% chart.date "Date" %>
-	<% chart.number "Sales" %>
-	<% chart.number "Expenses" %>
-	<% chart.string "Location" %>
-	<%# Add the data %>
-	<% chart.add_rows([
-			["Apples", Date.new(1998,1,1), 1000,300,'East'],
-			["Oranges", Date.new(1998,1,1), 950,200,'West'],
-			["Bananas", Date.new(1998,1,1), 300,250,'West'],
-			["Apples", Date.new(1998,2,1), 1200,400,'East'],
-			["Oranges", Date.new(1998,2,1), 950,150,'West'],
-			["Bananas", Date.new(1998,2,1), 788,617,'West']
-		]) %>
-<% end %>
-Copyright (c) 2009 [Jeremy Olliver], released under the MIT license

data/lib/data_table.rb DELETED Viewed

@@ -1,76 +0,0 @@
-# Converts Ruby data structures into javascript strings for constructing the data for Google Visualization API clients.
-#
-# This library can be used to create a google.visualization.DataTable usable by
-# visualizations built on the Google Visualization API. Output formats are raw
-# JSON, JSON response, and JavaScript.
-#
-# written by Jeremy Olliver
-class DataTable
-  attr_accessor :data, :columns, :column_types
-  def initialize(data = nil, columns = [], options = {})
-    @columns, @column_types = [], {}
-    unless columns.nil? || columns.empty?
-      columns.each do |type, name|
-        register_column(type, name, options)
-      end
-    end
-    @data = data || []
-  end
-  # Registers each column explicitly, with data type, and a name associated
-  def register_column(type, name, options = {})
-    @columns << name.to_s
-    @column_types.merge!(name.to_s => type.to_s)
-  end
-  # Adds a single row to the table
-  def add_row(row)
-    @data << row
-  end
-  # Adds multiple rows (2D array) to the table
-  def add_rows(rows)
-    @data += rows
-  end
-  # Handle the Column definition methods (#string, #number, #date, #datetime)
-  def method_missing(method, *arguments)
-    if ["string", "number", "date", "datetime"].include?(method.to_s)
-      options = arguments.extract_options!
-      register_column(method, arguments, options)
-    else
-      raise NoMethodError.new(method)
-    end
-  end
-  ###################################################################################
-  # Format the ruby arrays into JS                                                  #
-  # Builds up a string representing a JS Array with JS escaped and formatted values #
-  ###################################################################################
-  def js_format_data
-    formatted_rows = []
-    @data.each do |row|
-      values = []
-      row.each_with_index do |entry,index|
-        # Format/escape individual values for javascript, checking column types, and the ruby value as a failsafe
-        safe_val = if @column_types[index] == "date" || entry.is_a?(Date)
-          # Format a date object as a javascript date
-          entry.is_a?(String) ? entry : "new Date (#{entry.year},#{entry.month - 1},#{entry.day})"
-        elsif @column_types[index] == "datetime" || entry.is_a?(Time)
-          # Format a Time (datetime) as a javascript date object down to seconds
-          entry.is_a?(String) ? entry : "new Date (#{entry.year},#{entry.month - 1},#{entry.day},#{entry.hour},#{entry.min},#{entry.sec})"
-        else
-          # Non date/time values can be JS escaped/formatted safely with # to_json
-          entry.to_json
-        end
-        values << safe_val
-      end
-      rowstring = "[#{values.join(",")}]"
-      formatted_rows << rowstring
-    end
-    "[#{formatted_rows.join(',')}]"
-  end
-end