faraday_middleware 0.8.4 → 0.8.5

data/Gemfile

@@ -1,6 +1,10 @@
 source 'http://rubygems.org'
 
-gem 'simplecov' unless ENV['CI']
+platforms :ruby_19 do
+  gem 'simplecov'
+  gem 'cane'
+end
+
 gem 'json', :platforms => [:ruby_18, :jruby]
 gem 'jruby-openssl', '~> 0.7', :platforms => :jruby
 

data/Rakefile

@@ -1,6 +1,10 @@
 #!/usr/bin/env rake
 
-task :default => [:enable_coverage, :spec, :test]
+if defined? RUBY_ENGINE and 'ruby' == RUBY_ENGINE and '1.9.3' == RUBY_VERSION
+  task :default => [:enable_coverage, :spec, :test, :quality]
+else
+  task :default => [:spec, :test]
+end
 
 require 'bundler'
 Bundler::GemHelper.install_tasks
@@ -9,9 +13,16 @@ require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
 task :enable_coverage do
-  ENV['COVERAGE'] = 'yes' unless ENV['CI']
+  ENV['COVERAGE'] = 'yes'
 end
 
 task :test do
   sh 'ruby', '-Ilib', 'spec/caching_test.rb'
 end
+
+task :quality do
+  sh 'cane',
+    '--style-measure=100',
+    '--gte=coverage/covered_percent,99',
+    '--max-violations=2' # TODO: remove for cane > 1.0.0
+end

data/lib/faraday_middleware/instrumentation.rb

@@ -7,10 +7,10 @@ module FaradayMiddleware
   #
   # Examples
   #
-  #   ActiveSupport::Notifications.subscribe('request.faraday') do |name, start_time, end_time, _, env|
+  #   ActiveSupport::Notifications.subscribe('request.faraday') do |name, starts, ends, _, env|
   #     url = env[:url]
   #     http_method = env[:method].to_s.upcase
-  #     duration = end_time - start_time
+  #     duration = ends - starts
   #     $stderr.puts '[%s] %s %s (%.3f s)' % [url.host, http_method, url.request_uri, duration]
   #   end
   class Instrumentation < Faraday::Middleware

data/lib/faraday_middleware/rack_compatible.rb

@@ -26,11 +26,7 @@ module FaradayMiddleware
 
     # faraday to rack-compatible
     def prepare_env(env)
-      env[:request_headers].each do |name, value|
-        name = name.upcase.tr('-', '_')
-        name = "HTTP_#{name}" unless NonPrefixedHeaders.include? name
-        env[name] = value
-      end
+      headers_to_rack(env)
 
       url = env[:url]
       env['rack.url_scheme'] = url.scheme
@@ -44,6 +40,14 @@ module FaradayMiddleware
       env
     end
 
+    def headers_to_rack(env)
+      env[:request_headers].each do |name, value|
+        name = name.upcase.tr('-', '_')
+        name = "HTTP_#{name}" unless NonPrefixedHeaders.include? name
+        env[name] = value
+      end
+    end
+
     # rack to faraday-compatible
     def restore_env(env)
       headers = env[:request_headers]

data/lib/faraday_middleware/request/oauth.rb

@@ -1,4 +1,5 @@
 require 'faraday'
+require 'forwardable'
 
 module FaradayMiddleware
   # Public: Uses the simple_oauth library to sign requests according the
@@ -11,14 +12,25 @@ module FaradayMiddleware
   # The signature is added to the "Authorization" HTTP request header. If the
   # value for this header already exists, it is not overriden.
   #
-  # For requests that have parameters in the body, such as POST, this
-  # middleware expects them to be in Hash form, i.e. not encoded to string.
-  # This means this middleware has to be positioned on the stack before any
-  # encoding middleware such as UrlEncoded.
+  # If no Content-Type header is specified, this middleware assumes that
+  # request body parameters should be included while signing the request.
+  # Otherwise, it only includes them if the Content-Type is
+  # "application/x-www-form-urlencoded", as per OAuth 1.0.
+  #
+  # For better performance while signing requests, this middleware should be
+  # positioned before UrlEncoded middleware on the stack, but after any other
+  # body-encoding middleware (such as EncodeJson).
   class OAuth < Faraday::Middleware
     dependency 'simple_oauth'
 
     AUTH_HEADER = 'Authorization'.freeze
+    CONTENT_TYPE = 'Content-Type'.freeze
+    TYPE_URLENCODED = 'application/x-www-form-urlencoded'.freeze
+
+    extend Forwardable
+    parser_method = :parse_nested_query
+    parser_module = ::Faraday::Utils.respond_to?(parser_method) ? 'Faraday::Utils' : 'Rack::Utils'
+    def_delegator parser_module, parser_method
 
     def initialize(app, options)
       super(app)
@@ -50,7 +62,18 @@ module FaradayMiddleware
     end
 
     def body_params(env)
-      env[:body] || {}
+      if include_body_params?(env)
+        if env[:body].respond_to?(:to_str)
+          parse_nested_query env[:body]
+        else
+          env[:body]
+        end
+      end || {}
+    end
+
+    def include_body_params?(env)
+      # see RFC 5489, section 3.4.1.3.1 for details
+      !(type = env[:request_headers][CONTENT_TYPE]) or type == TYPE_URLENCODED
     end
 
     def signature_params(params)

data/lib/faraday_middleware/response/follow_redirects.rb

@@ -1,6 +1,8 @@
 require 'faraday'
+require 'set'
 
 module FaradayMiddleware
+  # Public: Exception thrown when the maximum amount of requests is exceeded.
   class RedirectLimitReached < Faraday::Error::ClientError
     attr_reader :response
 
@@ -10,10 +12,34 @@ module FaradayMiddleware
     end
   end
 
-  # Public: Follow HTTP 30x redirects.
+  # Public: Follow HTTP 301, 302, 303, and 307 redirects for GET, PATCH, POST,
+  # PUT, and DELETE requests.
+  #
+  # This middleware does not follow the HTTP specification for HTTP 302, by
+  # default, in that it follows the improper implementation used by most major
+  # web browsers which forces the redirected request to become a GET request
+  # regardless of the original request method.
+  #
+  # For HTTP 301, 302, and 303, the original request is transformed into a
+  # GET request to the response Location, by default. However, with standards
+  # compliance enabled, a 302 will instead act in accordance with the HTTP
+  # specification, which will replay the original request to the received
+  # Location, just as with a 307.
+  #
+  # For HTTP 307, the original request is replayed to the response Location,
+  # including original HTTP request method (GET, POST, PUT, DELETE, PATCH),
+  # original headers, and original body.
+  #
+  # This middleware currently only works with synchronous requests; in other
+  # words, it doesn't support parallelism.
   class FollowRedirects < Faraday::Middleware
-    # TODO: 307 & standards-compliant 302
-    REDIRECTS = [301, 302, 303]
+    # HTTP methods for which 30x redirects can be followed
+    ALLOWED_METHODS = Set.new [:get, :post, :put, :patch, :delete]
+    # HTTP redirect status codes that this middleware implements
+    REDIRECT_CODES  = Set.new [301, 302, 303, 307]
+    # Keys in env hash which will get cleared between requests
+    ENV_TO_CLEAR    = Set.new [:status, :response, :response_headers]
+
     # Default value for max redirects followed
     FOLLOW_LIMIT = 3
 
@@ -21,33 +47,67 @@ module FaradayMiddleware
     #
     # options - An options Hash (default: {}):
     #           limit - A Numeric redirect limit (default: 3)
+    #           standards_compliant - A Boolean indicating whether to respect
+    #                                 the HTTP spec when following 302
+    #                                 (default: false)
     def initialize(app, options = {})
       super(app)
       @options = options
+
+      @replay_request_codes = Set.new [307]
+      @replay_request_codes << 302 if standards_compliant?
     end
 
     def call(env)
-      process_response(@app.call(env), follow_limit)
+      perform_with_redirection(env, follow_limit)
     end
 
-    def process_response(response, follows)
+    private
+
+    def transform_into_get?(response)
+      !@replay_request_codes.include? response.status
+    end
+
+    def perform_with_redirection(env, follows)
+      request_body = env[:body]
+      response = @app.call(env)
+
       response.on_complete do |env|
-        if redirect? response
+        if follow_redirect?(env, response)
           raise RedirectLimitReached, response if follows.zero?
-          env[:url] += response['location']
-          env[:method] = :get
-          response = process_response(@app.call(env), follows - 1)
+          env = update_env(env, request_body, response)
+          response = perform_with_redirection(env, follows - 1)
         end
       end
       response
     end
 
-    def redirect?(response)
-      REDIRECTS.include? response.status
+    def update_env(env, request_body, response)
+      env[:url] += response['location']
+
+      if transform_into_get?(response)
+        env[:method] = :get
+        env[:body] = nil
+      else
+        env[:body] = request_body
+      end
+
+      ENV_TO_CLEAR.each {|key| env.delete key }
+
+      env
+    end
+
+    def follow_redirect?(env, response)
+      ALLOWED_METHODS.include? env[:method] and
+        REDIRECT_CODES.include? response.status
     end
 
     def follow_limit
       @options.fetch(:limit, FOLLOW_LIMIT)
     end
+
+    def standards_compliant?
+      @options.fetch(:standards_compliant, false)
+    end
   end
 end

data/lib/faraday_middleware/response/mashify.rb

@@ -1,6 +1,8 @@
 require 'faraday'
 
 module FaradayMiddleware
+  # Public: Converts parsed response bodies to a Hashie::Mash if they were of
+  # Hash or Array type.
   class Mashify < Faraday::Response::Middleware
     class << self
       attr_accessor :mash_class

data/lib/faraday_middleware/response/parse_json.rb

@@ -26,9 +26,19 @@ module FaradayMiddleware
       end
 
       BRACKETS = %w- [ { -
+      WHITESPACE = [ " ", "\n", "\r", "\t" ]
 
       def parse_response?(env)
-        super and BRACKETS.include? env[:body][0,1]
+        super and BRACKETS.include? first_char(env[:body])
+      end
+
+      def first_char(body)
+        idx = -1
+        begin
+          char = body[idx += 1]
+          char = char.chr if char
+        end while char and WHITESPACE.include? char
+        char
       end
     end
   end

data/lib/faraday_middleware/response/parse_xml.rb

@@ -1,6 +1,7 @@
 require 'faraday_middleware/response_middleware'
 
 module FaradayMiddleware
+  # Public: parses response bodies with MultiXml.
   class ParseXml < ResponseMiddleware
     dependency 'multi_xml'
 

data/lib/faraday_middleware/response/rashify.rb

@@ -1,6 +1,8 @@
 require 'faraday_middleware/response/mashify'
 
 module FaradayMiddleware
+  # Public: Converts parsed response bodies to a Hashie::Rash if they were of
+  # Hash or Array type.
   class Rashify < Mashify
     dependency do
       require 'rash'

data/lib/faraday_middleware/version.rb

@@ -1,3 +1,3 @@
 module FaradayMiddleware
-  VERSION = "0.8.4"
+  VERSION = "0.8.5"
 end

data/spec/follow_redirects_spec.rb

@@ -1,33 +1,182 @@
 require 'helper'
 require 'faraday_middleware/response/follow_redirects'
 require 'faraday'
-require 'forwardable'
+
+# expose a method in Test adapter that should have been public
+Faraday::Adapter::Test::Stubs.class_eval { public :new_stub }
 
 describe FaradayMiddleware::FollowRedirects do
-  let(:connection) {
-    Faraday.new do |c|
-      c.use described_class
-      c.adapter :test do |stub|
-        stub.get('/')        { [301, {'Location' => '/found'}, ''] }
-        stub.post('/create') { [302, {'Location' => '/'}, ''] }
-        stub.get('/found')   { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
-        stub.get('/loop')    { [302, {'Location' => '/loop'}, ''] }
+  let(:middleware_options) { Hash.new }
+
+  shared_examples_for 'a successful redirection' do |status_code|
+    it "follows the redirection for a GET request" do
+      connection do |stub|
+        stub.get('/permanent') { [status_code, {'Location' => '/found'}, ''] }
+        stub.get('/found') { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
+      end.get('/permanent').body.should eql 'fin'
+    end
+
+    [:head, :options].each do |method|
+      it "returning the response headers for a #{method.to_s.upcase} request" do
+        connection do |stub|
+          stub.new_stub(method, '/permanent') { [status_code, {'Location' => '/found'}, ''] }
+        end.run_request(method, '/permanent', nil, nil).headers['Location'].should eql('/found')
+      end
+    end
+  end
+
+  shared_examples_for 'a forced GET redirection' do |status_code|
+    [:put, :post, :delete, :patch].each do |method|
+      it "a #{method.to_s.upcase} request is converted to a GET" do
+        connection = connection do |stub|
+          stub.new_stub(method, '/redirect') {
+            [status_code, {'Location' => '/found'}, 'elsewhere']
+          }
+          stub.get('/found') { |env|
+            body = env[:body] and body.empty? && (body = nil)
+            [200, {'Content-Type' => 'text/plain'}, body.inspect]
+          }
+        end.run_request(method, '/redirect', 'request data', nil).body.should eql('nil')
+      end
+    end
+  end
+
+  shared_examples_for 'a replayed redirection' do |status_code|
+    it 'redirects with the original request headers' do
+      conn = connection do |stub|
+        stub.get('/redirect') {
+          [status_code, {'Location' => '/found'}, '']
+        }
+        stub.get('/found') { |env|
+          [200, {'Content-Type' => 'text/plain'}, env[:request_headers]['X-Test-Value']]
+        }
+      end
+
+      response = conn.get('/redirect') { |req|
+        req.headers['X-Test-Value'] = 'success'
+      }
+
+      response.body.should eql('success')
+    end
+
+    [:put, :post, :delete, :patch].each do |method|
+      it "replays a #{method.to_s.upcase} request" do
+        connection do |stub|
+          stub.new_stub(method, '/redirect') { [status_code, {'Location' => '/found'}, ''] }
+          stub.new_stub(method, '/found') { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
+        end.run_request(method, '/redirect', nil, nil).body.should eql 'fin'
+      end
+    end
+
+    [:put, :post, :patch].each do |method|
+      it "forwards request body for a #{method.to_s.upcase} request" do
+        conn = connection do |stub|
+          stub.new_stub(method, '/redirect') {
+            [status_code, {'Location' => '/found'}, '']
+          }
+          stub.new_stub(method, '/found') { |env|
+            [200, {'Content-Type' => 'text/plain'}, env[:body]]
+          }
+        end
+
+        response = conn.run_request(method, '/redirect', 'original data', nil)
+        response.body.should eql('original data')
       end
     end
-  }
+  end
 
-  extend Forwardable
-  def_delegators :connection, :get, :post
 
-  it "follows redirect" do
-    get('/').body.should eql('fin')
+  it "returns non-redirect response results" do
+    connection do |stub|
+      stub.get('/found') { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
+    end.get('/found').body.should eql 'fin'
   end
 
-  it "follows redirect twice" do
-    post('/create').body.should eql('fin')
+  it "follows a single redirection" do
+    connection do |stub|
+      stub.get('/')      { [301, {'Location' => '/found'}, ''] }
+      stub.get('/found') { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
+    end.get('/').body.should eql 'fin'
   end
 
-  it "raises exception on loop" do
-    expect { get('/loop') }.to raise_error(FaradayMiddleware::RedirectLimitReached)
+  it "follows many redirections" do
+    connection do |stub|
+      stub.get('/')          { [301, {'Location' => '/redirect1'}, ''] }
+      stub.get('/redirect1') { [301, {'Location' => '/redirect2'}, ''] }
+      stub.get('/redirect2') { [301, {'Location' => '/found'}, ''] }
+      stub.get('/found')     { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
+    end.get('/').body.should eql 'fin'
+  end
+
+  it "raises a FaradayMiddleware::RedirectLimitReached after 3 redirections (by default)" do
+    conn = connection do |stub|
+      stub.get('/')          { [301, {'Location' => '/redirect1'}, ''] }
+      stub.get('/redirect1') { [301, {'Location' => '/redirect2'}, ''] }
+      stub.get('/redirect2') { [301, {'Location' => '/redirect3'}, ''] }
+      stub.get('/redirect3') { [301, {'Location' => '/found'}, ''] }
+      stub.get('/found')     { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
+    end
+
+    expect { conn.get('/') }.to raise_error(FaradayMiddleware::RedirectLimitReached)
+  end
+
+  it "raises a FaradayMiddleware::RedirectLimitReached after the initialized limit" do
+    conn = connection(:limit => 1) do |stub|
+      stub.get('/')          { [301, {'Location' => '/redirect1'}, ''] }
+      stub.get('/redirect1') { [301, {'Location' => '/found'}, ''] }
+      stub.get('/found')     { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
+    end
+
+    expect { conn.get('/') }.to raise_error(FaradayMiddleware::RedirectLimitReached)
+  end
+
+  context 'for an HTTP 301 response' do
+    it_should_behave_like 'a successful redirection', 301
+    it_should_behave_like 'a forced GET redirection', 301
+  end
+
+  context 'for an HTTP 302 response' do
+    it_should_behave_like 'a successful redirection', 302
+
+    context 'by default' do
+      it_should_behave_like 'a forced GET redirection', 302
+    end
+
+    context 'with standards compliancy enabled' do
+      let(:middleware_options) { { :standards_compliant => true } }
+      it_should_behave_like 'a replayed redirection', 302
+    end
+  end
+
+  context 'for an HTTP 303 response' do
+    it_should_behave_like 'a successful redirection', 303
+    it_should_behave_like 'a forced GET redirection', 303
+  end
+
+  context 'for an HTTP 307 response' do
+    it_should_behave_like 'a successful redirection', 307
+    it_should_behave_like 'a replayed redirection', 307
+  end
+
+  # checks env hash in request phase for basic validity
+  class Lint < Struct.new(:app)
+    def call(env)
+      if env[:status] or env[:response] or env[:response_headers]
+        raise "invalid request: #{env.inspect}"
+      end
+      app.call(env)
+    end
+  end
+
+  private
+
+  def connection(options = middleware_options)
+    Faraday.new do |c|
+      c.use described_class, options
+      c.use Lint
+      c.adapter :test do |stub|
+        yield(stub) if block_given?
+      end
+    end
   end
 end

data/spec/helper.rb

@@ -1,5 +1,16 @@
 if ENV['COVERAGE']
   require 'simplecov'
+
+  class SimpleCov::Formatter::QualityFormatter
+    def format(result)
+      SimpleCov::Formatter::HTMLFormatter.new.format(result)
+      File.open('coverage/covered_percent', 'w') do |f|
+        f.puts result.source_files.covered_percent.to_i
+      end
+    end
+  end
+  SimpleCov.formatter = SimpleCov::Formatter::QualityFormatter
+
   SimpleCov.start do
     # add_filter 'faraday_middleware.rb'
     add_filter 'backwards_compatibility.rb'

data/spec/mashify_spec.rb

@@ -70,7 +70,10 @@ describe FaradayMiddleware::Mashify do
     # although it is not good practice to pass a hash as the body, if we add ParseJson
     # to the middleware stack we end up testing two middlewares instead of one
     it 'should create a Hash from the body' do
-      stubs.get('/hash') {[200, {'content-type' => 'application/json; charset=utf-8'}, { "name" => "Erik Michaels-Ober", "username" => "sferik" }]}
+      stubs.get('/hash') {
+        data = { 'name' => 'Erik Michaels-Ober', 'username' => 'sferik' }
+        [200, {'content-type' => 'application/json; charset=utf-8'}, data]
+      }
       me = connection.get('/hash').body
       me.name.should == 'Erik Michaels-Ober'
       me.username.should == 'sferik'

data/spec/oauth_spec.rb

@@ -1,6 +1,7 @@
 require 'helper'
 require 'faraday_middleware/request/oauth'
 require 'uri'
+require 'forwardable'
 
 describe FaradayMiddleware::OAuth do
   def auth_header(env)
@@ -14,11 +15,12 @@ describe FaradayMiddleware::OAuth do
     end
   end
 
-  def perform(oauth_options = {}, headers = {})
+  def perform(oauth_options = {}, headers = {}, params = {})
     env = {
       :url => URI('http://example.com/'),
       :request_headers => Faraday::Utils::Headers.new.update(headers),
-      :request => {}
+      :request => {},
+      :body => params
     }
     unless oauth_options.is_a? Hash and oauth_options.empty?
       env[:request][:oauth] = oauth_options
@@ -98,4 +100,52 @@ describe FaradayMiddleware::OAuth do
       auth.should_not include('oauth_token')
     end
   end
+
+  context "handling body parameters" do
+    let(:options) { [{ :consumer_key => 'CKEY',
+                       :consumer_secret => 'CSECRET',
+                       :nonce => '547fed103e122eecf84c080843eedfe6',
+                       :timestamp => '1286830180'}] }
+
+    let(:value) { {'foo' => 'bar'} }
+
+    let(:type_json) { {'Content-Type' => 'application/json'} }
+    let(:type_form) { {'Content-Type' => 'application/x-www-form-urlencoded'} }
+
+    extend Forwardable
+    query_method = :build_nested_query
+    query_module = ::Faraday::Utils.respond_to?(query_method) ? 'Faraday::Utils' : 'Rack::Utils'
+    def_delegator query_module, query_method
+
+    it "does not include the body for JSON" do
+      auth_header_with    = auth_header(perform({}, type_json, '{"foo":"bar"}'))
+      auth_header_without = auth_header(perform({}, type_json, {}))
+
+      auth_header_with.should == auth_header_without
+    end
+
+    it "includes the body parameters with form Content-Type" do
+      auth_header_with    = auth_header(perform({}, type_form, {}))
+      auth_header_without = auth_header(perform({}, type_form, value))
+
+      auth_header_with.should_not == auth_header_without
+    end
+
+    it "includes the body parameters with an unspecified Content-Type" do
+      auth_header_with    = auth_header(perform({}, {}, value))
+      auth_header_without = auth_header(perform({}, type_form, value))
+
+      auth_header_with.should == auth_header_without
+    end
+
+    it "includes the body parameters for form type with string body" do
+      # simulates the behavior of Faraday::MiddleWare::UrlEncoded
+      value = { 'foo' => ['bar', 'baz', 'wat'] }
+      auth_header_hash   = auth_header(perform({}, type_form, value))
+      auth_header_string = auth_header(perform({}, type_form, build_nested_query(value)))
+      auth_header_string.should == auth_header_hash
+    end
+
+  end
+
 end

data/spec/parse_json_spec.rb

@@ -90,5 +90,11 @@ describe FaradayMiddleware::ParseJson, :type => :response do
       response.body.should be_a(Hash)
       response['content-type'].should eql('application/json')
     end
+
+    it "corrects compatible type even when data starts with whitespace" do
+      response = process(%( \r\n\t{"a":1}), 'text/javascript')
+      response.body.should be_a(Hash)
+      response['content-type'].should eql('application/json')
+    end
   end
 end

data/spec/rashify_spec.rb

@@ -60,7 +60,10 @@ describe FaradayMiddleware::Rashify do
     # although it is not good practice to pass a hash as the body, if we add ParseJson
     # to the middleware stack we end up testing two middlewares instead of one
     it 'should create a Hash from the body' do
-      stubs.get('/hash') {[200, {'content-type' => 'application/json; charset=utf-8'}, { "name" => "Erik Michaels-Ober", "username" => "sferik" }]}
+      stubs.get('/hash') {
+        data = { 'name' => 'Erik Michaels-Ober', 'username' => 'sferik' }
+        [200, {'content-type' => 'application/json; charset=utf-8'}, data]
+      }
       me = connection.get('/hash').body
       me.name.should == 'Erik Michaels-Ober'
       me.username.should == 'sferik'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: faraday_middleware
 version: !ruby/object:Gem::Version
-  version: 0.8.4
+  version: 0.8.5
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-30 00:00:00.000000000 Z
+date: 2012-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
-  requirement: &70176520423440 !ruby/object:Gem::Requirement
+  requirement: &70319499815400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -25,10 +25,10 @@ dependencies:
         version: '0.9'
   type: :runtime
   prerelease: false
-  version_requirements: *70176520423440
+  version_requirements: *70319499815400
 - !ruby/object:Gem::Dependency
   name: multi_xml
-  requirement: &70176520413280 !ruby/object:Gem::Requirement
+  requirement: &70319499836420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -36,10 +36,10 @@ dependencies:
         version: '0.2'
   type: :development
   prerelease: false
-  version_requirements: *70176520413280
+  version_requirements: *70319499836420
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70176520410400 !ruby/object:Gem::Requirement
+  requirement: &70319499834040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -47,10 +47,10 @@ dependencies:
         version: '0.9'
   type: :development
   prerelease: false
-  version_requirements: *70176520410400
+  version_requirements: *70319499834040
 - !ruby/object:Gem::Dependency
   name: hashie
-  requirement: &70176520395720 !ruby/object:Gem::Requirement
+  requirement: &70319499847520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -58,10 +58,10 @@ dependencies:
         version: '1.2'
   type: :development
   prerelease: false
-  version_requirements: *70176520395720
+  version_requirements: *70319499847520
 - !ruby/object:Gem::Dependency
   name: rash
-  requirement: &70176520393980 !ruby/object:Gem::Requirement
+  requirement: &70319499843360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -69,10 +69,10 @@ dependencies:
         version: '0.3'
   type: :development
   prerelease: false
-  version_requirements: *70176520393980
+  version_requirements: *70319499843360
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70176520392900 !ruby/object:Gem::Requirement
+  requirement: &70319499841140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -80,10 +80,10 @@ dependencies:
         version: '2.6'
   type: :development
   prerelease: false
-  version_requirements: *70176520392900
+  version_requirements: *70319499841140
 - !ruby/object:Gem::Dependency
   name: simple_oauth
-  requirement: &70176520391440 !ruby/object:Gem::Requirement
+  requirement: &70319499852100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -91,10 +91,10 @@ dependencies:
         version: '0.1'
   type: :development
   prerelease: false
-  version_requirements: *70176520391440
+  version_requirements: *70319499852100
 - !ruby/object:Gem::Dependency
   name: rack-cache
-  requirement: &70176520390140 !ruby/object:Gem::Requirement
+  requirement: &70319499897100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -102,7 +102,7 @@ dependencies:
         version: '1.1'
   type: :development
   prerelease: false
-  version_requirements: *70176520390140
+  version_requirements: *70319499897100
 description: Various middleware for Faraday
 email:
 - sferik@gmail.com