koala 1.5.0 → 1.6.0

data/lib/koala/api/graph_api.rb

@@ -1,3 +1,5 @@
+require 'addressable/uri'
+
 require 'koala/api/graph_collection'
 require 'koala/http_service/uploadable_io'
 
@@ -40,13 +42,20 @@ module Koala
       # @param args any additional arguments
       #         (fields, metadata, etc. -- see {http://developers.facebook.com/docs/reference/api/ Facebook's documentation})
       # @param options (see Koala::Facebook::API#api)
+      # @param block for post-processing. It receives the result data; the
+      #        return value of the method is the result of the block, if
+      #        provided.  (see Koala::Facebook::API#api)
       #
       # @raise [Koala::Facebook::APIError] if the ID is invalid or you don't have access to that object
       #
+      # @example
+      #     get_object("me")  # => {"id" => ..., "name" => ...}
+      #     get_object("me") {|data| data['education']}  # => only education section of profile
+      #
       # @return a hash of object data
-      def get_object(id, args = {}, options = {})
-        # Fetchs the given object from the graph.
-        graph_call(id, args, "get", options)
+      def get_object(id, args = {}, options = {}, &block)
+        # Fetches the given object from the graph.
+        graph_call(id, args, "get", options, &block)
       end
 
       # Get information about multiple Facebook objects in one call.
@@ -54,15 +63,16 @@ module Koala
       # @param ids an array or comma-separated string of object IDs
       # @param args (see #get_object)
       # @param options (see Koala::Facebook::API#api)
+      # @param block (see Koala::Facebook::API#api)
       #
       # @raise [Koala::Facebook::APIError] if any ID is invalid or you don't have access to that object
       #
       # @return an array of object data hashes
-      def get_objects(ids, args = {}, options = {})
-        # Fetchs all of the given objects from the graph.
+      def get_objects(ids, args = {}, options = {}, &block)
+        # Fetches all of the given objects from the graph.
         # If any of the IDs are invalid, they'll raise an exception.
         return [] if ids.empty?
-        graph_call("", args.merge("ids" => ids.respond_to?(:join) ? ids.join(",") : ids), "get", options)
+        graph_call("", args.merge("ids" => ids.respond_to?(:join) ? ids.join(",") : ids), "get", options, &block)
       end
 
       # Write an object to the Graph for a specific user.
@@ -71,20 +81,21 @@ module Koala
       # @note put_object is (for historical reasons) the same as put_connections.
       #       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 = {})
-        put_connections(parent_object, connection_name, args, options)
+      def put_object(parent_object, connection_name, args = {}, options = {}, &block)
+        put_connections(parent_object, connection_name, args, options, &block)
       end
 
       # Delete an object from the Graph if you have appropriate permissions.
       #
       # @param id (see #get_object)
       # @param options (see #get_object)
+      # @param block (see Koala::Facebook::API#api)
       #
       # @return true if successful, false (or an APIError) if not
-      def delete_object(id, options = {})
+      def delete_object(id, options = {}, &block)
         # Deletes the object with the given ID from the graph.
-        raise APIError.new({"type" => "KoalaMissingAccessToken", "message" => "Delete requires an access token"}) unless @access_token
-        graph_call(id, {}, "delete", options)
+        raise AuthenticationError.new(nil, nil, "Delete requires an access token") unless @access_token
+        graph_call(id, {}, "delete", options, &block)
       end
 
       # Fetch information about a given connection (e.g. type of activity -- feed, events, photos, etc.)
@@ -98,11 +109,12 @@ module Koala
       # @param connection_name what
       # @param args any additional arguments
       # @param options (see #get_object)
+      # @param block (see Koala::Facebook::API#api)
       #
       # @return [Koala::Facebook::API::GraphCollection] an array of object hashes (in most cases)
-      def get_connection(id, connection_name, args = {}, options = {})
-        # Fetchs the connections for given object.
-        graph_call("#{id}/#{connection_name}", args, "get", options)
+      def get_connection(id, connection_name, args = {}, options = {}, &block)
+        # Fetches the connections for given object.
+        graph_call("#{id}/#{connection_name}", args, "get", options, &block)
       end
       alias_method :get_connections, :get_connection
 
@@ -126,12 +138,13 @@ module Koala
       # @param connection_name (see #get_connection)
       # @param args (see #get_connection)
       # @param options (see #get_object)
+      # @param block (see Koala::Facebook::API#api)
       #
       # @return a hash containing the new object's id
-      def put_connections(id, connection_name, args = {}, options = {})
+      def put_connections(id, connection_name, args = {}, options = {}, &block)
         # Posts a certain connection
-        raise APIError.new({"type" => "KoalaMissingAccessToken", "message" => "Write operations require an access token"}) unless @access_token
-        graph_call("#{id}/#{connection_name}", args, "post", options)
+        raise AuthenticationError.new(nil, nil, "Write operations require an access token") unless @access_token
+        graph_call("#{id}/#{connection_name}", args, "post", options, &block)
       end
 
       # Delete an object's connection (for instance, unliking the object).
@@ -142,12 +155,13 @@ module Koala
       # @param connection_name (see #get_connection)
       # @args (see #get_connection)
       # @param options (see #get_object)
+      # @param block (see Koala::Facebook::API#api)
       #
       # @return (see #delete_object)
-      def delete_connections(id, connection_name, args = {}, options = {})
+      def delete_connections(id, connection_name, args = {}, options = {}, &block)
         # Deletes a given connection
-        raise APIError.new({"type" => "KoalaMissingAccessToken", "message" => "Delete requires an access token"}) unless @access_token
-        graph_call("#{id}/#{connection_name}", args, "delete", options)
+        raise AuthenticationError.new(nil, nil, "Delete requires an access token") unless @access_token
+        graph_call("#{id}/#{connection_name}", args, "delete", options, &block)
       end
 
       # Fetches a photo.
@@ -156,15 +170,17 @@ module Koala
       #
       # @param options options for Facebook (see #get_object).
       #                        To get a different size photo, pass :type => size (small, normal, large, square).
+      # @param block (see Koala::Facebook::API#api)
       #
       # @note to delete photos or videos, use delete_object(id)
       #
       # @return the URL to the image
-      def get_picture(object, args = {}, options = {})
+      def get_picture(object, args = {}, options = {}, &block)
         # Gets a picture object, returning the URL (which Facebook sends as a header)
-        graph_call("#{object}/picture", args, "get", options.merge(:http_component => :headers)) do |result|
+        resolved_result = graph_call("#{object}/picture", args, "get", options.merge(:http_component => :headers)) do |result|
           result["Location"]
         end
+        block ? block.call(resolved_result) : resolved_result
       end
 
       # Upload a photo.
@@ -180,6 +196,7 @@ module Koala
       # @param args (see #get_object)
       # @param target_id the Facebook object to which to post the picture (default: "me")
       # @param options (see #get_object)
+      # @param block (see Koala::Facebook::API#api)
       #
       # @example
       #     put_picture(file, content_type, {:message => "Message"}, 01234560)
@@ -190,16 +207,16 @@ module Koala
       # @note to access the media after upload, you'll need the user_photos or user_videos permission as appropriate.
       #
       # @return (see #put_connections)
-      def put_picture(*picture_args)
-        put_connections(*parse_media_args(picture_args, "photos"))
+      def put_picture(*picture_args, &block)
+        put_connections(*parse_media_args(picture_args, "photos"), &block)
       end
 
       # Upload a video.  Functions exactly the same as put_picture.
       # @see #put_picture
-      def put_video(*video_args)
+      def put_video(*video_args, &block)
         args = parse_media_args(video_args, "videos")
         args.last[:video] = true
-        put_connections(*args)
+        put_connections(*args, &block)
       end
 
       # Write directly to the user's wall.
@@ -213,6 +230,7 @@ module Koala
       #         (see the {https://developers.facebook.com/docs/guides/attachments/ stream attachments} documentation.)
       # @param target_id the target wall
       # @param options (see #get_object)
+      # @param block (see Koala::Facebook::API#api)
       #
       # @example
       #       @api.put_wall_post("Hello there!", {
@@ -225,8 +243,8 @@ module Koala
       #
       # @see #put_connections
       # @return (see #put_connections)
-      def put_wall_post(message, attachment = {}, target_id = "me", options = {})
-        put_connections(target_id, "feed", attachment.merge({:message => message}), options)
+      def put_wall_post(message, attachment = {}, target_id = "me", options = {}, &block)
+        put_connections(target_id, "feed", attachment.merge({:message => message}), options, &block)
       end
 
       # Comment on a given object.
@@ -238,11 +256,12 @@ module Koala
       # @param id (see #get_object)
       # @param message the comment to write
       # @param options (see #get_object)
+      # @param block (see Koala::Facebook::API#api)
       #
       # @return (see #put_connections)
-      def put_comment(id, message, options = {})
+      def put_comment(id, message, options = {}, &block)
         # Writes the given comment on the given post.
-        put_connections(id, "comments", {:message => message}, options)
+        put_connections(id, "comments", {:message => message}, options, &block)
       end
 
       # Like a given object.
@@ -252,11 +271,12 @@ module Koala
       #
       # @param id (see #get_object)
       # @param options (see #get_object)
+      # @param block (see Koala::Facebook::API#api)
       #
       # @return (see #put_connections)
-      def put_like(id, options = {})
+      def put_like(id, options = {}, &block)
         # Likes the given post.
-        put_connections(id, "likes", {}, options)
+        put_connections(id, "likes", {}, options, &block)
       end
 
       # Unlike a given object.
@@ -264,12 +284,13 @@ module Koala
       #
       # @param id (see #get_object)
       # @param options (see #get_object)
+      # @param block (see Koala::Facebook::API#api)
       #
       # @return (see #delete_object)
-      def delete_like(id, options = {})
+      def delete_like(id, options = {}, &block)
         # Unlikes a given object for the logged-in user
-        raise APIError.new({"type" => "KoalaMissingAccessToken", "message" => "Unliking requires an access token"}) unless @access_token
-        graph_call("#{id}/likes", {}, "delete", options)
+        raise AuthenticationError.new(nil, nil, "Unliking requires an access token") unless @access_token
+        graph_call("#{id}/likes", {}, "delete", options, &block)
       end
 
       # Search for a given query among visible Facebook objects.
@@ -278,11 +299,12 @@ module Koala
       # @param search_terms the query to search for
       # @param args additional arguments, such as type, fields, etc.
       # @param options (see #get_object)
+      # @param block (see Koala::Facebook::API#api)
       #
       # @return [Koala::Facebook::API::GraphCollection] an array of search results
-      def search(search_terms, args = {}, options = {})
+      def search(search_terms, args = {}, options = {}, &block)
         args.merge!({:q => search_terms}) unless search_terms.nil?
-        graph_call("search", args, "get", options)
+        graph_call("search", args, "get", options, &block)
       end
 
       # Convenience Methods
@@ -296,8 +318,11 @@ module Koala
       # @param query the FQL query to perform
       # @param args (see #get_object)
       # @param options (see #get_object)
-      def fql_query(query, args = {}, options = {})
-        get_object("fql", args.merge(:q => query), options)
+      # @param block (see Koala::Facebook::API#api)
+      #
+      # @return the result of the FQL query.
+      def fql_query(query, args = {}, options = {}, &block)
+        get_object("fql", args.merge(:q => query), options, &block)
       end
 
       # Make an FQL multiquery.
@@ -306,6 +331,7 @@ module Koala
       # @param queries a hash of query names => FQL queries
       # @param args (see #get_object)
       # @param options (see #get_object)
+      # @param block (see Koala::Facebook::API#api)
       #
       # @example
       #     @api.fql_multiquery({
@@ -316,11 +342,13 @@ module Koala
       #     # instead of [{"name":"query1", "fql_result_set":[]},{"name":"query2", "fql_result_set":[]}]
       #
       # @return a hash of FQL results keyed to the appropriate query
-      def fql_multiquery(queries = {}, args = {}, options = {})
-        if results = get_object("fql", args.merge(:q => MultiJson.dump(queries)), options)
+      def fql_multiquery(queries = {}, args = {}, options = {}, &block)
+        resolved_results = if results = get_object("fql", args.merge(:q => MultiJson.dump(queries)), options)
           # simplify the multiquery result format
           results.inject({}) {|outcome, data| outcome[data["name"]] = data["fql_result_set"]; outcome}
         end
+
+        block ? block.call(resolved_results) : resolved_results
       end
 
       # Get a page's access token, allowing you to act as the page.
@@ -329,30 +357,34 @@ module Koala
       # @param id the page ID
       # @param args (see #get_object)
       # @param options (see #get_object)
+      # @param block (see Koala::Facebook::API#api)
       #
       # @return the page's access token (discarding expiration and any other information)
-      def get_page_access_token(id, args = {}, options = {})
-        result = get_object(id, args.merge(:fields => "access_token"), options) do
+      def get_page_access_token(id, args = {}, options = {}, &block)
+        access_token = get_object(id, args.merge(:fields => "access_token"), options) do |result|
           result ? result["access_token"] : nil
         end
+
+        block ? block.call(access_token) : access_token
       end
 
-      # Fetchs the comments from fb:comments widgets for a given set of URLs (array or comma-separated string).
+      # Fetches the comments from fb:comments widgets for a given set of URLs (array or comma-separated string).
       # See https://developers.facebook.com/blog/post/490.
       #
       # @param urls the URLs for which you want comments
       # @param args (see #get_object)
       # @param options (see #get_object)
+      # @param block (see Koala::Facebook::API#api)
       #
       # @returns a hash of urls => comment arrays
-      def get_comments_for_urls(urls = [], args = {}, options = {})
+      def get_comments_for_urls(urls = [], args = {}, options = {}, &block)
         return [] if urls.empty?
         args.merge!(:ids => urls.respond_to?(:join) ? urls.join(",") : urls)
-        get_object("comments", args, options)
+        get_object("comments", args, options, &block)
       end
 
-      def set_app_restrictions(app_id, restrictions_hash, args = {}, options = {})
-        graph_call(app_id, args.merge(:restrictions => MultiJson.dump(restrictions_hash)), "post", options)
+      def set_app_restrictions(app_id, restrictions_hash, args = {}, options = {}, &block)
+        graph_call(app_id, args.merge(:restrictions => MultiJson.dump(restrictions_hash)), "post", options, &block)
       end
 
       # Certain calls such as {#get_connections} return an array of results which you can page through
@@ -364,10 +396,11 @@ module Koala
       #
       # @param params an array of arguments to graph_call
       #               as returned by {Koala::Facebook::GraphCollection.parse_page_url}.
+      # @param block (see Koala::Facebook::API#api)
       #
       # @return Koala::Facebook::GraphCollection the appropriate page of results (an empty array if there are none)
-      def get_page(params)
-        graph_call(*params)
+      def get_page(params, &block)
+        graph_call(*params, &block)
       end
 
       # Execute a set of Graph API calls as a batch.
@@ -386,10 +419,21 @@ module Koala
       #
       # @example
       #         results = @api.batch do |batch_api|
-      #          batch_api.get_object('me')
-      #          batch_api.get_object(KoalaTest.user1)
+      #           batch_api.get_object('me')
+      #           batch_api.get_object(KoalaTest.user1)
+      #         end
+      #         # => [{'id' => my_id, ...}, {'id' => koppel_id, ...}]
+      #
+      #         # You can also provide blocks to your operations to process the
+      #         # results, which is often useful if you're constructing batch
+      #         # requests in various locations and want to keep the code
+      #         # together in logical places.
+      #         # See readme.md and the wiki for more examples.
+      #         @api.batch do |batch_api|
+      #           batch_api.get_object('me') {|data| data["id"] }
+      #           batch_api.get_object(KoalaTest.user1) {|data| data["name"] }
       #         end
-      #         # => [{"id" => my_id, ...}, {"id"" => koppel_id, ...}]
+      #         # => [my_id, "Alex Koppel"]
       #
       # @return an array of results from your batch calls (as if you'd made them individually),
       #         arranged in the same order they're made.
@@ -422,7 +466,7 @@ module Koala
       # @return the result from Facebook
       def graph_call(path, args = {}, verb = "get", options = {}, &post_processing)
         result = api(path, args, verb, options) do |response|
-          error = check_response(response)
+          error = check_response(response.status, response.body)
           raise error if error
         end
 
@@ -435,12 +479,38 @@ module Koala
 
       private
 
-      def check_response(response)
-        # check for Graph API-specific errors
-        # this returns an error, which is immediately raised (non-batch)
-        # or added to the list of batch results (batch)
-        if response.is_a?(Hash) && error_details = response["error"]
-          APIError.new(error_details)
+      def check_response(http_status, response_body)
+        # Check for Graph API-specific errors. This returns an error of the appropriate type
+        # which is immediately raised (non-batch) or added to the list of batch results (batch)
+        http_status = http_status.to_i
+
+        if http_status >= 400
+          begin
+            response_hash = MultiJson.load(response_body)
+          rescue MultiJson::DecodeError
+            response_hash = {}
+          end
+
+          if response_hash['error_code']
+            # Old batch api error format. This can be removed on July 5, 2012.
+            # See https://developers.facebook.com/roadmap/#graph-batch-api-exception-format
+            error_info = {
+              'code' => response_hash['error_code'],
+              'message' => response_hash['error_description']
+            }
+          else
+            error_info = response_hash['error'] || {}
+          end
+
+          if error_info['type'] == 'OAuthException' &&
+             ( !error_info['code'] || [102, 190, 450, 452, 2500].include?(error_info['code'].to_i))
+
+            # See: https://developers.facebook.com/docs/authentication/access-token-expiration/
+            #      https://developers.facebook.com/bugs/319643234746794?browse=search_4fa075c0bd9117b20604672
+            AuthenticationError.new(http_status, response_body, error_info)
+          else
+            ClientError.new(http_status, response_body, error_info)
+          end
         end
       end
 
@@ -468,9 +538,9 @@ module Koala
       def url?(data)
         return false unless data.is_a? String
         begin
-          uri = URI.parse(data)
+          uri = Addressable::URI.parse(data)
           %w( http https ).include?(uri.scheme)
-        rescue URI::BadURIError
+        rescue Addressable::URI::InvalidURIError
           false
         end
       end

data/lib/koala/api/graph_batch_api.rb

@@ -19,35 +19,23 @@ module Koala
       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(
-            :url => path,
-            :args => args,
-            :method => verb,
-            :access_token => options['access_token'] || access_token,
-            :http_options => options,
-            :post_processing => post_processing
-          )
-          nil # batch operations return nothing immediately
+        # for batch APIs, we queue up the call details (incl. post-processing)
+        batch_calls << BatchOperation.new(
+          :url => path,
+          :args => args,
+          :method => verb,
+          :access_token => options['access_token'] || access_token,
+          :http_options => options,
+          :post_processing => post_processing
+        )
+        nil # batch operations return nothing immediately
       end
 
-      def check_graph_batch_api_response(response)
-        if response.is_a?(Hash) && response["error"] && !response["error"].is_a?(Hash)
-          # old error format -- see http://developers.facebook.com/blog/post/596/
-          APIError.new({"type" => "Error #{response["error"]}", "message" => response["error_description"]}.merge(response))
-        else
-          check_graph_api_response(response)
-        end
-      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
+      # redefine the graph_call method 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
 
-      alias_method :check_graph_api_response, :check_response
-      alias_method :check_response, :check_graph_batch_api_response
-
       # execute the queued batch calls
       def execute(http_options = {})
         return [] unless batch_calls.length > 0
@@ -62,7 +50,7 @@ module Koala
           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}"})
+            raise BadFacebookResponse.new(200, '', "Facebook returned an empty body")
           end
 
           # map the results with post-processing included
@@ -72,13 +60,16 @@ module Koala
             batch_op = batch_calls[index]
             index += 1
 
+            raw_result = nil
             if call_result
-              # (see note in regular api method about JSON parsing)
-              body = MultiJson.load("[#{call_result['body'].to_s}]")[0]
+              if ( error = check_response(call_result['code'], call_result['body'].to_s) )
+                raw_result = error
+              else
+                # (see note in regular api method about JSON parsing)
+                body = MultiJson.load("[#{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]
+                raw_result = case batch_op.http_options[:http_component]
                 when :status
                   call_result["code"].to_i
                 when :headers
@@ -87,20 +78,19 @@ module Koala
                 else
                   body
                 end
-
-                # process it if we are given a block to process with
-                batch_op.post_processing ? batch_op.post_processing.call(data) : data
-              else
-                error || APIError.new({"type" => "HTTP #{call_result["code"].to_s}", "message" => "Response body: #{body}"})
               end
+            end
+
+            # turn any results that are pageable into GraphCollections
+            # and pass to post-processing callback if given
+            result = GraphCollection.evaluate(raw_result, @original_api)
+            if batch_op.post_processing
+              batch_op.post_processing.call(result)
             else
-              nil
+              result
             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
 
     end

data/lib/koala/api/graph_collection.rb

@@ -1,3 +1,5 @@
+require 'addressable/uri'
+
 module Koala
   module Facebook
     class API
@@ -87,7 +89,7 @@ module Koala
         #
         # @return an array of parameters that can be provided via graph_call(*parsed_params)
         def self.parse_page_url(url)
-          uri = URI.parse(url)
+          uri = Addressable::URI.parse(url)
 
           base = uri.path.sub(/^\//, '')
           params = CGI.parse(uri.query)

data/lib/koala/api/rest_api.rb

@@ -21,7 +21,7 @@ module Koala
       #
       # @return true if successful, false if not.  (This call currently doesn't give useful feedback on failure.)
       def set_app_properties(properties, args = {}, options = {})
-        raise APIError.new({"type" => "KoalaMissingAccessToken", "message" => "setAppProperties requires an access token"}) unless @access_token
+        raise AuthenticationError.new(nil, nil, "setAppProperties requires an access token") unless @access_token
         rest_call("admin.setAppProperties", args.merge(:properties => MultiJson.dump(properties)), options, "post")
       end
 
@@ -44,8 +44,24 @@ module Koala
 
         api("method/#{fb_method}", args.merge('format' => 'json'), verb, options) do |response|
           # check for REST API-specific errors
-          if response.is_a?(Hash) && response["error_code"]
-            raise APIError.new("type" => response["error_code"], "message" => response["error_msg"])
+          if response.status >= 400
+            begin
+              response_hash = MultiJson.load(response.body)
+            rescue MultiJson::DecodeError
+              response_hash = {}
+            end
+
+            error_info = {
+              'code' => response_hash['error_code'],
+              'error_subcode' => response_hash['error_subcode'],
+              'message' => response_hash['error_msg']
+            }
+
+            if response.status >= 500
+              raise ServerError.new(response.status, response.body, error_info)
+            else
+              raise ClientError.new(response.status, response.body, error_info)
+            end
           end
         end
       end

data/lib/koala/api.rb

@@ -35,9 +35,9 @@ module Koala
       #                                    (All API requests with access tokens use SSL.)
       # @param error_checking_block a block to evaluate the response status for additional JSON-encoded errors
       #
-      # @yield The response body for evaluation
+      # @yield The response for evaluation
       #
-      # @raise [Koala::Facebook::APIError] if Facebook returns an error (response status >= 500)
+      # @raise [Koala::Facebook::ServerError] 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)
@@ -50,43 +50,23 @@ module Koala
         # make the request via the provided service
         result = Koala.make_request(path, args, verb, options)
 
-        # Check for any 500 errors before parsing the body
-        # since we're not guaranteed that the body is valid JSON
-        # in the case of a server error
-        raise APIError.new({"type" => "HTTP #{result.status.to_s}", "message" => "Response body: #{result.body}"}) if result.status >= 500
-
-        # parse the body as JSON and run it through the error checker (if provided)
-        # Note: Facebook sometimes sends results like "true" and "false", which aren't strictly objects
-        # and cause MultiJson.load to fail -- so we account for that by wrapping the result in []
-        body = MultiJson.load("[#{result.body.to_s}]")[0]
-        yield body if error_checking_block
+        if result.status.to_i >= 500
+          raise Koala::Facebook::ServerError.new(result.status.to_i, result.body)
+        end
+      
+        yield result if error_checking_block
 
         # if we want a component other than the body (e.g. redirect header for images), return that
         if component = options[:http_component]
           component == :response ? result : result.send(options[:http_component])
         else
-          body
+          # parse the body as JSON and run it through the error checker (if provided)
+          # Note: Facebook sometimes sends results like "true" and "false", which aren't strictly objects
+          # and cause MultiJson.load to fail -- so we account for that by wrapping the result in []
+          MultiJson.load("[#{result.body.to_s}]")[0]
         end
       end
     end
-
-    class APIError < StandardError
-      attr_accessor :fb_error_type, :fb_error_code, :fb_error_message, :raw_response
-
-      # 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.
-      #
-      # @param details error details containing "type" and "message" keys.
-      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
   end
 end