coingecko_client 0.1.0

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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+module Excon
+  class SSLSocket < Socket
+    HAVE_NONBLOCK = [:connect_nonblock, :read_nonblock, :write_nonblock].all? do |m|
+      OpenSSL::SSL::SSLSocket.public_method_defined?(m)
+    end
+
+    def initialize(data = {})
+      @port = data[:port] || 443
+      super
+
+      # create ssl context
+      ssl_context = OpenSSL::SSL::SSLContext.new
+
+      # disable less secure options, when supported
+      ssl_context_options = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:options]
+      if defined?(OpenSSL::SSL::OP_DONT_INSERT_EMPTY_FRAGMENTS)
+        ssl_context_options &= ~OpenSSL::SSL::OP_DONT_INSERT_EMPTY_FRAGMENTS
+      end
+
+      if defined?(OpenSSL::SSL::OP_NO_COMPRESSION)
+        ssl_context_options |= OpenSSL::SSL::OP_NO_COMPRESSION
+      end
+      ssl_context.options = ssl_context_options
+
+      ssl_context.ciphers = @data[:ciphers]
+      if @data[:ssl_version]
+        ssl_context.ssl_version = @data[:ssl_version]
+      end
+      if @data[:ssl_min_version]
+        ssl_context.min_version = @data[:ssl_min_version]
+      end
+      if @data[:ssl_max_version]
+        ssl_context.max_version = @data[:ssl_max_version]
+      end
+
+
+      if @data[:ssl_verify_peer]
+        # turn verification on
+        ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+        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']
+          ssl_context.ca_path = ca_path
+        end
+        if cert_store = @data[:ssl_cert_store]
+          ssl_context.cert_store = cert_store
+        end
+
+        # no defaults, fallback to bundled
+        unless ca_file || ca_path || cert_store
+          ssl_context.cert_store = OpenSSL::X509::Store.new
+          ssl_context.cert_store.set_default_paths
+
+          # workaround issue #257 (JRUBY-6970)
+          ca_file = DEFAULT_CA_FILE
+          ca_file = ca_file.gsub(/^jar:/, '') if ca_file =~ /^jar:file:\//
+
+          begin
+            ssl_context.cert_store.add_file(ca_file)
+          rescue
+            Excon.display_warning("Excon unable to add file to cert store, ignoring: #{ca_file}\n[#{$!.class}] #{$!.message}")
+          end
+        end
+
+        if verify_callback = @data[:ssl_verify_callback]
+          ssl_context.verify_callback = verify_callback
+        end
+      else
+        # turn verification off
+        ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      if client_cert_data && client_key_data
+        ssl_context.cert = OpenSSL::X509::Certificate.new client_cert_data
+        if OpenSSL::PKey.respond_to? :read
+          ssl_context.key = OpenSSL::PKey.read(client_key_data, client_key_pass)
+        else
+          ssl_context.key = OpenSSL::PKey::RSA.new(client_key_data, client_key_pass)
+        end
+      elsif @data.key?(:certificate) && @data.key?(:private_key)
+        ssl_context.cert = OpenSSL::X509::Certificate.new(@data[:certificate])
+        if OpenSSL::PKey.respond_to? :read
+          ssl_context.key = OpenSSL::PKey.read(@data[:private_key], client_key_pass)
+        else
+          ssl_context.key = OpenSSL::PKey::RSA.new(@data[:private_key], client_key_pass)
+        end
+      end
+
+      if @data[:proxy]
+        request = "CONNECT #{@data[:host]}#{port_string(@data.merge(:omit_default_port => false))}#{Excon::HTTP_1_1}" +
+                  "Host: #{@data[:host]}#{port_string(@data)}#{Excon::CR_NL}"
+
+        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)
+          request += "Proxy-Authorization: Basic #{auth}#{Excon::CR_NL}"
+        end
+
+        request += "Proxy-Connection: Keep-Alive#{Excon::CR_NL}"
+
+        request += Excon::CR_NL
+
+        # write out the proxy setup request
+        @socket.write(request)
+
+        # eat the proxy's connection response
+        response = Excon::Response.parse(self,  :expects => 200, :method => 'CONNECT')
+        if response[:response][:status] != 200
+          raise(Excon::Errors::ProxyConnectionError.new("proxy connection could not be established", request, response))
+        end
+      end
+
+      # convert Socket to OpenSSL::SSL::SSLSocket
+      @socket = OpenSSL::SSL::SSLSocket.new(@socket, ssl_context)
+      @socket.sync_close = true
+
+      # Server Name Indication (SNI) RFC 3546
+      if @socket.respond_to?(:hostname=)
+        @socket.hostname = @data[:host]
+      end
+
+      begin
+        if @nonblock
+          begin
+            @socket.connect_nonblock
+          rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
+            select_with_timeout(@socket, :connect_read) && retry
+          rescue IO::WaitWritable
+            select_with_timeout(@socket, :connect_write) && retry
+          end
+        else
+          @socket.connect
+        end
+      rescue Errno::ETIMEDOUT, Timeout::Error
+        raise Excon::Errors::Timeout.new('connect timeout reached')
+      end
+
+      # verify connection
+      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]
+                              ccd
+                            elsif path = @data[:client_cert]
+                              File.read 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
+    end
+
+    def connect
+      # backwards compatability for things lacking nonblock
+      @nonblock = HAVE_NONBLOCK && @nonblock
+      super
+    end
+
+    def client_key_data
+      @client_key_data ||= if ckd = @data[:client_key_data]
+                             ckd
+                           elsif path = @data[:client_key]
+                             File.read 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
+    end
+
+    def client_key_pass
+      @data[:client_key_pass] || @data[:private_key_pass]
+    end
+
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/excon-0.75.0/lib/excon/test/plugin/server/exec.rb

@@ -0,0 +1,23 @@
+module Excon
+  module Test
+    module Plugin
+      module Server
+        module Exec
+          def start(app_str = app)
+            line = ''
+            open_process(app)
+            until line =~ /\Aready\Z/
+              line = error.gets
+              fatal_time = elapsed_time > timeout
+              if fatal_time
+                msg = "executable #{app} has taken too long to start"
+                raise msg
+              end
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/excon-0.75.0/lib/excon/test/plugin/server/puma.rb

@@ -0,0 +1,20 @@
+module Excon
+  module Test
+    module Plugin
+      module Server
+        module Puma
+          def start(app_str = app, bind_uri = bind)
+            open_process('puma', '-b', bind_uri.to_s, app_str)
+            line = ''
+            until line =~ /Use Ctrl-C to stop/
+              line = read.gets
+              fatal_time = elapsed_time > timeout
+              raise 'puma server has taken too long to start' if fatal_time
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/excon-0.75.0/lib/excon/test/plugin/server/unicorn.rb

@@ -0,0 +1,35 @@
+module Excon
+  module Test
+    module Plugin
+      module Server
+        module Unicorn
+          def start(app_str = app, bind_uri = bind)
+            bind_uri = URI.parse(bind_uri) unless bind_uri.is_a? URI::Generic
+            is_unix_socket = (bind_uri.scheme == "unix")
+            if is_unix_socket
+              bind_str = bind_uri.to_s
+            else
+              host = bind_uri.host.gsub(/[\[\]]/, '')
+              bind_str = "#{host}:#{bind_uri.port}"
+            end
+            args = [ 
+              'unicorn', 
+              '--no-default-middleware', 
+              '-l',
+              bind_str,  
+              app_str
+            ]
+            open_process(*args)
+            line = ''
+            until line =~ /worker\=0 ready/
+              line = error.gets
+              fatal_time = elapsed_time > timeout
+              raise 'unicorn server has taken too long to start' if fatal_time
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/excon-0.75.0/lib/excon/test/plugin/server/webrick.rb

@@ -0,0 +1,23 @@
+module Excon
+  module Test
+    module Plugin
+      module Server
+        module Webrick
+          def start(app_str = app, bind_uri = bind)
+            bind_uri = URI.parse(bind_uri) unless bind_uri.is_a? URI::Generic
+            host = bind_uri.host.gsub(/[\[\]]/, '')
+            port = bind_uri.port.to_s
+            open_process('rackup', '-s', 'webrick', '--host', host, '--port', port, app_str)
+            line = ''
+            until line =~ /HTTPServer#start/
+              line = error.gets
+              fatal_time = elapsed_time > timeout
+              raise 'webrick server has taken too long to start' if fatal_time
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+require 'open4'
+require 'excon'
+require 'excon/test/plugin/server/webrick'
+require 'excon/test/plugin/server/unicorn'
+require 'excon/test/plugin/server/puma'
+require 'excon/test/plugin/server/exec'
+
+
+module Excon
+  module Test
+    class Server
+      attr_accessor :app, :server, :bind, :pid, :read, :write, :error, :started_at, :timeout
+
+      # Methods that must be implemented by a plugin
+      INSTANCE_REQUIRES = [:start]
+      Excon.defaults.merge!(
+        connect_timeout: 5,
+        read_timeout: 5,
+        write_timeout: 5
+      )
+
+      def initialize(args)
+        # TODO: Validate these args
+        @server = args.keys.first
+        @app = args[server]
+        args[:bind] ||= 'tcp://127.0.0.1:9292'
+        @bind = URI.parse(args[:bind])
+        @is_unix_socket = (@bind.scheme == 'unix')
+        @bind.host = @bind.host.gsub(/[\[\]]/, '') unless @is_unix_socket
+        if args[:timeout]
+          @timeout = args[:timeout]
+        else
+          @timeout = 20
+        end
+        name = @server.to_s.split('_').collect(&:capitalize).join
+        plug = nested_const_get("Excon::Test::Plugin::Server::#{name}")
+        self.extend plug
+        check_implementation(plug)
+      end
+
+      def open_process(*args)
+        if RUBY_PLATFORM == 'java'
+          @pid, @write, @read, @error = IO.popen4(*args)
+        else
+          GC.disable if RUBY_VERSION < '1.9'
+          @pid, @write, @read, @error = Open4.popen4(*args)
+        end
+        @started_at = Time.now
+      end
+
+      def elapsed_time
+        Time.now - started_at
+      end
+
+      def stop
+        if RUBY_PLATFORM == 'java'
+          Process.kill('USR1', pid)
+        else
+          Process.kill(9, pid)
+          GC.enable if RUBY_VERSION < '1.9'
+          Process.wait(pid)
+        end
+
+        if @is_unix_socket
+          socket = @bind.path
+          File.delete(socket) if File.exist?(socket)
+        end
+
+        # TODO: Ensure process is really dead
+        dump_errors
+        true
+      end
+      def dump_errors
+        lines = error.read.split($/)
+        while line = lines.shift
+          case line
+            when /(ERROR|Error)/
+              unless line =~ /(null cert chain|did not return a certificate|SSL_read:: internal error)/
+                in_err = true
+                puts
+              end
+            when /^(127|localhost)/
+              in_err = false
+            end
+          puts line if in_err
+        end
+      end
+
+      private
+
+      def nested_const_get(namespace)
+        namespace.split('::').inject(Object) do |mod, klass|
+          mod.const_get(klass)
+        end
+      end
+
+      def check_implementation(plug)
+        INSTANCE_REQUIRES.each do |m|
+          unless self.respond_to? m
+            raise "FATAL: #{plug} does not implement ##{m}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module Excon
+  class UnixSocket < Excon::Socket
+
+    private
+
+    def connect
+      @socket  = ::Socket.new(::Socket::AF_UNIX, ::Socket::SOCK_STREAM, 0)
+      # If a Unix proxy was specified, the :path option will be set for it,
+      # otherwise fall back to the :socket option.
+      proxy_path = @data[:proxy] ? @data[:proxy][:path] : nil
+      sockaddr = ::Socket.sockaddr_un(proxy_path || @data[:socket])
+      if @nonblock
+        begin
+          @socket.connect_nonblock(sockaddr)
+        rescue Errno::EINPROGRESS
+          unless IO.select(nil, [@socket], nil, @data[:connect_timeout])
+            raise(Excon::Errors::Timeout.new("connect timeout reached"))
+          end
+          begin
+            @socket.connect_nonblock(sockaddr)
+          rescue Errno::EISCONN
+          end
+        end
+      else
+        begin
+          Timeout.timeout(@data[:connect_timeout]) do
+            @socket.connect(sockaddr)
+          end
+        rescue Timeout::Error
+          raise Excon::Errors::Timeout.new('connect timeout reached')
+        end
+      end
+
+    rescue => error
+      @socket.close rescue nil if @socket
+      raise error
+    end
+
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+module Excon
+  module Utils
+    extend self
+
+    CONTROL   = (0x0..0x1f).map {|c| c.chr }.join + "\x7f"
+    DELIMS    = '<>#%"'
+    UNWISE    = '{}|\\^[]`'
+    NONASCII  = (0x80..0xff).map {|c| c.chr }.join
+    UNESCAPED = /([#{ Regexp.escape(CONTROL + ' ' + DELIMS + UNWISE + NONASCII) }])/
+    ESCAPED   = /%([0-9a-fA-F]{2})/
+
+    def binary_encode(string)
+      if FORCE_ENC && string.encoding != Encoding::ASCII_8BIT
+        if string.frozen?
+          string.dup.force_encoding('BINARY')
+        else
+          string.force_encoding('BINARY')
+        end
+      else
+        string
+      end
+    end
+
+    def connection_uri(datum = @data)
+      unless datum
+        raise ArgumentError, '`datum` must be given unless called on a Connection'
+      end
+      if datum[:scheme] == UNIX
+        "#{datum[:scheme]}://#{datum[:socket]}"
+      else
+        "#{datum[:scheme]}://#{datum[:host]}#{port_string(datum)}"
+      end
+    end
+
+    # Redact sensitive info from provided data
+    def redact(datum)
+      datum = datum.dup
+      if datum.has_key?(:headers)
+        if datum[:headers].has_key?('Authorization') || datum[:headers].has_key?('Proxy-Authorization')
+          datum[:headers] = datum[:headers].dup
+        end
+        if datum[:headers].has_key?('Authorization')
+          datum[:headers]['Authorization'] = REDACTED
+        end
+        if datum[:headers].has_key?('Proxy-Authorization')
+          datum[:headers]['Proxy-Authorization'] = REDACTED
+        end
+      end
+      if datum.has_key?(:password)
+        datum[:password] = REDACTED
+      end
+      if datum.has_key?(:proxy) && datum[:proxy].has_key?(:password)
+        datum[:proxy] = datum[:proxy].dup
+        datum[:proxy][:password] = REDACTED
+      end
+      datum
+    end
+
+    def request_uri(datum)
+      connection_uri(datum) + datum[:path] + query_string(datum)
+    end
+
+    def port_string(datum)
+      if datum[:port].nil? || (datum[:omit_default_port] && ((datum[:scheme].casecmp('http') == 0 && datum[:port] == 80) || (datum[:scheme].casecmp('https') == 0 && datum[:port] == 443)))
+        ''
+      else
+        ':' + datum[:port].to_s
+      end
+    end
+
+    def query_string(datum)
+      str = String.new
+      case datum[:query]
+      when String
+        str << '?' << datum[:query]
+      when Hash
+        str << '?'
+        datum[:query].sort_by {|k,_| k.to_s }.each do |key, values|
+          key = CGI.escape(key.to_s)
+          if values.nil?
+            str << key << '&'
+          else
+            [values].flatten.each do |value|
+              str << key << '=' << CGI.escape(value.to_s) << '&'
+            end
+          end
+        end
+        str.chop! # remove trailing '&'
+      end
+      str
+    end
+
+    # Splits a header value +str+ according to HTTP specification.
+    def split_header_value(str)
+      return [] if str.nil?
+      str = str.dup.strip
+      str = binary_encode(str)
+      str.scan(%r'\G((?:"(?:\\.|[^"])+?"|[^",]+)+)
+                    (?:,\s*|\Z)'xn).flatten
+    end
+
+    # Escapes HTTP reserved and unwise characters in +str+
+    def escape_uri(str)
+      str = str.dup
+      str = binary_encode(str)
+      str.gsub(UNESCAPED) { "%%%02X" % $1[0].ord }
+    end
+
+    # Unescapes HTTP reserved and unwise characters in +str+
+    def unescape_uri(str)
+      str = str.dup
+      str = binary_encode(str)
+      str.gsub(ESCAPED) { $1.hex.chr }
+    end
+
+    # Unescape form encoded values in +str+
+    def unescape_form(str)
+      str = str.dup
+      str = binary_encode(str)
+      str.gsub!(/\+/, ' ')
+      str.gsub(ESCAPED) { $1.hex.chr }
+    end
+  end
+end