faraday 0.9.1 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1c31dbb021fc6a43b4f0b102a9a3ccf52a72303a
-  data.tar.gz: 54da868027777adb5a21145bd6433b0154af2297
+SHA256:
+  metadata.gz: 3737507d92b48e4b98e891c5026210048ab70b2b1ee17ea20993b8ffc65eafb5
+  data.tar.gz: caaaa7f7ad1bdda848ac7bc70d4d1b9ba9d06bc85912a61b1ee4082086629a26
 SHA512:
-  metadata.gz: 22c1c286687ca596bd1d6b7d9a6a3749731f6d8962a5bbbe7e1e39cf22e364b92010ae44446cf1804ba10567a2e6409cc2be537375d9f47ace9bca909196dcd3
-  data.tar.gz: 7e8116cdeea918b8e7de661ec6d49d839960e26f136903e53db62e8cc353f89b3ac053d5efe6401995129418ae4dfce8fda9c8a471093223dca08002615d10e1
+  metadata.gz: 231b96efdd5b0399f204edaeba22d01661b9d301aff6cad7d097c27c1e95f0a0a8adc9184e88f089862fa9db9a833e50a3eb7bfb96034a2df7f1bdd93661f3fb
+  data.tar.gz: f19fca5f59454b7b620160c3e58339e0dff8049be29bda8e8f1a494455dac6c62a1c6cbe4b4e141e999ea3df25cbcdf3ef09d65e93d71a882c318c75c3070dec

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2009-2013 Rick Olson, Zack Hobson
+Copyright (c) 2009-2017 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

@@ -1,23 +1,56 @@
 # Faraday
 
+[![Gem Version](https://badge.fury.io/rb/faraday.svg)](https://rubygems.org/gems/faraday)
+[![Build Status](https://travis-ci.org/lostisland/faraday.svg)](https://travis-ci.org/lostisland/faraday)
+[![Coverage Status](https://coveralls.io/repos/github/lostisland/faraday/badge.svg?branch=master)](https://coveralls.io/github/lostisland/faraday?branch=master)
+[![Code Climate](https://codeclimate.com/github/lostisland/faraday/badges/gpa.svg)](https://codeclimate.com/github/lostisland/faraday)
+[![Gitter](https://badges.gitter.im/lostisland/faraday.svg)](https://gitter.im/lostisland/faraday?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+
+
 Faraday is an HTTP client lib that provides a common interface over many
 adapters (such as Net::HTTP) and embraces the concept of Rack middleware when
 processing the request/response cycle.
 
-Faraday supports these adapters:
+Faraday supports these adapters out of the box:
 
-* Net::HTTP
+* [Net::HTTP][net_http] _(default)_
+* [Net::HTTP::Persistent][persistent]
 * [Excon][]
-* [Typhoeus][]
 * [Patron][]
 * [EventMachine][]
 * [HTTPClient][]
 
+Adapters are slowly being moved into their own gems, or bundled with HTTP clients:
+
+* [Typhoeus][]
+
 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
 
+### Basic Use
+
+```ruby
+response = Faraday.get 'http://sushi.com/nigiri/sake.json'
+```
+A simple `get` request can be performed by using the syntax described above. This works if you don't need to set up anything; you can roll with just the default middleware
+stack and default adapter (see [Faraday::RackBuilder#initialize](https://github.com/lostisland/faraday/blob/master/lib/faraday/rack_builder.rb)).
+
+A more flexible way to use Faraday is to start with a Connection object. If you want to keep the same defaults, you can use this syntax:
+
+```ruby
+conn = Faraday.new(:url => 'http://www.example.com')
+response = conn.get '/users'                 # GET http://www.example.com/users'
+```
+
+Connections can also take an options hash as a parameter or be configured by using a block. Checkout the section called [Advanced middleware usage](#advanced-middleware-usage) for more details about how to use this block for configurations.
+Since the default middleware stack uses url\_encoded middleware and default adapter, use them on building your own middleware stack.
+
 ```ruby
 conn = Faraday.new(:url => 'http://sushi.com') do |faraday|
   faraday.request  :url_encoded             # form-encode POST params
@@ -25,6 +58,20 @@ 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.request  :url_encoded             # form-encode POST params
+  faraday.response :logger do | logger |
+    logger.filter(/(api_key=)(\w+)/,'\1[REMOVED]')
+  end
+  faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+end
+```
+
+Once you have the connection object, use it to make HTTP requests. You can pass parameters to it in a few different ways:
+
+```ruby
 ## GET ##
 
 response = conn.get '/nigiri/sake.json'     # GET http://sushi.com/nigiri/sake.json
@@ -32,7 +79,7 @@ response.body
 
 conn.get '/nigiri', { :name => 'Maguro' }   # GET http://sushi.com/nigiri?name=Maguro
 
-conn.get do |req|                           # GET http://sushi.com/search?page=2&limit=100
+conn.get do |req|                           # GET http://sushi.com/search?page=2&limit=100  
   req.url '/search', :page => 2
   req.params['limit'] = 100
 end
@@ -40,7 +87,11 @@ end
 ## POST ##
 
 conn.post '/nigiri', { :name => 'Maguro' }  # POST "name=maguro" to http://sushi.com/nigiri
+```
+
+Some configuration options can be adjusted per request:
 
+```ruby
 # post payload as JSON instead of "www-form-urlencoded" encoding:
 conn.post do |req|
   req.url '/nigiri'
@@ -57,11 +108,74 @@ conn.get do |req|
 end
 ```
 
-If you don't need to set up anything, you can roll with just the default middleware
-stack and default adapter (see [Faraday::RackBuilder#initialize](https://github.com/lostisland/faraday/blob/master/lib/faraday/rack_builder.rb)):
+And you can inject arbitrary data into the request using the `context` option:
 
 ```ruby
-response = Faraday.get 'http://sushi.com/nigiri/sake.json'
+# Anything you inject using context option will be available in the env on all middlewares
+
+conn.get do |req|
+  req.url '/search'
+  req.options.context = {
+      foo: 'foo',
+      bar: 'bar'
+  }          
+end
+```
+
+### 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.
+
+## Authentication
+
+Basic and Token authentication are handled by Faraday::Request::BasicAuthentication and Faraday::Request::TokenAuthentication respectively. These can be added as middleware manually or through the helper methods.
+
+```ruby
+Faraday.new(...) do |conn|
+  conn.basic_auth('username', 'password')
+end
+
+Faraday.new(...) do |conn|
+  conn.token_auth('authentication-token')
+end
+```
+
+## Proxy
+
+Faraday will try to automatically infer the proxy settings from your system using `URI#find_proxy`.
+This will retrieve them from environment variables such as http_proxy, ftp_proxy, no_proxy, etc.
+If for any reason you want to disable this behaviour, you can do so by setting the global varibale `ignore_env_proxy`:
+
+```ruby
+Faraday.ignore_env_proxy = true
+```
+
+You can also specify a custom proxy when initializing the connection
+
+```ruby
+Faraday.new('http://www.example.com', :proxy => 'http://proxy.com')
 ```
 
 ## Advanced middleware usage
@@ -76,6 +190,7 @@ Faraday.new(...) do |conn|
   conn.request :multipart
   conn.request :url_encoded
 
+  # Last middleware must be the adapter:
   conn.adapter :net_http
 end
 ```
@@ -138,6 +253,53 @@ later, response. Some keys are:
 :response_headers
 ```
 
+## Ad-hoc adapters customization
+
+Faraday is intended to be a generic interface between your code and the adapter. However, sometimes you need to access a feature specific to one of the adapters that is not covered in Faraday's interface.
+
+When that happens, you can pass a block when specifying the adapter to customize it. The block parameter will change based on the adapter you're using. See below for some examples.
+
+### NetHttp
+```ruby
+conn = Faraday.new(...) do |f|
+  f.adapter :net_http do |http| # yields Net::HTTP
+    http.idle_timeout = 100
+    http.verify_callback = lambda do | preverify_ok, cert_store |
+      # do something here...
+    end
+  end
+end
+```
+
+### NetHttpPersistent
+```ruby
+conn = Faraday.new(...) do |f|
+  f.adapter :net_http_persistent do |http| # yields Net::HTTP::Persistent
+    http.idle_timeout = 100
+    http.retry_change_requests = true
+  end
+end
+```
+
+### Patron
+```ruby
+conn = Faraday.new(...) do |f|
+  f.adapter :patron do |session| # yields Patron::Session
+    session.max_redirects = 10
+  end
+end
+```
+
+### HTTPClient
+```ruby
+conn = Faraday.new(...) do |f|
+  f.adapter :httpclient do |client| # yields HTTPClient
+    client.keep_alive_timeout = 20
+    client.ssl_config.timeout = 25
+  end
+end
+```
+
 ## Using Faraday for testing
 
 ```ruby
@@ -173,23 +335,14 @@ resp = test.get '/else' #=> raises "no such stub" error
 stubs.verify_stubbed_calls
 ```
 
-## TODO
-
-* support streaming requests/responses
-* better stubbing API
-
 ## Supported Ruby versions
 
 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.
 
@@ -204,17 +357,25 @@ implementation, you will be responsible for providing patches in a timely
 fashion. If critical issues for a particular implementation exist at the time
 of a major release, support for that Ruby version may be dropped.
 
+## Contribute
+
+Do you want to contribute to Faraday?
+Open the issues page and check for the `any volunteer?` label!
+But before you start coding, please read our [Contributing Guide](https://github.com/lostisland/faraday/blob/master/.github/CONTRIBUTING.md)
+
 ## Copyright
 
-Copyright (c) 2009-2013 [Rick Olson](mailto:technoweenie@gmail.com), Zack Hobson.
+Copyright (c) 2009-2017 [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
+[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
+[typhoeus]:     https://github.com/typhoeus/typhoeus/blob/master/lib/typhoeus/adapters/faraday.rb
+[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
 
@@ -35,12 +30,12 @@ module Faraday
 
           if req[:open_timeout]
             opts[:connect_timeout]   = req[:open_timeout]
-            opts[:write_timeout]     = req[:open_timeout]
           end
 
           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 +44,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 +66,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, SocketError
         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,10 +52,12 @@ module Faraday
         end
 
         @app.call env
-      rescue Timeout::Error => err
+      rescue Timeout::Error, Errno::ETIMEDOUT => err
         raise Faraday::Error::TimeoutError, err
       end
 
+      private
+
       def create_request(env)
         request = Net::HTTPGenericRequest.new \
           env[:method].to_s.upcase,    # request method
@@ -89,10 +89,10 @@ module Faraday
 
       def net_http_connection(env)
         if proxy = env[:request][:proxy]
-          Net::HTTP::Proxy(proxy[:uri].host, proxy[:uri].port, proxy[:user], proxy[:password])
+          Net::HTTP::Proxy(proxy[:uri].hostname, proxy[:uri].port, proxy[:user], proxy[:password])
         else
           Net::HTTP
-        end.new(env[:url].host, env[:url].port)
+        end.new(env[:url].hostname, env[:url].port || (env[:url].scheme == 'https' ? 443 : 80))
       end
 
       def configure_ssl(http, ssl)
@@ -108,6 +108,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

@@ -1,15 +1,25 @@
-# Rely on autoloading instead of explicit require; helps avoid the "already
-# initialized constant" warning on Ruby 1.8.7 when NetHttp is refereced below.
-# require 'faraday/adapter/net_http'
-
 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]
+      private
+
+      def net_http_connection(env)
+        proxy_uri = proxy_uri(env)
+
+        cached_connection env[:url], proxy_uri do
+          if Net::HTTP::Persistent.instance_method(:initialize).parameters.first == [:key, :name]
+            Net::HTTP::Persistent.new(name: 'Faraday', proxy: proxy_uri)
+          else
+            Net::HTTP::Persistent.new('Faraday', proxy_uri)
+          end
+        end
+      end
+
+      def proxy_uri(env)
+        proxy_uri = nil
+        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
@@ -18,12 +28,13 @@ module Faraday
             define_method(:password) { proxy[:password] }
           end if proxy[:user]
         end
-
-        yield Net::HTTP::Persistent.new 'Faraday', proxy_uri
+        proxy_uri
       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
@@ -43,6 +54,10 @@ module Faraday
         http.ca_file      = ssl[:ca_file]      if ssl[:ca_file]
         http.ssl_version  = ssl[:version]      if ssl[:version]
       end
+
+      def cached_connection(url, proxy_uri)
+        (@cached_connection ||= {})[[url.scheme, url.host, url.port, proxy_uri]] ||= yield
+      end
     end
   end
 end