koala 1.1.0 → 1.2.0beta1

data/lib/koala/graph_batch_api.rb

@@ -1,21 +1,21 @@
 module Koala
   module Facebook
       module GraphBatchAPIMethods
-        
+
       def self.included(base)
         base.class_eval do
           alias_method :graph_call_outside_batch, :graph_call
           alias_method :graph_call, :graph_call_in_batch
-          
+
           alias_method :check_graph_api_response, :check_response
           alias_method :check_response, :check_graph_batch_api_response
         end
       end
-      
+
       def batch_calls
         @batch_calls ||= []
       end
-            
+
       def graph_call_in_batch(path, args = {}, verb = "get", options = {}, &post_processing)
           # for batch APIs, we queue up the call details (incl. post-processing)
           batch_calls << BatchOperation.new(
@@ -26,7 +26,7 @@ module Koala
             :http_options => options,
             :post_processing => post_processing
           )
-          nil # batch operations return nothing immediately 
+          nil # batch operations return nothing immediately
       end
 
       def check_graph_batch_api_response(response)
@@ -45,7 +45,7 @@ module Koala
           args.merge!(batch_op.files) if batch_op.files
           batch_op.to_batch_params(access_token)
         })
-        
+
         graph_call_outside_batch('/', args, 'post', http_options) do |response|
           # map the results with post-processing included
           index = 0 # keep compat with ruby 1.8 - no with_index for map
@@ -57,10 +57,10 @@ module Koala
             if call_result
               # (see note in regular api method about JSON parsing)
               body = MultiJson.decode("[#{call_result['body'].to_s}]")[0]
-              
+
               unless call_result["code"].to_i >= 500 || error = check_response(body)
                 # Get the HTTP component they want
-                data = case batch_op.http_options[:http_component] 
+                data = case batch_op.http_options[:http_component]
                 when :status
                   call_result["code"].to_i
                 when :headers
@@ -78,10 +78,10 @@ module Koala
             else
               nil
             end
-          end          
+          end
         end
       end
-      
+
     end
   end
 end

data/lib/koala/graph_collection.rb

@@ -12,23 +12,23 @@ module Koala
       # by calling next_page or previous_page.
       attr_reader :paging
       attr_reader :api
-      
+
       def initialize(response, api)
         super response["data"]
         @paging = response["paging"]
         @api = api
       end
-            
+
       # defines methods for NEXT and PREVIOUS pages
       %w{next previous}.each do |this|
-        
+
         # def next_page
         # def previous_page
         define_method "#{this.to_sym}_page" do
           base, args = send("#{this}_page_params")
           base ? @api.get_page([base, args]) : nil
         end
-        
+
         # def next_page_params
         # def previous_page_params
         define_method "#{this.to_sym}_page_params" do
@@ -36,7 +36,7 @@ module Koala
           parse_page_url(@paging[this])
         end
       end
-      
+
       def parse_page_url(url)
         match = url.match(/.com\/(.*)\?(.*)/)
         base = match[1]
@@ -48,7 +48,7 @@ module Koala
         end
         [base,new_params]
       end
-      
+
     end
   end
 end

data/lib/koala/http_service.rb

@@ -0,0 +1,177 @@
+require 'faraday'
+require 'faraday_stack'
+
+module Koala
+  class Response
+    attr_reader :status, :body, :headers
+    def initialize(status, body, headers)
+      @status = status
+      @body = body
+      @headers = headers
+    end
+  end
+
+  module HTTPService
+    # common functionality for all HTTP services
+
+    class << self
+      attr_accessor :faraday_middleware, :http_options
+    end
+
+    @http_options ||= {}
+    
+    DEFAULT_MIDDLEWARE = Proc.new do |builder|
+      builder.request :multipart
+      builder.request :url_encoded
+      builder.adapter Faraday.default_adapter
+    end
+
+    def self.server(options = {})
+      server = "#{options[:rest_api] ? Facebook::REST_SERVER : Facebook::GRAPH_SERVER}"
+      server.gsub!(/\.facebook/, "-video.facebook") if options[:video]
+      "#{options[:use_ssl] ? "https" : "http"}://#{options[:beta] ? "beta." : ""}#{server}"
+    end
+
+    def self.make_request(path, args, verb, options = {})
+      # if the verb isn't get or post, send it as a post argument
+      args.merge!({:method => verb}) && verb = "post" if verb != "get" && verb != "post"
+
+      # turn all the keys to strings (Faraday has issues with symbols under 1.8.7) and resolve UploadableIOs
+      params = args.inject({}) {|hash, kv| hash[kv.first.to_s] = kv.last.is_a?(UploadableIO) ? kv.last.to_upload_io : kv.last; hash}
+
+      # figure out our options for this request   
+      request_options = {:params => (verb == "get" ? params : {})}.merge(http_options || {}).merge(process_options(options))
+      request_options[:use_ssl] = true if args["access_token"] # require http if there's a token
+
+      # set up our Faraday connection
+      # we have to manually assign params to the URL or the
+      conn = Faraday.new(server(request_options), request_options, &(faraday_middleware || DEFAULT_MIDDLEWARE))
+
+      response = conn.send(verb, path, (verb == "post" ? params : {}))
+      Koala::Response.new(response.status.to_i, response.body, response.headers)
+    end
+
+    def self.encode_params(param_hash)
+      # unfortunately, we can't use to_query because that's Rails, not Ruby
+      # if no hash (e.g. no auth token) return empty string
+      # this is used mainly by the Batch API nowadays
+      ((param_hash || {}).collect do |key_and_value|
+        key_and_value[1] = MultiJson.encode(key_and_value[1]) unless key_and_value[1].is_a? String
+        "#{key_and_value[0].to_s}=#{CGI.escape key_and_value[1]}"
+      end).join("&")
+    end
+    
+    # deprecations
+    # not elegant or compact code, but temporary
+    
+    def self.always_use_ssl
+      Koala::Utils.deprecate("HTTPService.always_use_ssl is now HTTPService.http_options[:use_ssl]; always_use_ssl will be removed in a future version.")
+      http_options[:use_ssl]
+    end
+
+    def self.always_use_ssl=(value)
+      Koala::Utils.deprecate("HTTPService.always_use_ssl is now HTTPService.http_options[:use_ssl]; always_use_ssl will be removed in a future version.")
+      http_options[:use_ssl] = value
+    end
+    
+    def self.timeout
+      Koala::Utils.deprecate("HTTPService.timeout is now HTTPService.http_options[:timeout]; .timeout will be removed in a future version.")
+      http_options[:timeout]
+    end
+
+    def self.timeout=(value)
+      Koala::Utils.deprecate("HTTPService.timeout is now HTTPService.http_options[:timeout]; .timeout will be removed in a future version.")
+      http_options[:timeout] = value
+    end
+    
+    def self.timeout
+      Koala::Utils.deprecate("HTTPService.timeout is now HTTPService.http_options[:timeout]; .timeout will be removed in a future version.")
+      http_options[:timeout]
+    end
+
+    def self.timeout=(value)
+      Koala::Utils.deprecate("HTTPService.timeout is now HTTPService.http_options[:timeout]; .timeout will be removed in a future version.")
+      http_options[:timeout] = value
+    end
+    
+    def self.proxy
+      Koala::Utils.deprecate("HTTPService.proxy is now HTTPService.http_options[:proxy]; .proxy will be removed in a future version.")
+      http_options[:proxy]
+    end
+
+    def self.proxy=(value)
+      Koala::Utils.deprecate("HTTPService.proxy is now HTTPService.http_options[:proxy]; .proxy will be removed in a future version.")
+      http_options[:proxy] = value
+    end
+    
+    def self.ca_path
+      Koala::Utils.deprecate("HTTPService.ca_path is now (HTTPService.http_options[:ssl] ||= {})[:ca_path]; .ca_path will be removed in a future version.")
+      (http_options[:ssl] || {})[:ca_path]
+    end
+
+    def self.ca_path=(value)
+      Koala::Utils.deprecate("HTTPService.ca_path is now (HTTPService.http_options[:ssl] ||= {})[:ca_path]; .ca_path will be removed in a future version.")
+      (http_options[:ssl] ||= {})[:ca_path] = value
+    end
+    
+    def self.ca_file
+      Koala::Utils.deprecate("HTTPService.ca_file is now (HTTPService.http_options[:ssl] ||= {})[:ca_file]; .ca_file will be removed in a future version.")
+      (http_options[:ssl] || {})[:ca_file]
+    end
+
+    def self.ca_file=(value)
+      Koala::Utils.deprecate("HTTPService.ca_file is now (HTTPService.http_options[:ssl] ||= {})[:ca_file]; .ca_file will be removed in a future version.")
+      (http_options[:ssl] ||= {})[:ca_file] = value
+    end
+
+    def self.verify_mode
+      Koala::Utils.deprecate("HTTPService.verify_mode is now (HTTPService.http_options[:ssl] ||= {})[:verify_mode]; .verify_mode will be removed in a future version.")
+      (http_options[:ssl] || {})[:verify_mode]
+    end
+
+    def self.verify_mode=(value)
+      Koala::Utils.deprecate("HTTPService.verify_mode is now (HTTPService.http_options[:ssl] ||= {})[:verify_mode]; .verify_mode will be removed in a future version.")
+      (http_options[:ssl] ||= {})[:verify_mode] = value
+    end
+
+    def self.process_options(options)
+      if typhoeus_options = options.delete(:typhoeus_options)
+        Koala::Utils.deprecate("typhoeus_options should now be included directly in the http_options hash.  Support for this key will be removed in a future version.")
+        options = options.merge(typhoeus_options)
+      end
+      
+      if ca_file = options.delete(:ca_file)
+        Koala::Utils.deprecate("http_options[:ca_file] should now be passed inside (http_options[:ssl] = {}) -- that is, http_options[:ssl][:ca_file].  Support for this key will be removed in a future version.")
+        (options[:ssl] ||= {})[:ca_file] = ca_file
+      end
+
+      if ca_path = options.delete(:ca_path)
+        Koala::Utils.deprecate("http_options[:ca_path] should now be passed inside (http_options[:ssl] = {}) -- that is, http_options[:ssl][:ca_path].  Support for this key will be removed in a future version.")
+        (options[:ssl] ||= {})[:ca_path] = ca_path
+      end
+
+      if verify_mode = options.delete(:verify_mode)
+        Koala::Utils.deprecate("http_options[:verify_mode] should now be passed inside (http_options[:ssl] = {}) -- that is, http_options[:ssl][:verify_mode].  Support for this key will be removed in a future version.")
+        (options[:ssl] ||= {})[:verify_mode] = verify_mode
+      end
+      
+      options
+    end   
+  end
+  
+  module TyphoeusService
+    def self.deprecated_interface
+      # support old-style interface with a warning
+      Koala::Utils.deprecate("the TyphoeusService module is deprecated; to use Typhoeus, set Faraday.default_adapter = :typhoeus.  Enabling Typhoeus for all Faraday connections.")
+      Faraday.default_adapter = :typhoeus
+    end
+  end
+
+  module NetHTTPService
+    def self.deprecated_interface
+      # support old-style interface with a warning
+      Koala::Utils.deprecate("the NetHTTPService module is deprecated; to use Net::HTTP, set Faraday.default_adapter = :net_http.  Enabling Net::HTTP for all Faraday connections.")
+      Faraday.default_adapter = :net_http
+    end
+  end
+end

data/lib/koala/oauth.rb

@@ -52,7 +52,7 @@ module Koala
         permissions = options[:permissions]
         scope = permissions ? "&scope=#{permissions.is_a?(Array) ? permissions.join(",") : permissions}" : ""
         display = options.has_key?(:display) ? "&display=#{options[:display]}" : ""
-        
+
         callback = options[:callback] || @oauth_callback_url
         raise ArgumentError, "url_for_oauth_code must get a callback either from the OAuth object or in the options!" unless callback
 
@@ -178,4 +178,4 @@ module Koala
       end
     end
   end
-end
+end

data/lib/koala/realtime_updates.rb

@@ -1,15 +1,13 @@
-require 'koala'
-
 module Koala
   module Facebook
     module RealtimeUpdateMethods
       # note: to subscribe to real-time updates, you must have an application access token
-      
+
       def self.included(base)
         # make the attributes readable
         base.class_eval do
-          attr_reader :app_id, :app_access_token, :secret
-          
+          attr_reader :api, :app_id, :app_access_token, :secret
+
           # parses the challenge params and makes sure the call is legitimate
           # returns the challenge string to be sent back to facebook if true
           # returns false otherwise
@@ -20,7 +18,7 @@ module Koala
                 # you can make sure this is legitimate through two ways
                 # if your store the token across the calls, you can pass in the token value
                 # and we'll make sure it matches
-                (verify_token && params["hub.verify_token"] == verify_token) ||        
+                (verify_token && params["hub.verify_token"] == verify_token) ||
                 # alternately, if you sent a specially-constructed value (such as a hash of various secret values)
                 # you can pass in a block, which we'll call with the verify_token sent by Facebook
                 # if it's legit, return anything that evaluates to true; otherwise, return nil or false
@@ -32,7 +30,7 @@ module Koala
           end
         end
       end
-      
+
       def initialize(options = {})
         @app_id = options[:app_id]
         @app_access_token = options[:app_access_token]
@@ -40,22 +38,22 @@ module Koala
         unless @app_id && (@app_access_token || @secret) # make sure we have what we need
           raise ArgumentError, "Initialize must receive a hash with :app_id and either :app_access_token or :secret! (received #{options.inspect})"
         end
-        
+
         # fetch the access token if we're provided a secret
         if @secret && !@app_access_token
           oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
           @app_access_token = oauth.get_app_access_token
         end
-        
-        @graph_api = GraphAPI.new(@app_access_token)
+
+        @graph_api = API.new(@app_access_token)
       end
-      
+
       # subscribes for realtime updates
       # your callback_url must be set up to handle the verification request or the subscription will not be set up
       # http://developers.facebook.com/docs/api/realtime
       def subscribe(object, fields, callback_url, verify_token)
         args = {
-          :object => object, 
+          :object => object,
           :fields => fields,
           :callback_url => callback_url,
           :verify_token => verify_token
@@ -63,7 +61,7 @@ module Koala
         # a subscription is a success if Facebook returns a 200 (after hitting your server for verification)
         @graph_api.graph_call(subscription_path, args, 'post', :http_component => :status) == 200
       end
-          
+
       # removes subscription for object
       # if object is nil, it will remove all subscriptions
       def unsubscribe(object = nil)
@@ -71,16 +69,21 @@ module Koala
         args[:object] = object if object
         @graph_api.graph_call(subscription_path, args, 'delete', :http_component => :status) == 200
       end
-  
+
       def list_subscriptions
         @graph_api.graph_call(subscription_path)["data"]
       end
-      
+
+      def graph_api
+        Koala::Utils.deprecate("the TestUsers.graph_api accessor is deprecated and will be removed in a future version; please use .api instead.")
+        @api
+      end
+
       protected
-      
+
       def subscription_path
         @subscription_path ||= "#{@app_id}/subscriptions"
       end
     end
   end
-end
+end

data/lib/koala/rest_api.rb

@@ -4,7 +4,7 @@ module Koala
 
     module RestAPIMethods
       def fql_query(fql, args = {}, options = {})
-        rest_call('fql.query', args.merge(:query => fql), options) 
+        rest_call('fql.query', args.merge(:query => fql), options)
       end
 
       def fql_multiquery(queries = {}, args = {}, options = {})

data/lib/koala/test_users.rb

@@ -3,7 +3,14 @@ require 'koala'
 module Koala
   module Facebook
     module TestUserMethods
-      
+
+      def self.included(base)
+        base.class_eval do
+          # make the Graph API accessible in case someone wants to make other calls to interact with their users
+          attr_reader :api, :app_id, :app_access_token, :secret
+        end
+      end
+
       def initialize(options = {})
         @app_id = options[:app_id]
         @app_access_token = options[:app_access_token]
@@ -17,29 +24,34 @@ module Koala
           oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
           @app_access_token = oauth.get_app_access_token
         end
-        @graph_api = GraphAPI.new(@app_access_token)
+        @api = API.new(@app_access_token)
       end
 
       def create(installed, permissions = nil, args = {}, options = {})
         # Creates and returns a test user
         args['installed'] = installed
         args['permissions'] = (permissions.is_a?(Array) ? permissions.join(",") : permissions) if installed
-        result = @graph_api.graph_call(accounts_path, args, "post", options)
+        result = @api.graph_call(accounts_path, args, "post", options)
       end
-      
+
       def list
-        @graph_api.graph_call(accounts_path)["data"]
+        @api.graph_call(accounts_path)["data"]
       end
-      
+
       def delete(test_user)
         test_user = test_user["id"] if test_user.is_a?(Hash)
-        @graph_api.delete_object(test_user)
+        @api.delete_object(test_user)
       end
-      
+
       def delete_all
-        list.each {|u| delete u }
+        list.each {|u| delete u}
+      end
+
+      def update(test_user, args = {}, http_options = {})
+        test_user = test_user["id"] if test_user.is_a?(Hash)
+        @api.graph_call(test_user, args, "post", http_options)
       end
-      
+
       def befriend(user1_hash, user2_hash)
         user1_id = user1_hash["id"] || user1_hash[:id]
         user2_id = user2_hash["id"] || user2_hash[:id]
@@ -51,11 +63,11 @@ module Koala
           # but the Facebook call would fail
           raise ArgumentError, "TestUsers#befriend requires hash arguments for both users with id and access_token"
         end
-        
-        u1_graph_api = GraphAPI.new(user1_token)
-        u2_graph_api = GraphAPI.new(user2_token)
 
-        u1_graph_api.graph_call("#{user1_id}/friends/#{user2_id}", {}, "post") && 
+        u1_graph_api = API.new(user1_token)
+        u2_graph_api = API.new(user2_token)
+
+        u1_graph_api.graph_call("#{user1_id}/friends/#{user2_id}", {}, "post") &&
           u2_graph_api.graph_call("#{user2_id}/friends/#{user1_id}", {}, "post")
       end
 
@@ -73,9 +85,14 @@ module Koala
         end
         return users
       end
-      
+
+      def graph_api
+        Koala::Utils.deprecate("the TestUsers.graph_api accessor is deprecated and will be removed in a future version; please use .api instead.")
+        @api
+      end
+
       protected
-      
+
       def accounts_path
         @accounts_path ||= "/#{@app_id}/accounts/test-users"
       end