google_visualr_rails5 2.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 336730e9cc3b35d547dc615631210d2afc4de27559278a3f90198babaebc4e40
+  data.tar.gz: 93888bafbd52dcffa8dacdbf54c7c691029f9dfd018b2e09fad54e2929542b44
+SHA512:
+  metadata.gz: a560535ccdc977233a1390db6a2c2e7adbeb031ba249fa29f9f0ae99027fc26c970b05e66760f803e5d68f657f7822a3962fe52e069892a22a998e60c701408f
+  data.tar.gz: d99d339f74bc54cbabb804a414c1716a642838ea753d283a067de916a05537ef9fd2154e72771fa0e082a96a6e896031c145b87d0a8ecad78c45c77685ff7383

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2011 Winston Teo Yong Wei
+
+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/README.md

@@ -0,0 +1,159 @@
+# GoogleVisualr
+
+[![Gem Version](http://img.shields.io/gem/v/google_visualr.svg?style=flat-square)](https://rubygems.org/gems/google_visualr)
+[![Build Status](http://img.shields.io/travis/Kenneth-KT/google_visualr.svg?style=flat-square)](https://travis-ci.org/winston/google_visualr)
+[![License](http://img.shields.io/:license-mit-blue.svg?style=flat-square)](https://github.com/winston/google_visualr/blob/master/MIT-LICENSE)
+
+GoogleVisualr, is a wrapper around the [Google Charts](https://developers.google.com/chart/) that allows anyone to create beautiful charts with just plain Ruby. You don't have to write any JavaScript at all.
+
+It's good for any Ruby (Rails/Sinatra) setup, and you can handle the entire charting logic in Ruby.
+
+Please refer to the [GoogleVisualr API Reference site](http://googlevisualr.herokuapp.com/) for a complete list of Google charts that you can create with GoogleVisualr.
+
+## tl:dr
+
+* In your model or controller, write Ruby code to create your chart (e.g. Area Chart, Bar Chart etc).
+* Configure your chart with any of the options as listed in Google's API Docs. E.g. [Area Chart](http://code.google.com/apis/chart/interactive/docs/gallery/areachart.html#Configuration_Options).
+* In your view, call `chart.to_js(div_id)` and that renders JavaScript into the HTML output.
+* You get your awesome Google chart, and you didn't write any JavaScript!
+
+## Limitations
+
+GoogleVisualr is not a 100% complete wrapper for Google Chart Tools.
+
+`Methods` and `Events` as described in Google's API Docs - for use after a chart has been rendered, 
+are not implemented because they feel more natural being written as JavaScript functions, within the views or .js files.
+
+## Install
+
+Assuming you are on Rails 3/4, include the gem in your Gemfile.
+
+    gem "google_visualr", ">= 2.5"
+
+## Basics
+
+This is a basic implementation of `GoogleVisualr::DataTable` and `GoogleVisualr::AreaChart`.
+
+For detailed documentation, please refer to the [GoogleVisualr API Reference](http://googlevisualr.herokuapp.com/) or [read the source](https://github.com/winston/google_visualr_app).
+
+---
+
+In your Rails layout, load Google Ajax API in the head tag, at the very top.
+
+    <script src='https://www.google.com/jsapi'></script>
+
+In your Rails controller, initialize a GoogleVisualr::DataTable object with an empty constructor.
+
+    data_table = GoogleVisualr::DataTable.new
+
+Populate data_table with column headers, and row values.
+
+	# Add Column Headers
+	data_table.new_column('string', 'Year' )
+	data_table.new_column('number', 'Sales')
+	data_table.new_column('number', 'Expenses')
+
+	# Add Rows and Values
+	data_table.add_rows([
+		['2004', 1000, 400],
+		['2005', 1170, 460],
+		['2006', 660, 1120],
+		['2007', 1030, 540]
+	])
+
+Create a GoogleVisualr::AreaChart with data_table and configuration options.
+
+	option = { width: 400, height: 240, title: 'Company Performance' }
+	@chart = GoogleVisualr::Interactive::AreaChart.new(data_table, option)
+
+In your Rails view, render the Google chart.
+
+	<div id='chart'></div>
+	<%= render_chart(@chart, 'chart') %>
+
+## Chart Initializer
+
+The initializer of `GoogleVisualr::<ChartName>` takes in two parameters: `data_table` and `options`.
+
+### `data_table` 
+
+`data_table` is an instance of `GoogleVisualr::DataTable` and contains headers and rows of data.
+
+### `options`
+
+`options` is a hash of configuration options for the Google chart (e.g. width, height, colors etc). 
+
+The available configuration options are exactly the same as those specified in Google's API Docs.
+
+For example: 
+- [Configuration options for AreaChart](https://developers.google.com/chart/interactive/docs/gallery/areachart#configuration-options)
+- [Configuration options for BarChart](https://developers.google.com/chart/interactive/docs/gallery/barchart#configuration-options)
+ 
+At the same time, you can also specify `version`, `language` and `material` as configuration options.
+
+#### `version`
+
+The default version of Google Charts library loaded is `1.0`. 
+
+However, some charts (e.g. Gantt Charts) require the latest version of the Google Charts library,
+so you will have to specify `version` as `1.1` in the configuration options 
+
+```
+....
+@chart = GoogleVisualr::GanttChart.new(data_table, { version: '1.1' })
+```
+
+[Read more about it on Google's API Docs](https://developers.google.com/chart/interactive/docs/basic_load_libs).
+
+#### `language` 
+
+The default locale of all Google Charts is `en`.
+ 
+You can override this default by specifying `language` in the configuration options.
+
+```
+....
+@chart = GoogleVisualr::BarChart.new(data_table, { language: 'ja' })
+```
+
+[Read more about it on Google's API Docs](https://developers.google.com/chart/interactive/docs/library_loading_enhancements#loadwithlocale).
+
+#### `material`
+
+Google has also enabled `Material` design for some charts:
+
+> In 2014, Google announced guidelines intended to support a common look and feel across its properties and apps (such as Android apps) that run on Google platforms. We call this effort Material Design. We'll be providing "Material" versions of all our core charts; you're welcome to use them if you like how they look.
+
+To use material design, you will have to specify `material` as `true` 
+in the configuration options.
+
+```
+....
+@chart = GoogleVisualr::BarChart.new(data_table, { material: true })
+```
+
+## Listeners
+
+For an example usage of `listeners`, please refer to [this comment](https://github.com/winston/google_visualr/issues/36#issuecomment-9880256).
+
+Besides `listeners` you can now also redraw charts in your JavaScript maunally by calling `draw_<element id>()` function. See [this commit](https://github.com/winston/google_visualr/commit/e5554886bd83f56dd31bbc543fdcf1e24523776a) for more details.
+
+## Support
+
+Please submit all feedback, bugs and feature-requests to [GitHub Issues Tracker](http://github.com/winston/google_visualr/issues).
+
+Feel free to fork the project, make improvements or bug fixes and submit pull requests (with tests!).
+
+## Who's Using GoogleVisualr?
+
+I would like to collect some data about who's using this Gem. [Please drop me a line](mailto:winstonyw+googlevisualr@gmail.com).
+
+## Author
+
+GoogleVisualr is maintained by [Winston Teo](mailto:winstonyw+googlevisualr@gmail.com).
+
+Who is Winston Teo? [You should follow Winston on Twitter](http://www.twitter.com/winstonyw), or find out more on [WinstonYW](http://www.winstonyw.com).
+
+## License
+
+Copyright © 2015 Winston Teo Yong Wei. Free software, released under the MIT license.

data/Rakefile

@@ -0,0 +1,9 @@
+# Bundler Gem Tasks
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task test: :spec
+task default: :spec

data/lib/google_visualr.rb

@@ -0,0 +1,53 @@
+lib_path = File.dirname(__FILE__)
+
+# Common
+require "#{lib_path}/google_visualr/param_helpers"
+
+# Base Classes
+require "#{lib_path}/google_visualr/data_table"
+
+require "#{lib_path}/google_visualr/packages"
+require "#{lib_path}/google_visualr/base_chart"
+
+require "#{lib_path}/google_visualr/formatters"
+
+# Interactive Charts
+
+## Main
+require "#{lib_path}/google_visualr/interactive/annotated_time_line"
+require "#{lib_path}/google_visualr/interactive/annotation_chart"
+require "#{lib_path}/google_visualr/interactive/area_chart"
+require "#{lib_path}/google_visualr/interactive/bar_chart"
+require "#{lib_path}/google_visualr/interactive/bubble_chart"
+require "#{lib_path}/google_visualr/interactive/calendar"
+require "#{lib_path}/google_visualr/interactive/candlestick_chart"
+require "#{lib_path}/google_visualr/interactive/column_chart"
+require "#{lib_path}/google_visualr/interactive/combo_chart"
+require "#{lib_path}/google_visualr/interactive/gantt_chart"
+require "#{lib_path}/google_visualr/interactive/gauge"
+require "#{lib_path}/google_visualr/interactive/geo_chart"
+require "#{lib_path}/google_visualr/interactive/geo_map"
+require "#{lib_path}/google_visualr/interactive/histogram"
+require "#{lib_path}/google_visualr/interactive/intensity_map"
+require "#{lib_path}/google_visualr/interactive/line_chart"
+require "#{lib_path}/google_visualr/interactive/map"
+require "#{lib_path}/google_visualr/interactive/motion_chart"
+require "#{lib_path}/google_visualr/interactive/org_chart"
+require "#{lib_path}/google_visualr/interactive/pie_chart"
+require "#{lib_path}/google_visualr/interactive/sankey"
+require "#{lib_path}/google_visualr/interactive/scatter_chart"
+require "#{lib_path}/google_visualr/interactive/stepped_area_chart"
+require "#{lib_path}/google_visualr/interactive/table"
+require "#{lib_path}/google_visualr/interactive/timeline"
+require "#{lib_path}/google_visualr/interactive/tree_map"
+require "#{lib_path}/google_visualr/interactive/word_tree"
+
+# Image Charts
+require "#{lib_path}/google_visualr/image/spark_line"
+require "#{lib_path}/google_visualr/image/bar_chart"
+require "#{lib_path}/google_visualr/image/line_chart"
+require "#{lib_path}/google_visualr/image/pie_chart"
+
+
+# Rails Helper
+require "#{lib_path}/google_visualr/app/railtie.rb" if defined?(Rails)

data/lib/google_visualr/app/helpers/view_helper.rb

@@ -0,0 +1,26 @@
+module GoogleVisualr
+  module Rails
+    module ViewHelper
+      extend ActiveSupport::Concern
+
+      included do
+        # Rails 5 compatibility fix
+        if respond_to?(:helper_method)
+          helper_method "render_chart"
+        end
+      end
+
+      def render_chart(chart, dom, options={})
+        script_tag = options.fetch(:script_tag) { true }
+        if script_tag
+          chart.to_js(dom).html_safe
+        else
+          html = ""
+          html << chart.load_js(dom)
+          html << chart.draw_js(dom)
+          html.html_safe
+        end
+      end
+    end
+  end
+end

data/lib/google_visualr/app/railtie.rb

@@ -0,0 +1,19 @@
+require "#{File.dirname(__FILE__)}/helpers/view_helper"
+
+module GoogleVisualr
+
+  module Rails
+
+    class Railtie < ::Rails::Railtie
+
+      initializer "google_visualr" do
+        ActiveSupport.on_load(:action_controller) do
+          include GoogleVisualr::Rails::ViewHelper
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/google_visualr/base_chart.rb

@@ -0,0 +1,100 @@
+module GoogleVisualr
+
+  class BaseChart
+    include GoogleVisualr::ParamHelpers
+
+    DEFAULT_VERSION = "1.0".freeze
+
+    attr_accessor :data_table, :listeners, :version, :language, :material
+
+    def initialize(data_table, options={})
+      @data_table  = data_table
+      @listeners   = []
+      @version     = options.delete(:version)  || DEFAULT_VERSION
+      @language    = options.delete(:language)
+      @material    = options.delete(:material) || false
+      send(:options=, options)
+    end
+
+    def package_name
+      self.class.to_s.split("::").last.downcase
+    end
+
+    def class_name
+      self.class.to_s.split("::").last
+    end
+
+    def chart_class
+      if material
+        "charts"
+      else
+        "visualization"
+      end
+    end
+
+    def chart_name
+      if material
+        class_name.gsub!("Chart", "")
+      else
+        class_name
+      end
+    end
+
+    def chart_function_name(element_id)
+      "draw_#{element_id.gsub('-', '_')}"
+    end
+
+    def options
+      @options
+    end
+
+    def options=(options)
+      @options = stringify_keys!(options)
+    end
+
+    def add_listener(event, callback)
+      @listeners << { :event => event.to_s, :callback => callback }
+    end
+
+    # Generates JavaScript and renders the Google Chart in the final HTML output.
+    #
+    # Parameters:
+    #  *div_id            [Required] The ID of the DIV element that the Google Chart should be rendered in.
+    def to_js(element_id)
+      js =  ""
+      js << "\n<script type='text/javascript'>"
+      js << load_js(element_id)
+      js << draw_js(element_id)
+      js << "\n</script>"
+      js
+    end
+
+    # Generates JavaScript for loading the appropriate Google Visualization package, with callback to render chart.
+    #
+    # Parameters:
+    #  *div_id            [Required] The ID of the DIV element that the Google Chart should be rendered in.
+    def load_js(element_id)
+      language_opt = ", language: '#{language}'" if language
+
+      "\n  google.load('visualization', '#{version}', {packages: ['#{package_name}']#{language_opt}, callback: #{chart_function_name(element_id)}});"
+    end
+
+    # Generates JavaScript function for rendering the chart.
+    #
+    # Parameters:
+    #  *div_id            [Required] The ID of the DIV element that the Google Chart should be rendered in.
+    def draw_js(element_id)
+      js = ""
+      js << "\n  function #{chart_function_name(element_id)}() {"
+      js << "\n    #{@data_table.to_js}"
+      js << "\n    var chart = new google.#{chart_class}.#{chart_name}(document.getElementById('#{element_id}'));"
+      @listeners.each do |listener|
+        js << "\n    google.visualization.events.addListener(chart, '#{listener[:event]}', #{listener[:callback]});"
+      end
+      js << "\n    chart.draw(data_table, #{js_parameters(@options)});"
+      js << "\n  };"
+      js
+    end
+  end
+
+end

data/lib/google_visualr/data_table.rb

@@ -0,0 +1,294 @@
+module GoogleVisualr
+
+  class DataTable
+
+    attr_accessor :cols
+    attr_accessor :rows
+
+    ##############################
+    # Constructors
+    ##############################
+    #
+    # GoogleVisualr::DataTable.new
+    # Creates an empty data_table instance. Use new_column/s, add_row/s and set_cell methods to populate the data_table.
+    #
+    # GoogleVisualr::DataTable.new(data_object)
+    # Creates a data_table by passing a JavaScript-string-literal like data object into the data parameter. This object can contain formatting options.
+    #
+    ##############################
+    # Syntax Description of a Data Object
+    ##############################
+    #
+    # The data object consists of two required top-level properties, cols and rows.
+    #
+    # * cols property
+    #
+    #   cols is an array of objects describing the ID and type of each column. Each property is an object with the following properties (case-sensitive):
+    #
+    #   * type            [Required] The data type of the data in the column. Supports the following string values:
+    #     - 'string'    : String value. Example values: v:'foo', :v:'bar'
+    #     - 'number'    : Number value. Example values: v:7, v:3.14, v:-55
+    #     - 'boolean'   : Boolean value ('true' or 'false'). Example values: v:true, v:false
+    #     - 'date'      : Date object, with the time truncated. Example value: v:Date.parse('2010-01-01')
+    #     - 'datetime'  : DateTime/Time object, time inclusive. Example value: v:DateTime.parse('2010-01-01 14:20:25')
+    #     - 'timeofday' : Array of 3 numbers or 4 numbers, [Hour,Minute,Second,(Optional) Milliseconds]. Example value: v:[8, 15, 0]
+    #   * label           [Optional] A string value that some visualizations display for this column. Example: label:'Height'
+    #   * id              [Optional] A unique (basic alphanumeric) string ID of the column. Be careful not to choose a JavaScript keyword. Example: id:'col_1'
+    #
+    # * rows property
+    #
+    #   The rows property holds an array of row objects. Each row object has one required property called c, which is an array of cells in that row.
+    #
+    #   Each cell in the table is described by an object with the following properties:
+    #
+    #   * v               [Optional] The cell value. The data type should match the column data type.
+    #   * f               [Optional] A string version of the v value, formatted strictly for display only. If omitted, a string version of v will be used.
+    #   * p               [Optional] An object that is a map of custom values applied to the cell. Example: :p => { :style => 'border: 1px solid green;' }.
+    #
+    #   Cells in the row array should be in the same order as their column descriptions in cols.
+    #
+    #   To indicate a null cell, you can either specify null, or set empty string for a cell in an array, or omit trailing array members.
+    #   So, to indicate a row with null for the first two cells, you could specify [ '', '', {cell_val}] or [null, null, {cell_val}].
+    def initialize(options = {})
+      @cols = Array.new
+      @rows = Array.new
+
+       unless options.empty?
+         cols = options[:cols]
+         new_columns(cols)
+
+         rows = options[:rows]
+         rows.each do |row|
+           add_row(row[:c])
+         end
+      end
+    end
+
+    # Adds a new column to the data_table.
+    # Experimental support for role (and pattern): http://code.google.com/apis/chart/interactive/docs/roles.html.
+    #
+    # Parameters:
+    #   * type            [Required] The data type of the data in the column. Supports the following string values:
+    #     - 'string'    : String value. Example values: v:'hello'
+    #     - 'number'    : Number value. Example values: v:7 , v:3.14, v:-55
+    #     - 'date'      : Date object, with the time truncated. Example values: v:Date.parse('2010-01-01')
+    #     - 'datetime'  : Date object including the time. Example values: v:Date.parse('2010-01-01 14:20:25')
+    #     - 'boolean'   : Boolean value ('true' or 'false'). Example values: v: true
+    #   * label           [Optional] A string value that some visualizations display for this column. Example: label:'Height'
+    #   * id              [Optional] A unique (basic alphanumeric) string ID of the column. Be careful not to choose a JavaScript keyword. Example: id:'col_1'
+    #   * role            [Optional] A string value that describes the purpose of the data in that column. Example, a column might hold data describing tooltip text, data point annotations, or uncertainty indicators.
+    #   * pattern         [Optional] A number (or date) format string specifying how to display the column value; used in conjunction with role.
+    def new_column(type, label=nil, id =nil, role=nil, pattern=nil)
+      column = { :type => type, :label => label, :id => id, :role => role, :pattern => pattern }.reject { |key, value| value.nil? }
+      @cols << column
+    end
+
+    # Adds multiple columns to the data_table.
+    #
+    # Parameters:
+    #   * columns         [Required] An array of column objects {:type, :label, :id, :role, :pattern}. Calls new_column for each column object.
+    def new_columns(columns)
+      columns.each do |column|
+        new_column(column[:type], column[:label], column[:id], column[:role], column[:pattern])
+      end
+    end
+
+    # Sets a column in data_table, specified by column_index with an array of column_values. column_index starts from 0.
+    #
+    # Parameters
+    #   * column_index    [Required] The column to assign column_values. column_index starts from 0.
+    #   * column_values   [Required] An array of cell values.
+    def set_column(column_index, column_values)
+      if @rows.size < column_values.size
+        1.upto(column_values.size - @rows.size) { @rows << Array.new }
+      end
+
+      column_values.each_with_index do |column_value, row_index|
+        set_cell(row_index, column_index, column_value)
+      end
+    end
+
+    # Gets a column of cell values from the data_table, at column_index. column_index starts from 0.
+    #
+    # Parameters
+    #   * column_index    [Required] The column to retrieve column values. column_index starts from 0.
+    def get_column(column_index)
+      @rows.transpose[column_index].collect(&:v)
+    end
+
+    # Adds a new row to the data_table.
+    # Call method without any parameters to add an empty row, otherwise, call method with a row object.
+    #
+    # Parameters:
+    #   * row             [Optional] An array of cell values specifying the data for the new row.
+    #     - You can specify a value for a cell (e.g. 'hi') or specify a formatted value using cell objects (e.g. {v:55, f:'Fifty-five'}) as described in the constructor section.
+    #     - You can mix simple values and cell objects in the same method call.
+    #     - To create an empty cell, use nil or empty string.
+    def add_row(row_values=[])
+      @rows    << Array.new
+      row_index = @rows.size-1
+
+      row_values.each_with_index do |row_value, column_index|
+        set_cell(row_index, column_index, row_value)
+      end
+    end
+
+    # Adds multiple rows to the data_table. You can call this method with data to populate a set of new rows or create new empty rows.
+    #
+    # Parameters:
+    #   * array_or_num    [Required] Either an array or a number.
+    #     - Array: An array of row objects used to populate a set of new rows. Each row is an object as described in add_row().
+    #     - Number: A number specifying the number of new empty rows to create.
+    def add_rows(array_or_num)
+      if array_or_num.is_a?(Array)
+        array_or_num.each do |row|
+          add_row(row)
+        end
+      else
+        array_or_num.times do
+          add_row
+        end
+      end
+    end
+
+    # Gets a row of cell values from the data_table, at row_index. row_index starts from 0.
+    #
+    # Parameters
+    #   * row_index       [Required] The row to retrieve row values. row_index starts from 0.
+    def get_row(row_index)
+      @rows[row_index].collect(&:v)
+    end
+
+    # Sets the value (and formatted value) of a cell.
+    #
+    # Parameters:
+    #   * row_index       [Required] A number greater than or equal to zero, but smaller than the total number of rows.
+    #   * column_index    [Required] A number greater than or equal to zero, but smaller than the total number of columns.
+    #   * value           [Required] The cell value.
+    #                       The data type should match the column data type.
+    #                       You can specify a value for a cell (e.g. 'hi').
+    #                       Or specify a formatted value using cell objects (e.g. {v:55, f:'Fifty-five'}).
+    def set_cell(row_index, column_index, value)
+      if within_range?(row_index, column_index)
+        verify_against_column_type( @cols[column_index][:type], value )
+        @rows[row_index][column_index] = GoogleVisualr::DataTable::Cell.new(value, @cols[column_index][:type])
+      else
+        raise RangeError, "row_index and column_index MUST be < @rows.size and @cols.size", caller
+      end
+    end
+
+    # Gets a cell value from the visualization, at row_index, column_index. row_index and column_index start from 0.
+    #
+    # Parameters:
+    #   * row_index       [Required] row_index starts from 0.
+    #   * column_index    [Required] column_index starts from 0.
+    def get_cell(row_index, column_index)
+      if within_range?(row_index, column_index)
+        @rows[row_index][column_index].v
+      else
+        raise RangeError, "row_index and column_index MUST be < @rows.size and @cols.size", caller
+      end
+    end
+
+    # Applies one or more formatters to the data_table to format the columns as specified by the formatter/s.
+    #
+    # Parameters:
+    #   * formatter/s     [Required] One, or an array of formatters.
+    def format(*formatters)
+      @formatters ||= Array.new
+      @formatters  += formatters
+    end
+
+    # Returns the JavaScript equivalent for this data_table instance.
+    def to_js
+      js = "var data_table = new google.visualization.DataTable();"
+
+      @cols.each do |column|
+        js << "data_table.addColumn("
+        js << display(column)
+        js << ");"
+      end
+
+      @rows.each do |row|
+        js << "data_table.addRow("
+        js << "[#{row.map(&:to_js).join(", ")}]" unless row.empty?
+        js << ");"
+      end
+
+      if @formatters
+        @formatters.each do |formatter|
+          js << formatter.to_js
+        end
+      end
+
+      js
+    end
+
+    private
+
+    def display(column)
+      column[:type] = "datetime" if column[:type] == "time"
+      column.to_json
+    end
+
+    def within_range?(row_index, column_index)
+      row_index < @rows.size && column_index < @cols.size
+    end
+
+    def verify_against_column_type(type, value)
+      v = value.is_a?(Hash) ? value[:v] : value
+
+      case
+        when v.nil?
+          return
+        when type == "string"
+          raise ArgumentError, "cell value '#{v}' is not a String", caller              unless v.is_a?(String)
+        when type == "number"
+          raise ArgumentError, "cell value '#{v}' is not an Integer, Float or BigDecimal", caller unless v.is_a?(Integer) || v.is_a?(Float) || v.is_a?(BigDecimal)
+        when type == "boolean"
+          raise ArgumentError, "cell value '#{v}' is not a Boolean", caller             unless v.is_a?(TrueClass) || v.is_a?(FalseClass)
+        when type == 'datetime'
+          raise ArgumentError, "cell value '#{v}' is not a DateTime", caller            unless v.is_a?(DateTime)  || v.is_a?(Time)
+        when type == 'time'
+          raise ArgumentError, "cell value '#{v}' is not a DateTime", caller            unless v.is_a?(DateTime)  || v.is_a?(Time)
+        when type == "date"
+          raise ArgumentError, "cell value '#{v}' is not a Date", caller                unless v.is_a?(Date)
+      end
+    end
+
+    class Cell
+      include GoogleVisualr::ParamHelpers
+
+      attr_accessor :v # value
+      attr_accessor :f # formatted
+      attr_accessor :p # properties
+
+      def initialize(options, type = nil)
+        if options.is_a?(Hash)
+          @v = options[:v]
+          @f = options[:f]
+          @p = options[:p]
+          @type = type
+        else # should be a string
+          @v = options
+          @type = type
+        end
+      end
+
+      def to_js
+        return "null" if @v.nil? && @f.nil? && @p.nil?
+
+        js  = "{"
+        js << "v: #{typecast(@v, @type)}"
+        js << ", f: #{typecast(@f)}"  unless @f.nil?
+        js << ", p: #{typecast(@p)}"  unless @p.nil?
+        js << "}"
+
+        js
+      end
+
+    end
+
+  end
+
+end