faraday 2.9.0 → 2.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8daafc733cd0bf7b27c3ec39dcca14da1dd4ad6bf28d72e96c6c7c214d4992e1
-  data.tar.gz: 8b5ce62606f14fd89a64adbe24099ef53067c98444419bfe58b0b986501dae5d
+  metadata.gz: 7ceee5efaef78f039d68da91b621e8ae3723f6663fc11667709845b08358bb53
+  data.tar.gz: 430834e5a0cecbc636eecf485eae7061447126e93b5de5f27ad2d7a938a36459
 SHA512:
-  metadata.gz: 980d8a35587b2ead1383ac7cd7f8649c193a6d9685c0d69c97f9be4937a18deeef7858d50d2c20649774ac97293d0dc6d4b51049cb40e4f4422132d0c58f372b
-  data.tar.gz: a02dbd0bd5d2670728f39f2a673b385abda43d7449cb204bff10878e562a179c2de595665096dbc24c4d183990a0417c7386159afb952955806c0ea3321bf5fe
+  metadata.gz: 9664749d4913670b04ed973554bf2893fb17f63eb5117a86a36d083615421cbca07212f4797e2869f1ec86905e428f9de89c913c142464bdb6764316ad4edeae
+  data.tar.gz: c2d7c4259cfceb8f862e4ea45f8bf7f8f3a7c1896478b882f349539270aac8161fb079b29b0f4fa29b57539a395e9a9d7f62f65ecd76433746373dc0243200b4

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/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

@@ -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/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/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

@@ -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/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

@@ -10,6 +10,8 @@ module Faraday
       ServerErrorStatuses = (500...600)
       # rubocop:enable Naming/ConstantName
 
+      DEFAULT_OPTIONS = { include_request: true }.freeze
+
       def on_complete(env)
         case env[:status]
         when 400
@@ -58,7 +60,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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Faraday
-  VERSION = '2.9.0'
+  VERSION = '2.11.0'
 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/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/raise_error_spec.rb

@@ -194,16 +194,60 @@ 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

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/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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: faraday
 version: !ruby/object:Gem::Version
-  version: 2.9.0
+  version: 2.11.0
 platform: ruby
 authors:
 - "@technoweenie"
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-09 00:00:00.000000000 Z
+date: 2024-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday-net_http
@@ -21,7 +21,7 @@ dependencies:
         version: '2.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -31,7 +31,21 @@ dependencies:
         version: '2.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email: technoweenie@gmail.com
 executables: []
@@ -107,6 +121,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
@@ -117,9 +132,10 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://lostisland.github.io/faraday
-  changelog_uri: https://github.com/lostisland/faraday/releases/tag/v2.9.0
+  changelog_uri: https://github.com/lostisland/faraday/releases/tag/v2.11.0
   source_code_uri: https://github.com/lostisland/faraday
   bug_tracker_uri: https://github.com/lostisland/faraday/issues
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -136,7 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.11
 signing_key: 
 specification_version: 4
 summary: HTTP/REST API client library.