faraday_middleware 0.8.8 → 0.9.0

data/Gemfile

@@ -2,7 +2,7 @@ source 'http://rubygems.org'
 
 platforms :mri_19 do
   gem 'simplecov'
-  gem 'cane', '>= 0.3'
+  gem 'cane', '~> 2.2.2'
 end
 
 gem 'json', :platforms => [:ruby_18, :jruby]

data/Rakefile

@@ -14,14 +14,16 @@ task :enable_coverage do
   ENV['COVERAGE'] = 'yes'
 end
 
+desc %(Run Test::Unit tests)
 task :test do
   sh 'ruby', '-Ilib', 'spec/caching_test.rb'
 end
 
+desc %(Check code quality metrics with Cane)
 task :quality do
   sh 'cane',
-    '--abc-max=10',
-    '--style-measure=100',
+    '--abc-max=15',
+    '--style-measure=110',
     '--gte=coverage/covered_percent,99',
-    '--max-violations=2'
+    '--max-violations=0'
 end

data/lib/faraday_middleware.rb

@@ -4,12 +4,14 @@ module FaradayMiddleware
   autoload :OAuth,           'faraday_middleware/request/oauth'
   autoload :OAuth2,          'faraday_middleware/request/oauth2'
   autoload :EncodeJson,      'faraday_middleware/request/encode_json'
+  autoload :MethodOverride,  'faraday_middleware/request/method_override'
   autoload :Mashify,         'faraday_middleware/response/mashify'
   autoload :Rashify,         'faraday_middleware/response/rashify'
   autoload :ParseJson,       'faraday_middleware/response/parse_json'
   autoload :ParseXml,        'faraday_middleware/response/parse_xml'
   autoload :ParseMarshal,    'faraday_middleware/response/parse_marshal'
   autoload :ParseYaml,       'faraday_middleware/response/parse_yaml'
+  autoload :ParseDates,      'faraday_middleware/response/parse_dates'
   autoload :Caching,         'faraday_middleware/response/caching'
   autoload :Chunked,         'faraday_middleware/response/chunked'
   autoload :RackCompatible,  'faraday_middleware/rack_compatible'
@@ -20,7 +22,8 @@ module FaradayMiddleware
     Faraday.register_middleware :request,
       :oauth    => lambda { OAuth },
       :oauth2   => lambda { OAuth2 },
-      :json     => lambda { EncodeJson }
+      :json     => lambda { EncodeJson },
+      :method_override => lambda { MethodOverride }
 
     Faraday.register_middleware :response,
       :mashify  => lambda { Mashify },
@@ -30,6 +33,7 @@ module FaradayMiddleware
       :xml      => lambda { ParseXml },
       :marshal  => lambda { ParseMarshal },
       :yaml     => lambda { ParseYaml },
+      :dates    => lambda { ParseDates },
       :caching  => lambda { Caching },
       :follow_redirects => lambda { FollowRedirects },
       :chunked => lambda { Chunked }

data/lib/faraday_middleware/request/method_override.rb

@@ -0,0 +1,51 @@
+require 'faraday'
+
+module FaradayMiddleware
+  # Public: Writes the original HTTP method to "X-Http-Method-Override" header
+  # and sends the request as POST.
+  #
+  # This can be used to work around technical issues with making non-POST
+  # requests, e.g. faulty HTTP client or server router.
+  #
+  # This header is recognized in Rack apps by default, courtesy of the
+  # Rack::MethodOverride module. See
+  # http://rack.rubyforge.org/doc/classes/Rack/MethodOverride.html
+  class MethodOverride < Faraday::Middleware
+
+    HEADER = "X-Http-Method-Override".freeze
+
+    # Public: Initialize the middleware.
+    #
+    # app     - the Faraday app to wrap
+    # options - (optional)
+    #           :rewrite - Array of HTTP methods to rewrite
+    #                      (default: all but GET and POST)
+    def initialize(app, options = nil)
+      super(app)
+      @methods = options && options.fetch(:rewrite).map { |method|
+        method = method.downcase if method.respond_to? :downcase
+        method.to_sym
+      }
+    end
+
+    def call(env)
+      method = env[:method]
+      rewrite_request(env, method) if rewrite_request?(method)
+      @app.call(env)
+    end
+
+    def rewrite_request?(method)
+      if @methods.nil? or @methods.empty?
+        method != :get and method != :post
+      else
+        @methods.include? method
+      end
+    end
+
+    # Internal: Write the original HTTP method to header, change method to POST.
+    def rewrite_request(env, original_method)
+      env[:request_headers][HEADER] = original_method.to_s.upcase
+      env[:method] = :post
+    end
+  end
+end

data/lib/faraday_middleware/response/follow_redirects.rb

@@ -34,7 +34,7 @@ module FaradayMiddleware
   # words, it doesn't support parallelism.
   class FollowRedirects < Faraday::Middleware
     # HTTP methods for which 30x redirects can be followed
-    ALLOWED_METHODS = Set.new [:get, :post, :put, :patch, :delete]
+    ALLOWED_METHODS = Set.new [:head, :options, :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
@@ -68,6 +68,9 @@ module FaradayMiddleware
     private
 
     def transform_into_get?(response)
+      return false if [:head, :options].include? response.env[:method]
+      # Never convert head or options to a get. That would just be silly.
+
       !@replay_request_codes.include? response.status
     end
 
@@ -87,7 +90,10 @@ module FaradayMiddleware
 
     def update_env(env, request_body, response)
       env[:url] += response['location']
-      env[:request_headers][:cookies] = keep_cookies(env) if @options[:cookies]
+      if @options[:cookies]
+        cookies = keep_cookies(env)
+        env[:request_headers][:cookies] = cookies unless cookies.nil?
+      end
 
       if transform_into_get?(response)
         env[:method] = :get

data/lib/faraday_middleware/version.rb

@@ -1,3 +1,3 @@
 module FaradayMiddleware
-  VERSION = "0.8.8"
+  VERSION = "0.9.0"
 end

data/spec/caching_test.rb

@@ -152,4 +152,4 @@ class HttpCachingTest < Test::Unit::TestCase
     assert_equal 'request:2', post('/').body
     assert_equal 'request:3', post('/').body
   end
-end unless defined? RUBY_ENGINE and "rbx" == RUBY_ENGINE  # rbx bug #1522
+end unless defined? RUBY_ENGINE and "rbx" == RUBY_ENGINE # rbx bug #1522

data/spec/chunked_spec.rb

@@ -4,15 +4,15 @@ require 'faraday_middleware/response/chunked'
 describe FaradayMiddleware::Chunked, :type => :response do
   context "no transfer-encoding" do
     it "doesn't change nil body" do
-      process(nil).body.should be_nil
+      expect(process(nil).body).to be_nil
     end
 
     it "doesn't change an empty body" do
-      process('').body.should eql('')
+      expect(process('').body).to eq('')
     end
 
     it "doesn't change a normal body" do
-      process('asdf').body.should eql('asdf')
+      expect(process('asdf').body).to eq('asdf')
     end
   end
 
@@ -20,15 +20,15 @@ describe FaradayMiddleware::Chunked, :type => :response do
     let(:headers) { {"transfer-encoding" => "gzip"}}
 
     it "doesn't change nil body" do
-      process(nil).body.should be_nil
+      expect(process(nil).body).to be_nil
     end
 
     it "doesn't change an empty body" do
-      process('').body.should eql('')
+      expect(process('').body).to eq('')
     end
 
     it "doesn't change a normal body" do
-      process('asdf').body.should eql('asdf')
+      expect(process('asdf').body).to eq('asdf')
     end
   end
 
@@ -36,35 +36,35 @@ describe FaradayMiddleware::Chunked, :type => :response do
     let(:headers) { {"transfer-encoding" => "chunked"}}
 
     it "doesn't change nil body" do
-      process(nil).body.should be_nil
+      expect(process(nil).body).to be_nil
     end
 
     it "doesn't change an empty body" do
-      process('').body.should eql('')
+      expect(process('').body).to eq('')
     end
 
     it "parses a basic chunked body" do
-      process("10\r\nasdfghjklasdfghj\r\n0\r\n").body.should eql('asdfghjklasdfghj')
+      expect(process("10\r\nasdfghjklasdfghj\r\n0\r\n").body).to eq('asdfghjklasdfghj')
     end
 
     it "parses a chunked body with no ending chunk" do
-      process("10\r\nasdfghjklasdfghj\r\n").body.should eql('asdfghjklasdfghj')
+      expect(process("10\r\nasdfghjklasdfghj\r\n").body).to eq('asdfghjklasdfghj')
     end
 
     it "parses a chunked body with no trailing CRLF on the data chunk" do
-      process("10\r\nasdfghjklasdfghj0\r\n").body.should eql('asdfghjklasdfghj')
+      expect(process("10\r\nasdfghjklasdfghj0\r\n").body).to eq('asdfghjklasdfghj')
     end
 
     it "parses a chunked body with an extension" do
-      process("10;foo=bar\r\nasdfghjklasdfghj\r\n0\r\n").body.should eql('asdfghjklasdfghj')
+      expect(process("10;foo=bar\r\nasdfghjklasdfghj\r\n0\r\n").body).to eq('asdfghjklasdfghj')
     end
 
     it "parses a chunked body with two extensions" do
-      process("10;foo=bar;bar=baz\r\nasdfghjklasdfghj\r\n0\r\n").body.should eql('asdfghjklasdfghj')
+      expect(process("10;foo=bar;bar=baz\r\nasdfghjklasdfghj\r\n0\r\n").body).to eq('asdfghjklasdfghj')
     end
 
     it "parses a chunked body with two chunks" do
-      process("8\r\nasdfghjk\r\n8\r\nlasdfghj\r\n0\r\n").body.should eql('asdfghjklasdfghj')
+      expect(process("8\r\nasdfghjk\r\n8\r\nlasdfghj\r\n0\r\n").body).to eq('asdfghjklasdfghj')
     end
   end
 
@@ -72,7 +72,7 @@ describe FaradayMiddleware::Chunked, :type => :response do
     let(:headers) { {"transfer-encoding" => "chunked,chunked"}}
 
     it "parses a basic chunked body" do
-      process("10\r\nasdfghjklasdfghj\r\n0\r\n").body.should eql('asdfghjklasdfghj')
+      expect(process("10\r\nasdfghjklasdfghj\r\n0\r\n").body).to eq('asdfghjklasdfghj')
     end
   end
 end

data/spec/encode_json_spec.rb

@@ -17,11 +17,11 @@ describe FaradayMiddleware::EncodeJson do
     let(:result) { process(nil) }
 
     it "doesn't change body" do
-      result_body.should be_nil
+      expect(result_body).to be_nil
     end
 
     it "doesn't add content type" do
-      result_type.should be_nil
+      expect(result_type).to be_nil
     end
   end
 
@@ -29,11 +29,11 @@ describe FaradayMiddleware::EncodeJson do
     let(:result) { process('') }
 
     it "doesn't change body" do
-      result_body.should be_empty
+      expect(result_body).to be_empty
     end
 
     it "doesn't add content type" do
-      result_type.should be_nil
+      expect(result_type).to be_nil
     end
   end
 
@@ -41,11 +41,11 @@ describe FaradayMiddleware::EncodeJson do
     let(:result) { process('{"a":1}') }
 
     it "doesn't change body" do
-      result_body.should eql('{"a":1}')
+      expect(result_body).to eq('{"a":1}')
     end
 
     it "adds content type" do
-      result_type.should eql('application/json')
+      expect(result_type).to eq('application/json')
     end
   end
 
@@ -53,11 +53,11 @@ describe FaradayMiddleware::EncodeJson do
     let(:result) { process({:a => 1}) }
 
     it "encodes body" do
-      result_body.should eql('{"a":1}')
+      expect(result_body).to eq('{"a":1}')
     end
 
     it "adds content type" do
-      result_type.should eql('application/json')
+      expect(result_type).to eq('application/json')
     end
   end
 
@@ -65,7 +65,7 @@ describe FaradayMiddleware::EncodeJson do
     let(:result) { process({}) }
 
     it "encodes body" do
-      result_body.should eql('{}')
+      expect(result_body).to eq('{}')
     end
   end
 
@@ -73,11 +73,11 @@ describe FaradayMiddleware::EncodeJson do
     let(:result) { process({:a => 1}, 'application/json; charset=utf-8') }
 
     it "encodes body" do
-      result_body.should eql('{"a":1}')
+      expect(result_body).to eq('{"a":1}')
     end
 
     it "doesn't change content type" do
-      result_type.should eql('application/json; charset=utf-8')
+      expect(result_type).to eq('application/json; charset=utf-8')
     end
   end
 
@@ -85,11 +85,11 @@ describe FaradayMiddleware::EncodeJson do
     let(:result) { process({:a => 1}, 'application/xml; charset=utf-8') }
 
     it "doesn't change body" do
-      result_body.should eql({:a => 1})
+      expect(result_body).to eq({:a => 1})
     end
 
     it "doesn't change content type" do
-      result_type.should eql('application/xml; charset=utf-8')
+      expect(result_type).to eq('application/xml; charset=utf-8')
     end
   end
 end

data/spec/follow_redirects_spec.rb

@@ -8,27 +8,33 @@ Faraday::Adapter::Test::Stubs.class_eval { public :new_stub }
 describe FaradayMiddleware::FollowRedirects do
   let(:middleware_options) { Hash.new }
 
-  shared_examples_for 'a successful redirection' do |status_code|
+  shared_examples_for "a successful redirection" do |status_code|
     it "follows the redirection for a GET request" do
-      connection do |stub|
+      expect(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.get('/permanent').body).to eq '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
+    it "follows the redirection for a HEAD request" do
+      expect(connection do |stub|
+               stub.head('/permanent') { [status_code, {'Location' => '/found'}, ''] }
+               stub.head('/found') { [200, {'Content-Type' => 'text/plain'}, ''] }
+             end.head('/permanent').status).to eq 200
+    end
+
+    it "follows the redirection for a OPTIONS request" do
+      expect(connection do |stub|
+               stub.new_stub(:options, '/permanent') { [status_code, {'Location' => '/found'}, ''] }
+               stub.new_stub(:options, '/found') { [200, {'Content-Type' => 'text/plain'}, ''] }
+             end.run_request(:options, '/permanent', nil, nil).status).to eq 200
     end
   end
 
-  shared_examples_for 'a forced GET redirection' do |status_code|
+  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|
+        expect(connection do |stub|
           stub.new_stub(method, '/redirect') {
             [status_code, {'Location' => '/found'}, 'elsewhere']
           }
@@ -36,13 +42,13 @@ describe FaradayMiddleware::FollowRedirects do
             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.run_request(method, '/redirect', 'request data', nil).body).to eq('nil')
       end
     end
   end
 
-  shared_examples_for 'a replayed redirection' do |status_code|
-    it 'redirects with the original request headers' do
+  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'}, '']
@@ -56,15 +62,15 @@ describe FaradayMiddleware::FollowRedirects do
         req.headers['X-Test-Value'] = 'success'
       }
 
-      response.body.should eql('success')
+      expect(response.body).to eq('success')
     end
 
     [:put, :post, :delete, :patch].each do |method|
       it "replays a #{method.to_s.upcase} request" do
-        connection do |stub|
+        expect(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.run_request(method, '/redirect', nil, nil).body).to eq 'fin'
       end
     end
 
@@ -80,32 +86,32 @@ describe FaradayMiddleware::FollowRedirects do
         end
 
         response = conn.run_request(method, '/redirect', 'original data', nil)
-        response.body.should eql('original data')
+        expect(response.body).to eq('original data')
       end
     end
   end
 
 
   it "returns non-redirect response results" do
-    connection do |stub|
+    expect(connection do |stub|
       stub.get('/found') { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
-    end.get('/found').body.should eql 'fin'
+    end.get('/found').body).to eq 'fin'
   end
 
   it "follows a single redirection" do
-    connection do |stub|
+    expect(connection do |stub|
       stub.get('/')      { [301, {'Location' => '/found'}, ''] }
       stub.get('/found') { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
-    end.get('/').body.should eql 'fin'
+    end.get('/').body).to eq 'fin'
   end
 
   it "follows many redirections" do
-    connection do |stub|
+    expect(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.get('/').body).to eq 'fin'
   end
 
   it "raises a FaradayMiddleware::RedirectLimitReached after 3 redirections (by default)" do
@@ -117,7 +123,7 @@ describe FaradayMiddleware::FollowRedirects do
       stub.get('/found')     { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
     end
 
-    expect { conn.get('/') }.to raise_error(FaradayMiddleware::RedirectLimitReached)
+    expect{ conn.get('/') }.to raise_error(FaradayMiddleware::RedirectLimitReached)
   end
 
   it "raises a FaradayMiddleware::RedirectLimitReached after the initialized limit" do
@@ -127,58 +133,65 @@ describe FaradayMiddleware::FollowRedirects do
       stub.get('/found')     { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
     end
 
-    expect { conn.get('/') }.to raise_error(FaradayMiddleware::RedirectLimitReached)
+    expect{ conn.get('/') }.to raise_error(FaradayMiddleware::RedirectLimitReached)
   end
 
-  context 'when cookies option' do
+  context "when cookies option" do
 
     let(:cookies) { 'cookie1=abcdefg; cookie2=1234567; cookie3=awesome' }
 
     context "is :all" do
       it "puts all cookies from the response into the next request" do
-        conn = connection(:cookies => :all) do |stub|
+        expect(connection(:cookies => :all) do |stub|
           stub.get('/')           { [301, {'Location' => '/found', 'Cookies' => cookies }, ''] }
           stub.get('/found')      { [200, {'Content-Type' => 'text/plain'}, ''] }
-        end.get('/').env[:request_headers][:cookies].should == cookies
+        end.get('/').env[:request_headers][:cookies]).to eq(cookies)
+      end
+
+      it "not set cookies header on request when response has no cookies" do
+        expect(connection(:cookies => :all) do |stub|
+          stub.get('/')           { [301, {'Location' => '/found'}, ''] }
+          stub.get('/found')      { [200, {'Content-Type' => 'text/plain'}, ''] }
+        end.get('/').env[:request_headers].has_key?('Cookies')).to eq(false)
       end
     end
 
     context "is an array of cookie names" do
       it "puts selected cookies from the response into the next request" do
-        conn = connection(:cookies => ['cookie2']) do |stub|
+        expect(connection(:cookies => ['cookie2']) do |stub|
           stub.get('/')           { [301, {'Location' => '/found', 'Cookies' => cookies }, ''] }
           stub.get('/found')      { [200, {'Content-Type' => 'text/plain'}, ''] }
-        end.get('/').env[:request_headers][:cookies].should == 'cookie2=1234567'
+        end.get('/').env[:request_headers][:cookies]).to eq('cookie2=1234567')
       end
     end
   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
+  context "for an HTTP 301 response" do
+    it_behaves_like 'a successful redirection', 301
+    it_behaves_like 'a forced GET redirection', 301
   end
 
-  context 'for an HTTP 302 response' do
-    it_should_behave_like 'a successful redirection', 302
+  context "for an HTTP 302 response" do
+    it_behaves_like 'a successful redirection', 302
 
-    context 'by default' do
-      it_should_behave_like 'a forced GET redirection', 302
+    context "by default" do
+      it_behaves_like 'a forced GET redirection', 302
     end
 
-    context 'with standards compliancy enabled' do
+    context "with standards compliancy enabled" do
       let(:middleware_options) { { :standards_compliant => true } }
-      it_should_behave_like 'a replayed redirection', 302
+      it_behaves_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
+  context "for an HTTP 303 response" do
+    it_behaves_like 'a successful redirection', 303
+    it_behaves_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
+  context "for an HTTP 307 response" do
+    it_behaves_like 'a successful redirection', 307
+    it_behaves_like 'a replayed redirection', 307
   end
 
   # checks env hash in request phase for basic validity