faraday 2.6.0 → 2.7.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9ba15c64f037b4f2c0194ae0d6340af38e79ded9d85b37a36f2ca3cde44d2f0
-  data.tar.gz: b4ae3fe514db4cba5db21446e4b50d2d8b58ae3f3c077c7e288b4eb0a64637e1
+  metadata.gz: e4aa57af93476ba31117b14ed37bea950bf9b677d4dcca13ca1296a3ac2c3ff7
+  data.tar.gz: 98b3cb7b7c5c08eba9f58ad96181757d6cd7fc7431ac47ae19e8c95a25de12f9
 SHA512:
-  metadata.gz: 20feaa462add0a309d25ceefbd6e5c4481f08a0e1f201d15a2f7459ea83611363002bfc40ba35b143b99d9ef29455edf10e40557455f2d7b057a8440d2f4e3ba
-  data.tar.gz: f82680b983f1059eba7191b4ac7f17bc21f8b33736c6e1130c684c695d32fae3f3f278ea7e7b13adb92f89208befaf35fe7dc485dc5e5eb3f582943bde5a2b37
+  metadata.gz: 28f98f568e844799353a00d5ff49511f7bdb759a50edd3de2d4194fbb348dc14d1ef0294d854016ccdcbec915546225ebb2cf6dec354d6e7fbbf707b00cfc170
+  data.tar.gz: 3506cebb9ad1fbd1dd38c1804e18cfd7d7352796d11fa564cde9ce0eee1b1a8ba6d07acda4b179662e5b6eb23baf6f70173240cf8a6b69834d2db9c740a80e25

data/LICENSE.md

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

@@ -4,7 +4,6 @@
 [![GitHub Actions CI](https://github.com/lostisland/faraday/workflows/CI/badge.svg)](https://github.com/lostisland/faraday/actions?query=workflow%3ACI)
 [![GitHub Discussions](https://img.shields.io/github/discussions/lostisland/faraday?logo=github)](https://github.com/lostisland/faraday/discussions)
 
-
 Faraday is an HTTP client library abstraction layer 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.
 You probably don't want to use Faraday directly in your project, as it will lack an actual client library to perform
@@ -13,7 +12,8 @@ requests. Instead, you probably want to have a look at [Awesome Faraday][awesome
 ## Getting Started
 
 The best starting point is the [Faraday Website][website], with its introduction and explanation.
-Need more details? See the [Faraday API Documentation][apidoc] to see how it works internally.
+
+Need more details? See the [Faraday API Documentation][apidoc] to see how it works internally, or take a look at [Advanced techniques for calling HTTP APIs in Ruby](https://mattbrictson.com/blog/advanced-http-techniques-in-ruby) blog post from @mattbrictson 🚀
 
 ## Supported Ruby versions
 
@@ -42,14 +42,15 @@ Open the issues page and check for the `help wanted` label!
 But before you start coding, please read our [Contributing Guide][contributing]
 
 ## Copyright
-© 2009 - 2022, the [Faraday Team][faraday_team]. Website and branding design by [Elena Lo Piccolo](https://elelopic.design).
 
-[awesome]:      https://github.com/lostisland/awesome-faraday/#adapters
-[website]:      https://lostisland.github.io/faraday
+© 2009 - 2023, the [Faraday Team][faraday_team]. Website and branding design by [Elena Lo Piccolo](https://elelopic.design).
+
+[awesome]: https://github.com/lostisland/awesome-faraday/#adapters
+[website]: https://lostisland.github.io/faraday
 [faraday_team]: https://lostisland.github.io/faraday/team
 [contributing]: https://github.com/lostisland/faraday/blob/master/.github/CONTRIBUTING.md
-[apidoc]:       https://www.rubydoc.info/github/lostisland/faraday
-[actions]:      https://github.com/lostisland/faraday/actions
-[jruby]:        http://jruby.org/
-[rubinius]:     http://rubini.us/
-[license]:      LICENSE.md
+[apidoc]: https://www.rubydoc.info/github/lostisland/faraday
+[actions]: https://github.com/lostisland/faraday/actions
+[jruby]: http://jruby.org/
+[rubinius]: http://rubini.us/
+[license]: LICENSE.md

data/Rakefile

@@ -2,6 +2,8 @@
 
 require 'rspec/core/rake_task'
 
-RSpec::Core::RakeTask.new(:spec)
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.ruby_opts = %w[-W]
+end
 
 task default: :spec

data/lib/faraday/adapter/test.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'timeout'
+
 module Faraday
   class Adapter
     # @example
@@ -182,7 +184,7 @@ module Faraday
       end
 
       # Stub request
-      class Stub < Struct.new(:host, :path, :query, :headers, :body, :strict_mode, :block) # rubocop:disable Style/StructInheritance
+      Stub = Struct.new(:host, :path, :query, :headers, :body, :strict_mode, :block) do
         # @param env [Faraday::Env]
         def matches?(env)
           request_host = env[:url].host
@@ -238,7 +240,7 @@ module Faraday
         end
 
         def body_match?(request_body)
-          return true if body.to_s.size.zero?
+          return true if body.to_s.empty?
 
           case body
           when Proc
@@ -273,15 +275,26 @@ module Faraday
 
         unless stub
           raise Stubs::NotFound, "no stubbed request for #{env[:method]} " \
-                                 "#{env[:url]} #{env[:body]}"
+                                 "#{env[:url]} #{env[:body]} #{env[:headers]}"
         end
 
         block_arity = stub.block.arity
+        params = if block_arity >= 0
+                   [env, meta].take(block_arity)
+                 else
+                   [env, meta]
+                 end
+
+        timeout = request_timeout(:open, env[:request])
+        timeout ||= request_timeout(:read, env[:request])
+
         status, headers, body =
-          if block_arity >= 0
-            stub.block.call(*[env, meta].take(block_arity))
+          if timeout
+            ::Timeout.timeout(timeout, Faraday::TimeoutError) do
+              stub.block.call(*params)
+            end
           else
-            stub.block.call(env, meta)
+            stub.block.call(*params)
           end
 
         # We need to explicitly pass `reason_phrase = nil` here to avoid keyword args conflicts.

data/lib/faraday/adapter.rb

@@ -78,8 +78,7 @@ module Faraday
     # @param type [Symbol] Describes which timeout setting to get: :read,
     #                      :write, or :open.
     # @param options [Hash] Hash containing Symbol keys like :timeout,
-    #                       :read_timeout, :write_timeout, :open_timeout, or
-    #                       :timeout
+    #                       :read_timeout, :write_timeout, or :open_timeout
     #
     # @return [Integer, nil] Timeout duration in seconds, or nil if no timeout
     #                        has been set.

data/lib/faraday/connection.rb

@@ -220,7 +220,7 @@ module Faraday
     # @yield [Faraday::Request] for further request customizations
     # @return [Faraday::Response]
     def options(*args)
-      return @options if args.size.zero?
+      return @options if args.empty?
 
       url, params, headers = *args
       run_request(:options, url, nil, headers) do |request|
@@ -261,14 +261,13 @@ module Faraday
     # @param headers [Hash, nil] unencoded HTTP header key/value pairs.
     #
     # @example
-    #   # TODO: Make it a PUT example
-    #   conn.post '/items', data, content_type: 'application/json'
+    #   conn.put '/products/123', data, content_type: 'application/json'
     #
-    #   # Simple ElasticSearch indexing sample.
-    #   conn.post '/twitter/tweet' do |req|
-    #     req.headers[:content_type] = 'application/json'
-    #     req.params[:routing] = 'kimchy'
-    #     req.body = JSON.generate(user: 'kimchy', ...)
+    #   # Star a gist.
+    #   conn.put 'https://api.github.com/gists/GIST_ID/star' do |req|
+    #     req.headers['Accept'] = 'application/vnd.github+json'
+    #     req.headers['Authorization'] = 'Bearer <YOUR-TOKEN>'
+    #     req.headers['X-GitHub-Api-Version'] = '2022-11-28'
     #   end
     #
     # @yield [Faraday::Request] for further request customizations
@@ -471,10 +470,10 @@ module Faraday
     def build_exclusive_url(url = nil, params = nil, params_encoder = nil)
       url = nil if url.respond_to?(:empty?) && url.empty?
       base = url_prefix.dup
-      if url && base.path && base.path !~ %r{/$}
+      if url && !base.path.end_with?('/')
         base.path = "#{base.path}/" # ensure trailing slash
       end
-      url = url.to_s.gsub(':', '%3A') if url && URI.parse(url.to_s).opaque
+      url = url.to_s.gsub(':', '%3A') if URI.parse(url.to_s).opaque
       uri = url ? base + url : base
       if params
         uri.query = params.to_query(params_encoder || options.params_encoder)
@@ -515,22 +514,17 @@ module Faraday
       return if Faraday.ignore_env_proxy
 
       uri = nil
-      if URI.parse('').respond_to?(:find_proxy)
-        case url
-        when String
-          uri = Utils.URI(url)
-          uri = if uri.host.nil?
-                  find_default_proxy
-                else
-                  URI.parse("#{uri.scheme}://#{uri.host}").find_proxy
-                end
-        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']
+      case url
+      when String
+        uri = Utils.URI(url)
+        uri = if uri.host.nil?
+                find_default_proxy
+              else
+                URI.parse("#{uri.scheme}://#{uri.host}").find_proxy
+              end
+      when URI
+        uri = url.find_proxy
+      when nil
         uri = find_default_proxy
       end
       ProxyOptions.from(uri) if uri

data/lib/faraday/error.rb

@@ -29,15 +29,21 @@ module Faraday
     end
 
     def response_status
-      @response[:status] if @response
+      return unless @response
+
+      @response.is_a?(Faraday::Response) ? @response.status : @response[:status]
     end
 
     def response_headers
-      @response[:headers] if @response
+      return unless @response
+
+      @response.is_a?(Faraday::Response) ? @response.headers : @response[:headers]
     end
 
     def response_body
-      @response[:body] if @response
+      return unless @response
+
+      @response.is_a?(Faraday::Response) ? @response.body : @response[:body]
     end
 
     protected
@@ -106,6 +112,10 @@ module Faraday
   class ProxyAuthError < ClientError
   end
 
+  # Raised by Faraday::Response::RaiseError in case of a 408 response.
+  class RequestTimeoutError < ClientError
+  end
+
   # Raised by Faraday::Response::RaiseError in case of a 409 response.
   class ConflictError < ClientError
   end

data/lib/faraday/logging/formatter.rb

@@ -8,35 +8,47 @@ module Faraday
     class Formatter
       extend Forwardable
 
-      DEFAULT_OPTIONS = { headers: true, bodies: false,
+      DEFAULT_OPTIONS = { headers: true, bodies: false, errors: false,
                           log_level: :info }.freeze
 
       def initialize(logger:, options:)
         @logger = logger
-        @filter = []
         @options = DEFAULT_OPTIONS.merge(options)
+        unless %i[debug info warn error fatal].include?(@options[:log_level])
+          @options[:log_level] = :info
+        end
+        @filter = []
       end
 
       def_delegators :@logger, :debug, :info, :warn, :error, :fatal
 
       def request(env)
-        request_log = proc do
+        public_send(log_level, 'request') do
           "#{env.method.upcase} #{apply_filters(env.url.to_s)}"
         end
-        public_send(log_level, 'request', &request_log)
 
         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)
-        status = proc { "Status #{env.status}" }
-        public_send(log_level, 'response', &status)
+        public_send(log_level, 'response') { "Status #{env.status}" }
 
         log_headers('response', env.response_headers) if log_headers?(:response)
         log_body('response', env[:body]) if env[:body] && log_body?(:response)
       end
 
+      def exception(exc)
+        return unless log_errors?
+
+        public_send(log_level, 'error') { exc.full_message }
+
+        log_headers('error', exc.response_headers) if exc.respond_to?(:response_headers) && log_headers?(:error)
+        return unless exc.respond_to?(:response_body) && exc.response_body && log_body?(:error)
+
+        log_body('error', exc.response_body)
+      end
+
       def filter(filter_word, filter_replacement)
         @filter.push([filter_word, filter_replacement])
       end
@@ -44,6 +56,8 @@ module Faraday
       private
 
       def dump_headers(headers)
+        return if headers.nil?
+
         headers.map { |k, v| "#{k}: #{v.inspect}" }.join("\n")
       end
 
@@ -77,6 +91,10 @@ module Faraday
         end
       end
 
+      def log_errors?
+        @options[:errors]
+      end
+
       def apply_filters(output)
         @filter.each do |pattern, replacement|
           output = output.to_s.gsub(pattern, replacement)
@@ -85,21 +103,15 @@ module Faraday
       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)
+        public_send(log_level, type) { apply_filters(dump_headers(headers)) }
       end
 
       def log_body(type, body)
-        body_log = proc { apply_filters(dump_body(body)) }
-        public_send(log_level, type, &body_log)
+        public_send(log_level, type) { apply_filters(dump_body(body)) }
       end
     end
   end

data/lib/faraday/middleware.rb

@@ -17,6 +17,9 @@ module Faraday
       app.call(env).on_complete do |environment|
         on_complete(environment) if respond_to?(:on_complete)
       end
+    rescue StandardError => e
+      on_error(e) if respond_to?(:on_error)
+      raise
     end
 
     def close

data/lib/faraday/options/connection_options.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 module Faraday
-  # ConnectionOptions contains the configurable properties for a Faraday
-  # connection object.
-  class ConnectionOptions < Options.new(:request, :proxy, :ssl, :builder, :url,
-                                        :parallel_manager, :params, :headers,
-                                        :builder_class)
-
+  # @!parse
+  #   # ConnectionOptions contains the configurable properties for a Faraday
+  #   # connection object.
+  #   class ConnectionOptions < Options; end
+  ConnectionOptions = Options.new(:request, :proxy, :ssl, :builder, :url,
+                                  :parallel_manager, :params, :headers,
+                                  :builder_class) do
     options request: RequestOptions, ssl: SSLOptions
 
     memoized(:request) { self.class.options_for(:request).new }

data/lib/faraday/options/env.rb

@@ -1,65 +1,70 @@
 # frozen_string_literal: true
 
 module Faraday
-  # @!attribute method
-  #   @return [Symbol] HTTP method (`:get`, `:post`)
-  #
-  # @!attribute body
-  #   @return [String] The request body that will eventually be converted to a
-  #   string.
-  #
-  # @!attribute url
-  #   @return [URI] URI instance for the current request.
-  #
-  # @!attribute request
-  #   @return [Hash] options for configuring the request.
-  #   Options for configuring the request.
-  #
-  #   - `:timeout`  open/read timeout Integer in seconds
-  #   - `:open_timeout` - read timeout Integer in seconds
-  #   - `:on_data`      - Proc for streaming
-  #   - `:proxy`        - Hash of proxy options
-  #       - `:uri`        - Proxy Server URI
-  #       - `:user`       - Proxy server username
-  #       - `:password`   - Proxy server password
-  #
-  # @!attribute request_headers
-  #   @return [Hash] HTTP Headers to be sent to the server.
-  #
-  # @!attribute ssl
-  #   @return [Hash] options for configuring SSL requests
-  #
-  # @!attribute parallel_manager
-  #   @return [Object] sent if the connection is in parallel mode
-  #
-  # @!attribute params
-  #   @return [Hash]
-  #
-  # @!attribute response
-  #   @return [Response]
-  #
-  # @!attribute response_headers
-  #   @return [Hash] HTTP headers from the server
-  #
-  # @!attribute status
-  #   @return [Integer] HTTP response status code
-  #
-  # @!attribute reason_phrase
-  #   @return [String]
-  class Env < Options.new(:method, :request_body, :url, :request,
-                          :request_headers, :ssl, :parallel_manager, :params,
-                          :response, :response_headers, :status,
-                          :reason_phrase, :response_body)
-
-    # rubocop:disable Naming/ConstantName
-    ContentLength = 'Content-Length'
-    StatusesWithoutBody = Set.new [204, 304]
-    SuccessfulStatuses = (200..299).freeze
-    # rubocop:enable Naming/ConstantName
+  # @!parse
+  #   # @!attribute method
+  #   #   @return [Symbol] HTTP method (`:get`, `:post`)
+  #   #
+  #   # @!attribute body
+  #   #   @return [String] The request body that will eventually be converted to a
+  #   #   string.
+  #   #
+  #   # @!attribute url
+  #   #   @return [URI] URI instance for the current request.
+  #   #
+  #   # @!attribute request
+  #   #   @return [Hash] options for configuring the request.
+  #   #   Options for configuring the request.
+  #   #
+  #   #   - `:timeout`       - time limit for the entire request (Integer in
+  #   #                        seconds)
+  #   #   - `:open_timeout`  - time limit for just the connection phase (e.g.
+  #   #                        handshake) (Integer in seconds)
+  #   #   - `:read_timeout`  - time limit for the first response byte received from
+  #   #                        the server (Integer in seconds)
+  #   #   - `:write_timeout` - time limit for the client to send the request to the
+  #   #                        server (Integer in seconds)
+  #   #   - `:on_data`       - Proc for streaming
+  #   #   - `:proxy`         - Hash of proxy options
+  #   #       - `:uri`         - Proxy server URI
+  #   #       - `:user`        - Proxy server username
+  #   #       - `:password`    - Proxy server password
+  #   #
+  #   # @!attribute request_headers
+  #   #   @return [Hash] HTTP Headers to be sent to the server.
+  #   #
+  #   # @!attribute ssl
+  #   #   @return [Hash] options for configuring SSL requests
+  #   #
+  #   # @!attribute parallel_manager
+  #   #   @return [Object] sent if the connection is in parallel mode
+  #   #
+  #   # @!attribute params
+  #   #   @return [Hash]
+  #   #
+  #   # @!attribute response
+  #   #   @return [Response]
+  #   #
+  #   # @!attribute response_headers
+  #   #   @return [Hash] HTTP headers from the server
+  #   #
+  #   # @!attribute status
+  #   #   @return [Integer] HTTP response status code
+  #   #
+  #   # @!attribute reason_phrase
+  #   #   @return [String]
+  #   class Env < Options; end
+  Env = Options.new(:method, :request_body, :url, :request,
+                    :request_headers, :ssl, :parallel_manager, :params,
+                    :response, :response_headers, :status,
+                    :reason_phrase, :response_body) do
+    const_set(:ContentLength, 'Content-Length')
+    const_set(:StatusesWithoutBody, Set.new([204, 304]))
+    const_set(:SuccessfulStatuses, (200..299).freeze)
 
     # A Set of HTTP verbs that typically send a body.  If no body is set for
     # these requests, the Content-Length header is set to 0.
-    MethodsWithBodies = Set.new(Faraday::METHODS_WITH_BODY.map(&:to_sym))
+    const_set(:MethodsWithBodies, Set.new(Faraday::METHODS_WITH_BODY.map(&:to_sym)))
 
     options request: RequestOptions,
             request_headers: Utils::Headers, response_headers: Utils::Headers
@@ -120,25 +125,25 @@ module Faraday
 
     # @return [Boolean] true if status is in the set of {SuccessfulStatuses}.
     def success?
-      SuccessfulStatuses.include?(status)
+      Env::SuccessfulStatuses.include?(status)
     end
 
     # @return [Boolean] true if there's no body yet, and the method is in the
-    # set of {MethodsWithBodies}.
+    # set of {Env::MethodsWithBodies}.
     def needs_body?
-      !body && MethodsWithBodies.include?(method)
+      !body && Env::MethodsWithBodies.include?(method)
     end
 
     # Sets content length to zero and the body to the empty string.
     def clear_body
-      request_headers[ContentLength] = '0'
+      request_headers[Env::ContentLength] = '0'
       self.body = +''
     end
 
     # @return [Boolean] true if the status isn't in the set of
-    # {StatusesWithoutBody}.
+    # {Env::StatusesWithoutBody}.
     def parse_body?
-      !StatusesWithoutBody.include?(status)
+      !Env::StatusesWithoutBody.include?(status)
     end
 
     # @return [Boolean] true if there is a parallel_manager

data/lib/faraday/options/proxy_options.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
 module Faraday
-  # ProxyOptions contains the configurable properties for the proxy
-  # configuration used when making an HTTP request.
-  class ProxyOptions < Options.new(:uri, :user, :password)
+  # @!parse
+  #   # ProxyOptions contains the configurable properties for the proxy
+  #   # configuration used when making an HTTP request.
+  #   class ProxyOptions < Options; end
+  ProxyOptions = Options.new(:uri, :user, :password) do
     extend Forwardable
     def_delegators :uri, :scheme, :scheme=, :host, :host=, :port, :port=,
                    :path, :path=
 
     def self.from(value)
       case value
+      when ''
+        value = nil
       when String
         # URIs without a scheme should default to http (like 'example:123').
         # This fixes #1282 and prevents a silent failure in some adapters.

data/lib/faraday/options/request_options.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 module Faraday
-  # RequestOptions contains the configurable properties for a Faraday request.
-  class RequestOptions < Options.new(:params_encoder, :proxy, :bind,
-                                     :timeout, :open_timeout, :read_timeout,
-                                     :write_timeout, :boundary, :oauth,
-                                     :context, :on_data)
-
+  # @!parse
+  #   # RequestOptions contains the configurable properties for a Faraday request.
+  #   class RequestOptions < Options; end
+  RequestOptions = Options.new(:params_encoder, :proxy, :bind,
+                               :timeout, :open_timeout, :read_timeout,
+                               :write_timeout, :boundary, :oauth,
+                               :context, :on_data) do
     def []=(key, value)
       if key && key.to_sym == :proxy
         super(key, value ? ProxyOptions.from(value) : nil)

data/lib/faraday/options/ssl_options.rb

@@ -1,56 +1,57 @@
 # frozen_string_literal: true
 
 module Faraday
-  # SSL-related options.
-  #
-  # @!attribute verify
-  #   @return [Boolean] whether to verify SSL certificates or not
-  #
-  # @!attribute verify_hostname
-  #   @return [Boolean] whether to enable hostname verification on server certificates
-  #           during the handshake or not (see https://github.com/ruby/openssl/pull/60)
-  #
-  # @!attribute ca_file
-  #   @return [String] CA file
-  #
-  # @!attribute ca_path
-  #   @return [String] CA path
-  #
-  # @!attribute verify_mode
-  #   @return [Integer] Any `OpenSSL::SSL::` constant (see https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL.html)
-  #
-  # @!attribute cert_store
-  #   @return [OpenSSL::X509::Store] certificate store
-  #
-  # @!attribute client_cert
-  #   @return [String, OpenSSL::X509::Certificate] client certificate
-  #
-  # @!attribute client_key
-  #   @return [String, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA] client key
-  #
-  # @!attribute certificate
-  #   @return [OpenSSL::X509::Certificate] certificate (Excon only)
-  #
-  # @!attribute private_key
-  #   @return [OpenSSL::PKey::RSA, OpenSSL::PKey::DSA] private key (Excon only)
-  #
-  # @!attribute verify_depth
-  #   @return [Integer] maximum depth for the certificate chain verification
-  #
-  # @!attribute version
-  #   @return [String, Symbol] SSL version (see https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html#method-i-ssl_version-3D)
-  #
-  # @!attribute min_version
-  #   @return [String, Symbol] minimum SSL version (see https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html#method-i-min_version-3D)
-  #
-  # @!attribute max_version
-  #   @return [String, Symbol] maximum SSL version (see https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html#method-i-max_version-3D)
-  class SSLOptions < Options.new(:verify, :verify_hostname,
-                                 :ca_file, :ca_path, :verify_mode,
-                                 :cert_store, :client_cert, :client_key,
-                                 :certificate, :private_key, :verify_depth,
-                                 :version, :min_version, :max_version)
-
+  # @!parse
+  #   # SSL-related options.
+  #   #
+  #   # @!attribute verify
+  #   #   @return [Boolean] whether to verify SSL certificates or not
+  #   #
+  #   # @!attribute verify_hostname
+  #   #   @return [Boolean] whether to enable hostname verification on server certificates
+  #   #           during the handshake or not (see https://github.com/ruby/openssl/pull/60)
+  #   #
+  #   # @!attribute ca_file
+  #   #   @return [String] CA file
+  #   #
+  #   # @!attribute ca_path
+  #   #   @return [String] CA path
+  #   #
+  #   # @!attribute verify_mode
+  #   #   @return [Integer] Any `OpenSSL::SSL::` constant (see https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL.html)
+  #   #
+  #   # @!attribute cert_store
+  #   #   @return [OpenSSL::X509::Store] certificate store
+  #   #
+  #   # @!attribute client_cert
+  #   #   @return [String, OpenSSL::X509::Certificate] client certificate
+  #   #
+  #   # @!attribute client_key
+  #   #   @return [String, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA] client key
+  #   #
+  #   # @!attribute certificate
+  #   #   @return [OpenSSL::X509::Certificate] certificate (Excon only)
+  #   #
+  #   # @!attribute private_key
+  #   #   @return [OpenSSL::PKey::RSA, OpenSSL::PKey::DSA] private key (Excon only)
+  #   #
+  #   # @!attribute verify_depth
+  #   #   @return [Integer] maximum depth for the certificate chain verification
+  #   #
+  #   # @!attribute version
+  #   #   @return [String, Symbol] SSL version (see https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html#method-i-ssl_version-3D)
+  #   #
+  #   # @!attribute min_version
+  #   #   @return [String, Symbol] minimum SSL version (see https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html#method-i-min_version-3D)
+  #   #
+  #   # @!attribute max_version
+  #   #   @return [String, Symbol] maximum SSL version (see https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html#method-i-max_version-3D)
+  #   class SSLOptions < Options; end
+  SSLOptions = Options.new(:verify, :verify_hostname,
+                           :ca_file, :ca_path, :verify_mode,
+                           :cert_store, :client_cert, :client_key,
+                           :certificate, :private_key, :verify_depth,
+                           :version, :min_version, :max_version) do
     # @return [Boolean] true if should verify
     def verify?
       verify != false

data/lib/faraday/options.rb

@@ -174,6 +174,7 @@ module Faraday
 
       memoized_attributes[key.to_sym] = block
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        remove_method(key) if method_defined?(key, false)
         def #{key}() self[:#{key}]; end
       RUBY
     end

data/lib/faraday/request/instrumentation.rb

@@ -5,12 +5,14 @@ module Faraday
     # Middleware for instrumenting Requests.
     class Instrumentation < Faraday::Middleware
       # Options class used in Request::Instrumentation class.
-      class Options < Faraday::Options.new(:name, :instrumenter)
+      Options = Faraday::Options.new(:name, :instrumenter) do
+        remove_method :name
         # @return [String]
         def name
           self[:name] ||= 'request.faraday'
         end
 
+        remove_method :instrumenter
         # @return [Class]
         def instrumenter
           self[:instrumenter] ||= ActiveSupport::Notifications

data/lib/faraday/request/json.rb

@@ -40,7 +40,16 @@ module Faraday
       end
 
       def body?(env)
-        (body = env[:body]) && !(body.respond_to?(:to_str) && body.empty?)
+        body = env[:body]
+        case body
+        when true, false
+          true
+        when nil
+          # NOTE: nil can be converted to `"null"`, but this middleware doesn't process `nil` for the compatibility.
+          false
+        else
+          !(body.respond_to?(:to_str) && body.empty?)
+        end
       end
 
       def request_type(env)

data/lib/faraday/request.rb

@@ -24,13 +24,14 @@ module Faraday
   #   @return [String] body
   # @!attribute options
   #   @return [RequestOptions] options
-  #
-  # rubocop:disable Style/StructInheritance
-  class Request < Struct.new(:http_method, :path, :params, :headers, :body, :options)
-    # rubocop:enable Style/StructInheritance
-
+  Request = Struct.new(:http_method, :path, :params, :headers, :body, :options) do
     extend MiddlewareRegistry
 
+    alias_method :member_get, :[]
+    private :member_get
+    alias_method :member_set, :[]=
+    private :member_set
+
     # @param request_method [String]
     # @yield [request] for block customization, if block given
     # @yieldparam request [Request]
@@ -41,6 +42,7 @@ module Faraday
       end
     end
 
+    remove_method :params=
     # Replace params, preserving the existing hash type.
     #
     # @param hash [Hash] new params
@@ -48,10 +50,11 @@ module Faraday
       if params
         params.replace hash
       else
-        super
+        member_set(:params, hash)
       end
     end
 
+    remove_method :headers=
     # Replace request headers, preserving the existing hash type.
     #
     # @param hash [Hash] new headers
@@ -59,7 +62,7 @@ module Faraday
       if headers
         headers.replace hash
       else
-        super
+        member_set(:headers, hash)
       end
     end
 

data/lib/faraday/response/logger.rb

@@ -26,6 +26,10 @@ module Faraday
       def on_complete(env)
         @formatter.response(env)
       end
+
+      def on_error(exc)
+        @formatter.exception(exc) if @formatter.respond_to?(:exception)
+      end
     end
   end
 end

data/lib/faraday/response/raise_error.rb

@@ -24,6 +24,8 @@ module Faraday
           # mimic the behavior that we get with proxy requests with HTTPS
           msg = %(407 "Proxy Authentication Required")
           raise Faraday::ProxyAuthError.new(msg, response_values(env))
+        when 408
+          raise Faraday::RequestTimeoutError, response_values(env)
         when 409
           raise Faraday::ConflictError, response_values(env)
         when 422

data/lib/faraday/response.rb

@@ -61,7 +61,8 @@ module Faraday
     def to_hash
       {
         status: env.status, body: env.body,
-        response_headers: env.response_headers
+        response_headers: env.response_headers,
+        url: env.url
       }
     end
 

data/lib/faraday/utils/headers.rb

@@ -132,7 +132,12 @@ module Faraday
 
       # Join multiple values with a comma.
       def add_parsed(key, value)
-        self[key] ? self[key] << ', ' << value : self[key] = value
+        if key?(key)
+          self[key] = self[key].to_s
+          self[key] << ', ' << value
+        else
+          self[key] = value
+        end
       end
     end
   end

data/lib/faraday/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Faraday
-  VERSION = '2.6.0'
+  VERSION = '2.7.10'
 end

data/spec/faraday/adapter/test_spec.rb

@@ -410,4 +410,33 @@ RSpec.describe Faraday::Adapter::Test do
       end
     end
   end
+
+  describe 'request timeout' do
+    subject(:request) do
+      connection.get('/sleep') do |req|
+        req.options.timeout = timeout
+      end
+    end
+
+    before do
+      stubs.get('/sleep') do
+        sleep(0.01)
+        [200, {}, '']
+      end
+    end
+
+    context 'when request is within timeout' do
+      let(:timeout) { 1 }
+
+      it { expect(request.status).to eq 200 }
+    end
+
+    context 'when request is too slow' do
+      let(:timeout) { 0.001 }
+
+      it 'raises an exception' do
+        expect { request }.to raise_error(Faraday::TimeoutError)
+      end
+    end
+  end
 end

data/spec/faraday/connection_spec.rb

@@ -310,6 +310,21 @@ RSpec.describe Faraday::Connection do
         expect(uri.to_s).to eq('http://service.com/api/service%3Asearch?limit=400')
       end
     end
+
+    context 'with a custom `default_uri_parser`' do
+      let(:url) { 'http://httpbingo.org' }
+      let(:parser) { Addressable::URI }
+
+      around do |example|
+        with_default_uri_parser(parser) do
+          example.run
+        end
+      end
+
+      it 'does not raise error' do
+        expect { conn.build_exclusive_url('/nigiri') }.not_to raise_error
+      end
+    end
   end
 
   describe '#build_url' do

data/spec/faraday/error_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe Faraday::ClientError do
+RSpec.describe Faraday::Error do
   describe '.initialize' do
     subject { described_class.new(exception, response) }
     let(:response) { nil }
@@ -12,8 +12,10 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.response).to be_nil }
       it { expect(subject.message).to eq(exception.message) }
       it { expect(subject.backtrace).to eq(exception.backtrace) }
-      it { expect(subject.inspect).to eq('#<Faraday::ClientError wrapped=#<RuntimeError: test>>') }
+      it { expect(subject.inspect).to eq('#<Faraday::Error wrapped=#<RuntimeError: test>>') }
       it { expect(subject.response_status).to be_nil }
+      it { expect(subject.response_headers).to be_nil }
+      it { expect(subject.response_body).to be_nil }
     end
 
     context 'with response hash' do
@@ -22,8 +24,10 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.wrapped_exception).to be_nil }
       it { expect(subject.response).to eq(exception) }
       it { expect(subject.message).to eq('the server responded with status 400') }
-      it { expect(subject.inspect).to eq('#<Faraday::ClientError response={:status=>400}>') }
+      it { expect(subject.inspect).to eq('#<Faraday::Error response={:status=>400}>') }
       it { expect(subject.response_status).to eq(400) }
+      it { expect(subject.response_headers).to be_nil }
+      it { expect(subject.response_body).to be_nil }
     end
 
     context 'with string' do
@@ -32,8 +36,10 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.wrapped_exception).to be_nil }
       it { expect(subject.response).to be_nil }
       it { expect(subject.message).to eq('custom message') }
-      it { expect(subject.inspect).to eq('#<Faraday::ClientError #<Faraday::ClientError: custom message>>') }
+      it { expect(subject.inspect).to eq('#<Faraday::Error #<Faraday::Error: custom message>>') }
       it { expect(subject.response_status).to be_nil }
+      it { expect(subject.response_headers).to be_nil }
+      it { expect(subject.response_body).to be_nil }
     end
 
     context 'with anything else #to_s' do
@@ -42,8 +48,10 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.wrapped_exception).to be_nil }
       it { expect(subject.response).to be_nil }
       it { expect(subject.message).to eq('["error1", "error2"]') }
-      it { expect(subject.inspect).to eq('#<Faraday::ClientError #<Faraday::ClientError: ["error1", "error2"]>>') }
+      it { expect(subject.inspect).to eq('#<Faraday::Error #<Faraday::Error: ["error1", "error2"]>>') }
       it { expect(subject.response_status).to be_nil }
+      it { expect(subject.response_headers).to be_nil }
+      it { expect(subject.response_body).to be_nil }
     end
 
     context 'with exception string and response hash' do
@@ -53,8 +61,25 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.wrapped_exception).to be_nil }
       it { expect(subject.response).to eq(response) }
       it { expect(subject.message).to eq('custom message') }
-      it { expect(subject.inspect).to eq('#<Faraday::ClientError response={:status=>400}>') }
+      it { expect(subject.inspect).to eq('#<Faraday::Error response={:status=>400}>') }
       it { expect(subject.response_status).to eq(400) }
+      it { expect(subject.response_headers).to be_nil }
+      it { expect(subject.response_body).to be_nil }
+    end
+
+    context 'with exception and response object' do
+      let(:exception) { RuntimeError.new('test') }
+      let(:body) { { test: 'test' } }
+      let(:headers) { { 'Content-Type' => 'application/json' } }
+      let(:response) { Faraday::Response.new(status: 400, response_headers: headers, response_body: body) }
+
+      it { expect(subject.wrapped_exception).to eq(exception) }
+      it { expect(subject.response).to eq(response) }
+      it { expect(subject.message).to eq(exception.message) }
+      it { expect(subject.backtrace).to eq(exception.backtrace) }
+      it { expect(subject.response_status).to eq(400) }
+      it { expect(subject.response_headers).to eq(headers) }
+      it { expect(subject.response_body).to eq(body) }
     end
   end
 end

data/spec/faraday/middleware_spec.rb

@@ -33,6 +33,24 @@ RSpec.describe Faraday::Middleware do
     end
   end
 
+  describe '#on_error' do
+    subject do
+      Class.new(described_class) do
+        def on_error(error)
+          # do nothing
+        end
+      end.new(app)
+    end
+
+    it 'is called by #call' do
+      expect(app).to receive(:call).and_raise(Faraday::ConnectionFailed)
+      is_expected.to receive(:call).and_call_original
+      is_expected.to receive(:on_error)
+
+      expect { subject.call(double) }.to raise_error(Faraday::ConnectionFailed)
+    end
+  end
+
   describe '#close' do
     context "with app that doesn't support \#close" do
       it 'should issue warning' do

data/spec/faraday/options/options_spec.rb

@@ -2,7 +2,7 @@
 
 RSpec.describe Faraday::Options do
   SubOptions = Class.new(Faraday::Options.new(:sub_a, :sub_b))
-  class ParentOptions < Faraday::Options.new(:a, :b, :c)
+  ParentOptions = Faraday::Options.new(:a, :b, :c) do
     options c: SubOptions
   end
 

data/spec/faraday/options/proxy_options_spec.rb

@@ -32,6 +32,14 @@ RSpec.describe Faraday::ProxyOptions do
       expect(proxy.user).to be_nil
       expect(proxy.password).to be_nil
     end
+
+    it 'treats empty string as nil' do
+      proxy = nil
+      proxy_string = proxy.to_s # => empty string
+      options = Faraday::ProxyOptions.from proxy_string
+      expect(options).to be_a_kind_of(Faraday::ProxyOptions)
+      expect(options.inspect).to eq('#<Faraday::ProxyOptions (empty)>')
+    end
   end
 
   it 'allows hash access' do

data/spec/faraday/request/json_spec.rb

@@ -73,6 +73,30 @@ RSpec.describe Faraday::Request::Json do
     end
   end
 
+  context 'true body' do
+    let(:result) { process(true) }
+
+    it 'encodes body' do
+      expect(result_body).to eq('true')
+    end
+
+    it 'adds content type' do
+      expect(result_type).to eq('application/json')
+    end
+  end
+
+  context 'false body' do
+    let(:result) { process(false) }
+
+    it 'encodes body' do
+      expect(result_body).to eq('false')
+    end
+
+    it 'adds content type' do
+      expect(result_type).to eq('application/json')
+    end
+  end
+
   context 'object body with json type' do
     let(:result) { process({ a: 1 }, 'application/json; charset=utf-8') }
 

data/spec/faraday/response/logger_spec.rb

@@ -25,6 +25,7 @@ RSpec.describe Faraday::Response::Logger do
         stubs.get('/filtered_headers') { [200, { 'Content-Type' => 'text/html' }, 'headers response'] }
         stubs.get('/filtered_params') { [200, { 'Content-Type' => 'text/html' }, 'params response'] }
         stubs.get('/filtered_url') { [200, { 'Content-Type' => 'text/html' }, 'url response'] }
+        stubs.get('/connection_failed') { raise Faraday::ConnectionFailed, 'Failed to open TCP connection' }
       end
     end
   end
@@ -64,6 +65,15 @@ RSpec.describe Faraday::Response::Logger do
       expect(formatter).to receive(:response).with(an_instance_of(Faraday::Env))
       conn.get '/hello'
     end
+
+    context 'when no route' do
+      it 'delegates logging to the formatter' do
+        expect(formatter).to receive(:request).with(an_instance_of(Faraday::Env))
+        expect(formatter).to receive(:exception).with(an_instance_of(Faraday::Adapter::Test::Stubs::NotFound))
+
+        expect { conn.get '/noroute' }.to raise_error(Faraday::Adapter::Test::Stubs::NotFound)
+      end
+    end
   end
 
   context 'with custom formatter' do
@@ -94,6 +104,16 @@ RSpec.describe Faraday::Response::Logger do
     expect(string_io.string).to match('GET http:/hello')
   end
 
+  it 'logs status' do
+    conn.get '/hello', nil, accept: 'text/html'
+    expect(string_io.string).to match('Status 200')
+  end
+
+  it 'does not log error message by default' do
+    expect { conn.get '/noroute' }.to raise_error(Faraday::Adapter::Test::Stubs::NotFound)
+    expect(string_io.string).not_to match(%(no stubbed request for get http:/noroute))
+  end
+
   it 'logs request headers by default' do
     conn.get '/hello', nil, accept: 'text/html'
     expect(string_io.string).to match(%(Accept: "text/html))
@@ -188,6 +208,24 @@ RSpec.describe Faraday::Response::Logger do
     end
   end
 
+  context 'when logging errors' do
+    let(:logger_options) { { errors: true } }
+
+    it 'logs error message' do
+      expect { conn.get '/noroute' }.to raise_error(Faraday::Adapter::Test::Stubs::NotFound)
+      expect(string_io.string).to match(%(no stubbed request for get http:/noroute))
+    end
+  end
+
+  context 'when logging headers and errors' do
+    let(:logger_options) { { headers: true, errors: true } }
+
+    it 'logs error message' do
+      expect { conn.get '/connection_failed' }.to raise_error(Faraday::ConnectionFailed)
+      expect(string_io.string).to match(%(Failed to open TCP connection))
+    end
+  end
+
   context 'when using log_level' do
     let(:logger_options) { { bodies: true, log_level: :debug } }
 

data/spec/faraday/response/raise_error_spec.rb

@@ -11,6 +11,7 @@ RSpec.describe Faraday::Response::RaiseError do
         stub.get('forbidden') { [403, { 'X-Reason' => 'because' }, 'keep looking'] }
         stub.get('not-found') { [404, { 'X-Reason' => 'because' }, 'keep looking'] }
         stub.get('proxy-error') { [407, { 'X-Reason' => 'because' }, 'keep looking'] }
+        stub.get('request-timeout') { [408, { 'X-Reason' => 'because' }, 'keep looking'] }
         stub.get('conflict') { [409, { 'X-Reason' => 'because' }, 'keep looking'] }
         stub.get('unprocessable-entity') { [422, { 'X-Reason' => 'because' }, 'keep looking'] }
         stub.get('4xx') { [499, { 'X-Reason' => 'because' }, 'keep looking'] }
@@ -79,6 +80,17 @@ RSpec.describe Faraday::Response::RaiseError do
     end
   end
 
+  it 'raises Faraday::RequestTimeoutError for 408 responses' do
+    expect { conn.get('request-timeout') }.to raise_error(Faraday::RequestTimeoutError) do |ex|
+      expect(ex.message).to eq('the server responded with status 408')
+      expect(ex.response[:headers]['X-Reason']).to eq('because')
+      expect(ex.response[:status]).to eq(408)
+      expect(ex.response_status).to eq(408)
+      expect(ex.response_body).to eq('keep looking')
+      expect(ex.response_headers['X-Reason']).to eq('because')
+    end
+  end
+
   it 'raises Faraday::ConflictError for 409 responses' do
     expect { conn.get('conflict') }.to raise_error(Faraday::ConflictError) do |ex|
       expect(ex.message).to eq('the server responded with status 409')

data/spec/faraday/response_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe Faraday::Response do
   subject { Faraday::Response.new(env) }
 
   let(:env) do
-    Faraday::Env.from(status: 404, body: 'yikes',
+    Faraday::Env.from(status: 404, body: 'yikes', url: Faraday::Utils.URI('https://lostisland.github.io/faraday'),
                       response_headers: { 'Content-Type' => 'text/plain' })
   end
 
@@ -30,6 +30,7 @@ RSpec.describe Faraday::Response do
     it { expect(hash[:status]).to eq(subject.status) }
     it { expect(hash[:response_headers]).to eq(subject.headers) }
     it { expect(hash[:body]).to eq(subject.body) }
+    it { expect(hash[:url]).to eq(subject.env.url) }
   end
 
   describe 'marshal serialization support' do
@@ -45,6 +46,7 @@ RSpec.describe Faraday::Response do
     it { expect(loaded.env[:body]).to eq(env[:body]) }
     it { expect(loaded.env[:response_headers]).to eq(env[:response_headers]) }
     it { expect(loaded.env[:status]).to eq(env[:status]) }
+    it { expect(loaded.env[:url]).to eq(env[:url]) }
   end
 
   describe '#on_complete' do

data/spec/faraday/utils/headers_spec.rb

@@ -57,11 +57,11 @@ RSpec.describe Faraday::Utils::Headers do
   end
 
   describe '#parse' do
-    before { subject.parse(headers) }
-
     context 'when response headers leave http status line out' do
       let(:headers) { "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n" }
 
+      before { subject.parse(headers) }
+
       it { expect(subject.keys).to eq(%w[Content-Type]) }
       it { expect(subject['Content-Type']).to eq('text/html') }
       it { expect(subject['content-type']).to eq('text/html') }
@@ -70,13 +70,31 @@ RSpec.describe Faraday::Utils::Headers do
     context 'when response headers values include a colon' do
       let(:headers) { "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nLocation: http://httpbingo.org/\r\n\r\n" }
 
+      before { subject.parse(headers) }
+
       it { expect(subject['location']).to eq('http://httpbingo.org/') }
     end
 
     context 'when response headers include a blank line' do
       let(:headers) { "HTTP/1.1 200 OK\r\n\r\nContent-Type: text/html\r\n\r\n" }
 
+      before { subject.parse(headers) }
+
       it { expect(subject['content-type']).to eq('text/html') }
     end
+
+    context 'when response headers include already stored keys' do
+      let(:headers) { "HTTP/1.1 200 OK\r\nX-Numbers: 123\r\n\r\n" }
+
+      before do
+        h = subject
+        h[:x_numbers] = 8
+        h.parse(headers)
+      end
+
+      it do
+        expect(subject[:x_numbers]).to eq('8, 123')
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: faraday
 version: !ruby/object:Gem::Version
-  version: 2.6.0
+  version: 2.7.10
 platform: ruby
 authors:
 - "@technoweenie"
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-10-03 00:00:00.000000000 Z
+date: 2023-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday-net_http
@@ -131,7 +131,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://lostisland.github.io/faraday
-  changelog_uri: https://github.com/lostisland/faraday/releases/tag/v2.6.0
+  changelog_uri: https://github.com/lostisland/faraday/releases/tag/v2.7.10
   source_code_uri: https://github.com/lostisland/faraday
   bug_tracker_uri: https://github.com/lostisland/faraday/issues
 post_install_message: