faraday 1.0.0.pre.rc1 → 1.0.0

data/lib/faraday/adapter/net_http_persistent.rb

@@ -16,7 +16,7 @@ module Faraday
             if @connection_options.key?(:pool_size)
               options[:pool_size] = @connection_options[:pool_size]
             end
-            Net::HTTP::Persistent.new(options)
+            Net::HTTP::Persistent.new(**options)
           else
             Net::HTTP::Persistent.new('Faraday')
           end
@@ -73,6 +73,8 @@ module Faraday
       }.freeze
 
       def configure_ssl(http, ssl)
+        return unless ssl
+
         http_set(http, :verify_mode, ssl_verify_mode(ssl))
         http_set(http, :cert_store, ssl_cert_store(ssl))
 

data/lib/faraday/adapter/patron.rb

@@ -6,11 +6,7 @@ module Faraday
     class Patron < Faraday::Adapter
       dependency 'patron'
 
-      def call(env)
-        super
-        # TODO: support streaming requests
-        env[:body] = env[:body].read if env[:body].respond_to? :read
-
+      def build_connection(env)
         session = ::Patron::Session.new
         @config_block&.call(session)
         if (env[:url].scheme == 'https') && env[:ssl]
@@ -18,27 +14,26 @@ module Faraday
         end
 
         if (req = env[:request])
-          if req[:timeout]
-            session.timeout = session.connect_timeout = req[:timeout]
-          end
-          session.connect_timeout = req[:open_timeout] if req[:open_timeout]
-
-          if (proxy = req[:proxy])
-            proxy_uri = proxy[:uri].dup
-            proxy_uri.user = proxy[:user] &&
-                             Utils.escape(proxy[:user]).gsub('+', '%20')
-            proxy_uri.password = proxy[:password] &&
-                                 Utils.escape(proxy[:password]).gsub('+', '%20')
-            session.proxy = proxy_uri.to_s
-          end
+          configure_timeouts(session, req)
+          configure_proxy(session, req[:proxy])
         end
 
-        response = begin
-          data = env[:body] ? env[:body].to_s : nil
-          session.request(env[:method], env[:url].to_s,
-                          env[:request_headers], data: data)
-                   rescue Errno::ECONNREFUSED, ::Patron::ConnectionFailed
-                     raise Faraday::ConnectionFailed, $ERROR_INFO
+        session
+      end
+
+      def call(env)
+        super
+        # TODO: support streaming requests
+        env[:body] = env[:body].read if env[:body].respond_to? :read
+
+        response = connection(env) do |session|
+          begin
+            data = env[:body] ? env[:body].to_s : nil
+            session.request(env[:method], env[:url].to_s,
+                            env[:request_headers], data: data)
+          rescue Errno::ECONNREFUSED, ::Patron::ConnectionFailed
+            raise Faraday::ConnectionFailed, $ERROR_INFO
+          end
         end
 
         if (req = env[:request]).stream_response?
@@ -91,6 +86,29 @@ module Faraday
         end
       end
 
+      def configure_timeouts(session, req)
+        return unless req
+
+        if (sec = request_timeout(:read, req))
+          session.timeout = sec
+        end
+
+        return unless (sec = request_timeout(:open, req))
+
+        session.connect_timeout = sec
+      end
+
+      def configure_proxy(session, proxy)
+        return unless proxy
+
+        proxy_uri = proxy[:uri].dup
+        proxy_uri.user = proxy[:user] &&
+                         Utils.escape(proxy[:user]).gsub('+', '%20')
+        proxy_uri.password = proxy[:password] &&
+                             Utils.escape(proxy[:password]).gsub('+', '%20')
+        session.proxy = proxy_uri.to_s
+      end
+
       private
 
       CURL_TIMEOUT_MESSAGES = [

data/lib/faraday/adapter/rack.rb

@@ -37,7 +37,8 @@ module Faraday
           rack_env[name] = value
         end
 
-        timeout  = env[:request][:timeout] || env[:request][:open_timeout]
+        timeout = request_timeout(:open, env[:request])
+        timeout ||= request_timeout(:read, env[:request])
         response = if timeout
                      Timer.timeout(timeout, Faraday::TimeoutError) do
                        execute_request(env, rack_env)

data/lib/faraday/connection.rb

@@ -14,7 +14,7 @@ module Faraday
   #
   class Connection
     # A Set of allowed HTTP verbs.
-    METHODS = Set.new %i[get post put delete head patch options trace connect]
+    METHODS = Set.new %i[get post put delete head patch options trace]
 
     # @return [Hash] URI query unencoded key/value pairs.
     attr_reader :params
@@ -99,7 +99,6 @@ module Faraday
         else
           proxy_from_env(url)
         end
-      @temp_proxy = @proxy
     end
 
     # Sets the Hash of URI query unencoded key/value pairs.
@@ -118,6 +117,13 @@ module Faraday
 
     def_delegators :builder, :build, :use, :request, :response, :adapter, :app
 
+    # Closes the underlying resources and/or connections. In the case of
+    # persistent connections, this closes all currently open connections
+    # but does not prevent new connections from being made.
+    def close
+      app.close
+    end
+
     # @!method get(url = nil, params = nil, headers = nil)
     # Makes a GET HTTP request without a body.
     # @!scope class
@@ -170,21 +176,6 @@ module Faraday
     # @yield [Faraday::Request] for further request customizations
     # @return [Faraday::Response]
 
-    # @!method connect(url = nil, params = nil, headers = nil)
-    # Makes a CONNECT HTTP request without a body.
-    # @!scope class
-    #
-    # @param url [String] The optional String base URL to use as a prefix for
-    #            all requests.  Can also be the options Hash.
-    # @param params [Hash] Hash of URI query unencoded key/value pairs.
-    # @param headers [Hash] unencoded HTTP header key/value pairs.
-    #
-    # @example
-    #   conn.connect '/items/1'
-    #
-    # @yield [Faraday::Request] for further request customizations
-    # @return [Faraday::Response]
-
     # @!method trace(url = nil, params = nil, headers = nil)
     # Makes a TRACE HTTP request without a body.
     # @!scope class
@@ -490,11 +481,8 @@ 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.options.proxy = proxy_for_request(url)
         req.url(url)                if url
         req.headers.update(headers) if headers
         req.body = body             if body
@@ -514,7 +502,7 @@ module Faraday
       Request.create(method) do |req|
         req.params  = params.dup
         req.headers = headers.dup
-        req.options = options
+        req.options = options.dup
         yield(req) if block_given?
       end
     end

data/lib/faraday/encoders/flat_params_encoder.rb

@@ -45,9 +45,13 @@ module Faraday
         if value.nil?
           buffer << "#{encoded_key}&"
         elsif value.is_a?(Array)
-          value.each do |sub_value|
-            encoded_value = escape(sub_value)
-            buffer << "#{encoded_key}=#{encoded_value}&"
+          if value.empty?
+            buffer << "#{encoded_key}=&"
+          else
+            value.each do |sub_value|
+              encoded_value = escape(sub_value)
+              buffer << "#{encoded_key}=#{encoded_value}&"
+            end
           end
         else
           encoded_value = escape(value)

data/lib/faraday/error.rb

@@ -1,23 +1,15 @@
 # frozen_string_literal: true
 
+# Faraday namespace.
 module Faraday
   # Faraday error base class.
   class Error < StandardError
     attr_reader :response, :wrapped_exception
 
     def initialize(exc, response = nil)
-      @wrapped_exception = nil
-      @response = response
-
-      if exc.respond_to?(:backtrace)
-        super(exc.message)
-        @wrapped_exception = exc
-      elsif exc.respond_to?(:each_key)
-        super("the server responded with status #{exc[:status]}")
-        @response = exc
-      else
-        super(exc.to_s)
-      end
+      @wrapped_exception = nil unless defined?(@wrapped_exception)
+      @response = nil unless defined?(@response)
+      super(exc_msg_and_response!(exc, response))
     end
 
     def backtrace
@@ -35,6 +27,38 @@ module Faraday
       inner << " #{super}" if inner.empty?
       %(#<#{self.class}#{inner}>)
     end
+
+    protected
+
+    # Pulls out potential parent exception and response hash, storing them in
+    # instance variables.
+    # exc      - Either an Exception, a string message, or a response hash.
+    # response - Hash
+    #              :status  - Optional integer HTTP response status
+    #              :headers - String key/value hash of HTTP response header
+    #                         values.
+    #              :body    - Optional string HTTP response body.
+    #
+    # If a subclass has to call this, then it should pass a string message
+    # to `super`. See NilStatusError.
+    def exc_msg_and_response!(exc, response = nil)
+      if @response.nil? && @wrapped_exception.nil?
+        @wrapped_exception, msg, @response = exc_msg_and_response(exc, response)
+        return msg
+      end
+
+      exc.to_s
+    end
+
+    # Pulls out potential parent exception and response hash.
+    def exc_msg_and_response(exc, response = nil)
+      return [exc, exc.message, response] if exc.respond_to?(:backtrace)
+
+      return [nil, "the server responded with status #{exc[:status]}", exc] \
+        if exc.respond_to?(:each_key)
+
+      [nil, exc.to_s, response]
+    end
   end
 
   # Faraday client error class. Represents 4xx status responses.
@@ -80,6 +104,14 @@ module Faraday
     end
   end
 
+  # Raised by Faraday::Response::RaiseError in case of a nil status in response.
+  class NilStatusError < ServerError
+    def initialize(exc, response = nil)
+      exc_msg_and_response!(exc, response)
+      super('http status could not be derived from the server response')
+    end
+  end
+
   # A unified error for failed connections.
   class ConnectionFailed < Error
   end

data/lib/faraday/{upload_io.rb → file_part.rb}

@@ -7,6 +7,59 @@ require 'composite_io'
 require 'parts'
 
 module Faraday
+  # Multipart value used to POST a binary data from a file or
+  #
+  # @example
+  #   payload = { file: Faraday::FilePart.new("file_name.ext", "content/type") }
+  #   http.post("/upload", payload)
+  #
+
+  # @!method initialize(filename_or_io, content_type, filename = nil, opts = {})
+  #
+  #   @param filename_or_io [String, IO] Either a String filename to a local
+  #     file or an open IO object.
+  #   @param content_type [String] String content type of the file data.
+  #   @param filename [String] Optional String filename, usually to add context
+  #     to a given IO object.
+  #   @param opts [Hash] Optional Hash of String key/value pairs to describethis
+  #     this uploaded file. Expected Header keys include:
+  #     * Content-Transfer-Encoding - Defaults to "binary"
+  #     * Content-Disposition - Defaults to "form-data"
+  #     * Content-Type - Defaults to the content_type argument.
+  #     * Content-ID - Optional.
+  #
+  # @return [Faraday::FilePart]
+  #
+  # @!attribute [r] content_type
+  # The uploaded binary data's content type.
+  #
+  # @return [String]
+  #
+  # @!attribute [r] original_filename
+  # The base filename, taken either from the filename_or_io or filename
+  # arguments in #initialize.
+  #
+  # @return [String]
+  #
+  # @!attribute [r] opts
+  # Extra String key/value pairs to make up the header for this uploaded file.
+  #
+  # @return [Hash]
+  #
+  # @!attribute [r] io
+  # The open IO object for the uploaded file.
+  #
+  # @return [IO]
+  FilePart = ::UploadIO
+
+  # Multipart value used to POST a file.
+  #
+  # @deprecated Use FilePart instead of this class. It behaves identically, with
+  #   a matching name to ParamPart.
+  UploadIO = ::UploadIO
+
+  Parts = ::Parts
+
   # Similar to, but not compatible with CompositeReadIO provided by the
   # multipart-post gem.
   # https://github.com/nicksieger/multipart-post/blob/master/lib/composite_io.rb
@@ -72,7 +125,4 @@ module Faraday
       @index += 1
     end
   end
-
-  UploadIO = ::UploadIO
-  Parts = ::Parts
 end

data/lib/faraday/logging/formatter.rb

@@ -7,7 +7,8 @@ module Faraday
     class Formatter
       extend Forwardable
 
-      DEFAULT_OPTIONS = { headers: true, bodies: false }.freeze
+      DEFAULT_OPTIONS = { headers: true, bodies: false,
+                          log_level: :info }.freeze
 
       def initialize(logger:, options:)
         @logger = logger
@@ -18,27 +19,21 @@ module Faraday
       def_delegators :@logger, :debug, :info, :warn, :error, :fatal
 
       def request(env)
-        info('request') do
+        request_log = proc do
           "#{env.method.upcase} #{apply_filters(env.url.to_s)}"
         end
-        if log_headers?(:request)
-          debug('request') { apply_filters(dump_headers(env.request_headers)) }
-        end
-        return unless env[:body] && log_body?(:request)
+        public_send(log_level, 'request', &request_log)
 
-        debug('request') { apply_filters(dump_body(env[:body])) }
+        log_headers('request', env.request_headers) if log_headers?(:request)
+        log_body('request', env[:body]) if env[:body] && log_body?(:request)
       end
 
       def response(env)
-        info('response') { "Status #{env.status}" }
-        if log_headers?(:response)
-          debug('response') do
-            apply_filters(dump_headers(env.response_headers))
-          end
-        end
-        return unless env[:body] && log_body?(:response)
+        status = proc { "Status #{env.status}" }
+        public_send(log_level, 'response', &status)
 
-        debug('response') { apply_filters(dump_body(env[:body])) }
+        log_headers('response', env.response_headers) if log_headers?(:response)
+        log_body('response', env[:body]) if env[:body] && log_body?(:response)
       end
 
       def filter(filter_word, filter_replacement)
@@ -87,6 +82,24 @@ module Faraday
         end
         output
       end
+
+      def log_level
+        unless %i[debug info warn error fatal].include?(@options[:log_level])
+          return :info
+        end
+
+        @options[:log_level]
+      end
+
+      def log_headers(type, headers)
+        headers_log = proc { apply_filters(dump_headers(headers)) }
+        public_send(log_level, type, &headers_log)
+      end
+
+      def log_body(type, body)
+        body_log = proc { apply_filters(dump_body(body)) }
+        public_send(log_level, type, &body_log)
+      end
     end
   end
 end

data/lib/faraday/middleware.rb

@@ -9,5 +9,13 @@ module Faraday
     def initialize(app = nil)
       @app = app
     end
+
+    def close
+      if @app.respond_to?(:close)
+        @app.close
+      else
+        warn "#{@app} does not implement \#close!"
+      end
+    end
   end
 end

data/lib/faraday/options.rb

@@ -79,7 +79,7 @@ module Faraday
         if !args.empty?
           send(key_setter, args.first)
         elsif block_given?
-          send(key_setter, Proc.new.call(key))
+          send(key_setter, yield(key))
         else
           raise self.class.fetch_error_class, "key not found: #{key.inspect}"
         end