faraday 1.10.4 → 2.13.1

data/lib/faraday/options/ssl_options.rb

@@ -1,51 +1,63 @@
 # frozen_string_literal: true
 
 module Faraday
-  # SSL-related options.
-  #
-  # @!attribute verify
-  #   @return [Boolean] whether to verify SSL certificates or not
-  #
-  # @!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, :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 hostname
+  #   #   @return [String] Server hostname used for SNI (see https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL/SSLSocket.html#method-i-hostname-3D)
+  #   #
+  #   # @!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)
+  #   #
+  #   # @!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, :hostname,
+                           :ca_file, :ca_path, :verify_mode,
+                           :cert_store, :client_cert, :client_key,
+                           :certificate, :private_key, :verify_depth,
+                           :version, :min_version, :max_version, :ciphers) do
     # @return [Boolean] true if should verify
     def verify?
       verify != false
@@ -55,5 +67,10 @@ module Faraday
     def disable?
       !verify?
     end
+
+    # @return [Boolean] true if should verify_hostname
+    def verify_hostname?
+      verify_hostname != false
+    end
   end
 end

data/lib/faraday/options.rb

@@ -30,7 +30,7 @@ module Faraday
           new_value = value
         end
 
-        send("#{key}=", new_value) unless new_value.nil?
+        send(:"#{key}=", new_value) unless new_value.nil?
       end
       self
     end
@@ -38,7 +38,7 @@ module Faraday
     # Public
     def delete(key)
       value = send(key)
-      send("#{key}=", nil)
+      send(:"#{key}=", nil)
       value
     end
 
@@ -57,7 +57,7 @@ module Faraday
                     else
                       other_value
                     end
-        send("#{key}=", new_value) unless new_value.nil?
+        send(:"#{key}=", new_value) unless new_value.nil?
       end
       self
     end
@@ -104,7 +104,7 @@ module Faraday
 
     # Public
     def each_key(&block)
-      return to_enum(:each_key) unless block_given?
+      return to_enum(:each_key) unless block
 
       keys.each(&block)
     end
@@ -118,7 +118,7 @@ module Faraday
 
     # Public
     def each_value(&block)
-      return to_enum(:each_value) unless block_given?
+      return to_enum(:each_value) unless block
 
       values.each(&block)
     end
@@ -168,12 +168,13 @@ module Faraday
     end
 
     def self.memoized(key, &block)
-      unless block_given?
+      unless block
         raise ArgumentError, '#memoized must be called with a block'
       end
 
       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/rack_builder.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'ruby2_keywords'
 require 'faraday/adapter_registry'
 
 module Faraday
@@ -8,7 +7,7 @@ module Faraday
   # middleware stack (heavily inspired by Rack).
   #
   # @example
-  #   Faraday::Connection.new(url: 'http://sushi.com') do |builder|
+  #   Faraday::Connection.new(url: 'http://httpbingo.org') do |builder|
   #     builder.request  :url_encoded  # Faraday::Request::UrlEncoded
   #     builder.adapter  :net_http     # Faraday::Adapter::NetHttp
   #   end
@@ -28,10 +27,11 @@ module Faraday
 
       attr_reader :name
 
-      ruby2_keywords def initialize(klass, *args, &block)
+      def initialize(klass, *args, **kwargs, &block)
         @name = klass.to_s
         REGISTRY.set(klass) if klass.respond_to?(:name)
         @args = args
+        @kwargs = kwargs
         @block = block
       end
 
@@ -54,27 +54,26 @@ module Faraday
       end
 
       def build(app = nil)
-        klass.new(app, *@args, &@block)
+        klass.new(app, *@args, **@kwargs, &@block)
       end
     end
 
-    def initialize(handlers = [], adapter = nil, &block)
-      @adapter = adapter
-      @handlers = handlers
-      if block_given?
-        build(&block)
-      elsif @handlers.empty?
-        # default stack, if nothing else is configured
-        request :url_encoded
-        self.adapter Faraday.default_adapter
-      end
+    def initialize(&block)
+      @adapter = nil
+      @handlers = []
+      build(&block)
+    end
+
+    def initialize_dup(original)
+      super
+      @adapter = original.adapter
+      @handlers = original.handlers.dup
     end
 
-    def build(options = {})
+    def build
       raise_if_locked
-      @handlers.clear unless options[:keep]
-      yield(self) if block_given?
-      adapter(Faraday.default_adapter) unless @adapter
+      block_given? ? yield(self) : request(:url_encoded)
+      adapter(Faraday.default_adapter, **Faraday.default_adapter_options) unless @adapter
     end
 
     def [](idx)
@@ -90,52 +89,52 @@ 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)
-      return @adapter if klass == NO_ARGUMENT
+    def adapter(klass = NO_ARGUMENT, *args, **kwargs, &block)
+      return @adapter if klass == NO_ARGUMENT || klass.nil?
 
       klass = Faraday::Adapter.lookup_middleware(klass) if klass.is_a?(Symbol)
-      @adapter = self.class::Handler.new(klass, *args, &block)
+      @adapter = self.class::Handler.new(klass, *args, **kwargs, &block)
     end
 
     ## 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)
@@ -164,6 +163,7 @@ module Faraday
     def app
       @app ||= begin
         lock!
+        ensure_adapter!
         to_app
       end
     end
@@ -182,10 +182,6 @@ module Faraday
         @adapter == other.adapter
     end
 
-    def dup
-      self.class.new(@handlers.dup, @adapter.dup)
-    end
-
     # ENV Keys
     # :http_method - a symbolized request HTTP method (:get, :post)
     # :body   - the request body that will eventually be converted to a string.
@@ -216,6 +212,9 @@ module Faraday
     private
 
     LOCK_ERR = "can't modify middleware stack after making a request"
+    MISSING_ADAPTER_ERROR = "An attempt to run a request with a Faraday::Connection without adapter has been made.\n" \
+                            "Please set Faraday.default_adapter or provide one when initializing the connection.\n" \
+                            'For more info, check https://lostisland.github.io/faraday/usage/.'
 
     def raise_if_locked
       raise StackLocked, LOCK_ERR if locked?
@@ -227,6 +226,10 @@ module Faraday
       raise 'Adapter should be set using the `adapter` method, not `use`'
     end
 
+    def ensure_adapter!
+      raise MISSING_ADAPTER_ERROR unless @adapter
+    end
+
     def adapter_set?
       !@adapter.nil?
     end
@@ -235,8 +238,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/authorization.rb

@@ -1,53 +1,21 @@
 # frozen_string_literal: true
 
-require 'base64'
-
 module Faraday
   class Request
     # Request middleware for the Authorization HTTP header
     class Authorization < Faraday::Middleware
-      unless defined?(::Faraday::Request::Authorization::KEY)
-        KEY = 'Authorization'
-      end
-
-      # @param type [String, Symbol]
-      # @param token [String, Symbol, Hash]
-      # @return [String] a header value
-      def self.header(type, token)
-        case token
-        when String, Symbol, Proc
-          token = token.call if token.is_a?(Proc)
-          "#{type} #{token}"
-        when Hash
-          build_hash(type.to_s, token)
-        else
-          raise ArgumentError,
-                "Can't build an Authorization #{type}" \
-                  "header from #{token.inspect}"
-        end
-      end
-
-      # @param type [String]
-      # @param hash [Hash]
-      # @return [String] type followed by comma-separated key=value pairs
-      # @api private
-      def self.build_hash(type, hash)
-        comma = ', '
-        values = []
-        hash.each do |key, value|
-          value = value.call if value.is_a?(Proc)
-          values << "#{key}=#{value.to_s.inspect}"
-        end
-        "#{type} #{values * comma}"
-      end
+      KEY = 'Authorization'
 
       # @param app [#call]
       # @param type [String, Symbol] Type of Authorization
-      # @param param [String, Symbol, Hash, Proc] parameter to build the Authorization header.
-      #   This value can be a proc, in which case it will be invoked on each request.
-      def initialize(app, type, param)
+      # @param params [Array<String, Proc, #call>] parameters to build the Authorization header.
+      #   If the type is `:basic`, then these can be a login and password pair.
+      #   Otherwise, a single value is expected that will be appended after the type.
+      #   This value can be a proc or an object responding to `.call`, in which case
+      #   it will be invoked on each request.
+      def initialize(app, type, *params)
         @type = type
-        @param = param
+        @params = params
         super(app)
       end
 
@@ -55,8 +23,32 @@ module Faraday
       def on_request(env)
         return if env.request_headers[KEY]
 
-        env.request_headers[KEY] = self.class.header(@type, @param)
+        env.request_headers[KEY] = header_from(@type, env, *@params)
+      end
+
+      private
+
+      # @param type [String, Symbol]
+      # @param env [Faraday::Env]
+      # @param params [Array]
+      # @return [String] a header value
+      def header_from(type, env, *params)
+        if type.to_s.casecmp('basic').zero? && params.size == 2
+          Utils.basic_header_from(*params)
+        elsif params.size != 1
+          raise ArgumentError, "Unexpected params received (got #{params.size} instead of 1)"
+        else
+          value = params.first
+          if (value.is_a?(Proc) && value.arity == 1) || (value.respond_to?(:call) && value.method(:call).arity == 1)
+            value = value.call(env)
+          elsif value.is_a?(Proc) || value.respond_to?(:call)
+            value = value.call
+          end
+          "#{type} #{value}"
+        end
       end
     end
   end
 end
+
+Faraday::Request.register_middleware(authorization: Faraday::Request::Authorization)

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
@@ -52,3 +54,5 @@ module Faraday
     end
   end
 end
+
+Faraday::Request.register_middleware(instrumentation: Faraday::Request::Instrumentation)

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|
@@ -24,7 +24,13 @@ module Faraday
       private
 
       def encode(data)
-        ::JSON.generate(data)
+        if options[:encoder].is_a?(Array) && options[:encoder].size >= 2
+          options[:encoder][0].public_send(options[:encoder][1], data)
+        elsif options[:encoder].respond_to?(:dump)
+          options[:encoder].dump(data)
+        else
+          ::JSON.generate(data)
+        end
       end
 
       def match_content_type(env)
@@ -40,7 +46,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/url_encoded.rb

@@ -31,7 +31,9 @@ module Faraday
         return unless process_request?(env)
 
         env.request_headers[CONTENT_TYPE] ||= self.class.mime_type
-        yield(env.body) unless env.body.respond_to?(:to_str)
+        return if env.body.respond_to?(:to_str) || env.body.respond_to?(:read)
+
+        yield(env.body)
       end
 
       # @param env [Faraday::Env]
@@ -54,3 +56,5 @@ module Faraday
     end
   end
 end
+
+Faraday::Request.register_middleware(url_encoded: Faraday::Request::UrlEncoded)

data/lib/faraday/request.rb

@@ -21,31 +21,16 @@ module Faraday
   # @!attribute headers
   #   @return [Faraday::Utils::Headers] headers
   # @!attribute body
-  #   @return [Hash] body
+  #   @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
 
-    register_middleware File.expand_path('request', __dir__),
-                        url_encoded: [:UrlEncoded, 'url_encoded'],
-                        authorization: [:Authorization, 'authorization'],
-                        basic_auth: [
-                          :BasicAuthentication,
-                          'basic_authentication'
-                        ],
-                        token_auth: [
-                          :TokenAuthentication,
-                          'token_authentication'
-                        ],
-                        instrumentation: [:Instrumentation, 'instrumentation'],
-                        json: [:Json, 'json']
+    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
@@ -57,13 +42,7 @@ module Faraday
       end
     end
 
-    def method
-      http_method
-    end
-
-    extend Faraday::Deprecate
-    deprecate :method, :http_method, '2.0'
-
+    remove_method :params=
     # Replace params, preserving the existing hash type.
     #
     # @param hash [Hash] new params
@@ -71,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
@@ -82,7 +62,7 @@ module Faraday
       if headers
         headers.replace hash
       else
-        super
+        member_set(:headers, hash)
       end
     end
 
@@ -152,3 +132,8 @@ module Faraday
     end
   end
 end
+
+require 'faraday/request/authorization'
+require 'faraday/request/instrumentation'
+require 'faraday/request/json'
+require 'faraday/request/url_encoded'

data/lib/faraday/response/json.rb

@@ -6,11 +6,13 @@ module Faraday
   class Response
     # Parse response bodies as JSON.
     class Json < Middleware
-      def initialize(app = nil, options = {})
+      def initialize(app = nil, parser_options: nil, content_type: /\bjson$/, preserve_raw: false)
         super(app)
-        @parser_options = options[:parser_options]
-        @content_types = Array(options[:content_type] || /\bjson$/)
-        @preserve_raw = options[:preserve_raw]
+        @parser_options = parser_options
+        @content_types = Array(content_type)
+        @preserve_raw = preserve_raw
+
+        process_parser_options
       end
 
       def on_complete(env)
@@ -27,7 +29,11 @@ module Faraday
       end
 
       def parse(body)
-        ::JSON.parse(body, @parser_options || {}) unless body.strip.empty?
+        return if body.strip.empty?
+
+        decoder, method_name = @decoder_options
+
+        decoder.public_send(method_name, body, @parser_options || {})
       end
 
       def parse_response?(env)
@@ -47,6 +53,20 @@ module Faraday
         type = type.split(';', 2).first if type.index(';')
         type
       end
+
+      def process_parser_options
+        @decoder_options = @parser_options&.delete(:decoder)
+
+        @decoder_options =
+          if @decoder_options.is_a?(Array) && @decoder_options.size >= 2
+            @decoder_options.slice(0, 2)
+          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]
+          end
+      end
     end
   end
 end