faraday 2.8.1 → 2.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14056963c7f6d474cd9c3a407ea2bfbe9e9fd2246b3b3a69aa57585668bc0739
-  data.tar.gz: d8d3125754e43fdfdfbaf134d53d2e6524944cd68422f7b10b13fb587a9ff288
+  metadata.gz: bfb424c45e703a33fd819b31c8ee41c9e4e30874b280530a19ce8ae320570ef9
+  data.tar.gz: c1a1a5b7aab4f393908958701959f7b41fd303ca4da906c1b4c0581a13c590db
 SHA512:
-  metadata.gz: 026fcfad3c5696d387f4bd68c6ddbe36ef6b13a640771209954adf4fb191d27e8fcc13af61b23645cba44cf4f92c71e720a3e7d022081402143b8639ca0a8fa7
-  data.tar.gz: 21bce5de8543dc53735214b7a35d6dcf3387f93be56e1a1c575522ce07e66d6de555fbb5673aede73f3fa9ca3fa3613e06a5aa7e9a63035b8028553f2cb4ccfe
+  metadata.gz: 6d4d18e2006ac83dfd22aff834b4fe3c983bfbf578b6850944d35cfbb1ca40ba58ce07414821bc3e604ca3310c85500d5d2b8de7c33b0e6147f24484fcae688f
+  data.tar.gz: 9cc8057d003f09a02bbdb9a29b920003beff58391c3bf86838ae61b2e9aaac4782d5764286f824b24d486e8dee202cc2d892ec3f658db6b710d5088d5836be3c

data/CHANGELOG.md

@@ -517,7 +517,7 @@ Breaking changes:
 - Drop support for Ruby 1.8
 
 Features:
-- Include wrapped exception/reponse in ClientErrors
+- Include wrapped exception/response in ClientErrors
 - Add `response.reason_phrase`
 - Provide option to selectively skip logging request/response headers
 - Add regex support for pattern matching in `test` adapter

data/README.md

@@ -35,7 +35,7 @@ Need more details? See the [Faraday API Documentation][apidoc] to see how it wor
 This library aims to support and is [tested against][actions] the currently officially supported Ruby
 implementations. This means that, even without a major release, we could add or drop support for Ruby versions,
 following their [EOL](https://endoflife.date/ruby).
-Currently that means we support Ruby 2.6+
+Currently that means we support Ruby 3.0+
 
 If something doesn't work on one of these Ruby versions, it's a bug.
 

data/Rakefile

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require 'rspec/core/rake_task'
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
 
 RSpec::Core::RakeTask.new(:spec) do |task|
   task.ruby_opts = %w[-W]

data/lib/faraday/adapter.rb

@@ -26,7 +26,7 @@ module Faraday
     self.supports_parallel = false
 
     def initialize(_app = nil, opts = {}, &block)
-      @app = ->(env) { env.response }
+      @app = lambda(&:response)
       @connection_options = opts
       @config_block = block
     end

data/lib/faraday/connection.rb

@@ -15,7 +15,7 @@ module Faraday
   class Connection
     # A Set of allowed HTTP verbs.
     METHODS = Set.new %i[get post put delete head patch options trace]
-    USER_AGENT = "Faraday v#{VERSION}"
+    USER_AGENT = "Faraday v#{VERSION}".freeze
 
     # @return [Hash] URI query unencoded key/value pairs.
     attr_reader :params
@@ -314,15 +314,23 @@ module Faraday
     #
     # @yield a block to execute multiple requests.
     # @return [void]
-    def in_parallel(manager = nil)
+    def in_parallel(manager = nil, &block)
       @parallel_manager = manager || default_parallel_manager do
         warn 'Warning: `in_parallel` called but no parallel-capable adapter ' \
              'on Faraday stack'
         warn caller[2, 10].join("\n")
         nil
       end
-      yield
-      @parallel_manager&.run
+      return yield unless @parallel_manager
+
+      if @parallel_manager.respond_to?(:execute)
+        # Execute is the new method that is responsible for executing the block.
+        @parallel_manager.execute(&block)
+      else
+        # TODO: Old behaviour, deprecate and remove in 3.0
+        yield
+        @parallel_manager.run
+      end
     ensure
       @parallel_manager = nil
     end
@@ -423,8 +431,8 @@ module Faraday
     #
     # @param method [Symbol] HTTP method.
     # @param url [String, URI, nil] String or URI to access.
-    # @param body [String, nil] The request body that will eventually be converted to
-    #             a string.
+    # @param body [String, Hash, Array, nil] The request body that will eventually be converted to
+    #             a string; middlewares can be used to support more complex types.
     # @param headers [Hash, nil] unencoded HTTP header key/value pairs.
     #
     # @return [Faraday::Response]
@@ -473,7 +481,8 @@ module Faraday
       if url && !base.path.end_with?('/')
         base.path = "#{base.path}/" # ensure trailing slash
       end
-      url = url.to_s.gsub(':', '%3A') if URI.parse(url.to_s).opaque
+      # Ensure relative url will be parsed correctly (such as `service:search` )
+      url = "./#{url}" if url.respond_to?(:start_with?) && !url.start_with?('http://', 'https://', '/', './', '../')
       uri = url ? base + url : base
       if params
         uri.query = params.to_query(params_encoder || options.params_encoder)

data/lib/faraday/encoders/nested_params_encoder.rb

@@ -102,7 +102,7 @@ module Faraday
 
     protected
 
-    SUBKEYS_REGEX = /[^\[\]]+(?:\]?\[\])?/.freeze
+    SUBKEYS_REGEX = /[^\[\]]+(?:\]?\[\])?/
 
     def decode_pair(key, value, context)
       subkeys = key.scan(SUBKEYS_REGEX)

data/lib/faraday/error.rb

@@ -158,4 +158,8 @@ module Faraday
   # Raised by middlewares that parse the response, like the JSON response middleware.
   class ParsingError < Error
   end
+
+  # Raised by Faraday::Middleware and subclasses when invalid default_options are used
+  class InitializationError < Error
+  end
 end

data/lib/faraday/logging/formatter.rb

@@ -23,8 +23,8 @@ module Faraday
       def_delegators :@logger, :debug, :info, :warn, :error, :fatal
 
       def request(env)
-        public_send(log_level, 'request') do
-          "#{env.method.upcase} #{apply_filters(env.url.to_s)}"
+        public_send(log_level) do
+          "request: #{env.method.upcase} #{apply_filters(env.url.to_s)}"
         end
 
         log_headers('request', env.request_headers) if log_headers?(:request)
@@ -32,7 +32,7 @@ module Faraday
       end
 
       def response(env)
-        public_send(log_level, 'response') { "Status #{env.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)
@@ -41,7 +41,7 @@ module Faraday
       def exception(exc)
         return unless log_errors?
 
-        public_send(log_level, 'error') { exc.full_message }
+        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)
@@ -107,11 +107,11 @@ module Faraday
       end
 
       def log_headers(type, headers)
-        public_send(log_level, type) { apply_filters(dump_headers(headers)) }
+        public_send(log_level) { "#{type}: #{apply_filters(dump_headers(headers))}" }
       end
 
       def log_body(type, body)
-        public_send(log_level, type) { apply_filters(dump_body(body)) }
+        public_send(log_level) { "#{type}: #{apply_filters(dump_body(body))}" }
       end
     end
   end

data/lib/faraday/middleware.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'monitor'
+
 module Faraday
   # Middleware is the basic base class of any Faraday middleware.
   class Middleware
@@ -7,9 +9,46 @@ module Faraday
 
     attr_reader :app, :options
 
+    DEFAULT_OPTIONS = {}.freeze
+    LOCK = Mutex.new
+
     def initialize(app = nil, options = {})
       @app = app
-      @options = options
+      @options = self.class.default_options.merge(options)
+    end
+
+    class << self
+      # Faraday::Middleware::default_options= allows user to set default options at the Faraday::Middleware
+      # class level.
+      #
+      # @example Set the Faraday::Response::RaiseError option, `include_request` to `false`
+      # my_app/config/initializers/my_faraday_middleware.rb
+      #
+      # Faraday::Response::RaiseError.default_options = { include_request: false }
+      #
+      def default_options=(options = {})
+        validate_default_options(options)
+        LOCK.synchronize do
+          @default_options = default_options.merge(options)
+        end
+      end
+
+      # default_options attr_reader that initializes class instance variable
+      # with the values of any Faraday::Middleware defaults, and merges with
+      # subclass defaults
+      def default_options
+        @default_options ||= DEFAULT_OPTIONS.merge(self::DEFAULT_OPTIONS)
+      end
+
+      private
+
+      def validate_default_options(options)
+        invalid_keys = options.keys.reject { |opt| self::DEFAULT_OPTIONS.key?(opt) }
+        return unless invalid_keys.any?
+
+        raise(Faraday::InitializationError,
+              "Invalid options provided. Keys not found in #{self}::DEFAULT_OPTIONS: #{invalid_keys.join(', ')}")
+      end
     end
 
     def call(env)

data/lib/faraday/options/env.rb

@@ -60,7 +60,7 @@ module Faraday
                     :reason_phrase, :response_body) do
     const_set(:ContentLength, 'Content-Length')
     const_set(:StatusesWithoutBody, Set.new([204, 304]))
-    const_set(:SuccessfulStatuses, (200..299).freeze)
+    const_set(:SuccessfulStatuses, (200..299))
 
     # 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.
@@ -169,7 +169,7 @@ module Faraday
     def stream_response(&block)
       size = 0
       yielded = false
-      block_result = block.call do |chunk| # rubocop:disable Performance/RedundantBlockCall
+      block_result = block.call do |chunk|
         if chunk.bytesize.positive? || size.positive?
           yielded = true
           size += chunk.bytesize

data/lib/faraday/options/ssl_options.rb

@@ -46,12 +46,15 @@ module Faraday
   #   #
   #   # @!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)
+  #   #
+  #   # @!attribute ciphers
+  #   #   @return [String] cipher list in OpenSSL format (see https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html#method-i-ciphers-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
+                           :version, :min_version, :max_version, :ciphers) do
     # @return [Boolean] true if should verify
     def verify?
       verify != false

data/lib/faraday/rack_builder.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'ruby2_keywords'
 require 'faraday/adapter_registry'
 
 module Faraday
@@ -89,22 +88,22 @@ module Faraday
       @handlers.frozen?
     end
 
-    ruby2_keywords def use(klass, *args, &block)
+    def use(klass, ...)
       if klass.is_a? Symbol
-        use_symbol(Faraday::Middleware, klass, *args, &block)
+        use_symbol(Faraday::Middleware, klass, ...)
       else
         raise_if_locked
         raise_if_adapter(klass)
-        @handlers << self.class::Handler.new(klass, *args, &block)
+        @handlers << self.class::Handler.new(klass, ...)
       end
     end
 
-    ruby2_keywords def request(key, *args, &block)
-      use_symbol(Faraday::Request, key, *args, &block)
+    def request(key, ...)
+      use_symbol(Faraday::Request, key, ...)
     end
 
-    ruby2_keywords def response(key, *args, &block)
-      use_symbol(Faraday::Response, key, *args, &block)
+    def response(...)
+      use_symbol(Faraday::Response, ...)
     end
 
     ruby2_keywords def adapter(klass = NO_ARGUMENT, *args, &block)
@@ -116,25 +115,25 @@ module Faraday
 
     ## methods to push onto the various positions in the stack:
 
-    ruby2_keywords def insert(index, *args, &block)
+    def insert(index, ...)
       raise_if_locked
       index = assert_index(index)
-      handler = self.class::Handler.new(*args, &block)
+      handler = self.class::Handler.new(...)
       @handlers.insert(index, handler)
     end
 
     alias insert_before insert
 
-    ruby2_keywords def insert_after(index, *args, &block)
+    def insert_after(index, ...)
       index = assert_index(index)
-      insert(index + 1, *args, &block)
+      insert(index + 1, ...)
     end
 
-    ruby2_keywords def swap(index, *args, &block)
+    def swap(index, ...)
       raise_if_locked
       index = assert_index(index)
       @handlers.delete_at(index)
-      insert(index, *args, &block)
+      insert(index, ...)
     end
 
     def delete(handler)
@@ -238,8 +237,8 @@ module Faraday
       klass <= Faraday::Adapter
     end
 
-    ruby2_keywords def use_symbol(mod, key, *args, &block)
-      use(mod.lookup_middleware(key), *args, &block)
+    def use_symbol(mod, key, ...)
+      use(mod.lookup_middleware(key), ...)
     end
 
     def assert_index(index)

data/lib/faraday/request/json.rb

@@ -13,7 +13,7 @@ module Faraday
     # Doesn't try to encode bodies that already are in string form.
     class Json < Middleware
       MIME_TYPE = 'application/json'
-      MIME_TYPE_REGEX = %r{^application/(vnd\..+\+)?json$}.freeze
+      MIME_TYPE_REGEX = %r{^application/(vnd\..+\+)?json$}
 
       def on_request(env)
         match_content_type(env) do |data|

data/lib/faraday/response/json.rb

@@ -60,7 +60,8 @@ module Faraday
         @decoder_options =
           if @decoder_options.is_a?(Array) && @decoder_options.size >= 2
             @decoder_options.slice(0, 2)
-          elsif @decoder_options.respond_to?(:load)
+          elsif @decoder_options&.respond_to?(:load) # rubocop:disable Lint/RedundantSafeNavigation
+            # In some versions of Rails, `nil` responds to `load` - hence the safe navigation check above
             [@decoder_options, :load]
           else
             [::JSON, :parse]

data/lib/faraday/response/raise_error.rb

@@ -6,32 +6,32 @@ module Faraday
     # client or server error responses.
     class RaiseError < Middleware
       # rubocop:disable Naming/ConstantName
-      ClientErrorStatuses = (400...500).freeze
-      ServerErrorStatuses = (500...600).freeze
+      ClientErrorStatuses = (400...500)
+      ServerErrorStatuses = (500...600)
+      ClientErrorStatusesWithCustomExceptions = {
+        400 => Faraday::BadRequestError,
+        401 => Faraday::UnauthorizedError,
+        403 => Faraday::ForbiddenError,
+        404 => Faraday::ResourceNotFound,
+        408 => Faraday::RequestTimeoutError,
+        409 => Faraday::ConflictError,
+        422 => Faraday::UnprocessableEntityError,
+        429 => Faraday::TooManyRequestsError
+      }.freeze
       # rubocop:enable Naming/ConstantName
 
+      DEFAULT_OPTIONS = { include_request: true, allowed_statuses: [] }.freeze
+
       def on_complete(env)
+        return if Array(options[:allowed_statuses]).include?(env[:status])
+
         case env[:status]
-        when 400
-          raise Faraday::BadRequestError, response_values(env)
-        when 401
-          raise Faraday::UnauthorizedError, response_values(env)
-        when 403
-          raise Faraday::ForbiddenError, response_values(env)
-        when 404
-          raise Faraday::ResourceNotFound, response_values(env)
+        when *ClientErrorStatusesWithCustomExceptions.keys
+          raise ClientErrorStatusesWithCustomExceptions[env[:status]], response_values(env)
         when 407
           # 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
-          raise Faraday::UnprocessableEntityError, response_values(env)
-        when 429
-          raise Faraday::TooManyRequestsError, response_values(env)
         when ClientErrorStatuses
           raise Faraday::ClientError, response_values(env)
         when ServerErrorStatuses
@@ -58,7 +58,7 @@ module Faraday
 
         # Include the request data by default. If the middleware was explicitly
         # configured to _not_ include request data, then omit it.
-        return response unless options.fetch(:include_request, true)
+        return response unless options[:include_request]
 
         response.merge(
           request: {

data/lib/faraday/utils/headers.rb

@@ -62,10 +62,10 @@ module Faraday
         super(key, val)
       end
 
-      def fetch(key, *args, &block)
+      def fetch(key, ...)
         key = KeyMap[key]
         key = @names.fetch(key.downcase, key)
-        super(key, *args, &block)
+        super(key, ...)
       end
 
       def delete(key)
@@ -77,6 +77,12 @@ module Faraday
         super(key)
       end
 
+      def dig(key, *rest)
+        key = KeyMap[key]
+        key = @names.fetch(key.downcase, key)
+        super(key, *rest)
+      end
+
       def include?(key)
         @names.include? key.downcase
       end

data/lib/faraday/utils.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'base64'
 require 'uri'
 require 'faraday/utils/headers'
 require 'faraday/utils/params_hash'
@@ -26,7 +25,7 @@ module Faraday
       attr_writer :default_space_encoding
     end
 
-    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/.freeze
+    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
 
     def escape(str)
       str.to_s.gsub(ESCAPE_RE) do |match|
@@ -38,7 +37,7 @@ module Faraday
       CGI.unescape str.to_s
     end
 
-    DEFAULT_SEP = /[&;] */n.freeze
+    DEFAULT_SEP = /[&;] */n
 
     # Adapted from Rack
     def parse_query(query)
@@ -54,7 +53,7 @@ module Faraday
     end
 
     def basic_header_from(login, pass)
-      value = Base64.encode64("#{login}:#{pass}")
+      value = ["#{login}:#{pass}"].pack('m') # Base64 encoding
       value.delete!("\n")
       "Basic #{value}"
     end

data/lib/faraday/version.rb

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

data/spec/faraday/connection_spec.rb

@@ -300,14 +300,14 @@ RSpec.describe Faraday::Connection do
       it 'joins url to base when used relative path' do
         conn = Faraday.new(url: url)
         uri = conn.build_exclusive_url('service:search?limit=400')
-        expect(uri.to_s).to eq('http://service.com/service%3Asearch?limit=400')
+        expect(uri.to_s).to eq('http://service.com/service:search?limit=400')
       end
 
       it 'joins url to base when used with path prefix' do
         conn = Faraday.new(url: url)
         conn.path_prefix = '/api'
         uri = conn.build_exclusive_url('service:search?limit=400')
-        expect(uri.to_s).to eq('http://service.com/api/service%3Asearch?limit=400')
+        expect(uri.to_s).to eq('http://service.com/api/service:search?limit=400')
       end
     end
 

data/spec/faraday/error_spec.rb

@@ -24,7 +24,11 @@ RSpec.describe Faraday::Error 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::Error response={:status=>400}>') }
+      if RUBY_VERSION >= '3.4'
+        it { expect(subject.inspect).to eq('#<Faraday::Error response={status: 400}>') }
+      else
+        it { expect(subject.inspect).to eq('#<Faraday::Error response={:status=>400}>') }
+      end
       it { expect(subject.response_status).to eq(400) }
       it { expect(subject.response_headers).to be_nil }
       it { expect(subject.response_body).to be_nil }
@@ -61,7 +65,11 @@ RSpec.describe Faraday::Error 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::Error response={:status=>400}>') }
+      if RUBY_VERSION >= '3.4'
+        it { expect(subject.inspect).to eq('#<Faraday::Error response={status: 400}>') }
+      else
+        it { expect(subject.inspect).to eq('#<Faraday::Error response={:status=>400}>') }
+      end
       it { expect(subject.response_status).to eq(400) }
       it { expect(subject.response_headers).to be_nil }
       it { expect(subject.response_body).to be_nil }

data/spec/faraday/middleware_spec.rb

@@ -67,4 +67,147 @@ RSpec.describe Faraday::Middleware do
       end
     end
   end
+
+  describe '::default_options' do
+    let(:subclass_no_options) { FaradayMiddlewareSubclasses::SubclassNoOptions }
+    let(:subclass_one_option) { FaradayMiddlewareSubclasses::SubclassOneOption }
+    let(:subclass_two_options) { FaradayMiddlewareSubclasses::SubclassTwoOptions }
+
+    def build_conn(resp_middleware)
+      Faraday.new do |c|
+        c.adapter :test do |stub|
+          stub.get('/success') { [200, {}, 'ok'] }
+        end
+        c.response resp_middleware
+      end
+    end
+
+    RSpec.shared_context 'reset @default_options' do
+      before(:each) do
+        FaradayMiddlewareSubclasses::SubclassNoOptions.instance_variable_set(:@default_options, nil)
+        FaradayMiddlewareSubclasses::SubclassOneOption.instance_variable_set(:@default_options, nil)
+        FaradayMiddlewareSubclasses::SubclassTwoOptions.instance_variable_set(:@default_options, nil)
+        Faraday::Middleware.instance_variable_set(:@default_options, nil)
+      end
+    end
+
+    after(:all) do
+      FaradayMiddlewareSubclasses::SubclassNoOptions.instance_variable_set(:@default_options, nil)
+      FaradayMiddlewareSubclasses::SubclassOneOption.instance_variable_set(:@default_options, nil)
+      FaradayMiddlewareSubclasses::SubclassTwoOptions.instance_variable_set(:@default_options, nil)
+      Faraday::Middleware.instance_variable_set(:@default_options, nil)
+    end
+
+    context 'with subclass DEFAULT_OPTIONS defined' do
+      include_context 'reset @default_options'
+
+      context 'and without application options configured' do
+        let(:resp1) { build_conn(:one_option).get('/success') }
+
+        it 'has only subclass defaults' do
+          expect(Faraday::Middleware.default_options).to eq(Faraday::Middleware::DEFAULT_OPTIONS)
+          expect(subclass_no_options.default_options).to eq(subclass_no_options::DEFAULT_OPTIONS)
+          expect(subclass_one_option.default_options).to eq(subclass_one_option::DEFAULT_OPTIONS)
+          expect(subclass_two_options.default_options).to eq(subclass_two_options::DEFAULT_OPTIONS)
+        end
+
+        it { expect(resp1.body).to eq('ok') }
+      end
+
+      context "and with one application's options changed" do
+        let(:resp2) { build_conn(:two_options).get('/success') }
+
+        before(:each) do
+          FaradayMiddlewareSubclasses::SubclassTwoOptions.default_options = { some_option: false }
+        end
+
+        it 'only updates default options of target subclass' do
+          expect(Faraday::Middleware.default_options).to eq(Faraday::Middleware::DEFAULT_OPTIONS)
+          expect(subclass_no_options.default_options).to eq(subclass_no_options::DEFAULT_OPTIONS)
+          expect(subclass_one_option.default_options).to eq(subclass_one_option::DEFAULT_OPTIONS)
+          expect(subclass_two_options.default_options).to eq({ some_option: false, some_other_option: false })
+        end
+
+        it { expect(resp2.body).to eq('ok') }
+      end
+
+      context "and with two applications' options changed" do
+        let(:resp1) { build_conn(:one_option).get('/success') }
+        let(:resp2) { build_conn(:two_options).get('/success') }
+
+        before(:each) do
+          FaradayMiddlewareSubclasses::SubclassOneOption.default_options = { some_other_option: true }
+          FaradayMiddlewareSubclasses::SubclassTwoOptions.default_options = { some_option: false }
+        end
+
+        it 'updates subclasses and parent independent of each other' do
+          expect(Faraday::Middleware.default_options).to eq(Faraday::Middleware::DEFAULT_OPTIONS)
+          expect(subclass_no_options.default_options).to eq(subclass_no_options::DEFAULT_OPTIONS)
+          expect(subclass_one_option.default_options).to eq({ some_other_option: true })
+          expect(subclass_two_options.default_options).to eq({ some_option: false, some_other_option: false })
+        end
+
+        it { expect(resp1.body).to eq('ok') }
+        it { expect(resp2.body).to eq('ok') }
+      end
+    end
+
+    context 'with FARADAY::MIDDLEWARE DEFAULT_OPTIONS and with Subclass DEFAULT_OPTIONS' do
+      before(:each) do
+        stub_const('Faraday::Middleware::DEFAULT_OPTIONS', { its_magic: false })
+      end
+
+      # Must stub Faraday::Middleware::DEFAULT_OPTIONS before resetting default options
+      include_context 'reset @default_options'
+
+      context 'and without application options configured' do
+        let(:resp1) { build_conn(:one_option).get('/success') }
+
+        it 'has only subclass defaults' do
+          expect(Faraday::Middleware.default_options).to eq(Faraday::Middleware::DEFAULT_OPTIONS)
+          expect(FaradayMiddlewareSubclasses::SubclassNoOptions.default_options).to eq({ its_magic: false })
+          expect(FaradayMiddlewareSubclasses::SubclassOneOption.default_options).to eq({ its_magic: false, some_other_option: false })
+          expect(FaradayMiddlewareSubclasses::SubclassTwoOptions.default_options).to eq({ its_magic: false, some_option: true, some_other_option: false })
+        end
+
+        it { expect(resp1.body).to eq('ok') }
+      end
+
+      context "and with two applications' options changed" do
+        let(:resp1) { build_conn(:one_option).get('/success') }
+        let(:resp2) { build_conn(:two_options).get('/success') }
+
+        before(:each) do
+          FaradayMiddlewareSubclasses::SubclassOneOption.default_options = { some_other_option: true }
+          FaradayMiddlewareSubclasses::SubclassTwoOptions.default_options = { some_option: false }
+        end
+
+        it 'updates subclasses and parent independent of each other' do
+          expect(Faraday::Middleware.default_options).to eq(Faraday::Middleware::DEFAULT_OPTIONS)
+          expect(FaradayMiddlewareSubclasses::SubclassNoOptions.default_options).to eq({ its_magic: false })
+          expect(FaradayMiddlewareSubclasses::SubclassOneOption.default_options).to eq({ its_magic: false, some_other_option: true })
+          expect(FaradayMiddlewareSubclasses::SubclassTwoOptions.default_options).to eq({ its_magic: false, some_option: false, some_other_option: false })
+        end
+
+        it { expect(resp1.body).to eq('ok') }
+        it { expect(resp2.body).to eq('ok') }
+      end
+    end
+
+    describe 'default_options input validation' do
+      include_context 'reset @default_options'
+
+      it 'raises error if Faraday::Middleware option does not exist' do
+        expect { Faraday::Middleware.default_options = { something_special: true } }.to raise_error(Faraday::InitializationError) do |e|
+          expect(e.message).to eq('Invalid options provided. Keys not found in Faraday::Middleware::DEFAULT_OPTIONS: something_special')
+        end
+      end
+
+      it 'raises error if subclass option does not exist' do
+        expect { subclass_one_option.default_options = { this_is_a_typo: true } }.to raise_error(Faraday::InitializationError) do |e|
+          expect(e.message).to eq('Invalid options provided. Keys not found in FaradayMiddlewareSubclasses::SubclassOneOption::DEFAULT_OPTIONS: this_is_a_typo')
+        end
+      end
+    end
+  end
 end

data/spec/faraday/params_encoders/nested_spec.rb

@@ -62,7 +62,8 @@ RSpec.describe Faraday::NestedParamsEncoder do
   it 'encodes rack compat' do
     params   = { a: [{ one: '1', two: '2' }, '3', ''] }
     result   = Faraday::Utils.unescape(Faraday::NestedParamsEncoder.encode(params)).split('&')
-    expected = Rack::Utils.build_nested_query(params).split('&')
+    escaped = Rack::Utils.build_nested_query(params)
+    expected = Rack::Utils.unescape(escaped).split('&')
     expect(result).to match_array(expected)
   end
 

data/spec/faraday/response/json_spec.rb

@@ -184,6 +184,23 @@ RSpec.describe Faraday::Response::Json, type: :response do
         response = process(body)
         expect(response.body).to eq(result)
       end
+
+      it 'passes relevant options to JSON parse even when nil responds to :load' do
+        original_allow_message_expectations_on_nil = RSpec::Mocks.configuration.allow_message_expectations_on_nil
+        RSpec::Mocks.configuration.allow_message_expectations_on_nil = true
+        allow(nil).to receive(:respond_to?)
+          .with(:load)
+          .and_return(true)
+
+        expect(JSON).to receive(:parse)
+          .with(body, { symbolize_names: true })
+          .and_return(result)
+
+        response = process(body)
+        expect(response.body).to eq(result)
+      ensure
+        RSpec::Mocks.configuration.allow_message_expectations_on_nil = original_allow_message_expectations_on_nil
+      end
     end
   end
 end

data/spec/faraday/response/logger_spec.rb

@@ -55,6 +55,26 @@ RSpec.describe Faraday::Response::Logger do
     end
   end
 
+  context 'when logger with program name' do
+    let(:logger) { Logger.new(string_io, progname: 'my_best_program') }
+
+    it 'logs with program name' do
+      conn.get '/hello'
+
+      expect(string_io.string).to match('-- my_best_program: request:')
+      expect(string_io.string).to match('-- my_best_program: response:')
+    end
+  end
+
+  context 'when logger without program name' do
+    it 'logs without program name' do
+      conn.get '/hello'
+
+      expect(string_io.string).to match('-- : request:')
+      expect(string_io.string).to match('-- : response:')
+    end
+  end
+
   context 'with default formatter' do
     let(:formatter) { instance_double(Faraday::Logging::Formatter, request: true, response: true, filter: []) }
 

data/spec/faraday/response/raise_error_spec.rb

@@ -194,18 +194,82 @@ RSpec.describe Faraday::Response::RaiseError do
       end
     end
 
-    context 'when the include_request option is set to false' do
-      let(:middleware_options) { { include_request: false } }
-
-      it 'does not include request info in the exception' do
-        expect { perform_request }.to raise_error(Faraday::BadRequestError) do |ex|
-          expect(ex.response.keys).to contain_exactly(
-            :status,
-            :headers,
-            :body
-          )
+    describe 'DEFAULT_OPTION: include_request' do
+      before(:each) do
+        Faraday::Response::RaiseError.instance_variable_set(:@default_options, nil)
+        Faraday::Middleware.instance_variable_set(:@default_options, nil)
+      end
+
+      after(:all) do
+        Faraday::Response::RaiseError.instance_variable_set(:@default_options, nil)
+        Faraday::Middleware.instance_variable_set(:@default_options, nil)
+      end
+
+      context 'when RaiseError DEFAULT_OPTION (include_request: true) is used' do
+        it 'includes request info in the exception' do
+          expect { perform_request }.to raise_error(Faraday::BadRequestError) do |ex|
+            expect(ex.response.keys).to contain_exactly(
+              :status,
+              :headers,
+              :body,
+              :request
+            )
+          end
         end
       end
+
+      context 'when application sets default_options `include_request: false`' do
+        before(:each) do
+          Faraday::Response::RaiseError.default_options = { include_request: false }
+        end
+
+        context 'and when include_request option is omitted' do
+          it 'does not include request info in the exception' do
+            expect { perform_request }.to raise_error(Faraday::BadRequestError) do |ex|
+              expect(ex.response.keys).to contain_exactly(
+                :status,
+                :headers,
+                :body
+              )
+            end
+          end
+        end
+
+        context 'and when include_request option is explicitly set for instance' do
+          let(:middleware_options) { { include_request: true } }
+
+          it 'includes request info in the exception' do
+            expect { perform_request }.to raise_error(Faraday::BadRequestError) do |ex|
+              expect(ex.response.keys).to contain_exactly(
+                :status,
+                :headers,
+                :body,
+                :request
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe 'allowing certain status codes' do
+    let(:conn) do
+      Faraday.new do |b|
+        b.response :raise_error, allowed_statuses: [404]
+        b.adapter :test do |stub|
+          stub.get('bad-request') { [400, { 'X-Reason' => 'because' }, 'keep looking'] }
+          stub.get('not-found') { [404, { 'X-Reason' => 'because' }, 'keep looking'] }
+        end
+      end
+    end
+
+    it 'raises an error for status codes that are not explicitly allowed' do
+      expect { conn.get('bad-request') }.to raise_error(Faraday::BadRequestError)
+    end
+
+    it 'does not raise an error for allowed status codes' do
+      expect { conn.get('not-found') }.not_to raise_error
     end
   end
 end

data/spec/faraday/utils/headers_spec.rb

@@ -56,6 +56,15 @@ RSpec.describe Faraday::Utils::Headers do
     it { expect(subject.delete('content-type')).to be_nil }
   end
 
+  describe '#dig' do
+    before { subject['Content-Type'] = 'application/json' }
+
+    it { expect(subject&.dig('Content-Type')).to eq('application/json') }
+    it { expect(subject&.dig('CONTENT-TYPE')).to eq('application/json') }
+    it { expect(subject&.dig(:content_type)).to eq('application/json') }
+    it { expect(subject&.dig('invalid')).to be_nil }
+  end
+
   describe '#parse' do
     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" }

data/spec/faraday/utils_spec.rb

@@ -103,7 +103,8 @@ RSpec.describe Faraday::Utils do
           version: '2',
           min_version: nil,
           max_version: nil,
-          verify_hostname: nil
+          verify_hostname: nil,
+          ciphers: nil
         }
       end
 

data/spec/faraday_spec.rb

@@ -19,7 +19,9 @@ RSpec.describe Faraday do
 
     it 'uses method_missing on Faraday if there is no proxyable method' do
       expected_message =
-        if RUBY_VERSION >= '3.3'
+        if RUBY_VERSION >= '3.4'
+          "undefined method 'this_method_does_not_exist' for module Faraday"
+        elsif RUBY_VERSION >= '3.3'
           "undefined method `this_method_does_not_exist' for module Faraday"
         else
           "undefined method `this_method_does_not_exist' for Faraday:Module"

data/spec/spec_helper.rb

@@ -29,14 +29,15 @@ SimpleCov.start do
   minimum_coverage_by_file 26
 end
 
-# Ensure all /lib files are loaded
-# so they will be included in the test coverage report.
-Dir['./lib/**/*.rb'].sort.each { |file| require file }
-
 require 'faraday'
 require 'pry'
 
-Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
+# Ensure all /lib files are loaded
+# so they will be included in the test coverage report.
+Dir['./lib/**/*.rb'].each { |file| require file }
+
+# Load all Rspec support files
+Dir['./spec/support/**/*.rb'].each { |file| require file }
 
 RSpec.configure do |config|
   # rspec-expectations config goes here. You can use an alternate

data/spec/support/faraday_middleware_subclasses.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module FaradayMiddlewareSubclasses
+  class SubclassNoOptions < Faraday::Middleware
+  end
+
+  class SubclassOneOption < Faraday::Middleware
+    DEFAULT_OPTIONS = { some_other_option: false }.freeze
+  end
+
+  class SubclassTwoOptions < Faraday::Middleware
+    DEFAULT_OPTIONS = { some_option: true, some_other_option: false }.freeze
+  end
+end
+
+Faraday::Response.register_middleware(no_options: FaradayMiddlewareSubclasses::SubclassNoOptions)
+Faraday::Response.register_middleware(one_option: FaradayMiddlewareSubclasses::SubclassOneOption)
+Faraday::Response.register_middleware(two_options: FaradayMiddlewareSubclasses::SubclassTwoOptions)

metadata

@@ -1,66 +1,66 @@
 --- !ruby/object:Gem::Specification
 name: faraday
 version: !ruby/object:Gem::Version
-  version: 2.8.1
+  version: 2.12.2
 platform: ruby
 authors:
 - "@technoweenie"
 - "@iMacTia"
 - "@olleolleolle"
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-21 00:00:00.000000000 Z
+date: 2024-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: base64
+  name: faraday-net_http
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.5'
 - !ruby/object:Gem::Dependency
-  name: faraday-net_http
+  name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: ruby2_keywords
+  name: logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.4
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.4
-description: 
+        version: '0'
+description:
 email: technoweenie@gmail.com
 executables: []
 extensions: []
@@ -135,6 +135,7 @@ files:
 - spec/spec_helper.rb
 - spec/support/disabling_stub.rb
 - spec/support/fake_safe_buffer.rb
+- spec/support/faraday_middleware_subclasses.rb
 - spec/support/helper_methods.rb
 - spec/support/shared_examples/adapter.rb
 - spec/support/shared_examples/params_encoder.rb
@@ -145,10 +146,11 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://lostisland.github.io/faraday
-  changelog_uri: https://github.com/lostisland/faraday/releases/tag/v2.8.1
+  changelog_uri: https://github.com/lostisland/faraday/releases/tag/v2.12.2
   source_code_uri: https://github.com/lostisland/faraday
   bug_tracker_uri: https://github.com/lostisland/faraday/issues
-post_install_message: 
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -157,15 +159,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: HTTP/REST API client library.
 test_files: []