patron 0.13.4 → 1.0.0

data/lib/patron/compat.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# The positional-argument forms of the 0.x API, kept for the 1.0 line so that webmock's
+# adapter and sniffer's wrapper keep working while they move to keywords. Each form warns
+# once. Everything about this lives here on purpose, bar the one line in Session#request: to drop
+# it in 1.1, delete this file, its require in session.rb, that line and spec/compat_spec.rb.
+# See https://github.com/toland/patron/issues/209
+module Patron
+  module Compat
+    # Kept per Ractor since a non-main Ractor may not touch module state, so each Ractor warns once
+    def self.warned = Ractor.current[:patron_compat_warned] ||= {}
+
+    # uplevel counts frames up to the user's call site: deprecated -> shim method -> caller
+    def self.deprecated(form, replacement, uplevel: 2)
+      return if warned[form]
+      warned[form] = true
+      warn "Patron: #{form} is deprecated and will be removed in Patron 1.1, use #{replacement} instead (https://github.com/toland/patron/issues/209)", uplevel: uplevel
+    end
+
+    # Session.new(hash). The request(action, url, headers, options_hash) form is handled in
+    # Session#request itself, see the comment there
+    module SessionArguments
+      def initialize(*positional, **options, &block)
+        options = Compat.hash_to_keywords("Patron::Session.new with a Hash", positional, options)
+        super(**options, &block)
+      end
+    end
+
+    # Response.new(url, status, redirect_count, header_data, body, default_charset = nil)
+    module ResponseArguments
+      POSITIONAL = %i[url status redirect_count header_data body default_charset].freeze
+
+      def new(*positional, **keywords)
+        return super(**keywords) if positional.empty?
+
+        Compat.deprecated("Patron::Response.new with positional arguments", "keyword arguments")
+        if positional.size > POSITIONAL.size
+          raise ArgumentError, "wrong number of arguments (given #{positional.size}, expected 5..6)"
+        end
+        super(**POSITIONAL.zip(positional).to_h.compact, **keywords)
+      end
+    end
+
+    def self.hash_to_keywords(form, positional, keywords)
+      return keywords if positional.empty?
+      unless positional.size == 1 && positional.first.is_a?(Hash)
+        raise ArgumentError, "wrong number of arguments (given #{positional.size}, expected 0)"
+      end
+
+      deprecated(form, "keyword arguments", uplevel: 3)
+      positional.first.transform_keys(&:to_sym).merge(keywords)
+    end
+  end
+
+  Session.prepend(Compat::SessionArguments)
+  Response.singleton_class.prepend(Compat::ResponseArguments)
+end

data/lib/patron/error.rb

@@ -1,47 +1,59 @@
+# frozen_string_literal: true
+
 module Patron
 
   # Base class for Patron exceptions.
-  class Error < StandardError; end
+  class Error < StandardError
+    # @return [Integer, nil] the CURLcode libcurl reported, when the error came from a transfer
+    attr_reader :curl_code
+  end
 
   # Gets raised when the URL passed to Patron used a protocol that it does not support.
   # This most likely the result of a misspelled protocol string.
-  class UnsupportedProtocol    < Error; end
+  class UnsupportedProtocol < Error; end
 
   # Gets raised when a request is attempted with an unsupported SSL version.
-  class UnsupportedSSLVersion  < Error; end
+  class UnsupportedSSLVersion < Error; end
 
   # Gets raised when a request is attempted with an unsupported HTTP version.
-  class UnsupportedHTTPVersion  < Error; end
+  class UnsupportedHTTPVersion < Error; end
 
   # Gets raised when the URL was not properly formatted.
-  class URLFormatError         < Error; end
+  class URLFormatError < Error; end
 
   # Gets raised when the remote host name could not be resolved.
-  class HostResolutionError    < Error; end
+  class HostResolutionError < Error; end
 
   # Gets raised when failing to connect to the remote host.
-  class ConnectionFailed       < Error; end
+  class ConnectionFailed < Error; end
 
   # Gets raised when the response was shorter or larger than expected.
   # This happens when the server first reports an expected transfer size,
   # and then delivers data that doesn't match the previously given size.
-  class PartialFileError       < Error; end
+  class PartialFileError < Error; end
 
   # Gets raised on an operation timeout. The specified time-out period was reached.
-  class TimeoutError           < Error; end
+  class TimeoutError < Error; end
 
   # Gets raised on too many redirects. When following redirects, Patron hit the maximum amount.
-  class TooManyRedirects       < Error; end
+  class TooManyRedirects < Error; end
+
+  # Gets raised when the request was aborted: by Session#interrupt, or by a progress callback returning false.
+  class Aborted < Error; end
 
-  # Gets raised if the progress callback, or an interrupt, aborts the Curl perform() call
-  class Aborted                < Error; end
+  # Gets raised when the response body grew past Session#download_byte_limit.
+  class DownloadLimitExceeded < Aborted; end
+
+  # Gets raised when the client certificate or its private key could not be used,
+  # for example when the key password is wrong or the certificate file is missing.
+  class ClientCertificateError < Error; end
 
   # Gets raised when the server specifies an encoding that could not be found, or has an invalid name,
   # or when the server "lies" about the encoding of the response body (such as can be the case
   # when the server specifies an encoding in `Content-Type`) which the HTML generator then overrides
   # with a `meta` element.
   class HeaderCharsetInvalid < Error; end
-  
+
   # Gets raised when you try to use `decoded_body` but it can't
   # be represented by your Ruby process's current internal encoding
   class NonRepresentableBody < HeaderCharsetInvalid; end

data/lib/patron/header_parser.rb

@@ -1,30 +1,32 @@
-module Patron::HeaderParser
-  HTTP_STATUS_LINE_START_RE = /^HTTP\/\d(\.\d)? \d+/
-  HEADER_LINE_START_RE = /^[^:]+\:/
+# frozen_string_literal: true
 
-  # Returned for each response parsed out
-  class SingleResponseHeaders < Struct.new(:status_line, :headers)
-  end
+module Patron
+  module HeaderParser
+    HTTP_STATUS_LINE_START_RE = /^HTTP\/\d(\.\d)? \d+/
+    HEADER_LINE_START_RE = /^[^:]+:/
+
+    # The status line and header lines of one response
+    SingleResponseHeaders = Data.define(:status_line, :headers)
 
-  # Parses a string with lines delimited with CRLF into
-  # an Array of SingleResponseHeaders objects. libCURL supplies
-  # us multiple responses in sequence, so if we encounter multiple redirect
-  # or operate through a proxy - that adds ConnectionEstablished status at
-  # the beginning of the response - we need to account for parsing
-  # multiple response headres and potentially preserving them.
-  #
-  # @param [String] the string of headers, with responses delimited by empty lines. All lines must end with CRLF
-  # @return Array<SingleResponseHeaders>
-  def self.parse(string_of_headers_from_multiple_responses_in_sequence)
-    responses = []
-    string_of_headers_from_multiple_responses_in_sequence.each_line do |matched_line|
-      if matched_line =~ HTTP_STATUS_LINE_START_RE
-        responses << SingleResponseHeaders.new(matched_line.strip, [])
-      elsif matched_line =~ HEADER_LINE_START_RE
-        raise "Header should follow an HTTP status line" unless responses.any?
-        responses[-1].headers << matched_line.strip
-      end # else it is the end of the headers for the request
+    # Splits the raw header data libcurl hands us into one SingleResponseHeaders per response.
+    # There is more than one when redirects were followed, or when a proxy added its own
+    # "Connection established" response in front of the real one.
+    #
+    # @param raw_headers [String] CRLF-delimited header lines, responses separated by empty lines
+    # @return [Array<SingleResponseHeaders>]
+    def self.parse(raw_headers)
+      responses = []
+      current_headers = nil
+      raw_headers.each_line do |line|
+        if line.match?(HTTP_STATUS_LINE_START_RE)
+          current_headers = []
+          responses << SingleResponseHeaders.new(status_line: line.strip, headers: current_headers)
+        elsif line.match?(HEADER_LINE_START_RE)
+          raise Patron::Error, "Header should follow an HTTP status line" unless current_headers
+          current_headers << line.strip
+        end
+      end
+      responses.each { |r| r.headers.freeze }
     end
-    responses
   end
 end

data/lib/patron/request.rb

@@ -1,197 +1,153 @@
+# frozen_string_literal: true
+
 require 'patron/util'
 
 module Patron
 
-  # Represents the information necessary for an HTTP request.
-  # This is basically a data object with validation. Not all fields will be
-  # used in every request.
+  # Represents the information necessary for an HTTP request. A data object with
+  # validation in the setters, built by Session#build_request or by hand. A Request
+  # can be reused: the extension reads its attributes once when the request starts,
+  # so changing the URL and sending it again is fine.
   class Request
-
-    # Contains the valid HTTP verbs that can be used to perform requests
-    VALID_ACTIONS = %w[GET PUT POST DELETE HEAD COPY PATCH]
-
-    # Initializes a new Request, which defaults to the GET HTTP verb and
-    # has it's timeouts set to 0
-    def initialize
+    ATTRIBUTES = %i[
+      action url headers timeout connect_timeout dns_cache_timeout max_redirects
+      username password auth_type proxy proxy_type insecure cacert
+      ssl_version http_version ssl_cert ssl_cert_type ssl_key ssl_key_password
+      ignore_content_length buffer_size download_byte_limit progress_callback
+      automatic_content_encoding force_ipv4 low_speed_time low_speed_limit
+      upload_data file_name multipart
+    ].freeze
+
+    # Any HTTP token works as a verb; the ones libcurl does not know natively are sent as custom requests
+    ACTION_RE = /\A[A-Za-z][A-Za-z0-9-]*\z/
+
+    # Attributes without validation of their own
+    attr_accessor :url, :username, :password, :file_name, :proxy, :proxy_type, :insecure, :dns_cache_timeout,
+                  :ignore_content_length, :multipart, :cacert, :ssl_version, :http_version,
+                  :automatic_content_encoding, :force_ipv4, :download_byte_limit, :low_speed_time,
+                  :low_speed_limit, :progress_callback, :ssl_cert, :ssl_cert_type, :ssl_key, :ssl_key_password
+
+    attr_reader :action, :headers, :timeout, :connect_timeout, :max_redirects, :auth_type, :buffer_size, :upload_data
+
+    # Defaults to a GET with no timeouts and unlimited redirects. Attributes may be given as
+    # keywords; `action` and `multipart` are applied first since `upload_data=` depends on them.
+    #
+    # @param attributes [Hash] attribute values by name
+    def initialize(**attributes)
       @action = :get
       @headers = {}
-      @timeout = 0
-      @connect_timeout = 0
+      @timeout = 0.0
+      @connect_timeout = 0.0
       @max_redirects = -1
-    end
-
-    READER_VARS = [
-      :url, :username, :password, :file_name, :proxy, :proxy_type, :insecure,
-      :ignore_content_length, :multipart, :action, :timeout, :connect_timeout, :dns_cache_timeout,
-      :max_redirects, :headers, :auth_type, :upload_data, :buffer_size, :cacert,
-      :ssl_version, :http_version, :automatic_content_encoding, :force_ipv4, :download_byte_limit,
-      :low_speed_time, :low_speed_limit, :progress_callback
-    ]
+      @auth_type = Request::AuthBasic
+      @force_ipv4 = false
 
-    WRITER_VARS = [
-      :url, :username, :password, :file_name, :proxy, :proxy_type, :insecure, :dns_cache_timeout,
-      :ignore_content_length, :multipart, :cacert, :ssl_version, :http_version, :automatic_content_encoding, :force_ipv4, :download_byte_limit,
-      :low_speed_time, :low_speed_limit, :progress_callback
-    ]
+      unknown = attributes.keys - ATTRIBUTES
+      raise ArgumentError, "Unknown Request attributes: #{unknown.join(', ')}" unless unknown.empty?
 
-    attr_reader(*READER_VARS)
-    attr_writer(*WRITER_VARS)
+      %i[action multipart].each { |first| public_send("#{first}=", attributes[first]) if attributes.key?(first) }
+      attributes.each { |name, value| public_send("#{name}=", value) unless %i[action multipart].include?(name) }
+    end
 
     # Set the type of authentication to use for this request.
     #
-    # @param [String, Symbol]type The type of authentication to use for this request, can be one of
-    #   :basic, :digest, or :any
-    #
-    # @example
-    #   sess.username = "foo"
-    #   sess.password = "sekrit"
-    #   sess.auth_type = :digest
-    def auth_type=(type=:basic)
+    # @param type [String, Symbol, Integer] `:basic`, `:digest`, `:any`, or a `Request::Auth*` constant
+    def auth_type=(type)
       @auth_type = case type
-      when :basic, "basic"
-        Request::AuthBasic
-      when :digest, "digest"
-        Request::AuthDigest
-      when :any, "any"
-        Request::AuthAny
-      else
-        raise "#{type.inspect} is an unknown authentication type"
+      in :basic | "basic" | nil then Request::AuthBasic
+      in :digest | "digest" then Request::AuthDigest
+      in :any | "any" then Request::AuthAny
+      in Integer then type
+      else raise ArgumentError, "#{type.inspect} is an unknown authentication type"
       end
     end
 
-    # Sets the upload data (request body) for the request. If the
-    # given argument is a Hash, the contents of the hash will be handled
-    # as form fields and will be form-encoded. The somposition of the request
-    # body is then going to be handled by Curl.
-    #
-    # If the given `data` is any other object, it is going to be treated as a stringable
-    # request body (JSON or other verbatim type) and will have it's `to_s` method called
-    # before sending out the request.
+    # Sets the request body. A Hash is form-encoded, unless the request is multipart, in which
+    # case libcurl composes the body from it. Anything else is sent as its `to_s`, or uploaded
+    # from the file it names when it responds to `to_path`.
     #
-    # @param data[Hash, #to_s] a Hash of form fields to values, or an object that responds to `to_s`
+    # @param data [Hash, #to_s, #to_path, nil]
     def upload_data=(data)
-      @upload_data = case data
-      when Hash
-        self.multipart ? data : Util.build_query_string_from_hash(data, action == :post)
+      @upload_data = if data.is_a?(Hash) && !multipart
+        Util.build_query_string_from_hash(data, action == :post)
       else
         data
       end
     end
 
-    # Sets the HTTP verb for the request
+    # Sets the HTTP verb. Any HTTP token is accepted (#180); the ones libcurl does not know
+    # natively are sent as custom requests.
     #
-    # @param action[String] the name of the HTTP verb
+    # @param action [Symbol, String]
     def action=(action)
-      if !VALID_ACTIONS.include?(action.to_s.upcase)
-        raise ArgumentError, "Action must be one of #{VALID_ACTIONS.join(', ')}"
-      end
-      @action = action.downcase.to_sym
+      name = action.to_s
+      raise ArgumentError, "#{action.inspect} is not a valid HTTP verb" unless name.match?(ACTION_RE)
+      @action = name.downcase.to_sym
     end
 
-    # Sets the read timeout for the CURL request, in seconds.
-    # Can be set to less than a second using a floating-point value.
-    # Setting the value to 0 will disable the timeout.
-    #
-    # @param new_timeout[Integer] the number of seconds to wait before raising a timeout error
-    def timeout=(new_timeout)
-      if new_timeout && new_timeout.to_f < 0
-        raise ArgumentError, "Timeout must be a positive number"
-      end
-      @timeout = new_timeout.to_f
+    # @param seconds [Numeric, nil] transfer timeout, fractional seconds allowed, 0 or nil to disable
+    def timeout=(seconds)
+      @timeout = validate_timeout(seconds)
     end
 
-    # Sets the connect timeout for the CURL request, in seconds.
-    # Can be set to less than a second using a floating-point value.
-    #
-    # @param new_timeout[Integer] the number of seconds to wait before raising a timeout error
-    def connect_timeout=(new_timeout)
-      if new_timeout && new_timeout.to_f < 0
-        raise ArgumentError, "Timeout must be a positive number"
-      end
-
-      @connect_timeout = new_timeout.to_f
+    # @param seconds [Numeric, nil] connect timeout, fractional seconds allowed, 0 or nil to disable
+    def connect_timeout=(seconds)
+      @connect_timeout = validate_timeout(seconds)
     end
-    
-    # Sets the maximum number of redirects that are going to be followed.
-    #
-    # @param new_max_redirects[Integer] The number of redirects to follow, or `-1` for unlimited redirects.
-    def max_redirects=(new_max_redirects)
-      if new_max_redirects.to_i < -1
-        raise ArgumentError, "Max redirects must be a positive integer, 0 or -1"
-      end
 
-      @max_redirects = new_max_redirects.to_i
+    # @param count [Integer] -1 for unlimited, 0 to not follow redirects
+    def max_redirects=(count)
+      raise ArgumentError, "Max redirects must be a positive integer, 0 or -1" if count.to_i < -1
+      @max_redirects = count.to_i
     end
 
-    # Sets the headers for the request. Headers muse be set with the right capitalization.
-    # The previously set headers will be replaced.
-    #
-    # @param new_headers[Hash] the hash of headers to set.
+    # @param new_headers [Hash] replaces the headers set so far
     def headers=(new_headers)
-      if !new_headers.kind_of?(Hash)
-        raise ArgumentError, "Headers must be a hash"
-      end
-
+      raise ArgumentError, "Headers must be a hash" unless new_headers.is_a?(Hash)
       @headers = new_headers
     end
 
-    # Sets the receive buffer size. This is a recommendedation value, as CURL is not guaranteed to
-    # honor this value internally (see https://curl.haxx.se/libcurl/c/CURLOPT_BUFFERSIZE.html).
-    # By default, CURL uses the maximum possible buffer size, which will be the best especially
-    # for smaller and quickly-executing requests.
-    #
-    # @param buffer_size[Integer,nil] the desired buffer size, or `nil` for automatic buffer size
-    def buffer_size=(buffer_size)
-      if buffer_size != nil && buffer_size.to_i < 1
-        raise ArgumentError, "Buffer size must be a positive integer greater than 0 or nil"
-      end
-
-      @buffer_size = buffer_size != nil ? buffer_size.to_i : nil
+    # @param size [Integer, nil] the receive buffer size libcurl should use, nil for its default
+    def buffer_size=(size)
+      raise ArgumentError, "Buffer size must be a positive integer greater than 0 or nil" if !size.nil? && size.to_i < 1
+      @buffer_size = size&.to_i
     end
 
-    # Returns the set HTTP authentication string for basic authentication.
-    #
-    # @return [String, NilClass] the authentication string or nil if no authentication is used
+    # @return [String, nil] the "user:password" pair for HTTP authentication, or nil when either is missing
     def credentials
       return nil if username.nil? || password.nil?
       "#{username}:#{password}"
     end
 
-    # Returns the set HTTP verb
-    #
-    # @return [String] the HTTP verb
-    def action_name
-      @action.to_s.upcase
-    end
+    # @return [String] the HTTP verb in upper case
+    def action_name = action.to_s.upcase
 
-    # Tells whether this Request is configured the same as the other request
-    # @return [TrueClass, FalseClass]
-    def eql?(request)
-      return false unless Request === request
+    # @return [Hash{Symbol => Object}] every attribute by name
+    def to_h = ATTRIBUTES.to_h { |name| [name, public_send(name)] }
 
-      READER_VARS.inject(true) do |memo, name|
-        memo && (self.send(name) == request.send(name))
-      end
+    # @return [Boolean] whether the other request is configured identically
+    def eql?(other)
+      other.is_a?(Request) && to_h == other.to_h
     end
+    alias == eql?
 
-    alias_method :==, :eql?
+    def hash = to_h.hash
 
-    # Returns a Marshalable representation of the Request
-    # @return [Array]
-    def marshal_dump
-      [ @url, @username, @password, @file_name, @proxy, @proxy_type, @insecure,
-        @ignore_content_length, @multipart, @action, @timeout, @connect_timeout,
-        @max_redirects, @headers, @auth_type, @upload_data, @buffer_size, @cacert ]
-    end
+    # @return [Hash] every attribute, so that Marshal round-trips are complete
+    def marshal_dump = to_h
 
-    # Reinstates instance variables from a marshaled representation
-    # @param data[Array]
-    # @return [void]
-    def marshal_load(data)
-      @url, @username, @password, @file_name, @proxy, @proxy_type, @insecure,
-      @ignore_content_length, @multipart, @action, @timeout, @connect_timeout,
-      @max_redirects, @headers, @auth_type, @upload_data, @buffer_size, @cacert = data
+    # @param attributes [Hash]
+    def marshal_load(attributes)
+      initialize(**attributes.compact.except(:progress_callback))
+      @progress_callback = attributes[:progress_callback]
     end
 
+    private
+
+    def validate_timeout(seconds)
+      return nil if seconds.nil?
+      raise ArgumentError, "Timeout must be a positive number" if seconds.to_f < 0
+      seconds.to_f
+    end
   end
 end

data/lib/patron/response.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Patron
 
   # Represents the response from the HTTP server.
   class Response
     include ResponseDecoding
-    
+
     # @return [String] the original URL used to perform the request (contains the final URL after redirects)
     attr_reader :url
 
@@ -19,7 +21,7 @@ module Patron
     # @return [String, nil] the response body as a String encoded as `Encoding::BINARY` or
     #           or `nil` if the response was written directly to a file
     attr_reader :body
-    
+
     # @return [Hash] the response headers. If there were multiple headers received for the same value
     #   (like "Cookie"), the header values will be within an Array under the key for the header, in order.
     attr_reader :headers
@@ -28,37 +30,44 @@ module Patron
     #    to be a valid charset name, just stored. To check the charset for validity, use #body_decodable?
     attr_reader :charset
 
+    # @return [Hash{Symbol => Float}, nil] curl's cumulative transfer marks in seconds since the request
+    #   started: `:namelookup`, `:connect`, `:appconnect`, `:pretransfer`, `:starttransfer`, `:redirect`
+    #   and `:total`. `nil` when the response was not built from a curl transfer (e.g. a stub).
+    attr_reader :timings
+
     # Overridden so that the output is shorter and there is no response body printed
     def inspect
-      # Avoid spamming the console with the header and body data
       "#<Patron::Response @status_line='#{@status_line}'>"
     end
 
-    def initialize(url, status, redirect_count, raw_header_data, body, default_charset = nil)
-      @url            = url.force_encoding(Encoding::ASCII) # the URL is always an ASCII subset, _always_.
-      @status         = status
+    # @param url [String] the effective URL after redirects
+    # @param status [Integer] the HTTP status code
+    # @param redirect_count [Integer] how many redirects were followed
+    # @param header_data [String] the raw header lines of every response in the chain, CRLF delimited
+    # @param body [String, nil] the response body, or nil when it was downloaded to a file
+    # @param default_charset [String, nil] the charset to assume when the Content-Type header names none
+    # @param timings [Hash, nil] see #timings
+    def initialize(url:, status:, header_data:, redirect_count: 0, body: nil, default_charset: nil, timings: nil)
+      @url = url
+      @status = status
       @redirect_count = redirect_count
-      @body           = body.force_encoding(Encoding::BINARY) if body
+      @body = body && (body.encoding == Encoding::BINARY ? body : body.b)
+      @timings = timings
 
-      header_data = decode_header_data(raw_header_data)
-      parse_headers(header_data)
-      @charset = charset_from_content_type
+      parse_headers(decode_header_data(header_data))
+      @charset = charset_from_content_type || default_charset
     end
 
     # Tells whether the HTTP response code is less than 400
     #
     # @return [Boolean]
-    def ok?
-      !error?
-    end
-    
+    def ok? = !error?
+
     # Tells whether the HTTP response code is larger than 399
     #
     # @return [Boolean]
-    def error?
-      status >= 400
-    end
-    
+    def error? = status >= 400
+
     # Tells whether the response body can be decoded losslessly into the curren internal encoding
     #
     # @return [Boolean] true if the body is decodable, false if otherwise
@@ -94,9 +103,10 @@ module Patron
     # @return [String, nil]
     def decoded_body
       return unless @body
+      return decode_body(true) if frozen? # a shareable Response may not memoize
       @decoded_body ||= decode_body(true)
     end
-    
+
     # Works the same as `decoded_body`, with one substantial difference: characters which can't be represented
     # in your process' default encoding are going to be replaced with question marks. This can be used for raising
     # errors when you receive responses which indicate errors on the server you are calling. For example, if you expect
@@ -107,26 +117,25 @@ module Patron
     # @return [String, nil]
     def inspectable_body
       return unless @body
+      return decode_body(false) if frozen?
       @inspectable_body ||= decode_body(false)
     end
 
     private
 
-    # Called by the C code to parse and set the headers
     def parse_headers(header_data_for_multiple_responses)
       @headers = {}
 
       responses = Patron::HeaderParser.parse(header_data_for_multiple_responses)
-      last_response = responses[-1] # Only use the last response (for proxies and redirects)
+      last_response = responses[-1] # proxies and redirects put their own responses in front of the real one
 
       @status_line = last_response.status_line
       last_response.headers.each do |line|
         hdr, val = line.split(":", 2)
-
-        val.strip! unless val.nil?
+        val = val&.strip
 
         if @headers.key?(hdr)
-          @headers[hdr] = [@headers[hdr]] unless @headers[hdr].kind_of? Array
+          @headers[hdr] = [@headers[hdr]] unless @headers[hdr].kind_of?(Array)
           @headers[hdr] << val
         else
           @headers[hdr] = val