google_rest 1.0.0

data/README

@@ -0,0 +1,22 @@
+GoogleRest
+==========
+
+A plugin to manipulate some Google REST API. For now it partially support:
+* Google Ajax Feed Api (find a feed, retrieve articles from a feed)
+* Google Search API (inbound links, number of indexed page)
+
+Setup
+=====
+
+You must add a config/google_rest.yml with your api key and referer (requested by Google Terms of use)
+Ex config/google_rest.yml
+---
+api_key: XXXXX
+referer: http://www.mydomain.com
+
+
+Example
+=======
+
+
+Copyright (c) 2008 Olivier Ruffin, http://www.veilleperso.com , released under the MIT license

data/init.rb

@@ -0,0 +1,3 @@
+require 'httparty'
+require 'json'
+require "google_rest"

data/lib/google_rest.rb

@@ -0,0 +1,231 @@
+require 'json/add/rails'
+
+module GoogleRest
+  PER_PAGE = 8
+
+  class Results
+
+    attr_accessor :raw, :results, :cursor
+
+    def initialize(raw)
+      self.raw = raw
+      data = (raw || {})
+      self.cursor = data["cursor"]
+      self.results = data["results"] || []
+    end
+
+    def empty?
+      raw.blank?
+    end
+
+    def each
+      results.each { |r| yield r }
+    end
+
+    def map
+      results.map { |r| yield r }
+    end
+
+    def page
+      cursor["currentPageIndex"].blank? ? 1 : cursor["currentPageIndex"]
+    end
+
+    def pages
+      (cursor["pages"] || [])
+    end
+
+    def total_pages
+      (cursor["pages"] || []).length
+    end
+
+    def total_entries
+      if pages.last
+        pages.last["start"].to_i + GoogleRest::PER_PAGE - 1
+      else
+        0
+      end
+    end
+
+    def per_page
+      8
+    end
+
+    def paginated(current_page = nil)
+      results.paginate(:page => current_page || page, :per_page => per_page, :total_entries => total_entries)
+    end
+
+  end
+
+  class Request
+    if defined?(HTTParty)
+      include HTTParty
+      base_uri "http://ajax.googleapis.com/ajax/services"
+      format :json
+      parser Proc.new { |data, format|
+        begin
+          Crack::JSON.parse(data)
+        rescue Crack::ParseError => err
+          ActiveSupport::JSON.decode(data)
+        end
+      }
+    end
+
+    attr_accessor :api_key
+    attr_accessor :referer
+    attr_accessor :userip
+
+    @@ascii_available = "".respond_to?(:to_ascii)
+
+    API_VERSION = "1.0"
+    API_URL = {
+      :feed_lookup => "/feed/lookup",
+      :feed_load => "/feed/load",
+      :web => "/search/web",
+      :blog => "/search/blogs",
+      :news => "/search/news",
+      :image => "/search/images",
+      :local => "/search/local",
+      :video => "/search/video"
+    }
+
+    def initialize(userip = nil)
+      path = Rails.root.join("config/google_rest.yml")
+      if !File.exists?(path)
+        raise StandardError, "Missing config file: #{path}"
+      else
+        config = YAML.load_file(path) || {}
+        data = config[Rails.env.to_s] || config
+        self.api_key = data['api_key']
+        self.referer = data['referer']
+        self.userip = userip
+      end
+    end
+
+    def feed_lookup(website)
+      return nil if website.blank?
+      res = google_request(:feed_lookup, {:q => website.to_s.gsub(/^https?:\/\//i, '')})
+      res.empty? ? nil : res.raw["url"]
+    end
+
+    def feed_load(feed_url, count_entries = false)
+      return nil if feed_url.blank?
+      if count_entries == false
+        # we retrieve the current feed entries
+        res = google_request(:feed_load, {:q => feed_url, :num => -1})
+      else
+        res = google_request(:feed_load, {:q => feed_url, :num => count_entries, :scoring => 'h'} )
+      end
+      res.empty? ? nil : res.raw["feed"]
+    end
+
+    def blog_search(query, options = {})
+      common_search(:blog, {:scoring => 'd', :rsz => 'large', :q => query}.merge(options))
+    end
+
+    def web_search(query, options = {})
+      common_search(:web, {:rsz => 'large', :q => query}.merge(options))
+    end
+
+    def news_search(query, options = {})
+      common_search(:news, {:rsz => 'large', :scoring => 'd', :q => query}.merge(options))
+    end
+
+    def image_search(query, options = {})
+      common_search(:image, {:q => query}.merge(options))
+    end
+
+    def video_search(query, options = {})
+      common_search(:video, {:q => query}.merge(options))
+    end
+
+    def local_search(query, options = {})
+      common_search(:local, {:q => query}.merge(options))
+    end
+
+    def inbound_links(url)
+      res = common_search(:web, {:q => "link:#{url.gsub(/^https?:\/\//,'')}"})
+      res.cursor.blank? ? 0 : res.cursor["estimatedResultCount"].to_i
+    end
+
+    def indexed_pages(url)
+      res = common_search(:web, {:q => "site:#{url.gsub(/^https?:\/\//,'')}"})
+      res.cursor.blank? ? 0 : res.cursor["estimatedResultCount"].to_i
+    end
+
+    def api_key?
+      !self.api_key.blank?
+    end
+    
+    def userip?
+      !self.userip.blank?
+    end
+    
+    private
+    def common_search(type, query = {})
+      if !(lang=query.delete(:lang)).blank?
+        lang.downcase!
+        if type == :news
+          query.reverse_merge!(:hl => lang, :ned => lang)
+        else
+          query.reverse_merge!(:hl => lang, :lr => "lang_#{lang}")
+        end
+      end
+      query.delete_if {|k,v| v.blank?}
+      google_request(type, query)
+    end
+
+    def google_request(type, query = {})
+      # HTTParty now use Crack instead of ActiveSupport::JSON to do the decoding
+      # But it doesn't seems to work properly with some Google Results so we hack it to not parse
+      # google results and we decode them by ourselves
+      begin
+        Timeout::timeout(15) do
+          no_escape = query.delete(:no_escape)
+          query[:v] = API_VERSION
+          query[:key] = api_key if api_key?
+          query[:userip] = userip if userip?
+          self.class.headers({'Referer' => self.referer})
+          res = self.class.get(API_URL[type], :query => query)
+          if !res["responseData"].blank?
+            GoogleRest::Results.new(no_escape ? res["responseData"] : Util.json_recursive_unescape(res["responseData"]))
+          else
+            GoogleRest::Results.new(nil)
+          end
+        end
+      rescue Timeout::Error => err
+        GoogleRest::Results.new(nil)
+      end
+    end
+
+    module Util
+      JSON_ESCAPE = { '&' => '\u0026', '>' => '\u003E', '<' => '\u003C', '=' => '\u003D' }
+
+      # A utility method for unescaping HTML entities in JSON strings.
+      #   puts json_unescape("\u003E 0 \u0026 a \u003C 10?")
+      #   # => is a > 0 & a < 10?
+      def json_unescape(s)
+        JSON_ESCAPE.inject(s.to_s) { |str, (k,v)| str.gsub!(/#{Regexp.escape(v)}/i, k); str }
+      end
+
+      # A utility method for escaping HTML entities in JSON strings.
+      #   puts json_escape("is a > 0 & a < 10?")
+      #   # => is a \u003E 0 \u0026 a \u003C 10?
+      def json_escape(s)
+        s.to_s.gsub(/[&"><]/) { |special| JSON_ESCAPE[special] }
+      end
+
+      # A utility method for unescaping recursively HTML entities in JSON array or hash.
+      def json_recursive_unescape(data)
+        case data
+        when String : json_unescape(data)
+        when Hash : data.inject({}) { |hsh, (k,v)| hsh[k] = json_recursive_unescape(v);hsh }
+        when Array : data.collect { |v| json_recursive_unescape(v) }
+        end
+      end
+
+      module_function :json_escape
+      module_function :json_unescape
+      module_function :json_recursive_unescape
+    end
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: google_rest
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Olivier Ruffin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-17 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Wrapper around google rest api
+email: olivier@muweb.fr
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- init.rb
+- lib/google_rest.rb
+has_rdoc: true
+homepage: https://github.com/veilleperso/google_rest
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: Google REST API
+test_files: []
+