excon 0.99.0 → 1.2.5

data/excon.gemspec

@@ -1,44 +1,51 @@
+# frozen_string_literal: true
+
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), 'lib')
 require 'excon/version'
 
 Gem::Specification.new do |s|
   s.name             = 'excon'
   s.version          = Excon::VERSION
-  s.summary          = "speed, persistence, http(s)"
-  s.description      = "EXtended http(s) CONnections"
-  s.authors          = ["dpiddy (Dan Peterson)", "geemus (Wesley Beary)", "nextmat (Matt Sanders)"]
+  s.summary          = 'speed, persistence, http(s)'
+  s.description      = 'EXtended http(s) CONnections'
+  s.authors          = ['dpiddy (Dan Peterson)', 'geemus (Wesley Beary)', 'nextmat (Matt Sanders)']
   s.email            = 'geemus@gmail.com'
   s.homepage         = 'https://github.com/excon/excon'
   s.license          = 'MIT'
-  s.rdoc_options     = ["--charset=UTF-8"]
+  s.rdoc_options     = ['--charset=UTF-8']
   s.extra_rdoc_files = %w[README.md CONTRIBUTORS.md CONTRIBUTING.md]
   s.files            = `git ls-files -- data/* lib/*`.split("\n") + [
-    "CONTRIBUTING.md",
-    "CONTRIBUTORS.md",
-    "LICENSE.md",
-    "README.md",
-    "excon.gemspec"
+    'CONTRIBUTING.md',
+    'CONTRIBUTORS.md',
+    'LICENSE.md',
+    'README.md',
+    'excon.gemspec'
   ]
+  s.required_ruby_version = '>= 2.7.0'
+
+  s.add_dependency 'logger'
 
-  s.add_development_dependency('rspec', '>= 3.5.0')
   s.add_development_dependency('activesupport')
   s.add_development_dependency('delorean')
   s.add_development_dependency('eventmachine', '>= 1.0.4')
+  s.add_development_dependency('json', '>= 1.8.5')
   s.add_development_dependency('open4')
+  s.add_development_dependency('puma')
   s.add_development_dependency('rake')
+  s.add_development_dependency('rdoc')
+  s.add_development_dependency('rspec', '>= 3.5.0')
   s.add_development_dependency('shindo')
   s.add_development_dependency('sinatra')
   s.add_development_dependency('sinatra-contrib')
-  s.add_development_dependency('json', '>= 1.8.5')
-  s.add_development_dependency('puma')
   s.add_development_dependency('webrick')
 
   s.metadata = {
-    'homepage_uri'      => 'https://github.com/excon/excon',
-    'bug_tracker_uri'   => 'https://github.com/excon/excon/issues',
-    'changelog_uri'     => 'https://github.com/excon/excon/blob/master/changelog.txt',
+    'bug_tracker_uri' => 'https://github.com/excon/excon/issues',
+    'changelog_uri' => 'https://github.com/excon/excon/blob/master/changelog.txt',
     'documentation_uri' => 'https://github.com/excon/excon/blob/master/README.md',
-    'source_code_uri'   => 'https://github.com/excon/excon',
-    'wiki_uri'          => 'https://github.com/excon/excon/wiki'
+    'funding_uri' => 'https://github.com/sponsors/geemus',
+    'homepage_uri' => 'https://github.com/excon/excon',
+    'source_code_uri' => 'https://github.com/excon/excon',
+    'wiki_uri' => 'https://github.com/excon/excon/wiki'
   }
 end

data/lib/excon/connection.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require 'ipaddr'
 
 module Excon
   class Connection
@@ -139,7 +138,7 @@ module Excon
 
             # The HTTP spec isn't clear on it, but specifically, GET requests don't usually send bodies;
             # if they don't, sending Content-Length:0 can cause issues.
-            unless datum[:method].to_s.casecmp('GET') == 0 && body.nil?
+            unless datum[:method].to_s.casecmp?('GET') && body.nil?
               unless datum[:headers].has_key?('Content-Length')
                 datum[:headers]['Content-Length'] = detect_content_length(body)
               end
@@ -160,7 +159,7 @@ module Excon
               if chunk.length > 0
                 socket(datum).write(chunk.length.to_s(16) << CR_NL << chunk << CR_NL)
               else
-                socket(datum).write(String.new("0#{CR_NL}#{CR_NL}"))
+                socket(datum).write("0#{CR_NL}#{CR_NL}")
                 break
               end
             end
@@ -195,7 +194,7 @@ module Excon
           raise(error)
         when Errno::EPIPE
           # Read whatever remains in the pipe to aid in debugging
-          response = socket.read
+          response = socket.read rescue ""
           error = Excon::Error.new(response + error.message)
           raise_socket_error(error)
         else
@@ -230,6 +229,13 @@ module Excon
     def request(params={}, &block)
       # @data has defaults, merge in new params to override
       datum = @data.merge(params)
+
+      # Set the deadline for the current request in order to determine when we have run out of time.
+      # Only set when a request timeout has been defined.
+      if datum[:timeout]
+        datum[:deadline] = Process.clock_gettime(Process::CLOCK_MONOTONIC) + datum[:timeout]
+      end
+
       datum[:headers] = @data[:headers].merge(datum[:headers] || {})
 
       validate_params(:request, params, datum[:middlewares])
@@ -244,16 +250,17 @@ module Excon
         datum[:headers]['Authorization'] ||= 'Basic ' + ["#{user}:#{pass}"].pack('m').delete(Excon::CR_NL)
       end
 
+      host_key = datum[:headers].keys.detect {|k| k.casecmp?('Host') } || 'Host'
       if datum[:scheme] == UNIX
-        datum[:headers]['Host']   ||= ''
+        datum[:headers][host_key] ||= ''
       else
-        datum[:headers]['Host']   ||= datum[:host] + port_string(datum)
+        datum[:headers][host_key] ||= datum[:host] + port_string(datum)
       end
 
       # RFC 7230, section 5.4, states that the Host header SHOULD be the first one # to be present.
       # Some web servers will reject the request if it comes too late, so let's hoist it to the top.
-      if (host = datum[:headers].delete('Host'))
-        datum[:headers] = { 'Host' => host }.merge(datum[:headers])
+      if (host = datum[:headers].delete(host_key))
+        datum[:headers] = { host_key => host }.merge(datum[:headers])
       end
 
       # default to GET if no method specified
@@ -291,8 +298,8 @@ module Excon
         @persistent_socket_reusable = true
 
         if datum[:persistent]
-          if (key = datum[:response][:headers].keys.detect {|k| k.casecmp('Connection') == 0 })
-            if datum[:response][:headers][key].casecmp('close') == 0
+          if (key = datum[:response][:headers].keys.detect {|k| k.casecmp?('Connection') })
+            if datum[:response][:headers][key].casecmp?('close')
               reset
             end
           end
@@ -322,7 +329,7 @@ module Excon
     # @param pipeline_params [Array<Hash>] An array of one or more optional params, override defaults set in Connection.new, see #request for details
     def requests(pipeline_params)
       pipeline_params.each {|params| params.merge!(:pipeline => true, :persistent => true) }
-      pipeline_params.last.merge!(:persistent => @data[:persistent])
+      pipeline_params.last[:persistent] = @data[:persistent]
 
       responses = pipeline_params.map do |params|
         request(params)
@@ -331,8 +338,8 @@ module Excon
       end
 
       if @data[:persistent]
-        if (key = responses.last[:headers].keys.detect {|k| k.casecmp('Connection') == 0 })
-          if responses.last[:headers][key].casecmp('close') == 0
+        if (key = responses.last[:headers].keys.detect {|k| k.casecmp?('Connection') })
+          if responses.last[:headers][key].casecmp?('close')
             reset
           end
         end
@@ -439,6 +446,12 @@ module Excon
         raise ArgumentError.new("Invalid validation type '#{validation}'")
       end
 
+      if validation == :connection && params[:omit_default_port] != true
+        Excon.display_warning(
+          'The `omit_default_port` connection option is deprecated, please use `include_default_port` instead.'
+        )
+      end
+
       invalid_keys = params.keys - valid_keys
       unless invalid_keys.empty?
         Excon.display_warning("Invalid Excon #{validation} keys: #{invalid_keys.map(&:inspect).join(', ')}")
@@ -498,7 +511,7 @@ module Excon
     end
 
     def raise_socket_error(error)
-      if error.message =~ /certificate verify failed/
+      if error.message.include?('certificate verify failed')
         raise(Excon::Errors::CertificateError.new(error))
       else
         raise(Excon::Errors::SocketError.new(error))

data/lib/excon/constants.rb

@@ -1,32 +1,31 @@
 # frozen_string_literal: true
 module Excon
-
   CR_NL = "\r\n"
 
-  DEFAULT_CA_FILE = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "data", "cacert.pem"))
+  DEFAULT_CA_FILE = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data', 'cacert.pem'))
 
-  DEFAULT_CHUNK_SIZE = 1048576 # 1 megabyte
+  DEFAULT_CHUNK_SIZE = 1_048_576 # 1 megabyte
 
   # avoid overwrite if somebody has redefined
-  unless const_defined?(:CHUNK_SIZE)
-    CHUNK_SIZE = DEFAULT_CHUNK_SIZE
-  end
+  CHUNK_SIZE = DEFAULT_CHUNK_SIZE unless const_defined?(:CHUNK_SIZE)
 
   DEFAULT_REDIRECT_LIMIT = 10
 
   DEFAULT_RETRY_LIMIT = 4
 
   DEFAULT_RETRY_ERRORS = [
-    Excon::Error::Timeout,
+    Excon::Error::RequestTimeout,
+    Excon::Error::Server,
     Excon::Error::Socket,
-    Excon::Error::HTTPStatus
-  ]
+    Excon::Error::Timeout,
+    Excon::Error::TooManyRequests
+  ].freeze
 
   FORCE_ENC = CR_NL.respond_to?(:force_encoding)
 
   HTTP_1_1 = " HTTP/1.1\r\n"
 
-  HTTP_VERBS = %w{connect delete get head options patch post put trace}
+  HTTP_VERBS = %w[connect delete get head options patch post put trace].freeze
 
   HTTPS = 'https'
 
@@ -40,86 +39,91 @@ module Excon
 
   VERSIONS = "#{USER_AGENT} (#{RUBY_PLATFORM}) ruby/#{RUBY_VERSION}"
 
-  VALID_REQUEST_KEYS = [
-    :allow_unstubbed_requests,
-    :body,
-    :chunk_size,
-    :debug_request,
-    :debug_response,
-    :headers,
-    :instrumentor, # Used for setting logging within Connection
-    :logger,
-    :method,
-    :middlewares,
-    :password,
-    :path,
-    :persistent,
-    :pipeline,
-    :query,
-    :read_timeout,
-    :request_block,
-    :response_block,
-    :stubs,
-    :user,
-    :versions,
-    :write_timeout
-  ]
-
-  VALID_CONNECTION_KEYS = VALID_REQUEST_KEYS + [
-    :ciphers,
-    :client_key,
-    :client_key_data,
-    :client_key_pass,
-    :client_cert,
-    :client_cert_data,
-    :client_chain,
-    :client_chain_data,
-    :certificate,
-    :certificate_path,
-    :disable_proxy,
-    :private_key,
-    :private_key_path,
-    :connect_timeout,
-    :family,
-    :keepalive,
-    :host,
-    :hostname,
-    :omit_default_port,
-    :nonblock,
-    :reuseaddr,
-    :port,
-    :proxy,
-    :scheme,
-    :socket,
-    :ssl_ca_file,
-    :ssl_ca_path,
-    :ssl_cert_store,
-    :ssl_verify_callback,
-    :ssl_verify_peer,
-    :ssl_verify_peer_host,
-    :ssl_verify_hostname,
-    :ssl_version,
-    :ssl_min_version,
-    :ssl_max_version,
-    :ssl_security_level,
-    :ssl_proxy_headers,
-    :ssl_uri_schemes,
-    :tcp_nodelay,
-    :thread_safe_sockets,
-    :uri_parser,
+  VALID_REQUEST_KEYS = %i[
+    allow_unstubbed_requests
+    body
+    chunk_size
+    debug_request
+    debug_response
+    dns_timeouts
+    headers
+    instrumentor
+    logger
+    method
+    middlewares
+    password
+    path
+    persistent
+    pipeline
+    query
+    read_timeout
+    request_block
+    resolv_resolver
+    response_block
+    stubs
+    timeout
+    user
+    versions
+    write_timeout
+  ].freeze
+
+  VALID_CONNECTION_KEYS = VALID_REQUEST_KEYS + %i[
+    ciphers
+    client_key
+    client_key_data
+    client_key_pass
+    client_cert
+    client_cert_data
+    client_chain
+    client_chain_data
+    certificate
+    certificate_path
+    disable_proxy
+    private_key
+    private_key_path
+    connect_timeout
+    family
+    keepalive
+    host
+    hostname
+    ignore_unexpected_eof
+    include_default_port
+    omit_default_port
+    nonblock
+    reuseaddr
+    port
+    proxy
+    scheme
+    socket
+    ssl_ca_file
+    ssl_ca_path
+    ssl_cert_store
+    ssl_verify_callback
+    ssl_verify_peer
+    ssl_verify_peer_host
+    ssl_verify_hostname
+    ssl_version
+    ssl_min_version
+    ssl_max_version
+    ssl_security_level
+    ssl_proxy_headers
+    ssl_uri_schemes
+    tcp_nodelay
+    thread_safe_sockets
+    uri_parser
   ]
 
   DEPRECATED_VALID_REQUEST_KEYS = {
-    :captures => 'Mock',
-    :expects => 'Expects',
-    :idempotent => 'Idempotent',
-    :instrumentor_name => 'Instrumentor',
-    :mock => 'Mock',
-    :retries_remaining => 'Idempotent', # referenced in Instrumentor, but only relevant with Idempotent
-    :retry_errors => 'Idempotent',
-    :retry_interval => 'Idempotent',
-    :retry_limit => 'Idempotent' # referenced in Instrumentor, but only relevant with Idempotent
-  }
+    captures: 'Mock',
+    expects: 'Expects',
+    idempotent: 'Idempotent',
+    instrumentor_name: 'Instrumentor',
+    mock: 'Mock',
+    retries_remaining: 'Idempotent', # referenced in Instrumentor, but only relevant with Idempotent
+    retry_errors: 'Idempotent',
+    retry_interval: 'Idempotent',
+    retry_limit: 'Idempotent' # referenced in Instrumentor, but only relevant with Idempotent
+  }.freeze
 
   unless ::IO.const_defined?(:WaitReadable)
     class ::IO
@@ -132,43 +136,48 @@ module Excon
       module WaitWritable; end
     end
   end
+
   # these come last as they rely on the above
   DEFAULTS = {
-    :chunk_size           => CHUNK_SIZE || DEFAULT_CHUNK_SIZE,
+    chunk_size: CHUNK_SIZE || DEFAULT_CHUNK_SIZE,
     # see https://wiki.mozilla.org/Security/Server_Side_TLS#Intermediate_compatibility_.28default.29
     # list provided then had DES related things sorted to the end
-    :ciphers              => 'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:ECDHE-ECDSA-DES-CBC3-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:DES-CBC3-SHA:!DSS',
-    :connect_timeout      => 60,
-    :debug_request        => false,
-    :debug_response       => false,
-    :headers              => {
+    ciphers: 'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:ECDHE-ECDSA-DES-CBC3-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:DES-CBC3-SHA:!DSS',
+    connect_timeout: 60,
+    debug_request: false,
+    debug_response: false,
+    dns_timeouts: nil, # nil allows Resolv::DNS default timeout value (see https://ruby-doc.org/3.2.2/stdlibs/resolv/Resolv/DNS.html#method-i-timeouts-3D)
+    headers: {
       'User-Agent' => USER_AGENT,
-      'Accept'     =>  '*/*'
+      'Accept' => '*/*'
     },
-    :idempotent           => false,
-    :instrumentor_name    => 'excon',
-    :middlewares          => [
+    idempotent: false,
+    instrumentor_name: 'excon',
+    middlewares: [
       Excon::Middleware::ResponseParser,
+      Excon::Middleware::Decompress,
       Excon::Middleware::Expects,
       Excon::Middleware::Idempotent,
       Excon::Middleware::Instrumentor,
       Excon::Middleware::Mock
     ],
-    :mock                 => false,
-    :nonblock             => true,
-    :omit_default_port    => false,
-    :persistent           => false,
-    :read_timeout         => 60,
-    :retry_errors         => DEFAULT_RETRY_ERRORS,
-    :retry_limit          => DEFAULT_RETRY_LIMIT,
-    :ssl_verify_peer      => true,
-    :ssl_uri_schemes      => [HTTPS],
-    :stubs                => :global,
-    :tcp_nodelay          => false,
-    :thread_safe_sockets  => true,
-    :uri_parser           => URI,
-    :versions             => VERSIONS,
-    :write_timeout        => 60
+    mock: false,
+    include_default_port: false,
+    nonblock: true,
+    omit_default_port: true,
+    persistent: false,
+    read_timeout: 60,
+    resolv_resolver: nil,
+    retry_errors: DEFAULT_RETRY_ERRORS,
+    retry_limit: DEFAULT_RETRY_LIMIT,
+    ssl_verify_peer: true,
+    ssl_uri_schemes: [HTTPS],
+    stubs: :global,
+    tcp_nodelay: false,
+    thread_safe_sockets: true,
+    timeout: nil,
+    uri_parser: URI,
+    versions: VERSIONS,
+    write_timeout: 60
   }
-
 end

data/lib/excon/error.rb

@@ -216,8 +216,8 @@ or:
 
     klasses.each do |klass|
       class_name = klass.to_s
-      unless class_name =~ /Error\Z/
-        class_name = klass.to_s + 'Error' if class_name =~ legacy_re
+      unless class_name.match?(/Error\Z/)
+        class_name = klass.to_s + 'Error' if class_name.match?(legacy_re)
       end
       Excon::Errors.const_set(class_name, Excon::Error.const_get(klass))
     end

data/lib/excon/middlewares/capture_cookies.rb

@@ -9,7 +9,7 @@ module Excon
 
       def get_header(datum, header)
         _, header_value = datum[:response][:headers].detect do |key, _|
-          key.casecmp(header) == 0
+          key.casecmp?(header)
         end
         header_value
       end

data/lib/excon/middlewares/decompress.rb

@@ -1,41 +1,36 @@
 # frozen_string_literal: true
+
 module Excon
   module Middleware
     class Decompress < Excon::Middleware::Base
-
       INFLATE_ZLIB_OR_GZIP  = 47 # Zlib::MAX_WBITS + 32
       INFLATE_RAW           = -15 # Zlib::MAX_WBITS * -1
 
       def request_call(datum)
-        unless datum.has_key?(:response_block)
-          key = datum[:headers].keys.detect {|k| k.to_s.casecmp('Accept-Encoding') == 0 } || 'Accept-Encoding'
-          if datum[:headers][key].to_s.empty?
-            datum[:headers][key] = 'deflate, gzip'
-          end
+        unless datum.key?(:response_block)
+          key = datum[:headers].keys.detect { |k| k.to_s.casecmp?('Accept-Encoding') } || 'Accept-Encoding'
+          datum[:headers][key] = 'deflate, gzip' if datum[:headers][key].to_s.empty?
         end
         @stack.request_call(datum)
       end
 
       def response_call(datum)
         body = datum[:response][:body]
-        unless datum.has_key?(:response_block) || body.nil? || body.empty?
-          if (key = datum[:response][:headers].keys.detect {|k| k.casecmp('Content-Encoding') == 0 })
-            encodings = Utils.split_header_value(datum[:response][:headers][key])
-            if (encoding = encodings.last)
-              if encoding.casecmp('deflate') == 0
-                datum[:response][:body] = begin
-                  Zlib::Inflate.new(INFLATE_ZLIB_OR_GZIP).inflate(body)
-                rescue Zlib::DataError # fallback to raw on error
-                  Zlib::Inflate.new(INFLATE_RAW).inflate(body)
-                end
-                encodings.pop
-              elsif encoding.casecmp('gzip') == 0 || encoding.casecmp('x-gzip') == 0
-                datum[:response][:body] = Zlib::GzipReader.new(StringIO.new(body)).read
-                encodings.pop
-              end
-              datum[:response][:headers][key] = encodings.join(', ')
+        if !(datum.key?(:response_block) || body.nil? || body.empty?) &&
+           (key = datum[:response][:headers].keys.detect { |k| k.casecmp?('Content-Encoding') })
+          encodings = Utils.split_header_value(datum[:response][:headers][key])
+          if encodings&.last&.casecmp?('deflate')
+            datum[:response][:body] = begin
+              Zlib::Inflate.new(INFLATE_ZLIB_OR_GZIP).inflate(body)
+            rescue Zlib::DataError # fallback to raw on error
+              Zlib::Inflate.new(INFLATE_RAW).inflate(body)
             end
+            encodings.pop
+          elsif encodings&.last&.casecmp?('gzip') || encodings&.last&.casecmp?('x-gzip')
+            datum[:response][:body] = Zlib::GzipReader.new(StringIO.new(body)).read
+            encodings.pop
           end
+          datum[:response][:headers][key] = encodings.join(', ')
         end
         @stack.response_call(datum)
       end

data/lib/excon/middlewares/redirect_follower.rb

@@ -17,7 +17,7 @@ module Excon
 
       def get_header(datum, header)
         _, header_value = datum[:response][:headers].detect do |key, _|
-          key.casecmp(header) == 0
+          key.casecmp?(header)
         end
         header_value
       end
@@ -67,8 +67,8 @@ module Excon
               :query      => uri.query
             )
 
-            params.merge!(:user => Utils.unescape_uri(uri.user)) if uri.user
-            params.merge!(:password => Utils.unescape_uri(uri.password)) if uri.password
+            params[:user] = Utils.unescape_uri(uri.user) if uri.user
+            params[:password] = Utils.unescape_uri(uri.password) if uri.password
 
             response = Excon::Connection.new(params).request
             datum.merge!({

data/lib/excon/response.rb

@@ -106,9 +106,9 @@ module Excon
 
       unless (['HEAD', 'CONNECT'].include?(datum[:method].to_s.upcase)) || NO_ENTITY.include?(datum[:response][:status])
 
-        if (key = datum[:response][:headers].keys.detect {|k| k.casecmp('Transfer-Encoding') == 0 })
+        if (key = datum[:response][:headers].keys.detect {|k| k.casecmp?('Transfer-Encoding') })
           encodings = Utils.split_header_value(datum[:response][:headers][key])
-          if (encoding = encodings.last) && encoding.casecmp('chunked') == 0
+          if (encoding = encodings.last) && encoding.casecmp?('chunked')
             transfer_encoding_chunked = true
             if encodings.length == 1
               datum[:response][:headers].delete(key)
@@ -156,7 +156,7 @@ module Excon
           end
           parse_headers(socket, datum) # merge trailers into headers
         else
-          if (key = datum[:response][:headers].keys.detect {|k| k.casecmp('Content-Length') == 0 })
+          if (key = datum[:response][:headers].keys.detect {|k| k.casecmp?('Content-Length') })
             content_length = datum[:response][:headers][key].to_i
           end
 
@@ -202,7 +202,7 @@ module Excon
           raise Excon::Error::ResponseParse, 'malformed header' unless value
           # add key/value or append value to existing values
           datum[:response][:headers][key] = ([datum[:response][:headers][key]] << value.strip).compact.join(', ')
-          if key.casecmp('Set-Cookie') == 0
+          if key.casecmp?('Set-Cookie')
             datum[:response][:cookies] << value.strip
           end
           last_key = key