google_visualr 2.1.0 → 2.1.1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    google_visualr (2.1.0)
+    google_visualr (2.1.1)
 
 GEM
   remote: http://rubygems.org/

data/README.rdoc

@@ -8,6 +8,21 @@ Good for any Ruby on Rails setup whereby you prefer to work your logic in models
 
 Please refer to the {GoogleVisualr API Reference site}[http://googlevisualr.heroku.com/] for a complete list of Google charts that you can create with GoogleVisualr.
 
+== The Gist
+
+* In your model or controller, write Ruby code to create your chart (e.g. Area Chart, Bar Chart, even Spark Lines etc).
+* Configure your chart with any of the options as listed in Google Chart Tools' API Docs. E.g. {Area Chart's Configuration Options}[http://code.google.com/apis/chart/interactive/docs/gallery/areachart.html#Configuration_Options].
+* In your view, invoke a <em>chart.to_js(div_id)</em> method and that will magically generate and insert JavaScript into the final HTML output.
+* You get your awesome Google chart, and you didn't write any JavaScript!
+
+== Limitations
+
+GoogleVisualr is created solely for the aim of simplifying the display of a chart, and not the interactions.
+
+Hence, do note that GoogleVisualr is not a 100% complete wrapper for Google Chart Tools.
+
+For example, Methods and Events as described in Google Chart Tools' API Docs, for use after a chart has been rendered, are not implemented because they felt more native being written as JavaScript functions, within views or .js files.
+
 == Differences Between Gem and Plugin
 
 Gem
@@ -24,21 +39,6 @@ This gem, however, is not a drop-in replacement for the plugin, as there are num
 
 Notably, you will have to interact mostly with GoogleVisualr::DataTable which was absent in the plugin.
 
-== The Gist
-
-* In your model or controller, write Ruby code to create your chart (e.g. Area Chart, Bar Chart, even Spark Lines etc).
-* Configure your chart with any of the options as listed in Google Chart Tools' API Docs. E.g. {Area Chart's Configuration Options}[http://code.google.com/apis/chart/interactive/docs/gallery/areachart.html#Configuration_Options].
-* In your view, invoke a <em>chart.to_js(div_id)</em> method and that will magically generate and insert JavaScript into the final HTML output.
-* You get your awesome Google chart, and you didn't write any JavaScript!
-
-== Limitations
-
-GoogleVisualr is created solely for the aim of simplifying the display of a chart, and not the interactions.
-
-Hence, do note that GoogleVisualr is not a 100% complete wrapper for Google Chart Tools.
-
-For example, Methods and Events as described in Google Chart Tools' API Docs, for use after a chart has been rendered, are not implemented because they felt more native being written as JavaScript functions, within views or .js files.
-
 = Install
 
 Assuming you are on Rails 3, include the gem in your Gemfile.
@@ -94,8 +94,8 @@ Please submit all feedback, bugs and feature-requests to {GitHub Issues Tracker}
 
 = Change Log
 
-*Version 2.1.0*
-* Added `#render_chart` as a helper method in Rails views.
+<em>Version 2.1.0</em>
+* Added +#render_chart+ as a helper method in Rails views.
 
 = Author
 

data/lib/google_visualr/data_table.rb

@@ -65,6 +65,7 @@ module GoogleVisualr
     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:
@@ -75,17 +76,20 @@ module GoogleVisualr
     #     - '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'
-    def new_column(type, label=nil, id =nil)
-      @cols << { :type => type, :label => label, :id => id }
+    #   * 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}. Calls new_column for each column object.
+    #   * 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])
+        new_column(column[:type], column[:label], column[:id], column[:role], column[:pattern])
       end
     end
 
@@ -200,10 +204,12 @@ module GoogleVisualr
       js = "var data_table = new google.visualization.DataTable();"
 
       @cols.each do |column|
-        js << "data_table.addColumn('"
-        js << "#{column[:type]}'"
-        js << ", '#{column[:label]}'" unless column[:label].nil?
-        js << ", '#{column[:id]}'"    unless column[:id].nil?
+        js << "data_table.addColumn("
+        if column[:role].nil?
+          js << column.map{ |key, value| "'#{value}'" }.join(", ")
+        else
+          js << "{" + column.map{ |key, value| "#{key}: '#{value}'" }.join(", ") + "}"
+        end
         js << ");"
       end
 

data/lib/google_visualr/version.rb

@@ -1,3 +1,3 @@
 module GoogleVisualr
-  VERSION = "2.1.0"
+  VERSION = "2.1.1"
 end

data/spec/google_visualr/data_table_spec.rb

@@ -2,8 +2,9 @@ require 'spec_helper'
 
 describe GoogleVisualr::DataTable do
 
-  def valid_object
+  let(:dt) { GoogleVisualr::DataTable.new }
 
+  def valid_object
     @cols = [
               { :id => 'A', :label => 'NEW A'  , :type => 'string' },
               { :id => 'B', :label => 'B-label', :type => 'number' },
@@ -15,12 +16,10 @@ describe GoogleVisualr::DataTable do
               { :c => [ {:v => 'c'}, {:v => 3.0, :f => 'Three'}, {:v => Date.parse('2008-04-30 00:31:26'), :f => '4/30/08 12:31 AM'} ] }
             ]
     GoogleVisualr::DataTable.new({:cols => @cols, :rows => @rows})
-
   end
 
   describe "#new" do
     it "initializes without params" do
-      dt = GoogleVisualr::DataTable.new
       dt.should_not be_nil
       dt.cols.should be_a_kind_of Array
       dt.rows.should be_a_kind_of Array
@@ -46,142 +45,144 @@ describe GoogleVisualr::DataTable do
 
   describe "#new_column" do
     it "initializes a new column with only type param" do
-      dt = GoogleVisualr::DataTable.new
       dt.new_column('string')
-      dt.cols.first.should == {:id => nil, :label => nil, :type => 'string'}
+      dt.cols.first.should == {:type => 'string'}
     end
 
     it "initializes a new column with all params" do
-      dt = GoogleVisualr::DataTable.new
       dt.new_column('string', 'A LABEL', 'col_0')
       dt.cols.first.should == {:id => 'col_0', :label => 'A LABEL', :type => 'string'}
     end
+
+    it "initializes a new column with experimental role param" do
+      dt.new_column('string', nil, nil, 'interval', 'pattern')
+      dt.cols.first.should == {:type => 'string', :role => 'interval', :pattern => 'pattern'}
+    end
   end
 
   describe "new_columns" do
-    it "initializes new columns" do
-      columns = [ {:id => 'A', :label => 'NEW A', :type => 'string'}, {:id => 'B', :label => 'NEW B', :type => 'string'} ]
+    it "initializes new columns (with experimental support)" do
+      columns = [
+        {:id => 'A', :label => 'NEW A', :type => 'string'},
+        {:id => 'B', :label => 'NEW B', :type => 'string'},
+        {:type => 'string', :role => 'interval', :pattern => 'pattern'}
+      ]
 
-      dt = GoogleVisualr::DataTable.new
       dt.new_columns(columns)
-      dt.cols.first.should  == columns.first
-      dt.cols.last.should   == columns.last
+      dt.cols[0].should == columns[0]
+      dt.cols[1].should == columns[1]
+      dt.cols[2].should == columns[2]
     end
   end
 
   context "column values" do
     before do
-      @dt = GoogleVisualr::DataTable.new
-      @dt.new_column({:type => 'number'})
-      @dt.set_column(0, [1,2,3])
+      dt.new_column({:type => 'number'})
+      dt.set_column(0, [1,2,3])
     end
 
     describe "#set_column" do
       it "sets a column of values to column #index" do
-        @dt.rows[0][0].v.should == 1
-        @dt.rows[1][0].v.should == 2
-        @dt.rows[2][0].v.should == 3
+        dt.rows[0][0].v.should == 1
+        dt.rows[1][0].v.should == 2
+        dt.rows[2][0].v.should == 3
       end
     end
 
     describe "#get_column" do
       it "retrieves values in column #index" do
-        @dt.get_column(0).should == [1,2,3]
+        dt.get_column(0).should == [1,2,3]
       end
     end
   end
 
   context "row values" do
     before do
-      @dt = GoogleVisualr::DataTable.new
-      @dt.new_columns( [ {:type => 'number'}, {:type => 'string'} ] )
-      @dt.rows.should be_empty
+      dt.new_columns( [ {:type => 'number'}, {:type => 'string'} ] )
+      dt.rows.should be_empty
     end
 
     describe "#add_row" do
       context "when param is empty" do
         it "adds an empty row to the data_table" do
-          @dt.add_row
-          @dt.rows.size.should == 1
-          @dt.rows[0].should be_empty
+          dt.add_row
+          dt.rows.size.should == 1
+          dt.rows[0].should be_empty
         end
       end
 
       context "when param is not empty" do
         it "adds the row values to the data_table" do
-          @dt.add_row([1, 'A'])
-          @dt.rows.size.should == 1
-          @dt.rows[0][0].v.should == 1
-          @dt.rows[0][1].v.should == 'A'
+          dt.add_row([1, 'A'])
+          dt.rows.size.should == 1
+          dt.rows[0][0].v.should == 1
+          dt.rows[0][1].v.should == 'A'
         end
       end
     end
 
-
     describe "#add_rows" do
       context "when param is number" do
         it "adds x number of empty rows to the data_table" do
-          @dt.add_rows(2)
-          @dt.rows.size.should == 2
-          @dt.rows[0].should be_empty
-          @dt.rows[1].should be_empty
+          dt.add_rows(2)
+          dt.rows.size.should == 2
+          dt.rows[0].should be_empty
+          dt.rows[1].should be_empty
         end
       end
 
       context "when param is an array" do
         it "adds the rows to the data_table" do
-          @dt.add_rows( [ [1, 'A'], [2, 'B'] ] )
-          @dt.rows.size.should == 2
+          dt.add_rows( [ [1, 'A'], [2, 'B'] ] )
+          dt.rows.size.should == 2
 
-          @dt.rows[0][0].v.should == 1
-          @dt.rows[0][1].v.should == 'A'
-          @dt.rows[1][0].v.should == 2
-          @dt.rows[1][1].v.should == 'B'
+          dt.rows[0][0].v.should == 1
+          dt.rows[0][1].v.should == 'A'
+          dt.rows[1][0].v.should == 2
+          dt.rows[1][1].v.should == 'B'
         end
       end
     end
 
     describe "@get_row" do
       it "retrieves values in row #index" do
-        @dt.add_rows( [ [1, 'A'], [2, 'B'] ] )
-        @dt.rows.size.should == 2
+        dt.add_rows( [ [1, 'A'], [2, 'B'] ] )
+        dt.rows.size.should == 2
 
-        @dt.get_row(0).should == [1, 'A']
-        @dt.get_row(1).should == [2, 'B']
+        dt.get_row(0).should == [1, 'A']
+        dt.get_row(1).should == [2, 'B']
       end
     end
   end
 
   context "cell value" do
     before do
-      @dt = GoogleVisualr::DataTable.new
-      @dt.new_columns( [ {:type => 'string'}, {:type => 'number'}, {:type => 'boolean'}, {:type => 'datetime'}, {:type => 'date'} ] )
-      @dt.add_row
+      dt.new_columns( [ {:type => 'string'}, {:type => 'number'}, {:type => 'boolean'}, {:type => 'datetime'}, {:type => 'date'} ] )
+      dt.add_row
     end
 
-
     describe "#set_cell" do
       it "sets cell" do
-        @dt.set_cell(0, 0, {:v => 'ABCD'})
-        @dt.set_cell(0, 1, 1000)
+        dt.set_cell(0, 0, {:v => 'ABCD'})
+        dt.set_cell(0, 1, 1000)
 
-        @dt.get_row(0).should == ['ABCD', 1000]
+        dt.get_row(0).should == ['ABCD', 1000]
       end
 
       it "raises an exception if the row_index or column_index specified is out of range" do
         expect {
-          @dt.set_cell(5, 0, 1000)
+          dt.set_cell(5, 0, 1000)
         }.to raise_exception(RangeError)
 
         expect {
-          @dt.set_cell(0, 5, 1000)
+          dt.set_cell(0, 5, 1000)
         }.to raise_exception(RangeError)
       end
 
       describe "#verify_against_column_type" do
         def assert_raises_exception(col, value)
           expect {
-            @dt.set_cell(0, col, value)
+            dt.set_cell(0, col, value)
           }.to raise_exception(ArgumentError)
         end
 
@@ -208,24 +209,24 @@ describe GoogleVisualr::DataTable do
 
       it "accepts 'nil' for all column types" do
         expect {
-          @dt.set_cell(0, 0, nil)
+          dt.set_cell(0, 0, nil)
         }.to_not raise_exception(ArgumentError)
       end
     end
 
     describe "#get_cell" do
       it "gets cell" do
-        @dt.set_cell(0, 0, 'ABCD')
-        @dt.get_cell(0, 0).should == 'ABCD'
+        dt.set_cell(0, 0, 'ABCD')
+        dt.get_cell(0, 0).should == 'ABCD'
       end
 
       it "raises an exception if the row_index or column_index specified is out of range" do
         expect {
-          @dt.get_cell(0, 5)
+          dt.get_cell(0, 5)
         }.to raise_exception(RangeError)
 
         expect {
-          @dt.get_cell(5, 0)
+          dt.get_cell(5, 0)
         }.to raise_exception(RangeError)
       end
     end
@@ -234,28 +235,35 @@ describe GoogleVisualr::DataTable do
   describe "#to_js" do
     context "cols" do
       it "includes :id and :label when these are specified" do
-        data_table = GoogleVisualr::DataTable.new()
-        data_table.new_column("Total", "Total", "1")
-        data_table.add_row([1])
+        dt.new_column('number', 'Total', '1')
+        dt.add_row([1])
 
-        data_table.to_js.should == "var data_table = new google.visualization.DataTable();data_table.addColumn('Total', 'Total', '1');data_table.addRow([{v: 1}]);"
+        dt.to_js.should == "var data_table = new google.visualization.DataTable();data_table.addColumn('number', 'Total', '1');data_table.addRow([{v: 1}]);"
       end
 
       it "excludes :id and :label when these are not specified" do
-        data_table = GoogleVisualr::DataTable.new()
-        data_table.new_column("Total")
-        data_table.add_row([1])
+        dt.new_column('number')
+        dt.add_row([1])
+
+        dt.to_js.should == "var data_table = new google.visualization.DataTable();data_table.addColumn('number');data_table.addRow([{v: 1}]);"
+      end
 
-        data_table.to_js.should == "var data_table = new google.visualization.DataTable();data_table.addColumn('Total');data_table.addRow([{v: 1}]);"
+      it "includes :role and :pattern when these are specified" do
+        dt.new_column('string', nil, nil, 'interval', 'pattern')
+        dt.add_row(['interval'])
+
+        dt.to_js.should == "var data_table = new google.visualization.DataTable();data_table.addColumn({type: 'string', role: 'interval', pattern: 'pattern'});data_table.addRow([{v: 'interval'}]);"
       end
     end
 
-    it "converts object to js string" do
-      dt = valid_object
-      js = dt.to_js
-      js.should match /google.visualization.DataTable/i
-      js.should match /addColumn/i
-      js.should match /addRow/i
+    context "valid object literal" do
+      it "converts object to js string" do
+        dt = valid_object
+        js = dt.to_js
+        js.should match /google.visualization.DataTable/i
+        js.should match /addColumn/i
+        js.should match /addRow/i
+      end
     end
   end
 
@@ -267,9 +275,9 @@ describe GoogleVisualr::DataTable do
       end
 
       it "initializes with a hash" do
-        cell = GoogleVisualr::DataTable::Cell.new( { :v => 1, :f => "1.0", :p => {:style => 'border: 1px solid green;'} } )
+        cell = GoogleVisualr::DataTable::Cell.new( { :v => 1, :f => '1.0', :p => {:style => 'border: 1px solid green;'} } )
         cell.v.should == 1
-        cell.f.should == "1.0"
+        cell.f.should == '1.0'
         cell.p.should == {:style => 'border: 1px solid green;'}
       end
     end
@@ -278,12 +286,12 @@ describe GoogleVisualr::DataTable do
       context "initialized with a value" do
         it "returns a json string" do
           cell = GoogleVisualr::DataTable::Cell.new(1)
-          cell.to_js.should == "{v: 1}"
+          cell.to_js.should == '{v: 1}'
         end
 
         it "returns 'null' when v is nil" do
           cell = GoogleVisualr::DataTable::Cell.new(nil)
-          cell.to_js.should == "null"
+          cell.to_js.should == 'null'
         end
       end
 

metadata

@@ -2,7 +2,7 @@
 name: google_visualr
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 2.1.0
+  version: 2.1.1
 platform: ruby
 authors: 
 - Winston Teo
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-13 00:00:00 Z
+date: 2012-01-22 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: bundler
@@ -171,7 +171,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: google_visualr
-rubygems_version: 1.8.5
+rubygems_version: 1.8.13
 signing_key: 
 specification_version: 3
 summary: A Ruby wrapper around the Google Chart Tools that allows anyone to create the same beautiful charts with just plain Ruby.