excon 0.75.0 → 0.80.0

data/excon.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.license          = 'MIT'
   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") + [
+  s.files            = `git ls-files -- data/* lib/*`.split("\n") + [
     "CONTRIBUTING.md",
     "CONTRIBUTORS.md",
     "LICENSE.md",
@@ -31,6 +31,7 @@ Gem::Specification.new do |s|
   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',

data/lib/excon.rb

@@ -146,10 +146,10 @@ module Excon
     # @param request_params [Hash<Symbol, >] request params to match against, omitted params match all
     # @param response_params [Hash<Symbol, >] response params to return from matched request or block to call with params
     def stub(request_params = {}, response_params = nil, &block)
-      if method = request_params.delete(:method)
+      if (method = request_params.delete(:method))
         request_params[:method] = method.to_s.downcase.to_sym
       end
-      if url = request_params.delete(:url)
+      if (url = request_params.delete(:url))
         uri = URI.parse(url)
         request_params = {
           :host              => uri.host,
@@ -190,7 +190,7 @@ module Excon
     # @param request_params [Hash<Symbol, >] request params to match against, omitted params match all
     # @return [Hash<Symbol, >] response params to return from matched request or block to call with params
     def stub_for(request_params={})
-      if method = request_params.delete(:method)
+      if (method = request_params.delete(:method))
         request_params[:method] = method.to_s.downcase.to_sym
       end
       Excon.stubs.each do |stub, response_params|
@@ -198,7 +198,7 @@ module Excon
         headers_match = !stub.has_key?(:headers) || stub[:headers].keys.all? do |key|
           case value = stub[:headers][key]
           when Regexp
-            if match = value.match(request_params[:headers][key])
+            if (match = value.match(request_params[:headers][key]))
               captures[:headers][key] = match.captures
             end
             match
@@ -209,7 +209,7 @@ module Excon
         non_headers_match = (stub.keys - [:headers]).all? do |key|
           case value = stub[key]
           when Regexp
-            if match = value.match(request_params[key])
+            if (match = value.match(request_params[key]))
               captures[key] = match.captures
             end
             match

data/lib/excon/connection.rb

@@ -79,7 +79,7 @@ module Excon
 
       setup_proxy
 
-      if  ENV.has_key?('EXCON_STANDARD_INSTRUMENTOR')
+      if ENV.has_key?('EXCON_STANDARD_INSTRUMENTOR')
         @data[:instrumentor] = Excon::StandardInstrumentor
       end
 
@@ -191,7 +191,7 @@ module Excon
               socket.write(request) # write out request + headers
             end
 
-            while chunk = body.read(datum[:chunk_size])
+            while (chunk = body.read(datum[:chunk_size]))
               socket.write(chunk)
             end
           end
@@ -252,6 +252,12 @@ module Excon
         datum[:headers]['Host']   ||= 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])
+      end
+
       # if path is empty or doesn't start with '/', insert one
       unless datum[:path][0, 1] == '/'
         datum[:path] = datum[:path].dup.insert(0, '/')
@@ -282,7 +288,7 @@ module Excon
         @persistent_socket_reusable = true
 
         if datum[:persistent]
-          if key = datum[:response][:headers].keys.detect {|k| k.casecmp('Connection') == 0 }
+          if (key = datum[:response][:headers].keys.detect {|k| k.casecmp('Connection') == 0 })
             if datum[:response][:headers][key].casecmp('close') == 0
               reset
             end
@@ -322,7 +328,7 @@ module Excon
       end
 
       if @data[:persistent]
-        if key = responses.last[:headers].keys.detect {|k| k.casecmp('Connection') == 0 }
+        if (key = responses.last[:headers].keys.detect {|k| k.casecmp('Connection') == 0 })
           if responses.last[:headers][key].casecmp('close') == 0
             reset
           end
@@ -350,7 +356,7 @@ module Excon
     end
 
     def reset
-      if old_socket = sockets.delete(@socket_key)
+      if (old_socket = sockets.delete(@socket_key))
         old_socket.close rescue nil
       end
       @persistent_socket_reusable = true
@@ -470,13 +476,14 @@ module Excon
 
     def sockets
       @_excon_sockets ||= {}
+      @_excon_sockets.compare_by_identity
 
       if @data[:thread_safe_sockets]
         # In a multi-threaded world, if the same connection is used by multiple
         # threads at the same time to connect to the same destination, they may
         # stomp on each other's sockets.  This ensures every thread gets their
         # own socket cache, within the context of a single connection.
-        @_excon_sockets[Thread.current.object_id] ||= {}
+        @_excon_sockets[Thread.current] ||= {}
       else
         @_excon_sockets
       end

data/lib/excon/constants.rb

@@ -95,6 +95,7 @@ module Excon
     :ssl_verify_callback,
     :ssl_verify_peer,
     :ssl_verify_peer_host,
+    :ssl_verify_hostname,
     :ssl_version,
     :ssl_min_version,
     :ssl_max_version,

data/lib/excon/headers.rb

@@ -22,6 +22,7 @@ module Excon
     alias_method :raw_values_at, :values_at
 
     def initialize
+      super
       @downcased = {}
     end
 
@@ -29,11 +30,11 @@ module Excon
       @downcased[key.to_s.downcase]
     end
 
-    alias_method :[]=, :store
     def []=(key, value)
       raw_writer(key, value)
       @downcased[key.to_s.downcase] = value
     end
+    alias_method :store, :[]=
 
     if SENTINEL.respond_to? :assoc
       def assoc(obj)
@@ -54,11 +55,11 @@ module Excon
       end
     end
 
-    alias_method :has_key?, :key?
-    alias_method :has_key?, :member?
     def has_key?(key)
       raw_key?(key) || @downcased.has_key?(key.to_s.downcase)
     end
+    alias_method :key?, :has_key?
+    alias_method :member?, :has_key?
 
     def merge(other_hash)
       self.dup.merge!(other_hash)

data/lib/excon/instrumentors/logging_instrumentor.rb

@@ -3,7 +3,7 @@ require 'logger'
 module Excon
   class LoggingInstrumentor
 
-    def self.instrument(name, params = {}, &block)
+    def self.instrument(name, params = {})
       params = params.dup
 
       logger = params[:logger] || Logger.new($stderr)

data/lib/excon/instrumentors/standard_instrumentor.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module Excon
   class StandardInstrumentor
-    def self.instrument(name, params = {}, &block)
+    def self.instrument(name, params = {})
       params = params.dup
 
       # reduce duplication/noise of output

data/lib/excon/middlewares/capture_cookies.rb

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

data/lib/excon/middlewares/decompress.rb

@@ -15,9 +15,9 @@ module Excon
       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 }
+          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 = encodings.last)
               if encoding.casecmp('deflate') == 0
                 # assume inflate omits header
                 datum[:response][:body] = Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(body)

data/lib/excon/middlewares/expects.rb

@@ -12,7 +12,7 @@ module Excon
         if datum.has_key?(:expects) && ![*datum[:expects]].include?(datum[:response][:status])
           raise(
             Excon::Errors.status_error(
-              datum.reject {|key,value| key == :response},
+              datum.reject {|key,_| key == :response},
               Excon::Response.new(datum[:response])
             )
           )

data/lib/excon/middlewares/mock.rb

@@ -25,7 +25,7 @@ module Excon
             raise Excon::Errors::InvalidStub.new("Request body should be a string or an IO object. #{datum[:body].class} provided")
           end
 
-          if stub = Excon.stub_for(datum)
+          if (stub = Excon.stub_for(datum))
             datum[:remote_ip] ||= '127.0.0.1'
             datum[:response] = {
               :body       => '',
@@ -41,7 +41,7 @@ module Excon
               stub.last
             end
 
-            datum[:response].merge!(stub_datum.reject {|key,value| key == :headers})
+            datum[:response].merge!(stub_datum.reject {|key,_| key == :headers})
             if stub_datum.has_key?(:headers)
               datum[:response][:headers].merge!(stub_datum[:headers])
             end

data/lib/excon/middlewares/redirect_follower.rb

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

data/lib/excon/response.rb

@@ -59,10 +59,13 @@ module Excon
 
     def self.parse(socket, datum)
       # this will discard any trailing lines from the previous response if any.
-      begin
+      line = nil
+      loop do
         line = socket.readline
-      end until status = line[9, 3].to_i
+        break if line[9,3].to_i != 0
+      end
 
+      status = line[9, 3].to_i
       reason_phrase = line[13..-3] # -3 strips the trailing "\r\n"
 
       datum[:response] = {
@@ -90,7 +93,7 @@ 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') == 0 })
           encodings = Utils.split_header_value(datum[:response][:headers][key])
           if (encoding = encodings.last) && encoding.casecmp('chunked') == 0
             transfer_encoding_chunked = true
@@ -103,7 +106,7 @@ module Excon
         end
 
         # use :response_block unless :expects would fail
-        if response_block = datum[:response_block]
+        if (response_block = datum[:response_block])
           if datum[:middlewares].include?(Excon::Middleware::Expects) && datum[:expects] &&
                                 !Array(datum[:expects]).include?(datum[:response][:status])
             response_block = nil
@@ -140,11 +143,11 @@ 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') == 0 })
             content_length = datum[:response][:headers][key].to_i
           end
 
-          if remaining = content_length
+          if (remaining = content_length)
             if response_block
               while remaining > 0
                 chunk = socket.read([datum[:chunk_size], remaining].min) || raise(EOFError)
@@ -160,11 +163,11 @@ module Excon
             end
           else
             if response_block
-              while chunk = socket.read(datum[:chunk_size])
+              while (chunk = socket.read(datum[:chunk_size]))
                 response_block.call(chunk, nil, nil)
               end
             else
-              while chunk = socket.read(datum[:chunk_size])
+              while (chunk = socket.read(datum[:chunk_size]))
                 datum[:response][:body] << chunk
               end
             end

data/lib/excon/socket.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require 'resolv'
+
 module Excon
   class Socket
     include Utils
@@ -60,18 +62,8 @@ module Excon
     def readline
       return legacy_readline if RUBY_VERSION.to_f <= 1.8_7
       buffer = String.new
-      begin
-        buffer << @socket.read_nonblock(1) while buffer[-1] != "\n"
-        buffer
-      rescue *READ_RETRY_EXCEPTION_CLASSES
-        select_with_timeout(@socket, :read) && retry
-      rescue OpenSSL::SSL::SSLError => error
-        if error.message == 'read would block'
-          select_with_timeout(@socket, :read) && retry
-        else
-          raise(error)
-        end
-      end
+      buffer << (read_nonblock(1) || raise(EOFError)) while buffer[-1] != "\n"
+      buffer
     end
 
     def legacy_readline
@@ -105,20 +97,17 @@ module Excon
     def connect
       @socket = nil
       exception = nil
+      hostname = @data[:hostname]
+      port = @port
+      family = @data[:family]
 
       if @data[:proxy]
-        family = @data[:proxy][:family] || ::Socket::Constants::AF_UNSPEC
-        args = [@data[:proxy][:hostname], @data[:proxy][:port], family, ::Socket::Constants::SOCK_STREAM]
-      else
-        family = @data[:family] || ::Socket::Constants::AF_UNSPEC
-        args = [@data[:hostname], @port, family, ::Socket::Constants::SOCK_STREAM]
+        hostname = @data[:proxy][:hostname]
+        port = @data[:proxy][:port]
+        family = @data[:proxy][:family]
       end
-      if RUBY_VERSION >= '1.9.2' && defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
-        args << nil << nil << false # no reverse lookup
-      end
-      addrinfo = ::Socket.getaddrinfo(*args)
 
-      addrinfo.each do |_, port, _, ip, a_family, s_type|
+      Resolv.each_address(hostname) do |ip|
         # already succeeded on previous addrinfo
         if @socket
           break
@@ -130,8 +119,8 @@ module Excon
         # nonblocking connect
         begin
           sockaddr = ::Socket.sockaddr_in(port, ip)
-
-          socket = ::Socket.new(a_family, s_type, 0)
+          addrinfo = Addrinfo.getaddrinfo(ip, port, family, :STREAM).first
+          socket = ::Socket.new(addrinfo.pfamily, addrinfo.socktype, addrinfo.protocol)
 
           if @data[:reuseaddr]
             socket.setsockopt(::Socket::Constants::SOL_SOCKET, ::Socket::Constants::SO_REUSEADDR, true)
@@ -161,6 +150,8 @@ module Excon
         end
       end
 
+      exception ||= Resolv::ResolvError.new("no address for #{hostname}")
+
       # this will be our last encountered exception
       fail exception unless @socket
 

data/lib/excon/ssl_socket.rb

@@ -39,13 +39,13 @@ module Excon
         # turn verification on
         ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
 
-        if ca_file = @data[:ssl_ca_file] || ENV['SSL_CERT_FILE']
+        if (ca_file = @data[:ssl_ca_file] || ENV['SSL_CERT_FILE'])
           ssl_context.ca_file = ca_file
         end
-        if ca_path = @data[:ssl_ca_path] || ENV['SSL_CERT_DIR']
+        if (ca_path = @data[:ssl_ca_path] || ENV['SSL_CERT_DIR'])
           ssl_context.ca_path = ca_path
         end
-        if cert_store = @data[:ssl_cert_store]
+        if (cert_store = @data[:ssl_cert_store])
           ssl_context.cert_store = cert_store
         end
 
@@ -65,7 +65,7 @@ module Excon
           end
         end
 
-        if verify_callback = @data[:ssl_verify_callback]
+        if (verify_callback = @data[:ssl_verify_callback])
           ssl_context.verify_callback = verify_callback
         end
       else
@@ -73,6 +73,9 @@ module Excon
         ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
       end
 
+      # Verify certificate hostname if supported (ruby >= 2.4.0)
+      ssl_context.verify_hostname = @data[:ssl_verify_hostname] if ssl_context.respond_to?(:verify_hostname=)
+
       if client_cert_data && client_key_data
         ssl_context.cert = OpenSSL::X509::Certificate.new client_cert_data
         if OpenSSL::PKey.respond_to? :read
@@ -142,18 +145,16 @@ module Excon
       if @data[:ssl_verify_peer]
         @socket.post_connection_check(@data[:ssl_verify_peer_host] || @data[:host])
       end
-
-      @socket
     end
 
     private
 
     def client_cert_data
-      @client_cert_data ||= if ccd = @data[:client_cert_data]
+      @client_cert_data ||= if (ccd = @data[:client_cert_data])
                               ccd
-                            elsif path = @data[:client_cert]
+                            elsif (path = @data[:client_cert])
                               File.read path
-                            elsif path = @data[:certificate_path]
+                            elsif (path = @data[:certificate_path])
                               warn ":certificate_path is no longer supported and will be deprecated. Please use :client_cert or :client_cert_data"
                               File.read path
                             end
@@ -166,11 +167,11 @@ module Excon
     end
 
     def client_key_data
-      @client_key_data ||= if ckd = @data[:client_key_data]
+      @client_key_data ||= if (ckd = @data[:client_key_data])
                              ckd
-                           elsif path = @data[:client_key]
+                           elsif (path = @data[:client_key])
                              File.read path
-                           elsif path = @data[:private_key_path]
+                           elsif (path = @data[:private_key_path])
                              warn ":private_key_path is no longer supported and will be deprecated. Please use :client_key or :client_key_data"
                              File.read path
                            end