faraday 0.9.1 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1c31dbb021fc6a43b4f0b102a9a3ccf52a72303a
-  data.tar.gz: 54da868027777adb5a21145bd6433b0154af2297
+SHA256:
+  metadata.gz: 16a3bb1447dde55604486c5a3a912281318ca8d0a211008623bcafb270a104ea
+  data.tar.gz: 966aaefe77900eab1bd1687bf7ce57950e0dbc8fb8dcd7a062fddf6be4393c4f
 SHA512:
-  metadata.gz: 22c1c286687ca596bd1d6b7d9a6a3749731f6d8962a5bbbe7e1e39cf22e364b92010ae44446cf1804ba10567a2e6409cc2be537375d9f47ace9bca909196dcd3
-  data.tar.gz: 7e8116cdeea918b8e7de661ec6d49d839960e26f136903e53db62e8cc353f89b3ac053d5efe6401995129418ae4dfce8fda9c8a471093223dca08002615d10e1
+  metadata.gz: b016c9c3ea03bba4a9a40325f0494ef8a096e6c67d46ced7cb13da8e2bfeafca92107bc971f276ea883249219e13fa3f5f67e6c73d43c6ce66c6827108457e86
+  data.tar.gz: 23e0a83830645895da998a9961d43747de7da1ee9428ea15a68776e1edb346f67c1b66d9403f3e4e0b5c40790e6adbf9bfa8dbb26db0cf79d4fafcb292c9e7ff

data/CHANGELOG.md

@@ -1,5 +1,201 @@
 # Faraday Changelog
 
+## v0.17.1
+
+Final release before Faraday v1.0, with important fixes for Ruby 2.7.
+
+Fixes:
+
+* RaiseError response middleware raises exception if HTTP client returns a nil
+  status. (#1042)
+
+Misc:
+
+* Fix Ruby 2.7 warnings (#1009)
+* Add `Faraday::Deprecate` to warn about upcoming v1.0 changes. (#1054, #1059,
+    #1076, #1077)
+* Add release notes up to current in CHANGELOG.md (#1066)
+* Port minimal rspec suite from main branch to run backported tests. (#1058)
+
+## v0.17.0
+
+This release is the same as v0.15.4. It was pushed to cover up releases
+v0.16.0-v0.16.2.
+
+## v0.15.4
+
+* Expose `pool_size` as a option for the NetHttpPersistent adapter (#834)
+
+## v0.15.3
+
+* Make Faraday::Request serialisable with Marshal. (#803)
+* Add DEFAULT_EXCEPTIONS constant to Request::Retry (#814)
+* Add support for Ruby 2.6 Net::HTTP write_timeout (#824)
+
+## v0.15.2
+
+* Prevents `Net::HTTP` adapters to retry request internally by setting `max_retries` to 0 if available (Ruby 2.5+). (#799)
+* Fixes `NestedParamsEncoder` handling of empty array values (#801)
+
+## v0.15.1
+
+* NetHttpPersistent adapter better reuse of SSL connections (#793)
+* Refactor: inline cached_connection (#797)
+* Logger middleware: use $stdout instead of STDOUT (#794)
+* Fix: do not memoize/reuse Patron session (#796)
+
+Also in this release:
+
+* Allow setting min/max ssl version for Net::HTTP (#792)
+* Allow setting min/max ssl version for Excon (#795)
+
+## v0.15.0
+
+Features:
+
+* Added retry block option to retry middleware. (#770)
+* Retry middleware improvements (honour Retry-After header, retry statuses) (#773)
+* Improve response logger middleware output (#784)
+
+Fixes:
+
+* Remove unused class error (#767)
+* Fix minor typo in README (#760)
+* Reuse persistent connections when using net-http-persistent (#778)
+* Fix Retry middleware documentation (#781)
+* Returns the http response when giving up on retrying by status (#783)
+
+## v0.14.0
+
+Features:
+
+* Allow overriding env proxy (#754)
+* Remove legacy Typhoeus adapter (#715)
+* External Typhoeus Adapter Compatibility (#748)
+* Warn about missing adapter when making a request (#743)
+* Faraday::Adapter::Test stubs now support entire urls (with host) (#741)
+
+Fixes:
+
+* If proxy is manually provided, this takes priority over `find_proxy` (#724)
+* Fixes the behaviour for Excon's open_timeout (not setting write_timeout anymore) (#731)
+* Handle all connection timeout messages in Patron (#687)
+
+## v0.13.1
+
+* Fixes an incompatibility with Addressable::URI being used as uri_parser
+
+## v0.13.0
+
+Features:
+
+* Dynamically reloads the proxy when performing a request on an absolute domain (#701)
+* Adapter support for Net::HTTP::Persistent v3.0.0 (#619)
+
+Fixes:
+
+* Prefer #hostname over #host. (#714)
+* Fixes an edge-case issue with response headers parsing (missing HTTP header) (#719)
+
+## v0.12.2
+
+* Parse headers from aggregated proxy requests/responses (#681)
+* Guard against invalid middleware configuration with warning (#685)
+* Do not use :insecure option by default in Patron (#691)
+* Fixes an issue with HTTPClient not raising a `Faraday::ConnectionFailed` (#702)
+* Fixes YAML serialization/deserialization for `Faraday::Utils::Headers` (#690)
+* Fixes an issue with Options having a nil value (#694)
+* Fixes an issue with Faraday.default_connection not using Faraday.default_connection_options (#698)
+* Fixes an issue with Options.merge! and Faraday instrumentation middleware (#710)
+
+## v0.12.1
+
+* Fix an issue with Patron tests failing on jruby
+* Fix an issue with new `rewind_files` feature that was causing an exception when the body was not an Hash
+* Expose wrapped_exception in all client errors
+* Add Authentication Section to the ReadMe
+
+## v0.12.0.1
+
+* Hotfix release to address an issue with TravisCI deploy on Rubygems
+
+## v0.12.0
+
+Features:
+
+* Proxy feature now relies on Ruby `URI::Generic#find_proxy` and can use `no_proxy` ENV variable (not compatible with ruby < 2.0)
+* Adds support for `context` request option to pass arbitrary information to middlewares
+
+Fixes:
+
+* Fix an issue with options that was causing new options to override defaults ones unexpectedly
+* Rewind `UploadIO`s on retry to fix a compatibility issue
+* Make multipart boundary unique
+* Improvements in `README.md`
+
+## v0.11.0
+
+Features:
+
+* Add `filter` method to Logger middleware
+* Add support for Ruby2.4 and Minitest 6
+* Introduce block syntax to customise the adapter
+
+Fixes:
+
+* Fix an issue that was allowing to override `default_connection_options` from a connection instance
+* Fix a bug that was causing newline escape characters ("\n") to be used when building the Authorization header
+
+## v0.10.1
+
+- Fix an issue with HTTPClient adapter that was causing the SSL to be reset on every request
+- Rescue `IOError` instead of specific subclass
+- `Faraday::Utils::Headers` can now be successfully serialised in YAML
+- Handle `default_connection_options` set with hash
+
+## v0.10.0
+
+Breaking changes:
+- Drop support for Ruby 1.8
+
+Features:
+- Include wrapped exception/reponse in ClientErrors
+- Add `response.reason_phrase`
+- Provide option to selectively skip logging request/response headers
+- Add regex support for pattern matching in `test` adapter
+
+Fixes:
+- Add `Faraday.respond_to?` to find methods managed by `method_missing`
+- em-http: `request.host` instead of `connection.host` should be taken for SSL validations
+- Allow `default_connection_options` to be merged when options are passed as url parameter
+- Improve splitting key-value pairs in raw HTTP headers
+
+## v0.9.2
+
+Adapters:
+- Enable gzip compression for httpclient
+- Fixes default certificate store for httpclient not having default paths.
+- Make excon adapter compatible with 0.44 excon version
+- Add compatibility with Patron 0.4.20
+- Determine default port numbers in Net::HTTP adapters (Addressable compatibility)
+- em-http: wrap "connection closed by server" as ConnectionFailed type
+- Wrap Errno::ETIMEDOUT in Faraday::Error::TimeoutError
+
+Utils:
+- Add Rack-compatible support for parsing `a[][b]=c` nested queries
+- Encode nil values in queries different than empty strings. Before: `a=`; now: `a`.
+- Have `Faraday::Utils::Headers#replace` clear internal key cache
+- Dup the internal key cache when a Headers hash is copied
+
+Env and middleware:
+- Ensure `env` stored on middleware response has reference to the response
+- Ensure that Response properties are initialized during `on_complete` (VCR compatibility)
+- Copy request options in Faraday::Connection#dup
+- Env custom members should be copied by Env.from(env)
+- Honour per-request `request.options.params_encoder`
+- Fix `interval_randomness` data type for Retry middleware
+- Add maximum interval option for Retry middleware
+
 ## v0.9.1
 
 * Refactor Net:HTTP adapter so that with_net_http_connection can be overridden to allow pooled connections. (@Ben-M)

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,30 +1,77 @@
 # Faraday
 
+[![Gem Version](https://badge.fury.io/rb/faraday.svg)](https://rubygems.org/gems/faraday)
+[![Build Status](https://travis-ci.org/lostisland/faraday.svg?branch=master)](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
-  faraday.response :logger                  # log requests to STDOUT
+  faraday.response :logger                  # log requests to $stdout
+  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
@@ -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
@@ -75,7 +189,11 @@ Faraday.new(...) do |conn|
   # POST/PUT params encoders:
   conn.request :multipart
   conn.request :url_encoded
+  
+  # add custom middleware
+  conn.use MyMiddleware
 
+  # Last middleware must be the adapter:
   conn.adapter :net_http
 end
 ```
@@ -138,6 +256,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, pool_size: 5 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 +338,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 +360,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 `help wanted` 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/Rakefile

@@ -1,71 +1,13 @@
-require 'date'
-require 'fileutils'
-require 'openssl'
-require 'rake/testtask'
-require 'bundler'
-Bundler::GemHelper.install_tasks
-
-task :default => :test
-
-## helper functions
-
-def name
-  @name ||= Dir['*.gemspec'].first.split('.').first
-end
+# frozen_string_literal: true
 
-def version
-  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
-  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
-end
-
-def gemspec_file
-  "#{name}.gemspec"
-end
-
-def gem_file
-  "#{name}-#{version}.gem"
-end
+require 'rake/testtask'
+require 'rspec/core/rake_task'
 
-def replace_header(head, header_name)
-  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
-end
+RSpec::Core::RakeTask.new(:spec)
 
-# Adapted from WEBrick::Utils. Skips cert extensions so it
-# can be used as a CA bundle
-def create_self_signed_cert(bits, cn, comment)
-  rsa = OpenSSL::PKey::RSA.new(bits)
-  cert = OpenSSL::X509::Certificate.new
-  cert.version = 2
-  cert.serial = 1
-  name = OpenSSL::X509::Name.new(cn)
-  cert.subject = name
-  cert.issuer = name
-  cert.not_before = Time.now
-  cert.not_after = Time.now + (365*24*60*60)
-  cert.public_key = rsa.public_key
-  cert.sign(rsa, OpenSSL::Digest::SHA1.new)
-  return [cert, rsa]
-end
-
-## standard tasks
+task :default => :test
 
 desc "Run all tests"
-task :test do
+task :test => :spec do
   exec 'script/test'
 end
-
-desc "Generate certificates for SSL tests"
-task :'test:generate_certs' do
-  cert, key = create_self_signed_cert(1024, [['CN', 'localhost']], 'Faraday Test CA')
-  FileUtils.mkdir_p 'tmp'
-  File.open('tmp/faraday-cert.key', 'w') {|f| f.puts(key) }
-  File.open('tmp/faraday-cert.crt', 'w') {|f| f.puts(cert.to_s) }
-end
-
-file 'tmp/faraday-cert.key' => :'test:generate_certs'
-file 'tmp/faraday-cert.crt' => :'test:generate_certs'
-
-desc "Open an irb session preloaded with this library"
-task :console do
-  sh "irb -rubygems -r ./lib/#{name}.rb"
-end

data/lib/faraday/adapter/em_http.rb

@@ -124,9 +124,9 @@ module Faraday
         end
       rescue EventMachine::Connectify::CONNECTError => err
         if err.message.include?("Proxy Authentication Required")
-          raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+          raise Faraday::ConnectionFailed, %{407 "Proxy Authentication Required "}
         else
-          raise Error::ConnectionFailed, err
+          raise Faraday::ConnectionFailed, err
         end
       rescue => err
         if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
@@ -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,20 +150,24 @@ 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
 
       def raise_error(msg)
-        errklass = Faraday::Error::ClientError
+        errklass = Faraday::ClientError
         if msg == Errno::ETIMEDOUT
-          errklass = Faraday::Error::TimeoutError
+          errklass = Faraday::TimeoutError
           msg = "request timed out"
         elsif msg == Errno::ECONNREFUSED
-          errklass = Faraday::Error::ConnectionFailed
+          errklass = Faraday::ConnectionFailed
           msg = "connection refused"
         elsif msg == "connection closed by server"
-          errklass = Faraday::Error::ConnectionFailed
+          errklass = Faraday::ConnectionFailed
         end
         raise errklass, msg
       end
@@ -187,11 +193,11 @@ module Faraday
 
         def running?() @running end
 
-        def add
+        def add(&block)
           if running?
             perform_request { yield }
           else
-            @registered_procs << Proc.new
+            @registered_procs << block
           end
           @num_registered += 1
         end
@@ -205,7 +211,7 @@ module Faraday
               end
             end
             if @errors.size > 0
-              raise Faraday::Error::ClientError, @errors.first || "connection failed"
+              raise Faraday::ClientError, @errors.first || "connection failed"
             end
           end
         ensure

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