koala 1.4.1 → 1.5.0rc1

data/CHANGELOG

@@ -1,9 +1,26 @@
+v1.5
+New methods:
+-- Added Koala::Utils.logger to enable debugging (thanks, KentonWhite!)
+-- Expose fb_error_message and fb_error_code directly in APIError
+Updated methods:
+-- GraphCollection.parse_page_url now uses the URI library and can parse any address (thanks, bnorton!)
+Internal improvements:
+-- Update MultiJson dependency to support the Oj library (thanks, zinenko!)
+-- Loosened Faraday dependency (thanks, rewritten and romanbsd!)
+-- Fixed typos (thanks, nathanbertram!)
+-- Switched uses of put_object to the more semantically accurate put_connections
+-- Cleaned up gemspec
+-- Handle invalid batch API responses better
+Documentation:
+-- Added HTTP Services description for Faraday 0.8/persistent connections (thanks, romanbsd!)
+-- Remove documentation of the old pre-1.2 HTTP Service options
+
 v.1.4.1
 -- Update MultiJson to 1.3 and change syntax to silence warnings (thanks, eckz and masterkain!)
 
 v1.4
 New methods:
--- OAuth#exchange_access_token(_info) allows you to extend access tokens you receive (thanks,   etiennebarrie!)
+-- OAuth#exchange_access_token(_info) allows you to extend access tokens you receive (thanks, etiennebarrie!)
 Updated methods:
 -- HTTPServices#encode_params sorts parameters to aid in URL comparison (thanks, sholden!)
 -- get_connections is now aliased as get_connection (use whichever makes sense to you)

data/koala.gemspec

@@ -2,47 +2,26 @@
 $LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require 'koala/version'
 
-Gem::Specification.new do |s|
-  s.name    = %q{koala}
-  s.version = Koala::VERSION
-
-  s.summary     = %q{A lightweight, flexible library for Facebook with support for the Graph API, the REST API, realtime updates, and OAuth authentication.}
-  s.description = %q{Koala is a lightweight, flexible Ruby SDK for Facebook.  It allows read/write access to the social graph via the Graph and REST APIs, as well as support for realtime updates and OAuth and Facebook Connect authentication.  Koala is fully tested and supports Net::HTTP and Typhoeus connections out of the box and can accept custom modules for other services.}
-  s.homepage    = %q{http://github.com/arsduo/koala}
-
-  s.authors = ["Alex Koppel"]
-  s.email   = %q{alex@alexkoppel.com}
-
-  s.files = `git ls-files`.split("\n")
-  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
-
-  s.extra_rdoc_files = ["readme.md", "CHANGELOG"]
-  s.rdoc_options     = ["--line-numbers", "--inline-source", "--title", "Koala"]
-
-  s.require_paths     = ["lib"]
-
-  s.rubygems_version  = %q{1.4.2}
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<multi_json>,    ["~> 1.3.0"])
-      s.add_runtime_dependency(%q<faraday>,  ["~> 0.7.0"])
-      s.add_development_dependency(%q<rspec>,     ["~> 2.8.0rc1"])
-      s.add_development_dependency(%q<rake>,      ["~> 0.8.7"])
-    else
-      s.add_dependency(%q<multi_json>,      ["~> 1.3.0"])
-      s.add_dependency(%q<rspec>,     ["~> 2.8.0rc1"])
-      s.add_dependency(%q<rake>,      ["~> 0.8.7"])
-      s.add_dependency(%q<faraday>,  ["~> 0.7.0"])
-    end
-  else
-    s.add_dependency(%q<multi_json>,      ["~> 1.3.0"])
-    s.add_dependency(%q<rspec>,     ["~> 2.8.0rc1"])
-    s.add_dependency(%q<rake>,      ["~> 0.8.7"])
-    s.add_dependency(%q<faraday>,  ["~> 0.7.0"])
-  end
+Gem::Specification.new do |gem|
+  gem.name        = "koala"
+  gem.summary     = "A lightweight, flexible library for Facebook with support for the Graph API, the REST API, realtime updates, and OAuth authentication."
+  gem.description = "Koala is a lightweight, flexible Ruby SDK for Facebook.  It allows read/write access to the social graph via the Graph and REST APIs, as well as support for realtime updates and OAuth and Facebook Connect authentication.  Koala is fully tested and supports Net::HTTP and Typhoeus connections out of the box and can accept custom modules for other services."
+  gem.homepage    = "http://github.com/arsduo/koala"
+  gem.version     = Koala::VERSION
+
+  gem.authors     = ["Alex Koppel"]
+  gem.email       = "alex@alexkoppel.com"
+
+  gem.require_paths  = ["lib"]
+  gem.files          = `git ls-files`.split("\n")
+  gem.test_files     = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables    = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+
+  gem.extra_rdoc_files = ["readme.md", "CHANGELOG"]
+  gem.rdoc_options     = ["--line-numbers", "--inline-source", "--title", "Koala"]
+
+  gem.add_runtime_dependency(%q<multi_json>,    ["~> 1.3"])
+  gem.add_runtime_dependency(%q<faraday>,       ["~> 0.7"])
+  gem.add_development_dependency(%q<rspec>,     ["~> 2.8"])
+  gem.add_development_dependency(%q<rake>,      ["~> 0.8"])
 end

data/lib/koala/api/graph_api.rb

@@ -72,8 +72,7 @@ module Koala
       #       Please use put_connections; in a future version of Koala (2.0?),
       #       put_object will issue a POST directly to an individual object, not to a connection.
       def put_object(parent_object, connection_name, args = {}, options = {})
-        raise APIError.new({"type" => "KoalaMissingAccessToken", "message" => "Write operations require an access token"}) unless @access_token
-        graph_call("#{parent_object}/#{connection_name}", args, "post", options)
+        put_connections(parent_object, connection_name, args, options)
       end
 
       # Delete an object from the Graph if you have appropriate permissions.
@@ -115,7 +114,7 @@ module Koala
       # @note (see #get_connection)
       #
       # @example
-      #         graph.put_object("me", "feed", :message => "Hello, world")
+      #         graph.put_connections("me", "feed", :message => "Hello, world")
       #         => writes "Hello, world" to the active user's wall
       #
       # Most write operations require extended permissions. For example,
@@ -192,7 +191,7 @@ module Koala
       #
       # @return (see #put_connections)
       def put_picture(*picture_args)
-        put_object(*parse_media_args(picture_args, "photos"))
+        put_connections(*parse_media_args(picture_args, "photos"))
       end
 
       # Upload a video.  Functions exactly the same as put_picture.
@@ -200,11 +199,11 @@ module Koala
       def put_video(*video_args)
         args = parse_media_args(video_args, "videos")
         args.last[:video] = true
-        put_object(*args)
+        put_connections(*args)
       end
 
       # Write directly to the user's wall.
-      # Convenience method equivalent to put_object(id, "feed").
+      # Convenience method equivalent to put_connections(id, "feed").
       #
       # To get wall posts, use get_connections(user, "feed")
       # To delete a wall post, use delete_object(post_id)
@@ -227,7 +226,7 @@ module Koala
       # @see #put_connections
       # @return (see #put_connections)
       def put_wall_post(message, attachment = {}, target_id = "me", options = {})
-        self.put_object(target_id, "feed", attachment.merge({:message => message}), options)
+        put_connections(target_id, "feed", attachment.merge({:message => message}), options)
       end
 
       # Comment on a given object.
@@ -243,7 +242,7 @@ module Koala
       # @return (see #put_connections)
       def put_comment(id, message, options = {})
         # Writes the given comment on the given post.
-        self.put_object(id, "comments", {:message => message}, options)
+        put_connections(id, "comments", {:message => message}, options)
       end
 
       # Like a given object.
@@ -257,7 +256,7 @@ module Koala
       # @return (see #put_connections)
       def put_like(id, options = {})
         # Likes the given post.
-        self.put_object(id, "likes", {}, options)
+        put_connections(id, "likes", {}, options)
       end
 
       # Unlike a given object.
@@ -447,7 +446,7 @@ module Koala
 
       def parse_media_args(media_args, method)
         # photo and video uploads can accept different types of arguments (see above)
-        # so here, we parse the arguments into a form directly usable in put_object
+        # so here, we parse the arguments into a form directly usable in put_connections
         raise KoalaError.new("Wrong number of arguments for put_#{method == "photos" ? "picture" : "video"}") unless media_args.size.between?(1, 5)
 
         args_offset = media_args[1].kind_of?(Hash) || media_args.size == 1 ? 0 : 1

data/lib/koala/api/graph_batch_api.rb

@@ -41,7 +41,7 @@ module Koala
       end
 
       # redefine the graph_call and check_response methods
-      # so we can use this API inside the batch block just like any regular Graph API  
+      # so we can use this API inside the batch block just like any regular Graph API
       alias_method :graph_call_outside_batch, :graph_call
       alias_method :graph_call, :graph_call_in_batch
 
@@ -59,6 +59,12 @@ module Koala
         })
 
         batch_result = graph_call_outside_batch('/', args, 'post', http_options) do |response|
+          unless response
+            # Facebook sometimes reportedly returns an empty body at times
+            # see https://github.com/arsduo/koala/issues/184
+            raise APIError.new({"type" => "BadFacebookResponse", "message" => "Facebook returned invalid batch response: #{response.inspect}"})
+          end
+
           # map the results with post-processing included
           index = 0 # keep compat with ruby 1.8 - no with_index for map
           response.map do |call_result|
@@ -92,7 +98,7 @@ module Koala
             end
           end
         end
-        
+
         # turn any results that are pageable into GraphCollections
         batch_result.inject([]) {|processed_results, raw| processed_results << GraphCollection.evaluate(raw, @original_api)}
       end

data/lib/koala/api/graph_collection.rb

@@ -87,10 +87,11 @@ module Koala
         #
         # @return an array of parameters that can be provided via graph_call(*parsed_params)
         def self.parse_page_url(url)
-          match = url.match(/.com\/(.*)\?(.*)/)
-          base = match[1]
-          args = match[2]
-          params = CGI.parse(args)
+          uri = URI.parse(url)
+
+          base = uri.path.sub(/^\//, '')
+          params = CGI.parse(uri.query)
+
           new_params = {}
           params.each_pair do |key,value|
             new_params[key] = value.join ","

data/lib/koala/api.rb

@@ -12,12 +12,12 @@ module Koala
       def initialize(access_token = nil)
         @access_token = access_token
       end
-      
+
       attr_reader :access_token
 
       include GraphAPIMethods
       include RestAPIMethods
-      
+
       # Makes a request to the appropriate Facebook API.
       # @note You'll rarely need to call this method directly.
       #
@@ -27,17 +27,17 @@ module Koala
       # @param path the server path for this request (leading / is prepended if not present)
       # @param args arguments to be sent to Facebook
       # @param verb the HTTP method to use
-      # @param options request-related options for Koala and Faraday. 
+      # @param options request-related options for Koala and Faraday.
       #                See https://github.com/arsduo/koala/wiki/HTTP-Services for additional options.
       # @option options [Symbol] :http_component which part of the response (headers, body, or status) to return
       # @option options [Boolean] :beta use Facebook's beta tier
-      # @option options [Boolean] :use_ssl force SSL for this request, even if it's tokenless.  
+      # @option options [Boolean] :use_ssl force SSL for this request, even if it's tokenless.
       #                                    (All API requests with access tokens use SSL.)
-      # @param error_checking_block a block to evaluate the response status for additional JSON-encoded errors 
+      # @param error_checking_block a block to evaluate the response status for additional JSON-encoded errors
       #
       # @yield The response body for evaluation
       #
-      # @raise [Koala::Facebook::APIError] if Facebook returns an error (response status >= 500)      
+      # @raise [Koala::Facebook::APIError] if Facebook returns an error (response status >= 500)
       #
       # @return the body of the response from Facebook (unless another http_component is requested)
       def api(path, args = {}, verb = "get", options = {}, &error_checking_block)
@@ -69,11 +69,11 @@ module Koala
         end
       end
     end
-    
+
     class APIError < StandardError
-      attr_accessor :fb_error_type, :raw_response
+      attr_accessor :fb_error_type, :fb_error_code, :fb_error_message, :raw_response
 
-      # Creates a new APIError. 
+      # Creates a new APIError.
       #
       # Assigns the error type (as reported by Facebook) to #fb_error_type
       # and the raw error response available to #raw_response.
@@ -82,6 +82,8 @@ module Koala
       def initialize(details = {})
         self.raw_response = details
         self.fb_error_type = details["type"]
+        self.fb_error_code = details["code"]
+        self.fb_error_message = details["message"]
         super("#{fb_error_type}: #{details["message"]}")
       end
     end

data/lib/koala/http_service.rb

@@ -4,7 +4,7 @@ require 'koala/http_service/uploadable_io'
 require 'koala/http_service/response'
 
 module Koala
-  module HTTPService    
+  module HTTPService
     class << self
       # A customized stack of Faraday middleware that will be used to make each request.
       attr_accessor :faraday_middleware
@@ -13,9 +13,9 @@ module Koala
     end
 
     @http_options ||= {}
-    
-    # Koala's default middleware stack. 
-    # We encode requests in a Facebook-compatible multipart request, 
+
+    # Koala's default middleware stack.
+    # We encode requests in a Facebook-compatible multipart request,
     # and use whichever adapter has been configured for this application.
     DEFAULT_MIDDLEWARE = Proc.new do |builder|
       builder.use Koala::HTTPService::MultipartRequest
@@ -30,7 +30,7 @@ module Koala
     # @option options :video use the server designated for video uploads
     # @option options :beta use the beta tier
     # @option options :use_ssl force https, even if not needed
-    # 
+    #
     # @return a complete server address with protocol
     def self.server(options = {})
       server = "#{options[:rest_api] ? Facebook::REST_SERVER : Facebook::GRAPH_SERVER}"
@@ -48,9 +48,9 @@ module Koala
     #
     # @param path the server path for this request
     # @param args (see Koala::Facebook::API#api)
-    # @param verb the HTTP method to use.  
+    # @param verb the HTTP method to use.
     #             If not get or post, this will be turned into a POST request with the appropriate :method
-    #             specified in the arguments.           
+    #             specified in the arguments.
     # @param options (see Koala::Facebook::API#api)
     #
     # @raise an appropriate connection error if unable to make the request to Facebook
@@ -63,23 +63,30 @@ module Koala
       # 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   
+      # 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 https if there's a token
+      if request_options[:use_ssl]
+        ssl = (request_options[:ssl] ||= {})
+        ssl[:verify] = true unless ssl.has_key?(:verify)
+      end
 
       # 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 : {}))
+
+      # Log URL information
+      Koala::Utils.debug "#{verb.upcase}: #{path} params: #{params.inspect}"
       Koala::HTTPService::Response.new(response.status.to_i, response.body, response.headers)
     end
 
-    # Encodes a given hash into a query string.  
+    # Encodes a given hash into a query string.
     # This is used mainly by the Batch API nowadays, since Faraday handles this for regular cases.
-    # 
+    #
     # @param params_hash a hash of values to CGI-encode and appropriately join
-    # 
+    #
     # @example
     #   Koala.http_service.encode_params({:a => 2, :b => "My String"})
     #   => "a=2&b=My+String"
@@ -91,10 +98,10 @@ module Koala
         "#{key_and_value[0].to_s}=#{CGI.escape key_and_value[1]}"
       end).join("&")
     end
-    
+
     # deprecations
     # not elegant or compact code, but temporary
-    
+
     # @private
     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.")
@@ -106,7 +113,7 @@ module Koala
       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
-    
+
     # @private
     def self.timeout
       Koala::Utils.deprecate("HTTPService.timeout is now HTTPService.http_options[:timeout]; .timeout will be removed in a future version.")
@@ -118,7 +125,7 @@ module Koala
       Koala::Utils.deprecate("HTTPService.timeout is now HTTPService.http_options[:timeout]; .timeout will be removed in a future version.")
       http_options[:timeout] = value
     end
-    
+
     # @private
     def self.timeout
       Koala::Utils.deprecate("HTTPService.timeout is now HTTPService.http_options[:timeout]; .timeout will be removed in a future version.")
@@ -130,7 +137,7 @@ module Koala
       Koala::Utils.deprecate("HTTPService.timeout is now HTTPService.http_options[:timeout]; .timeout will be removed in a future version.")
       http_options[:timeout] = value
     end
-    
+
     # @private
     def self.proxy
       Koala::Utils.deprecate("HTTPService.proxy is now HTTPService.http_options[:proxy]; .proxy will be removed in a future version.")
@@ -142,7 +149,7 @@ module Koala
       Koala::Utils.deprecate("HTTPService.proxy is now HTTPService.http_options[:proxy]; .proxy will be removed in a future version.")
       http_options[:proxy] = value
     end
-    
+
     # @private
     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.")
@@ -154,7 +161,7 @@ module Koala
       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
-    
+
     # @private
     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.")
@@ -179,14 +186,14 @@ module Koala
       (http_options[:ssl] ||= {})[:verify_mode] = value
     end
 
-    private 
-    
+    private
+
     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
@@ -201,11 +208,11 @@ module Koala
         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
   end
-  
+
   # @private
   module TyphoeusService
     def self.deprecated_interface

data/lib/koala/oauth.rb

@@ -325,6 +325,7 @@ module Koala
 
           components.merge(token_info) if token_info
         else
+          Koala::Utils.logger.warn("Signed cookie didn't contain Facebook OAuth code! Components: #{components}")
           nil
         end
       end

data/lib/koala/utils.rb

@@ -1,12 +1,27 @@
 module Koala
   module Utils
 
+    # Utility methods used by Koala.
+    require 'logger'
+    require 'forwardable'
+
+    extend Forwardable
+    extend self
+
+    def_delegators :logger, :debug, :info, :warn, :error, :fatal, :level, :level=
+
+    # The Koala logger, an instance of the standard Ruby logger, pointing to STDOUT by default.
+    # In Rails projects, you can set this to Rails.logger.
+    attr_accessor :logger
+    self.logger = Logger.new(STDOUT)
+    self.logger.level = Logger::ERROR
+
     # @private
     DEPRECATION_PREFIX = "KOALA: Deprecation warning: "
 
-    # Prints a deprecation message.  
+    # Prints a deprecation message.
     # Each individual message will only be printed once to avoid spamming.
-    def self.deprecate(message)
+    def deprecate(message)
       @posted_deprecations ||= []
       unless @posted_deprecations.include?(message)
         # only include each message once

data/lib/koala/version.rb

@@ -1,3 +1,3 @@
 module Koala
-  VERSION = "1.4.1"
+  VERSION = "1.5.0rc1"
 end

data/readme.md

@@ -23,17 +23,17 @@ Or in Bundler:
 Graph API
 ----
 The Graph API is the simple, slick new interface to Facebook's data.  Using it with Koala is quite straightforward:
-  
+
     @graph = Koala::Facebook::API.new(oauth_access_token)
     # in 1.1 or earlier, use GraphAPI instead of API
-    
+
     profile = @graph.get_object("me")
     friends = @graph.get_connections("me", "friends")
-    @graph.put_object("me", "feed", :message => "I am writing on my wall!")
-   
+    @graph.put_connections("me", "feed", :message => "I am writing on my wall!")
+
     # three-part queries are easy too!
     @graph.get_connections("me", "mutualfriends/#{friend_id}")
-    
+
     # you can even use the new Timeline API
     # see https://developers.facebook.com/docs/beta/opengraph/tutorial/
     @graph.put_connections("me", "namespace:action", :object => object_url)
@@ -70,7 +70,7 @@ Fortunately, Koala supports the REST API using the very same interface; to use t
 
     @rest = Koala::Facebook::API.new(oauth_access_token)
     # in 1.1 or earlier, use RestAPI instead of API
-  	
+
   	@rest.fql_query(my_fql_query) # convenience method
   	@rest.fql_multiquery(fql_query_hash) # convenience method
   	@rest.rest_call("stream.publish", arguments_hash) # generic version
@@ -79,11 +79,11 @@ Of course, you can use the Graph API methods on the same object -- the power of
 
     @api = Koala::Facebook::API.new(oauth_access_token)
     # in 1.1 or earlier, use GraphAndRestAPI instead of API
-    
+
     @api = Koala::Facebook::API.new(oauth_access_token)
     fql = @api.fql_query(my_fql_query)
     @api.put_wall_post(process_result(fql))
-    
+
 
 OAuth
 -----
@@ -91,7 +91,7 @@ You can use the Graph and REST APIs without an OAuth access token, but the real
 
     @oauth = Koala::Facebook::OAuth.new(app_id, app_secret, callback_url)
 
-If your application uses Koala and the Facebook [JavaScript SDK](http://github.com/facebook/connect-js) (formerly Facebook Connect), you can use the OAuth class to parse the cookies:
+If your application uses Koala and the Facebook [JavaScript SDK](http://github.com/facebook/facebook-js-sdk) (formerly Facebook Connect), you can use the OAuth class to parse the cookies:
 
     @oauth.get_user_from_cookies(cookies) # gets the user's ID
 	  @oauth.get_user_info_from_cookies(cookies) # parses and returns the entire hash
@@ -166,7 +166,7 @@ Koala uses Faraday to make HTTP requests, which means you have complete control
     }
     # or on a per-request basis
     @api.get_object(id, args_hash, { :timeout => 10 })
-  
+
 The <a href="https://github.com/arsduo/koala/wiki/HTTP-Services">HTTP Services wiki page</a> has more information on what options are available, as well as on how to configure your own Faraday middleware stack (for instance, to implement request logging).
 
 See examples, ask questions

data/spec/cases/error_spec.rb

@@ -5,24 +5,27 @@ describe Koala::Facebook::APIError do
     Koala::Facebook::APIError.new.should be_a(StandardError)
   end
 
-  it "has an accessor for fb_error_type" do
-    Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:fb_error_type)
-    Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:fb_error_type=)
-  end
-
-  it "has an accessor for raw_response" do
-    Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:raw_response)
-    Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:raw_response=)
+  [:fb_error_type, :fb_error_code, :fb_error_message, :raw_response].each do |accessor|
+    it "has an accessor for #{accessor}" do
+      Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(accessor)
+      Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:"#{accessor}=")
+    end
   end
 
   it "sets raw_response to the provided error details" do
     error_response = {"type" => "foo", "other_details" => "bar"}
     Koala::Facebook::APIError.new(error_response).raw_response.should == error_response
   end
-  
-  it "sets fb_error_type to details['type']" do
-    type = "foo"
-    Koala::Facebook::APIError.new("type" => type).fb_error_type.should == type
+
+  {
+    :fb_error_type => 'type',
+    :fb_error_message => 'message',
+    :fb_error_code => 'code'
+  }.each_pair do |accessor, key|
+    it "sets #{accessor} to details['#{key}']" do
+      value = "foo"
+      Koala::Facebook::APIError.new(key => value).send(accessor).should == value
+    end
   end
 
   it "sets the error message details['type']: details['message']" do

data/spec/cases/graph_api_batch_spec.rb

@@ -381,6 +381,13 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
             }.to raise_exception(Koala::Facebook::APIError)
           end
 
+          it "raises an APIError if the body is empty" do
+            Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(200, "", {}))
+            expect {
+              Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
+            }.to raise_exception(Koala::Facebook::APIError)
+          end
+
           context "with the old style" do
             before :each do
               Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(200, '{"error":190,"error_description":"Error validating access token."}', {}))

data/spec/cases/graph_collection_spec.rb

@@ -13,11 +13,11 @@ describe Koala::Facebook::GraphCollection do
   it "subclasses Array" do
     Koala::Facebook::GraphCollection.ancestors.should include(Array)
   end
-  
+
   it "creates an array-like object" do
     Koala::Facebook::GraphCollection.new(@result, @api).should be_an(Array)
   end
-  
+
   it "contains the result data" do
     @result["data"].each_with_index {|r, i| @collection[i].should == r}
   end
@@ -26,19 +26,19 @@ describe Koala::Facebook::GraphCollection do
     @collection.methods.map(&:to_sym).should include(:paging)
     @collection.methods.map(&:to_sym).should_not include(:paging=)
   end
-  
+
   it "sets paging to results['paging']" do
     @collection.paging.should == @result["paging"]
   end
-  
+
   it "sets raw_response to the original results" do
     @collection.raw_response.should == @result
   end
-  
+
   it "sets the API to the provided API" do
     @collection.api.should == @api
   end
-    
+
   describe "when getting a whole page" do
     before(:each) do
       @second_page = {
@@ -87,16 +87,22 @@ describe Koala::Facebook::GraphCollection do
         @collection.parse_page_url(stub("url")).should == parsed_content
       end
     end
-    
-    describe ".parse_page_url" do    
+
+    describe ".parse_page_url" do
       it "should return the base as the first array entry" do
         base = "url_path"
-        Koala::Facebook::GraphCollection.parse_page_url("anything.com/#{base}?anything").first.should == base
+        Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/#{base}?anything").first.should == base
       end
 
       it "should return the arguments as a hash as the last array entry" do
         args_hash = {"one" => "val_one", "two" => "val_two"}
-        Koala::Facebook::GraphCollection.parse_page_url("anything.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last.should == args_hash
+        Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last.should == args_hash
+      end
+
+      it "works with non-.com addresses" do
+        base = "url_path"
+        args_hash = {"one" => "val_one", "two" => "val_two"}
+        Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/#{base}?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").should == [base, args_hash]
       end
     end
   end
@@ -106,22 +112,22 @@ describe Koala::Facebook::GraphCollection do
       result = []
       Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
     end
-    
+
     it "returns the original result if it's provided a nil result" do
       result = nil
       Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
     end
-    
+
     it "returns the original result if the result doesn't have a data key" do
       result = {"paging" => {}}
       Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
     end
-    
+
     it "returns the original result if the result's data key isn't an array" do
       result = {"data" => {}, "paging" => {}}
       Koala::Facebook::GraphCollection.evaluate(result, @api).should == result
     end
-        
+
     it "returns a new GraphCollection of the result if it has an array data key and a paging key" do
       result = {"data" => [], "paging" => {}}
       expected = :foo

data/spec/cases/http_service_spec.rb

@@ -10,7 +10,7 @@ describe "Koala::HTTPService" do
     Koala::HTTPService.should respond_to(:http_options)
     Koala::HTTPService.should respond_to(:http_options=)
   end
-  
+
   it "sets http_options to {} by default" do
     Koala::HTTPService.http_options.should == {}
   end
@@ -123,10 +123,10 @@ describe "Koala::HTTPService" do
         val.should == CGI.escape(args[key])
       end
     end
-    
+
     it "encodes parameters in alphabetical order" do
       args = {:b => '2', 'a' => '1'}
-      
+
       result = Koala::HTTPService.encode_params(args)
       result.split('&').map{|key_val| key_val.split('=')[0]}.should == ['a', 'b']
     end
@@ -184,33 +184,44 @@ describe "Koala::HTTPService" do
         Faraday.should_receive(:new).with(anything, hash_including(http_options.merge(options))).and_return(@mock_connection)
         Koala::HTTPService.make_request("anything", {}, "get", options)
       end
-      
+
       it "forces use_ssl to true if an access token is present" do
         options = {:use_ssl => false}
         Koala::HTTPService.stub(:http_options).and_return(:use_ssl => false)
-        Faraday.should_receive(:new).with(anything, hash_including(:use_ssl => true)).and_return(@mock_connection)
+        Faraday.should_receive(:new).with(anything, hash_including(:use_ssl => true, :ssl => {:verify => true})).and_return(@mock_connection)
         Koala::HTTPService.make_request("anything", {"access_token" => "foo"}, "get", options)
       end
-      
+
+      it "defaults verify to true if use_ssl is true" do
+        Faraday.should_receive(:new).with(anything, hash_including(:ssl => {:verify => true})).and_return(@mock_connection)
+        Koala::HTTPService.make_request("anything", {"access_token" => "foo"}, "get")
+      end
+
+      it "allows you to set other verify modes if you really want" do
+        options = {:ssl => {:verify => :foo}}
+        Faraday.should_receive(:new).with(anything, hash_including(options)).and_return(@mock_connection)
+        Koala::HTTPService.make_request("anything", {"access_token" => "foo"}, "get", options)
+      end
+
       it "calls server with the composite options" do
         options = {:a => 2, :c => "3"}
         http_options = {:a => :a}
         Koala::HTTPService.stub(:http_options).and_return(http_options)
         Koala::HTTPService.should_receive(:server).with(hash_including(http_options.merge(options))).and_return("foo")
-        Koala::HTTPService.make_request("anything", {}, "get", options)        
+        Koala::HTTPService.make_request("anything", {}, "get", options)
       end
 
       it "uses the default builder block if HTTPService.faraday_middleware block is not defined" do
-        Koala::HTTPService.stub(:faraday_middleware).and_return(nil)        
+        Koala::HTTPService.stub(:faraday_middleware).and_return(nil)
         Faraday.should_receive(:new).with(anything, anything, &Koala::HTTPService::DEFAULT_MIDDLEWARE).and_return(@mock_connection)
-        Koala::HTTPService.make_request("anything", {}, "get")        
+        Koala::HTTPService.make_request("anything", {}, "get")
       end
-      
+
       it "uses the defined HTTPService.faraday_middleware block if defined" do
         block = Proc.new { }
         Koala::HTTPService.should_receive(:faraday_middleware).and_return(block)
         Faraday.should_receive(:new).with(anything, anything, &block).and_return(@mock_connection)
-        Koala::HTTPService.make_request("anything", {}, "get")        
+        Koala::HTTPService.make_request("anything", {}, "get")
       end
     end
 
@@ -244,6 +255,21 @@ describe "Koala::HTTPService" do
         @mock_connection.should_receive(:get).with(anything, {}).and_return(@mock_http_response)
         Koala::HTTPService.make_request("anything", args, "get")
       end
+
+      it "logs verb, url and params to debug" do
+        args = {"a" => :b, "c" => 3}
+        log_message_stem = "GET: anything params: "
+        Koala::Utils.logger.should_receive(:debug) do |log_message|
+          # unordered hashes are a bane
+          # Ruby in 1.8 modes tends to return different hash orderings,
+          # which makes checking the content of the stringified hash hard
+          # it's enough just to ensure that there's hash content in the string, I think
+          log_message.should include(log_message_stem)
+          log_message.match(/\{.*\}/).should_not be_nil
+        end
+
+        Koala::HTTPService.make_request("anything", args, "get")
+      end
     end
 
     describe "for POSTs" do
@@ -262,6 +288,20 @@ describe "Koala::HTTPService" do
         @mock_connection.should_receive(:post).with(anything, hash_including("source" => upload_io)).and_return(@mock_http_response)
         Koala::HTTPService.make_request("anything", {:source => u}, "post")
       end
+
+      it "logs verb, url and params to debug" do
+        args = {"a" => :b, "c" => 3}
+        log_message_stem = "POST: anything params: "
+        Koala::Utils.logger.should_receive(:debug) do |log_message|
+          # unordered hashes are a bane
+          # Ruby in 1.8 modes tends to return different hash orderings,
+          # which makes checking the content of the stringified hash hard
+          # it's enough just to ensure that there's hash content in the string, I think
+          log_message.should include(log_message_stem)
+          log_message.match(/\{.*\}/).should_not be_nil
+        end
+        Koala::HTTPService.make_request("anything", args, "post")
+      end
     end
   end
 
@@ -274,11 +314,11 @@ describe "Koala::HTTPService" do
     after :each do
       Koala.http_service = @service
     end
-    
+
     {
       :timeout => :timeout,
       :always_use_ssl => :use_ssl,
-      :proxy => :proxy 
+      :proxy => :proxy
     }.each_pair do |deprecated_method, parameter|
       describe ".#{deprecated_method}" do
         context "read" do
@@ -287,13 +327,13 @@ describe "Koala::HTTPService" do
             Koala::HTTPService.http_options[parameter] = value
             Koala::HTTPService.send(deprecated_method).should == value
           end
-      
+
           it "generates a deprecation warning" do
             Koala::Utils.should_receive(:deprecate)
             Koala::HTTPService.send(deprecated_method)
           end
         end
-      
+
         context "write" do
           it "writes to http_options[:#{parameter}]" do
             Koala::HTTPService.http_options[parameter] = nil
@@ -301,7 +341,7 @@ describe "Koala::HTTPService" do
             Koala::HTTPService.send(:"#{deprecated_method}=", value)
             Koala::HTTPService.http_options[parameter].should == value
           end
-      
+
           it "generates a deprecation warning" do
             Koala::Utils.should_receive(:deprecate)
             Koala::HTTPService.send(:"#{deprecated_method}=", 2)
@@ -309,7 +349,7 @@ describe "Koala::HTTPService" do
         end
       end
     end
-    
+
     # ssl options
     [:ca_path, :ca_file, :verify_mode].each do |deprecated_method|
       describe ".#{deprecated_method}" do
@@ -319,7 +359,7 @@ describe "Koala::HTTPService" do
             Koala::HTTPService.http_options[:ssl] = {deprecated_method => value}
             Koala::HTTPService.send(deprecated_method).should == value
           end
-      
+
           it "returns nil if http_options[:ssl] is not defined" do
             Koala::HTTPService.send(deprecated_method).should be_nil
           end
@@ -329,8 +369,8 @@ describe "Koala::HTTPService" do
             Koala::HTTPService.send(deprecated_method)
           end
         end
-      
-        context "write" do      
+
+        context "write" do
           it "defines http_options[:ssl] if not defined" do
             Koala::HTTPService.http_options[:ssl] = nil
             value = "foo"
@@ -344,14 +384,14 @@ describe "Koala::HTTPService" do
             Koala::HTTPService.http_options[:ssl].should
             Koala::HTTPService.http_options[:ssl][deprecated_method].should == value
           end
-          
+
           it "does not redefine http_options[:ssl] if already defined" do
             hash = {:a => 2}
             Koala::HTTPService.http_options[:ssl] = hash
             Koala::HTTPService.send(:"#{deprecated_method}=", 3)
             Koala::HTTPService.http_options[:ssl].should include(hash)
           end
-                
+
           it "generates a deprecation warning" do
             Koala::Utils.should_receive(:deprecate)
             Koala::HTTPService.send(:"#{deprecated_method}=", 2)
@@ -359,7 +399,7 @@ describe "Koala::HTTPService" do
         end
       end
     end
-    
+
     describe "per-request options" do
       before :each do
         # Setup stubs for make_request to execute without exceptions
@@ -372,18 +412,18 @@ describe "Koala::HTTPService" do
         @mock_connection.stub(:post).and_return(@mock_http_response)
         Faraday.stub(:new).and_return(@mock_connection)
       end
-      
+
       describe ":typhoeus_options" do
         it "merges any typhoeus_options into options" do
           typhoeus_options = {:a => 2}
           Faraday.should_receive(:new).with(anything, hash_including(typhoeus_options)).and_return(@mock_connection)
-          Koala::HTTPService.make_request("anything", {}, "get", :typhoeus_options => typhoeus_options)          
+          Koala::HTTPService.make_request("anything", {}, "get", :typhoeus_options => typhoeus_options)
         end
-        
+
         it "deletes the typhoeus_options key" do
           typhoeus_options = {:a => 2}
           Faraday.should_receive(:new).with(anything, hash_not_including(:typhoeus_options => typhoeus_options)).and_return(@mock_connection)
-          Koala::HTTPService.make_request("anything", {}, "get", :typhoeus_options => typhoeus_options)          
+          Koala::HTTPService.make_request("anything", {}, "get", :typhoeus_options => typhoeus_options)
         end
       end
 
@@ -400,7 +440,7 @@ describe "Koala::HTTPService" do
           Koala::HTTPService.make_request("anything", {}, "get", :ca_path => ca_path)
         end
       end
-      
+
       describe ":ca_file" do
         it "sets any ca_file into options[:ssl]" do
           ca_file = :foo
@@ -414,7 +454,7 @@ describe "Koala::HTTPService" do
           Koala::HTTPService.make_request("anything", {}, "get", :ca_file => ca_file)
         end
       end
-      
+
       describe ":verify_mode" do
         it "sets any verify_mode into options[:ssl]" do
           verify_mode = :foo

data/spec/cases/oauth_spec.rb

@@ -98,6 +98,12 @@ describe "Koala::Facebook::OAuth" do
             @oauth.stub(:parse_signed_request).and_return({})
             @oauth.get_user_info_from_cookies(@cookie).should be_nil
           end
+
+          it "logs a warning" do
+            @oauth.stub(:parse_signed_request).and_return({})
+            Koala::Utils.logger.should_receive(:warn)
+            @oauth.get_user_info_from_cookies(@cookie)
+          end
         end
 
         context "if the code is present" do

data/spec/cases/utils_spec.rb

@@ -31,4 +31,25 @@ describe Koala::Utils do
       Koala::Utils.deprecate(message)
     end
   end
+  
+  describe ".logger" do
+    it "has an accessor for logger" do
+      Koala::Utils.methods.map(&:to_sym).should include(:logger)
+      Koala::Utils.methods.map(&:to_sym).should include(:logger=)
+    end
+    
+    it "defaults to the standard ruby logger with level set to ERROR" do |variable|
+      Koala::Utils.logger.should be_kind_of(Logger)
+      Koala::Utils.logger.level.should == Logger::ERROR
+    end
+    
+    logger_methods = [:debug, :info, :warn, :error, :fatal]
+    
+    logger_methods.each do |logger_method|
+      it "should delegate #{logger_method} to the attached logger" do
+        Koala::Utils.logger.should_receive(logger_method)
+        Koala::Utils.send(logger_method, "Test #{logger_method} message")
+      end
+    end
+  end
 end

data/spec/fixtures/mock_facebook_responses.yml

@@ -42,11 +42,11 @@ graph_api:
 
   # OAuth error response
   oauth_error: &oauth_error
-    no_token: '{"error": {"type": "OAuthException", "message": "Error validating verification code."}}'
+    no_token: '{"error": {"code"=>2500, "type": "OAuthException", "message": "Error validating verification code."}}'
 
   # Subscription error response
   verification_error: &verification_error
-    with_token: '{"error": {"type": "OAuthException", "message": "Error validating verification code."}}'
+    with_token: '{"error": {"code"=>2500, "type": "OAuthException", "message": "Error validating verification code."}}'
 
   test_user_uninstalled: &test_user_uninstalled
     post:

data/spec/support/graph_api_shared_examples.rb

@@ -592,10 +592,13 @@ shared_examples_for "Koala GraphAPI without an access token" do
   end
 
   it "can't put an object" do
+    lambda { @result = @api.put_connections(KoalaTest.user2, "feed", :message => "Hello, world") }.should raise_error(Koala::Facebook::APIError)
+    # legacy put_object syntax
     lambda { @result = @api.put_object(KoalaTest.user2, "feed", :message => "Hello, world") }.should raise_error(Koala::Facebook::APIError)
   end
 
-  # these are not strictly necessary as the other put methods resolve to put_object, but are here for completeness
+  # these are not strictly necessary as the other put methods resolve to put_connections,
+  # but are here for completeness
   it "can't post to a feed" do
     (lambda do
       attachment = {:name => "OAuth Playground", :link => "http://oauth.twoalex.com/"}

data/spec/support/ordered_hash.rb

@@ -1,7 +1,7 @@
 module KoalaTest
   # directly taken from Rails 3.1's OrderedHash
   # see https://github.com/rails/rails/blob/master/activesupport/lib/active_support/ordered_hash.rb
-  
+
   # The order of iteration over hashes in Ruby 1.8 is undefined. For example, you do not know the
   # order in which +keys+ will return keys, or +each+ yield pairs. <tt>ActiveSupport::OrderedHash</tt>
   # implements a hash that preserves insertion order, as in Ruby 1.9:
@@ -192,10 +192,6 @@ module KoalaTest
         OrderedHash[self.to_a.map!{|key_value_pair| key_value_pair.reverse}]
       end
 
-      def inspect
-        "#<OrderedHash #{super}>"
-      end
-
       private
         def sync_keys!
           @keys.delete_if {|k| !has_key?(k)}

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: koala
 version: !ruby/object:Gem::Version
-  version: 1.4.1
-  prerelease: 
+  version: 1.5.0rc1
+  prerelease: 5
 platform: ruby
 authors:
 - Alex Koppel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-19 00:00:00.000000000 Z
+date: 2012-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -34,7 +34,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: '0.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,7 +42,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: '0.7'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -50,7 +50,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.8.0rc1
+        version: '2.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -58,7 +58,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.8.0rc1
+        version: '2.8'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -66,7 +66,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.7
+        version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -74,7 +74,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.7
+        version: '0.8'
 description: Koala is a lightweight, flexible Ruby SDK for Facebook.  It allows read/write
   access to the social graph via the Graph and REST APIs, as well as support for realtime
   updates and OAuth and Facebook Connect authentication.  Koala is fully tested and
@@ -163,13 +163,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3018714754119846442
+      hash: 2822012277760002951
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '1.2'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.21