googleajax 0.2.0 → 1.0.0

data/History.txt

@@ -1,3 +1,14 @@
+=== 1.0.0 / 2009-12-17
+
+* Incompatible changes:
+  * Returns Hashes instead of OpenStruct by default (require googleajax/as_open_struct if you need OpenStruct)
+  * Indices are symbols with underscores instead of camelcased string, (e.g. :estimated_count instead of "estimatedCount")
+  * Values are converted automatically for Floats, Integers and true and false.
+
+* translate accepts :english, :french, etc... as source or destination languages in addition to the language codes
+
+* Much more flexible structure.
+
 === 0.2.0 / 2009-11-17
 
 * New features:

data/README.txt

@@ -1,7 +1,7 @@
 = GoogleAjax
 
 * Docs: http://googleajax.rubyforge.org
-* Code: http://github.com/monki/google_ajax/tree/master
+* Code: http://github.com/geemus/googleajax
 
 == DESCRIPTION:
 
@@ -9,6 +9,8 @@ Ruby wrapper for Google AJAX API REST interfaces(Feeds, Language and Search).
 
 == SYNOPSIS:
 
+  require "googleajax"
+
   # First, setup referer: 
   GoogleAjax.referer = [your domain name here]
 
@@ -53,6 +55,37 @@ Ruby wrapper for Google AJAX API REST interfaces(Feeds, Language and Search).
   # Find top 4 web page results for 'Hello world'
   GoogleAjax::Search.web('Hello world')
 
+  # Find top 10 feeds for 'ruby'
+  GoogleAjax::Feed.find('ruby')
+
+
+
+=== Results
+
+Results from the methods are hashes, automatically converted from the response from Google.
+
+For example:
+
+  # Find top 4 web page results for 'Hello world'
+  GoogleAjax::Search.web('Hello world')
+  # => { :results=>[
+  #       { :title=>"<b>Hello world</b> program - Wikipedia, the free encyclopedia",
+  #         # ... more data ...
+  #         :url=>"http://en.wikipedia.org/wiki/Hello_world_program"
+  #       },
+  #       # ... more results
+  #     ],
+  #     :cursor=>{
+  #       :current_page_index=>0,
+  #       # ... more data ...
+  #       :estimated_result_count=>57800000
+  #     }
+  #   }
+
+When possible, the result is simplified:
+* Feed.find will return an array instead of {:entries => array}
+* Feed.load will return the feed instead of {:feed => feed}
+
 == REQUIREMENTS:
 
 * JSON gem to parse responses, or rails
@@ -66,6 +99,7 @@ Ruby wrapper for Google AJAX API REST interfaces(Feeds, Language and Search).
 (The MIT License)
 
 Copyright (c) 2009 {geemus (Wesley Beary)}[http://github.com/geemus]
+and {Marc-Andre Lafortune}[http://github.com/marcandre]
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/VERSION

@@ -1 +1 @@
-0.2.0
+1.0.0

data/lib/googleajax/api.rb

@@ -0,0 +1,57 @@
+module GoogleAjax
+  # The API module provides generic methods to call the Google API
+  # These are specialized in the different APIs (Language, Search & Feed)
+  module API
+
+    # All APIs have a default version of 1.0 (override otherwise)
+    def version
+      1.0
+    end
+
+    # All APIs have, by default version a kind corresponding to their name (e.g. "language")
+    def kind
+      @kind ||= name.demodulize.downcase.to_sym
+    end
+
+    # Sends the request to google and converts it to Ruby
+    # A block can be passed to alter the received hash
+    def get(method, query, args = {})
+      args = { :v => version }.merge(args)
+      response = GoogleAjax::get(kind, method, query, args)
+      data = extract_data(
+        parse(response)
+      )
+      data = yield data if block_given?
+      # Convert hashes to an instance of ourself from this data:
+      Filters::Recursive.remap(data, self)
+    end
+
+    def parse(data)
+      if defined? Rails
+        ActiveSupport::JSON::decode(data)
+      else
+        JSON.parse(data)
+      end
+    end
+
+    # verifies the responses' status and either raises an error
+    # or else returns the response data.
+    def extract_data(hash)
+      status = hash['responseStatus']
+      unless (200..206).include? status
+        raise StandardError, hash['responseDetails'] || "Wrong status code (#{status.inspect})"
+      end
+      hash['responseData']
+    end
+
+    # Since most api have the same form, this helper can create these calls easily.
+    # If a block is given, it will be passed to #get
+    def standard_api(*methods, &block)
+      methods.each do |method|
+        define_singleton_method(method) do |*args|
+          get(method, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/googleajax/as_hash.rb

@@ -1,15 +1,2 @@
-# Include this file instead of googleajax so that results are simply hashes
-
-module GoogleAjax
-  class Base < Hash
-    def initialize(h)
-      super()
-      replace(h)
-    end
-
-    def self.remap(h)
-    end
-  end
-end
-
-require 'googleajax'
+warn "requiring 'googleajax/as_hash' is deprecated. Require 'googleajax' instead"
+require 'googleajax'

data/lib/googleajax/as_open_struct.rb

@@ -0,0 +1,20 @@
+# If you prefer getting back OpenStructs instead of Hashes,
+# then require 'googleajax/as_open_struct' *instead* of 'googleajax'
+
+# These OpenStruct will also have the [] and []= operators defined
+require 'ostruct'
+require 'googleajax/filters'
+module GoogleAjax
+  class Base < ::OpenStruct
+    include Filters::Default
+
+    def [](key)
+      send(key)
+    end
+
+    def []=(key, value)
+      send("#{key}=", value)
+    end
+  end
+end
+require 'googleajax'

data/lib/googleajax/base.rb

@@ -1,25 +1,6 @@
 module GoogleAjax
-  class Base < OpenStruct
-    def [](key)
-      send(key)
-    end
-
-    def []=(key, value)
-      send("#{key}=", value)
-    end
-
-    def self.remap(h)
-      define_method(:initialize) do |arg|
-        super(arg)
-        h.each do |key, klass|
-          case self[key]
-          when Array
-            self[key] = self[key].map(&klass.method(:new))
-          when Hash
-            self[key] = klass.new(self[key])
-          end
-        end
-      end
-    end
+  # See Results
+  class Base < Hash
+    include Filters::Default
   end
-end
+end

data/lib/googleajax/basic.rb

@@ -0,0 +1,9 @@
+# If you prefer getting unfiltered Hashes,
+# then require 'googleajax/basic' *instead* of 'googleajax'
+# (not recommended)
+require 'googleajax/hash'
+module GoogleAjax
+  class Base < Hash
+  end
+end
+require 'googleajax'

data/lib/googleajax/extensions/hash.rb

@@ -0,0 +1,21 @@
+class Hash
+  # From the 'backports' gem
+  # New Ruby 1.8.7+ constructor -- not documented, see redmine # 1385
+  # <tt>Hash[[[:foo, :bar],[:hello, "world"]]] ==> {:foo => :bar, :hello => "world"}</tt>
+  unless (Hash[[[:test, :test]]] rescue false)
+    class << self
+      alias_method :constructor_without_key_value_pair_form, :[]
+      def [](*args)
+        return constructor_without_key_value_pair_form(*args) unless args.length == 1 && args.first.is_a?(Array)
+        h = {}
+        args.first.each do |arr|
+          next unless arr.respond_to? :to_ary
+          arr = arr.to_ary
+          next unless (1..2).include? arr.size
+          h[arr.at(0)] = arr.at(1)
+        end
+        h
+      end
+    end
+  end
+end

data/lib/googleajax/extensions/kernel.rb

@@ -0,0 +1,9 @@
+module Kernel
+  # From the backports gem
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Object.html]
+  def define_singleton_method(*args, &block)
+    class << self
+      self
+    end.send(:define_method, *args, &block)
+  end unless method_defined? :define_singleton_method
+end

data/lib/googleajax/extensions/string.rb

@@ -0,0 +1,15 @@
+class String
+  # Standard in rails. See official documentation[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/String/Inflections.html]
+  def underscore
+    gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end unless method_defined? :underscore
+
+  # Standard in rails. See official documentation[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/String/Inflections.html]
+  def demodulize
+    gsub(/^.*::/, '')
+  end unless method_defined? :demodulize
+end

data/lib/googleajax/feed.rb

@@ -1,35 +1,24 @@
 module GoogleAjax
-  module Feed
-    FEED_VERSION = 1.0
-    # Arguments: http://code.google.com/apis/ajaxfeeds/documentation/reference.html#_intro_fonje
-    def self.get(method, query, args)
-      args = { :v => FEED_VERSION }.merge(args)
-      GoogleAjax::get(:feed, method, query, args)
-    end
-
+  class Feed < Results
+    ##
+    # :call-seq:
+    #   find(query, args = {})
     # will return a list of feeds that match the given query
     # Arguments: http://code.google.com/apis/ajaxfeeds/documentation/reference.html#_fonje_find
-    def self.find(query, args = {})
-      self.get(:find, query, args)
-    end
+    standard_api(:find){|h| h['entries']}
 
+    ##
+    # :call-seq:
+    #   load(url, args = {})
     # downloads this feed from Google's servers
     # Arguments: http://code.google.com/apis/ajaxfeeds/documentation/reference.html#_fonje_load
-    def self.load(url, args = {})
-      self.get(:load, url, args)
-    end
+    standard_api(:load){|h| h['feed']}
 
+    ##
+    # :call-seq:
+    #   lookup(url, args = {})
     # will return the associated feed if it exists for a given url    
     # Arguments: http://code.google.com/apis/ajaxfeeds/documentation/reference.html#_intro_fonje
-    def self.lookup(url, args = {})
-      self.get(:lookup, url, args)
-    end    
-
-    class Entry < Base
-    end    
-
-    class Feed < Base
-      remap :entries => Entry
-    end
+    standard_api :lookup
   end
 end

data/lib/googleajax/filters.rb

@@ -0,0 +1,70 @@
+module GoogleAjax
+  # The Result classes are initialized with a hash.
+  # Filters can be included to modify this hash.
+  module Filters
+
+    # The Recursive filter converts all Hash values to GoogleAjax::Base (recursively)
+    # This will also make any other filters included in GoogleAjax::Base be called
+    module Recursive
+      
+      # A utility method to inspect value and convert Hash to base_klass, even when inside arrays
+      def self.remap(value, base_klass = Base)
+        case value
+        when ::Hash
+          base_klass.new(value)
+        when Array
+          value.map{|e| remap(e)}
+        else
+          value
+        end
+      end
+
+      def initialize(h)
+        h.each{|key, value| h[key] = Recursive.remap(value)}
+        super(h)
+      end
+    end
+
+    # The SymbolizeKeys filter converts the Javascript style keys ("someKey")
+    # to ruby-style keys (:some_key)
+    module SymbolizeKeys
+      def initialize(h)
+        h= ::Hash[
+          h.map do |key, value|
+            [key.underscore.to_sym, value]
+          end
+        ]
+        super(h)
+      end
+    end
+
+    # The ConvertValues filter converts the string values
+    # to ruby-style values (e.g. Integers, Floats, true, false or Strings)
+    module ConvertValues
+      TRUE_OR_FALSE = /^true|(false)$/i
+      INTEGER = /^\d+$/
+      FLOAT = /^\d+\.\d+$/
+      def initialize(h)
+        h.each do |key, value|
+          # Won't use Integer.try_convert for 1.8.6 & 7 compatibility
+          case value
+          when INTEGER
+            h[key] = value.to_i
+          when FLOAT
+            h[key] = value.to_f
+          when TRUE_OR_FALSE
+            h[key] = Regexp.last_match[1].nil?
+          end
+        end
+        super(h)
+      end
+    end
+
+    # By default, all filters are applied
+    module Default
+      include ConvertValues
+      include SymbolizeKeys
+      include Recursive
+    end
+  end
+end

data/lib/googleajax/hash.rb

@@ -0,0 +1,10 @@
+module GoogleAjax
+  # Out very own Hash class, with the only difference being the constructor
+  # which takes a hash for its initial values
+  class Hash < ::Hash
+    def initialize(h)
+      replace(h)
+      super()
+    end
+  end
+end

data/lib/googleajax/language.rb

@@ -1,75 +1,79 @@
 module GoogleAjax
-  module Language
-    LANGUAGE_VERSION = 1.0
-    def self.get(method, query, args)
-      args = { :v => LANGUAGE_VERSION }.merge(args)
-      GoogleAjax::get(:language, method, query, args)
+  class Language < Results
+    def name
+      LANGUAGE_NAME[self[:language]].to_s
     end
-    
+
+    ##
+    # :call-seq:
+    #   detect(query, args = {})
     # will return the language code that describes the language of the given text
-    def self.detect(query, args = {})
-      self.get(:detect, query, args)
-    end
+    standard_api :detect
     
-    # will return translated text for the given text supplied, matching the destination language.
+    # Translates the supplied text, matching the destination language.
+    # source and destination can be the language code ("en") or a symbol (:english).
+    # source can also be an empty string, in which case Google does an auto-detection and
+    # will set :detected_source_language to the language it used as a source.
     def self.translate(query, source, destination, args = {})
-      args = { :langpair => "#{source}%7C#{destination}"}.merge(args)
-      self.get(:translate, query, args)
-    end
-    
-    class Language < Base
-      def name
-        (@@lang_cache ||= LANGUAGES.invert)[self.language]
-      end
-    end
-    
-    class Translation < Base
+      langpair = [source, destination].map{|l| LANGUAGE_CODE[l] || l.to_s}.join("%7C")
+      args = { :langpair => langpair }.merge(args)
+      get(:translate, query, args)
     end
     
-    LANGUAGES =
+    LANGUAGE_CODE =
     {
-      'ARABIC' => 'ar',
-      'BULGARIAN' => 'bg',
-      'CATALAN' => 'ca',
-      'CHINESE' => 'zh',
-      'CHINESE_SIMPLIFIED' => 'zh-CN',
-      'CHINESE_TRADITIONAL' => 'zh-TW',
-      'CROATIAN' => 'hr',
-      'CZECH' => 'cs',
-      'DANISH' => 'da',
-      'DUTCH'=> 'nl',
-      'ENGLISH' => 'en',
-      'ESTONIAN' => 'et',
-      'FILIPINO' => 'tl',
-      'FINISH' => 'fi',
-      'FRENCH' => 'fr',
-      'GERMAN' => 'de',
-      'GREK' => 'el',
-      'HEBREW' => 'iw',
-      'HINDI' => 'hi',
-      'HUNGARIAN' => 'hu',
-      'INDONESIAN' => 'id',
-      'ITALIAN' => 'it',
-      'JAPANESE' => 'ja',
-      'KOREAN' => 'ko',
-      'LATVIAN' => 'lv',
-      'LITHUANIAN' => 'lt',
-      'NORWEGIAN' => 'no',
-      'PERSIAN' => 'fa',
-      'POLISH' => 'pl',
-      'PORTUGUESE' => 'pt-PT',
-      'ROMANIAN' => 'ro',
-      'RUSIAN' => 'ru',
-      'SERBIAN' => 'sr',
-      'SLOVAK' => 'sk',
-      'SLOVENIAN' => 'sl',
-      'SPANISH' => 'es',
-      'SWEDISH' => 'sv',
-      'THAI' => 'th',
-      'TURKISH' => 'tr',
-      'UKRAINIAN' => 'uk',
-      'VIETNAMESE' => 'vi',
-      'UNKNOWN' => ''
+      :afrikaans   => "af",
+      :albanian    => "sq",
+      :arabic      => "ar",
+      :belarusian  => "be",
+      :bulgarian   => "bg",
+      :catalan     => "ca",
+      :chinese     => "zh-CN",
+      :croatian    => "hr",
+      :czech       => "cs",
+      :danish      => "da",
+      :dutch       => "nl",
+      :english     => "en",
+      :estonian    => "et",
+      :filipino    => "tl",
+      :finnish     => "fi",
+      :french      => "fr",
+      :galician    => "gl",
+      :german      => "de",
+      :greek       => "el",
+      :hebrew      => "iw",
+      :hindi       => "hi",
+      :hungarian   => "hu",
+      :icelandic   => "is",
+      :indonesian  => "id",
+      :irish       => "ga",
+      :italian     => "it",
+      :japanese    => "ja",
+      :korean      => "ko",
+      :latvian     => "lv",
+      :lithuanian  => "lt",
+      :macedonian  => "mk",
+      :malay       => "ms",
+      :maltese     => "mt",
+      :norwegian   => "no",
+      :persian     => "fa",
+      :polish      => "pl",
+      :portuguese  => "pt",
+      :romanian    => "ro",
+      :russian     => "ru",
+      :serbian     => "sr",
+      :slovak      => "sk",
+      :slovenian   => "sl",
+      :spanish     => "es",
+      :swahili     => "sw",
+      :swedish     => "sv",
+      :thai        => "th",
+      :turkish     => "tr",
+      :ukrainian   => "uk",
+      :vietnamese  => "vi",
+      :welsh       => "cy",
+      :yiddish     => "yi"
     }
+    LANGUAGE_NAME = LANGUAGE_CODE.invert
   end
 end

data/lib/googleajax/request.rb

@@ -0,0 +1,21 @@
+module GoogleAjax
+  module Request
+    API_BASE = 'http://ajax.googleapis.com/ajax/services/'
+
+    attr_accessor :api_key
+    attr_accessor :referer
+    alias_method :referrer, :referer  # See mispelling section in http://en.wikipedia.org/wiki/HTTP_referrer
+    alias_method :referrer=, :referer=
+
+    # Api doc is at http://code.google.com/apis/ajaxsearch/documentation/reference.html#_intro_fonje
+    def get(api, method, query, args = nil)
+      raise "You must assign a value to GoogleAjax.referer" unless referer
+      url  = "#{API_BASE}#{api}/"
+      url += "#{method}?"
+      url += "&q=#{CGI::escape(query)}"
+      url += "&key=#{api_key}" if api_key
+      url += "&" + args.collect {|key, value| "#{key}=#{value}"}.join('&') unless args.nil? || args.empty?
+      open(url, "Referer" => referer).read
+    end
+  end
+end

data/lib/googleajax/results.rb

@@ -0,0 +1,14 @@
+module GoogleAjax
+  # The Results class is the superclass for the results of API calls and acts as a Hash.
+  # Instance methods can be added to add functionalities (e.g. Search#count)
+  # Class methods are the actual api calls.
+  #
+  # For example the Search api inherits from Results.
+  # GoogleAjax::Search.web will return an instance of GoogleAjax::Search
+  # Some of the values within this GoogleAjax::Search instance will also
+  # act as hashes. They will be instances of GoogleAjax::Base and so will
+  # be their values that act as hashes.
+  class Results < Base
+    extend API
+  end
+end

data/lib/googleajax/search.rb

@@ -1,66 +1,50 @@
 module GoogleAjax
-  module Search
-    SEARCH_VERSION = 1.0
-    # Arguments: http://code.google.com/apis/ajaxsearch/documentation/reference.html#_fonje_web
-    def self.get(method, query, args)
-      args = { :v => SEARCH_VERSION }.merge(args)
-      GoogleAjax::get(:search, method, query, args)
-    end
-  
-    # Arguments: http://code.google.com/apis/ajaxsearch/documentation/reference.html#_fonje_blog
-    def self.blogs(query, args = {})
-      self.get(:blogs, query, args)
-    end
-  
-    # Arguments: http://code.google.com/apis/ajaxsearch/documentation/reference.html#_fonje_book
-    def self.books(query, args = {})
-      self.get(:books, query, args)
-    end
-
-    # Arguments: http://code.google.com/apis/ajaxsearch/documentation/reference.html#_fonje_image
-    def self.images(query, args = {})
-      self.get(:images, query, args)
+  class Search < Results
+    # A shortcut to the estimated result count
+    # e.g. GoogleAjax.books("Iliad").count  # => 60000
+    def count
+      self[:cursor][:estimated_result_count]
     end
 
+    ##
+    # :call-seq:
+    #   local(query, args = {})
     # Arguments: http://code.google.com/apis/ajaxsearch/documentation/reference.html#_fonje_local
     def self.local(query, latitude, longitude, args = {})
       args = { :sll => "#{latitude},#{longitude}" }.merge(args)
-      self.get(:local, query, args)
+      get(:local, query, args)
     end
 
+    ##
+    # :call-seq:
+    #   blogs(query, args = {})
+    # Arguments: http://code.google.com/apis/ajaxsearch/documentation/reference.html#_fonje_blog
+  
+    ##
+    # :call-seq:
+    #   books(query, args = {})
+    # Arguments: http://code.google.com/apis/ajaxsearch/documentation/reference.html#_fonje_book
+
+    ##
+    # :call-seq:
+    #   images(query, args = {})
+    # Arguments: http://code.google.com/apis/ajaxsearch/documentation/reference.html#_fonje_image
+
+    ##
+    # :call-seq:
+    #   news(query, args = {})
     # Arguments: http://code.google.com/apis/ajaxsearch/documentation/reference.html#_fonje_news
-    def self.news(query, args = {})
-      self.get(:news, query, args)
-    end
 
+    ##
+    # :call-seq:
+    #   video(query, args = {})
     # Arguments: http://code.google.com/apis/ajaxsearch/documentation/reference.html#_fonje_video
-    def self.video(query, args = {})
-      self.get(:video, query, args)
-    end
 
+    ##
+    # :call-seq:
+    #   web(query, args = {})
     # http://code.google.com/apis/ajaxsearch/documentation/reference.html#_fonje_web
-    def self.web(query, args = {})
-      self.get(:web, query, args)
-    end
-
-    class Result < Base
-    end
-
-    class Page < Base
-    end
-
-    class Cursor < Base
-      remap :pages => Page
-    end
-
-    class Results < Base
-      remap :results => Result,
-            :cursor => Cursor
-
-      def count
-        self['cursor']['estimatedResultCount'].to_i
-      end
-    end
 
+    standard_api :blogs, :books, :images, :news, :video, :web
   end
 end

data/lib/googleajax.rb

@@ -1,31 +1,23 @@
 require 'cgi'
 require 'open-uri'
-require 'ostruct'
 require 'rubygems'
 require 'json' unless defined?(Rails)
 
-module GoogleAjax
-  require 'googleajax/base' unless const_defined?("Base")
-  require 'googleajax/feed'
-  require 'googleajax/language'
-  require 'googleajax/search'
-  require 'googleajax/parser'
+# The following extensions are standard in either Ruby 1.8.7, 1.9 or rails:
+require 'googleajax/extensions/kernel'
+require 'googleajax/extensions/string'
+require 'googleajax/extensions/hash'
 
-  API_BASE = 'http://ajax.googleapis.com/ajax/services/'
-  class << self
-    attr_accessor :api_key
-    attr_accessor :referer
+# GoogleAjax lib:
+require 'googleajax/hash'
+require 'googleajax/filters'
+require 'googleajax/api'
+require 'googleajax/request'
+require 'googleajax/base' unless GoogleAjax.const_defined?("Base")
+require 'googleajax/results'
+require 'googleajax/feed'
+require 'googleajax/language'
+require 'googleajax/search'
 
-    # Api doc is at http://code.google.com/apis/ajaxsearch/documentation/reference.html#_intro_fonje
-    def get(api, method, query, args = nil)
-      raise "You must assign a value to GoogleAjax.referer" unless referer
-      url  = "#{API_BASE}#{api}/"
-      url += "#{method}?"
-      url += "&q=#{CGI::escape(query)}"
-      url += "&key=#{api_key}" if api_key
-      url += "&" + args.collect {|key, value| "#{key}=#{value}"}.join('&') if args && !args.empty?
-      data = open(url, "Referer" => referer).read
-      Parser.parse(api, method, data)
-    end
-  end
-end
+# Final touch
+GoogleAjax.extend GoogleAjax::Request

data/spec/{googleajax_as_hash_spec.rb → googleajax_as_open_struct_spec.rb}

@@ -1,15 +1,15 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require File.expand_path(File.dirname(__FILE__) + '/googleajax_common')
 
-require 'googleajax/as_hash'
+require 'googleajax/as_open_struct'
 
-describe "GoogleAjax/as_hash" do
+describe "GoogleAjax/as_open_struct" do
   it_should_behave_like "GoogleAjax"
 
-  it "returns results as a hash" do
+  it "returns results as an OpenStuct" do
     GoogleAjax.referer = "http://example.com"
     response = GoogleAjax::Search.web("apple", :rsz => :large)
-    response.is_a? Hash
-    response['cursor'].is_a? Hash
+    response.is_a? OpenStruct
+    response.cursor.is_a? OpenStruct
   end
 end

data/spec/googleajax_basic_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/googleajax_common')
+
+require 'googleajax/basic'
+
+describe "GoogleAjax (basic)" do
+  it "returns results as an unaltered hash" do
+    GoogleAjax.referer = "http://example.com"
+    response = GoogleAjax::Search.web("apple", :rsz => :large)
+    response.should be_kind_of(Hash)
+    response['cursor'].should be_an_instance_of(Hash)
+  end
+end

data/spec/googleajax_common.rb

@@ -13,7 +13,7 @@ shared_examples_for "GoogleAjax" do
       end
 
       it "returns the expected results" do
-        @response['results'].select{|result| result['url'] =~ /http:(.*).apple.com/}.size.should >= 4
+        @response[:results].select{|result| result[:url] =~ /http:(.*).apple.com/}.size.should >= 4
       end
     end
 
@@ -33,7 +33,7 @@ shared_examples_for "GoogleAjax" do
 
         it "takes options into account" do
           @response_large = GoogleAjax::Search.send(method, "ruby", *(args+[{:rsz => :large}]))
-          @response_large['results'].size.should > @response_small['results'].size
+          @response_large[:results].size.should > @response_small[:results].size
         end unless method == :blogs # Google doesn't seem to support this option for blogs???
 
         it "returns an approximate count of hits" do
@@ -50,14 +50,20 @@ shared_examples_for "GoogleAjax" do
 
     describe ".detect" do
       it "returns the right language" do
-        GoogleAjax::Language.detect("What's up folks")['language'].should == "en"
-        GoogleAjax::Language.detect("Montréal est une ville incroyable")['language'].should == "fr"
+        GoogleAjax::Language.detect("What's up folks")[:language].should == "en"
+        GoogleAjax::Language.detect("Montréal est une ville incroyable")[:language].should == "fr"
+      end
+
+      it "converts nicely the return types" do
+        result = GoogleAjax::Language.detect("Sandwich")
+        result[:is_reliable].should == false
+        result[:confidence].should be_a(Numeric)
       end
     end
 
     describe ".translate" do
       it "does an approximate translation" do
-        GoogleAjax::Language.translate("Ruby rocks", "en", "fr")['translatedText'].should == "Ruby roches"
+        GoogleAjax::Language.translate("Ruby rocks", "en", "fr")[:translated_text].should == "Ruby roches"
       end
     end
   end
@@ -71,22 +77,22 @@ shared_examples_for "GoogleAjax" do
       it "returns the right feeds" do
         feeds = GoogleAjax::Feed.find("Ruby")
         feeds.size.should == 10
-        feeds.any?{|result| result['url'] == "http://www.ruby-lang.org/en/feeds/news.rss"}.should be_true
+        feeds.any?{|result| result[:url] == "http://ruby-lang.org/en/feeds/news.rss"}.should be_true
       end
     end
 
     describe ".load" do
       it "loads entries of a feed" do
         feed = GoogleAjax::Feed.load('http://digg.com/rss/index.xml')
-        feed['title'].should == "digg.com: Stories / Popular"
-        feed['entries'].size.should == 4
+        feed[:title].should == "digg.com: Stories / Popular"
+        feed[:entries].size.should == 4
       end
     end
 
     describe ".lookup" do
       it "returns the feed associated with a URL" do
         feed = GoogleAjax::Feed.lookup("http://digg.com/")
-        feed['url'].should == "http://feeds.digg.com/digg/popular.rss"
+        feed[:url].should == "http://feeds.digg.com/digg/popular.rss"
       end
     end
   end

data/spec/googleajax_spec.rb

@@ -6,10 +6,10 @@ require 'googleajax'
 describe "GoogleAjax (standard)" do
   it_should_behave_like "GoogleAjax"
 
-  it "returns results as an OpenStuct" do
+  it "returns results as a hash" do
     GoogleAjax.referer = "http://example.com"
     response = GoogleAjax::Search.web("apple", :rsz => :large)
-    response.is_a? OpenStruct
-    response.cursor.is_a? OpenStruct
+    response.is_a? Hash
+    response[:cursor].is_a? Hash
   end
 end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
 require 'spec'
 require 'spec/autorun'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: googleajax
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors: 
 - geemus(Wesley Beary)
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-17 00:00:00 -08:00
+date: 2009-12-24 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -47,13 +47,23 @@ files:
 - Rakefile
 - VERSION
 - lib/googleajax.rb
+- lib/googleajax/api.rb
 - lib/googleajax/as_hash.rb
+- lib/googleajax/as_open_struct.rb
 - lib/googleajax/base.rb
+- lib/googleajax/basic.rb
+- lib/googleajax/extensions/hash.rb
+- lib/googleajax/extensions/kernel.rb
+- lib/googleajax/extensions/string.rb
 - lib/googleajax/feed.rb
+- lib/googleajax/filters.rb
+- lib/googleajax/hash.rb
 - lib/googleajax/language.rb
-- lib/googleajax/parser.rb
+- lib/googleajax/request.rb
+- lib/googleajax/results.rb
 - lib/googleajax/search.rb
-- spec/googleajax_as_hash_spec.rb
+- spec/googleajax_as_open_struct_spec.rb
+- spec/googleajax_basic_spec.rb
 - spec/googleajax_common.rb
 - spec/googleajax_spec.rb
 - spec/spec.opts
@@ -87,7 +97,8 @@ signing_key:
 specification_version: 3
 summary: Ruby wrapper to the Google AJAX API REST interfaces(Feeds, Language and Search).
 test_files: 
-- spec/googleajax_as_hash_spec.rb
+- spec/googleajax_as_open_struct_spec.rb
+- spec/googleajax_basic_spec.rb
 - spec/googleajax_common.rb
 - spec/googleajax_spec.rb
 - spec/spec_helper.rb

data/lib/googleajax/parser.rb

@@ -1,38 +0,0 @@
-module GoogleAjax
-  module Parser
-    def self.parse(api, method, data)
-      data = if defined? Rails
-        ActiveSupport::JSON::decode(data)
-      else
-        JSON.parse(data)
-      end
-      process_errors(data)
-      parser = PARSERS[api][method]
-      response = data['responseData']
-      parser.is_a?(Symbol) ? send(parser, response) : parser.new(response) if response
-    end
-
-    def self.process_errors(data)
-      status = data['responseStatus']
-      unless (200..206).include? status
-        raise StandardError, data['responseDetails']
-      end
-    end
-
-    def self.parse_feed_list(data)
-      data['entries'].map(&Feed::Feed.method(:new))
-    end
-
-    def self.parse_one_feed(data)
-      Feed::Feed.new(data['feed'])
-    end
-
-    PARSERS = {
-      :feed     => { :find => :parse_feed_list, :load => :parse_one_feed, :lookup => Feed::Feed },
-      :language => { :detect => Language::Language, :translate => Language::Translation },
-      :search   => { :blogs => Search::Results, :books => Search::Results, :images => Search::Results, :local => Search::Results,
-                     :news => Search::Results, :video => Search::Results, :web => Search::Results }
-    }
-
-  end
-end