faraday 0.9.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1c31dbb021fc6a43b4f0b102a9a3ccf52a72303a
-  data.tar.gz: 54da868027777adb5a21145bd6433b0154af2297
+  metadata.gz: 88d17f843f96e641d4cb8b87b360b99adfee6c53
+  data.tar.gz: 3c0031b2fa042939cc5e7f27aefa00f8ebe6a97f
 SHA512:
-  metadata.gz: 22c1c286687ca596bd1d6b7d9a6a3749731f6d8962a5bbbe7e1e39cf22e364b92010ae44446cf1804ba10567a2e6409cc2be537375d9f47ace9bca909196dcd3
-  data.tar.gz: 7e8116cdeea918b8e7de661ec6d49d839960e26f136903e53db62e8cc353f89b3ac053d5efe6401995129418ae4dfce8fda9c8a471093223dca08002615d10e1
+  metadata.gz: 03fa51e8008930909fb2e5f40afe8f3d59d176574a084e364569d256b0c073bd06796bb0fe96f79c42cfacda2ee8417fecb1b3fc13e5b46bbb76f960136d116c
+  data.tar.gz: 16432e693c7c666ac40de8a03ca890f08ee1cba705477afd31d64346282f018abf9ee617e1996330bbe2b2c3352021683e386522d700c49d08246b77d36fb65a

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2009-2013 Rick Olson, Zack Hobson
+Copyright (c) 2009-2015 Rick Olson, Zack Hobson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -6,7 +6,8 @@ processing the request/response cycle.
 
 Faraday supports these adapters:
 
-* Net::HTTP
+* [Net::HTTP][net_http] _(default)_
+* [Net::HTTP::Persistent][persistent]
 * [Excon][]
 * [Typhoeus][]
 * [Patron][]
@@ -16,6 +17,10 @@ Faraday supports these adapters:
 It also includes a Rack adapter for hitting loaded Rack applications through
 Rack::Test, and a Test adapter for stubbing requests by hand.
 
+## API documentation
+
+Available at [rubydoc.info](http://www.rubydoc.info/gems/faraday).
+
 ## Usage
 
 ```ruby
@@ -25,6 +30,14 @@ conn = Faraday.new(:url => 'http://sushi.com') do |faraday|
   faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
 end
 
+# Filter sensitive information from logs with a regex matcher
+
+conn = Faraday.new(:url => 'http://sushi.com/api_key=s3cr3t') do |faraday|
+  faraday.response :logger do | logger |
+    logger.filter(/(api_key=)(\w+)/,'\1[REMOVED]')
+  end
+end
+
 ## GET ##
 
 response = conn.get '/nigiri/sake.json'     # GET http://sushi.com/nigiri/sake.json
@@ -64,6 +77,32 @@ stack and default adapter (see [Faraday::RackBuilder#initialize](https://github.
 response = Faraday.get 'http://sushi.com/nigiri/sake.json'
 ```
 
+### Changing how parameters are serialized
+
+Sometimes you need to send the same URL parameter multiple times with different
+values. This requires manually setting the parameter encoder and can be done on
+either per-connection or per-request basis.
+
+```ruby
+# per-connection setting
+conn = Faraday.new :request => { :params_encoder => Faraday::FlatParamsEncoder }
+
+conn.get do |req|
+  # per-request setting:
+  # req.options.params_encoder = my_encoder
+  req.params['roll'] = ['california', 'philadelphia']
+end
+# GET 'http://sushi.com?roll=california&roll=philadelphia'
+```
+
+The value of Faraday `params_encoder` can be any object that responds to:
+
+* `encode(hash) #=> String`
+* `decode(string) #=> Hash`
+
+The encoder will affect both how query strings are processed and how POST bodies
+get serialized. The default encoder is Faraday::NestedParamsEncoder.
+
 ## Advanced middleware usage
 
 The order in which middleware is stacked is important. Like with Rack, the
@@ -183,13 +222,9 @@ stubs.verify_stubbed_calls
 This library aims to support and is [tested against][travis] the following Ruby
 implementations:
 
-* MRI 1.8.7
-* MRI 1.9.2
-* MRI 1.9.3
-* MRI 2.0.0
-* MRI 2.1.0
-* [JRuby][]
-* [Rubinius][]
+* Ruby 1.9.3+
+* [JRuby][] 1.7+
+* [Rubinius][] 2+
 
 If something doesn't work on one of these Ruby versions, it's a bug.
 
@@ -209,12 +244,14 @@ of a major release, support for that Ruby version may be dropped.
 Copyright (c) 2009-2013 [Rick Olson](mailto:technoweenie@gmail.com), Zack Hobson.
 See [LICENSE][] for details.
 
-[travis]:    http://travis-ci.org/lostisland/faraday
-[excon]:     https://github.com/geemus/excon#readme
-[typhoeus]:  https://github.com/typhoeus/typhoeus#readme
-[patron]:    http://toland.github.com/patron/
+[net_http]:     http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/Net/HTTP.html
+[persistent]:   https://github.com/drbrain/net-http-persistent
+[travis]:       https://travis-ci.org/lostisland/faraday
+[excon]:        https://github.com/excon/excon#readme
+[typhoeus]:     https://github.com/typhoeus/typhoeus#readme
+[patron]:       http://toland.github.io/patron/
 [eventmachine]: https://github.com/igrigorik/em-http-request#readme
-[httpclient]: https://github.com/nahi/httpclient
-[jruby]:     http://jruby.org/
-[rubinius]:  http://rubini.us/
-[license]:   LICENSE.md
+[httpclient]:   https://github.com/nahi/httpclient
+[jruby]:        http://jruby.org/
+[rubinius]:     http://rubini.us/
+[license]:      LICENSE.md

data/lib/faraday/adapter/em_http.rb

@@ -138,9 +138,11 @@ module Faraday
 
       # TODO: reuse the connection to support pipelining
       def perform_single_request(env)
-        req = EventMachine::HttpRequest.new(env[:url], connection_config(env))
+        req = create_request(env)
         req.setup_request(env[:method], request_config(env)).callback { |client|
-          save_response(env, client.response_header.status, client.response) do |resp_headers|
+          status = client.response_header.status
+          reason = client.response_header.http_reason
+          save_response(env, status, client.response, nil, reason) do |resp_headers|
             client.response_header.each do |name, value|
               resp_headers[name.to_sym] = value
             end
@@ -148,6 +150,10 @@ module Faraday
         }
       end
 
+      def create_request(env)
+        EventMachine::HttpRequest.new(env[:url], connection_config(env).merge(@connection_options))
+      end
+
       def error_message(client)
         client.error or "request failed"
       end

data/lib/faraday/adapter/em_http_ssl_patch.rb

@@ -39,7 +39,7 @@ module EmHttpSslPatch
   end
 
   def host
-    parent.connopts.host
+    parent.uri.host
   end
 
   def certificate_store

data/lib/faraday/adapter/em_synchrony.rb

@@ -19,7 +19,7 @@ module Faraday
 
       def call(env)
         super
-        request = EventMachine::HttpRequest.new(Utils::URI(env[:url].to_s), connection_config(env))
+        request = create_request(env)
 
         http_method = env[:method].to_s.downcase.to_sym
 
@@ -54,7 +54,9 @@ module Faraday
 
           raise client.error if client.error
 
-          save_response(env, client.response_header.status, client.response) do |resp_headers|
+          status = client.response_header.status
+          reason = client.response_header.http_reason
+          save_response(env, status, client.response, nil, reason) do |resp_headers|
             client.response_header.each do |name, value|
               resp_headers[name.to_sym] = value
             end
@@ -70,6 +72,14 @@ module Faraday
         else
           raise Error::ConnectionFailed, err
         end
+      rescue Errno::ETIMEDOUT => err
+        raise Error::TimeoutError, err
+      rescue RuntimeError => err
+        if err.message == "connection closed by server"
+          raise Error::ConnectionFailed, err
+        else
+          raise
+        end
       rescue => err
         if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
           raise Faraday::SSLError, err
@@ -77,6 +87,10 @@ module Faraday
           raise
         end
       end
+
+      def create_request(env)
+        EventMachine::HttpRequest.new(Utils::URI(env[:url].to_s), connection_config(env).merge(@connection_options))
+      end
     end
   end
 end

data/lib/faraday/adapter/excon.rb

@@ -3,11 +3,6 @@ module Faraday
     class Excon < Faraday::Adapter
       dependency 'excon'
 
-      def initialize(app, connection_options = {})
-        @connection_options = connection_options
-        super(app)
-      end
-
       def call(env)
         super
 
@@ -41,6 +36,7 @@ module Faraday
           if req[:proxy]
             opts[:proxy] = {
               :host     => req[:proxy][:uri].host,
+              :hostname => req[:proxy][:uri].hostname,
               :port     => req[:proxy][:uri].port,
               :scheme   => req[:proxy][:uri].scheme,
               :user     => req[:proxy][:user],
@@ -49,14 +45,14 @@ module Faraday
           end
         end
 
-        conn = ::Excon.new(env[:url].to_s, opts.merge(@connection_options))
+        conn = create_connection(env, opts)
 
         resp = conn.request \
           :method  => env[:method].to_s.upcase,
           :headers => env[:request_headers],
           :body    => read_body(env)
 
-        save_response(env, resp.status.to_i, resp.body, resp.headers)
+        save_response(env, resp.status.to_i, resp.body, resp.headers, resp.reason_phrase)
 
         @app.call env
       rescue ::Excon::Errors::SocketError => err
@@ -71,6 +67,10 @@ module Faraday
         raise Error::TimeoutError, err
       end
 
+      def create_connection(env, opts)
+        ::Excon.new(env[:url].to_s, opts.merge(@connection_options))
+      end
+
       # TODO: support streaming requests
       def read_body(env)
         env[:body].respond_to?(:read) ? env[:body].read : env[:body]

data/lib/faraday/adapter/httpclient.rb

@@ -10,6 +10,9 @@ module Faraday
       def call(env)
         super
 
+        # enable compression
+        client.transparent_gzip_decompression = true
+
         if req = env[:request]
           if proxy = req[:proxy]
             configure_proxy proxy
@@ -26,6 +29,8 @@ module Faraday
           configure_ssl ssl
         end
 
+        configure_client
+
         # TODO Don't stream yet.
         # https://github.com/nahi/httpclient/pull/90
         env[:body] = env[:body].read if env[:body].respond_to? :read
@@ -34,10 +39,10 @@ module Faraday
           :body   => env[:body],
           :header => env[:request_headers]
 
-        save_response env, resp.status, resp.body, resp.headers
+        save_response env, resp.status, resp.body, resp.headers, resp.reason
 
         @app.call env
-      rescue ::HTTPClient::TimeoutError
+      rescue ::HTTPClient::TimeoutError, Errno::ETIMEDOUT
         raise Faraday::Error::TimeoutError, $!
       rescue ::HTTPClient::BadResponseError => err
         if err.message.include?('status 407')
@@ -45,7 +50,7 @@ module Faraday
         else
           raise Faraday::Error::ClientError, $!
         end
-      rescue Errno::ECONNREFUSED, EOFError
+      rescue Errno::ECONNREFUSED, IOError
         raise Faraday::Error::ConnectionFailed, $!
       rescue => err
         if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
@@ -69,14 +74,14 @@ module Faraday
 
       def configure_ssl(ssl)
         ssl_config = client.ssl_config
+        ssl_config.verify_mode = ssl_verify_mode(ssl)
+        ssl_config.cert_store = ssl_cert_store(ssl)
 
         ssl_config.add_trust_ca ssl[:ca_file]        if ssl[:ca_file]
         ssl_config.add_trust_ca ssl[:ca_path]        if ssl[:ca_path]
-        ssl_config.cert_store   = ssl[:cert_store]   if ssl[:cert_store]
         ssl_config.client_cert  = ssl[:client_cert]  if ssl[:client_cert]
         ssl_config.client_key   = ssl[:client_key]   if ssl[:client_key]
         ssl_config.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
-        ssl_config.verify_mode  = ssl_verify_mode(ssl)
       end
 
       def configure_timeouts(req)
@@ -92,6 +97,23 @@ module Faraday
         end
       end
 
+      def configure_client
+        @config_block.call(client) if @config_block
+      end
+
+      def ssl_cert_store(ssl)
+        return ssl[:cert_store] if ssl[:cert_store]
+        # Memoize the cert store so that the same one is passed to
+        # HTTPClient each time, to avoid resyncing SSL sesions when
+        # it's changed
+        @cert_store ||= begin
+          # Use the default cert store by default, i.e. system ca certs
+          cert_store = OpenSSL::X509::Store.new
+          cert_store.set_default_paths
+          cert_store
+        end
+      end
+
       def ssl_verify_mode(ssl)
         ssl[:verify_mode] || begin
           if ssl.fetch(:verify, true)

data/lib/faraday/adapter/net_http.rb

@@ -10,13 +10,14 @@ module Faraday
   class Adapter
     class NetHttp < Faraday::Adapter
       NET_HTTP_EXCEPTIONS = [
-        EOFError,
+        IOError,
         Errno::ECONNABORTED,
         Errno::ECONNREFUSED,
         Errno::ECONNRESET,
         Errno::EHOSTUNREACH,
         Errno::EINVAL,
         Errno::ENETUNREACH,
+        Errno::EPIPE,
         Net::HTTPBadResponse,
         Net::HTTPHeaderSyntaxError,
         Net::ProtocolError,
@@ -31,10 +32,7 @@ module Faraday
         super
         with_net_http_connection(env) do |http|
           configure_ssl(http, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
-
-          req = env[:request]
-          http.read_timeout = http.open_timeout = req[:timeout] if req[:timeout]
-          http.open_timeout = req[:open_timeout]                if req[:open_timeout]
+          configure_request(http, env[:request])
 
           begin
             http_response = perform_request(http, env)
@@ -46,7 +44,7 @@ module Faraday
             end
           end
 
-          save_response(env, http_response.code.to_i, http_response.body || '') do |response_headers|
+          save_response(env, http_response.code.to_i, http_response.body || '', nil, http_response.message) do |response_headers|
             http_response.each_header do |key, value|
               response_headers[key] = value
             end
@@ -54,7 +52,7 @@ module Faraday
         end
 
         @app.call env
-      rescue Timeout::Error => err
+      rescue Timeout::Error, Errno::ETIMEDOUT => err
         raise Faraday::Error::TimeoutError, err
       end
 
@@ -92,7 +90,7 @@ module Faraday
           Net::HTTP::Proxy(proxy[:uri].host, proxy[:uri].port, proxy[:user], proxy[:password])
         else
           Net::HTTP
-        end.new(env[:url].host, env[:url].port)
+        end.new(env[:url].host, env[:url].port || (env[:url].scheme == 'https' ? 443 : 80))
       end
 
       def configure_ssl(http, ssl)
@@ -108,6 +106,13 @@ module Faraday
         http.ssl_version  = ssl[:version]      if ssl[:version]
       end
 
+      def configure_request(http, req)
+        http.read_timeout = http.open_timeout = req[:timeout] if req[:timeout]
+        http.open_timeout = req[:open_timeout]                if req[:open_timeout]
+
+        @config_block.call(http) if @config_block
+      end
+
       def ssl_cert_store(ssl)
         return ssl[:cert_store] if ssl[:cert_store]
         # Use the default cert store by default, i.e. system ca certs

data/lib/faraday/adapter/net_http_persistent.rb

@@ -4,12 +4,11 @@
 
 module Faraday
   class Adapter
-    # Experimental adapter for net-http-persistent
     class NetHttpPersistent < NetHttp
       dependency 'net/http/persistent'
 
-      def with_net_http_connection(env)
-        if proxy = env[:request][:proxy]
+      def net_http_connection(env)
+        if (proxy = env[:request][:proxy])
           proxy_uri = ::URI::HTTP === proxy[:uri] ? proxy[:uri].dup : ::URI.parse(proxy[:uri].to_s)
           proxy_uri.user = proxy_uri.password = nil
           # awful patch for net-http-persistent 2.8 not unescaping user/password
@@ -17,13 +16,16 @@ module Faraday
             define_method(:user) { proxy[:user] }
             define_method(:password) { proxy[:password] }
           end if proxy[:user]
+          return Net::HTTP::Persistent.new 'Faraday', proxy_uri
         end
 
-        yield Net::HTTP::Persistent.new 'Faraday', proxy_uri
+        Net::HTTP::Persistent.new 'Faraday'
       end
 
       def perform_request(http, env)
         http.request env[:url], create_request(env)
+      rescue Errno::ETIMEDOUT => error
+        raise Faraday::Error::TimeoutError, error
       rescue Net::HTTP::Persistent::Error => error
         if error.message.include? 'Timeout'
           raise Faraday::Error::TimeoutError, error

data/lib/faraday/adapter/patron.rb

@@ -3,11 +3,6 @@ module Faraday
     class Patron < Faraday::Adapter
       dependency 'patron'
 
-      def initialize(app, &block)
-        super(app)
-        @block = block
-      end
-
       def call(env)
         super
 
@@ -35,7 +30,10 @@ module Faraday
           raise Error::ConnectionFailed, $!
         end
 
-        save_response(env, response.status, response.body, response.headers)
+        # Remove the "HTTP/1.1 200", leaving just the reason phrase
+        reason_phrase = response.status_line.gsub(/^.* \d{3} /, '')
+
+        save_response(env, response.status, response.body, response.headers, reason_phrase)
 
         @app.call env
       rescue ::Patron::TimeoutError => err
@@ -56,15 +54,21 @@ module Faraday
         # HAX: helps but doesn't work completely
         # https://github.com/toland/patron/issues/34
         ::Patron::Request::VALID_ACTIONS.tap do |actions|
-          actions << :patch unless actions.include? :patch
-          actions << :options unless actions.include? :options
+          if actions[0].is_a?(Symbol)
+            actions << :patch unless actions.include? :patch
+            actions << :options unless actions.include? :options
+          else
+            # Patron 0.4.20 and up
+            actions << "PATCH" unless actions.include? "PATCH"
+            actions << "OPTIONS" unless actions.include? "OPTIONS"
+          end
         end
       end
 
       def create_session
         session = ::Patron::Session.new
         session.insecure = true
-        @block.call(session) if @block
+        @config_block.call(session) if @config_block
         session
       end
     end

data/lib/faraday/adapter/test.rb

@@ -1,16 +1,41 @@
 module Faraday
   class Adapter
-    # test = Faraday::Connection.new do
-    #   use Faraday::Adapter::Test do |stub|
-    #     stub.get '/nigiri/sake.json' do
-    #       [200, {}, 'hi world']
+    # Examples
+    #
+    #   test = Faraday::Connection.new do
+    #     use Faraday::Adapter::Test do |stub|
+    #       # simply define matcher to match the request
+    #       stub.get '/resource.json' do
+    #         # return static content
+    #         [200, {'Content-Type' => 'application/json'}, 'hi world']
+    #       end
+    #       
+    #       # response with content generated based on request
+    #       stub.get '/showget' do |env|
+    #         [200, {'Content-Type' => 'text/plain'}, env[:method].to_s]
+    #       end
+    #       
+    #       # regular expression can be used as matching filter
+    #       stub.get /\A\/items\/(\d+)\z/ do |env, meta|
+    #         # in case regular expression is used an instance of MatchData can be received
+    #         [200, {'Content-Type' => 'text/plain'}, "showing item: #{meta[:match_data][1]}"]
+    #       end
     #     end
     #   end
-    # end
-    #
-    # resp = test.get '/nigiri/sake.json'
-    # resp.body # => 'hi world'
+    #   
+    #   resp = test.get '/resource.json'
+    #   resp.body # => 'hi world'
+    #   
+    #   resp = test.get '/showget'
+    #   resp.body # => 'get'
+    #   
+    #   resp = test.get '/items/1'
+    #   resp.body # => 'showing item: 1'
+    #   
+    #   resp = test.get '/items/2'
+    #   resp.body # => 'showing item: 2'
     #
+
     class Test < Faraday::Adapter
       attr_accessor :stubs
 
@@ -33,12 +58,12 @@ module Faraday
           stack = @stack[request_method]
           consumed = (@consumed[request_method] ||= [])
 
-          if stub = matches?(stack, path, headers, body)
+          stub, meta = matches?(stack, path, headers, body)
+          if stub
             consumed << stack.delete(stub)
-            stub
-          else
-            matches?(consumed, path, headers, body)
+            return stub, meta
           end
+          matches?(consumed, path, headers, body)
         end
 
         def get(path, headers = {}, &block)
@@ -85,18 +110,22 @@ module Faraday
         protected
 
         def new_stub(request_method, path, headers = {}, body=nil, &block)
-          normalized_path = Faraday::Utils.normalize_path(path)
+          normalized_path = path.is_a?(Regexp) ? path : Faraday::Utils.normalize_path(path)
           (@stack[request_method] ||= []) << Stub.new(normalized_path, headers, body, block)
         end
 
         def matches?(stack, path, headers, body)
-          stack.detect { |stub| stub.matches?(path, headers, body) }
+          stack.each do |stub|
+            match_result, meta = stub.matches?(path, headers, body)
+            return stub, meta if match_result
+          end
+          nil
         end
       end
 
       class Stub < Struct.new(:path, :params, :headers, :body, :block)
         def initialize(full, headers, body, block)
-          path, query = full.split('?')
+          path, query = full.respond_to?(:split) ? full.split("?") : full
           params = query ?
             Faraday::Utils.parse_nested_query(query) :
             {}
@@ -108,10 +137,21 @@ module Faraday
           request_params = request_query ?
             Faraday::Utils.parse_nested_query(request_query) :
             {}
-          request_path == path &&
+          # meta is a hash use as carrier
+          # that will be yielded to consumer block
+          meta = {}
+          return path_match?(request_path, meta) &&
             params_match?(request_params) &&
             (body.to_s.size.zero? || request_body == body) &&
-            headers_match?(request_headers)
+            headers_match?(request_headers), meta
+        end
+
+        def path_match?(request_path, meta)
+          if path.is_a? Regexp
+            !!(meta[:match_data] = path.match(request_path))
+          else
+            path == request_path
+          end
         end
 
         def params_match?(request_params)
@@ -146,11 +186,14 @@ module Faraday
         normalized_path = Faraday::Utils.normalize_path(env[:url])
         params_encoder = env.request.params_encoder || Faraday::Utils.default_params_encoder
 
-        if stub = stubs.match(env[:method], normalized_path, env.request_headers, env[:body])
+        stub, meta = stubs.match(env[:method], normalized_path, env.request_headers, env[:body])
+        if stub
           env[:params] = (query = env[:url].query) ?
-            params_encoder.decode(query)  :
-            {}
-          status, headers, body = stub.block.call(env)
+            params_encoder.decode(query) : {}
+          block_arity = stub.block.arity
+          status, headers, body = (block_arity >= 0) ?
+            stub.block.call(*[env, meta].take(block_arity)) :
+            stub.block.call(env, meta)
           save_response(env, status, body, headers)
         else
           raise Stubs::NotFound, "no stubbed request for #{env[:method]} #{normalized_path} #{env[:body]}"

data/lib/faraday/adapter.rb

@@ -30,13 +30,20 @@ module Faraday
     extend Parallelism
     self.supports_parallel = false
 
+    def initialize(app = nil, opts = {}, &block)
+      super(app)
+      @connection_options = opts
+      @config_block = block
+    end
+
     def call(env)
       env.clear_body if env.needs_body?
     end
 
-    def save_response(env, status, body, headers = nil)
+    def save_response(env, status, body, headers = nil, reason_phrase = nil)
       env.status = status
       env.body = body
+      env.reason_phrase = reason_phrase && reason_phrase.to_s.strip
       env.response_headers = Utils::Headers.new.tap do |response_headers|
         response_headers.update headers unless headers.nil?
         yield(response_headers) if block_given?