coingecko_client 0.1.0

data/vendor/bundle/ruby/2.7.0/gems/excon-0.75.0/excon.gemspec

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), 'lib', '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.email            = 'geemus@gmail.com'
+  s.homepage         = 'https://github.com/excon/excon'
+  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") + [
+    "CONTRIBUTING.md",
+    "CONTRIBUTORS.md",
+    "LICENSE.md",
+    "README.md",
+    "excon.gemspec"
+  ]
+
+  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('open4')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rdoc')
+  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.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',
+    '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'
+  }
+end

data/vendor/bundle/ruby/2.7.0/gems/excon-0.75.0/lib/excon.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'cgi'
+require 'forwardable'
+require 'openssl'
+require 'rbconfig'
+require 'socket'
+require 'timeout'
+require 'uri'
+require 'zlib'
+require 'stringio'
+
+require 'excon/version'
+
+require 'excon/extensions/uri'
+
+require 'excon/middlewares/base'
+require 'excon/middlewares/expects'
+require 'excon/middlewares/idempotent'
+require 'excon/middlewares/instrumentor'
+require 'excon/middlewares/mock'
+require 'excon/middlewares/response_parser'
+
+require 'excon/error'
+require 'excon/constants'
+require 'excon/utils'
+
+require 'excon/connection'
+require 'excon/headers'
+require 'excon/response'
+require 'excon/middlewares/decompress'
+require 'excon/middlewares/escape_path'
+require 'excon/middlewares/redirect_follower'
+require 'excon/middlewares/capture_cookies'
+require 'excon/pretty_printer'
+require 'excon/socket'
+require 'excon/ssl_socket'
+require 'excon/instrumentors/standard_instrumentor'
+require 'excon/instrumentors/logging_instrumentor'
+require 'excon/unix_socket'
+
+# Define defaults first so they will be available to other files
+module Excon
+  class << self
+
+    # @return [Hash] defaults for Excon connections
+    def defaults
+      @defaults ||= DEFAULTS
+    end
+
+    # Change defaults for Excon connections
+    # @return [Hash] defaults for Excon connections
+    def defaults=(new_defaults)
+      @defaults = new_defaults
+    end
+
+    def display_warning(warning)
+      # Show warning if $VERBOSE or ENV['EXCON_DEBUG'] is set
+      if $VERBOSE || ENV['EXCON_DEBUG']
+        $stderr.puts "[excon][WARNING] #{warning}\n#{ caller.join("\n") }"
+      end
+
+      if @raise_on_warnings
+        raise Error::Warning.new(warning)
+      end
+    end
+
+    def set_raise_on_warnings!(should_raise)
+      @raise_on_warnings = should_raise
+    end
+
+    # Status of mocking
+    def mock
+      display_warning('Excon#mock is deprecated, use Excon.defaults[:mock] instead.')
+      self.defaults[:mock]
+    end
+
+    # Change the status of mocking
+    # false is the default and works as expected
+    # true returns a value from stubs or raises
+    def mock=(new_mock)
+      display_warning('Excon#mock is deprecated, use Excon.defaults[:mock]= instead.')
+      self.defaults[:mock] = new_mock
+    end
+
+    # @return [String] The filesystem path to the SSL Certificate Authority
+    def ssl_ca_path
+      display_warning('Excon#ssl_ca_path is deprecated, use Excon.defaults[:ssl_ca_path] instead.')
+      self.defaults[:ssl_ca_path]
+    end
+
+    # Change path to the SSL Certificate Authority
+    # @return [String] The filesystem path to the SSL Certificate Authority
+    def ssl_ca_path=(new_ssl_ca_path)
+      display_warning('Excon#ssl_ca_path= is deprecated, use Excon.defaults[:ssl_ca_path]= instead.')
+      self.defaults[:ssl_ca_path] = new_ssl_ca_path
+    end
+
+    # @return [true, false] Whether or not to verify the peer's SSL certificate / chain
+    def ssl_verify_peer
+      display_warning('Excon#ssl_verify_peer is deprecated, use Excon.defaults[:ssl_verify_peer] instead.')
+      self.defaults[:ssl_verify_peer]
+    end
+
+    # Change the status of ssl peer verification
+    # @see Excon#ssl_verify_peer (attr_reader)
+    def ssl_verify_peer=(new_ssl_verify_peer)
+      display_warning('Excon#ssl_verify_peer= is deprecated, use Excon.defaults[:ssl_verify_peer]= instead.')
+      self.defaults[:ssl_verify_peer] = new_ssl_verify_peer
+    end
+
+    # @see Connection#initialize
+    # Initializes a new keep-alive session for a given remote host
+    # @param [String] url The destination URL
+    # @param [Hash<Symbol, >] params One or more option params to set on the Connection instance
+    # @return [Connection] A new Excon::Connection instance
+    def new(url, params = {})
+      uri_parser = params[:uri_parser] || defaults[:uri_parser]
+      uri = uri_parser.parse(url)
+      if params[:path]
+        uri_parser.parse(params[:path])
+      end
+      unless uri.scheme
+        raise ArgumentError.new("Invalid URI: #{uri}")
+      end
+      params = {
+        :host       => uri.host,
+        :hostname   => uri.hostname,
+        :path       => uri.path,
+        :port       => uri.port,
+        :query      => uri.query,
+        :scheme     => uri.scheme
+      }.merge(params)
+      if uri.password
+        params[:password] = Utils.unescape_uri(uri.password)
+      end
+      if uri.user
+        params[:user] = Utils.unescape_uri(uri.user)
+      end
+      Excon::Connection.new(params)
+    end
+
+    # push an additional stub onto the list to check for mock requests
+    # @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)
+        request_params[:method] = method.to_s.downcase.to_sym
+      end
+      if url = request_params.delete(:url)
+        uri = URI.parse(url)
+        request_params = {
+          :host              => uri.host,
+          :path              => uri.path,
+          :port              => uri.port,
+          :query             => uri.query,
+          :scheme            => uri.scheme
+        }.merge!(request_params)
+        if uri.user || uri.password
+          request_params[:headers] ||= {}
+          user, pass = Utils.unescape_form(uri.user.to_s), Utils.unescape_form(uri.password.to_s)
+          request_params[:headers]['Authorization'] ||= 'Basic ' + ["#{user}:#{pass}"].pack('m').delete(Excon::CR_NL)
+        end
+      end
+      if request_params.has_key?(:headers)
+        headers = Excon::Headers.new
+        request_params[:headers].each do |key, value|
+          headers[key] = value
+        end
+        request_params[:headers] = headers
+      end
+      if block_given?
+        if response_params
+          raise(ArgumentError.new("stub requires either response_params OR a block"))
+        else
+          stub = [request_params, block]
+        end
+      elsif response_params
+        stub = [request_params, response_params]
+      else
+        raise(ArgumentError.new("stub requires either response_params OR a block"))
+      end
+      stubs.unshift(stub)
+      stub
+    end
+
+    # get a stub matching params or nil
+    # @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)
+        request_params[:method] = method.to_s.downcase.to_sym
+      end
+      Excon.stubs.each do |stub, response_params|
+        captures = { :headers => {} }
+        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])
+              captures[:headers][key] = match.captures
+            end
+            match
+          else
+            value == request_params[:headers][key]
+          end
+        end
+        non_headers_match = (stub.keys - [:headers]).all? do |key|
+          case value = stub[key]
+          when Regexp
+            if match = value.match(request_params[key])
+              captures[key] = match.captures
+            end
+            match
+          else
+            value == request_params[key]
+          end
+        end
+        if headers_match && non_headers_match
+          request_params[:captures] = captures
+          return [stub, response_params]
+        end
+      end
+      nil
+    end
+
+    # get a list of defined stubs
+    def stubs
+      case Excon.defaults[:stubs]
+      when :global
+        @stubs ||= []
+      when :local
+        Thread.current[:_excon_stubs] ||= []
+      end
+    end
+
+    # remove first/oldest stub matching request_params
+    # @param request_params [Hash<Symbol, >] request params to match against, omitted params match all
+    # @return [Hash<Symbol, >] response params from deleted stub
+    def unstub(request_params = {})
+      stub = stub_for(request_params)
+      Excon.stubs.delete_at(Excon.stubs.index(stub))
+    end
+
+    # Generic non-persistent HTTP methods
+    HTTP_VERBS.each do |method|
+      module_eval <<-DEF, __FILE__, __LINE__ + 1
+        def #{method}(url, params = {}, &block)
+          new(url, params).request(:method => :#{method}, &block)
+        end
+      DEF
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/excon-0.75.0/lib/excon/connection.rb

@@ -0,0 +1,594 @@
+# frozen_string_literal: true
+require 'ipaddr'
+
+module Excon
+  class Connection
+    include Utils
+
+    attr_reader :data
+
+    def connection
+      Excon.display_warning('Excon::Connection#connection is deprecated use Excon::Connection#data instead.')
+      @data
+    end
+    def connection=(new_params)
+      Excon.display_warning('Excon::Connection#connection= is deprecated. Use of this method may cause unexpected results.')
+      @data = new_params
+    end
+
+    def params
+      Excon.display_warning('Excon::Connection#params is deprecated use Excon::Connection#data instead.')
+      @data
+    end
+    def params=(new_params)
+      Excon.display_warning('Excon::Connection#params= is deprecated. Use of this method may cause unexpected results.')
+      @data = new_params
+    end
+
+    def proxy
+      Excon.display_warning('Excon::Connection#proxy is deprecated use Excon::Connection#data[:proxy] instead.')
+      @data[:proxy]
+    end
+    def proxy=(new_proxy)
+      Excon.display_warning('Excon::Connection#proxy= is deprecated. Use of this method may cause unexpected results.')
+      @data[:proxy] = new_proxy
+    end
+
+    def logger
+      if @data[:instrumentor] && @data[:instrumentor].respond_to?(:logger)
+        @data[:instrumentor].logger
+      end
+    end
+    def logger=(logger)
+      @data[:instrumentor] = Excon::LoggingInstrumentor
+      @data[:logger] = logger
+    end
+
+    # Initializes a new Connection instance
+    # @param [Hash<Symbol, >] params One or more optional params
+    # @option params [String] :body Default text to be sent over a socket. Only used if :body absent in Connection#request params
+    # @option params [Hash<Symbol, String>] :headers The default headers to supply in a request. Only used if params[:headers] is not supplied to Connection#request
+    # @option params [String] :host The destination host's reachable DNS name or IP, in the form of a String. IPv6 addresses must be wrapped (e.g. [::1]).  See URI#host.
+    # @option params [String] :hostname Same as host, but usable for socket connections. IPv6 addresses must not be wrapped (e.g. ::1).  See URI#hostname.
+    # @option params [String] :path Default path; appears after 'scheme://host:port/'. Only used if params[:path] is not supplied to Connection#request
+    # @option params [Fixnum] :port The port on which to connect, to the destination host
+    # @option params [Hash]   :query Default query; appended to the 'scheme://host:port/path/' in the form of '?key=value'. Will only be used if params[:query] is not supplied to Connection#request
+    # @option params [String] :scheme The protocol; 'https' causes OpenSSL to be used
+    # @option params [String] :socket The path to the unix socket (required for 'unix://' connections)
+    # @option params [String] :ciphers Only use the specified SSL/TLS cipher suites; use OpenSSL cipher spec format e.g. 'HIGH:!aNULL:!3DES' or 'AES256-SHA:DES-CBC3-SHA'
+    # @option params [String] :proxy Proxy server; e.g. 'http://myproxy.com:8888'
+    # @option params [Fixnum] :retry_limit Set how many times we'll retry a failed request.  (Default 4)
+    # @option params [Fixnum] :retry_interval Set how long to wait between retries. (Default 0)
+    # @option params [Class] :instrumentor Responds to #instrument as in ActiveSupport::Notifications
+    # @option params [String] :instrumentor_name Name prefix for #instrument events.  Defaults to 'excon'
+    def initialize(params = {})
+      @data = Excon.defaults.dup
+      # merge does not deep-dup, so make sure headers is not the original
+      @data[:headers] = @data[:headers].dup
+
+      # the same goes for :middlewares
+      @data[:middlewares] = @data[:middlewares].dup
+
+      @data.merge!(params)
+      validate_params(:connection, @data, @data[:middlewares])
+
+      if @data.key?(:host) && !@data.key?(:hostname)
+        Excon.display_warning('hostname is missing! For IPv6 support, provide both host and hostname: Excon::Connection#new(:host => uri.host, :hostname => uri.hostname, ...).')
+        @data[:hostname] = @data[:host]
+      end
+
+      setup_proxy
+
+      if  ENV.has_key?('EXCON_STANDARD_INSTRUMENTOR')
+        @data[:instrumentor] = Excon::StandardInstrumentor
+      end
+
+      if @data[:debug] || ENV.has_key?('EXCON_DEBUG')
+        @data[:debug_request] = @data[:debug_response] = true
+        @data[:instrumentor] = Excon::StandardInstrumentor
+      end
+
+      if @data[:scheme] == UNIX
+        if @data[:host]
+          raise ArgumentError, "The `:host` parameter should not be set for `unix://` connections.\n" +
+                               "When supplying a `unix://` URI, it should start with `unix:/` or `unix:///`."
+        elsif !@data[:socket]
+          raise ArgumentError, 'You must provide a `:socket` for `unix://` connections'
+        else
+          @socket_key = "#{@data[:scheme]}://#{@data[:socket]}"
+        end
+      else
+        @socket_key = "#{@data[:scheme]}://#{@data[:host]}#{port_string(@data)}"
+      end
+      reset
+    end
+
+    def error_call(datum)
+      if datum[:error]
+        raise(datum[:error])
+      end
+    end
+
+    def request_call(datum)
+      begin
+        if datum.has_key?(:response)
+          # we already have data from a middleware, so bail
+          return datum
+        else
+          socket.data = datum
+          # start with "METHOD /path"
+          request = datum[:method].to_s.upcase + ' '
+          if datum[:proxy] && datum[:scheme] != HTTPS
+            request << datum[:scheme] << '://' << datum[:host] << port_string(datum)
+          end
+          request << datum[:path]
+
+          # add query to path, if there is one
+          request << query_string(datum)
+
+          # finish first line with "HTTP/1.1\r\n"
+          request << HTTP_1_1
+
+          if datum.has_key?(:request_block)
+            datum[:headers]['Transfer-Encoding'] = 'chunked'
+          else
+            body = datum[:body].is_a?(String) ? StringIO.new(datum[:body]) : datum[:body]
+
+            # 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[:headers].has_key?('Content-Length')
+                datum[:headers]['Content-Length'] = detect_content_length(body)
+              end
+            end
+          end
+
+          # add headers to request
+          datum[:headers].each do |key, values|
+            if key.to_s.match(/[\r\n]/)
+              raise Excon::Errors::InvalidHeaderKey.new(key.to_s.inspect + ' contains forbidden "\r" or "\n"')
+            end
+            [values].flatten.each do |value|
+              if value.to_s.match(/[\r\n]/)
+                raise Excon::Errors::InvalidHeaderValue.new(value.to_s.inspect + ' contains forbidden "\r" or "\n"')
+              end
+              request << key.to_s << ': ' << value.to_s << CR_NL
+            end
+          end
+
+          # add additional "\r\n" to indicate end of headers
+          request << CR_NL
+
+          if datum.has_key?(:request_block)
+            socket.write(request) # write out request + headers
+            while true # write out body with chunked encoding
+              chunk = datum[:request_block].call
+              chunk = binary_encode(chunk)
+              if chunk.length > 0
+                socket.write(chunk.length.to_s(16) << CR_NL << chunk << CR_NL)
+              else
+                socket.write(String.new("0#{CR_NL}#{CR_NL}"))
+                break
+              end
+            end
+          elsif body.nil?
+            socket.write(request) # write out request + headers
+          else # write out body
+            if body.respond_to?(:binmode) && !body.is_a?(StringIO)
+              body.binmode
+            end
+            if body.respond_to?(:rewind)
+              body.rewind  rescue nil
+            end
+
+            # if request + headers is less than chunk size, fill with body
+            request = binary_encode(request)
+            chunk = body.read([datum[:chunk_size] - request.length, 0].max)
+            if chunk
+              chunk = binary_encode(chunk)
+              socket.write(request << chunk)
+            else
+              socket.write(request) # write out request + headers
+            end
+
+            while chunk = body.read(datum[:chunk_size])
+              socket.write(chunk)
+            end
+          end
+        end
+      rescue => error
+        case error
+        when Excon::Errors::InvalidHeaderKey, Excon::Errors::InvalidHeaderValue, Excon::Errors::StubNotFound, Excon::Errors::Timeout
+          raise(error)
+        else
+          raise_socket_error(error)
+        end
+      end
+
+      datum
+    end
+
+    def response_call(datum)
+      # ensure response_block is yielded to and body is empty from middlewares
+      if datum.has_key?(:response_block) && !(datum[:response][:body].nil? || datum[:response][:body].empty?)
+        response_body = datum[:response][:body].dup
+        datum[:response][:body] = ''
+        content_length = remaining = response_body.bytesize
+        while remaining > 0
+          datum[:response_block].call(response_body.slice!(0, [datum[:chunk_size], remaining].min), [remaining - datum[:chunk_size], 0].max, content_length)
+          remaining -= datum[:chunk_size]
+        end
+      end
+      datum
+    end
+
+    # Sends the supplied request to the destination host.
+    # @yield [chunk] @see Response#self.parse
+    # @param [Hash<Symbol, >] params One or more optional params, override defaults set in Connection.new
+    # @option params [String] :body text to be sent over a socket
+    # @option params [Hash<Symbol, String>] :headers The default headers to supply in a request
+    # @option params [String] :path appears after 'scheme://host:port/'
+    # @option params [Hash]   :query appended to the 'scheme://host:port/path/' in the form of '?key=value'
+    def request(params={}, &block)
+      # @data has defaults, merge in new params to override
+      datum = @data.merge(params)
+      datum[:headers] = @data[:headers].merge(datum[:headers] || {})
+
+      validate_params(:request, params, datum[:middlewares])
+      # If the user passed in new middleware, we want to validate that the original connection parameters
+      # are still valid with the provided middleware.
+      if params[:middlewares]
+        validate_params(:connection, @data, datum[:middlewares])
+      end
+
+      if datum[:user] || datum[:password]
+        user, pass = Utils.unescape_uri(datum[:user].to_s), Utils.unescape_uri(datum[:password].to_s)
+        datum[:headers]['Authorization'] ||= 'Basic ' + ["#{user}:#{pass}"].pack('m').delete(Excon::CR_NL)
+      end
+
+      if datum[:scheme] == UNIX
+        datum[:headers]['Host']   ||= ''
+      else
+        datum[:headers]['Host']   ||= datum[:host] + port_string(datum)
+      end
+
+      # if path is empty or doesn't start with '/', insert one
+      unless datum[:path][0, 1] == '/'
+        datum[:path] = datum[:path].dup.insert(0, '/')
+      end
+
+      if block_given?
+        Excon.display_warning('Excon requests with a block are deprecated, pass :response_block instead.')
+        datum[:response_block] = block
+      end
+
+      datum[:connection] = self
+
+      # cleanup data left behind on persistent connection after interrupt
+      if datum[:persistent] && !@persistent_socket_reusable
+        reset
+      end
+
+      datum[:stack] = datum[:middlewares].map do |middleware|
+        lambda {|stack| middleware.new(stack)}
+      end.reverse.inject(self) do |middlewares, middleware|
+        middleware.call(middlewares)
+      end
+      datum = datum[:stack].request_call(datum)
+
+      unless datum[:pipeline]
+        @persistent_socket_reusable = false
+        datum = response(datum)
+        @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
+              reset
+            end
+          end
+        else
+          reset
+        end
+
+        Excon::Response.new(datum[:response])
+      else
+        datum
+      end
+    rescue => error
+      reset
+
+      # If we didn't get far enough to initialize datum and the middleware stack, just raise
+      raise error if !datum
+
+      datum[:error] = error
+      if datum[:stack]
+        datum[:stack].error_call(datum)
+      else
+        raise error
+      end
+    end
+
+    # Sends the supplied requests to the destination host using pipelining.
+    # @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])
+
+      responses = pipeline_params.map do |params|
+        request(params)
+      end.map do |datum|
+        Excon::Response.new(response(datum)[:response])
+      end
+
+      if @data[:persistent]
+        if key = responses.last[:headers].keys.detect {|k| k.casecmp('Connection') == 0 }
+          if responses.last[:headers][key].casecmp('close') == 0
+            reset
+          end
+        end
+      else
+        reset
+      end
+
+      responses
+    end
+
+    # Sends the supplied requests to the destination host using pipelining in
+    # batches of @limit [Numeric] requests. This is your soft file descriptor
+    # limit by default, typically 256.
+    # @param pipeline_params [Array<Hash>] An array of one or more optional params, override defaults set in Connection.new, see #request for details
+    def batch_requests(pipeline_params, limit = nil)
+      limit ||= Process.respond_to?(:getrlimit) ? Process.getrlimit(:NOFILE).first : 256
+      responses = []
+
+      pipeline_params.each_slice(limit) do |params|
+        responses.concat(requests(params))
+      end
+
+      responses
+    end
+
+    def reset
+      if old_socket = sockets.delete(@socket_key)
+        old_socket.close rescue nil
+      end
+      @persistent_socket_reusable = true
+    end
+
+    # Generate HTTP request verb methods
+    Excon::HTTP_VERBS.each do |method|
+      class_eval <<-DEF, __FILE__, __LINE__ + 1
+        def #{method}(params={}, &block)
+          request(params.merge!(:method => :#{method}), &block)
+        end
+      DEF
+    end
+
+    def retry_limit=(new_retry_limit)
+      Excon.display_warning('Excon::Connection#retry_limit= is deprecated, pass :retry_limit to the initializer.')
+      @data[:retry_limit] = new_retry_limit
+    end
+
+    def retry_limit
+      Excon.display_warning('Excon::Connection#retry_limit is deprecated, use Excon::Connection#data[:retry_limit].')
+      @data[:retry_limit] ||= DEFAULT_RETRY_LIMIT
+    end
+
+    def inspect
+      vars = instance_variables.inject({}) do |accum, var|
+        accum.merge!(var.to_sym => instance_variable_get(var))
+      end
+      vars[:'@data'] = Utils.redact(vars[:'@data'])
+      inspection = '#<Excon::Connection:'
+      inspection += (object_id << 1).to_s(16)
+      vars.each do |key, value|
+        inspection += " #{key}=#{value.inspect}"
+      end
+      inspection += '>'
+      inspection
+    end
+
+    def valid_request_keys(middlewares)
+      valid_middleware_keys(middlewares) + Excon::VALID_REQUEST_KEYS
+    end
+
+    private
+
+    def detect_content_length(body)
+      if body.respond_to?(:size)
+        # IO object: File, Tempfile, StringIO, etc.
+        body.size
+      elsif body.respond_to?(:stat)
+        # for 1.8.7 where file does not have size
+        body.stat.size
+      else
+        0
+      end
+    end
+
+    def valid_middleware_keys(middlewares)
+      middlewares.flat_map do |middleware|
+        if middleware.respond_to?(:valid_parameter_keys)
+          middleware.valid_parameter_keys
+        else
+          Excon.display_warning(
+            "Excon middleware #{middleware} does not define #valid_parameter_keys"
+          )
+          []
+        end
+      end
+    end
+
+    def validate_params(validation, params, middlewares)
+      valid_keys = case validation
+      when :connection
+        valid_middleware_keys(middlewares) + Excon::VALID_CONNECTION_KEYS
+      when :request
+        valid_request_keys(middlewares)
+      else
+        raise ArgumentError.new("Invalid validation type '#{validation}'")
+      end
+
+      invalid_keys = params.keys - valid_keys
+      unless invalid_keys.empty?
+        Excon.display_warning("Invalid Excon #{validation} keys: #{invalid_keys.map(&:inspect).join(', ')}")
+
+        if validation == :request
+          deprecated_keys = invalid_keys & Excon::DEPRECATED_VALID_REQUEST_KEYS.keys
+          mw_msg = deprecated_keys.map do |k|
+            "#{k}: #{Excon::DEPRECATED_VALID_REQUEST_KEYS[k]}"
+          end.join(', ')
+          Excon.display_warning(
+            "The following request keys are only valid with the associated middleware: #{mw_msg}"
+          )
+        end
+      end
+    end
+
+    def response(datum={})
+      datum[:stack].response_call(datum)
+    rescue => error
+      case error
+      when Excon::Errors::HTTPStatusError, Excon::Errors::Timeout, Excon::Errors::TooManyRedirects
+        raise(error)
+      else
+        raise_socket_error(error)
+      end
+    end
+
+    def socket
+      unix_proxy = @data[:proxy] ? @data[:proxy][:scheme] == UNIX : false
+      sockets[@socket_key] ||= if @data[:scheme] == UNIX || unix_proxy
+        Excon::UnixSocket.new(@data)
+      elsif @data[:ssl_uri_schemes].include?(@data[:scheme])
+        Excon::SSLSocket.new(@data)
+      else
+        Excon::Socket.new(@data)
+      end
+    end
+
+    def sockets
+      @_excon_sockets ||= {}
+
+      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] ||= {}
+      else
+        @_excon_sockets
+      end
+    end
+
+    def raise_socket_error(error)
+      if error.message =~ /certificate verify failed/
+        raise(Excon::Errors::CertificateError.new(error))
+      else
+        raise(Excon::Errors::SocketError.new(error))
+      end
+    end
+
+    def proxy_match_host_port(host, port)
+        host_match = if host.is_a? IPAddr
+                       begin
+                         host.include? @data[:host]
+                       rescue IPAddr::Error
+                         false
+                       end
+                     else
+                       /(^|\.)#{host}$/.match(@data[:host])
+                     end
+        host_match && (port.nil? || port.to_i == @data[:port])
+    end
+
+    def proxy_from_env
+      if (no_proxy_env = ENV['no_proxy'] || ENV['NO_PROXY'])
+        no_proxy_list = no_proxy_env.scan(/\s*(?:\[([\dA-Fa-f:\/]+)\]|\*?\.?([^\s,:]+))(?::(\d+))?\s*/i).map { |e|
+          if e[0]
+            begin
+              [IPAddr.new(e[0]), e[2]]
+            rescue IPAddr::Error
+              nil
+            end
+          else
+            begin
+              [IPAddr.new(e[1]), e[2]]
+            rescue IPAddr::Error
+              [e[1], e[2]]
+            end
+          end
+        }.reject { |e| e.nil? || e[0].nil? }
+      end
+
+      unless no_proxy_env && no_proxy_list.index { |h| proxy_match_host_port(h[0], h[1]) }
+        if @data[:scheme] == HTTPS && (ENV.has_key?('https_proxy') || ENV.has_key?('HTTPS_PROXY'))
+          @data[:proxy] = ENV['https_proxy'] || ENV['HTTPS_PROXY']
+        elsif (ENV.has_key?('http_proxy') || ENV.has_key?('HTTP_PROXY'))
+          @data[:proxy] = ENV['http_proxy'] || ENV['HTTP_PROXY']
+        end
+      end
+    end
+
+    def setup_proxy
+      if @data[:disable_proxy]
+        if @data[:proxy]
+          raise ArgumentError, "`:disable_proxy` parameter and `:proxy` parameter cannot both be set at the same time."
+        end
+        return
+      end
+
+      return if @data[:scheme] == UNIX
+
+      proxy_from_env
+
+      case @data[:proxy]
+      when nil
+        @data.delete(:proxy)
+      when ''
+        @data.delete(:proxy)
+      when Hash
+        # no processing needed
+      when String, URI
+        uri = @data[:proxy].is_a?(String) ? URI.parse(@data[:proxy]) : @data[:proxy]
+        @data[:proxy] = {
+          :host       => uri.host,
+          :hostname   => uri.hostname,
+          # path is only sensible for a Unix socket proxy
+          :path       => uri.scheme == UNIX ? uri.path : nil,
+          :port       => uri.port,
+          :scheme     => uri.scheme,
+        }
+        if uri.password
+          @data[:proxy][:password] = uri.password
+        end
+        if uri.user
+          @data[:proxy][:user] = uri.user
+        end
+        if @data[:proxy][:scheme] == UNIX
+          if @data[:proxy][:host]
+            raise ArgumentError, "The `:host` parameter should not be set for `unix://` proxies.\n" +
+                                 "When supplying a `unix://` URI, it should start with `unix:/` or `unix:///`."
+          end
+        else
+          unless uri.host && uri.port && uri.scheme
+            raise Excon::Errors::ProxyParse, "Proxy is invalid"
+          end
+        end
+      else
+        raise Excon::Errors::ProxyParse, "Proxy is invalid"
+      end
+
+      if @data.has_key?(:proxy) && @data[:scheme] == 'http'
+        @data[:headers]['Proxy-Connection'] ||= 'Keep-Alive'
+        # https credentials happen in handshake
+        if @data[:proxy].has_key?(:user) || @data[:proxy].has_key?(:password)
+          user, pass = Utils.unescape_form(@data[:proxy][:user].to_s), Utils.unescape_form(@data[:proxy][:password].to_s)
+          auth = ["#{user}:#{pass}"].pack('m').delete(Excon::CR_NL)
+          @data[:headers]['Proxy-Authorization'] = 'Basic ' + auth
+        end
+      end
+    end
+  end
+end