googlecharts 1.4.0 → 1.5.0

data/VERSION

@@ -1 +1 @@
-1.4.0
+1.5.0

data/lib/gchart.rb

@@ -7,79 +7,108 @@ require "cgi"
 require 'enumerator'
 
 class Gchart
-
   include GchartInfo
-  
-  @@url = "http://chart.apis.google.com/chart?"  
-  @@types = ['line', 'line_xy', 'scatter', 'bar', 'venn', 'pie', 'pie_3d', 'jstize', 'sparkline', 'meter', 'map']
-  @@simple_chars = ('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a
-  @@chars = @@simple_chars + ['-', '.']
-  @@ext_pairs = @@chars.map { |char_1| @@chars.map { |char_2| char_1 + char_2 } }.flatten
-  @@file_name = 'chart.png'
-  
-  attr_accessor :title, :type, :width, :height, :horizontal, :grouped, :legend, :data, :encoding, :min_value, :max_value, :bar_colors,
-                :title_color, :title_size, :custom, :axis_with_labels, :axis_labels, :bar_width_and_spacing, :id, :alt, :class,
-                :range_markers, :geographical_area, :map_colors, :country_codes, :axis_range
-    
-  # Support for Gchart.line(:title => 'my title', :size => '400x600')
-  def self.method_missing(m, options={})
-    # Start with theme defaults if a theme is set
-    theme = options[:theme]
-    options = theme ? Chart::Theme.load(theme).to_options.merge(options) : options 
-    # Extract the format and optional filename, then clean the hash
-    format = options[:format] || 'url'
-    @@file_name = options[:filename] unless options[:filename].nil?
-    options.delete(:format)
-    options.delete(:filename)
-    #update map_colors to be bar_colors
-    options.update(:bar_colors => options[:map_colors]) if options.has_key?(:map_colors)
-    # create the chart and return it in the format asked for
-    if @@types.include?(m.to_s)  
-      chart = new(options.merge!({:type => m}))
+
+  def self.url
+    "http://chart.apis.google.com/chart?" 
+  end
+
+  def self.types
+    @types ||= ['line', 'line_xy', 'scatter', 'bar', 'venn', 'pie', 'pie_3d', 'jstize', 'sparkline', 'meter', 'map']
+  end
+
+  def self.simple_chars
+    @simple_chars ||= ('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a
+  end 
+
+  def self.chars
+    @chars ||= simple_chars + ['-', '.']
+  end
+
+  def self.ext_pairs
+    @ext_pairs ||= chars.map { |char_1| chars.map { |char_2| char_1 + char_2 } }.flatten
+  end
+
+  def self.default_filename
+    'chart.png'
+  end
+
+  attr_accessor :title, :type, :width, :height, :horizontal, :grouped, :legend, :data, :encoding, :bar_colors,
+  :title_color, :title_size, :custom, :axis_with_labels, :axis_labels, :bar_width_and_spacing, :id, :alt, :klass,
+  :range_markers, :geographical_area, :map_colors, :country_codes, :axis_range, :filename, :min, :max, :colors
+
+  attr_accessor :bg_type, :bg_color, :bg_angle, :chart_type, :chart_color, :chart_angle, :axis_range
+
+  attr_accessor :min_value, :max_value
+  
+  types.each do |type|
+    instance_eval <<-DYNCLASSMETH
+    def #{type}(options = {})
+      # Start with theme defaults if a theme is set
+      theme = options[:theme]
+      options = theme ? Chart::Theme.load(theme).to_options.merge(options) : options 
+      # # Extract the format and optional filename, then clean the hash
+      format = options[:format] || 'url'
+      options[:filename] ||= Gchart.default_filename
+      options.delete(:format)
+      #update map_colors to become bar_colors
+      options.update(:bar_colors => options[:map_colors]) if options.has_key?(:map_colors)
+      chart = new(options.merge!({:type => "#{type}"}))
       chart.send(format)
-    elsif m.to_s == 'version' 
-      Gchart::VERSION::STRING
-    else
-      "#{m} is not a supported chart format, please use one of the following: #{supported_types}."
-    end  
+    end
+    DYNCLASSMETH
   end
-  
+
+  def version
+    Gchart::VERSION::STRING
+  end
+
+  def self.method_missing(m, options={})
+    raise NoMethodError, "#{m} is not a supported chart format, please use one of the following: #{supported_types}."
+  end
+
   def initialize(options={})
-      @type = :line
-      @data = []
-      @width = 300
-      @height = 200
-      @horizontal = false
-      @grouped = false
-      @encoding = 'simple'
-      @max_value = 'auto'
-      # Sets the alt tag when chart is exported as image tag
-      @alt = 'Google Chart'
-      # Sets the CSS id selector when chart is exported as image tag
-      @id = false
-      # Sets the CSS class selector when chart is exported as image tag
-      @class = false
-
-      # set the options value if definable
-      options.each do |attribute, value| 
-          send("#{attribute.to_s}=", value) if self.respond_to?("#{attribute}=")
-      end
+    @type = options[:type] || 'line'
+    @data = []
+    @width = 300
+    @height = 200
+    @horizontal = false
+    @grouped = false
+    @encoding = 'simple'
+    # @max_value = 'auto'
+    # @min_value defaults to nil meaning zero
+    @filename = options[:filename]
+    # Sets the alt tag when chart is exported as image tag
+    @alt = 'Google Chart'
+    # Sets the CSS id selector when chart is exported as image tag
+    @id = false
+    # Sets the CSS class selector when chart is exported as image tag
+    @klass = options[:class] || false
+    # set the options value if definable
+    options.each do |attribute, value| 
+      send("#{attribute}=", value) if self.respond_to?("#{attribute}=")
+    end
   end
-  
+
   def self.supported_types
-    @@types.join(' ')
+    Gchart.types.join(' ')
   end
-  
+
   # Defines the Graph size using the following format:
   # width X height
   def size=(size='300x200')
     @width, @height = size.split("x").map { |dimension| dimension.to_i }
   end
-  
+
   def size
-    "#{@width}x#{@height}"
+    "#{width}x#{height}"
   end
   
+  def dimensions
+    # TODO: maybe others?
+    [:line_xy, :scatter].include?(type) ? 2 : 1
+  end
+
   # Sets the orientation of a bar graph
   def orientation=(orientation='h')
     if orientation == 'h' || orientation == 'horizontal'
@@ -88,276 +117,360 @@ class Gchart
       self.horizontal = false
     end
   end
-  
+
   # Sets the bar graph presentation (stacked or grouped)
   def stacked=(option=true)
-   @grouped = option ? false : true
+    @grouped = option ? false : true
   end
-  
+
   def bg=(options)
     if options.is_a?(String)
       @bg_color = options
     elsif options.is_a?(Hash)
       @bg_color = options[:color]
-      @bg_type = options[:type]
+      @bg_type  = options[:type]
       @bg_angle = options[:angle]
     end
   end
-  
+
   def graph_bg=(options)
     if options.is_a?(String)
       @chart_color = options
     elsif options.is_a?(Hash)
       @chart_color = options[:color]
-      @chart_type = options[:type]
+      @chart_type  =  options[:type]
       @chart_angle = options[:angle]
     end
   end
   
+  def max_value=(max_v)
+    if max_v =~ /false/
+      @max_value = false
+    else
+      @max_value = max_v
+    end
+  end
+
+  def min_value=(min_v)
+    if min_v =~ /false/
+      @min_value = false
+    else
+      @min_value = min_v
+    end
+  end
+
   # returns the full data range as an array
   # it also sets the data range if not defined
   def full_data_range(ds)
-    return [@min, @max] unless (@min.nil? || @max.nil?)
-    @max = (max_value.nil? || max_value == 'auto') ? ds.compact.map{|mds| mds.compact.max}.max : max_value
-    if (min_value.nil? || min_value == 'auto') 
-      min_ds_value = ds.compact.map{|mds| mds.compact.min}.min || 0
-      @min = (min_ds_value < 0) ? min_ds_value : 0
+    return if max_value == false
+
+    ds.each_with_index do |mds, mds_index|
+      mds[:min_value] ||= min_value
+      mds[:max_value] ||= max_value
+      
+      if mds_index == 0 && type.to_s == 'bar'
+        # TODO: unless you specify a zero line (using chp or chds),
+        #       the min_value of a bar chart is always 0.
+        #mds[:min_value] ||= mds[:data].first.to_a.compact.min
+        mds[:min_value] ||= 0
+      end
+      if (mds_index == 0 && type.to_s == 'bar' && 
+        !grouped && mds[:data].first.is_a?(Array))
+        totals = []
+        mds[:data].each do |l|
+          l.each_with_index do |v, index|
+            next if v.nil?
+            totals[index] ||= 0
+            totals[index] += v
+          end
+        end
+        mds[:max_value] ||= totals.compact.max
+      else
+        all = mds[:data].flatten.compact
+        # default min value should be 0 unless set to auto
+        if mds[:min_value] == 'auto'
+          mds[:min_value] = all.min
+        else
+          min = all.min
+          mds[:min_value] ||=  (min && min < 0 ? min : 0)
+        end
+        mds[:max_value] ||= all.max
+      end
+    end
+
+    unless axis_range
+      @axis_range = ds.map{|mds| [mds[:min_value], mds[:max_value]]}
+      if dimensions == 1 && (type.to_s != 'bar' || horizontal)
+        tmp = axis_range.fetch(0, [])
+        @axis_range[0] = axis_range.fetch(1, [])
+        @axis_range[1] = tmp
+      end
+    end
+    # return [min, max] unless (min.nil? || max.nil?)
+    # @max = (max_value.nil? || max_value == 'auto') ? ds.compact.map{|mds| mds.compact.max}.max : max_value
+    # 
+    # if min_value.nil? 
+    #   min_ds_value = ds.compact.map{|mds| mds.compact.min}.min || 0
+    #   @min = (min_ds_value < 0) ? min_ds_value : 0
+    # else
+    #   @min = min_value == 'auto' ? ds.compact.map{|mds| mds.compact.min}.min || 0 : min_value      
+    # end
+    # @axis_range = [[min,max]]
+  end
+
+  def dataset
+    if @dataset
+      @dataset 
     else
-      @min = min_value  
-    end 
-    @axis_range = [[@min,@max]]
+      @dataset = convert_dataset(data || [])
+      full_data_range(@dataset)   # unless axis_range
+      @dataset
+    end
   end
   
-  def dataset
-    @dataset ||= prepare_dataset(data)
-    full_data_range(@dataset) unless @axis_range
-    @dataset
+  # Sets of data to handle multiple sets
+  def datasets
+    datasets = []
+    dataset.each do |d|
+      if d[:data].first.is_a?(Array)
+        datasets += d[:data]
+      else
+        datasets << d[:data]
+      end
+    end
+    datasets
   end
   
   def self.jstize(string)
-    string.gsub(' ', '+').gsub(/\[|\{|\}|\||\\|\^|\[|\]|\`|\]/) {|c| "%#{c[0].to_s(16).upcase}"}
+    string.gsub(' ', '+').gsub(/\[|\{|\}|\\|\^|\[|\]|\`|\]/) {|c| "%#{c[0].to_s.upcase}"}
   end    
   # load all the custom aliases
   require 'gchart/aliases'
-  
-  protected
-  
+
   # Returns the chart's generated PNG as a blob. (borrowed from John's gchart.rubyforge.org)
   def fetch
     open(query_builder) { |io| io.read }
   end
 
   # Writes the chart's generated PNG to a file. (borrowed from John's gchart.rubyforge.org)
-  def write(io_or_file=@@file_name)
+  def write
+    io_or_file = filename || Gchart.default_filename
     return io_or_file.write(fetch) if io_or_file.respond_to?(:write)
     open(io_or_file, "w+") { |io| io.write(fetch) }
   end
-  
+
   # Format
-  
+
   def image_tag
     image = "<img"
-    image += " id=\"#{@id}\"" if @id  
-    image += " class=\"#{@class}\"" if @class      
+    image += " id=\"#{id}\"" if id  
+    image += " class=\"#{klass}\"" if klass      
     image += " src=\"#{query_builder(:html)}\""
-    image += " width=\"#{@width}\""
-    image += " height=\"#{@height}\""
-    image += " alt=\"#{@alt}\""
-    image += " title=\"#{@title}\"" if @title
+    image += " width=\"#{width}\""
+    image += " height=\"#{height}\""
+    image += " alt=\"#{alt}\""
+    image += " title=\"#{title}\"" if title
     image += " />"
   end
-  
+
   alias_method :img_tag, :image_tag
-  
+
   def url
     query_builder
   end
-  
+
   def file
     write
   end
-  
+
   #
   def jstize(string)
     Gchart.jstize(string)
   end 
-  
+
   private
-  
+
   # The title size cannot be set without specifying a color.
   # A dark key will be used for the title color if no color is specified 
   def set_title
     title_params = "chtt=#{title}"
     unless (title_color.nil? && title_size.nil? )
-      title_params << "&chts=" + (color, size = (@title_color || '454545'), @title_size).compact.join(',')
+      title_params << "&chts=" + (color, size = (title_color || '454545'), title_size).compact.join(',')
     end
     title_params
   end
-  
+
   def set_size
     "chs=#{size}"
   end
-  
+
   def set_data
     data = send("#{@encoding}_encoding")
     "chd=#{data}"
   end
-  
+
   def set_colors
-    bg_type = fill_type(@bg_type) || 's' if @bg_color
-    chart_type = fill_type(@chart_type) || 's' if @chart_color
-    
-    "chf=" + {'bg' => fill_for(bg_type, @bg_color, @bg_angle), 'c' => fill_for(chart_type, @chart_color, @chart_angle)}.map{|k,v| "#{k},#{v}" unless v.nil?}.compact.join('|')      
+    @bg_type = fill_type(bg_type) || 's' if bg_color
+    @chart_type = fill_type(chart_type) || 's' if chart_color
+
+    "chf=" + {'bg' => fill_for(bg_type, bg_color, bg_angle), 'c' => fill_for(chart_type, chart_color, chart_angle)}.map{|k,v| "#{k},#{v}" unless v.nil?}.compact.join('|')      
   end
-  
+
   # set bar, line colors
   def set_bar_colors
-    @bar_colors = @bar_colors.join(',') if @bar_colors.is_a?(Array)
-    "chco=#{@bar_colors}"
+    @bar_colors = bar_colors.join(',') if bar_colors.is_a?(Array)
+    "chco=#{bar_colors}"
   end
-  
+
   def set_country_codes
-    @country_codes = @country_codes.join() if @country_codes.is_a?(Array)
-    "chld=#{@country_codes}"
+    @country_codes = country_codes.join() if country_codes.is_a?(Array)
+    "chld=#{country_codes}"
   end
-  
+
   # set bar spacing
   # chbh=
   # <bar width in pixels>,
   # <optional space between bars in a group>,
   # <optional space between groups>
   def set_bar_width_and_spacing
-    width_and_spacing_values = case @bar_width_and_spacing
+    width_and_spacing_values = case bar_width_and_spacing
     when String
-      @bar_width_and_spacing
+      bar_width_and_spacing
     when Array
-      @bar_width_and_spacing.join(',')
+      bar_width_and_spacing.join(',')
     when Hash
-      width = @bar_width_and_spacing[:width] || 23
-      spacing = @bar_width_and_spacing[:spacing] || 4
-      group_spacing = @bar_width_and_spacing[:group_spacing] || 8
+      width         = bar_width_and_spacing[:width] || 23
+      spacing       = bar_width_and_spacing[:spacing] || 4
+      group_spacing = bar_width_and_spacing[:group_spacing] || 8
       [width,spacing,group_spacing].join(',')
     else
-      @bar_width_and_spacing.to_s
+      bar_width_and_spacing.to_s
     end
     "chbh=#{width_and_spacing_values}"
   end
-  
+
   def set_range_markers
-    markers = case @range_markers
+    markers = case range_markers
     when Hash
-      set_range_marker(@range_markers)
+      set_range_marker(range_markers)
     when Array
       range_markers.collect{|marker| set_range_marker(marker)}.join('|')
     end
     "chm=#{markers}"
   end
-  
+
   def set_range_marker(options)
     orientation = ['vertical', 'Vertical', 'V', 'v', 'R'].include?(options[:orientation]) ? 'R' : 'r'
     "#{orientation},#{options[:color]},0,#{options[:start_position]},#{options[:stop_position]}#{',1' if options[:overlaid?]}"  
   end
-  
+
   def fill_for(type=nil, color='', angle=nil)
     unless type.nil? 
       case type
-        when 'lg'
-          angle ||= 0
-          color = "#{color},0,ffffff,1" if color.split(',').size == 1
-          "#{type},#{angle},#{color}"
-        when 'ls'
-          angle ||= 90
-          color = "#{color},0.2,ffffff,0.2" if color.split(',').size == 1
-          "#{type},#{angle},#{color}"
-        else
-          "#{type},#{color}"
-        end
+      when 'lg'
+        angle ||= 0
+        color = "#{color},0,ffffff,1" if color.split(',').size == 1
+        "#{type},#{angle},#{color}"
+      when 'ls'
+        angle ||= 90
+        color = "#{color},0.2,ffffff,0.2" if color.split(',').size == 1
+        "#{type},#{angle},#{color}"
+      else
+        "#{type},#{color}"
+      end
     end
   end
-  
+
   # A chart can have one or many legends. 
   # Gchart.line(:legend => 'label')
   # or
   # Gchart.line(:legend => ['first label', 'last label'])
   def set_legend
-    return set_labels if @type == :pie || @type == :pie_3d || @type == :meter
-    
-    if @legend.is_a?(Array)
-      "chdl=#{@legend.map{|label| "#{CGI::escape(label)}"}.join('|')}"
+    return set_labels if type.to_s =~ /pie|pie_3d|meter/
+
+    if legend.is_a?(Array)
+      "chdl=#{@legend.map{|label| "#{CGI::escape(label.to_s)}"}.join('|')}"
     else
-      "chdl=#{@legend}"
+      "chdl=#{legend}"
     end
-    
+
   end
-  
+
   def set_labels
-     if @legend.is_a?(Array)
-        "chl=#{@legend.map{|label| "#{label}"}.join('|')}"
-      else
-        "chl=#{@legend}"
-      end
+    if legend.is_a?(Array)
+      "chl=#{@legend.map{|label| "#{CGI::escape(label.to_s)}"}.join('|')}"
+    else
+      "chl=#{@legend}"
+    end
   end
-  
+
   def set_axis_with_labels
-    @axis_with_labels = @axis_with_labels.join(',') if @axis_with_labels.is_a?(Array)
-    "chxt=#{@axis_with_labels}"
+    @axis_with_labels = axis_with_labels.join(',') if @axis_with_labels.is_a?(Array)
+    "chxt=#{axis_with_labels}"
   end
-  
+
   def set_axis_labels
-    labels_arr = []
-    axis_labels.each_with_index do |labels,index| 
+    if axis_labels.is_a?(Array)
+      if RUBY_VERSION.to_f < 1.9
+        labels_arr = axis_labels.enum_with_index.map{|labels,index| [index,labels]}
+      else
+        labels_arr = axis_labels.map.with_index.map{|labels,index| [index,labels]}
+      end
+    elsif axis_labels.is_a?(Hash)
+      labels_arr = axis_labels.to_a
+    end
+    labels_arr.map! do |index,labels|
       if labels.is_a?(Array)
-        labels_arr << "#{index}:|#{labels.join('|')}"
+        "#{index}:|#{labels.map{|label| "#{CGI::escape(label.to_s)}"}.join('|')}"
       else
-        labels_arr << "#{index}:|#{labels}"
+        "#{index}:|#{labels}"
       end
     end
     "chxl=#{labels_arr.join('|')}"
   end
-  
+
   # http://code.google.com/apis/chart/labels.html#axis_range
   # Specify a range for axis labels
   def set_axis_range
     # a passed axis_range should look like:
     # [[10,100]] or [[10,100,4]] or [[10,100], [20,300]]
     # in the second example, 4 is the interval 
-    dataset # just making sure we processed the data before
-    if axis_range && axis_range.respond_to?(:each) && axis_range.first.respond_to?(:each)
-     'chxr=' + axis_range.enum_for(:each_with_index).map{|range, index| [index, range[0], range[1], range[2]].compact.join(',')}.join("|")
+    if datasets && datasets.respond_to?(:each) && datasets.first.respond_to?(:each)
+      'chxr=' + datasets.enum_for(:each_with_index).map{|range, index| [index, (min_value || range[0]), range[1], (max_value || range[2])].compact.uniq.join(',')}.join("|")
     else
       nil
     end
   end
-  
+
   def set_geographical_area
-    "chtm=#{@geographical_area}"
+    "chtm=#{geographical_area}"
   end
-  
+
   def set_type
-    case @type
-      when :line
-        "cht=lc"
-      when :line_xy
-        "cht=lxy"
-      when :bar
-        "cht=b" + (horizontal? ? "h" : "v") + (grouped? ? "g" : "s")
-      when :pie_3d
-        "cht=p3"
-      when :pie
-        "cht=p"
-      when :venn
-        "cht=v"
-      when :scatter
-        "cht=s"
-      when :sparkline
-        "cht=ls"
-      when :meter
-        "cht=gom"
-      when :map
-        "cht=t"
-      end
+    case type.to_s
+    when 'line'
+      "cht=lc"
+    when 'line_xy'
+      "cht=lxy"
+    when 'bar'
+      "cht=b" + (horizontal? ? "h" : "v") + (grouped? ? "g" : "s")
+    when 'pie_3d'
+      "cht=p3"
+    when 'pie'
+      "cht=p"
+    when 'venn'
+      "cht=v"
+    when 'scatter'
+      "cht=s"
+    when 'sparkline'
+      "cht=ls"
+    when 'meter'
+      "cht=gom"
+    when 'map'
+      "cht=t"
+    end
   end
-  
+
   def fill_type(type)
     case type
     when 'solid'
@@ -369,36 +482,99 @@ class Gchart
     end
   end
   
-  # Wraps a single dataset inside another array to support more datasets
-  def prepare_dataset(ds)
-    ds = [ds] unless ds.first.is_a?(Array)
+  def number_visible
+    n = 0
+    dataset.each do |mds|
+      return n.to_s if mds[:invisible] == true
+      if mds[:data].first.is_a?(Array)
+        n += mds[:data].length
+      else
+        n += 1
+      end
+    end
+    ""
+  end
+  
+  # Turns input into an array of axis hashes, dependent on the chart type
+  def convert_dataset(ds)
+    if dimensions == 2
+      # valid inputs include:
+      # an array of >=2 arrays, or an array of >=2 hashes
+      ds = ds.map do |d|
+        d.is_a?(Hash) ? d : {:data => d}
+      end
+    elsif dimensions == 1
+      # valid inputs include:
+      # a hash, an array of data, an array of >=1 array, or an array of >=1 hash
+      if ds.is_a?(Hash)
+        ds = [ds]
+      elsif not ds.first.is_a?(Hash)
+        ds = [{:data => ds}]
+      end
+    end
     ds
   end
   
+  # just an alias
+  def axis_set
+    dataset
+  end
+
   def convert_to_simple_value(number)
     if number.nil?
       "_"
     else
-      value = @@simple_chars[number.to_i]
+      value = Gchart.simple_chars[number.to_i]
       value.nil? ? "_" : value
     end
   end
   
+  def convert_to_extended_value(number)
+    if number.nil?
+      '__'
+    else
+      value = Gchart.ext_pairs[number.to_i]
+      value.nil? ? "__" : value
+    end
+  end
+  
+  def encode_scaled_dataset(chars, nil_char)
+    dsets = []
+    dataset.each do |ds|
+      if max_value != false
+        range = ds[:max_value] - ds[:min_value]
+        range = 1 if range == 0
+      end
+      unless ds[:data].first.is_a?(Array)
+        ldatasets = [ds[:data]]
+      else
+        ldatasets = ds[:data]
+      end
+      ldatasets.each do |l|
+        dsets << l.map do |number|
+          if number.nil?
+            nil_char
+          else
+            unless range.nil? || range.zero?
+              number = chars.size * (number - ds[:min_value]) / range.to_f
+              number = [number, chars.size - 1].min
+            end
+            chars[number.to_i]
+          end
+        end.join
+      end
+    end
+    dsets.join(',')
+  end
+
   # http://code.google.com/apis/chart/#simple
   # Simple encoding has a resolution of 62 different values. 
   # Allowing five pixels per data point, this is sufficient for line and bar charts up
   # to about 300 pixels. Simple encoding is suitable for all other types of chart regardless of size.
   def simple_encoding
-    @max_value = dataset.compact.map{|ds| ds.compact.max}.max if @max_value == 'auto'
-    
-    if @max_value == false || @max_value == 'false' || @max_value == :false || @max_value == 0
-      "s:" + dataset.map { |ds| ds.map { |number| number.nil? ? '_' : convert_to_simple_value(number) }.join }.join(',')
-    else
-      "s:" + dataset.map { |ds| ds.map { |number| number.nil? ? '_' : convert_to_simple_value( (@@simple_chars.size - 1) * number / @max_value) }.join }.join(',')
-    end
-    
+    "s" + number_visible + ":" + encode_scaled_dataset(Gchart.simple_chars, '_')
   end
-  
+
   # http://code.google.com/apis/chart/#text
   # Text encoding with data scaling lets you specify arbitrary positive or
   # negative floating point numbers, in combination with a scaling parameter
@@ -412,61 +588,41 @@ class Gchart
   # This encoding is not available for maps.
   #
   def text_encoding
-    "t:" + dataset.map{ |ds| ds.join(',') }.join('|') + "&chds=#{@min},#{@max}"
-  end
-  
-  def convert_to_extended_value(number)
-    if number.nil?
-      '__'
-    else
-      value = @@ext_pairs[number.to_i]
-      value.nil? ? "__" : value
-    end
+    chds = dataset.map{|ds| "#{ds[:min_value]},#{ds[:max_value]}" }.join(",")
+    "t" + number_visible + ":" + datasets.map{ |ds| ds.join(',') }.join('|') + "&chds=" + chds
   end
 
-  
   # http://code.google.com/apis/chart/#extended
   # Extended encoding has a resolution of 4,096 different values 
   # and is best used for large charts where a large data range is required.
   def extended_encoding
-    @max_value = dataset.compact.map{|ds| ds.compact.max}.max if @max_value == 'auto'
-    
-    if @max_value == false || @max_value == 'false' || @max_value == :false || @max_value == 0
-      "e:" +  dataset.map { |ds| ds.map { |number| number.nil? ? '__' : convert_to_extended_value(number)}.join }.join(',')
-    else
-      "e:" + dataset.map { |ds| ds.map { |number| number.nil? ? '__' : convert_to_extended_value( (@@ext_pairs.size - 1) * number / @max_value) }.join }.join(',')
-    end
-    
+    "e" + number_visible + ":" + encode_scaled_dataset(Gchart.ext_pairs, '__')
   end
-  
-  
+
   def query_builder(options="")
-    dataset 
     query_params = instance_variables.sort.map do |var|
-      case var
+      case var.to_s
       when '@data'
-        set_data unless @data == []  
-      # Set the graph size  
+        set_data unless data == []  
+        # Set the graph size  
       when '@width'
-        set_size unless @width.nil? || @height.nil?
+        set_size unless width.nil? || height.nil?
       when '@type'
         set_type
       when '@title'
-        set_title unless @title.nil?
+        set_title unless title.nil?
       when '@legend'
-        set_legend unless @legend.nil?
+        set_legend unless legend.nil?
       when '@bg_color'
         set_colors
       when '@chart_color'
-        set_colors if @bg_color.nil?
+        set_colors if bg_color.nil?
       when '@bar_colors'
         set_bar_colors
       when '@bar_width_and_spacing'
         set_bar_width_and_spacing
       when '@axis_with_labels'
         set_axis_with_labels
-      when '@axis_range'
-        set_axis_range if dataset
       when '@axis_labels'
         set_axis_labels
       when '@range_markers'
@@ -476,19 +632,21 @@ class Gchart
       when '@country_codes'
         set_country_codes
       when '@custom'
-        @custom
+        custom
       end
     end.compact
-    
+
+    query_params << set_axis_range
+
     # Use ampersand as default delimiter
     unless options == :html
       delimiter = '&'
-    # Escape ampersand for html image tags
+      # Escape ampersand for html image tags
     else
       delimiter = '&amp;'
     end
-    
-    jstize(@@url + query_params.join(delimiter))
+
+    jstize(Gchart.url + query_params.join(delimiter))
   end
-  
+
 end

data/lib/gchart/version.rb

@@ -1,7 +1,7 @@
 module GchartInfo #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 1
-    MINOR = 4
+    MINOR = 5
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')

data/lib/googlecharts.rb

@@ -0,0 +1,2 @@
+require 'gchart'
+Googlecharts = Gchart unless Object.const_defined? 'Googlechart'

data/spec/gchart_spec.rb

@@ -16,7 +16,7 @@ describe "generating a default Gchart" do
   end
 
   it "should have a default size" do
-    @chart.include?('chs=300x200').should be_true
+    @chart.should include('chs=300x200')
   end
 
   it "should be able to have a custom size" do
@@ -25,7 +25,7 @@ describe "generating a default Gchart" do
   end
 
   it "should have query parameters in predictable order" do
-    Gchart.line(:axis_with_labels => 'x,y,r', :size => '400x600').should match(/chxr=.+chxt=.+cht=.+chs=/)
+    Gchart.line(:axis_with_labels => 'x,y,r', :size => '400x600').should match(/chxt=.+cht=.+chs=/)
   end
 
   it "should have a type" do
@@ -33,19 +33,23 @@ describe "generating a default Gchart" do
   end
 
   it 'should use theme defaults if theme is set' do
-    Gchart.line(:theme=>:test).include?('chco=6886B4,FDD84E').should be_true
-    Gchart.line(:theme=>:test).include?(Gchart.jstize('chf=c,s,FFFFFF|bg,s,FFFFFF')).should be_true
+    Gchart.line(:theme=>:test).should include('chco=6886B4,FDD84E')
+    if RUBY_VERSION.to_f < 1.9
+      Gchart.line(:theme=>:test).should include(Gchart.jstize('chf=c,s,FFFFFF|bg,s,FFFFFF')) 
+    else
+       Gchart.line(:theme=>:test).should include(Gchart.jstize('chf=bg,s,FFFFFF|c,s,FFFFFF'))
+    end
   end
 
   it "should use the simple encoding by default with auto max value" do
     # 9 is the max value in simple encoding, 26 being our max value the 2nd encoded value should be 9
-    Gchart.line(:data => [0, 26]).include?('chd=s:A9').should be_true
+    Gchart.line(:data => [0, 26]).should include('chd=s:A9')
     Gchart.line(:data => [0, 26], :max_value => 26).should == Gchart.line(:data => [0, 26])
   end
 
   it "should support simple encoding with and without max_value" do
-    Gchart.line(:data => [0, 26], :max_value => 26).include?('chd=s:A9').should be_true
-    Gchart.line(:data => [0, 26], :max_value => false).include?('chd=s:Aa').should be_true
+    Gchart.line(:data => [0, 26], :max_value => 26).should include('chd=s:A9')
+    Gchart.line(:data => [0, 26], :max_value => false).should include('chd=s:Aa')
   end
 
   it "should support the extended encoding and encode properly" do
@@ -57,21 +61,21 @@ describe "generating a default Gchart" do
   end
 
   it "should auto set the max value for extended encoding" do
-    Gchart.line(:data => [0, 25], :encoding => 'extended', :max_value => false).include?('chd=e:AAAZ').should be_true
+    Gchart.line(:data => [0, 25], :encoding => 'extended', :max_value => false).should include('chd=e:AAAZ')
     # Extended encoding max value is '..'
     Gchart.line(:data => [0, 25], :encoding => 'extended').include?('chd=e:AA..').should be_true
   end
 
   it "should be able to have data with text encoding" do
-    Gchart.line(:data => [10, 5.2, 4, 45, 78], :encoding => 'text').include?('chd=t:10,5.2,4,45,78').should be_true
+    Gchart.line(:data => [10, 5.2, 4, 45, 78], :encoding => 'text').should include('chd=t:10,5.2,4,45,78')
   end
 
   it "should handle max and min values with text encoding" do
-    Gchart.line(:data => [10, 5.2, 4, 45, 78], :encoding => 'text').include?('chds=0,78').should be_true
+    Gchart.line(:data => [10, 5.2, 4, 45, 78], :encoding => 'text').should include('chds=0,78')
   end
 
   it "should automatically handle negative values with proper max/min limits when using text encoding" do
-    Gchart.line(:data => [-10, 5.2, 4, 45, 78], :encoding => 'text').include?('chds=-10,78').should be_true
+    Gchart.line(:data => [-10, 5.2, 4, 45, 78], :encoding => 'text').should include('chds=-10,78')
   end
 
   it "should handle negative values with manual max/min limits when using text encoding" do
@@ -159,7 +163,8 @@ describe "generating different type of charts" do
   end
 
   it "should not support other types" do
-    Gchart.sexy.should == "sexy is not a supported chart format, please use one of the following: #{Gchart.supported_types}."
+    lambda{Gchart.sexy}.should raise_error
+    # msg => "sexy is not a supported chart format, please use one of the following: #{Gchart.supported_types}."
   end
 
 end
@@ -319,18 +324,18 @@ describe "a line chart" do
   end
 
   it "should be able to set the background fill" do
-    Gchart.line(:bg => 'efefef').include?("chf=bg,s,efefef").should be_true
-    Gchart.line(:bg => {:color => 'efefef', :type => 'solid'}).include?("chf=bg,s,efefef").should be_true
+    Gchart.line(:bg => 'efefef').should include("chf=bg,s,efefef")
+    Gchart.line(:bg => {:color => 'efefef', :type => 'solid'}).should include("chf=bg,s,efefef")
 
-    Gchart.line(:bg => {:color => 'efefef', :type => 'gradient'}).include?("chf=bg,lg,0,efefef,0,ffffff,1").should be_true
-    Gchart.line(:bg => {:color => 'efefef,0,ffffff,1', :type => 'gradient'}).include?("chf=bg,lg,0,efefef,0,ffffff,1").should be_true
-    Gchart.line(:bg => {:color => 'efefef', :type => 'gradient', :angle => 90}).include?("chf=bg,lg,90,efefef,0,ffffff,1").should be_true
+    Gchart.line(:bg => {:color => 'efefef', :type => 'gradient'}).should include("chf=bg,lg,0,efefef,0,ffffff,1")
+    Gchart.line(:bg => {:color => 'efefef,0,ffffff,1', :type => 'gradient'}).should include("chf=bg,lg,0,efefef,0,ffffff,1")
+    Gchart.line(:bg => {:color => 'efefef', :type => 'gradient', :angle => 90}).should include("chf=bg,lg,90,efefef,0,ffffff,1")
 
-    Gchart.line(:bg => {:color => 'efefef', :type => 'stripes'}).include?("chf=bg,ls,90,efefef,0.2,ffffff,0.2").should be_true
+    Gchart.line(:bg => {:color => 'efefef', :type => 'stripes'}).should include("chf=bg,ls,90,efefef,0.2,ffffff,0.2")
   end
 
   it "should be able to set a graph fill" do
-    Gchart.line(:graph_bg => 'efefef').include?("chf=c,s,efefef").should be_true
+    Gchart.line(:graph_bg => 'efefef').should include("chf=c,s,efefef")
     Gchart.line(:graph_bg => {:color => 'efefef', :type => 'solid'}).include?("chf=c,s,efefef").should be_true
     Gchart.line(:graph_bg => {:color => 'efefef', :type => 'gradient'}).include?("chf=c,lg,0,efefef,0,ffffff,1").should be_true
     Gchart.line(:graph_bg => {:color => 'efefef,0,ffffff,1', :type => 'gradient'}).include?("chf=c,lg,0,efefef,0,ffffff,1").should be_true
@@ -340,7 +345,11 @@ describe "a line chart" do
   it "should be able to set both a graph and a background fill" do
     Gchart.line(:bg => 'efefef', :graph_bg => '76A4FB').include?("bg,s,efefef").should be_true
     Gchart.line(:bg => 'efefef', :graph_bg => '76A4FB').include?("c,s,76A4FB").should be_true
-    Gchart.line(:bg => 'efefef', :graph_bg => '76A4FB').include?(Gchart.jstize("chf=c,s,76A4FB|bg,s,efefef")).should be_true
+    if RUBY_VERSION.to_f < 1.9
+      Gchart.line(:bg => 'efefef', :graph_bg => '76A4FB').include?(Gchart.jstize("chf=c,s,76A4FB|bg,s,efefef")).should be_true      
+    else
+      Gchart.line(:bg => 'efefef', :graph_bg => '76A4FB').include?(Gchart.jstize("chf=bg,s,efefef|c,s,76A4FB")).should be_true
+    end
   end
 
   it "should be able to have different line colors" do
@@ -349,7 +358,7 @@ describe "a line chart" do
   end
 
   it "should be able to render a graph where all the data values are 0" do
-    Gchart.line(:data => [0, 0, 0]).include?("chd=s:AAA").should be_true
+    Gchart.line(:data => [0, 0, 0]).should include("chd=s:AAA")
   end
 
 end
@@ -408,7 +417,11 @@ describe "a sparkline chart" do
   it "should be able to set both a graph and a background fill" do
     Gchart.sparkline(:bg => 'efefef', :graph_bg => '76A4FB').include?("bg,s,efefef").should be_true
     Gchart.sparkline(:bg => 'efefef', :graph_bg => '76A4FB').include?("c,s,76A4FB").should be_true
-    Gchart.sparkline(:bg => 'efefef', :graph_bg => '76A4FB').include?(Gchart.jstize("chf=c,s,76A4FB|bg,s,efefef")).should be_true
+    if RUBY_VERSION.to_f < 1.9
+      Gchart.sparkline(:bg => 'efefef', :graph_bg => '76A4FB').include?(Gchart.jstize("chf=c,s,76A4FB|bg,s,efefef")).should be_true
+    else
+      Gchart.sparkline(:bg => 'efefef', :graph_bg => '76A4FB').include?(Gchart.jstize("chf=bg,s,efefef|c,s,76A4FB")).should be_true
+    end
   end
 
   it "should be able to have different line colors" do
@@ -437,8 +450,8 @@ describe "a 3d pie chart" do
   end
 
   it "should be able to set labels by using the legend or labesl accessor" do
-    Gchart.pie_3d(:title => @title, :legend => @legend, :data => @data).include?("chl=#{@jstized_legend}").should be_true
-    Gchart.pie_3d(:title => @title, :labels => @legend, :data => @data).include?("chl=#{@jstized_legend}").should be_true
+    Gchart.pie_3d(:title => @title, :legend => @legend, :data => @data).should include("chl=#{@jstized_legend}")
+    Gchart.pie_3d(:title => @title, :labels => @legend, :data => @data).should include("chl=#{@jstized_legend}")
     Gchart.pie_3d(:title => @title, :labels => @legend, :data => @data).should == Gchart.pie_3d(:title => @title, :legend => @legend, :data => @data)
   end
 
@@ -559,7 +572,7 @@ describe 'exporting a chart' do
     File.delete('foo.png') if File.exist?('foo.png')
     Gchart.line(:size => '400x200',
                 :data => [1,2,3,4,5],
-                :axis_labels => [[1,2,3,4, 5], %w[foo bar]],
+                # :axis_labels => [[1,2,3,4, 5], %w[foo bar]],
                 :axis_with_labels => 'x,r',
                 :format => "file",
                 :filename => "foo.png"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: googlecharts
 version: !ruby/object:Gem::Version 
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors: 
 - Matt Aimonetti
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-30 00:00:00 -07:00
+date: 2010-01-22 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -39,6 +39,7 @@ files:
 - lib/gchart/aliases.rb
 - lib/gchart/theme.rb
 - lib/gchart/version.rb
+- lib/googlecharts.rb
 - lib/themes.yml
 - script/destroy
 - script/generate
@@ -47,7 +48,6 @@ files:
 - spec/fixtures/another_test_theme.yml
 - spec/fixtures/test_theme.yml
 - spec/gchart_spec.rb
-- spec/spec.opts
 - spec/spec_helper.rb
 - spec/theme_spec.rb
 - tasks/deployment.rake

data/spec/spec.opts

@@ -1,4 +0,0 @@
-spec/
-spec/gchart_spec.rb
-spec/
-spec/