coingecko_client 0.1.0

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

@@ -0,0 +1,48 @@
+require 'logger'
+
+module Excon
+  class LoggingInstrumentor
+
+    def self.instrument(name, params = {}, &block)
+      params = params.dup
+
+      logger = params[:logger] || Logger.new($stderr)
+
+      # reduce duplication/noise of output
+      params.delete(:connection)
+      params.delete(:stack)
+
+      if params.has_key?(:headers) && params[:headers].has_key?('Authorization')
+        params[:headers] = params[:headers].dup
+        params[:headers]['Authorization'] = "REDACTED"
+      end
+
+      if params.has_key?(:password)
+        params[:password] = "REDACTED"
+      end
+
+      if name.include?('request')
+        info = "request: " + params[:scheme] + "://" + File.join(params[:host], params[:path])
+
+        if params[:query]
+          info << "?"
+
+          if params[:query].is_a?(Hash)
+            info << params.to_a.map{ |key,value| "#{key}=#{value}" }.join('&')
+          else
+            info << params[:query]
+          end
+        end
+      else
+        response_type = name.split('.').last
+        if params[:body]
+          info = "#{response_type}: " + params[:body]
+        end
+      end
+
+      logger.log(Logger::INFO, info) if info
+
+      yield if block_given?
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Excon
+  class StandardInstrumentor
+    def self.instrument(name, params = {}, &block)
+      params = params.dup
+
+      # reduce duplication/noise of output
+      params.delete(:connection)
+      params.delete(:stack)
+
+      params = Utils.redact(params)
+
+      $stderr.puts(name)
+      Excon::PrettyPrinter.pp($stderr, params)
+
+      if block_given?
+        yield
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class Base
+      # Returns the list of parameters that this middleware uses that are valid
+      # as arguments to `Connection#request` or `Connection#new`.
+      def self.valid_parameter_keys
+        []
+      end
+
+      def initialize(stack)
+        @stack = stack
+      end
+
+      def error_call(datum)
+        # do stuff
+        @stack.error_call(datum)
+      end
+
+      def request_call(datum)
+        # do stuff
+        @stack.request_call(datum)
+      end
+
+      def response_call(datum)
+        @stack.response_call(datum)
+        # do stuff
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class CaptureCookies < Excon::Middleware::Base
+
+      def extract_cookies_from_set_cookie(set_cookie)
+        set_cookie.split(',').map { |full| full.split(';').first.strip }.join('; ')
+      end
+
+      def get_header(datum, header)
+        _, header_value = datum[:response][:headers].detect do |key, value|
+          key.casecmp(header) == 0
+        end
+        header_value
+      end
+
+      def response_call(datum)
+        cookie = get_header(datum, 'Set-Cookie')
+        if cookie
+          cookie = extract_cookies_from_set_cookie(cookie)
+          unless datum[:headers].key?("Cookie")
+            datum[:headers]["Cookie"] = cookie
+          else
+            original_cookies = datum[:headers]["Cookie"]
+            datum[:headers]["Cookie"] = original_cookies.empty? ? cookie : [original_cookies,cookie].join('; ')
+          end
+        end
+        super(datum)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class Decompress < Excon::Middleware::Base
+      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
+        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
+                # assume inflate omits header
+                datum[:response][:body] = Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(body)
+                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(', ')
+            end
+          end
+        end
+        @stack.response_call(datum)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class EscapePath < Excon::Middleware::Base
+      def request_call(datum)
+        # make sure path is encoded, prevent double encoding
+        datum[:path] = Excon::Utils.escape_uri(Excon::Utils.unescape_uri(datum[:path]))
+        @stack.request_call(datum)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class Expects < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [
+          :expects
+        ]
+      end
+
+      def response_call(datum)
+        if datum.has_key?(:expects) && ![*datum[:expects]].include?(datum[:response][:status])
+          raise(
+            Excon::Errors.status_error(
+              datum.reject {|key,value| key == :response},
+              Excon::Response.new(datum[:response])
+            )
+          )
+        else
+          @stack.response_call(datum)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require 'set'
+
+module Excon
+  module Middleware
+    class Idempotent < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [
+          :idempotent,
+          :retries_remaining,
+          :retry_errors,
+          :retry_interval,
+          :retry_limit
+        ]
+      end
+
+      def request_call(datum)
+        datum[:retries_remaining] ||= datum[:retry_limit]
+        @stack.request_call(datum)
+      end
+
+      def error_call(datum)
+        if datum[:idempotent]
+          if datum.has_key?(:request_block)
+            if datum[:request_block].respond_to?(:rewind)
+              datum[:request_block].rewind
+            else
+              Excon.display_warning('Excon requests with a :request_block must implement #rewind in order to be :idempotent.')
+              datum[:idempotent] = false
+            end
+          end
+          if datum.has_key?(:response_block) && datum[:response_block].respond_to?(:rewind)
+            datum[:response_block].rewind
+          end
+          if datum.has_key?(:pipeline)
+            Excon.display_warning("Excon requests can not be :idempotent when pipelining.")
+            datum[:idempotent] = false
+          end
+        end
+
+        if datum[:idempotent] && datum[:retry_errors].any? {|ex| datum[:error].kind_of?(ex) } && datum[:retries_remaining] > 1
+
+          sleep(datum[:retry_interval]) if datum[:retry_interval]
+
+          # reduces remaining retries, reset connection, and restart request_call
+          datum[:retries_remaining] -= 1
+          connection = datum.delete(:connection)
+          valid_keys = Set.new(connection.valid_request_keys(datum[:middlewares]))
+          datum.select! {|key, _| valid_keys.include?(key) }
+          connection.request(datum)
+        else
+          @stack.error_call(datum)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class Instrumentor < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [
+          :logger,
+          :instrumentor,
+          :instrumentor_name
+        ]
+      end
+
+      def error_call(datum)
+        if datum.has_key?(:instrumentor)
+          datum[:instrumentor].instrument("#{datum[:instrumentor_name]}.error", :error => datum[:error]) do
+            @stack.error_call(datum)
+          end
+        else
+          @stack.error_call(datum)
+        end
+      end
+
+      def request_call(datum)
+        if datum.has_key?(:instrumentor)
+          if datum[:retries_remaining] < datum[:retry_limit]
+            event_name = "#{datum[:instrumentor_name]}.retry"
+          else
+            event_name = "#{datum[:instrumentor_name]}.request"
+          end
+          datum[:instrumentor].instrument(event_name, datum) do
+            @stack.request_call(datum)
+          end
+        else
+          @stack.request_call(datum)
+        end
+      end
+
+      def response_call(datum)
+        if datum.has_key?(:instrumentor)
+          datum[:instrumentor].instrument("#{datum[:instrumentor_name]}.response", datum[:response]) do
+            @stack.response_call(datum)
+          end
+        else
+          @stack.response_call(datum)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class Mock < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [
+          :allow_unstubbed_requests,
+          :captures,
+          :mock
+        ]
+      end
+
+      def request_call(datum)
+        if datum[:mock]
+          # convert File/Tempfile body to string before matching:
+          if datum[:body].respond_to?(:read)
+           if datum[:body].respond_to?(:binmode)
+             datum[:body].binmode
+           end
+           if datum[:body].respond_to?(:rewind)
+             datum[:body].rewind
+           end
+           datum[:body] = datum[:body].read
+          elsif !datum[:body].nil? && !datum[:body].is_a?(String)
+            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)
+            datum[:remote_ip] ||= '127.0.0.1'
+            datum[:response] = {
+              :body       => '',
+              :headers    => {},
+              :status     => 200,
+              :remote_ip  => datum[:remote_ip]
+            }
+
+            stub_datum = case stub.last
+            when Proc
+              stub.last.call(datum)
+            else
+              stub.last
+            end
+
+            datum[:response].merge!(stub_datum.reject {|key,value| key == :headers})
+            if stub_datum.has_key?(:headers)
+              datum[:response][:headers].merge!(stub_datum[:headers])
+            end
+          elsif datum[:allow_unstubbed_requests] != true
+            # if we reach here no stubs matched
+            message = StringIO.new
+            message.puts('no stubs matched')
+            Excon::PrettyPrinter.pp(message, datum)
+            raise(Excon::Errors::StubNotFound.new(message.string))
+          end
+        end
+
+        @stack.request_call(datum)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+module Excon
+  module Middleware
+    class RedirectFollower < Excon::Middleware::Base
+      def self.valid_parameter_keys
+        [
+          :redirects_remaining,
+          :redirect_limit
+        ]
+      end
+
+      def request_call(datum)
+        datum[:redirects_remaining] ||= datum[:redirect_limit] ||
+                                        Excon::DEFAULT_REDIRECT_LIMIT
+        @stack.request_call(datum)
+      end
+
+      def get_header(datum, header)
+        _, header_value = datum[:response][:headers].detect do |key, value|
+          key.casecmp(header) == 0
+        end
+        header_value
+      end
+
+      def response_call(datum)
+        if datum.has_key?(:response)
+          case datum[:response][:status]
+          when 301, 302, 303, 307, 308
+            if datum[:redirects_remaining] <= 0
+              raise Excon::Errors::TooManyRedirects
+            end
+
+            datum[:redirects_remaining] -= 1
+
+            uri_parser = datum[:uri_parser] || Excon.defaults[:uri_parser]
+
+            location = get_header(datum, 'Location')
+            base_uri = Excon::Utils.request_uri(datum)
+            uri = uri_parser.join(base_uri, location)
+
+            # delete old/redirect response and remote_ip
+            response = datum.delete(:response)
+            datum.delete(:remote_ip)
+
+            params = datum.dup
+            params.delete(:connection)
+            params.delete(:password)
+            params.delete(:stack)
+            params.delete(:user)
+
+            if [301, 302, 303].include?(response[:status])
+              params[:method] = :get
+              params.delete(:body)
+              params[:headers].delete('Content-Length')
+            end
+            params[:headers] = datum[:headers].dup
+            params[:headers].delete('Authorization')
+            params[:headers].delete('Proxy-Connection')
+            params[:headers].delete('Proxy-Authorization')
+            params[:headers].delete('Host')
+            params.merge!(
+              :scheme     => uri.scheme || datum[:scheme],
+              :host       => uri.host   || datum[:host],
+              :hostname   => uri.hostname || datum[:hostname],
+              :port       => uri.port   || datum[:port],
+              :path       => uri.path,
+              :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
+
+            response = Excon::Connection.new(params).request
+            datum.merge!({
+              :remote_ip  => response.remote_ip,
+              :response   => response.data
+            })
+          else
+            @stack.response_call(datum)
+          end
+        else
+          @stack.response_call(datum)
+        end
+      end
+    end
+  end
+end