Convert options hashes to keyword arguments

Author: sferik

CHANGELOG.md

@@ -9,6 +9,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- **BREAKING** Convert options hash parameters to keyword arguments across the
+  public API. Methods like `HTTP.get(url, body: "data")` continue to work, but
+  passing an explicit hash (e.g., `HTTP.get(url, {body: "data"})`) is no longer
+  supported. Affected methods: all HTTP verb methods (`get`, `post`, etc.),
+  `request`, `follow`, `Request.new`, `Response.new`, `Redirector.new`,
+  `Retriable::Performer.new`, `Retriable::DelayCalculator.new`, and
+  `Timeout::Null.new` (and subclasses)
 - **BREAKING** Extract request building into `HTTP::Request::Builder`. The
   `build_request` method has been removed from `Client`, `Session`, and the
   top-level `HTTP` module. Use `HTTP::Request::Builder.new(options).build(verb, uri)`

lib/http/chainable.rb

@@ -19,8 +19,8 @@ module Chainable
     # @param (see Client#request)
     # @return [HTTP::Response]
     # @api public
-    def request(verb, uri, opts = {})
-      make_client(default_options).request(verb, uri, opts)
+    def request(verb, uri, **)
+      make_client(default_options).request(verb, uri, **)
     end
 
     # Set timeout on the request
@@ -127,12 +127,12 @@ def via(*proxy)
     # @example
     #   HTTP.follow.get("http://example.com")
     #
-    # @param [Hash] options redirect options
+    # @param options [Hash] redirect options
     # @return [HTTP::Session]
     # @see Redirector#initialize
     # @api public
-    def follow(options = {})
-      branch default_options.with_follow options
+    def follow(**options)
+      branch default_options.with_follow(options)
     end
 
     # Make a request with the given headers
@@ -210,17 +210,12 @@ def auth(value)
     #   HTTP.basic_auth(user: "user", pass: "pass").get("http://example.com")
     #
     # @see http://tools.ietf.org/html/rfc2617
-    # @param [#fetch] opts
-    # @option opts [#to_s] :user
-    # @option opts [#to_s] :pass
+    # @param [#to_s] user
+    # @param [#to_s] pass
     # @return [HTTP::Session]
     # @api public
-    def basic_auth(opts)
-      user  = opts.fetch(:user)
-      pass  = opts.fetch(:pass)
-      creds = "#{user}:#{pass}"
-
-      auth("Basic #{encode64(creds)}")
+    def basic_auth(user:, pass:)
+      auth("Basic #{encode64("#{user}:#{pass}")}")
     end
 
     # Get options for HTTP

lib/http/chainable/verbs.rb

@@ -12,11 +12,11 @@ module Verbs
       #   HTTP.head("http://example.com")
       #
       # @param [String, URI] uri URI to request
-      # @param [Hash] options request options
+      # @param options [Hash] request options
       # @return [HTTP::Response]
       # @api public
-      def head(uri, options = {})
-        request :head, uri, options
+      def head(uri, **)
+        request(:head, uri, **)
       end
 
       # Get a resource
@@ -25,11 +25,11 @@ def head(uri, options = {})
       #   HTTP.get("http://example.com")
       #
       # @param [String, URI] uri URI to request
-      # @param [Hash] options request options
+      # @param options [Hash] request options
       # @return [HTTP::Response]
       # @api public
-      def get(uri, options = {})
-        request :get, uri, options
+      def get(uri, **)
+        request(:get, uri, **)
       end
 
       # Post to a resource
@@ -38,11 +38,11 @@ def get(uri, options = {})
       #   HTTP.post("http://example.com", body: "data")
       #
       # @param [String, URI] uri URI to request
-      # @param [Hash] options request options
+      # @param options [Hash] request options
       # @return [HTTP::Response]
       # @api public
-      def post(uri, options = {})
-        request :post, uri, options
+      def post(uri, **)
+        request(:post, uri, **)
       end
 
       # Put to a resource
@@ -51,11 +51,11 @@ def post(uri, options = {})
       #   HTTP.put("http://example.com", body: "data")
       #
       # @param [String, URI] uri URI to request
-      # @param [Hash] options request options
+      # @param options [Hash] request options
       # @return [HTTP::Response]
       # @api public
-      def put(uri, options = {})
-        request :put, uri, options
+      def put(uri, **)
+        request(:put, uri, **)
       end
 
       # Delete a resource
@@ -64,11 +64,11 @@ def put(uri, options = {})
       #   HTTP.delete("http://example.com/resource")
       #
       # @param [String, URI] uri URI to request
-      # @param [Hash] options request options
+      # @param options [Hash] request options
       # @return [HTTP::Response]
       # @api public
-      def delete(uri, options = {})
-        request :delete, uri, options
+      def delete(uri, **)
+        request(:delete, uri, **)
       end
 
       # Echo the request back to the client
@@ -77,11 +77,11 @@ def delete(uri, options = {})
       #   HTTP.trace("http://example.com")
       #
       # @param [String, URI] uri URI to request
-      # @param [Hash] options request options
+      # @param options [Hash] request options
       # @return [HTTP::Response]
       # @api public
-      def trace(uri, options = {})
-        request :trace, uri, options
+      def trace(uri, **)
+        request(:trace, uri, **)
       end
 
       # Return the methods supported on the given URI
@@ -90,11 +90,11 @@ def trace(uri, options = {})
       #   HTTP.options("http://example.com")
       #
       # @param [String, URI] uri URI to request
-      # @param [Hash] options request options
+      # @param options [Hash] request options
       # @return [HTTP::Response]
       # @api public
-      def options(uri, options = {})
-        request :options, uri, options
+      def options(uri, **)
+        request(:options, uri, **)
       end
 
       # Convert to a transparent TCP/IP tunnel
@@ -103,11 +103,11 @@ def options(uri, options = {})
       #   HTTP.connect("http://example.com")
       #
       # @param [String, URI] uri URI to request
-      # @param [Hash] options request options
+      # @param options [Hash] request options
       # @return [HTTP::Response]
       # @api public
-      def connect(uri, options = {})
-        request :connect, uri, options
+      def connect(uri, **)
+        request(:connect, uri, **)
       end
 
       # Apply partial modifications to a resource
@@ -116,11 +116,11 @@ def connect(uri, options = {})
       #   HTTP.patch("http://example.com/resource", body: "data")
       #
       # @param [String, URI] uri URI to request
-      # @param [Hash] options request options
+      # @param options [Hash] request options
       # @return [HTTP::Response]
       # @api public
-      def patch(uri, options = {})
-        request :patch, uri, options
+      def patch(uri, **)
+        request(:patch, uri, **)
       end
     end
   end

lib/http/client.rb

@@ -43,14 +43,14 @@ def initialize(default_options = nil, **)
     # @param opts [Hash] request options
     # @return [HTTP::Response] the response
     # @api public
-    def request(verb, uri, opts = {})
+    def request(verb, uri, **opts)
       opts    = @default_options.merge(opts)
       builder = Request::Builder.new(opts)
       req     = builder.build(verb, uri)
       res     = perform(req, opts)
       return res unless opts.follow
 
-      Redirector.new(opts.follow).perform(req, res) do |request|
+      Redirector.new(**opts.follow).perform(req, res) do |request|
         perform(builder.wrap(request), opts)
       end
     end
@@ -123,7 +123,7 @@ def perform_once(req, options)
     # @return [HTTP::Response] the response
     # @api private
     def perform_with_retry(req, options)
-      Retriable::Performer.new(options.retriable).perform(self, req) do
+      Retriable::Performer.new(**options.retriable).perform(self, req) do
         perform_once(req, options)
       end
     end

lib/http/connection.rb

@@ -238,7 +238,7 @@ def check_premature_eof(eof)
     # @return [void]
     # @api private
     def connect_socket(req, options)
-      @socket = options.timeout_class.new(options.timeout_options) # steep:ignore
+      @socket = options.timeout_class.new(**options.timeout_options) # steep:ignore
       @socket.connect(options.socket_class, req.socket_host, req.socket_port, nodelay: options.nodelay)
 
       send_proxy_connect_request(req)

lib/http/features/auto_inflate.rb

@@ -18,7 +18,7 @@ class AutoInflate < Feature
       def wrap_response(response)
         return response unless supported_encoding?(response)
 
-        Response.new(inflated_response_options(response))
+        Response.new(**inflated_response_options(response)) # steep:ignore
       end
 
       # Returns an inflating body stream for a connection

lib/http/features/logging.rb

@@ -78,7 +78,7 @@ def wrap_response(response)
         logger.debug { stringify_headers(response.headers) }
         return response unless logger.debug?
 
-        Response.new(logged_response_options(response))
+        Response.new(**logged_response_options(response)) # steep:ignore
       end
 
       private

lib/http/redirector.rb

@@ -48,15 +48,15 @@ class EndlessRedirectError < TooManyRedirectsError; end
     # @example
     #   HTTP::Redirector.new(strict: true, max_hops: 5)
     #
-    # @param [Hash] opts
-    # @option opts [Boolean] :strict (true) redirector hops policy
-    # @option opts [#to_i] :max_hops (5) maximum allowed amount of hops
+    # @param [Boolean] strict (true) redirector hops policy
+    # @param [#to_i] max_hops (5) maximum allowed amount of hops
+    # @param [#call, nil] on_redirect optional redirect callback
     # @api public
     # @return [HTTP::Redirector]
-    def initialize(opts = {})
-      @strict      = opts.fetch(:strict, true)
-      @max_hops    = Integer(opts.fetch(:max_hops, 5))
-      @on_redirect = opts.fetch(:on_redirect, nil)
+    def initialize(strict: true, max_hops: 5, on_redirect: nil)
+      @strict      = strict
+      @max_hops    = Integer(max_hops)
+      @on_redirect = on_redirect
     end
 
     # Follows redirects until non-redirect response found

lib/http/request.rb

@@ -147,28 +147,30 @@ class InvalidURIError < RequestError; end
 
     # Create a new HTTP request
     #
-    # @option opts [String] :version
-    # @option opts [#to_s] :verb HTTP request method
-    # @option opts [#call] :uri_normalizer (HTTP::URI::NORMALIZER)
-    # @option opts [HTTP::URI, #to_s] :uri
-    # @option opts [Hash] :headers
-    # @option opts [Hash] :proxy
-    # @option opts [String, Enumerable, IO, nil] :body
+    # @param [#to_s] verb HTTP request method
+    # @param [HTTP::URI, #to_s] uri
+    # @param [Hash] headers
+    # @param [Hash] proxy
+    # @param [String, Enumerable, IO, nil] body
+    # @param [String] version
+    # @param [#call] uri_normalizer
     #
     # @example
     #   Request.new(verb: :get, uri: "https://example.com")
     #
     # @return [HTTP::Request]
     # @api public
-    def initialize(opts)
-      @uri_normalizer = opts[:uri_normalizer] || HTTP::URI::NORMALIZER
-      parse_verb_and_uri!(opts)
+    def initialize(verb:, uri:, headers: nil, proxy: {}, body: nil, version: "1.1",
+                   uri_normalizer: nil)
+      @uri_normalizer = uri_normalizer || HTTP::URI::NORMALIZER
+      @verb = verb.to_s.downcase.to_sym
+      parse_uri!(uri)
       validate_method_and_scheme!
 
-      @proxy   = opts[:proxy] || {}
-      @version = opts[:version] || "1.1"
-      @headers = prepare_headers(opts[:headers])
-      @body    = prepare_body(opts[:body])
+      @proxy   = proxy
+      @version = version
+      @headers = prepare_headers(headers)
+      @body    = prepare_body(body)
     end
 
     # Returns new Request with updated uri
@@ -329,20 +331,14 @@ def default_host_header_value
       value
     end
 
-    # Parse verb, URI, and scheme from options
+    # Parse and normalize the URI, setting scheme
     # @return [void]
     # @api private
-    def parse_verb_and_uri!(opts)
-      @verb = opts.fetch(:verb).to_s.downcase.to_sym
-      uri   = opts.fetch(:uri)
-
-      begin
-        @uri = @uri_normalizer.call(uri)
-      rescue TypeError, Addressable::URI::InvalidURIError
-        raise InvalidURIError, "invalid URI: #{uri.inspect}"
-      end
-
+    def parse_uri!(uri)
+      @uri = @uri_normalizer.call(uri)
       @scheme = @uri.scheme.to_s.downcase.to_sym if @uri.scheme
+    rescue TypeError, Addressable::URI::InvalidURIError
+      raise InvalidURIError, "invalid URI: #{uri.inspect}"
     end
 
     # Validate HTTP method and URI scheme