koala 2.5.0 → 3.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cb4d756e15fa642ec1e30f91d951f33d49c436f8
-  data.tar.gz: a3ba0cc83d91175c351ffccb09eef6078d299a28
+  metadata.gz: 04714e9f9ae4e70420567406530119f6560518d1
+  data.tar.gz: 92ec819da43149fc5de98f6ec931afc6736c8199
 SHA512:
-  metadata.gz: c67c06d0e2978428f01a8e4f6d245715a6486fc2b572a152f49fcaf58c53fafc570885bd9df88450cded73e6b90b2ce72f6802b947ebdbf02aad8b5f2e3ca97f
-  data.tar.gz: b65059fbac83cd3d891baf4ce84a92cd53926644877be4ac76d80cebd5fc8ae630cd2997721bfb998b5067eb05a2576e12156ab62cee32c0f2fe0318f5e0f5c4
+  metadata.gz: 51df761c7444da9dfb2c78b1fc30216b6fb3e5463c8e3bda322cae0f01e5e6fde5eecd62fc63f81527d25277972ff8ec00db71ca56aae9322bcfa626484e2470
+  data.tar.gz: f0545dd4651b30877186dd1f9bf3abe921a73a73f778980434536d4ad7923e17085fa64df53f7f449986d4fe5c460e08e6ceba605ddcc4a70de90c1ed21881c7

data/.travis.yml

@@ -6,12 +6,14 @@ rvm:
   - 2.0
   - 2.1
   - 2.2
-  - 2.3.0
+  - 2.3.1
   # Rubinius is failing due to segfaults on Travis (and takes significantly longer to run)
   # those builds will be restored later
   # jruby
-  - jruby-19mode
+  # - jruby-19mode
 bundler_args: --without development
 addons:
   code_climate:
     repo_token: 7af99d9225b4c14640f9ec3cb2e24d2f7103ac49417b0bd989188fb6c25f2909
+after_success:
+    - bundle exec codeclimate-test-reporter

data/Gemfile

@@ -15,7 +15,7 @@ group :test do
   gem "rspec", '~> 3.4'
   gem "vcr"
   gem "webmock"
-  gem "codeclimate-test-reporter", require: nil
+  gem "codeclimate-test-reporter", "~> 1.0.0", require: nil
 end
 
 gem "jruby-openssl" if defined? JRUBY_VERSION

data/changelog.md

@@ -1,3 +1,29 @@
+v3.0.0
+======
+
+Key breaking changes:
+
+* HTTPService.make_request now requires an HTTPService::Request object (Koala.make_request does
+  not)
+* HTTPService behavior *should not* change, but in edge cases might. (If so, please let me know.)
+* Empty response bodies in batch API calls will raise a JSON parse error rather than returning nil
+
+Removed features:
+
+* Removed support for the Rest API, since Facebook removed support for it (#568)
+* Removed support for FQL, which Facebook removed on August 8, 2016 (#569)
+* Removed legacy duplication of serveral constants in the Koala module (#569)
+
+Internal improvements:
+
+* Completely rewrote HTTPService.make_request and several others, extracting most logic into
+  HTTPService::Request (#566)
+* Use the more secure JSON.parse instead of JSON.load (thanks, lautis!) (#567)
+
+Testing improvements:
+
+* Fixed a bunch of failing specs
+
 v2.5.0
 ======
 

data/lib/koala/api/batch_operation.rb

@@ -1,4 +1,5 @@
 require 'koala/api'
+require 'koala/api/graph_batch_api'
 
 module Koala
   module Facebook
@@ -65,13 +66,13 @@ module Koala
         def process_binary_args
           # collect binary files
           @args.each_pair do |key, value|
-            if UploadableIO.binary_content?(value)
+            if HTTPService::UploadableIO.binary_content?(value)
               @files ||= {}
               # we use a class-level counter to ensure unique file identifiers across multiple batch operations
               # (this is thread safe, since we just care about uniqueness)
               # so remove the file from the original hash and add it to the file store
               id = "op#{identifier}_file#{@files.keys.length}"
-              @files[id] = @args.delete(key).is_a?(UploadableIO) ? value : UploadableIO.new(value)
+              @files[id] = @args.delete(key).is_a?(HTTPService::UploadableIO) ? value : HTTPService::UploadableIO.new(value)
             end
           end
         end
@@ -81,9 +82,5 @@ module Koala
         end
       end
     end
-
-    # @private
-    # legacy support for when BatchOperation lived directly under Koala::Facebook
-    BatchOperation = GraphBatchAPI::BatchOperation
   end
 end

data/lib/koala/api/graph_api.rb

@@ -359,45 +359,6 @@ module Koala
       # except to support cases where the Facebook API requires non-standard input
       # such as JSON-encoding arguments, posts directly to objects, etc.
 
-      # Make an FQL query.
-      # Convenience method equivalent to get_object("fql", :q => query).
-      #
-      # @param query the FQL query to perform
-      # @param args (see #get_object)
-      # @param options (see #get_object)
-      # @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.
-      # This method simplifies the result returned from multiquery into a more logical format.
-      #
-      # @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({
-      #       "query1" => "select post_id from stream where source_id = me()",
-      #       "query2" => "select fromid from comment where post_id in (select post_id from #query1)"
-      #     })
-      #     # returns {"query1" => [obj1, obj2, ...], "query2" => [obj3, ...]}
-      #     # 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 = {}, &block)
-        resolved_results = if results = get_object("fql", args.merge(:q => JSON.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.
       # Convenience method for @api.get_object(page_id, :fields => "access_token").
       #
@@ -463,13 +424,13 @@ module Koala
       # Those methods use get_page to request another set of results from Facebook.
       #
       # @note You'll rarely need to use this method unless you're using Sinatra or another non-Rails framework
-      #       (see {Koala::Facebook::GraphCollection GraphCollection} for more information).
+      #       (see {Koala::Facebook::API::GraphCollection GraphCollection} for more information).
       #
       # @param params an array of arguments to graph_call
-      #               as returned by {Koala::Facebook::GraphCollection.parse_page_url}.
+      #               as returned by {Koala::Facebook::API::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)
+      # @return Koala::Facebook::API::GraphCollection the appropriate page of results (an empty array if there are none)
       def get_page(params, &block)
         graph_call(*params, &block)
       end
@@ -529,7 +490,7 @@ module Koala
       # @yield response when making a batch API call, you can pass in a block
       #        that parses the results, allowing for cleaner code.
       #        The block's return value is returned in the batch results.
-      #        See the code for {#get_picture} or {#fql_multiquery} for examples.
+      #        See the code for {#get_picture} for examples.
       #        (Not needed in regular calls; you'll probably rarely use this.)
       #
       # @raise [Koala::Facebook::APIError] if Facebook returns an error
@@ -544,7 +505,7 @@ module Koala
         end
 
         # turn this into a GraphCollection if it's pageable
-        result = GraphCollection.evaluate(result, self)
+        result = API::GraphCollection.evaluate(result, self)
 
         # now process as appropriate for the given call (get picture header, etc.)
         post_processing ? post_processing.call(result) : result
@@ -573,7 +534,7 @@ module Koala
           fb_expected_arg_name = method == "photos" ? :url : :file_url
           args.merge!(fb_expected_arg_name => media_args.first)
         else
-          args["source"] = Koala::UploadableIO.new(*media_args.slice(0, 1 + args_offset))
+          args["source"] = Koala::HTTPService::UploadableIO.new(*media_args.slice(0, 1 + args_offset))
         end
 
         [target_id, method, args, options]

data/lib/koala/api/graph_batch_api.rb

@@ -75,7 +75,7 @@ module Koala
                 raw_result = error
               else
                 # (see note in regular api method about JSON parsing)
-                body = JSON.load("[#{call_result['body'].to_s}]")[0]
+                body = JSON.parse("[#{call_result['body'].to_s}]")[0]
 
                 # Get the HTTP component they want
                 raw_result = case batch_op.http_options[:http_component]
@@ -101,7 +101,6 @@ module Koala
           end
         end
       end
-
     end
   end
 end

data/lib/koala/api/graph_collection.rb

@@ -23,7 +23,7 @@ module Koala
         # @param api the Graph {Koala::Facebook::API API} instance to use to make calls
         #            (usually the API that made the original call).
         #
-        # @return [Koala::Facebook::GraphCollection] an initialized GraphCollection
+        # @return [Koala::Facebook::API::GraphCollection] an initialized GraphCollection
         #         whose paging, summary, raw_response, and api attributes are populated.
         def initialize(response, api)
           super response["data"]
@@ -113,9 +113,5 @@ module Koala
         end
       end
     end
-
-    # @private
-    # legacy support for when GraphCollection lived directly under Koala::Facebook
-    GraphCollection = API::GraphCollection
   end
 end

data/lib/koala/api/graph_error_checker.rb

@@ -61,7 +61,7 @@ module Koala
         # Normally, we start with the response body. If it isn't valid JSON, we start with an empty
         # hash and fill it with error data.
         @response_hash ||= begin
-          JSON.load(body)
+          JSON.parse(body)
         rescue JSON::ParserError
           {}
         end

data/lib/koala/api.rb

@@ -1,6 +1,6 @@
 # graph_batch_api and legacy are required at the bottom, since they depend on API being defined
 require 'koala/api/graph_api'
-require 'koala/api/rest_api'
+require 'koala/api/graph_collection'
 require 'openssl'
 
 module Koala
@@ -23,13 +23,11 @@ module Koala
       attr_reader :access_token, :app_secret
 
       include GraphAPIMethods
-      include RestAPIMethods
 
       # Makes a request to the appropriate Facebook API.
       # @note You'll rarely need to call this method directly.
       #
       # @see GraphAPIMethods#graph_call
-      # @see RestAPIMethods#rest_call
       #
       # @param path the server path for this request (leading / is prepended if not present)
       # @param args arguments to be sent to Facebook
@@ -85,9 +83,9 @@ module Koala
         else
           # parse the body as JSON and run it through the error checker (if provided)
           # Note: Facebook sometimes sends results like "true" and "false", which are valid[RFC7159]
-          # but unsupported by Ruby's stdlib[RFC4627] and cause JSON.load to fail -- so we account for
+          # but unsupported by Ruby's stdlib[RFC4627] and cause JSON.parse to fail -- so we account for
           # that by wrapping the result in []
-          JSON.load("[#{result.body.to_s}]")[0]
+          JSON.parse("[#{result.body.to_s}]")[0]
         end
       end
 
@@ -117,5 +115,3 @@ module Koala
     end
   end
 end
-
-require 'koala/api/graph_batch_api'

data/lib/koala/errors.rb

@@ -50,7 +50,7 @@ module Koala
         else
           unless error_info
             begin
-              error_info = JSON.load(response_body)['error'] if response_body
+              error_info = JSON.parse(response_body)['error'] if response_body
             rescue
             end
             error_info ||= {}

data/lib/koala/http_service/multipart_request.rb

@@ -1,6 +1,6 @@
 require 'faraday'
 
-module Koala  
+module Koala
   module HTTPService
     class MultipartRequest < Faraday::Request::Multipart
       # Facebook expects nested parameters to be passed in a certain way
@@ -8,15 +8,15 @@ module Koala
       # Faraday needs two changes to make that work:
       # 1) [] need to be escaped (e.g. params[foo]=bar ==> params%5Bfoo%5D=bar)
       # 2) such messages need to be multipart-encoded
-    
+
       self.mime_type = 'multipart/form-data'.freeze
-    
+
       def process_request?(env)
         # if the request values contain any hashes or arrays, multipart it
         super || !!(env[:body].respond_to?(:values) && env[:body].values.find {|v| v.is_a?(Hash) || v.is_a?(Array)})
-      end   
-    
-    
+      end
+
+
       def process_params(params, prefix = nil, pieces = nil, &block)
         params.inject(pieces || []) do |all, (key, value)|
           key = "#{prefix}%5B#{key}%5D" if prefix
@@ -34,8 +34,4 @@ module Koala
       end
     end
   end
-  
-  # @private
-  # legacy support for when MultipartRequest lived directly under Koala
-  MultipartRequest = HTTPService::MultipartRequest  
 end

data/lib/koala/http_service/request.rb

@@ -0,0 +1,139 @@
+module Koala
+  module HTTPService
+    class Request
+      attr_reader :raw_path, :raw_args, :raw_verb, :raw_options
+
+      # @param path the server path for this request
+      # @param args (see Koala::Facebook::API#api)
+      # @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.
+      # @param options various flags to indicate which server to use. (see Koala::Facebook::API#api)
+      # @param options
+      # @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
+      # @option options :json whether or not to send JSON to Facebook
+      def initialize(path: nil, args: {}, verb: nil, options: {})
+        # we still support Ruby 2.0 so we can't use required keyword arguments
+        raise ArgumentError, "Missing required argument verb" unless verb
+        raise ArgumentError, "Missing required argument path" unless path
+
+        @raw_path = path
+        @raw_args = args
+        @raw_verb = verb
+        @raw_options = options
+      end
+
+      # Determines which type of request to send to Facebook. Facebook natively accepts GETs and POSTs, for others we have to include the method in the post body.
+      #
+      # @return one of get or post
+      def verb
+        ["get", "post"].include?(raw_verb) ? raw_verb : "post"
+      end
+
+      # Determines the path to be requested on Facebook, incorporating an API version if specified.
+      #
+      # @return the original path, with API version if appropriate.
+      def path
+        # if an api_version is specified and the path does not already contain
+        # one, prepend it to the path
+        api_version = raw_options[:api_version] || Koala.config.api_version
+        if api_version && !path_contains_api_version?
+          begins_with_slash = raw_path[0] == "/"
+          divider = begins_with_slash ? "" : "/"
+          "/#{api_version}#{divider}#{raw_path}"
+        else
+          raw_path
+        end
+      end
+
+      # Determines any arguments to be sent in a POST body.
+      #
+      # @return {} for GET; the provided args for POST; those args with the method parameter for
+      # other values
+      def post_args
+        if raw_verb == "get"
+          {}
+        elsif raw_verb == "post"
+          args
+        else
+          args.merge(method: raw_verb)
+        end
+      end
+
+      def get_args
+        raw_verb == "get" ? args : {}
+      end
+
+      # Calculates a set of request options to pass to Faraday.
+      #
+      # @return a hash combining GET parameters (if appropriate), default options, and
+      # any specified for the request.
+      def options
+        # figure out our options for this request
+        add_ssl_options(
+          # for GETs, we pass the params to Faraday to encode
+          {params: get_args}.merge(HTTPService.http_options).merge(raw_options)
+        )
+      end
+
+      # Whether or not this request should use JSON.
+      #
+      # @return true or false
+      def json?
+        raw_options[:format] == :json
+      end
+
+      # The address of the appropriate Facebook server.
+      #
+      # @return a complete server address with protocol
+      def server
+        uri = "#{options[:use_ssl] ? "https" : "http"}://#{Koala.config.graph_server}"
+        # if we want to use the beta tier or the video server, make those substitutions as
+        # appropriate
+        replace_server_component(
+          replace_server_component(uri, options[:video], Koala.config.video_replace),
+          options[:beta],
+          Koala.config.beta_replace
+        )
+      end
+
+      protected
+
+      # The arguments to include in the request.
+      def args
+        raw_args.inject({}) do |hash, (key, value)|
+          # Resolve UploadableIOs into data Facebook can work with
+          hash.merge(key => value.is_a?(UploadableIO) ? value.to_upload_io : value)
+        end
+      end
+
+      def add_ssl_options(opts)
+        # require https if there's a token
+        return opts unless raw_args["access_token"]
+
+        {
+          use_ssl: true,
+          ssl: {verify: true}.merge(opts[:ssl] || {})
+        }.merge(opts)
+      end
+
+      # Determines whether a given path already contains an API version.
+      #
+      # @param path the URL path.
+      #
+      # @return true or false accordingly.
+      def path_contains_api_version?
+        # looks for "/$MAJOR[.$MINOR]/" in the path
+        match = /^\/?(v\d+(?:\.\d+)?)\//.match(raw_path)
+        !!(match && match[1])
+      end
+
+      def replace_server_component(host, condition_met, replacement)
+        return host unless condition_met
+        host.gsub(Koala.config.host_path_matcher, replacement)
+      end
+    end
+  end
+end

data/lib/koala/http_service/response.rb

@@ -11,8 +11,4 @@ module Koala
       end
     end
   end
-  
-  # @private
-  # legacy support for when Response lived directly under Koala
-  Response = HTTPService::Response
 end

data/lib/koala/http_service/uploadable_io.rb

@@ -181,8 +181,4 @@ module Koala
       end
     end
   end
-
-  # @private
-  # legacy support for when UploadableIO lived directly under Koala
-  UploadableIO = HTTPService::UploadableIO
 end

data/lib/koala/http_service.rb

@@ -2,6 +2,7 @@ require 'faraday'
 require 'koala/http_service/multipart_request'
 require 'koala/http_service/uploadable_io'
 require 'koala/http_service/response'
+require 'koala/http_service/request'
 
 module Koala
   module HTTPService
@@ -28,7 +29,6 @@ module Koala
     DEFAULT_SERVERS = {
       :graph_server => 'graph.facebook.com',
       :dialog_host => 'www.facebook.com',
-      :rest_server => 'api.facebook.com',
       # certain Facebook services (beta, video) require you to access different
       # servers. If you're using your own servers, for instance, for a proxy,
       # you can change both the matcher and the replacement values.
@@ -40,81 +40,36 @@ module Koala
       :beta_replace => '.beta.facebook'
     }
 
-    # The address of the appropriate Facebook server.
-    #
-    # @param options various flags to indicate which server to use.
-    # @option options :rest_api use the old REST API instead of the Graph API
-    # @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] ? Koala.config.rest_server : Koala.config.graph_server}"
-      server.gsub!(Koala.config.host_path_matcher, Koala.config.video_replace) if options[:video]
-      server.gsub!(Koala.config.host_path_matcher, Koala.config.beta_replace) if options[:beta]
-      "#{options[:use_ssl] ? "https" : "http"}://#{server}"
-    end
-
     # Makes a request directly to Facebook.
     # @note You'll rarely need to call this method directly.
     #
     # @see Koala::Facebook::API#api
     # @see Koala::Facebook::GraphAPIMethods#graph_call
-    # @see Koala::Facebook::RestAPIMethods#rest_call
     #
-    # @param path the server path for this request
-    # @param args (see Koala::Facebook::API#api)
-    # @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.
-    # @param options (see Koala::Facebook::API#api)
+    # @param request a Koala::HTTPService::Request object
     #
     # @raise an appropriate connection error if unable to make the request to Facebook
     #
     # @return [Koala::HTTPService::Response] a response object representing the results from Facebook
-    def self.make_request(path, args, verb, options = {})
-      # if the verb isn't get or post, send it as a post argument with a method param
-      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(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
-
-      # if an api_version is specified and the path does not already contain
-      # one, prepend it to the path
-      api_version = request_options[:api_version] || Koala.config.api_version
-      if api_version && !path_contains_api_version?(path)
-        begins_with_slash = path[0] == "/"
-        divider = begins_with_slash ? "" : "/"
-        path = "/#{api_version}#{divider}#{path}"
-      end
-
+    def self.make_request(request)
       # set up our Faraday connection
-      # we have to manually assign params to the URL or the
-      conn = Faraday.new(server(request_options), faraday_options(request_options), &(faraday_middleware || DEFAULT_MIDDLEWARE))
+      conn = Faraday.new(request.server, faraday_options(request.options), &(faraday_middleware || DEFAULT_MIDDLEWARE))
 
-      # remember, all non-GET requests are turned into POSTs -- see the the start of this method
-      if verb == "post" && options[:format] == :json
+      if request.verb == "post" && request.json?
+        # JSON requires a bit more handling
+        # remember, all non-GET requests are turned into POSTs, so this covers everything but GETs
         response = conn.post do |req|
-          req.path = path
+          req.path = request.path
           req.headers["Content-Type"] = "application/json"
-          req.body = params.to_json
+          req.body = request.post_args.to_json
           req
         end
       else
-        response = conn.send(verb, path, (verb == "post" ? params : {}))
+        response = conn.send(request.verb, request.path, request.post_args)
       end
 
       # Log URL information
-      Koala::Utils.debug "#{verb.upcase}: #{path} params: #{params.inspect}"
+      Koala::Utils.debug "#{request.verb.upcase}: #{request.path} params: #{request.raw_args.inspect}"
       Koala::HTTPService::Response.new(response.status.to_i, response.body, response.headers)
     end
 
@@ -130,21 +85,14 @@ module Koala
     # @return the appropriately-encoded string
     def self.encode_params(param_hash)
       ((param_hash || {}).sort_by{|k, v| k.to_s}.collect do |key_and_value|
-        key_and_value[1] = JSON.dump(key_and_value[1]) unless key_and_value[1].is_a? String
-        "#{key_and_value[0].to_s}=#{CGI.escape key_and_value[1]}"
+        value = key_and_value[1]
+        unless value.is_a? String
+          value = value.to_json
+        end
+        "#{key_and_value[0].to_s}=#{CGI.escape value}"
       end).join("&")
     end
 
-    # Determines whether a given path already contains an API version.
-    #
-    # @param path the URL path.
-    #
-    # @return true or false accordingly.
-    def self.path_contains_api_version?(path)
-      match = /^\/?(v\d+(?:\.\d+)?)\//.match(path)
-      !!(match && match[1])
-    end
-
     private
 
     def self.faraday_options(options)

data/lib/koala/oauth.rb

@@ -134,7 +134,7 @@ module Koala
         if response == ''
           raise BadFacebookResponse.new(200, '', 'generate_client_code received an error: empty response body')
         else
-          result = JSON.load(response)
+          result = JSON.parse(response)
         end
 
         result.has_key?('code') ? result['code'] : raise(Koala::KoalaError.new("Facebook returned a valid response without the expected 'code' in the body (response = #{response})"))
@@ -240,7 +240,7 @@ module Koala
         raise OAuthSignatureError, 'Invalid (incomplete) signature data' unless encoded_sig && encoded_envelope
 
         signature = base64_url_decode(encoded_sig).unpack("H*").first
-        envelope = JSON.load(base64_url_decode(encoded_envelope))
+        envelope = JSON.parse(base64_url_decode(encoded_envelope))
 
         raise OAuthSignatureError, "Unsupported algorithm #{envelope['algorithm']}" if envelope['algorithm'] != 'HMAC-SHA256'
 
@@ -260,7 +260,7 @@ module Koala
       end
 
       def parse_access_token(response_text)
-        JSON.load(response_text)
+        JSON.parse(response_text)
       rescue JSON::ParserError
         response_text.split("&").inject({}) do |hash, bit|
           key, value = bit.split("=")

data/lib/koala/version.rb

@@ -1,3 +1,3 @@
 module Koala
-  VERSION = "2.5.0"
+  VERSION = "3.0.0.beta1"
 end

data/lib/koala.rb

@@ -5,6 +5,7 @@ require 'json'
 # include koala modules
 require 'koala/errors'
 require 'koala/api'
+require 'koala/api/graph_batch_api'
 require 'koala/oauth'
 require 'koala/realtime_updates'
 require 'koala/test_users'
@@ -61,7 +62,7 @@ module Koala
 
   # An convenenient alias to Koala.http_service.make_request.
   def self.make_request(path, args, verb, options = {})
-    http_service.make_request(path, args, verb, options)
+    http_service.make_request(HTTPService::Request.new(path: path, args: args, verb: verb, options: options))
   end
 
   # we use Faraday as our main service, with mock as the other main one