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

gvis 2.0.1 → 2.0.2

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