logstash-output-scalyr 0.1.5 → 0.1.10.beta

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/lib/faraday/adapter/net_http_persistent.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # Net::HTTP::Persistent adapter.
-    class NetHttpPersistent < NetHttp
-      dependency 'net/http/persistent'
-
-      private
-
-      def net_http_connection(env)
-        @cached_connection ||=
-          if Net::HTTP::Persistent.instance_method(:initialize)
-                                  .parameters.first == %i[key name]
-            options = { name: 'Faraday' }
-            if @connection_options.key?(:pool_size)
-              options[:pool_size] = @connection_options[:pool_size]
-            end
-            Net::HTTP::Persistent.new(**options)
-          else
-            Net::HTTP::Persistent.new('Faraday')
-          end
-
-        proxy_uri = proxy_uri(env)
-        if @cached_connection.proxy_uri != proxy_uri
-          @cached_connection.proxy = proxy_uri
-        end
-        @cached_connection
-      end
-
-      def proxy_uri(env)
-        proxy_uri = nil
-        if (proxy = env[:request][:proxy])
-          proxy_uri = if proxy[:uri].is_a?(::URI::HTTP)
-                        proxy[:uri].dup
-                      else
-                        ::URI.parse(proxy[:uri].to_s)
-                      end
-          proxy_uri.user = proxy_uri.password = nil
-          # awful patch for net-http-persistent 2.8
-          # not unescaping user/password
-          if proxy[:user]
-            (class << proxy_uri; self; end).class_eval do
-              define_method(:user) { proxy[:user] }
-              define_method(:password) { proxy[:password] }
-            end
-          end
-        end
-        proxy_uri
-      end
-
-      def perform_request(http, env)
-        http.request env[:url], create_request(env)
-      rescue Errno::ETIMEDOUT => e
-        raise Faraday::TimeoutError, e
-      rescue Net::HTTP::Persistent::Error => e
-        raise Faraday::TimeoutError, e if e.message.include? 'Timeout'
-
-        if e.message.include? 'connection refused'
-          raise Faraday::ConnectionFailed, e
-        end
-
-        raise
-      end
-
-      SSL_CONFIGURATIONS = {
-        certificate: :client_cert,
-        private_key: :client_key,
-        ca_file: :ca_file,
-        ssl_version: :version,
-        min_version: :min_version,
-        max_version: :max_version
-      }.freeze
-
-      def configure_ssl(http, ssl)
-        return unless ssl
-
-        http_set(http, :verify_mode, ssl_verify_mode(ssl))
-        http_set(http, :cert_store, ssl_cert_store(ssl))
-
-        SSL_CONFIGURATIONS
-          .select { |_, key| ssl[key] }
-          .each { |target, key| http_set(http, target, ssl[key]) }
-      end
-
-      def http_set(http, attr, value)
-        http.send("#{attr}=", value) if http.send(attr) != value
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/lib/faraday/adapter/patron.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # Patron adapter.
-    class Patron < Faraday::Adapter
-      dependency 'patron'
-
-      def build_connection(env)
-        session = ::Patron::Session.new
-        @config_block&.call(session)
-        if (env[:url].scheme == 'https') && env[:ssl]
-          configure_ssl(session, env[:ssl])
-        end
-
-        if (req = env[:request])
-          configure_timeouts(session, req)
-          configure_proxy(session, req[:proxy])
-        end
-
-        session
-      end
-
-      def call(env)
-        super
-        # TODO: support streaming requests
-        env[:body] = env[:body].read if env[:body].respond_to? :read
-
-        response = connection(env) do |session|
-          begin
-            data = env[:body] ? env[:body].to_s : nil
-            session.request(env[:method], env[:url].to_s,
-                            env[:request_headers], data: data)
-          rescue Errno::ECONNREFUSED, ::Patron::ConnectionFailed
-            raise Faraday::ConnectionFailed, $ERROR_INFO
-          end
-        end
-
-        if (req = env[:request]).stream_response?
-          warn "Streaming downloads for #{self.class.name} " \
-            'are not yet implemented.'
-          req.on_data.call(response.body, response.body.bytesize)
-        end
-        # Remove the "HTTP/1.1 200", leaving just the reason phrase
-        reason_phrase = response.status_line.gsub(/^.* \d{3} /, '')
-
-        save_response(env, response.status, response.body,
-                      response.headers, reason_phrase)
-
-        @app.call env
-      rescue ::Patron::TimeoutError => e
-        if connection_timed_out_message?(e.message)
-          raise Faraday::ConnectionFailed, e
-        end
-
-        raise Faraday::TimeoutError, e
-      rescue ::Patron::Error => e
-        if e.message.include?('code 407')
-          raise Faraday::ConnectionFailed,
-                %(407 "Proxy Authentication Required ")
-        end
-
-        raise Faraday::ConnectionFailed, e
-      end
-
-      if loaded? && defined?(::Patron::Request::VALID_ACTIONS)
-        # HAX: helps but doesn't work completely
-        # https://github.com/toland/patron/issues/34
-        ::Patron::Request::VALID_ACTIONS.tap do |actions|
-          if actions[0].is_a?(Symbol)
-            actions << :patch unless actions.include? :patch
-            actions << :options unless actions.include? :options
-          else
-            # Patron 0.4.20 and up
-            actions << 'PATCH' unless actions.include? 'PATCH'
-            actions << 'OPTIONS' unless actions.include? 'OPTIONS'
-          end
-        end
-      end
-
-      def configure_ssl(session, ssl)
-        if ssl.fetch(:verify, true)
-          session.cacert = ssl[:ca_file]
-        else
-          session.insecure = true
-        end
-      end
-
-      def configure_timeouts(session, req)
-        return unless req
-
-        if (sec = request_timeout(:read, req))
-          session.timeout = sec
-        end
-
-        return unless (sec = request_timeout(:open, req))
-
-        session.connect_timeout = sec
-      end
-
-      def configure_proxy(session, proxy)
-        return unless proxy
-
-        proxy_uri = proxy[:uri].dup
-        proxy_uri.user = proxy[:user] &&
-                         Utils.escape(proxy[:user]).gsub('+', '%20')
-        proxy_uri.password = proxy[:password] &&
-                             Utils.escape(proxy[:password]).gsub('+', '%20')
-        session.proxy = proxy_uri.to_s
-      end
-
-      private
-
-      CURL_TIMEOUT_MESSAGES = [
-        'Connection time-out',
-        'Connection timed out',
-        'Timed out before name resolve',
-        'server connect has timed out',
-        'Resolving timed out',
-        'name lookup timed out',
-        'timed out before SSL',
-        'connect() timed out'
-      ].freeze
-
-      def connection_timed_out_message?(message)
-        CURL_TIMEOUT_MESSAGES.any? do |curl_message|
-          message.include?(curl_message)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/lib/faraday/adapter/rack.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # Sends requests to a Rack app.
-    #
-    # @example
-    #
-    #   class MyRackApp
-    #     def call(env)
-    #       [200, {'Content-Type' => 'text/html'}, ["hello world"]]
-    #     end
-    #   end
-    #
-    #   Faraday.new do |conn|
-    #     conn.adapter :rack, MyRackApp.new
-    #   end
-    class Rack < Faraday::Adapter
-      dependency 'rack/test'
-
-      # not prefixed with "HTTP_"
-      SPECIAL_HEADERS = %w[CONTENT_LENGTH CONTENT_TYPE].freeze
-
-      def initialize(faraday_app, rack_app)
-        super(faraday_app)
-        mock_session = ::Rack::MockSession.new(rack_app)
-        @session     = ::Rack::Test::Session.new(mock_session)
-      end
-
-      def call(env)
-        super
-        rack_env = build_rack_env(env)
-
-        env[:request_headers]&.each do |name, value|
-          name = name.upcase.tr('-', '_')
-          name = "HTTP_#{name}" unless SPECIAL_HEADERS.include? name
-          rack_env[name] = value
-        end
-
-        timeout = request_timeout(:open, env[:request])
-        timeout ||= request_timeout(:read, env[:request])
-        response = if timeout
-                     Timer.timeout(timeout, Faraday::TimeoutError) do
-                       execute_request(env, rack_env)
-                     end
-                   else
-                     execute_request(env, rack_env)
-                   end
-
-        if (req = env[:request]).stream_response?
-          warn "Streaming downloads for #{self.class.name} " \
-            'are not yet implemented.'
-          req.on_data.call(response.body, response.body.bytesize)
-        end
-
-        save_response(env, response.status, response.body, response.headers)
-        @app.call env
-      end
-
-      private
-
-      def execute_request(env, rack_env)
-        @session.request(env[:url].to_s, rack_env)
-      end
-
-      def build_rack_env(env)
-        {
-          method: env[:method],
-          input: env[:body].respond_to?(:read) ? env[:body].read : env[:body],
-          'rack.url_scheme' => env[:url].scheme
-        }
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/lib/faraday/adapter/test.rb

@@ -1,246 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # @example
-    #   test = Faraday::Connection.new do
-    #     use Faraday::Adapter::Test do |stub|
-    #       # Define matcher to match the request
-    #       stub.get '/resource.json' do
-    #         # return static content
-    #         [200, {'Content-Type' => 'application/json'}, 'hi world']
-    #       end
-    #
-    #       # response with content generated based on request
-    #       stub.get '/showget' do |env|
-    #         [200, {'Content-Type' => 'text/plain'}, env[:method].to_s]
-    #       end
-    #
-    #       # A regular expression can be used as matching filter
-    #       stub.get /\A\/items\/(\d+)\z/ do |env, meta|
-    #         # in case regular expression is used, an instance of MatchData
-    #         # can be received
-    #         [200,
-    #          {'Content-Type' => 'text/plain'},
-    #          "showing item: #{meta[:match_data][1]}"
-    #         ]
-    #       end
-    #     end
-    #   end
-    #
-    #   resp = test.get '/resource.json'
-    #   resp.body # => 'hi world'
-    #
-    #   resp = test.get '/showget'
-    #   resp.body # => 'get'
-    #
-    #   resp = test.get '/items/1'
-    #   resp.body # => 'showing item: 1'
-    #
-    #   resp = test.get '/items/2'
-    #   resp.body # => 'showing item: 2'
-    class Test < Faraday::Adapter
-      attr_accessor :stubs
-
-      # A stack of Stubs
-      class Stubs
-        class NotFound < StandardError
-        end
-
-        def initialize
-          # { get: [Stub, Stub] }
-          @stack = {}
-          @consumed = {}
-          yield(self) if block_given?
-        end
-
-        def empty?
-          @stack.empty?
-        end
-
-        def match(request_method, host, path, headers, body)
-          return false unless @stack.key?(request_method)
-
-          stack = @stack[request_method]
-          consumed = (@consumed[request_method] ||= [])
-
-          stub, meta = matches?(stack, host, path, headers, body)
-          if stub
-            consumed << stack.delete(stub)
-            return stub, meta
-          end
-          matches?(consumed, host, path, headers, body)
-        end
-
-        def get(path, headers = {}, &block)
-          new_stub(:get, path, headers, &block)
-        end
-
-        def head(path, headers = {}, &block)
-          new_stub(:head, path, headers, &block)
-        end
-
-        def post(path, body = nil, headers = {}, &block)
-          new_stub(:post, path, headers, body, &block)
-        end
-
-        def put(path, body = nil, headers = {}, &block)
-          new_stub(:put, path, headers, body, &block)
-        end
-
-        def patch(path, body = nil, headers = {}, &block)
-          new_stub(:patch, path, headers, body, &block)
-        end
-
-        def delete(path, headers = {}, &block)
-          new_stub(:delete, path, headers, &block)
-        end
-
-        def options(path, headers = {}, &block)
-          new_stub(:options, path, headers, &block)
-        end
-
-        # Raises an error if any of the stubbed calls have not been made.
-        def verify_stubbed_calls
-          failed_stubs = []
-          @stack.each do |method, stubs|
-            next if stubs.empty?
-
-            failed_stubs.concat(
-              stubs.map do |stub|
-                "Expected #{method} #{stub}."
-              end
-            )
-          end
-          raise failed_stubs.join(' ') unless failed_stubs.empty?
-        end
-
-        protected
-
-        def new_stub(request_method, path, headers = {}, body = nil, &block)
-          normalized_path, host =
-            if path.is_a?(Regexp)
-              path
-            else
-              [
-                Faraday::Utils.normalize_path(path),
-                Faraday::Utils.URI(path).host
-              ]
-            end
-
-          stub = Stub.new(host, normalized_path, headers, body, block)
-          (@stack[request_method] ||= []) << stub
-        end
-
-        def matches?(stack, host, path, headers, body)
-          stack.each do |stub|
-            match_result, meta = stub.matches?(host, path, headers, body)
-            return stub, meta if match_result
-          end
-          nil
-        end
-      end
-
-      # Stub request
-      # rubocop:disable Style/StructInheritance
-      class Stub < Struct.new(:host, :path, :params, :headers, :body, :block)
-        # rubocop:enable Style/StructInheritance
-        def initialize(host, full, headers, body, block)
-          path, query = full.respond_to?(:split) ? full.split('?') : full
-          params =
-            if query
-              Faraday::Utils.parse_nested_query(query)
-            else
-              {}
-            end
-
-          super(host, path, params, headers, body, block)
-        end
-
-        def matches?(request_host, request_uri, request_headers, request_body)
-          request_path, request_query = request_uri.split('?')
-          request_params =
-            if request_query
-              Faraday::Utils.parse_nested_query(request_query)
-            else
-              {}
-            end
-          # meta is a hash used as carrier
-          # that will be yielded to consumer block
-          meta = {}
-          [(host.nil? || host == request_host) &&
-            path_match?(request_path, meta) &&
-            params_match?(request_params) &&
-            (body.to_s.size.zero? || request_body == body) &&
-            headers_match?(request_headers), meta]
-        end
-
-        def path_match?(request_path, meta)
-          if path.is_a?(Regexp)
-            !!(meta[:match_data] = path.match(request_path))
-          else
-            path == request_path
-          end
-        end
-
-        def params_match?(request_params)
-          params.keys.all? do |key|
-            request_params[key] == params[key]
-          end
-        end
-
-        def headers_match?(request_headers)
-          headers.keys.all? do |key|
-            request_headers[key] == headers[key]
-          end
-        end
-
-        def to_s
-          "#{path} #{body}"
-        end
-      end
-
-      def initialize(app, stubs = nil, &block)
-        super(app)
-        @stubs = stubs || Stubs.new
-        configure(&block) if block
-      end
-
-      def configure
-        yield(stubs)
-      end
-
-      def call(env)
-        super
-        host = env[:url].host
-        normalized_path = Faraday::Utils.normalize_path(env[:url])
-        params_encoder = env.request.params_encoder ||
-                         Faraday::Utils.default_params_encoder
-
-        stub, meta = stubs.match(env[:method], host, normalized_path,
-                                 env.request_headers, env[:body])
-
-        unless stub
-          raise Stubs::NotFound, "no stubbed request for #{env[:method]} "\
-                                 "#{normalized_path} #{env[:body]}"
-        end
-
-        env[:params] = if (query = env[:url].query)
-                         params_encoder.decode(query)
-                       else
-                         {}
-                       end
-        block_arity = stub.block.arity
-        status, headers, body =
-          if block_arity >= 0
-            stub.block.call(*[env, meta].take(block_arity))
-          else
-            stub.block.call(env, meta)
-          end
-        save_response(env, status, body, headers)
-
-        @app.call(env)
-      end
-    end
-  end
-end