rorschart 0.7.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 207eb5f790581640bb554a961024807eeb918303
+  data.tar.gz: dbdce40762ccce890b98f80d6d1f34d69d9efebc
+SHA512:
+  metadata.gz: d2a3b6948b0e7f94186fa15c54d66a9dcbdf7a5803951b60ae937a39d73c6046c68c5684e1ece067b41900581d82a447d9e941ac09c8d8956d223b70478f0cac
+  data.tar.gz: 55da3d85a93e7987a55a76b194fa50d48d37cd86263e4fcb1581b4b5c89b2422ac24fd42bdd0fdfcaf27fc205236c609dfb0a55703d757657502f36bad19db23

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rorschart.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,45 @@
+PATH
+  remote: .
+  specs:
+    rorschart (0.7.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.0.2)
+      activesupport (= 4.0.2)
+      builder (~> 3.1.0)
+    activerecord (4.0.2)
+      activemodel (= 4.0.2)
+      activerecord-deprecated_finders (~> 1.0.2)
+      activesupport (= 4.0.2)
+      arel (~> 4.0.0)
+    activerecord-deprecated_finders (1.0.3)
+    activesupport (4.0.2)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    arel (4.0.1)
+    atomic (1.1.14)
+    builder (3.1.4)
+    i18n (0.6.9)
+    minitest (4.7.5)
+    multi_json (1.8.4)
+    rake (10.1.0)
+    sqlite3 (1.3.8)
+    thread_safe (0.1.3)
+      atomic
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  bundler (~> 1.3)
+  minitest
+  rake
+  rorschart!
+  sqlite3

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Eric Pantera, Viadeo
+
+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,18 @@
+Rorschart
+=========
+
+Rorschart is a Ruby library that interprates common Ruby and Activerecord data structures for you to generate beautiful Javascript Google Chart.
+
+* Multi-series charts directly from yours ActiveRecord queries
+* Works with all Google Charts
+* Detects appropriate data type to customize axes labels
+* Supports asynchonous ajax data generation
+* Rorschart knows how to draw charts from Array, Hash, Array of Array or Hash, ActiveRecord::Relation...
+
+Checkout the [demonstration page](http://viadeo.github.io/rorschart).
+
+Designed to be the perfect companion to [Snowplow-dashboard](https://github.com/viadeo/snowplow-dashboard).
+
+## License
+
+Distributed under the MIT license.

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task :default => :test
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+end

data/app/assets/javascripts/rorschart.js

@@ -0,0 +1,122 @@
+/*jslint browser: true, indent: 2, plusplus: true, vars: true */
+/*global google, $*/
+
+(function () {
+  'use strict';
+
+  var rorschart, resize;
+
+  if (window.hasOwnProperty('google')) {
+    google.load('visualization', '1.0', {'packages': ['corechart', 'table']});
+  } else {
+    throw new Error("Please include Google Charts first.");
+  }
+
+  function setText(element, text) {
+    if (document.body.innerText) {
+      element.innerText = text;
+    } else {
+      element.textContent = text;
+    }
+  }
+
+  function chartError(element, message) {
+    setText(element, "Error Loading Chart: " + message);
+    element.style.color = "#ff0000";
+  }
+
+  function getElement(element) {
+    if (typeof element === "string") {
+      element = document.getElementById(element);
+    }
+    return element;
+  }
+
+  resize = function (callback) {
+    if (window.attachEvent) {
+      window.attachEvent("onresize", callback);
+    } else if (window.addEventListener) {
+      window.addEventListener("resize", callback, true);
+    }
+    callback();
+  };
+
+  function processDate(dataTable) {
+    var i, j, col, date_ISO8601;
+
+    for (i = 0; i < dataTable.cols.length; i++) {
+      col = dataTable.cols[i];
+      if ((col.type === 'date') || (col.type === 'datetime')) {
+        for (j = 0; j < dataTable.rows.length; j++) {
+          date_ISO8601 = dataTable.rows[j].c[i].v;
+          dataTable.rows[j].c[i].v = new Date(date_ISO8601);
+        }
+      }
+    }
+    return dataTable;
+  }
+
+  function drawChart(ChartClass, element, dataSource, options) {
+
+    var dataTable, type;
+
+    type = Object.prototype.toString.call(dataSource);
+    if (type === '[object String]') {
+      dataSource = JSON.parse(dataSource);
+    }
+
+    dataSource = Object.create(dataSource);
+    if (dataSource.cols == null) {
+      setText(element, "Empty data")
+      return
+    }
+
+    try {
+      dataTable = new google.visualization.DataTable(processDate(dataSource));
+    } catch (err) {
+      chartError(element, err.message);
+      throw err;
+    }
+
+    var chart = new ChartClass(element);
+
+    resize(function () {
+      chart.draw(dataTable, options);
+    });
+  }
+
+  function retrieveRemoteData(element, url, callback) {
+    $.ajax({
+      url: url,
+      statusCode: {
+        202: function (data) {
+          //Use traditionnal polling here instead of long one. Heroku in mind.
+          setTimeout(function () {
+            retrieveRemoteData(element, url, callback);
+          }, 1500);
+        },
+        200: function (data) {
+          callback(data);
+        }
+      },
+      error: function (jqXHR, textStatus, errorThrown) {
+        var message = (typeof errorThrown === "string") ? errorThrown : errorThrown.message;
+        chartError(element, message + " "+ jqXHR.responseText);
+      }
+    });
+  }
+
+  rorschart = function (chartClass, element, dataSource, options) {
+    element = getElement(element);
+    if (typeof dataSource === "string") {
+      retrieveRemoteData(element, dataSource, function (data) {
+        google.setOnLoadCallback(drawChart(chartClass, element, data, options));
+      });
+    } else {
+      google.setOnLoadCallback(drawChart(chartClass, element, dataSource, options));
+    }
+  };
+
+  window.Rorschart = rorschart;
+
+}());

data/app/assets/stylesheets/rorschart.css

@@ -0,0 +1,34 @@
+/*  Table  */
+
+table {
+  width: 100%;
+}
+
+.header_row {
+  background: #FFF;
+  color: #000;
+  white-space:nowrap;
+}
+
+.header_cel {
+  border: 1px solid transparent;
+  border-bottom: 1px solid #EEE;  
+  font-weight: bold;
+  padding: 7px 0;
+}
+
+.hover_table_row {
+  background-color: #d6e9f8;
+}
+
+.table_row {
+  white-space:nowrap;
+}
+
+/* layout */
+
+.container {
+  width: 99%;
+}
+
+

data/lib/rorschart.rb

@@ -0,0 +1,3 @@
+require "rorschart/version"
+require "rorschart/helper"
+require "rorschart/rails" if defined?(Rails)

data/lib/rorschart/engine.rb

@@ -0,0 +1,17 @@
+module Rorschart
+  class Engine < ::Rails::Engine
+
+    initializer "precompile", :group => :all do |app|
+      # use a proc instead of a string
+      app.config.assets.precompile << Proc.new{|path| path == "rorschart.js" }
+      app.config.assets.precompile << Proc.new{|path| path == "rorschart.css" }
+    end
+
+    initializer "helper" do |app|
+      ActiveSupport.on_load(:action_view) do
+        include Helper
+      end
+    end
+
+  end
+end

data/lib/rorschart/helper.rb

@@ -0,0 +1,264 @@
+require "json"
+require "erb"
+
+module Rorschart
+  module Helper
+
+	def default_options
+		{
+			fontName: "'Helvetica Neue', Helvetica, Arial, sans-serif",
+			pointSize: 8,
+			lineWidth: 3,
+			chartArea: {
+				width: '100%',
+				height: '70%'
+			},
+			titlePosition: 'out',
+			axisTitlesPosition: 'in',
+			legend: {
+				textStyle: {
+					fontSize: 12,
+					color: "#444"
+				},
+				alignment: "end",
+				position: "top"
+			},
+			curveType: "function",
+			hAxis: {
+				textStyle: {
+					color: "#666",
+					fontSize: 12
+				},
+				gridlines: {
+					color: "transparent"
+				},
+				baselineColor: "#ccc",
+				viewWindow: {}
+			},
+			  vAxis: {
+				textStyle: {
+					color: "#666",
+					fontSize: 12
+				},
+				textPosition: 'in',
+				baselineColor: "#ccc",
+				viewWindow: {}
+			},
+			  tooltip: {
+				textStyle: {
+					color: "#666",
+					fontSize: 12
+				}
+			},
+			#A nice Color Scheme from http://www.colourlovers.com/palettes/top
+			colors: ['#00A0B0', '#6A4A3C', '#CC333F', '#EB6841', '#EDC951'],
+			# colors: ['#F8FCC1', '#CC0C39', '#E6781E', '#C8CF02', '#1693A7'],
+			allowHtml: true
+		}
+	end
+
+	def chart_options(klass_symbol)
+		{
+			"Table" => {
+				cssClassNames: {
+					tableRow: 'table_row',
+					headerRow: 'header_row',
+					headerCell: 'header_cel'
+				},
+				height: "100%"
+			},
+			"AreaChart" => {
+				isStacked: true,
+			},
+			"PieChart" => {
+				legend: {
+					alignment: "start",
+					position: "right"
+				}
+			}
+		}[klass_symbol] || {}
+	end
+
+	def line_chart(data_source, options = {})
+		rorschart_chart "LineChart", data_source, options
+	end
+
+	def pie_chart(data_source, options = {})
+		rorschart_chart "PieChart", data_source, options
+	end
+
+	def column_chart(data_source, options = {})
+		rorschart_chart "ColumnChart", data_source, options
+	end
+
+	def bar_chart(data_source, options = {})
+		rorschart_chart "BarChart", data_source, options
+	end
+
+	def area_chart(data_source, options = {})
+		rorschart_chart "AreaChart", data_source, options
+	end
+
+	def table_chart(data_source, options = {})
+		rorschart_chart "Table", data_source, options
+	end
+
+	def geo_chart(data_source, options = {})
+		rorschart_chart "GeoChart", data_source, options
+	end
+
+	def to_chart(data_source)
+		to_datatable_format(data_source).to_json
+	end
+
+	def rorschart_chart(klass_name, dataSource, options = {})
+
+		dataSource = format_if_needed(dataSource)
+		element_id = options.delete(:id) || generateChartId
+		options = default_options.merge(chart_options(klass_name)).deep_merge(options);
+		height = options.delete(:height) || "300px"
+
+		html = <<HTML
+			<div id="#{ERB::Util.html_escape(element_id)}" style="height: #{ERB::Util.html_escape(height)}; width:100%;">
+				Loading Chart data...
+			</div>
+HTML
+
+	 js = <<JS
+			<script type="text/javascript">
+				Rorschart(google.visualization.#{klass_name}, #{element_id.to_json}, #{dataSource.to_json}, #{options.to_json});
+			</script>
+JS
+
+		(html + js).html_safe 
+	end	
+
+private
+
+
+	def format_if_needed(data_source)
+		data_source.is_a?(String) ? data_source : to_datatable_format(data_source)
+	end
+
+	def to_datatable_format(data)
+
+		data = convert_objects_to_array_of_hash(data)
+		data = merge_series(data)
+
+		case data
+		when Array
+			
+			case data.first			
+			when Array
+				cols = columns_from_array_row(data.first)
+				rows = add_rows data
+			
+			when Hash
+				cols = columns_from_hash_row(data)
+				rows = add_rows data.map{|row| row.values}
+			end
+
+		when Hash
+			cols = columns_from_array_row(data.first)			
+			rows = add_rows data
+		end
+
+		return  {cols: cols, rows: rows}
+	end
+
+	def merge_series(data)
+
+		return data if data.first.nil? || data.first.is_a?(Array)
+		prototype = flatten_array_hash(data).inject({}) { |h, (k, v)| h[k] = nil; h }
+		return data if prototype.values.size > 3
+
+		series = {}
+		data.each { |e|
+			key = e.values.first
+			series[key] = series[key] ? convert_grouped_values_into_series(series[key], e) : prototype.merge(e)
+		}
+
+		if series.keys[0].is_a? Date
+			series.sort.collect{|e| e[1]}
+		else
+			series.values
+		end
+	end
+
+	def convert_grouped_values_into_series(serieA, serieB)
+		# if (serieB.values.size == 3)
+		# 	serieA.merge({serieB.values[1] => serieB.values[2]})
+		# else
+		# 	serieA.merge(serieB)
+		# end
+		serieA.merge(serieB)
+	end
+
+	def flatten_array_hash(data)
+		data.inject({}){|row, hash| row.merge(hash)}
+	end
+
+	def add_rows(rows)
+		rows.map{|row|
+			{"c" => 
+				row.map{|col|
+					{"v" => col}
+				}
+			}
+		}
+	end
+
+	def generateChartId
+		@current_chart_id ||= 0
+		"chart#{@current_chart_id += 1}"
+	end
+
+	def convert_objects_to_array_of_hash(data)
+	
+		data = data.to_a if data.is_a? ActiveRecord::Relation
+		data = [] << data if data.is_a? ActiveRecord::Base
+
+		if data.is_a? Array and data.first.is_a? ActiveRecord::Base
+			data = data.map{|m| model_to_hash_without_empty_primary_key(m)}			
+		end
+
+		return data
+	end
+
+	def model_to_hash_without_empty_primary_key(object)
+		primary_keys = object.class.columns.map{|c| c.name if c.primary}.compact
+		object.attributes.except(primary_keys.first)
+	end
+
+	def chart_class_from_string(klass_symbol)
+		"google.visualization." + klass_symbol.to_s
+	end
+
+	def columns_from_hash_row(data)
+		hash_row = flatten_array_hash(data)
+		hash_row.map { |c|
+			{:type => type_to_string(c[1]), :label => c[0]}
+		}
+	end
+
+	def columns_from_array_row(array_row)
+		array_row.map { |c|
+			{:type => type_to_string(c), :label => default_label_for_type(c)}
+		}
+	end
+
+	def type_to_string(cel)
+		return 'number' if (cel.is_a? Integer) or (cel.is_a? Float) or cel.nil?
+		return 'datetime' if (cel.is_a? DateTime) or (cel.is_a? Time) 
+		return 'date' if cel.is_a? Date
+		return 'boolean' if (!!cel == cel)
+		return 'string'
+	end
+
+	def default_label_for_type(cel)
+		return 'Date' if (cel.is_a? DateTime) or (cel.is_a? Date)
+		return 'Value'
+	end
+
+  end
+end

data/lib/rorschart/rails.rb

@@ -0,0 +1,5 @@
+if Rails.version >= "3.1"
+  require "rorschart/engine"
+else
+  ActionView::Base.send :include, Rorschart::Helper
+end

data/lib/rorschart/version.rb

@@ -0,0 +1,3 @@
+module Rorschart
+  VERSION = "0.7.2"
+end

data/rorschart.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rorschart/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rorschart"
+  spec.version       = Rorschart::VERSION
+  spec.authors       = ["Eric Pantera"]
+  spec.email         = ["eric.pantera@gmail.com"]
+  spec.description   = %q{Interprates Rails data structures for you to generate beautiful Google Charts}
+  spec.summary       = %q{Beautiful Google Charts from Rails data structures}
+  spec.homepage      = "https://github.com/epantera/rorschart"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "sqlite3"  
+end

data/test/rorschart_test.rb

@@ -0,0 +1,320 @@
+require "test_helper"
+
+
+class TestRorschart  < Minitest::Unit::TestCase
+  include Rorschart::Helper
+
+  def compare_dataTable(right, left)
+    assert_equal right[:cols], left[:cols]
+    assert_equal right[:cols].count, left[:cols].count
+    assert_equal right.to_json, left.to_json
+  end
+
+  def test_from_a_simple_hash_and_detect_type_and_name
+
+    # Given
+    data = {
+      DateTime.now => 17,
+      DateTime.now - 1 => 18      
+    }
+    
+    # When
+    dataTable = to_datatable_format(data)   
+
+    # Then
+    excepted = {
+       cols: [
+          {type: 'datetime', label: 'Date'},
+          {type: 'number', label: 'Value'}
+          ],
+       rows: [
+          {c:[{v: DateTime.now}, {v: 17}]},
+          {c:[{v: DateTime.now - 1}, {v: 18}]}
+           ]
+    }
+
+    compare_dataTable excepted, dataTable
+  end
+
+  def test_from_a_very_simple_hash_and_detect_type_and_name
+
+    # Given
+    data = {
+      "test" => DateTime.now
+    }
+    
+    # When
+    dataTable = to_datatable_format(data)   
+
+    # Then
+    excepted = {
+       cols: [
+          {type: 'string', label: 'Value'},
+          {type: 'datetime', label: 'Date'}
+          ],
+       rows: [
+          {c:[{v: "test"}, {v: DateTime.now}]}
+           ]
+    }
+
+    compare_dataTable excepted, dataTable
+  end
+
+  def test_from_an_array_of_hash_and_detect_type_and_reuse_column_name
+
+    # Given
+    data = [
+      {"collector_tstamp"=> Date.parse("2013-12-02"), "count"=> 44},
+      {"collector_tstamp"=> Date.parse("2013-11-28"), "count"=> 49}
+    ]
+
+    # When
+    dataTable = to_datatable_format(data)   
+
+    # Then
+    excepted = {
+       cols: [
+          {type: 'date', label: 'collector_tstamp'},
+          {type: 'number', label: 'count'}
+          ],
+       rows: [
+          {c:[{v: Date.parse("2013-11-28")}, {v: 49}]},
+          {c:[{v: Date.parse("2013-12-02")}, {v: 44}]}
+           ]
+    }
+
+    compare_dataTable excepted, dataTable
+  end
+
+  def test_from_an_array_of_array
+
+    # Given
+    data = [
+      [Date.parse("2013-12-02"), 44],
+      [Date.parse("2013-11-28"), 49]
+    ]
+
+    # When
+    dataTable = to_datatable_format(data)   
+
+    # Then
+    excepted = {
+       cols: [
+          {type: 'date', label: 'Date'},
+          {type: 'number', label: 'Value'}
+          ],
+       rows: [
+          {c:[{v: Date.parse("2013-12-02")}, {v: 44}]},
+          {c:[{v: Date.parse("2013-11-28")}, {v: 49}]}
+           ]
+    }
+
+    compare_dataTable excepted, dataTable
+  end
+
+
+  def test_from_a_model_remove_empty_primary_key
+
+    # Given
+    data = SampleModel.create(:username => 'John Doe', :age => 42)
+    # When
+    dataTable = to_datatable_format(data)   
+
+    # Then
+    excepted = {
+       cols: [
+          {type: 'string', label: 'username'},
+          {type: 'number', label: 'age'}
+          ],
+       rows: [
+          {c:[{v: "John Doe"}, {v: 42}]}
+           ]
+    }
+
+    compare_dataTable excepted, dataTable
+  end
+
+
+  def test_from_an_array_of_model
+
+    # Given
+    data = [ 
+      SampleModel.create(:username => 'John Doe', :age => 42),
+      SampleModel.create(:username => 'Jc', :age => 45)
+    ]
+
+    # When
+    dataTable = to_datatable_format(data)   
+
+    # Then
+    excepted = {
+       cols: [
+          {type: 'string', label: 'username'},
+          {type: 'number', label: 'age'}
+          ],
+       rows: [
+          {c:[{v: "John Doe"}, {v: 42}]},
+          {c:[{v: "Jc"}, {v: 45}]}
+           ]
+    }
+
+    compare_dataTable excepted, dataTable
+  end
+
+  def test_merge_two_series
+    # Given
+    data = [
+      {"collector_tstamp"=> Date.parse("2013-12-01"), "count"=> 1},
+      {"collector_tstamp"=> Date.parse("2013-12-02"), "count"=> 2},
+      {"collector_tstamp"=> Date.parse("2013-12-02"), "visit"=> 11},
+      {"collector_tstamp"=> Date.parse("2013-12-03"), "visit"=> 3}
+    ]
+
+    # When
+    series = to_datatable_format(data)
+
+    # Then
+    excepted = {
+       cols: [
+          {type: 'date', label: 'collector_tstamp'},
+          {type: 'number', label: 'count'},
+          {type: 'number', label: 'visit'}          
+          ],
+       rows: [
+          {c:[{v: Date.parse("2013-12-01")}, {v: 1}, {v: nil}]},
+          {c:[{v: Date.parse("2013-12-02")}, {v: 2}, {v: 11}]},          
+          {c:[{v: Date.parse("2013-12-03")}, {v: nil}, {v: 3}]}
+           ]
+    }
+
+    compare_dataTable excepted, series  
+
+  end
+
+  def test_merge_two_series_with_first_serie_start_later
+    # Given
+    data = [
+      {"collector_tstamp"=> Date.parse("2013-12-03"), "count"=> 1},
+      {"collector_tstamp"=> Date.parse("2013-12-04"), "count"=> 2},
+      {"collector_tstamp"=> Date.parse("2013-12-05"), "count"=> 3},
+
+      {"collector_tstamp"=> Date.parse("2013-12-01"), "visit"=> 5},
+      {"collector_tstamp"=> Date.parse("2013-12-02"), "visit"=> 6},
+      {"collector_tstamp"=> Date.parse("2013-12-03"), "visit"=> 7},
+      {"collector_tstamp"=> Date.parse("2013-12-04"), "visit"=> 8}
+    ]
+
+    # When
+    series = to_datatable_format(data)
+
+    # Then
+    excepted = {
+       cols: [
+          {type: 'date', label: 'collector_tstamp'},
+          {type: 'number', label: 'count'},
+          {type: 'number', label: 'visit'}          
+          ],
+       rows: [
+          {c:[{v: Date.parse("2013-12-01")}, {v: nil}, {v: 5}]},
+          {c:[{v: Date.parse("2013-12-02")}, {v: nil}, {v: 6}]},
+          {c:[{v: Date.parse("2013-12-03")}, {v: 1}, {v: 7}]},
+          {c:[{v: Date.parse("2013-12-04")}, {v: 2}, {v: 8}]},
+          {c:[{v: Date.parse("2013-12-05")}, {v: 3}, {v: nil}]}
+           ]
+    }
+
+    compare_dataTable excepted, series  
+
+  end
+
+  # def test_convert_numeric_grouped_dy_date_and_another_field_into_multiseries
+
+  #   # Given
+  #   data = [
+  #     {"collector_tstamp"=> Date.parse("2013-11-02"), "series" => "A", "count"=> 1},
+  #     {"collector_tstamp"=> Date.parse("2013-11-02"), "series" => "B", "count"=> 2},
+  #     {"collector_tstamp"=> Date.parse("2013-11-02"), "series" => "C", "count"=> 3},
+  #     {"collector_tstamp"=> Date.parse("2013-12-01"), "series" => "A", "count"=> 4},
+  #     {"collector_tstamp"=> Date.parse("2013-12-01"), "series" => "B", "count"=> 5}
+  #   ]
+
+  #   # When
+  #   dataTable = to_datatable_format(data)   
+
+  #   # Then
+  #   excepted = {
+  #      cols: [
+  #         {type: 'date', label: 'collector_tstamp'},
+  #         {type: 'number', label: 'A'},
+  #         {type: 'number', label: 'B'},
+  #         {type: 'number', label: 'C'},          
+  #         ],
+  #      rows: [
+  #         {c:[{v: Date.parse("2013-11-02")}, {v: 1}, {v: 2}, {v: 3}]},
+  #         {c:[{v: Date.parse("2013-12-01")}, {v: 3}, {v: 4}, {v: nil}]}
+  #          ]
+  #   }
+
+  #   compare_dataTable excepted, dataTable
+  # end  
+
+  # def test_convert_numeric_grouped_dy_date_and_multiple_fields_into_multiseries
+
+  #   # Given
+  #   data = [
+  #     {"collector_tstamp"=> Date.parse("2013-11-02"), "series" => "A", "count"=> 1},
+  #     {"collector_tstamp"=> Date.parse("2013-11-02"), "series" => "B", "count"=> 2},      
+  #     {"collector_tstamp"=> Date.parse("2013-12-01"), "series" => "A", "count"=> 3},
+  #     {"collector_tstamp"=> Date.parse("2013-12-01"), "series" => "B", "count"=> 4}
+  #   ]
+
+  #   # When
+  #   dataTable = to_datatable_format(data)   
+
+  #   # Then
+  #   excepted = {
+  #      cols: [
+  #         {type: 'date', label: 'collector_tstamp'},
+  #         {type: 'number', label: 'A'},
+  #         {type: 'number', label: 'B'}          
+  #         ],
+  #      rows: [
+  #         {c:[{v: Date.parse("2013-11-02")}, {v: 1}, {v: 2}]},
+  #         {c:[{v: Date.parse("2013-12-01")}, {v: 3}, {v: 4}]}
+  #          ]
+  #   }
+
+  #   compare_dataTable excepted, dataTable
+  # end   
+
+  def test_flatten_data
+
+    # Given
+    data = [
+              {:a => 1, :b => 2},
+              {:a => 2, :b => 3},
+              {:b => 2, :c => 4}
+            ] 
+
+    # When
+    flat = flatten_array_hash(data)
+
+    # Then
+    excepted = {:a => 2, :b => 2, :c => 4}
+
+    assert_equal excepted, flat
+  end
+
+end
+
+
+class SampleModel < ActiveRecord::Base
+  
+  def self.create_schema
+    schema = 'CREATE TABLE "sample_models" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "username" varchar(255), "age" INTEGER);'
+    ActiveRecord::Base.connection.execute(schema)
+  end
+
+  create_schema
+
+end 

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+require "bundler/setup"
+Bundler.require(:default)
+require "minitest/autorun"
+require "minitest/pride"
+require 'date'
+require 'active_record'
+require "sqlite3"
+
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3',
+  :database => ':memory:'
+)

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: rorschart
+version: !ruby/object:Gem::Version
+  version: 0.7.2
+platform: ruby
+authors:
+- Eric Pantera
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Interprates Rails data structures for you to generate beautiful Google
+  Charts
+email:
+- eric.pantera@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- app/assets/javascripts/rorschart.js
+- app/assets/stylesheets/rorschart.css
+- lib/rorschart.rb
+- lib/rorschart/engine.rb
+- lib/rorschart/helper.rb
+- lib/rorschart/rails.rb
+- lib/rorschart/version.rb
+- rorschart.gemspec
+- test/rorschart_test.rb
+- test/test_helper.rb
+homepage: https://github.com/epantera/rorschart
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Beautiful Google Charts from Rails data structures
+test_files:
+- test/rorschart_test.rb
+- test/test_helper.rb