httpx 1.5.1 → 1.6.1

data/lib/httpx/options.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "socket"
-
 module HTTPX
   # Contains a set of options which are passed and shared across from session to its requests or
   # responses.
@@ -15,70 +13,16 @@ module HTTPX
     CONNECT_TIMEOUT = READ_TIMEOUT = WRITE_TIMEOUT = 60
     REQUEST_TIMEOUT = OPERATION_TIMEOUT = nil
 
-    # https://github.com/ruby/resolv/blob/095f1c003f6073730500f02acbdbc55f83d70987/lib/resolv.rb#L408
-    ip_address_families = begin
-      list = Socket.ip_address_list
-      if list.any? { |a| a.ipv6? && !a.ipv6_loopback? && !a.ipv6_linklocal? && !a.ipv6_unique_local? }
-        [Socket::AF_INET6, Socket::AF_INET]
-      else
-        [Socket::AF_INET]
-      end
-    rescue NotImplementedError
-      [Socket::AF_INET]
-    end.freeze
+    @options_names = []
 
-    SET_TEMPORARY_NAME = ->(mod, pl = nil) do
-      if mod.respond_to?(:set_temporary_name) # ruby 3.4 only
-        name = mod.name || "#{mod.superclass.name}(plugin)"
-        name = "#{name}/#{pl}" if pl
-        mod.set_temporary_name(name)
-      end
-    end
+    class << self
+      attr_reader :options_names
 
-    DEFAULT_OPTIONS = {
-      :max_requests => Float::INFINITY,
-      :debug => nil,
-      :debug_level => (ENV["HTTPX_DEBUG"] || 1).to_i,
-      :debug_redact => ENV.key?("HTTPX_DEBUG_REDACT"),
-      :ssl => EMPTY_HASH,
-      :http2_settings => { settings_enable_push: 0 }.freeze,
-      :fallback_protocol => "http/1.1",
-      :supported_compression_formats => %w[gzip deflate],
-      :decompress_response_body => true,
-      :compress_request_body => true,
-      :timeout => {
-        connect_timeout: CONNECT_TIMEOUT,
-        settings_timeout: SETTINGS_TIMEOUT,
-        close_handshake_timeout: CLOSE_HANDSHAKE_TIMEOUT,
-        operation_timeout: OPERATION_TIMEOUT,
-        keep_alive_timeout: KEEP_ALIVE_TIMEOUT,
-        read_timeout: READ_TIMEOUT,
-        write_timeout: WRITE_TIMEOUT,
-        request_timeout: REQUEST_TIMEOUT,
-      },
-      :headers_class => Class.new(Headers, &SET_TEMPORARY_NAME),
-      :headers => {},
-      :window_size => WINDOW_SIZE,
-      :buffer_size => BUFFER_SIZE,
-      :body_threshold_size => MAX_BODY_THRESHOLD_SIZE,
-      :request_class => Class.new(Request, &SET_TEMPORARY_NAME),
-      :response_class => Class.new(Response, &SET_TEMPORARY_NAME),
-      :request_body_class => Class.new(Request::Body, &SET_TEMPORARY_NAME),
-      :response_body_class => Class.new(Response::Body, &SET_TEMPORARY_NAME),
-      :pool_class => Class.new(Pool, &SET_TEMPORARY_NAME),
-      :connection_class => Class.new(Connection, &SET_TEMPORARY_NAME),
-      :options_class => Class.new(self, &SET_TEMPORARY_NAME),
-      :transport => nil,
-      :addresses => nil,
-      :persistent => false,
-      :resolver_class => (ENV["HTTPX_RESOLVER"] || :native).to_sym,
-      :resolver_options => { cache: true }.freeze,
-      :pool_options => EMPTY_HASH,
-      :ip_families => ip_address_families,
-      :close_on_fork => false,
-    }.freeze
+      def inherited(klass)
+        super
+        klass.instance_variable_set(:@options_names, @options_names.dup)
+      end
 
-    class << self
       def new(options = {})
         # let enhanced options go through
         return options if self == Options && options.class < self
@@ -87,14 +31,34 @@ module HTTPX
         super
       end
 
+      def freeze
+        @options_names.freeze
+        super
+      end
+
       def method_added(meth)
         super
 
         return unless meth =~ /^option_(.+)$/
 
-        optname = Regexp.last_match(1).to_sym
+        optname = Regexp.last_match(1)
+
+        if optname =~ /^(.+[^_])_+with/
+          # ignore alias method chain generated methods.
+          # this is the case with RBS runtime tests.
+          # it relies on the "_with/_without" separator, which is the most used convention,
+          # however it shouldn't be used in practice in httpx given the plugin architecture
+          # as the main extension API.
+          orig_name = Regexp.last_match(1)
+
+          return if @options_names.include?(orig_name.to_sym)
+        end
+
+        optname = optname.to_sym
 
         attr_reader(optname)
+
+        @options_names << optname unless @options_names.include?(optname)
       end
     end
 
@@ -103,7 +67,7 @@ module HTTPX
     # :debug :: an object which log messages are written to (must respond to <tt><<</tt>)
     # :debug_level :: the log level of messages (can be 1, 2, or 3).
     # :debug_redact :: whether header/body payload should be redacted (defaults to <tt>false</tt>).
-    # :ssl :: a hash of options which can be set as params of OpenSSL::SSL::SSLContext (see HTTPX::IO::SSL)
+    # :ssl :: a hash of options which can be set as params of OpenSSL::SSL::SSLContext (see HTTPX::SSL)
     # :http2_settings :: a hash of options to be passed to a HTTP2::Connection (ex: <tt>{ max_concurrent_streams: 2 }</tt>)
     # :fallback_protocol :: version of HTTP protocol to use by default in the absence of protocol negotiation
     #                       like ALPN (defaults to <tt>"http/1.1"</tt>)
@@ -123,6 +87,11 @@ module HTTPX
     # :request_body_class :: class used to instantiate a request body
     # :response_body_class :: class used to instantiate a response body
     # :connection_class :: class used to instantiate connections
+    # :http1_class :: class used to manage HTTP1 sessions
+    # :http2_class :: class used to imanage HTTP2 sessions
+    # :resolver_native_class :: class used to resolve names using pure ruby DNS implementation
+    # :resolver_system_class :: class used to resolve names using system-based (getaddrinfo) name resolution
+    # :resolver_https_class :: class used to resolve names using DoH
     # :pool_class :: class used to instantiate the session connection pool
     # :options_class :: class used to instantiate options
     # :transport :: type of transport to use (set to "unix" for UNIX sockets)
@@ -143,99 +112,54 @@ module HTTPX
     #                   it only works if the session is persistent (and ruby 3.1 or higher is used).
     #
     # This list of options are enhanced with each loaded plugin, see the plugin docs for details.
-    def initialize(options = {})
-      do_initialize(options)
-      freeze
-    end
-
-    def freeze
-      @origin.freeze
-      @base_path.freeze
-      @timeout.freeze
-      @headers.freeze
-      @addresses.freeze
-      @supported_compression_formats.freeze
-      @ssl.freeze
-      @http2_settings.freeze
-      @pool_options.freeze
-      @resolver_options.freeze
-      @ip_families.freeze
-      super
-    end
+    def initialize(options = EMPTY_HASH)
+      options_names = self.class.options_names
 
-    def option_origin(value)
-      URI(value)
-    end
-
-    def option_base_path(value)
-      String(value)
-    end
-
-    def option_headers(value)
-      headers_class.new(value)
-    end
-
-    def option_timeout(value)
-      Hash[value]
-    end
+      defaults =
+        case options
+        when Options
+          unknown_options = options.class.options_names - options_names
 
-    def option_supported_compression_formats(value)
-      Array(value).map(&:to_s)
-    end
+          raise Error, "unknown option: #{unknown_options.first}" unless unknown_options.empty?
 
-    def option_transport(value)
-      transport = value.to_s
-      raise TypeError, "#{transport} is an unsupported transport type" unless %w[unix].include?(transport)
+          DEFAULT_OPTIONS.merge(options)
+        else
+          options.each_key do |k|
+            raise Error, "unknown option: #{k}" unless options_names.include?(k)
+          end
 
-      transport
-    end
+          options.empty? ? DEFAULT_OPTIONS : DEFAULT_OPTIONS.merge(options)
+        end
 
-    def option_addresses(value)
-      Array(value)
-    end
+      options_names.each do |k|
+        v = defaults[k]
 
-    def option_ip_families(value)
-      Array(value)
-    end
+        if v.nil?
+          instance_variable_set(:"@#{k}", v)
 
-    # number options
-    %i[
-      max_concurrent_requests max_requests window_size buffer_size
-      body_threshold_size debug_level
-    ].each do |option|
-      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
-        # converts +v+ into an Integer before setting the +#{option}+ option.
-        def option_#{option}(value)                                             # def option_max_requests(v)
-          value = Integer(value) unless value.infinite?
-          raise TypeError, ":#{option} must be positive" unless value.positive? # raise TypeError, ":max_requests must be positive" unless value.positive?
-
-          value
+          next
         end
-      OUT
-    end
 
-    # hashable options
-    %i[ssl http2_settings resolver_options pool_options].each do |option|
-      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
-        # converts +v+ into an Hash before setting the +#{option}+ option.
-        def option_#{option}(value) # def option_ssl(v)
-          Hash[value]
-        end
-      OUT
+        value = __send__(:"option_#{k}", v)
+        instance_variable_set(:"@#{k}", value)
+      end
+
+      freeze
     end
 
-    %i[
-      request_class response_class headers_class request_body_class
-      response_body_class connection_class options_class
-      pool_class
-      io fallback_protocol debug debug_redact resolver_class
-      compress_request_body decompress_response_body
-      persistent close_on_fork
-    ].each do |method_name|
-      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
-        # sets +v+ as the value of the +#{method_name}+ option
-        def option_#{method_name}(v); v; end # def option_smth(v); v; end
-      OUT
+    def freeze
+      self.class.options_names.each do |ivar|
+        # avoid freezing debug option, as when it's set, it's usually an
+        # object which cannot be frozen, like stderr or stdout. It's a
+        # documented exception then, and still does not defeat the purpose
+        # here, which is to make option objects shareable across ractors,
+        # and in most cases debug should be nil, or one of the objects
+        # which will eventually be shareable, like STDOUT or STDERR.
+        next if ivar == :debug
+
+        instance_variable_get(:"@#{ivar}").freeze
+      end
+      super
     end
 
     REQUEST_BODY_IVARS = %i[@headers].freeze
@@ -262,11 +186,12 @@ module HTTPX
     def merge(other)
       ivar_map = nil
       other_ivars = case other
-                    when Hash
+                    when Options
+                      other.instance_variables
+                    else
+                      other = Hash[other] unless other.is_a?(Hash)
                       ivar_map = other.keys.to_h { |k| [:"@#{k}", k] }
                       ivar_map.keys
-                    else
-                      other.instance_variables
       end
 
       return self if other_ivars.empty?
@@ -297,70 +222,177 @@ module HTTPX
 
     def to_hash
       instance_variables.each_with_object({}) do |ivar, hs|
-        hs[ivar[1..-1].to_sym] = instance_variable_get(ivar)
+        val = instance_variable_get(ivar)
+
+        next if val.nil?
+
+        hs[ivar[1..-1].to_sym] = val
       end
     end
 
     def extend_with_plugin_classes(pl)
+      # extend request class
       if defined?(pl::RequestMethods) || defined?(pl::RequestClassMethods)
         @request_class = @request_class.dup
         SET_TEMPORARY_NAME[@request_class, pl]
         @request_class.__send__(:include, pl::RequestMethods) if defined?(pl::RequestMethods)
         @request_class.extend(pl::RequestClassMethods) if defined?(pl::RequestClassMethods)
       end
+      # extend response class
       if defined?(pl::ResponseMethods) || defined?(pl::ResponseClassMethods)
         @response_class = @response_class.dup
         SET_TEMPORARY_NAME[@response_class, pl]
         @response_class.__send__(:include, pl::ResponseMethods) if defined?(pl::ResponseMethods)
         @response_class.extend(pl::ResponseClassMethods) if defined?(pl::ResponseClassMethods)
       end
+      # extend headers class
       if defined?(pl::HeadersMethods) || defined?(pl::HeadersClassMethods)
         @headers_class = @headers_class.dup
         SET_TEMPORARY_NAME[@headers_class, pl]
         @headers_class.__send__(:include, pl::HeadersMethods) if defined?(pl::HeadersMethods)
         @headers_class.extend(pl::HeadersClassMethods) if defined?(pl::HeadersClassMethods)
       end
+      # extend request body class
       if defined?(pl::RequestBodyMethods) || defined?(pl::RequestBodyClassMethods)
         @request_body_class = @request_body_class.dup
         SET_TEMPORARY_NAME[@request_body_class, pl]
         @request_body_class.__send__(:include, pl::RequestBodyMethods) if defined?(pl::RequestBodyMethods)
         @request_body_class.extend(pl::RequestBodyClassMethods) if defined?(pl::RequestBodyClassMethods)
       end
+      # extend response body class
       if defined?(pl::ResponseBodyMethods) || defined?(pl::ResponseBodyClassMethods)
         @response_body_class = @response_body_class.dup
         SET_TEMPORARY_NAME[@response_body_class, pl]
         @response_body_class.__send__(:include, pl::ResponseBodyMethods) if defined?(pl::ResponseBodyMethods)
         @response_body_class.extend(pl::ResponseBodyClassMethods) if defined?(pl::ResponseBodyClassMethods)
       end
+      # extend connection pool class
       if defined?(pl::PoolMethods)
         @pool_class = @pool_class.dup
         SET_TEMPORARY_NAME[@pool_class, pl]
         @pool_class.__send__(:include, pl::PoolMethods)
       end
+      # extend connection class
       if defined?(pl::ConnectionMethods)
         @connection_class = @connection_class.dup
         SET_TEMPORARY_NAME[@connection_class, pl]
         @connection_class.__send__(:include, pl::ConnectionMethods)
       end
+      # extend http1 class
+      if defined?(pl::HTTP1Methods)
+        @http1_class = @http1_class.dup
+        SET_TEMPORARY_NAME[@http1_class, pl]
+        @http1_class.__send__(:include, pl::HTTP1Methods)
+      end
+      # extend http2 class
+      if defined?(pl::HTTP2Methods)
+        @http2_class = @http2_class.dup
+        SET_TEMPORARY_NAME[@http2_class, pl]
+        @http2_class.__send__(:include, pl::HTTP2Methods)
+      end
+      # extend native resolver class
+      if defined?(pl::ResolverNativeMethods)
+        @resolver_native_class = @resolver_native_class.dup
+        SET_TEMPORARY_NAME[@resolver_native_class, pl]
+        @resolver_native_class.__send__(:include, pl::ResolverNativeMethods)
+      end
+      # extend system resolver class
+      if defined?(pl::ResolverSystemMethods)
+        @resolver_system_class = @resolver_system_class.dup
+        SET_TEMPORARY_NAME[@resolver_system_class, pl]
+        @resolver_system_class.__send__(:include, pl::ResolverSystemMethods)
+      end
+      # extend https resolver class
+      if defined?(pl::ResolverHTTPSMethods)
+        @resolver_https_class = @resolver_https_class.dup
+        SET_TEMPORARY_NAME[@resolver_https_class, pl]
+        @resolver_https_class.__send__(:include, pl::ResolverHTTPSMethods)
+      end
+
       return unless defined?(pl::OptionsMethods)
 
+      # extend option class
+      # works around lack of initialize_dup callback
       @options_class = @options_class.dup
+      # (self.class.options_names)
       @options_class.__send__(:include, pl::OptionsMethods)
     end
 
     private
 
-    def do_initialize(options = {})
-      defaults = DEFAULT_OPTIONS.merge(options)
-      defaults.each do |k, v|
-        next if v.nil?
+    # number options
+    %i[
+      max_concurrent_requests max_requests window_size buffer_size
+      body_threshold_size debug_level
+    ].each do |option|
+      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+        # converts +v+ into an Integer before setting the +#{option}+ option.
+        private def option_#{option}(value)                                             # private def option_max_requests(v)
+          value = Integer(value) unless value.respond_to?(:infinite?) && value.infinite?
+          raise TypeError, ":#{option} must be positive" unless value.positive? # raise TypeError, ":max_requests must be positive" unless value.positive?
 
-        option_method_name = :"option_#{k}"
-        raise Error, "unknown option: #{k}" unless respond_to?(option_method_name)
+          value
+        end
+      OUT
+    end
 
-        value = __send__(option_method_name, v)
-        instance_variable_set(:"@#{k}", value)
-      end
+    # hashable options
+    %i[ssl http2_settings resolver_options pool_options].each do |option|
+      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+        # converts +v+ into an Hash before setting the +#{option}+ option.
+        private def option_#{option}(value) # def option_ssl(v)
+          Hash[value]
+        end
+      OUT
+    end
+
+    %i[
+      request_class response_class headers_class request_body_class
+      response_body_class connection_class http1_class http2_class
+      resolver_native_class resolver_system_class resolver_https_class options_class pool_class
+      io fallback_protocol debug debug_redact resolver_class
+      compress_request_body decompress_response_body
+      persistent close_on_fork
+    ].each do |method_name|
+      class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+        # sets +v+ as the value of the +#{method_name}+ option
+        private def option_#{method_name}(v); v; end # private def option_smth(v); v; end
+      OUT
+    end
+
+    def option_origin(value)
+      URI(value)
+    end
+
+    def option_base_path(value)
+      String(value)
+    end
+
+    def option_headers(value)
+      headers_class.new(value)
+    end
+
+    def option_timeout(value)
+      Hash[value]
+    end
+
+    def option_supported_compression_formats(value)
+      Array(value).map(&:to_s)
+    end
+
+    def option_transport(value)
+      transport = value.to_s
+      raise TypeError, "#{transport} is an unsupported transport type" unless %w[unix].include?(transport)
+
+      transport
+    end
+
+    def option_addresses(value)
+      Array(value).map { |entry| Resolver::Entry.convert(entry) }
+    end
+
+    def option_ip_families(value)
+      Array(value)
     end
 
     def access_option(obj, k, ivar_map)
@@ -371,5 +403,61 @@ module HTTPX
         obj.instance_variable_get(k)
       end
     end
+
+    SET_TEMPORARY_NAME = ->(klass, pl = nil) do
+      if klass.respond_to?(:set_temporary_name) # ruby 3.4 only
+        name = klass.name || "#{klass.superclass.name}(plugin)"
+        name = "#{name}/#{pl}" if pl
+        klass.set_temporary_name(name)
+      end
+    end
+
+    DEFAULT_OPTIONS = {
+      :max_requests => Float::INFINITY,
+      :debug => nil,
+      :debug_level => (ENV["HTTPX_DEBUG"] || 1).to_i,
+      :debug_redact => ENV.key?("HTTPX_DEBUG_REDACT"),
+      :ssl => EMPTY_HASH,
+      :http2_settings => { settings_enable_push: 0 }.freeze,
+      :fallback_protocol => "http/1.1",
+      :supported_compression_formats => %w[gzip deflate],
+      :decompress_response_body => true,
+      :compress_request_body => true,
+      :timeout => {
+        connect_timeout: CONNECT_TIMEOUT,
+        settings_timeout: SETTINGS_TIMEOUT,
+        close_handshake_timeout: CLOSE_HANDSHAKE_TIMEOUT,
+        operation_timeout: OPERATION_TIMEOUT,
+        keep_alive_timeout: KEEP_ALIVE_TIMEOUT,
+        read_timeout: READ_TIMEOUT,
+        write_timeout: WRITE_TIMEOUT,
+        request_timeout: REQUEST_TIMEOUT,
+      }.freeze,
+      :headers_class => Class.new(Headers, &SET_TEMPORARY_NAME),
+      :headers => EMPTY_HASH,
+      :window_size => WINDOW_SIZE,
+      :buffer_size => BUFFER_SIZE,
+      :body_threshold_size => MAX_BODY_THRESHOLD_SIZE,
+      :request_class => Class.new(Request, &SET_TEMPORARY_NAME),
+      :response_class => Class.new(Response, &SET_TEMPORARY_NAME),
+      :request_body_class => Class.new(Request::Body, &SET_TEMPORARY_NAME),
+      :response_body_class => Class.new(Response::Body, &SET_TEMPORARY_NAME),
+      :pool_class => Class.new(Pool, &SET_TEMPORARY_NAME),
+      :connection_class => Class.new(Connection, &SET_TEMPORARY_NAME),
+      :http1_class => Class.new(Connection::HTTP1, &SET_TEMPORARY_NAME),
+      :http2_class => Class.new(Connection::HTTP2, &SET_TEMPORARY_NAME),
+      :resolver_native_class => Class.new(Resolver::Native, &SET_TEMPORARY_NAME),
+      :resolver_system_class => Class.new(Resolver::System, &SET_TEMPORARY_NAME),
+      :resolver_https_class => Class.new(Resolver::HTTPS, &SET_TEMPORARY_NAME),
+      :options_class => Class.new(self, &SET_TEMPORARY_NAME),
+      :transport => nil,
+      :addresses => nil,
+      :persistent => false,
+      :resolver_class => (ENV["HTTPX_RESOLVER"] || :native).to_sym,
+      :resolver_options => { cache: true }.freeze,
+      :pool_options => EMPTY_HASH,
+      :ip_families => nil,
+      :close_on_fork => false,
+    }.freeze
   end
 end

data/lib/httpx/plugins/aws_sdk_authentication.rb

@@ -76,6 +76,8 @@ module HTTPX
       #
       # :aws_profile :: AWS account profile to retrieve credentials from.
       module OptionsMethods
+        private
+
         def option_aws_profile(value)
           String(value)
         end

data/lib/httpx/plugins/aws_sigv4.rb

@@ -170,6 +170,8 @@ module HTTPX
       #
       # :sigv4_signer :: instance of HTTPX::Plugins::AWSSigV4 used to sign requests.
       module OptionsMethods
+        private
+
         def option_sigv4_signer(value)
           value.is_a?(Signer) ? value : Signer.new(value)
         end

data/lib/httpx/plugins/callbacks.rb

@@ -32,6 +32,18 @@ module HTTPX
           MOD
         end
 
+        def plugin(*args, &blk)
+          super(*args).tap do |sess|
+            CALLBACKS.each do |cb|
+              next unless callbacks_for?(cb)
+
+              sess.callbacks(cb).concat(callbacks(cb))
+            end
+
+            sess.wrap(&blk) if blk
+          end
+        end
+
         private
 
         def branch(options, &blk)
@@ -85,7 +97,7 @@ module HTTPX
             end
           end
           request.on(:response) do |res|
-            emit_or_callback_error(:response_completed, request, res)
+            emit_or_callback_error(:response_completed, request, res) if res.is_a?(Response)
           end
         end
 

data/lib/httpx/plugins/circuit_breaker.rb

@@ -105,6 +105,8 @@ module HTTPX
       # :circuit_breaker_half_open_drip_rate :: the rate of requests a circuit allows to be performed when in an half-open state
       #                                         (defaults to <tt>1</tt>).
       module OptionsMethods
+        private
+
         def option_circuit_breaker_max_attempts(value)
           attempts = Integer(value)
           raise TypeError, ":circuit_breaker_max_attempts must be positive" unless attempts.positive?

data/lib/httpx/plugins/content_digest.rb

@@ -43,6 +43,8 @@ module HTTPX
       # :validate_content_digest :: whether a <tt>Content-Digest</tt> header in the response should be validated;
       #                             can also be a callable object (i.e. <tt>->(res) { ... }</tt>, defaults to <tt>false</tt>)
       module OptionsMethods
+        private
+
         def option_content_digest_algorithm(value)
           raise TypeError, ":content_digest_algorithm must be one of 'sha-256', 'sha-512'" unless SUPPORTED_ALGORITHMS.key?(value)
 

data/lib/httpx/plugins/cookies.rb

@@ -74,6 +74,8 @@ module HTTPX
       #
       # :cookies :: cookie jar for the session (can be a Hash, an Array, an instance of HTTPX::Plugins::Cookies::CookieJar)
       module OptionsMethods
+        private
+
         def option_headers(*)
           value = super
 
@@ -90,8 +92,6 @@ module HTTPX
           jar
         end
 
-        private
-
         def merge_cookie_in_jar(cookies, jar)
           cookies.each do |ck|
             ck.split(/ *; */).each do |cookie|

data/lib/httpx/plugins/digest_auth.rb

@@ -24,6 +24,8 @@ module HTTPX
       #
       # :digest :: instance of HTTPX::Plugins::Authentication::Digest, used to authenticate requests in the session.
       module OptionsMethods
+        private
+
         def option_digest(value)
           raise TypeError, ":digest must be a #{Authentication::Digest}" unless value.is_a?(Authentication::Digest)
 

data/lib/httpx/plugins/expect.rb

@@ -26,6 +26,8 @@ module HTTPX
       #                    before retrying without the Expect header (defaults to <tt>2</tt>).
       # :expect_threshold_size :: min threshold (in bytes) of the request payload to enable the 100-continue negotiation on.
       module OptionsMethods
+        private
+
         def option_expect_timeout(value)
           seconds = Float(value)
           raise TypeError, ":expect_timeout must be positive" unless seconds.positive?