rest-graph 1.5.0 → 1.6.0

data/README

@@ -1,4 +1,4 @@
-= rest-graph 1.5.0
+= rest-graph 1.6.0
 by Cardinal Blue ( http://cardinalblue.com )
 
 == LINKS:
@@ -20,12 +20,19 @@ A super simple Facebook Open Graph API client
 
 == REQUIREMENTS:
 
-* Tested with MRI 1.8.7 and 1.9.2 and Rubinius 1.1.0
-* gem install rest-client
-* gem install yajl-ruby (optional)
-* gem install json      (optional)
-* gem install json_pure (optional)
-* gem install rack      (optional, to parse access_token in HTTP_COOKIE)
+* Tested with MRI 1.8.7 and 1.9.2 and Rubinius 1.1.1
+
+* (must) pick one HTTP client:
+  - gem install rest-client
+  - gem install em-http-request
+
+* (optional) pick one JSON parser/generator:
+  - gem install yajl-ruby
+  - gem install json
+  - gem install json_pure
+
+* (optional) parse access_token in HTTP_COOKIE
+  - gem install rack
 
 == INSTALL:
 
@@ -77,7 +84,7 @@ adds the following two methods to your Controllers:
 New RestGraph objects can read their default setup configuration from a
 YAML configuration file.
 
-* {Sample}[http://github.com/cardinalblue/rest-graph/blob/master/test/config/rest-graph.yaml]
+* {Example}[http://github.com/cardinalblue/rest-graph/blob/master/test/config/rest-graph.yaml]
 
 To enable, just require anywhere:
 
@@ -119,6 +126,10 @@ Here are ALL the available options for new instance of RestGraph.
         # auto_authorize. That way, RailsUtil would do redirect instead
         # of raising an exception.
 
+        :log_method    => method(:puts),
+        # This way, any log message would be output by puts. If you want to
+        # change the log format, use log_handler instead. See below:
+
         :log_handler   => lambda{ |event|
           Rails.logger.
             debug("Spent #{event.duration} requesting #{event.url}")})
@@ -146,7 +157,7 @@ options for RestGraph instance are also valid options for rest_graph_setup.
                   # This means if the access_token is not there,
                   # then do auto_authorize.
 
-                  :write_session          => false     , # default false
+                  :write_session          => true      , # default false
                   :write_cookies          => false     , # default false
                   :write_handler          =>
                     lambda{ |fbs| @cache[uid] = fbs }  , # default nil

data/README.rdoc

@@ -1,4 +1,4 @@
-= rest-graph 1.5.0
+= rest-graph 1.6.0
 by Cardinal Blue ( http://cardinalblue.com )
 
 == LINKS:
@@ -20,12 +20,19 @@ A super simple Facebook Open Graph API client
 
 == REQUIREMENTS:
 
-* Tested with MRI 1.8.7 and 1.9.2 and Rubinius 1.1.0
-* gem install rest-client
-* gem install yajl-ruby (optional)
-* gem install json      (optional)
-* gem install json_pure (optional)
-* gem install rack      (optional, to parse access_token in HTTP_COOKIE)
+* Tested with MRI 1.8.7 and 1.9.2 and Rubinius 1.1.1
+
+* (must) pick one HTTP client:
+  - gem install rest-client
+  - gem install em-http-request
+
+* (optional) pick one JSON parser/generator:
+  - gem install yajl-ruby
+  - gem install json
+  - gem install json_pure
+
+* (optional) parse access_token in HTTP_COOKIE
+  - gem install rack
 
 == INSTALL:
 
@@ -77,7 +84,7 @@ adds the following two methods to your Controllers:
 New RestGraph objects can read their default setup configuration from a
 YAML configuration file.
 
-* {Sample}[http://github.com/cardinalblue/rest-graph/blob/master/test/config/rest-graph.yaml]
+* {Example}[http://github.com/cardinalblue/rest-graph/blob/master/test/config/rest-graph.yaml]
 
 To enable, just require anywhere:
 
@@ -119,6 +126,10 @@ Here are ALL the available options for new instance of RestGraph.
         # auto_authorize. That way, RailsUtil would do redirect instead
         # of raising an exception.
 
+        :log_method    => method(:puts),
+        # This way, any log message would be output by puts. If you want to
+        # change the log format, use log_handler instead. See below:
+
         :log_handler   => lambda{ |event|
           Rails.logger.
             debug("Spent #{event.duration} requesting #{event.url}")})
@@ -146,7 +157,7 @@ options for RestGraph instance are also valid options for rest_graph_setup.
                   # This means if the access_token is not there,
                   # then do auto_authorize.
 
-                  :write_session          => false     , # default false
+                  :write_session          => true      , # default false
                   :write_cookies          => false     , # default false
                   :write_handler          =>
                     lambda{ |fbs| @cache[uid] = fbs }  , # default nil

data/Rakefile

@@ -15,7 +15,8 @@ Bones{
 
   version RestGraph::VERSION
 
-  depend_on 'rest-client'
+  depend_on 'rest-client'    , :development => true
+  depend_on 'em-http-request', :development => true
 
   depend_on 'rack'     , :development => true
 

data/TODO

@@ -1,5 +1,7 @@
 = rest-graph todo list
 
+* error_handler can't be turned off
+
 * test for rails util for writing cookie
 
 * more docs?

data/example/multi/config.ru

@@ -0,0 +1,44 @@
+
+id = '4'
+times = 10
+
+require 'async-rack'
+require 'rest-graph'
+
+use Rack::ContentType
+use Rack::Reloader
+
+module RG
+  module_function
+  def create env
+    RestGraph.new(:log_method => env['rack.logger'].method(:debug))
+  end
+end
+
+run Rack::Builder.new{
+  map('/async'){
+    run lambda{ |env|
+      RG.create(env).multi([[:get, id]] * times){ |r|
+        env['async.callback'].call [200, {}, r.map(&:inspect)]
+      }
+      throw :async
+    }
+  }
+  map('/sync'){
+    run lambda{ |env|
+      [200, {}, (0...times).map{ RG.create(env).get(id) }.map(&:inspect)]
+    }
+  }
+  map('/'){
+    run lambda{ |env|
+      [200, {'Content-Type' => 'text/html'},
+        [<<-HTML
+<html><body>
+  go to <a href="/async">/async</a> for em-http-request (multi) result,<br/>
+  go to <a href="/sync">/sync</a> for rest-client result.<br/>
+</body></html>
+HTML
+        ]]
+    }
+  }
+}

data/example/multi/rainbows.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+Rainbows! do
+  use :EventMachine
+end

data/example/rails2/test/functional/application_controller_test.rb

@@ -5,7 +5,7 @@ require 'webmock'
 WebMock.disable_net_connect!
 
 class ApplicationControllerTest < ActionController::TestCase
-  include WebMock
+  include WebMock::API
 
   def setup
     body = rand(2) == 0 ? '{"error":{"type":"OAuthException"}}' :
@@ -16,7 +16,7 @@ class ApplicationControllerTest < ActionController::TestCase
   end
 
   def teardown
-    reset_webmock
+    WebMock.reset_webmock
   end
 
   def test_index
@@ -87,7 +87,7 @@ class ApplicationControllerTest < ActionController::TestCase
   end
 
   def test_cache
-    reset_webmock
+    WebMock.reset_webmock
     stub_request(:get, 'https://graph.facebook.com/cache').
       to_return(:body => '{"message":"ok"}')
 
@@ -97,7 +97,7 @@ class ApplicationControllerTest < ActionController::TestCase
   end
 
   def test_handler
-    reset_webmock
+    WebMock.reset_webmock
     stub_request(:get, 'https://graph.facebook.com/me?access_token=aloha').
       to_return(:body => '["snowman"]')
 
@@ -110,7 +110,7 @@ class ApplicationControllerTest < ActionController::TestCase
   end
 
   def test_session
-    reset_webmock
+    WebMock.reset_webmock
     stub_request(:get, 'https://graph.facebook.com/me?access_token=wozilla').
       to_return(:body => '["fireball"]')
 
@@ -123,7 +123,7 @@ class ApplicationControllerTest < ActionController::TestCase
   end
 
   def test_cookies
-    reset_webmock
+    WebMock.reset_webmock
     stub_request(:get, 'https://graph.facebook.com/me?access_token=blizzard').
       to_return(:body => '["yeti"]')
 

data/lib/rest-graph.rb

@@ -1,26 +1,27 @@
 
-# gem
-require 'rest_client'
+# optional http client
+begin; require 'restclient'     ; rescue LoadError; end
+begin; require 'em-http-request'; rescue LoadError; end
+
+# optional gem
+begin; require 'rack'           ; rescue LoadError; end
 
 # stdlib
 require 'digest/md5'
 require 'openssl'
 
 require 'cgi'
-
-# optional gem
-begin
-  require 'rack'
-rescue LoadError; end
+require 'timeout'
 
 # the data structure used in RestGraph
-RestGraphStruct = Struct.new(:auto_decode, :strict,
+RestGraphStruct = Struct.new(:auto_decode, :strict, :timeout,
                              :graph_server, :old_server,
                              :accept, :lang,
                              :app_id, :secret,
                              :data, :cache,
-                             :error_handler,
-                             :log_handler) unless defined?(::RestGraphStruct)
+                             :log_method,
+                             :log_handler,
+                             :error_handler) unless defined?(RestGraphStruct)
 
 class RestGraph < RestGraphStruct
   EventStruct = Struct.new(:duration, :url)           unless
@@ -29,31 +30,37 @@ class RestGraph < RestGraphStruct
   Attributes  = RestGraphStruct.members.map(&:to_sym) unless
     defined?(::RestGraph::Attributes)
 
-  class Event < EventStruct; end
+  class Event < EventStruct
+    # self.class.name[/(?<=::)\w+$/] if RUBY_VERSION >= '1.9.2'
+    def name; self.class.name[/::\w+$/].tr(':', ''); end
+    def to_s; "RestGraph: spent #{sprintf('%f', duration)} #{name} #{url}";end
+  end
+  class Event::MultiDone < Event; end
   class Event::Requested < Event; end
   class Event::CacheHit  < Event; end
+  class Event::Failed    < Event; end
 
   class Error < RuntimeError
     class AccessToken < Error; end
     class InvalidAccessToken < AccessToken; end
     class MissingAccessToken < AccessToken; end
 
-    attr_reader :error
-    def initialize error
-      @error = error
-      super(error.inspect)
+    attr_reader :error, :url
+    def initialize error, url=''
+      @error, @url = error, url
+      super("#{error.inspect} from #{url}")
     end
 
     module Util
       extend self
-      def parse error
-        return Error.new(error) unless error.kind_of?(Hash)
+      def parse error, url=''
+        return Error.new(error, url) unless error.kind_of?(Hash)
         if    invalid_token?(error)
-          InvalidAccessToken.new(error)
+          InvalidAccessToken.new(error, url)
         elsif missing_token?(error)
-          MissingAccessToken.new(error)
+          MissingAccessToken.new(error, url)
         else
-          Error.new(error)
+          Error.new(error, url)
         end
       end
 
@@ -85,6 +92,7 @@ class RestGraph < RestGraphStruct
     extend self
     def default_auto_decode ; true                         ; end
     def default_strict      ; false                        ; end
+    def default_timeout     ; 10                           ; end
     def default_graph_server; 'https://graph.facebook.com/'; end
     def default_old_server  ; 'https://api.facebook.com/'  ; end
     def default_accept      ; 'text/javascript'            ; end
@@ -93,11 +101,10 @@ class RestGraph < RestGraphStruct
     def default_secret      ; nil                          ; end
     def default_data        ; {}                           ; end
     def default_cache       ; nil                          ; end
+    def default_log_method  ; nil                          ; end
+    def default_log_handler ; nil                          ; end
     def default_error_handler
-      lambda{ |error| raise ::RestGraph::Error.parse(error) }
-    end
-    def default_log_handler
-      lambda{ |event| }
+      lambda{ |error, url| raise ::RestGraph::Error.parse(error, url) }
     end
   end
   extend DefaultAttributes
@@ -208,7 +215,8 @@ class RestGraph < RestGraphStruct
   end
 
   def lighten!
-    [:cache, :error_handler, :log_handler].each{ |obj| send("#{obj}=", nil) }
+    [:cache, :log_method, :log_handler, :error_handler].each{ |obj|
+      send("#{obj}=", nil) }
     self
   end
 
@@ -217,7 +225,7 @@ class RestGraph < RestGraphStruct
   end
 
   def inspect
-    super.gsub(/(\w+)=([^,]+)/){ |match|
+    super.gsub(/(\w+)=([^,>]+)/){ |match|
       value = $2 == 'nil' ? self.class.send("default_#{$1}").inspect : $2
       "#{$1}=#{value}"
     }
@@ -233,38 +241,76 @@ class RestGraph < RestGraphStruct
     "#{server}#{path}#{build_query_string(query)}"
   end
 
-  def get    path, query={}, opts={}
-    request(:get   , url(path, query, graph_server), opts)
+  def get    path, query={}, opts={}, &cb
+    request(opts, [:get   , url(path, query, graph_server)], &cb)
+  end
+
+  def delete path, query={}, opts={}, &cb
+    request(opts, [:delete, url(path, query, graph_server)], &cb)
+  end
+
+  def post   path, payload={}, query={}, opts={}, &cb
+    request(opts, [:post  , url(path, query, graph_server), payload], &cb)
+  end
+
+  def put    path, payload={}, query={}, opts={}, &cb
+    request(opts, [:put   , url(path, query, graph_server), payload], &cb)
+  end
+
+  # request by eventmachine (em-http)
+
+  def aget    path, query={}, opts={}, &cb
+    get(path, query, {:async => true}.merge(opts), &cb)
+  end
+
+  def adelete path, query={}, opts={}, &cb
+    delete(path, query, {:async => true}.merge(opts), &cb)
   end
 
-  def delete path, query={}, opts={}
-    request(:delete, url(path, query, graph_server), opts)
+  def apost   path, payload={}, query={}, opts={}, &cb
+    post(path, payload, query, {:async => true}.merge(opts), &cb)
   end
 
-  def post   path, payload, query={}, opts={}
-    request(:post  , url(path, query, graph_server), opts, payload)
+  def aput    path, payload={}, query={}, opts={}, &cb
+    put(path, payload, query, {:async => true}.merge(opts), &cb)
   end
 
-  def put    path, payload, query={}, opts={}
-    request(:put   , url(path, query, graph_server), opts, payload)
+  def multi reqs, opts={}, &cb
+    request({:async => true}.merge(opts),
+      *reqs.map{ |(meth, path, query, payload)|
+        [meth, url(path, query || {}, graph_server), payload]
+      }, &cb)
   end
 
-  def next_page hash, opts={}
-    return unless hash['paging'].kind_of?(Hash) && hash['paging']['next']
-    request(:get   , hash['paging']['next']        , opts)
+
+
+
+
+  def next_page hash, opts={}, &cb
+    if hash['paging'].kind_of?(Hash) && hash['paging']['next']
+      request(opts, [:get, hash['paging']['next']], &cb)
+    else
+      yield(nil) if block_given?
+    end
   end
 
-  def prev_page hash, opts={}
-    return unless hash['paging'].kind_of?(Hash) && hash['paging']['previous']
-    request(:get   , hash['paging']['previous']    , opts)
+  def prev_page hash, opts={}, &cb
+    if hash['paging'].kind_of?(Hash) && hash['paging']['previous']
+      request(opts, [:get, hash['paging']['previous']], &cb)
+    else
+      yield(nil) if block_given?
+    end
   end
   alias_method :previous_page, :prev_page
 
-  def for_pages hash, pages=1, kind=:next_page, opts={}
-    return hash if pages <= 1
-    if result = send(kind, hash, opts)
-      for_pages(merge_data(result, hash), pages - 1, kind, opts)
+  def for_pages hash, pages=1, opts={}, kind=:next_page, &cb
+    if pages > 1
+      merge_data(send(kind, hash, opts){ |result|
+        yield(result.freeze) if block_given?
+        for_pages(result, pages - 1, opts, kind, &cb) if result
+      }, hash)
     else
+      yield(nil) if block_given?
       hash
     end
   end
@@ -326,8 +372,8 @@ class RestGraph < RestGraphStruct
   def authorize! opts={}
     query = {:client_id => app_id, :client_secret => secret}.merge(opts)
     self.data = Rack::Utils.parse_query(
-                  request(:get, url('oauth/access_token', query),
-                          :suppress_decode => true))
+                  request({:suppress_decode => true}.merge(opts),
+                          [:get, url('oauth/access_token', query)]))
   end
 
 
@@ -336,31 +382,33 @@ class RestGraph < RestGraphStruct
 
   # old rest facebook api, i will definitely love to remove them someday
 
-  def old_rest path, query={}, opts={}
+  def old_rest path, query={}, opts={}, &cb
     request(
-      :get,
-      url("method/#{path}", {:format => 'json'}.merge(query), old_server),
-      opts)
+      opts,
+      [:get,
+      url("method/#{path}", {:format => 'json'}.merge(query), old_server)],
+      &cb)
   end
 
-  def secret_old_rest path, query={}, opts={}
-    old_rest(path, {:access_token => secret_access_token}.merge(query), opts)
+  def secret_old_rest path, query={}, opts={}, &cb
+    old_rest(path, {:access_token => secret_access_token}.merge(query), opts,
+      &cb)
   end
   alias_method :broken_old_rest, :secret_old_rest
 
-  def exchange_sessions opts={}
-    query = {:client_id => app_id, :client_secret => secret,
-             :type => 'client_cred'}.merge(opts)
-    request(:post, url('oauth/exchange_sessions', query))
+  def exchange_sessions query={}, opts={}, &cb
+    q = {:client_id => app_id, :client_secret => secret,
+         :type => 'client_cred'}.merge(query)
+    request(opts, [:post, url('oauth/exchange_sessions', q)], &cb)
   end
 
-  def fql code, query={}, opts={}
-    old_rest('fql.query', {:query => code}.merge(query), opts)
+  def fql code, query={}, opts={}, &cb
+    old_rest('fql.query', {:query => code}.merge(query), opts, &cb)
   end
 
-  def fql_multi codes, query={}, opts={}
+  def fql_multi codes, query={}, opts={}, &cb
     old_rest('fql.multiquery',
-      {:queries => self.class.json_encode(codes)}.merge(query), opts)
+      {:queries => self.class.json_encode(codes)}.merge(query), opts, &cb)
   end
 
 
@@ -368,13 +416,61 @@ class RestGraph < RestGraphStruct
 
 
   private
-  def request meth, uri, opts={}, payload=nil
+  def request opts, *reqs, &cb
+    Timeout.timeout(timeout){
+      if opts[:async]
+        request_em(opts, reqs, &cb)
+      else
+        request_rc(opts, *reqs.first, &cb)
+      end
+    }
+  end
+
+  def request_em opts, reqs
+    start_time = Time.now
+    rs = reqs.map{ |(meth, uri, payload)|
+      r = EM::HttpRequest.new(uri).send(meth, :body => payload)
+      if cached = cache_get(uri)
+        # TODO: this is hack!!
+        r.instance_variable_set('@response', cached)
+        r.instance_variable_set('@state'   , :finish)
+        r.on_request_complete
+        r.succeed(r)
+      else
+        r.callback{
+          cache_for(uri, r.response, meth)
+          log(Event::Requested.new(Time.now - start_time, uri))
+        }
+        r.error{
+          log(Event::Failed.new(Time.now - start_time, uri))
+        }
+      end
+      r
+    }
+    EM::MultiRequest.new(rs){ |m|
+      # TODO: how to deal with the failed?
+      clients = m.responses[:succeeded]
+      results = clients.map{ |client|
+        post_request(client.response, client.uri)
+      }
+
+      if reqs.size == 1
+        yield(results.first)
+      else
+        log(Event::MultiDone.new(Time.now - start_time,
+          clients.map(&:uri).join(', ')))
+        yield(results)
+      end
+    }
+  end
+
+  def request_rc opts, meth, uri, payload=nil, &cb
     start_time = Time.now
-    post_request(cache_get(uri) || fetch(meth, uri, payload), opts)
+    post_request(cache_get(uri) || fetch(meth, uri, payload), uri, opts, &cb)
   rescue RestClient::Exception => e
-    post_request(e.http_body, opts)
+    post_request(e.http_body, uri, opts, &cb)
   ensure
-    log_handler.call(Event::Requested.new(Time.now - start_time, uri))
+    log(Event::Requested.new(Time.now - start_time, uri))
   end
 
   def build_query_string query={}
@@ -391,30 +487,32 @@ class RestGraph < RestGraphStruct
     headers
   end
 
-  def post_request result, opts={}
+  def post_request result, uri='', opts={}, &cb
     if auto_decode && !opts[:suppress_decode]
       decoded = self.class.json_decode("[#{result}]").first
       check_error(if strict || !decoded.kind_of?(String)
                     decoded
                   else
                     self.class.json_decode(decoded)
-                  end)
+                  end, uri, &cb)
     else
-      result
+      block_given? ? yield(result) : result
     end
+  rescue ParseError => error
+    error_handler.call(error, uri) if error_handler
   end
 
   def check_sig_and_return_data cookies
     cookies if secret && calculate_sig(cookies) == cookies['sig']
   end
 
-  def check_error hash
+  def check_error hash, uri
     if error_handler && hash.kind_of?(Hash) &&
        (hash['error'] ||    # from graph api
         hash['error_code']) # from fql
-      error_handler.call(hash)
+      error_handler.call(hash, uri)
     else
-      hash
+      block_given? ? yield(hash) : hash
     end
   end
 
@@ -434,18 +532,19 @@ class RestGraph < RestGraphStruct
     return unless cache
     start_time = Time.now
     cache[cache_key(uri)].tap{ |result|
-      log_handler.call(Event::CacheHit.new(Time.now - start_time, uri)) if
-        result
+      log(Event::CacheHit.new(Time.now - start_time, uri)) if result
     }
   end
 
+  def cache_for uri, result, meth
+    cache[cache_key(uri)] = result if cache && meth == :get
+  end
+
   def fetch meth, uri, payload
     RestClient::Request.execute(:method => meth, :url => uri,
                                 :headers => build_headers,
                                 :payload => payload).body.
-      tap{ |result|
-        cache[cache_key(uri)] = result if cache && meth == :get
-      }
+      tap{ |result| cache_for(uri, result, meth) }
   end
 
   def merge_data lhs, rhs
@@ -456,4 +555,9 @@ class RestGraph < RestGraphStruct
     lhs['data'].unshift(*rhs['data'])
     lhs
   end
+
+  def log event
+    log_handler.call(event)             if log_handler
+    log_method .call("DEBUG: #{event}") if log_method
+  end
 end