gchartrb 0.1.0

data/CREDITS

@@ -0,0 +1 @@
+Will Fitzgerald - http://www.entish.org/willwhim

data/History.txt

@@ -0,0 +1,5 @@
+== 0.1 / 2007-12-11
+
+* Initial Release
+* RDoc documentation
+

data/Manifest.txt

@@ -0,0 +1,13 @@
+CREDITS
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+TODO
+lib/google_chart.rb
+lib/google_chart/bar_chart.rb
+lib/google_chart/base.rb
+lib/google_chart/line_chart.rb
+lib/google_chart/pie_chart.rb
+lib/google_chart/venn_diagram.rb
+lib/test.rb

data/README.txt

@@ -0,0 +1,138 @@
+gchartrb
+    by Deepak Jois
+    http://code.google.com/p/gchartrb
+
+== DESCRIPTION:
+  
+gchartrb is a Ruby wrapper around the Google Chart API, located at http://code.google.com/apis/chart/ 
+
+Visit http://code.google.com/p/gchartrb to track development regarding gchartrb.
+
+== FEATURES:
+  
+* Provides an object oriented interface in Ruby to create Google Chart URLs for charts.
+
+== INSTALL:
+
+=== Ruby Gem:
+
+    sudo gem install gchartrb
+
+=== Source Code:
+
+Download the latest release from http://code.google.com/p/gchartrb/downloads/list
+
+=== Subversion
+
+    svn checkout http://gchartrb.googlecode.com/svn/trunk/ gchartrb-read-only
+
+== Problems/TODO
+The following features are pending :
+
+* Scatter Charts
+* Horizontal and Vertical range Markers
+* Line Styles
+* Shape Markers
+* Fill Area
+
+However, you can still make use of the API to insert arbitrary parameters
+
+    # Adding Extra params
+    lc = GoogleChart::LineChart.new('320x200', "Line Chart", false)
+    lc.data "Trend 1", [5,4,3,1,3,5,6], '0000ff'
+    lc.data "Trend 2", [1,2,3,4,5,6], '00ff00'
+    lc.data "Trend 3", [6,5,4,3,2,1], 'ff0000'
+    puts lc.to_url({:chm => "r,000000,0,0.1,0.5"}) # Single black line as a horizontal marker by inserting arbitrary param
+
+== SYNOPSIS:
+
+    require 'rubygems'
+    require 'google_chart'
+
+    # Pie Chart
+    pc = GoogleChart::PieChart.new('320x200', "Pie Chart",false)
+    pc.data "Apples", 40
+    pc.data "Banana", 20
+    pc.data "Peach", 30
+    pc.data "Orange", 60
+    puts pc.to_url
+
+    # Line Chart
+    lc = GoogleChart::LineChart.new('320x200', "Line Chart", false)
+    lc.data "Trend 1", [5,4,3,1,3,5,6], '0000ff'
+    lc.show_legend = true 
+    lc.show_labels = false
+    lc.data "Trend 2", [1,2,3,4,5,6], '00ff00'
+    lc.data "Trend 3", [6,5,4,3,2,1], 'ff0000'
+    lc.axis :y, :range => [0,6], :color => 'ff00ff', :font_size => 16, :alignment => :center
+    lc.axis :x, :range => [0,6], :color => '00ffff', :font_size => 16, :alignment => :center
+    lc.grid :x_step => 100.0/6.0, :y_step => 100.0/6.0, :length_segment => 1, :length_blank => 0
+    puts lc.to_url
+
+    # Bar Chart
+    bc = GoogleChart::BarChart.new('800x200', "Bar Chart", :vertical, false)
+    bc.data "Trend 1", [5,4,3,1,3,5], '0000ff' 
+    bc.data "Trend 2", [1,2,3,4,5,6], 'ff0000'
+    bc.data "Trend 3", [6,5,4,4,5,6], '00ff00'
+    puts bc.to_url
+
+    # Line XY Chart
+    lcxy =  GoogleChart::LineChart.new('320x200', "Line XY Chart", true)
+    lcxy.data "Trend 1", [[1,1], [2,2], [3,3], [4,4]], '0000ff'
+    lcxy.data "Trend 2", [[4,5], [2,2], [1,1], [3,4]], '00ff00'
+    puts lcxy.to_url 
+
+    # Venn Diagram
+    # Supply three vd.data statements of label, size, color for circles A, B, C
+    # Then, an :intersections with four values:
+    # the first value specifies the area of A intersecting B
+    # the second value specifies the area of B intersecting C
+    # the third value specifies the area of C intersecting A
+    # the fourth value specifies the area of A intersecting B intersecting C
+    vd = GoogleChart::VennDiagram.new("320x200", 'Venn Diagram') 
+    vd.data "Blue", 100, '0000ff'
+    vd.data "Green", 80, '00ff00'
+    vd.data "Red",   60, 'ff0000'
+    vd.intersections 30,30,30,10
+    puts vd.to_url
+
+    # Solid fill
+    lc.fill(:background, :solid, {:color => 'fff2cc'})
+    lc.fill(:chart, :solid, {:color => 'ffcccc'})
+    puts lc.to_url
+
+    # Gradient fill
+    lc.fill :background, :gradient, :angle => 0,  :color => [['76A4FB',1],['ffffff',0]]
+    lc.fill :chart, :gradient, :angle => 0, :color => [['76A4FB',1],
+                                                       ['ffffff',0]]
+    puts lc.to_url
+
+    # Stripes Fill
+    lc.fill :chart, :stripes, :angle => 90, :color => [['76A4FB',0.2],
+                                                       ['ffffff',0.2]]
+    puts lc.to_url
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007 Deepak Jois
+
+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/Rakefile

@@ -0,0 +1,18 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/google_chart.rb'
+
+Hoe.new('gchartrb', "0.1.0") do |p|
+  p.rubyforge_name  = 'gchartrb'
+  p.author          = 'Deepak Jois'
+  p.email           = 'deepak.jois@gmail.com'
+  p.summary         = 'Ruby Wrapper for the Google Chart API'
+  p.description     = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url             = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes         = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.remote_rdoc_dir = ''
+end
+
+# vim: syntax=Ruby

data/TODO

@@ -0,0 +1,23 @@
+TODO List (Features)
+====================
+* Axis labels
+* Grid lines
+* Markers
+* Line Styles
+* Fill Area
+* Handle Missing Values (?)
+* Other charts (Scatter)
+* Download image
+
+TODO List (Other)
+=================
+* Create an alternate git repository
+
+Code Level Improvements
+=======================
+* Write tests that render different kinds of graphs
+* Remove the need for core_ext.rb file (stupid idea I was trying out earlier)
+* Use splats instead of attribute accessors to provide a neater API (?)
+* Improved error handling and reporting for things
+  * Number of labels and number of postions in axis must be the same
+  * Axis styles need to be specified in a certain way

data/lib/google_chart.rb

@@ -0,0 +1,9 @@
+%w(
+    base
+    pie_chart
+    line_chart
+    bar_chart
+    venn_diagram    
+).each do |filename|
+    require File.dirname(__FILE__) + "/google_chart/#{filename}"
+end

data/lib/google_chart/bar_chart.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/base'
+module GoogleChart
+    # Generates a Bar Chart. You can specify the alignment(horizontal or vertical) and whether you want the bars to be grouped or stacked
+    # ==== Examples
+    #     bc = GoogleChart::BarChart.new('800x200', "Bar Chart", :vertical, false)
+    #     bc.data "Trend 1", [5,4,3,1,3,5], '0000ff'     
+    class BarChart < Base
+      
+      attr_accessor :alignment, :stacked
+      
+      # Specify the 
+      # * +chart_size+ in WIDTHxHEIGHT format
+      # * +chart_title+ as a string
+      # * +alignment+ as either <tt>:vertical</tt> or <tt>:horizontal</tt>
+      # * +stacked+ should be +true+ if you want the bars to be stacked, false otherwise
+      def initialize(chart_size='300x200', chart_title=nil, alignment=:vertical, stacked=false)
+          super(chart_size, chart_title)
+          @alignment = alignment
+          @stacked = stacked
+          set_chart_type
+          self.show_labels = false
+          self.show_legend = true
+      end
+      
+      # Set the alignment to either <tt>:vertical</tt> or <tt>:horizontal</tt>
+      def alignment=(value)
+          @alignment = value
+          set_chart_type
+      end
+      
+      # If you want the bar chart to be stacked, set the value to <tt>true</tt>, otherwise set the value to <tt>false</tt> to group it.
+      def stacked=(stacked)
+          @stacked = value
+          set_chart_type
+      end
+
+      def process_data
+          if @data.size > 1
+              max_value = @data.flatten.max
+                join_encoded_data(@data.collect { |series|
+                  encode_data(series, max_value)
+                })
+          else
+              encode_data(@data.flatten)
+          end
+      end
+      
+      private
+      def set_chart_type
+          # Set chart type
+          if alignment == :vertical and stacked == false
+              self.chart_type = :bvg
+          elsif alignment == :vertical and stacked == true
+              self.chart_type = :bvs
+          elsif alignment == :horizontal and stacked == false
+              self.chart_type = :bhg
+          elsif alignment == :horizontal and stacked == true
+              self.chart_type = :bhs
+          end          
+      end
+    end
+end

data/lib/google_chart/base.rb

@@ -0,0 +1,304 @@
+require 'uri'
+
+module GoogleChart
+    class Base
+        BASE_URL = "http://chart.apis.google.com/chart?"
+        
+        SIMPLE_ENCODING = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'.split('');
+        COMPLEX_ENCODING_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-.'.split('');
+        @@complex_encoding = []
+        COMPLEX_ENCODING_ALPHABET.each_with_index do |outer,index_outer|
+            COMPLEX_ENCODING_ALPHABET.each_with_index do |inner, index_inner|
+                @@complex_encoding[index_outer * 64 + index_inner] = outer + inner
+            end
+        end
+
+        attr_accessor :chart_size, :chart_type, :chart_title, :data_encoding, :params, :show_legend, :show_labels 
+    
+        def initialize(chart_size, chart_title)
+            self.params = Hash.new
+            @labels = []
+            @data   = []
+            @colors = []
+            @axis   = []
+            self.chart_size    = chart_size
+            self.chart_title   = chart_title
+            self.data_encoding = :simple
+            self.show_legend   = true
+            self.show_labels   = false
+        end
+        
+        # Generates the URL string that can be used to retrieve the graph image in PNG format.
+        # Use this after assigning all the properties to the graph
+        # You can pass in additional params as a hash for features that may not have been implemented
+        # For e.g
+        #      lc = GoogleChart::LineChart.new('320x200', "Line Chart", false)
+        #      lc.data "Trend 1", [5,4,3,1,3,5,6], '0000ff'
+        #      lc.data "Trend 2", [1,2,3,4,5,6], '00ff00'
+        #      lc.data "Trend 3", [6,5,4,3,2,1], 'ff0000'
+        #      puts lc.to_url({:chm => "000000,0,0.1,0.11"}) # Single black line as a horizontal marker        
+        def to_url(extras={})
+            params.clear
+            set_size
+            set_type
+            set_colors
+            set_fill_options
+            add_axis
+            add_grid  
+            add_data
+            add_labels(@labels) if show_labels
+            add_legend(@labels) if show_legend
+            add_title  if chart_title.to_s.length > 0 
+            
+            params.merge!(extras)
+            query_string = params.map { |k,v| "#{k}=#{URI.escape(v.to_s)}" }.join('&')
+            BASE_URL + query_string
+        end
+        
+        # Adds the data to the chart, according to the type of the graph being generated.
+        #
+        # [+name+] is a string containing a label for the data.
+        # [+value+] is either a number or an array of numbers containing the data. Pie Charts and Venn Diagrams take a single number, but other graphs require an array of numbers
+        # [+color+ (optional)] is a hexadecimal RGB value for the color to represent the data
+        # 
+        # ==== Examples
+        #
+        # for GoogleChart::LineChart (normal)
+        #    lc.data "Trend 1", [1,2,3,4,5], 'ff00ff'
+        #
+        # for GoogleChart::LineChart (XY chart)
+        #    lc.data "Trend 2", [[4,5], [2,2], [1,1], [3,4]], 'ff00ff'
+        #
+        # for GoogleChart::PieChart
+        #    lc.data "Apples", 5, 'ff00ff'
+        #    lc.data "Oranges", 7, '00ffff'
+        def data(name, value, color=nil)
+            @data << value
+            @labels << name
+            @colors << color if color
+        end
+        
+        def fill(bg_or_c, type, options = {})
+            case bg_or_c
+                when :background
+                    @background_fill = "bg," + process_fill_options(type, options)
+                when :chart
+                    @chart_fill = "c," + process_fill_options(type, options)
+            end
+        end
+        
+        # Adds an axis to the graph. Not applicable for Pie Chart (GoogleChart::PieChart) or Venn Diagram (GoogleChart::VennDiagram)
+        # 
+        # [+type+] is a symbol which can be one of <tt>:x</tt>, <tt>:y</tt>, <tt>:right</tt>, <tt>:top</tt> 
+        # [+options+] is a hash containing the options (see below)
+        # 
+        # ==== Options
+        # Not all the options are mandatory.
+        # [<tt>:labels</tt>] An array containing the labels for the axis
+        # [<tt>:position</tt>] An Array containing the positions for the labels
+        # [<tt>:range</tt>] An array containing 2 elements, the start value and end value
+        # 
+        # axis styling options have to be specified as follows
+        # [<tt>:color</tt>] Hexadecimal RGB value for the color to represent the data for the axis labels
+        # [<tt>:font_size</tt>] Font size of the labels in pixels
+        # [<tt>:alignment</tt>] can be one of <tt>:left</tt>, <tt>:center</tt> or <tt>:right</tt>
+        # 
+        # ==== Examples
+        #     lc.axis :y, :range => [0,6], :color => 'ff00ff', :font_size => 16, :alignment => :center
+        #       
+        def axis(type, options = {})
+          raise "Illegal axis type" unless [:x, :y, :right, :top].member?(type)          
+          @axis << [type, options]
+        end
+        
+        # Adds a grid to the graph. Applicable only for Line Chart (GoogleChart::LineChart) and Scatter Chart (available soon)
+        #
+        # [+options+] is a hash containing the options (see below) 
+        #
+        # === Options
+        # [<tt>:xstep</tt>] X axis step size
+        # [<tt>:ystep</tt>] Y axis step size
+        # [<tt>:length_segment</tt> (optional)] Length of the line segement. Useful with the :length_blank value to have dashed lines
+        # [<tt>:length_blank</tt> (optional)] Length of the blank segment. use 0 if you want a solid grid
+        # 
+        # === Examples
+        #     lc.grid :x_step => 5, :y_step => 5, :length_segment => 1, :length_blank => 0
+        #
+        
+        def grid(options={})
+          @grid_str = "#{options[:x_step].to_f},#{options[:y_step].to_f}"
+          if options[:length_segment] or options[:length_blank]
+             @grid_str += ",#{options[:length_segment].to_f},#{options[:length_blank].to_f}"
+          end
+        end    
+        
+        protected
+                
+        def process_fill_options(type, options)
+            case type
+              when :solid
+                  "s,#{options[:color]}"
+              when :gradient
+                  "lg,#{options[:angle]}," + options[:color].collect { |o| "#{o.first},#{o.last}" }.join(",")
+              when :stripes
+                  "ls,#{options[:angle]}," + options[:color].collect { |o| "#{o.first},#{o.last}" }.join(",")
+            end
+                            
+        end
+        
+        def set_type
+            params.merge!({:cht => chart_type})
+        end
+        
+        def set_size
+            params.merge!({:chs => chart_size})
+        end
+        
+        def set_colors
+          params.merge!({:chco => @colors.collect{|c| c.downcase}.join(",")  }) if @colors.size > 0
+        end
+        
+        def set_fill_options
+             fill_opt = [@background_fill, @chart_fill].compact.join("|")
+             params.merge!({:chf => fill_opt}) if fill_opt.length > 0
+        end
+        
+        def add_labels(labels)
+            params.merge!({:chl => labels.collect{|l| l.to_s}.join("|") }) 
+        end                
+    
+        def add_legend(labels)
+            params.merge!({:chdl => labels.collect{ |l| l.to_s}.join("|")})
+        end
+        
+        def add_title
+            params.merge!({:chtt => chart_title})
+        end
+        
+        def add_axis          
+            chxt = []
+            chxl = []
+            chxp = []
+            chxr = []                       
+            chxs = []
+            # Process params
+            @axis.each_with_index do |axis, idx|
+              # Find axis type
+              case axis.first
+                when :x
+                  chxt << "x"
+                when :y
+                  chxt << "y"
+                when :top
+                  chxt << "r"
+                when :right
+                  chxt << "t"
+              end
+              
+              # Axis labels
+              axis_opts = axis.last
+              
+              if axis_opts[:labels]
+                chxl[idx] = "#{idx}:|" + axis_opts[:labels].join("|")
+              end
+              
+              # Axis positions
+              if axis_opts[:positions]
+                chxp[idx] = "#{idx}," + axis_opts[:positions].join(",")
+              end
+              
+              # Axis range
+              if axis_opts[:range]
+                chxr[idx] = "#{idx},#{axis_opts[:range].first},#{axis_opts[:range].last}"                
+              end
+              
+              # Axis Styles
+              if axis_opts[:color] or axis_opts[:font_size] or axis_opts[:alignment]
+                if axis_opts[:alignment]
+                  alignment = case axis_opts[:alignment]
+                                when :center
+                                   0
+                                when :left
+                                  -1
+                                when :right
+                                   1 
+                                else
+                                   nil
+                              end
+                end
+                chxs[idx] = "#{idx}," + [axis_opts[:color], axis_opts[:font_size], alignment].compact.join(",")
+              end
+            end
+            
+            # Add to params hash
+            params.merge!({ :chxt => chxt.join(",") })          unless chxt.empty?
+            params.merge!({ :chxl => chxl.compact.join("|") })  unless chxl.compact.empty?
+            params.merge!({ :chxp => chxp.compact.join("|") })  unless chxp.compact.empty?
+            params.merge!({ :chxr => chxr.compact.join("|") })  unless chxr.compact.empty?
+            params.merge!({ :chxs => chxs.compact.join("|") })  unless chxs.compact.empty?
+        end
+        
+        def add_grid
+          params.merge!({ :chg => @grid_str }) if @grid_str
+        end
+        
+        def add_data
+            converted_data = process_data
+            case data_encoding
+                when :simple
+                    converted_data = "s:" + converted_data
+                when :text
+                    converted_data = "t:" + converted_data
+                when :extended
+                    converted_data = "e:" + converted_data
+                else
+                    raise "Illegal Encoding Specified"
+            end
+            params.merge!({:chd => converted_data})
+        end
+        
+        def encode_data(values, max_value=nil)
+            case data_encoding
+                when :simple
+                    simple_encode(values)
+                when :text
+                    text_encode(values)
+                when :extended
+                    extended_encode(values)
+                else
+                    raise "Illegal Encoding Specified"
+            end
+        end
+        
+        def simple_encode(values, max_value=nil)
+            alphabet_length = 61
+            max_value = values.max unless max_value
+
+            chart_data = values.collect do |val|              
+                    if val.to_i >=0  
+                        SIMPLE_ENCODING[(alphabet_length * val / max_value).to_i]
+                    else
+                        "_"
+                    end
+            end
+            
+            return chart_data.join('')
+        end
+        
+        def text_encode(values, max_value=nil)
+             max_value = values.max unless max_value
+             values.inject("") { |sum, v|
+               sum += ( "%.1f" % (v*100/max_value) ) + ","
+             }.chomp(",")
+        end
+        
+        def extended_encode(values, max_value)
+            max_value = values.max unless max_value
+            values.collect { |v| @@complex_encoding[(v * 4095/max_value).to_i]}.join('')
+        end
+        
+        def join_encoded_data(encoded_data)
+            encoded_data.join((self.data_encoding == :simple) ? "," : "|")
+        end
+    end
+end

data/lib/google_chart/line_chart.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/base'
+module GoogleChart
+    # Generates a Line Chart. You can specify whether it is a standard line chart or an XY Line chart
+    # 
+    # ==== Examples
+    #
+    #      # Line Chart
+    #      lc = GoogleChart::LineChart.new('320x200', "Line Chart", false)
+    #      lc.data "Trend 1", [5,4,3,1,3,5,6], '0000ff'
+    #      lc.data "Trend 2", [1,2,3,4,5,6], '00ff00'
+    #      lc.data "Trend 3", [6,5,4,3,2,1], 'ff0000'
+    #      puts lc.to_url
+    #
+    #      # Line XY Chart
+    #      lcxy =  GoogleChart::LineChart.new('320x200', "Line XY Chart", true)
+    #      lcxy.data "Trend 1", [[1,1], [2,2], [3,3], [4,4]], '0000ff'
+    #      lcxy.data "Trend 2", [[4,5], [2,2], [1,1], [3,4]], '00ff00'
+    #      puts lcxy.to_url    
+    class LineChart < Base
+        attr_accessor :is_xy
+        
+        # Initializes a Line Chart object with a +chart_size+ and +chart_title+. Specify +is_xy+ as +true+ to generate a Line XY chart
+        def initialize(chart_size='300x200', chart_title=nil, is_xy=false)
+            super(chart_size, chart_title)
+            self.is_xy = is_xy
+        end
+        
+        # If you want the Line Chart to be an XY chart, set the value to <tt>true</tt>, otherwise <tt>false</tt>.
+        #
+        # ==== Examples
+        # A line chart takes data in the following format (both X and Y coordinates need to be specified)
+        #     lcxy =  GoogleChart::LineChart.new('320x200', "Line XY Chart", true)
+        #     lcxy.data "Trend 1", [[1,1], [2,2], [3,3], [4,4]], '0000ff'
+        #     puts lcxy.to_url         
+        def is_xy=(value)
+            @is_xy = value
+            if value
+                self.chart_type = :lxy
+            else
+                self.chart_type = :lc
+            end
+        end
+                
+        def process_data
+            if self.is_xy or @data.size > 1
+                if self.is_xy # XY Line graph data series
+                  max_value = @data.flatten.max
+                 x_data = @data.collect do |series|
+                     series.collect { |val| val.first }
+                 end
+                 
+                 y_data = @data.collect do |series|
+                      series.collect { |val| val.last }
+                 end
+                  
+                  encoded_data = []
+                  @data.size.times { |i|
+                      # Interleave X and Y co-ordinate data
+                      encoded_data << join_encoded_data([encode_data(x_data[i],max_value), encode_data(y_data[i],max_value)])
+                  }
+                  join_encoded_data(encoded_data)
+                else # Line graph multiple data series
+                  max_value = @data.flatten.max
+                  join_encoded_data(@data.collect { |series|
+                    encode_data(series, max_value)
+                  })
+                end
+            else
+                encode_data(@data.flatten)
+            end
+        end
+    end
+end

data/lib/google_chart/pie_chart.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/base'
+module GoogleChart
+    class PieChart < Base
+
+        attr_accessor :is_3d
+
+        # Initializes a Pie Chart object with a +chart_size+ and +chart_title+. Specify <tt>is_3d</tt> as +true+ to generate a 3D Pie chart
+        def initialize(chart_size='300x200', chart_title=nil, is_3d = false)
+            super(chart_size, chart_title)
+            self.is_3d = is_3d
+        end
+
+        # Set this value to <tt>true</tt> if you want the Pie Chart to be rendered as a 3D image
+        def is_3d=(value)
+            if value
+                self.chart_type = :p3
+            else
+                self.chart_type = :p
+            end
+        end
+
+        def process_data
+            encode_data(@data)
+        end
+    end
+end

data/lib/google_chart/venn_diagram.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/base'
+module GoogleChart
+    # Generates a Venn Diagram.
+    #        
+    # Supply three vd.data statements of label, size, color for circles A, B, C. Then, intersections with four values:
+    # * the first value specifies the area of A intersecting B
+    # * the second value specifies the area of B intersecting C
+    # * the third value specifies the area of C intersecting A
+    # * the fourth value specifies the area of A intersecting B intersecting C
+    #
+    #      vd = GoogleChart::VennDiagram.new("320x200", 'Venn Diagram') 
+    #      vd.data "Blue", 100, '0000ff'
+    #      vd.data "Green", 80, '00ff00'
+    #      vd.data "Red",   60, 'ff0000'
+    #      vd.intersections 30,30,30,10
+    #      puts vd.to_url  
+    class VennDiagram < Base
+      
+        # Initializes the Venn Diagram with a +chart_size+ and a +chart_title+
+        def initialize(chart_size='300x200', chart_title=nil)
+            super(chart_size, chart_title)
+            self.chart_type = :v
+            @intersections = [] 
+        end
+         
+        def process_data          
+          encode_data(@data + @intersections)
+        end
+         
+        # Specify the intersections of the circles in the Venn Diagram. See the Rdoc for class for sample
+        def intersections(*values)            
+          @intersections = values
+        end
+    end
+end

data/lib/test.rb

@@ -0,0 +1,72 @@
+require 'google_chart'
+
+# Pie Chart
+pc = GoogleChart::PieChart.new('320x200', "Pie Chart",false)
+pc.data "Apples", 40
+pc.data "Banana", 20
+pc.data "Peach", 30
+pc.data "Orange", 60
+puts pc.to_url
+
+# Line Chart
+lc = GoogleChart::LineChart.new('320x200', "Line Chart", false)
+lc.data "Trend 1", [5,4,3,1,3,5,6], '0000ff'
+lc.show_legend = true 
+lc.show_labels = false
+lc.data "Trend 2", [1,2,3,4,5,6], '00ff00'
+lc.data "Trend 3", [6,5,4,3,2,1], 'ff0000'
+lc.axis :y, :range => [0,6], :color => 'ff00ff', :font_size => 16, :alignment => :center
+lc.axis :x, :range => [0,6], :color => '00ffff', :font_size => 16, :alignment => :center
+lc.grid :x_step => 100.0/6.0, :y_step => 100.0/6.0, :length_segment => 1, :length_blank => 0
+puts lc.to_url
+
+# Bar Chart
+bc = GoogleChart::BarChart.new('800x200', "Bar Chart", :vertical, false)
+bc.data "Trend 1", [5,4,3,1,3,5], '0000ff' 
+bc.data "Trend 2", [1,2,3,4,5,6], 'ff0000'
+bc.data "Trend 3", [6,5,4,4,5,6], '00ff00'
+puts bc.to_url
+
+# Line XY Chart
+lcxy =  GoogleChart::LineChart.new('320x200', "Line XY Chart", true)
+lcxy.data "Trend 1", [[1,1], [2,2], [3,3], [4,4]], '0000ff'
+lcxy.data "Trend 2", [[4,5], [2,2], [1,1], [3,4]], '00ff00'
+puts lcxy.to_url 
+
+# Venn Diagram
+# Supply three vd.data statements of label, size, color for circles A, B, C
+# Then, an :intersections with four values:
+# the first value specifies the area of A intersecting B
+# the second value specifies the area of B intersecting C
+# the third value specifies the area of C intersecting A
+# the fourth value specifies the area of A intersecting B intersecting C
+vd = GoogleChart::VennDiagram.new("320x200", 'Venn Diagram') 
+vd.data "Blue", 100, '0000ff'
+vd.data "Green", 80, '00ff00'
+vd.data "Red",   60, 'ff0000'
+vd.intersections 30,30,30,10
+puts vd.to_url
+
+# Solid fill
+lc.fill(:background, :solid, {:color => 'fff2cc'})
+lc.fill(:chart, :solid, {:color => 'ffcccc'})
+puts lc.to_url
+
+# Gradient fill
+lc.fill :background, :gradient, :angle => 0,  :color => [['76A4FB',1],['ffffff',0]]
+lc.fill :chart, :gradient, :angle => 0, :color => [['76A4FB',1],
+                                                   ['ffffff',0]]
+puts lc.to_url
+
+# Stripes Fill
+lc.fill :chart, :stripes, :angle => 90, :color => [['76A4FB',0.2],
+                                                   ['ffffff',0.2]]
+puts lc.to_url
+
+# Adding Extra params
+lc = GoogleChart::LineChart.new('320x200', "Line Chart", false)
+lc.data "Trend 1", [5,4,3,1,3,5,6], '0000ff'
+lc.data "Trend 2", [1,2,3,4,5,6], '00ff00'
+lc.data "Trend 3", [6,5,4,3,2,1], 'ff0000'
+puts lc.to_url({:chm => "r,000000,0,0.1,0.5"}) # Single black line as a horizontal marker
+

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: gchartrb
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-12-11 00:00:00 +08:00
+summary: Ruby Wrapper for the Google Chart API
+require_paths: 
+- lib
+email: deepak.jois@gmail.com
+homepage: "    by Deepak Jois"
+rubyforge_project: gchartrb
+description: "Visit http://code.google.com/p/gchartrb to track development regarding gchartrb.  == FEATURES:  * Provides an object oriented interface in Ruby to create Google Chart URLs for charts.  == INSTALL:  === Ruby Gem:"
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Deepak Jois
+files: 
+- CREDITS
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- TODO
+- lib/google_chart.rb
+- lib/google_chart/bar_chart.rb
+- lib/google_chart/base.rb
+- lib/google_chart/line_chart.rb
+- lib/google_chart/pie_chart.rb
+- lib/google_chart/venn_diagram.rb
+- lib/test.rb
+test_files: []
+
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+    version: