faraday 0.12.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d6ed59b880f0d605e4efc8ce513ced0b4688c4ef
-  data.tar.gz: 21d3a0326416db1e19add553b8d5c0ef1c5a3b50
+SHA256:
+  metadata.gz: 3737507d92b48e4b98e891c5026210048ab70b2b1ee17ea20993b8ffc65eafb5
+  data.tar.gz: caaaa7f7ad1bdda848ac7bc70d4d1b9ba9d06bc85912a61b1ee4082086629a26
 SHA512:
-  metadata.gz: 9e882a5072cc36a986e8fc2f23f0563755bae2d0c4e6fed4adc51a6fd46b449ea6be3dd189662ea0aa4f427c5402969bfb0ad626c837e9bad68d06aa0a3cc6d3
-  data.tar.gz: 63856c35cbcceda6abeb3dc076574d7e880343e8ee7af5e80971c08637a647a079433b1220161c24871d3718c268d018ebdce009ca46d89c4da7c059fdaeaf72
+  metadata.gz: 231b96efdd5b0399f204edaeba22d01661b9d301aff6cad7d097c27c1e95f0a0a8adc9184e88f089862fa9db9a833e50a3eb7bfb96034a2df7f1bdd93661f3fb
+  data.tar.gz: f19fca5f59454b7b620160c3e58339e0dff8049be29bda8e8f1a494455dac6c62a1c6cbe4b4e141e999ea3df25cbcdf3ef09d65e93d71a882c318c75c3070dec

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2009-2015 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

@@ -2,6 +2,8 @@
 
 [![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)
 
 
@@ -9,7 +11,7 @@ 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] _(default)_
 * [Net::HTTP::Persistent][persistent]
@@ -18,6 +20,10 @@ Faraday supports these adapters:
 * [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.
 
@@ -38,11 +44,12 @@ stack and default adapter (see [Faraday::RackBuilder#initialize](https://github.
 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' 
+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. 
+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|
@@ -54,6 +61,7 @@ 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
@@ -61,7 +69,7 @@ conn = Faraday.new(:url => 'http://sushi.com/api_key=s3cr3t') do |faraday|
 end
 ```
 
-Once you have the connection object, use it to make HTTP requests. You can pass paramters to it in a few different ways:
+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 ##
@@ -140,6 +148,36 @@ The value of Faraday `params_encoder` can be any object that responds to:
 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
 
 The order in which middleware is stacked is important. Like with Rack, the
@@ -152,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
 ```
@@ -216,7 +255,7 @@ later, response. Some keys are:
 
 ## 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. 
+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.
 
@@ -296,11 +335,6 @@ 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
@@ -323,9 +357,15 @@ 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.
 
 [net_http]:     http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/Net/HTTP.html
@@ -335,6 +375,7 @@ See [LICENSE][] for details.
 [patron]:       http://toland.github.io/patron/
 [eventmachine]: https://github.com/igrigorik/em-http-request#readme
 [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/excon.rb

@@ -30,7 +30,6 @@ module Faraday
 
           if req[:open_timeout]
             opts[:connect_timeout]   = req[:open_timeout]
-            opts[:write_timeout]     = req[:open_timeout]
           end
 
           if req[:proxy]

data/lib/faraday/adapter/httpclient.rb

@@ -50,7 +50,7 @@ module Faraday
         else
           raise Faraday::Error::ClientError, $!
         end
-      rescue Errno::ECONNREFUSED, IOError
+      rescue Errno::ECONNREFUSED, IOError, SocketError
         raise Faraday::Error::ConnectionFailed, $!
       rescue => err
         if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err

data/lib/faraday/adapter/net_http.rb

@@ -56,6 +56,8 @@ module Faraday
         raise Faraday::Error::TimeoutError, err
       end
 
+      private
+
       def create_request(env)
         request = Net::HTTPGenericRequest.new \
           env[:method].to_s.upcase,    # request method
@@ -87,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 || (env[:url].scheme == 'https' ? 443 : 80))
+        end.new(env[:url].hostname, env[:url].port || (env[:url].scheme == 'https' ? 443 : 80))
       end
 
       def configure_ssl(http, ssl)

data/lib/faraday/adapter/net_http_persistent.rb

@@ -1,13 +1,24 @@
-# 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
     class NetHttpPersistent < NetHttp
       dependency 'net/http/persistent'
 
+      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
@@ -16,10 +27,8 @@ 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
-
-        Net::HTTP::Persistent.new 'Faraday'
+        proxy_uri
       end
 
       def perform_request(http, env)
@@ -45,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

data/lib/faraday/adapter/patron.rb

@@ -5,11 +5,11 @@ module Faraday
 
       def call(env)
         super
-
         # TODO: support streaming requests
         env[:body] = env[:body].read if env[:body].respond_to? :read
 
         session = @session ||= create_session
+        configure_ssl(session, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
 
         if req = env[:request]
           session.timeout = session.connect_timeout = req[:timeout] if req[:timeout]
@@ -37,7 +37,7 @@ module Faraday
 
         @app.call env
       rescue ::Patron::TimeoutError => err
-        if err.message == "Connection time-out"
+        if connection_timed_out_message?(err.message)
           raise Faraday::Error::ConnectionFailed, err
         else
           raise Faraday::Error::TimeoutError, err
@@ -67,10 +67,34 @@ module Faraday
 
       def create_session
         session = ::Patron::Session.new
-        session.insecure = true
         @config_block.call(session) if @config_block
         session
       end
+
+      def configure_ssl(session, ssl)
+        if ssl.fetch(:verify, true)
+          session.cacert = ssl[:ca_file]
+        else
+          session.insecure = true
+        end
+      end
+
+      private
+
+      CURL_TIMEOUT_MESSAGES = [ "Connection time-out",
+          "Connection timed out",
+          "Timed out before name resolve",
+          "server connect has timed out",
+          "Resolving timed out",
+          "name lookup timed out",
+          "timed out before SSL",
+          "connect() timed out"
+        ].freeze
+
+      def connection_timed_out_message?(message)
+        CURL_TIMEOUT_MESSAGES.any? { |curl_message| message.include?(curl_message) }
+      end
+
     end
   end
 end

data/lib/faraday/adapter/test.rb

@@ -53,17 +53,17 @@ module Faraday
           @stack.empty?
         end
 
-        def match(request_method, path, headers, body)
+        def match(request_method, host, path, headers, body)
           return false if !@stack.key?(request_method)
           stack = @stack[request_method]
           consumed = (@consumed[request_method] ||= [])
 
-          stub, meta = matches?(stack, path, headers, body)
+          stub, meta = matches?(stack, host, path, headers, body)
           if stub
             consumed << stack.delete(stub)
             return stub, meta
           end
-          matches?(consumed, path, headers, body)
+          matches?(consumed, host, path, headers, body)
         end
 
         def get(path, headers = {}, &block)
@@ -110,29 +110,35 @@ module Faraday
         protected
 
         def new_stub(request_method, path, headers = {}, body=nil, &block)
-          normalized_path = path.is_a?(Regexp) ? path : Faraday::Utils.normalize_path(path)
-          (@stack[request_method] ||= []) << Stub.new(normalized_path, headers, body, block)
+          normalized_path, host =
+            if path.is_a?(Regexp)
+              path
+            else
+              [Faraday::Utils.normalize_path(path), Faraday::Utils.URI(path).host]
+            end
+
+          (@stack[request_method] ||= []) << Stub.new(host, normalized_path, headers, body, block)
         end
 
-        def matches?(stack, path, headers, body)
+        def matches?(stack, host, path, headers, body)
           stack.each do |stub|
-            match_result, meta = stub.matches?(path, headers, body)
+            match_result, meta = stub.matches?(host, 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)
+      class Stub < Struct.new(:host, :path, :params, :headers, :body, :block)
+        def initialize(host, full, headers, body, block)
           path, query = full.respond_to?(:split) ? full.split("?") : full
           params = query ?
             Faraday::Utils.parse_nested_query(query) :
             {}
-          super(path, params, headers, body, block)
+          super(host, path, params, headers, body, block)
         end
 
-        def matches?(request_uri, request_headers, request_body)
+        def matches?(request_host, request_uri, request_headers, request_body)
           request_path, request_query = request_uri.split('?')
           request_params = request_query ?
             Faraday::Utils.parse_nested_query(request_query) :
@@ -140,7 +146,8 @@ module Faraday
           # meta is a hash use as carrier
           # that will be yielded to consumer block
           meta = {}
-          return path_match?(request_path, meta) &&
+          return (host.nil? || host == request_host) &&
+            path_match?(request_path, meta) &&
             params_match?(request_params) &&
             (body.to_s.size.zero? || request_body == body) &&
             headers_match?(request_headers), meta
@@ -183,10 +190,11 @@ module Faraday
 
       def call(env)
         super
+        host = env[:url].host
         normalized_path = Faraday::Utils.normalize_path(env[:url])
         params_encoder = env.request.params_encoder || Faraday::Utils.default_params_encoder
 
-        stub, meta = stubs.match(env[:method], normalized_path, env.request_headers, env[:body])
+        stub, meta = stubs.match(env[:method], host, normalized_path, env.request_headers, env[:body])
         if stub
           env[:params] = (query = env[:url].query) ?
             params_encoder.decode(query) : {}

data/lib/faraday/adapter/typhoeus.rb

@@ -1,123 +1,12 @@
 module Faraday
   class Adapter
+    # This class is just a stub, the real adapter is in https://github.com/philsturgeon/typhoeus/blob/master/lib/typhoeus/adapters/faraday.rb
     class Typhoeus < Faraday::Adapter
-      self.supports_parallel = true
-
-      def self.setup_parallel_manager(options = {})
-        options.empty? ? ::Typhoeus::Hydra.hydra : ::Typhoeus::Hydra.new(options)
-      end
+      # Needs to define this method in order to support Typhoeus <= 1.3.0
+      def call; end
 
       dependency 'typhoeus'
-
-      def call(env)
-        super
-        perform_request env
-        @app.call env
-      end
-
-      def perform_request(env)
-        read_body env
-
-        hydra = env[:parallel_manager] || self.class.setup_parallel_manager
-        hydra.queue request(env)
-        hydra.run unless parallel?(env)
-      rescue Errno::ECONNREFUSED
-        raise Error::ConnectionFailed, $!
-      end
-
-      # TODO: support streaming requests
-      def read_body(env)
-        env[:body] = env[:body].read if env[:body].respond_to? :read
-      end
-
-      def request(env)
-        method = env[:method]
-        # For some reason, prevents Typhoeus from using "100-continue".
-        # We want this because Webrick 1.3.1 can't seem to handle it w/ PUT.
-        method = method.to_s.upcase if method == :put
-
-        req = ::Typhoeus::Request.new env[:url].to_s,
-          :method  => method,
-          :body    => env[:body],
-          :headers => env[:request_headers],
-          :disable_ssl_peer_verification => (env[:ssl] && env[:ssl].disable?)
-
-        configure_ssl     req, env
-        configure_proxy   req, env
-        configure_timeout req, env
-        configure_socket  req, env
-
-        req.on_complete do |resp|
-          if resp.timed_out?
-            if parallel?(env)
-              # TODO: error callback in async mode
-            else
-              raise Faraday::Error::TimeoutError, "request timed out"
-            end
-          end
-
-          case resp.curl_return_code
-          when 0
-            # everything OK
-          when 7
-            raise Error::ConnectionFailed, resp.curl_error_message
-          when 60
-            raise Faraday::SSLError, resp.curl_error_message
-          else
-            raise Error::ClientError, resp.curl_error_message
-          end
-
-          save_response(env, resp.code, resp.body) do |response_headers|
-            response_headers.parse resp.headers
-          end
-          # in async mode, :response is initialized at this point
-          env[:response].finish(env) if parallel?(env)
-        end
-
-        req
-      end
-
-      def configure_ssl(req, env)
-        ssl = env[:ssl]
-
-        req.ssl_version = ssl[:version]          if ssl[:version]
-        req.ssl_cert    = ssl[:client_cert] if ssl[:client_cert]
-        req.ssl_key     = ssl[:client_key]  if ssl[:client_key]
-        req.ssl_cacert  = ssl[:ca_file]          if ssl[:ca_file]
-        req.ssl_capath  = ssl[:ca_path]          if ssl[:ca_path]
-      end
-
-      def configure_proxy(req, env)
-        proxy = request_options(env)[:proxy]
-        return unless proxy
-
-        req.proxy = "#{proxy[:uri].host}:#{proxy[:uri].port}"
-
-        if proxy[:user] && proxy[:password]
-          req.proxy_username = proxy[:user]
-          req.proxy_password = proxy[:password]
-        end
-      end
-
-      def configure_timeout(req, env)
-        env_req = request_options(env)
-        req.timeout = req.connect_timeout = (env_req[:timeout] * 1000) if env_req[:timeout]
-        req.connect_timeout = (env_req[:open_timeout] * 1000)          if env_req[:open_timeout]
-      end
-
-      def configure_socket(req, env)
-        if bind = request_options(env)[:bind]
-          req.interface = bind[:host]
-        end
-      end
-
-      def request_options(env)
-        env[:request]
-      end
-
-      def parallel?(env)
-        !!env[:parallel_manager]
-      end
+      dependency 'typhoeus/adapters/faraday'
     end
   end
 end

data/lib/faraday/adapter.rb

@@ -40,6 +40,8 @@ module Faraday
       env.clear_body if env.needs_body?
     end
 
+    private
+
     def save_response(env, status, body, headers = nil, reason_phrase = nil)
       env.status = status
       env.body = body

data/lib/faraday/autoload.rb

@@ -53,9 +53,9 @@ module Faraday
     autoload_all 'faraday/adapter',
       :NetHttp           => 'net_http',
       :NetHttpPersistent => 'net_http_persistent',
-      :Typhoeus          => 'typhoeus',
       :EMSynchrony       => 'em_synchrony',
       :EMHttp            => 'em_http',
+      :Typhoeus          => 'typhoeus',
       :Patron            => 'patron',
       :Excon             => 'excon',
       :Test              => 'test',

data/lib/faraday/connection.rb

@@ -39,6 +39,9 @@ module Faraday
     # Public: Sets the default parallel manager for this connection.
     attr_writer :default_parallel_manager
 
+    # Public: Gets or Sets the Hash proxy options.
+    # attr_reader :proxy
+
     # Public: Initializes a new Faraday::Connection.
     #
     # url     - URI or String base URL to use as a prefix for all
@@ -57,7 +60,7 @@ module Faraday
     def initialize(url = nil, options = nil)
       options = ConnectionOptions.from(options)
 
-      if url.is_a?(Hash)
+      if url.is_a?(Hash) || url.is_a?(ConnectionOptions)
         options = options.merge(url)
         url     = options.url
       end
@@ -79,23 +82,9 @@ module Faraday
       @params.update(options.params)   if options.params
       @headers.update(options.headers) if options.headers
 
-      @proxy = nil
-      proxy(options.fetch(:proxy) {
-        uri = nil
-        if URI.parse("").respond_to?(:find_proxy)
-          case url
-          when String
-            uri = URI.parse(url).find_proxy
-          when URI
-            uri = url.find_proxy
-          when nil
-            uri = find_default_proxy
-          end
-        else
-          uri = find_default_proxy
-        end
-        uri
-      })
+      @manual_proxy = !!options.proxy
+      @proxy = options.proxy ? ProxyOptions.from(options.proxy) : proxy_from_env(url)
+      @temp_proxy = @proxy
 
       yield(self) if block_given?
 
@@ -292,9 +281,17 @@ module Faraday
     # Public: Gets or Sets the Hash proxy options.
     def proxy(arg = nil)
       return @proxy if arg.nil?
+      warn 'Warning: use of proxy(new_value) to set connection proxy have been DEPRECATED and will be removed in Faraday 1.0'
+      @manual_proxy = true
       @proxy = ProxyOptions.from(arg)
     end
 
+    # Public: Sets the Hash proxy options.
+    def proxy=(new_value)
+      @manual_proxy = true
+      @proxy = new_value ? ProxyOptions.from(new_value) : nil
+    end
+
     def_delegators :url_prefix, :scheme, :scheme=, :host, :host=, :port, :port=
     def_delegator :url_prefix, :path, :path_prefix
 
@@ -313,7 +310,7 @@ module Faraday
     #
     #   conn.get("nigiri?page=2") # accesses https://sushi.com/api/nigiri
     #
-    # Returns the parsed URI from teh given input..
+    # Returns the parsed URI from the given input..
     def url_prefix=(url, encoder = nil)
       uri = @url_prefix = Utils.URI(url)
       self.path_prefix = uri.path
@@ -376,7 +373,11 @@ module Faraday
         raise ArgumentError, "unknown http method: #{method}"
       end
 
+      # Resets temp_proxy
+      @temp_proxy = proxy_for_request(url)
+
       request = build_request(method) do |req|
+        req.options = req.options.merge(:proxy => @temp_proxy)
         req.url(url)                if url
         req.headers.update(headers) if headers
         req.body = body             if body
@@ -393,7 +394,7 @@ module Faraday
       Request.create(method) do |req|
         req.params  = self.params.dup
         req.headers = self.headers.dup
-        req.options = self.options.merge(:proxy => self.proxy)
+        req.options = self.options
         yield(req) if block_given?
       end
     end
@@ -443,13 +444,41 @@ module Faraday
       headers[Faraday::Request::Authorization::KEY] = header
     end
 
+    def proxy_from_env(url)
+      return if Faraday.ignore_env_proxy
+      uri = nil
+      if URI.parse('').respond_to?(:find_proxy)
+        case url
+        when String
+            uri = Utils.URI(url)
+            uri = URI.parse("#{uri.scheme}://#{uri.hostname}").find_proxy
+          when URI
+            uri = url.find_proxy
+          when nil
+            uri = find_default_proxy
+        end
+      else
+        warn 'no_proxy is unsupported' if ENV['no_proxy'] || ENV['NO_PROXY']
+        uri = find_default_proxy
+      end
+      ProxyOptions.from(uri) if uri
+    end
+
     def find_default_proxy
-      warn 'no_proxy is unsupported' if ENV['no_proxy'] || ENV['NO_PROXY']
       uri = ENV['http_proxy']
       if uri && !uri.empty?
         uri = 'http://' + uri if uri !~ /^http/i
         uri
       end
     end
+
+    def proxy_for_request(url)
+      return self.proxy if @manual_proxy
+      if url && Utils.URI(url).absolute?
+        proxy_from_env(url)
+      else
+        self.proxy
+      end
+    end
   end
 end

data/lib/faraday/error.rb

@@ -1,9 +1,8 @@
 module Faraday
   class Error < StandardError; end
-  class MissingDependency < Error; end
 
   class ClientError < Error
-    attr_reader :response
+    attr_reader :response, :wrapped_exception
 
     def initialize(ex, response = nil)
       @wrapped_exception = nil
@@ -56,8 +55,12 @@ module Faraday
   class SSLError < ClientError
   end
 
-  [:MissingDependency, :ClientError, :ConnectionFailed, :ResourceNotFound,
-   :ParsingError, :TimeoutError, :SSLError].each do |const|
+  class RetriableResponse < ClientError; end
+
+  [:ClientError, :ConnectionFailed, :ResourceNotFound,
+   :ParsingError, :TimeoutError, :SSLError, :RetriableResponse].each do |const|
     Error.const_set(const, Faraday.const_get(const))
   end
+
+
 end

data/lib/faraday/options.rb

@@ -49,7 +49,7 @@ module Faraday
       other.each do |key, other_value|
         self_value = self.send(key)
         sub_options = self.class.options_for(key)
-        new_value = sub_options ? self_value.merge(other_value) : other_value
+        new_value = (self_value && sub_options && other_value) ? self_value.merge(other_value) : other_value
         self.send("#{key}=", new_value) unless new_value.nil?
       end
       self
@@ -243,8 +243,8 @@ module Faraday
       super(value)
     end
 
-    memoized(:user) { uri.user && Utils.unescape(uri.user) }
-    memoized(:password) { uri.password && Utils.unescape(uri.password) }
+    memoized(:user) { uri && uri.user && Utils.unescape(uri.user) }
+    memoized(:password) { uri && uri.password && Utils.unescape(uri.password) }
   end
 
   class ConnectionOptions < Options.new(:request, :proxy, :ssl, :builder, :url,

data/lib/faraday/rack_builder.rb

@@ -84,6 +84,7 @@ module Faraday
         use_symbol(Faraday::Middleware, klass, *args, &block)
       else
         raise_if_locked
+        warn_middleware_after_adapter if adapter_set?
         @handlers << self.class::Handler.new(klass, *args, &block)
       end
     end
@@ -105,6 +106,7 @@ module Faraday
     def insert(index, *args, &block)
       raise_if_locked
       index = assert_index(index)
+      warn_middleware_after_adapter if inserting_after_adapter?(index)
       handler = self.class::Handler.new(*args, &block)
       @handlers.insert(index, handler)
     end
@@ -136,6 +138,8 @@ module Faraday
     #
     # Returns a Faraday::Response.
     def build_response(connection, request)
+      warn 'WARNING: No adapter was configured for this request' unless adapter_set?
+
       app.call(build_env(connection, request))
     end
 
@@ -200,6 +204,26 @@ module Faraday
       raise StackLocked, "can't modify middleware stack after making a request" if locked?
     end
 
+    def warn_middleware_after_adapter
+      warn "WARNING: Unexpected middleware set after the adapter. " \
+        "This won't be supported from Faraday 1.0."
+    end
+
+    def adapter_set?
+      @handlers.any? { |handler| is_adapter?(handler) }
+    end
+
+    def inserting_after_adapter?(index)
+      adapter_index = @handlers.find_index { |handler| is_adapter?(handler) }
+      return false if adapter_index.nil?
+
+      index > adapter_index
+    end
+
+    def is_adapter?(handler)
+      handler.klass.ancestors.include? Faraday::Adapter
+    end
+
     def use_symbol(mod, key, *args, &block)
       use(mod.lookup_middleware(key), *args, &block)
     end

data/lib/faraday/request/retry.rb

@@ -23,7 +23,9 @@ module Faraday
     IDEMPOTENT_METHODS = [:delete, :get, :head, :options, :put]
 
     class Options < Faraday::Options.new(:max, :interval, :max_interval, :interval_randomness,
-                                         :backoff_factor, :exceptions, :methods, :retry_if)
+                                         :backoff_factor, :exceptions, :methods, :retry_if, :retry_block,
+                                         :retry_statuses)
+
       DEFAULT_CHECK = lambda { |env,exception| false }
 
       def self.from(value)
@@ -56,7 +58,8 @@ module Faraday
 
       def exceptions
         Array(self[:exceptions] ||= [Errno::ETIMEDOUT, 'Timeout::Error',
-                                     Error::TimeoutError])
+                                     Error::TimeoutError,
+                                     Faraday::Error::RetriableResponse])
       end
 
       def methods
@@ -67,6 +70,13 @@ module Faraday
         self[:retry_if] ||= DEFAULT_CHECK
       end
 
+      def retry_block
+        self[:retry_block] ||= Proc.new {}
+      end
+
+      def retry_statuses
+        Array(self[:retry_statuses] ||= [])
+      end
     end
 
     # Public: Initialize middleware
@@ -83,8 +93,8 @@ module Faraday
     #                       (default: 1)
     # exceptions          - The list of exceptions to handle. Exceptions can be
     #                       given as Class, Module, or String. (default:
-    #                       [Errno::ETIMEDOUT, Timeout::Error,
-    #                       Error::TimeoutError])
+    #                       [Errno::ETIMEDOUT, 'Timeout::Error',
+    #                       Error::TimeoutError, Faraday::Error::RetriableResponse])
     # methods             - A list of HTTP methods to retry without calling retry_if.  Pass
     #                       an empty Array to call retry_if for all exceptions.
     #                       (defaults to the idempotent HTTP methods in IDEMPOTENT_METHODS)
@@ -94,18 +104,21 @@ module Faraday
     #                       if the exception produced is non-recoverable or if the
     #                       the HTTP method called is not idempotent.
     #                       (defaults to return false)
+    # retry_block         - block that is executed after every retry. Request environment, middleware options,
+    #                       current number of retries and the exception is passed to the block as parameters.
     def initialize(app, options = nil)
       super(app)
       @options = Options.from(options)
       @errmatch = build_exception_matcher(@options.exceptions)
     end
 
-    def sleep_amount(retries)
-      retry_index = @options.max - retries
-      current_interval = @options.interval * (@options.backoff_factor ** retry_index)
-      current_interval = [current_interval, @options.max_interval].min
-      random_interval  = rand * @options.interval_randomness.to_f * @options.interval
-      current_interval + random_interval
+    def calculate_sleep_amount(retries, env)
+      retry_after     = calculate_retry_after(env)
+      retry_interval  = calculate_retry_interval(retries)
+
+      return if retry_after && retry_after > @options.max_interval
+
+      retry_after && retry_after >= retry_interval ? retry_after : retry_interval
     end
 
     def call(env)
@@ -113,15 +126,25 @@ module Faraday
       request_body = env[:body]
       begin
         env[:body] = request_body # after failure env[:body] is set to the response body
-        @app.call(env)
+        @app.call(env).tap do |resp|
+          raise Faraday::Error::RetriableResponse.new(nil, resp) if @options.retry_statuses.include?(resp.status)
+        end
       rescue @errmatch => exception
         if retries > 0 && retry_request?(env, exception)
           retries -= 1
           rewind_files(request_body)
-          sleep sleep_amount(retries + 1)
-          retry
+          @options.retry_block.call(env, @options, retries, exception)
+          if (sleep_amount = calculate_sleep_amount(retries + 1, env))
+            sleep sleep_amount
+            retry
+          end
+        end
+
+        if exception.is_a?(Faraday::Error::RetriableResponse)
+          exception.response
+        else
+          raise
         end
-        raise
       end
     end
 
@@ -151,13 +174,38 @@ module Faraday
       @options.methods.include?(env[:method]) || @options.retry_if.call(env, exception)
     end
 
-    def rewind_files(env)
-      env && env.each do |_, value|
+    def rewind_files(body)
+      return unless body.is_a?(Hash)
+      body.each do |_, value|
         if value.is_a? UploadIO
           value.rewind
         end
       end
     end
 
+    # MDN spec for Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
+    def calculate_retry_after(env)
+      response_headers = env[:response_headers]
+      return unless response_headers
+
+      retry_after_value = env[:response_headers]["Retry-After"]
+
+      # Try to parse date from the header value
+      begin
+        datetime = DateTime.rfc2822(retry_after_value)
+        datetime.to_time - Time.now.utc
+      rescue ArgumentError
+        retry_after_value.to_f
+      end
+    end
+
+    def calculate_retry_interval(retries)
+      retry_index = @options.max - retries
+      current_interval = @options.interval * (@options.backoff_factor ** retry_index)
+      current_interval = [current_interval, @options.max_interval].min
+      random_interval  = rand * @options.interval_randomness.to_f * @options.interval
+
+      current_interval + random_interval
+    end
   end
 end

data/lib/faraday/response/logger.rb

@@ -20,14 +20,14 @@ module Faraday
     def_delegators :@logger, :debug, :info, :warn, :error, :fatal
 
     def call(env)
-      info "#{env.method} #{apply_filters(env.url.to_s)}"
+      info('request')  { "#{env.method.upcase} #{apply_filters(env.url.to_s)}" }
       debug('request') { apply_filters( dump_headers env.request_headers ) } if log_headers?(:request)
       debug('request') { apply_filters( dump_body(env[:body]) ) } if env[:body] && log_body?(:request)
       super
     end
 
     def on_complete(env)
-      info('Status') { env.status.to_s }
+      info('response')  { "Status #{env.status.to_s}" }
       debug('response') { apply_filters( dump_headers env.response_headers ) } if log_headers?(:response)
       debug('response') { apply_filters( dump_body env[:body] ) } if env[:body] && log_body?(:response)
     end

data/lib/faraday/utils.rb

@@ -10,12 +10,22 @@ module Faraday
         new(value)
       end
 
+      def self.allocate
+        new_self = super
+        new_self.initialize_names
+        new_self
+      end
+
       def initialize(hash = nil)
         super()
         @names = {}
         self.update(hash || {})
       end
 
+      def initialize_names
+        @names = {}
+      end
+
       # on dup/clone, we need to duplicate @names hash
       def initialize_copy(other)
         super
@@ -95,7 +105,14 @@ module Faraday
 
       def parse(header_string)
         return unless header_string && !header_string.empty?
-        header_string.split(/\r\n/).
+
+        headers = header_string.split(/\r\n/)
+
+        # Find the last set of response headers.
+        start_index = headers.rindex { |x| x.match(/^HTTP\//) } || 0
+        last_response = headers.slice(start_index, headers.size)
+
+        last_response.
           tap  { |a| a.shift if a.first.index('HTTP/') == 0 }. # drop the HTTP status line
           map  { |h| h.split(/:\s*/, 2) }.reject { |p| p[0].nil? }. # split key and value, ignore blank lines
           each { |key, value|
@@ -108,14 +125,6 @@ module Faraday
           }
       end
 
-      def init_with(coder)
-        @names = coder['names']
-      end
-
-      def encode_with(coder)
-        coder['names'] = @names
-      end
-
       protected
 
       def names

data/lib/faraday.rb

@@ -14,7 +14,7 @@ require 'forwardable'
 #   conn.get '/'
 #
 module Faraday
-  VERSION = "0.12.0"
+  VERSION = "0.15.0"
 
   class << self
     # Public: Gets or sets the root path that Faraday is being loaded from.
@@ -34,6 +34,9 @@ module Faraday
     #     Faraday.get "https://faraday.com"
     attr_writer :default_connection
 
+    # Public: Tells faraday to ignore the environment proxy (http_proxy).
+    attr_accessor :ignore_env_proxy
+
     # Public: Initializes a new Faraday::Connection.
     #
     # url     - The optional String base URL to use as a prefix for all
@@ -101,6 +104,7 @@ module Faraday
     end
   end
 
+  self.ignore_env_proxy = false
   self.root_path = File.expand_path "..", __FILE__
   self.lib_path = File.expand_path "../faraday", __FILE__
   self.default_adapter = :net_http
@@ -109,7 +113,7 @@ module Faraday
   #
   # Returns a Faraday::Connection, configured with the #default_adapter.
   def self.default_connection
-    @default_connection ||= Connection.new
+    @default_connection ||= Connection.new(default_connection_options)
   end
 
   # Gets the default connection options used when calling Faraday#new.
@@ -121,6 +125,7 @@ module Faraday
 
   # Public: Sets the default options used when calling Faraday#new.
   def self.default_connection_options=(options)
+    @default_connection = nil
     @default_connection_options = ConnectionOptions.from(options)
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faraday
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Rick Olson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-01 00:00:00.000000000 Z
+date: 2018-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multipart-post
@@ -92,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: HTTP/REST API client library.