koala 3.0.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6941f9efa1f2d1a275581f20b5d10977f3d73fdd
-  data.tar.gz: 726f62799f0c20c9266515dc6d68bc333e9995d0
+SHA256:
+  metadata.gz: 27591b64021ee915c13d9bcea2763739c2c86ce04d961dd5b540d964515a9905
+  data.tar.gz: 4a8c184674f681b193a3686b4eeb0023da0c00765d60be9694af9098014dacfd
 SHA512:
-  metadata.gz: 10d6e349ebe3e89487f9052840d12d27b52b5fce77cb649fb97e2554855bf39c12acf60da93c3c5e55bf2f0ea66b9533310c50cad23006da331b4e253dfa4e77
-  data.tar.gz: 67c74e5c4af1c273d4c1e7edae915897753b610357763bf398b8c8b6107853dbbdaf86ac174951e2efddadd9aa5a611cb343c0655388e7a75b407ba80823a1c4
+  metadata.gz: 78e4a3d670c3524211d438b8b67713f3f27cc0638aee6660b544b8b3b83a99397546a96ae826c6d613a1b6799184894c816b95008dc6083689f866357ae7ae13
+  data.tar.gz: 7a135a41f63d84e7e4f6c68632574eb19140aaf32ea9d9220bb2aaa4c79c50097c7ee1c957f7e9740d6b2c1141b5d24ebffdb47edd510c28bd7590f3cc09bf4f

data/.github/workflows/test.yml

@@ -0,0 +1,32 @@
+name: Test
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    name: on ruby ${{matrix.ruby}}
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [2.7, "3.0", 3.1, 3.2, 3.3, head]
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{matrix.ruby}}
+
+    - name: Install dependencies
+      run: bundle install --jobs 4 --retry 3
+
+    - name: Specs & Coverage
+      uses: paambaati/codeclimate-action@v6
+      env:
+        CC_TEST_REPORTER_ID: 7af99d9225b4c14640f9ec3cb2e24d2f7103ac49417b0bd989188fb6c25f2909
+      with:
+        coverageCommand: bundle exec rspec

data/Gemfile

@@ -7,15 +7,17 @@ group :development do
 end
 
 group :development, :test do
+  gem "psych", '< 4.0.0' # safe_load signature not compatible with older rubies
   gem "rake"
   gem "typhoeus" unless defined? JRUBY_VERSION
+  gem 'faraday-typhoeus' unless defined? JRUBY_VERSION
 end
 
 group :test do
-  gem "rspec", '~> 3.4'
-  gem "vcr"
+  gem "rspec", "~> 3.0", "< 3.10" # resrict rspec version until https://github.com/rspec/rspec-support/pull/537 gets merged
+  gem "vcr", github: 'vcr/vcr', ref: '8ced6c96e01737a418cd270e0382a8c2c6d85f7f' # needs https://github.com/vcr/vcr/pull/907 for ruby 3.1
   gem "webmock"
-  gem "codeclimate-test-reporter", "~> 1.0.0", require: nil
+  gem "simplecov"
 end
 
 gem "jruby-openssl" if defined? JRUBY_VERSION

data/changelog.md

@@ -1,3 +1,101 @@
+Unreleased
+==========
+
+**Key breaking changes:**
+
+New features:
+
+Updated features:
+
+Removed features:
+
+Internal improvements:
+
+Testing improvements:
+
+Others:
+
+v3.6.0 (2024-06-27)
+==========
+
+Updated features:
+
+ * Add fbtrace_id, x-fb-rev, x-fb-debug to error messages and error class ([#668](https://github.com/arsduo/koala/pull/686))
+ * Handles the invalid JSON response from Facebook when the request's http_options[:http_component] is set to ':response' ([#689](https://github.com/arsduo/koala/pull/689))
+
+Internal improvements:
+
+* Require base64 for ruby 3.4 support ([#688](https://github.com/arsduo/koala/pull/688))
+
+Testing improvements:
+
+* Fix CI for ruby 3.4 ([#688](https://github.com/arsduo/koala/pull/688))
+* Add latest rubies to CI ([#687](https://github.com/arsduo/koala/pull/687))
+* Bump GHA action plugins to avoid deprecation warnings ([#689](https://github.com/arsduo/koala/pull/689))
+
+v3.5.0 (2023-08-23)
+======
+
+Internal improvements:
+* Raise ClientError instead of NoMethodError when body is 'null' ([#673](https://github.com/arsduo/koala/issues/673))
+
+v3.4.0 (2023-01-05)
+======
+
+Updated features:
+
+* Force use by default of HTTPS (instead of HTTP) when there is no access token.
+  HTTP can still be used by passing :use_ssl => false in the options hash for an api call ([#678](https://github.com/arsduo/koala/pull/678/files))
+
+v3.3.0 (2022-09-27)
+======
+
+Updated features:
+
+  * Removed restriction on faraday < 2 ([#666](https://github.com/arsduo/koala/pull/666))
+
+Internal improvements:
+
+ * Remove multipart hack and use default faraday multipart middleware ([#664](https://github.com/arsduo/koala/pull/664))
+
+Testing improvements:
+
+ * Fix tests with ruby-head ([#674](https://github.com/arsduo/koala/pull/674))
+ * Keep supported rubies (non EOL) for CI ([#675](https://github.com/arsduo/koala/pull/675))
+
+v3.2.0 (2022-05-27)
+======
+
+New features:
+
+  * Exposes limiting headers(`x-business-use-case-usage, x-ad-account-usage, x-app-usage`) to APIError ([#668](https://github.com/arsduo/koala/pull/668))
+  * Add `rate_limit_hook` configuration to get rate limiting headers (`x-business-use-case-usage, x-ad-account-usage, x-app-usage`) ([#670](https://github.com/arsduo/koala/pull/670))
+
+Testing improvements:
+
+* Fix builds for ruby 3.x
+
+v3.1.0 (2022-01-18)
+======
+
+New features:
+
+* mask_tokens config (default: true) to mask tokens in logs
+
+Updated features:
+
+* Log before and after sending request
+
+Internal improvements:
+
+* Lock Faraday to < 2
+* Compatibility with ruby 3.x
+
+Testing improvements:
+
+* Use Github actions for CI
+* Run CI on latest rubies
+
 v3.0.0 (2017-03-17)
 ======
 

data/koala.gemspec

@@ -24,6 +24,9 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version = '>= 2.1'
 
   gem.add_runtime_dependency("faraday")
+  gem.add_runtime_dependency("faraday-multipart")
   gem.add_runtime_dependency("addressable")
   gem.add_runtime_dependency("json", ">= 1.8")
+  gem.add_runtime_dependency("rexml")
+  gem.add_runtime_dependency("base64")
 end

data/lib/koala/api/graph_batch_api.rb

@@ -53,7 +53,16 @@ module Koala
           end
 
           original_api.graph_call("/", args, "post", http_options) do |response|
-            raise bad_response if response.nil?
+            raise bad_response('Facebook returned an empty body') if response.nil?
+
+            # when http_component is set we receive Koala::Http_service response object
+            # from graph_call so this needs to be parsed
+            # as generate_results method handles only JSON response
+            if http_options[:http_component] && http_options[:http_component] == :response
+              response = json_body(response.body)
+
+              raise bad_response('Facebook returned an invalid body') unless response.is_a?(Array)
+            end
 
             batch_results += generate_results(response, batch)
           end
@@ -81,9 +90,9 @@ module Koala
         end
       end
 
-      def bad_response
+      def bad_response(message)
         # Facebook sometimes reportedly returns an empty body at times
-        BadFacebookResponse.new(200, "", "Facebook returned an empty body")
+        BadFacebookResponse.new(200, '', message)
       end
 
       def result_from_response(response, options)
@@ -123,14 +132,17 @@ module Koala
         JSON.dump calls
       end
 
-      def json_body(response)
-        # quirks_mode is needed because Facebook sometimes returns a raw true or false value --
-        # in Ruby 2.4 we can drop that.
-        JSON.parse(response.fetch("body"), quirks_mode: true)
+      def json_body(body)
+        return if body.nil?
+
+        JSON.parse(body)
+      rescue JSON::ParserError => e
+        Koala::Utils.logger.error("#{e.class}: #{e.message} while parsing #{body}")
+        nil
       end
 
       def desired_component(component:, response:, headers:)
-        result = Koala::HTTPService::Response.new(response['status'], response['body'], headers)
+        result = Koala::HTTPService::Response.new(response['code'], response['body'], headers)
 
         # Get the HTTP component they want
         case component
@@ -138,6 +150,7 @@ module Koala
         # facebook returns the headers as an array of k/v pairs, but we want a regular hash
         when :headers then headers
         # (see note in regular api method about JSON parsing)
+        when :response then result
         else GraphCollection.evaluate(result, original_api)
         end
       end

data/lib/koala/api/graph_error_checker.rb

@@ -17,7 +17,7 @@ module Koala
 
       # Facebook can return debug information in the response headers -- see
       # https://developers.facebook.com/docs/graph-api/using-graph-api#bugdebug
-      DEBUG_HEADERS = ["x-fb-debug", "x-fb-rev", "x-fb-trace-id"]
+      DEBUG_HEADERS = %w[x-fb-debug x-fb-rev x-fb-trace-id x-business-use-case-usage x-ad-account-usage x-app-usage]
 
       def error_if_appropriate
         if http_status >= 400
@@ -61,7 +61,8 @@ 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.parse(body)
+          parsed_body = JSON.parse(body)
+          parsed_body.is_a?(Hash) ? parsed_body : {}
         rescue JSON::ParserError
           {}
         end

data/lib/koala/api.rb

@@ -13,14 +13,16 @@ module Koala
       #                 signed by default, unless you pass appsecret_proof:
       #                 false as an option to the API call. (See
       #                 https://developers.facebook.com/docs/graph-api/securing-requests/)
+      # @param [Block]  rate_limit_hook block called with limits received in facebook response headers
       # @note If no access token is provided, you can only access some public information.
       # @return [Koala::Facebook::API] the API client
-      def initialize(access_token = Koala.config.access_token, app_secret = Koala.config.app_secret)
+      def initialize(access_token = Koala.config.access_token, app_secret = Koala.config.app_secret, rate_limit_hook = Koala.config.rate_limit_hook)
         @access_token = access_token
         @app_secret = app_secret
+        @rate_limit_hook = rate_limit_hook
       end
 
-      attr_reader :access_token, :app_secret
+      attr_reader :access_token, :app_secret, :rate_limit_hook
 
       include GraphAPIMethods
 
@@ -58,6 +60,18 @@ module Koala
           API::GraphCollection.evaluate(response, self)
         end
 
+        if rate_limit_hook
+          limits = %w(x-business-use-case-usage x-ad-account-usage x-app-usage).each_with_object({}) do |key, hash|
+            value = response.headers.fetch(key, nil)
+            next unless value
+            hash[key] = JSON.parse(response.headers[key])
+          rescue JSON::ParserError => e
+            Koala::Utils.logger.error("#{e.class}: #{e.message} while parsing #{key} = #{value}")
+          end
+
+          rate_limit_hook.call(limits) if limits.keys.any?
+        end
+
         # now process as appropriate for the given call (get picture header, etc.)
         post_processing ? post_processing.call(desired_data) : desired_data
       end
@@ -102,7 +116,7 @@ module Koala
         args = sanitize_request_parameters(args) unless preserve_form_arguments?(options)
 
         # add a leading / if needed...
-        path = "/#{path}" unless path =~ /^\//
+        path = "/#{path}" unless path.to_s =~ /^\//
 
         # make the request via the provided service
         result = Koala.make_request(path, args, verb, options)

data/lib/koala/configuration.rb

@@ -28,6 +28,12 @@ class Koala::Configuration
   # The server to use when constructing dialog URLs.
   attr_accessor :dialog_host
 
+  # Whether or not to mask tokens
+  attr_accessor :mask_tokens
+
+  # Called with the info for the rate limits in the response header
+  attr_accessor :rate_limit_hook
+
   # 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 (what value to change when updating the URL) and the
@@ -45,5 +51,6 @@ class Koala::Configuration
     Koala::HTTPService::DEFAULT_SERVERS.each_pair do |key, value|
       self.public_send("#{key}=", value)
     end
+    self.mask_tokens = true
   end
 end

data/lib/koala/errors.rb

@@ -22,8 +22,12 @@ module Koala
                     :fb_error_user_msg,
                     :fb_error_user_title,
                     :fb_error_trace_id,
+                    :fb_error_debug_trace_id,
                     :fb_error_debug,
-                    :fb_error_rev
+                    :fb_error_rev,
+                    :fb_buc_usage,
+                    :fb_ada_usage,
+                    :fb_app_usage
 
       # Create a new API Error
       #
@@ -62,13 +66,17 @@ module Koala
           self.fb_error_message = error_info["message"]
           self.fb_error_user_msg = error_info["error_user_msg"]
           self.fb_error_user_title = error_info["error_user_title"]
+          self.fb_error_trace_id = error_info["fbtrace_id"]
 
-          self.fb_error_trace_id = error_info["x-fb-trace-id"]
+          self.fb_error_debug_trace_id = error_info["x-fb-trace-id"]
           self.fb_error_debug = error_info["x-fb-debug"]
           self.fb_error_rev = error_info["x-fb-rev"]
+          self.fb_buc_usage = json_parse_for(error_info, "x-business-use-case-usage")
+          self.fb_ada_usage = json_parse_for(error_info, "x-ad-account-usage")
+          self.fb_app_usage = json_parse_for(error_info, "x-app-usage")
 
           error_array = []
-          %w(type code error_subcode message error_user_title error_user_msg x-fb-trace-id).each do |key|
+          %w(type code error_subcode message error_user_title error_user_msg fbtrace_id x-fb-trace-id x-fb-debug x-fb-rev).each do |key|
             error_array << "#{key}: #{error_info[key]}" if error_info[key]
           end
 
@@ -82,6 +90,20 @@ module Koala
 
         super(message)
       end
+
+      private
+
+      # refs: https://developers.facebook.com/docs/graph-api/overview/rate-limiting/#headers
+      # NOTE: The header will contain a JSON-formatted string that describes current application rate limit usage.
+      def json_parse_for(error_info, key)
+        string = error_info[key]
+        return if string.nil?
+
+        JSON.parse(string)
+      rescue JSON::ParserError => e
+        Koala::Utils.logger.error("#{e.class}: #{e.message} while parsing #{key} = #{string}")
+        nil
+      end
     end
 
     # Facebook returned an invalid response body

data/lib/koala/http_service/request.rb

@@ -106,9 +106,7 @@ module Koala
       end
 
       def add_ssl_options(opts)
-        # require https if there's a token
-        return opts unless raw_args["access_token"]
-
+        # require https by default (can be overriden by explicitly setting other SSL options)
         {
           use_ssl: true,
           ssl: {verify: true}.merge(opts[:ssl] || {})

data/lib/koala/http_service/uploadable_io.rb

@@ -1,4 +1,3 @@
-require "net/http/post/multipart"
 require "tempfile"
 
 module Koala

data/lib/koala/http_service.rb

@@ -1,5 +1,5 @@
 require 'faraday'
-require 'koala/http_service/multipart_request'
+require 'faraday/multipart' unless defined? Faraday::FilePart # hack for faraday < 1.9 to avoid warnings
 require 'koala/http_service/uploadable_io'
 require 'koala/http_service/response'
 require 'koala/http_service/request'
@@ -19,7 +19,7 @@ module Koala
     # 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
+      builder.request :multipart
       builder.request :url_encoded
       builder.adapter Faraday.default_adapter
     end
@@ -49,6 +49,18 @@ module Koala
       # set up our Faraday connection
       conn = Faraday.new(request.server, faraday_options(request.options), &(faraday_middleware || DEFAULT_MIDDLEWARE))
 
+      filtered_args = request.raw_args.dup.transform_keys(&:to_s)
+
+      if Koala.config.mask_tokens
+        %w(access_token input_token).each do |arg_token|
+          if (token = filtered_args[arg_token])
+            filtered_args[arg_token] = token[0, 10] + '*****' + token[-5, 5]
+          end
+        end
+      end
+
+      Koala::Utils.debug "STARTED => #{request.verb.upcase}: #{request.path} params: #{filtered_args.inspect}"
+
       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
@@ -62,8 +74,7 @@ module Koala
         response = conn.send(request.verb, request.path, request.post_args)
       end
 
-      # Log URL information
-      Koala::Utils.debug "#{request.verb.upcase}: #{request.path} params: #{request.raw_args.inspect}"
+      Koala::Utils.debug "FINISHED => #{request.verb.upcase}: #{request.path} params: #{filtered_args.inspect}"
       Koala::HTTPService::Response.new(response.status.to_i, response.body, response.headers)
     end
 

data/lib/koala/version.rb

@@ -1,3 +1,3 @@
 module Koala
-  VERSION = "3.0.0"
+  VERSION = "3.6.0"
 end

data/readme.md

@@ -1,6 +1,6 @@
-Koala [![Version](https://img.shields.io/gem/v/koala.svg)](https://rubygems.org/gems/koala) [![Dependencies](https://img.shields.io/gemnasium/arsduo/koala.svg)](https://gemnasium.com/arsduo/koala) [![Build Status](https://img.shields.io/travis/arsduo/koala.svg)](http://travis-ci.org/arsduo/koala) [![Code Climate](https://img.shields.io/codeclimate/github/arsduo/koala.svg)](https://codeclimate.com/github/arsduo/koala) [![Code Coverage](https://img.shields.io/codeclimate/coverage/github/arsduo/koala.svg)](https://codeclimate.com/github/arsduo/koala)
+Koala [![Version](https://img.shields.io/gem/v/koala.svg)](https://rubygems.org/gems/koala) [![Build Status](https://img.shields.io/travis/arsduo/koala.svg)](http://travis-ci.org/arsduo/koala) [![Code Climate](https://img.shields.io/codeclimate/coverage-letter/arsduo/koala.svg)](https://codeclimate.com/github/arsduo/koala) [![Code Coverage](https://img.shields.io/codeclimate/coverage/arsduo/koala.svg)](https://codeclimate.com/github/arsduo/koala)
 ====
-[Koala](http://github.com/arsduo/koala) is a Facebook library for Ruby, supporting the Graph API (including the batch requests and photo uploads), realtime updates, test users, and OAuth validation.  We wrote Koala with four goals:
+[Koala](http://github.com/arsduo/koala) is a Facebook library for Ruby, supporting the Graph API (including the batch requests and photo uploads), the Marketing API, the Atlas API, realtime updates, test users, and OAuth validation.  We wrote Koala with four goals:
 
 * Lightweight: Koala should be as light and simple as Facebook’s own libraries, providing API accessors and returning simple JSON.
 * Fast: Koala should, out of the box, be quick. Out of the box, we use Facebook's faster read-only servers when possible and if available, the Typhoeus gem to make snappy Facebook requests.  Of course, that brings us to our next topic:
@@ -177,6 +177,37 @@ Koala::Facebook::RealtimeUpdates.meet_challenge(params, your_verify_token)
 ```
 For more information about meet_challenge and the RealtimeUpdates class, check out the Real-Time Updates page on the wiki.
 
+Rate limits
+-----------
+
+We support Facebook rate limit informations as defined here: [https://developers.facebook.com/docs/graph-api/overview/rate-limiting/](https://developers.facebook.com/docs/graph-api/overview/rate-limiting/)
+
+The information is available either via the `Facebook::APIError`:
+
+```ruby
+error.fb_buc_usage
+error.fb_ada_usage
+error.fb_app_usage
+```
+
+Or with the rate_limit_hook:
+
+```ruby
+# App level configuration
+
+Koala.configure do |config|
+  config.rate_limit_hook = ->(limits) { 
+    limits["x-app-usage"] # {"call_count"=>0, "total_cputime"=>0, "total_time"=>0}
+    limits["x-ad-account-usage"] # {"acc_id_util_pct"=>9.67}
+    limits["x-business-use-case-usage"] # {"123456789012345"=>[{"type"=>"messenger", "call_count"=>1, "total_cputime"=>1, "total_time"=>1, "estimated_time_to_regain_access"=>0}]}
+  }
+end
+
+# Per API configuration
+
+Koala::Facebook::API.new('', '', ->(limits) {})
+```
+
 Test Users
 ----------
 

data/spec/cases/api_spec.rb

@@ -282,4 +282,81 @@ describe "Koala::Facebook::API" do
       expect(@service.graph_call('anything')).to be_falsey
     end
   end
+
+  describe "Rate limit hook" do
+    it "is called when x-business-use-case-usage header is present" do
+      api = Koala::Facebook::API.new('', '', ->(limits) {
+        expect(limits["x-business-use-case-usage"]).to eq({"123456789012345"=>[{"type"=>"messenger", "call_count"=>1, "total_cputime"=>1, "total_time"=>1, "estimated_time_to_regain_access"=>0}]})
+      })
+
+      result = {"a" => 2}
+      response = Koala::HTTPService::Response.new(200, result.to_json, { "x-business-use-case-usage" => "{\"123456789012345\":[{\"type\":\"messenger\",\"call_count\":1,\"total_cputime\":1,\"total_time\":1,\"estimated_time_to_regain_access\":0}]}" })
+      allow(Koala).to receive(:make_request).and_return(response)
+
+      api.graph_call('anything')
+    end
+
+    it "is called when x-ad-account-usage header is present" do
+      api = Koala::Facebook::API.new('', '', ->(limits) {
+        expect(limits["x-ad-account-usage"]).to eq({"acc_id_util_pct"=>9.67})
+      })
+
+      result = {"a" => 2}
+      response = Koala::HTTPService::Response.new(200, result.to_json, { "x-ad-account-usage" => "{\"acc_id_util_pct\":9.67}" })
+      allow(Koala).to receive(:make_request).and_return(response)
+
+      api.graph_call('anything')
+    end
+
+    it "is called when x-app-usage header is present" do
+      api = Koala::Facebook::API.new('', '', ->(limits) {
+        expect(limits["x-app-usage"]).to eq({"call_count"=>0, "total_cputime"=>0, "total_time"=>0})
+      })
+
+      result = {"a" => 2}
+      response = Koala::HTTPService::Response.new(200, result.to_json, { "x-app-usage" => "{\"call_count\":0,\"total_cputime\":0,\"total_time\":0}" })
+      allow(Koala).to receive(:make_request).and_return(response)
+
+      api.graph_call('anything')
+    end
+
+    it "isn't called if none of the rate limit header is present" do
+      rate_limit_hook_called = false
+
+      api = Koala::Facebook::API.new('', '', ->(limits) {
+        rate_limit_hook_called = true
+      })
+
+      result = {"a" => 2}
+      response = Koala::HTTPService::Response.new(200, result.to_json, {})
+      allow(Koala).to receive(:make_request).and_return(response)
+
+      api.graph_call('anything')
+
+      expect(rate_limit_hook_called).to be(false)
+    end
+
+    it "isn't called if no rate limit hook is defined" do
+      api = Koala::Facebook::API.new('', '', ->(limits) {
+        #noop
+      })
+
+      result = {"a" => 2}
+      response = Koala::HTTPService::Response.new(200, result.to_json, { "x-ad-account-usage" => "{\"acc_id_util_pct\"9.67}"})
+      allow(Koala).to receive(:make_request).and_return(response)
+
+      expect(Koala::Utils.logger).to receive(:error).with(/JSON::ParserError:.*unexpected token at '{"acc_id_util_pct"9.67}' while parsing x-ad-account-usage = {"acc_id_util_pct"9.67}/)
+      api.graph_call('anything')
+    end
+
+    it "logs an error if the rate limit header can't be properly parsed" do
+      api = Koala::Facebook::API.new('', '', nil)
+
+      result = {"a" => 2}
+      response = Koala::HTTPService::Response.new(200, result.to_json, {})
+      allow(Koala).to receive(:make_request).and_return(response)
+
+      api.graph_call('anything')
+    end
+  end
 end

data/spec/cases/error_spec.rb

@@ -1,5 +1,9 @@
 require 'spec_helper'
 
+BUC_USAGE_JSON = "{\"123456789012345\":[{\"type\":\"messenger\",\"call_count\":1,\"total_cputime\":1,\"total_time\":1,\"estimated_time_to_regain_access\":0}]}"
+ADA_USAGE_JSON = "{\"acc_id_util_pct\":9.67}"
+APP_USAGE_JSON = "{\"call_count\":0,\"total_cputime\":0,\"total_time\":0}"
+
 describe Koala::Facebook::APIError do
   it "is a Koala::KoalaError" do
     expect(Koala::Facebook::APIError.new(nil, nil)).to be_a(Koala::KoalaError)
@@ -30,9 +34,13 @@ describe Koala::Facebook::APIError do
         'error_subcode' => 'subcode',
         'error_user_msg' => 'error user message',
         'error_user_title' => 'error user title',
-        'x-fb-trace-id' => 'fb trace id',
+        'fbtrace_id' => 'fb trace id',
+        'x-fb-trace-id' => 'x-fb trace id',
         'x-fb-debug' => 'fb debug token',
-        'x-fb-rev' => 'fb revision'
+        'x-fb-rev' => 'fb revision',
+        'x-business-use-case-usage' => BUC_USAGE_JSON,
+        'x-ad-account-usage' => ADA_USAGE_JSON,
+        'x-app-usage' => APP_USAGE_JSON
       }
       Koala::Facebook::APIError.new(400, '', error_info)
     }
@@ -45,8 +53,12 @@ describe Koala::Facebook::APIError do
       :fb_error_user_msg => 'error user message',
       :fb_error_user_title => 'error user title',
       :fb_error_trace_id => 'fb trace id',
+      :fb_error_debug_trace_id => 'x-fb trace id',
       :fb_error_debug => 'fb debug token',
-      :fb_error_rev => 'fb revision'
+      :fb_error_rev => 'fb revision',
+      :fb_buc_usage => JSON.parse(BUC_USAGE_JSON),
+      :fb_ada_usage => JSON.parse(ADA_USAGE_JSON),
+      :fb_app_usage => JSON.parse(APP_USAGE_JSON)
     }.each_pair do |accessor, value|
       it "sets #{accessor} to #{value}" do
         expect(error.send(accessor)).to eq(value)
@@ -54,7 +66,7 @@ describe Koala::Facebook::APIError do
     end
 
     it "sets the error message appropriately" do
-      expect(error.message).to eq("type: type, code: 1, error_subcode: subcode, message: message, error_user_title: error user title, error_user_msg: error user message, x-fb-trace-id: fb trace id [HTTP 400]")
+      expect(error.message).to eq("type: type, code: 1, error_subcode: subcode, message: message, error_user_title: error user title, error_user_msg: error user message, fbtrace_id: fb trace id, x-fb-trace-id: x-fb trace id, x-fb-debug: fb debug token, x-fb-rev: fb revision [HTTP 400]")
     end
   end
 
@@ -76,7 +88,10 @@ describe Koala::Facebook::APIError do
         :fb_error_code => 1,
         :fb_error_subcode => 'subcode',
         :fb_error_user_msg => 'error user message',
-        :fb_error_user_title => 'error user title'
+        :fb_error_user_title => 'error user title',
+        :fb_buc_usage => nil,
+        :fb_ada_usage => nil,
+        :fb_app_usage => nil
       }.each_pair do |accessor, value|
         expect(error.send(accessor)).to eq(value)
       end

data/spec/cases/graph_api_batch_spec.rb

@@ -383,28 +383,85 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         end
       end
 
-      describe "processing the request" do
-        it "returns the result headers as a hash if http_component is headers" do
+      describe 'processing the request' do
+        let(:response_status) { 203 }
+        let(:response_body) { '{\"id\":\"1234\"}'.gsub('\\', '') }
+        let(:response_headers) { { 'Content-Type' => 'text/javascript; charset=UTF-8' } }
+
+        it 'returns the result headers as a hash if http_component is headers' do
           allow(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(200, '[{"code":203,"headers":[{"name":"Content-Type","value":"text/javascript; charset=UTF-8"}],"body":"{\"id\":\"1234\"}"}]', {}))
           result = @api.batch do |batch_api|
             batch_api.get_object(KoalaTest.user1, {}, :http_component => :headers)
           end
-          expect(result[0]).to eq({"Content-Type" => "text/javascript; charset=UTF-8"})
+          expect(response_headers).to eq(result[0])
+        end
+
+        it 'returns the complete response if http_component is response' do
+          allow(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(200, '[{"code":203,"headers":[{"name":"Content-Type","value":"text/javascript; charset=UTF-8"}],"body":"{\"id\":\"1234\"}"}]', {}))
+          result = @api.batch do |batch_api|
+            batch_api.get_object(KoalaTest.user1, {}, :http_component => :response)
+          end
+
+          expect(response_status).to eq(result[0].status)
+          expect(response_body).to eq(result[0].body)
+          expect(response_headers).to eq(result[0].headers)
         end
 
-        describe "if it errors" do
-          it "raises an APIError if the response is not 200" do
-            allow(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(500, "[]", {}))
+        describe 'if it errors' do
+          it 'raises an APIError if the response is not 200' do
+            allow(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(500, '[]', {}))
             expect {
-              Koala::Facebook::API.new("foo").batch {|batch_api| batch_api.get_object('me') }
+              Koala::Facebook::API.new('foo').batch { |batch_api| batch_api.get_object('me') }
             }.to raise_exception(Koala::Facebook::APIError)
           end
 
-          it "raises a BadFacebookResponse if the body is empty" do
-            allow(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(200, "", {}))
+          it 'raises a BadFacebookResponse if the body is empty' do
+            allow(Koala).to receive(: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::BadFacebookResponse)
+              Koala::Facebook::API.new('foo').batch { |batch_api| batch_api.get_object('me') }
+            }.to raise_exception(Koala::Facebook::BadFacebookResponse, /Facebook returned an empty body \[HTTP 200\]/)
+          end
+
+          describe 'handle invalid body errors' do
+            describe 'with http_component set to :response' do
+              it 'raises a BadFacebookResponse if the body is non-empty, non-array' do
+                allow(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(200, '200', {}))
+                expect {
+                  Koala::Facebook::API.new('foo').batch(http_component: :response) do |batch_api|
+                    batch_api.get_object('me')
+                  end
+                }.to raise_exception(Koala::Facebook::BadFacebookResponse, /Facebook returned an invalid body \[HTTP 200\]/)
+              end
+
+              it 'raises a BadFacebookResponse if the body is invalid JSON' do
+                allow(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(200, '{"\"id\":\1234\"}"}', {}))
+                expect {
+                  Koala::Facebook::API.new('foo').batch(http_component: :response) do |batch_api|
+                    batch_api.get_object('me')
+                  end
+                }.to raise_exception(Koala::Facebook::BadFacebookResponse, /Facebook returned an invalid body \[HTTP 200\]/)
+              end
+            end
+
+            %i[headers status].each do |component|
+              describe "with http_component set to #{component}" do
+                it 'should not raise a BadFacebookResponse if the body is non-empty, non-array' do
+                  allow(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(200, '200', {}))
+                  expect {
+                    Koala::Facebook::API.new('foo').batch(http_component: component) { |batch_api| batch_api.get_object('me') }
+                  }.not_to raise_exception(Koala::Facebook::BadFacebookResponse, /Facebook returned an invalid body \[HTTP 200\]/)
+                end
+
+                it 'should not raise a BadFacebookResponse if the body is invalid JSON' do
+                  allow(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(200, '{"\"id\":\1234\"}"}', {}))
+                  expect {
+                    Koala::Facebook::API.new('foo').batch(http_component: component) do |batch_api|
+                      batch_api.get_object('me')
+                    end
+                  }.not_to raise_exception(Koala::Facebook::BadFacebookResponse, /Facebook returned an invalid body \[HTTP 200\]/)
+                end
+              end
+            end
           end
 
           context "with error info" do
@@ -593,7 +650,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
           hash_including(@other_access_token_args.dup),
           anything,
           anything
-      ).and_return(Koala::HTTPService::Response.new(200, "", ""))
+      ).and_return(Koala::HTTPService::Response.new(200, "", {}))
 
       # Page the collection
       app_event_types.next_page

data/spec/cases/graph_error_checker_spec.rb

@@ -11,7 +11,10 @@ module Koala
         expect(GraphErrorChecker::DEBUG_HEADERS).to match_array([
           "x-fb-rev",
           "x-fb-debug",
-          "x-fb-trace-id"
+          "x-fb-trace-id",
+          "x-business-use-case-usage",
+          "x-ad-account-usage",
+          "x-app-usage"
         ])
       end
 
@@ -60,6 +63,12 @@ module Koala
             expect(error.response_body).to eq(body)
           end
 
+          it "returns a ClientError if the body is null" do
+            body.replace("null")
+            expect(error).to be_a(ClientError)
+            expect(error.response_body).to eq(body)
+          end
+
           it "adds error data from the body" do
             error_data = {
               "type" => "FB error type",
@@ -67,10 +76,12 @@ module Koala
               "error_subcode" => "FB error subcode",
               "message" => "An error occurred!",
               "error_user_msg" => "A user msg",
-              "error_user_title" => "usr title"
+              "error_user_title" => "usr title",
+              "fbtrace_id" => "fbtrace_id"
             }
             body.replace({"error" => error_data}.to_json)
 
+            expect(error.fb_error_trace_id).to eq(error_data["fbtrace_id"])
             expect(error.fb_error_type).to eq(error_data["type"])
             expect(error.fb_error_code).to eq(error_data["code"])
             expect(error.fb_error_subcode).to eq(error_data["error_subcode"])
@@ -84,10 +95,25 @@ module Koala
               "x-fb-debug" => double("fb debug"),
               "x-fb-rev" => double("fb rev"),
               "x-fb-trace-id" => double("fb trace id"),
+              "x-business-use-case-usage" => { 'a' => 1, 'b' => 2 }.to_json,
+              "x-ad-account-usage" => { 'c' => 3, 'd' => 4 }.to_json,
+              "x-app-usage" => { 'e' => 5, 'f' => 6 }.to_json
             )
-            expect(error.fb_error_trace_id).to eq(headers["x-fb-trace-id"])
+            expect(error.fb_error_debug_trace_id).to eq(headers["x-fb-trace-id"])
             expect(error.fb_error_debug).to eq(headers["x-fb-debug"])
             expect(error.fb_error_rev).to eq(headers["x-fb-rev"])
+            expect(error.fb_buc_usage).to eq({ 'a' => 1, 'b' => 2 })
+            expect(error.fb_ada_usage).to eq({ 'c' => 3, 'd' => 4 })
+            expect(error.fb_app_usage).to eq({ 'e' => 5, 'f' => 6 })
+          end
+
+          it "logs if one of the FB debug headers can't be parsed" do
+            headers.merge!(
+              "x-app-usage" => '{invalid:json}'
+            )
+
+            expect(Koala::Utils.logger).to receive(:error).with(/JSON::ParserError:.*unexpected token at '{invalid:json}' while parsing x-app-usage = {invalid:json}/)
+            expect(error.fb_app_usage).to eq(nil)
           end
 
           context "it returns an AuthenticationError" do

data/spec/cases/http_service/request_spec.rb

@@ -176,9 +176,9 @@ module Koala
         end
 
         describe "ssl options" do
-          it "does nothing if there's no access token" do
+          it "includes the default SSL options even if there's no access token" do
             request_options = Request.new(path: path, args: args.delete_if {|k, _v| k == "access_token"}, verb: verb, options: options).options
-            expect(request_options).not_to include(:ssl, :use_ssl)
+            expect(request_options).to include(use_ssl: true, ssl: {verify: true})
           end
 
           context "if there is an access_token" do
@@ -193,9 +193,9 @@ module Koala
             end
 
             it "overrides default SSL options with what's provided" do
-              new_ssl_options = {verify: :dunno}
-              request_options = Request.new(path: path, args: args, verb: verb, options: options.merge(ssl: new_ssl_options)).options
-              expect(request_options[:ssl]).to include(new_ssl_options)
+              new_ssl_options = {use_ssl: false, ssl:{verify: :dunno}}
+              request_options = Request.new(path: path, args: args, verb: verb, options: options.merge(new_ssl_options)).options
+              expect(request_options).to include(new_ssl_options)
             end
           end
         end
@@ -211,9 +211,17 @@ module Koala
               expect(request.server).to eq("https://foo")
             end
 
-            context "if options[:use_ssl] is false (e.g. no access token)" do
+            context "if there is no access token" do
               let(:args) { {"a" => "b"} }
 
+              it "uses https" do
+                expect(request.server).to eq("https://graph.facebook.com")
+              end
+            end
+
+            context "if options[:use_ssl] is false" do
+              let(:options) { {use_ssl: false} }
+
               it "uses http" do
                 expect(request.server).to eq("http://graph.facebook.com")
               end

data/spec/cases/http_service_spec.rb

@@ -39,8 +39,7 @@ describe Koala::HTTPService do
 
     it "adds the right default middleware" do
       Koala::HTTPService::DEFAULT_MIDDLEWARE.call(builder)
-      expect(builder.requests).to eq([:url_encoded])
-      expect(builder.uses).to eq([Koala::HTTPService::MultipartRequest])
+      expect(builder.requests).to eq([:multipart, :url_encoded])
       expect(builder.adapters).to eq([Faraday.default_adapter])
     end
   end
@@ -122,7 +121,8 @@ describe Koala::HTTPService do
 
     let(:verb) { "get" }
     let(:options) { {} }
-    let(:request) { Koala::HTTPService::Request.new(path: "/foo", verb: verb, args: {"an" => :arg}, options: options) }
+    let(:args) { {"an" => :arg } }
+    let(:request) { Koala::HTTPService::Request.new(path: "/foo", verb: verb, args: args, options: options) }
 
     shared_examples_for :making_a_request do
       before :each do
@@ -153,7 +153,8 @@ describe Koala::HTTPService do
 
       it "logs verb, url and params to debug" do
         log_message = "#{verb.upcase}: #{request.path} params: #{request.raw_args.inspect}"
-        expect(Koala::Utils.logger).to receive(:debug).with(log_message)
+        expect(Koala::Utils.logger).to receive(:debug).with("STARTED => #{log_message}")
+        expect(Koala::Utils.logger).to receive(:debug).with("FINISHED => #{log_message}")
 
         Koala::HTTPService.make_request(request)
       end
@@ -192,18 +193,16 @@ describe Koala::HTTPService do
 
     it "uses the default builder block if HTTPService.faraday_middleware block is not defined" do
       block = Proc.new { |builder|
-        builder.use Koala::HTTPService::MultipartRequest
+        builder.request :multipart
         builder.request :url_encoded
-        builder.use Koala::HTTPService::MultipartRequest
       }
       stub_const("Koala::HTTPService::DEFAULT_MIDDLEWARE", block)
       allow(Koala::HTTPService).to receive(:faraday_middleware).and_return(nil)
 
       expect_any_instance_of(Faraday::Connection).to receive(:get) do |instance|
         expect(instance.builder.handlers).to eq([
-          Koala::HTTPService::MultipartRequest,
+          Faraday::Multipart::Middleware,
           Faraday::Request::UrlEncoded,
-          Koala::HTTPService::MultipartRequest
         ])
         mock_http_response
       end
@@ -213,22 +212,57 @@ describe Koala::HTTPService do
 
     it "uses the defined HTTPService.faraday_middleware block if defined" do
       block = Proc.new { |builder|
-        builder.use Koala::HTTPService::MultipartRequest
+        builder.request :multipart
         builder.request :url_encoded
-        builder.use Koala::HTTPService::MultipartRequest
       }
       expect(Koala::HTTPService).to receive(:faraday_middleware).and_return(block)
 
       expect_any_instance_of(Faraday::Connection).to receive(:get) do |instance|
         expect(instance.builder.handlers).to eq([
-          Koala::HTTPService::MultipartRequest,
+          Faraday::Multipart::Middleware,
           Faraday::Request::UrlEncoded,
-          Koala::HTTPService::MultipartRequest
         ])
         mock_http_response
       end
 
       Koala::HTTPService.make_request(request)
     end
+
+    context 'log_tokens configuration' do
+      let(:args) { { "an" => :arg, "access_token" => "myvisbleaccesstoken" } }
+
+      before(:each) do
+        allow_any_instance_of(Faraday::Connection).to receive(:get) { double(status: '200', body: 'ok', headers: {}) }
+      end
+
+      it 'logs tokens' do
+        allow(Koala.config).to receive(:mask_tokens) { false }
+
+        expect(Koala::Utils).to receive(:debug).with('STARTED => GET: /foo params: {"an"=>:arg, "access_token"=>"myvisbleaccesstoken"}')
+        expect(Koala::Utils).to receive(:debug).with('FINISHED => GET: /foo params: {"an"=>:arg, "access_token"=>"myvisbleaccesstoken"}')
+
+        Koala::HTTPService.make_request(request)
+      end
+
+      it 'doesnt log tokens' do
+        allow(Koala.config).to receive(:mask_tokens) { true }
+
+        expect(Koala::Utils).to receive(:debug).with('STARTED => GET: /foo params: {"an"=>:arg, "access_token"=>"myvisbleac*****token"}')
+        expect(Koala::Utils).to receive(:debug).with('FINISHED => GET: /foo params: {"an"=>:arg, "access_token"=>"myvisbleac*****token"}')
+
+        Koala::HTTPService.make_request(request)
+      end
+
+      it 'hides the token for the debug_token api endpoint' do
+        request = Koala::HTTPService::Request.new(path: "/debug_token", verb: verb, args: { input_token: 'myvisibleaccesstoken', 'access_token' => 'myvisibleaccesstoken' }, options: options)
+
+        allow(Koala.config).to receive(:mask_tokens) { true }
+
+        expect(Koala::Utils).to receive(:debug).with('STARTED => GET: /debug_token params: {"input_token"=>"myvisiblea*****token", "access_token"=>"myvisiblea*****token"}')
+        expect(Koala::Utils).to receive(:debug).with('FINISHED => GET: /debug_token params: {"input_token"=>"myvisiblea*****token", "access_token"=>"myvisiblea*****token"}')
+
+        Koala::HTTPService.make_request(request)
+      end
+    end
   end
 end

data/spec/fixtures/vcr_cassettes/app_test_accounts.yml

@@ -2,7 +2,7 @@
 http_interactions:
 - request:
     method: get
-    uri: https://graph.facebook.com/v2.8/119908831367602/accounts?access_token=**
+    uri: https://graph.facebook.com/v2.8/119908831367602/accounts?access_token=********************
     body:
       encoding: US-ASCII
       string: ''

data/spec/support/koala_test.rb

@@ -238,11 +238,11 @@ module KoalaTest
         # JRuby doesn't support typhoeus on Travis
         unless defined? JRUBY_VERSION
           require adapter
-          require 'typhoeus/adapters/faraday' if adapter.to_s == "typhoeus"
+          require "faraday/#{adapter}"
           Faraday.default_adapter = adapter.to_sym
         end
-      rescue ParserError
-        puts "Unable to load adapter #{adapter}, using Net::HTTP."
+      rescue => e
+        puts "Unable to load adapter #{adapter}, using Net::HTTP. #{e.class} #{e.message}"
       ensure
         @adapter_activation_attempted = true
       end

data/spec/support/mock_http_service.rb

@@ -8,7 +8,7 @@ module Koala
     # Mocks all HTTP requests for with koala_spec_with_mocks.rb
     # Mocked values to be included in TEST_DATA used in specs
     ACCESS_TOKEN = '*'
-    APP_ACCESS_TOKEN = "**"
+    APP_ACCESS_TOKEN = "********************"
     OAUTH_CODE = 'OAUTHCODE'
 
     # Loads testing data
@@ -30,7 +30,7 @@ module Koala
 
     # Loads the mock response data via ERB to substitue values for TEST_DATA (see oauth/access_token)
     mock_response_file_path = File.join(File.dirname(__FILE__), '..', 'fixtures', 'mock_facebook_responses.yml')
-    RESPONSES = YAML.load(ERB.new(IO.read(mock_response_file_path)).result(binding))
+    RESPONSES = YAML.safe_load(ERB.new(IO.read(mock_response_file_path)).result(binding), [], [], true)
 
     def self.make_request(request)
       if response = match_response(request.raw_path, request.raw_args, request.raw_verb, request.raw_options)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: koala
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.6.0
 platform: ruby
 authors:
 - Alex Koppel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-17 00:00:00.000000000 Z
+date: 2024-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday-multipart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: addressable
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rexml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 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
@@ -64,9 +106,9 @@ extra_rdoc_files:
 - readme.md
 - changelog.md
 files:
+- ".github/workflows/test.yml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
 - ".yardopts"
 - Gemfile
 - ISSUE_TEMPLATE
@@ -87,7 +129,6 @@ files:
 - lib/koala/configuration.rb
 - lib/koala/errors.rb
 - lib/koala/http_service.rb
-- lib/koala/http_service/multipart_request.rb
 - lib/koala/http_service/request.rb
 - lib/koala/http_service/response.rb
 - lib/koala/http_service/uploadable_io.rb
@@ -109,7 +150,6 @@ files:
 - spec/cases/http_service_spec.rb
 - spec/cases/koala_spec.rb
 - spec/cases/koala_test_spec.rb
-- spec/cases/multipart_request_spec.rb
 - spec/cases/oauth_spec.rb
 - spec/cases/realtime_updates_spec.rb
 - spec/cases/test_users_spec.rb
@@ -151,42 +191,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 3.3.26
 signing_key: 
 specification_version: 4
 summary: A lightweight, flexible library for Facebook with support for the Graph API,
   the REST API, realtime updates, and OAuth authentication.
-test_files:
-- spec/cases/api_spec.rb
-- spec/cases/configuration_spec.rb
-- spec/cases/error_spec.rb
-- spec/cases/graph_api_batch_spec.rb
-- spec/cases/graph_api_spec.rb
-- spec/cases/graph_collection_spec.rb
-- spec/cases/graph_error_checker_spec.rb
-- spec/cases/http_service/request_spec.rb
-- spec/cases/http_service/response_spec.rb
-- spec/cases/http_service_spec.rb
-- spec/cases/koala_spec.rb
-- spec/cases/koala_test_spec.rb
-- spec/cases/multipart_request_spec.rb
-- spec/cases/oauth_spec.rb
-- spec/cases/realtime_updates_spec.rb
-- spec/cases/test_users_spec.rb
-- spec/cases/uploadable_io_spec.rb
-- spec/cases/utils_spec.rb
-- spec/fixtures/beach.jpg
-- spec/fixtures/cat.m4v
-- spec/fixtures/facebook_data.yml
-- spec/fixtures/mock_facebook_responses.yml
-- spec/fixtures/vcr_cassettes/app_test_accounts.yml
-- spec/fixtures/vcr_cassettes/friend_list_next_page.yml
-- spec/integration/graph_collection_spec.rb
-- spec/spec_helper.rb
-- spec/support/custom_matchers.rb
-- spec/support/graph_api_shared_examples.rb
-- spec/support/koala_test.rb
-- spec/support/mock_http_service.rb
-- spec/support/uploadable_io_shared_examples.rb
-has_rdoc: 
+test_files: []

data/.travis.yml

@@ -1,19 +0,0 @@
-language: ruby
-sudo: false
-cache: bundler
-rvm:
-  # MRI
-  - 2.1
-  - 2.2
-  - 2.3.1
-  - 2.4.0
-  # Rubinius is failing due to segfaults on Travis (and takes significantly longer to run)
-  # those builds will be restored later
-  # jruby
-  # - jruby-19mode
-bundler_args: --without development
-addons:
-  code_climate:
-    repo_token: 7af99d9225b4c14640f9ec3cb2e24d2f7103ac49417b0bd989188fb6c25f2909
-after_success:
-    - bundle exec codeclimate-test-reporter

data/lib/koala/http_service/multipart_request.rb

@@ -1,37 +0,0 @@
-require 'faraday'
-
-module Koala
-  module HTTPService
-    class MultipartRequest < Faraday::Request::Multipart
-      # Facebook expects nested parameters to be passed in a certain way
-      # Based on our testing (https://github.com/arsduo/koala/issues/125),
-      # 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
-
-
-      def process_params(params, prefix = nil, pieces = nil, &block)
-        params.inject(pieces || []) do |all, (key, value)|
-          key = "#{prefix}%5B#{key}%5D" if prefix
-
-          case value
-          when Array
-            values = value.inject([]) { |a,v| a << [nil, v] }
-            process_params(values, key, all, &block)
-          when Hash
-            process_params(value, key, all, &block)
-          else
-            all << block.call(key, value)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/cases/multipart_request_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-describe Koala::HTTPService::MultipartRequest do
-  it "is a subclass of Faraday::Request::Multipart" do
-    expect(Koala::HTTPService::MultipartRequest.superclass).to eq(Faraday::Request::Multipart)
-  end
-
-  it "defines mime_type as multipart/form-data" do
-    expect(Koala::HTTPService::MultipartRequest.mime_type).to eq('multipart/form-data')
-  end
-
-  describe "#process_request?" do
-    before :each do
-      @env = Faraday::Env.new
-      @multipart = Koala::HTTPService::MultipartRequest.new
-      allow(@multipart).to receive(:request_type).and_return("")
-    end
-
-    # no way to test the call to super, unfortunately
-    it "returns true if env[:body] is a hash with at least one hash in its values" do
-      @env[:body] = {:a => {:c => 2}}
-      expect(@multipart.process_request?(@env)).to be_truthy
-    end
-
-    it "returns true if env[:body] is a hash with at least one array in its values" do
-      @env[:body] = {:a => [:c, 2]}
-      expect(@multipart.process_request?(@env)).to be_truthy
-    end
-
-    it "returns true if env[:body] is a hash with mixed objects in its values" do
-      @env[:body] = {:a => [:c, 2], :b => {:e => :f}}
-      expect(@multipart.process_request?(@env)).to be_truthy
-    end
-
-    it "returns false if env[:body] is a string" do
-      @env[:body] = "my body"
-      expect(@multipart.process_request?(@env)).to be_falsey
-    end
-
-    it "returns false if env[:body] is a hash without an array or hash value" do
-      @env[:body] = {:a => 3}
-      expect(@multipart.process_request?(@env)).to be_falsey
-    end
-  end
-
-  describe "#process_params" do
-    before :each do
-      @parent = Faraday::Request::Multipart.new
-      @multipart = Koala::HTTPService::MultipartRequest.new
-      @block = lambda {|k, v| "#{k}=#{v}"}
-    end
-
-    it "is identical to the parent for requests without a prefix" do
-      hash = {:a => 2, :c => "3"}
-      expect(@multipart.process_params(hash, &@block)).to eq(@parent.process_params(hash, &@block))
-    end
-
-    it "replaces encodes [ and ] if the request has a prefix" do
-      hash = {:a => 2, :c => "3"}
-      prefix = "foo"
-      # process_params returns an array
-      expect(@multipart.process_params(hash, prefix, &@block).join("&")).to eq(@parent.process_params(hash, prefix, &@block).join("&").gsub(/\[/, "%5B").gsub(/\]/, "%5D"))
-    end
-  end
-end