logstash-output-scalyr 0.1.3 → 0.1.8

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/lib/faraday/request/token_authentication.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Request
-    # TokenAuthentication is a middleware that adds a 'Token' header to a
-    # Faraday request.
-    class TokenAuthentication < load_middleware(:authorization)
-      # Public
-      def self.header(token, options = nil)
-        options ||= {}
-        options[:token] = token
-        super(:Token, options)
-      end
-
-      def initialize(app, token, options = nil)
-        super(app, token, options)
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/lib/faraday/request/url_encoded.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Request
-    # Middleware for supporting urlencoded requests.
-    class UrlEncoded < Faraday::Middleware
-      unless defined?(::Faraday::Request::UrlEncoded::CONTENT_TYPE)
-        CONTENT_TYPE = 'Content-Type'
-      end
-
-      class << self
-        attr_accessor :mime_type
-      end
-      self.mime_type = 'application/x-www-form-urlencoded'
-
-      # Encodes as "application/x-www-form-urlencoded" if not already encoded or
-      # of another type.
-      #
-      # @param env [Faraday::Env]
-      def call(env)
-        match_content_type(env) do |data|
-          params = Faraday::Utils::ParamsHash[data]
-          env.body = params.to_query(env.params_encoder)
-        end
-        @app.call env
-      end
-
-      # @param env [Faraday::Env]
-      # @yield [request_body] Body of the request
-      def match_content_type(env)
-        return unless process_request?(env)
-
-        env.request_headers[CONTENT_TYPE] ||= self.class.mime_type
-        yield(env.body) unless env.body.respond_to?(:to_str)
-      end
-
-      # @param env [Faraday::Env]
-      #
-      # @return [Boolean] True if the request has a body and its Content-Type is
-      #                   urlencoded.
-      def process_request?(env)
-        type = request_type(env)
-        env.body && (type.empty? || (type == self.class.mime_type))
-      end
-
-      # @param env [Faraday::Env]
-      #
-      # @return [String]
-      def request_type(env)
-        type = env.request_headers[CONTENT_TYPE].to_s
-        type = type.split(';', 2).first if type.index(';')
-        type
-      end
-    end
-  end
-end

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

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-module Faraday
-  # Response represents an HTTP response from making an HTTP request.
-  class Response
-    # Used for simple response middleware.
-    class Middleware < Faraday::Middleware
-      def call(env)
-        @app.call(env).on_complete do |environment|
-          on_complete(environment)
-        end
-      end
-
-      # Override this to modify the environment after the response has finished.
-      # Calls the `parse` method if defined
-      # `parse` method can be defined as private, public and protected
-      def on_complete(env)
-        return unless respond_to?(:parse, true) && env.parse_body?
-
-        env.body = parse(env.body)
-      end
-    end
-
-    extend Forwardable
-    extend MiddlewareRegistry
-
-    register_middleware File.expand_path('response', __dir__),
-                        raise_error: [:RaiseError, 'raise_error'],
-                        logger: [:Logger, 'logger']
-
-    def initialize(env = nil)
-      @env = Env.from(env) if env
-      @on_complete_callbacks = []
-    end
-
-    attr_reader :env
-
-    def status
-      finished? ? env.status : nil
-    end
-
-    def reason_phrase
-      finished? ? env.reason_phrase : nil
-    end
-
-    def headers
-      finished? ? env.response_headers : {}
-    end
-    def_delegator :headers, :[]
-
-    def body
-      finished? ? env.body : nil
-    end
-
-    def finished?
-      !!env
-    end
-
-    def on_complete(&block)
-      if !finished?
-        @on_complete_callbacks << block
-      else
-        yield(env)
-      end
-      self
-    end
-
-    def finish(env)
-      raise 'response already finished' if finished?
-
-      @env = env.is_a?(Env) ? env : Env.from(env)
-      @on_complete_callbacks.each { |callback| callback.call(@env) }
-      self
-    end
-
-    def success?
-      finished? && env.success?
-    end
-
-    def to_hash
-      {
-        status: env.status, body: env.body,
-        response_headers: env.response_headers
-      }
-    end
-
-    # because @on_complete_callbacks cannot be marshalled
-    def marshal_dump
-      finished? ? to_hash : nil
-    end
-
-    def marshal_load(env)
-      @env = Env.from(env)
-    end
-
-    # Expand the env with more properties, without overriding existing ones.
-    # Useful for applying request params after restoring a marshalled Response.
-    def apply_request(request_env)
-      raise "response didn't finish yet" unless finished?
-
-      @env = Env.from(request_env).update(@env)
-      self
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/lib/faraday/response/logger.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-require 'faraday/logging/formatter'
-
-module Faraday
-  class Response
-    # Logger is a middleware that logs internal events in the HTTP request
-    # lifecycle to a given Logger object. By default, this logs to STDOUT. See
-    # Faraday::Logging::Formatter to see specifically what is logged.
-    class Logger < Middleware
-      def initialize(app, logger = nil, options = {})
-        super(app)
-        logger ||= begin
-          require 'logger'
-          ::Logger.new($stdout)
-        end
-        formatter_class = options.delete(:formatter) || Logging::Formatter
-        @formatter = formatter_class.new(logger: logger, options: options)
-        yield @formatter if block_given?
-      end
-
-      def call(env)
-        @formatter.request(env)
-        super
-      end
-
-      def on_complete(env)
-        @formatter.response(env)
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/lib/faraday/response/raise_error.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Response
-    # RaiseError is a Faraday middleware that raises exceptions on common HTTP
-    # client or server error responses.
-    class RaiseError < Middleware
-      # rubocop:disable Naming/ConstantName
-      ClientErrorStatuses = (400...500).freeze
-      ServerErrorStatuses = (500...600).freeze
-      # rubocop:enable Naming/ConstantName
-
-      def on_complete(env)
-        case env[:status]
-        when 400
-          raise Faraday::BadRequestError, response_values(env)
-        when 401
-          raise Faraday::UnauthorizedError, response_values(env)
-        when 403
-          raise Faraday::ForbiddenError, response_values(env)
-        when 404
-          raise Faraday::ResourceNotFound, response_values(env)
-        when 407
-          # mimic the behavior that we get with proxy requests with HTTPS
-          msg = %(407 "Proxy Authentication Required")
-          raise Faraday::ProxyAuthError.new(msg, response_values(env))
-        when 409
-          raise Faraday::ConflictError, response_values(env)
-        when 422
-          raise Faraday::UnprocessableEntityError, response_values(env)
-        when ClientErrorStatuses
-          raise Faraday::ClientError, response_values(env)
-        when ServerErrorStatuses
-          raise Faraday::ServerError, response_values(env)
-        when nil
-          raise Faraday::NilStatusError, response_values(env)
-        end
-      end
-
-      def response_values(env)
-        { status: env.status, headers: env.response_headers, body: env.body }
-      end
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require 'faraday/utils/headers'
-require 'faraday/utils/params_hash'
-
-module Faraday
-  # Utils contains various static helper methods.
-  module Utils
-    module_function
-
-    def build_query(params)
-      FlatParamsEncoder.encode(params)
-    end
-
-    def build_nested_query(params)
-      NestedParamsEncoder.encode(params)
-    end
-
-    def default_space_encoding
-      @default_space_encoding ||= '+'
-    end
-
-    class << self
-      attr_writer :default_space_encoding
-    end
-
-    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/.freeze
-
-    def escape(str)
-      str.to_s.gsub(ESCAPE_RE) do |match|
-        '%' + match.unpack('H2' * match.bytesize).join('%').upcase
-      end.gsub(' ', default_space_encoding)
-    end
-
-    def unescape(str)
-      CGI.unescape str.to_s
-    end
-
-    DEFAULT_SEP = /[&;] */n.freeze
-
-    # Adapted from Rack
-    def parse_query(query)
-      FlatParamsEncoder.decode(query)
-    end
-
-    def parse_nested_query(query)
-      NestedParamsEncoder.decode(query)
-    end
-
-    def default_params_encoder
-      @default_params_encoder ||= NestedParamsEncoder
-    end
-
-    class << self
-      attr_writer :default_params_encoder
-    end
-
-    # Normalize URI() behavior across Ruby versions
-    #
-    # url - A String or URI.
-    #
-    # Returns a parsed URI.
-    def URI(url) # rubocop:disable Naming/MethodName
-      if url.respond_to?(:host)
-        url
-      elsif url.respond_to?(:to_str)
-        default_uri_parser.call(url)
-      else
-        raise ArgumentError, 'bad argument (expected URI object or URI string)'
-      end
-    end
-
-    def default_uri_parser
-      @default_uri_parser ||= begin
-        require 'uri'
-        Kernel.method(:URI)
-      end
-    end
-
-    def default_uri_parser=(parser)
-      @default_uri_parser = if parser.respond_to?(:call) || parser.nil?
-                              parser
-                            else
-                              parser.method(:parse)
-                            end
-    end
-
-    # Receives a String or URI and returns just
-    # the path with the query string sorted.
-    def normalize_path(url)
-      url = URI(url)
-      (url.path.start_with?('/') ? url.path : '/' + url.path) +
-        (url.query ? "?#{sort_query_params(url.query)}" : '')
-    end
-
-    # Recursive hash update
-    def deep_merge!(target, hash)
-      hash.each do |key, value|
-        target[key] = if value.is_a?(Hash) && target[key].is_a?(Hash)
-                        deep_merge(target[key], value)
-                      else
-                        value
-                      end
-      end
-      target
-    end
-
-    # Recursive hash merge
-    def deep_merge(source, hash)
-      deep_merge!(source.dup, hash)
-    end
-
-    def sort_query_params(query)
-      query.split('&').sort.join('&')
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/lib/faraday/utils/headers.rb

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  module Utils
-    # A case-insensitive Hash that preserves the original case of a header
-    # when set.
-    #
-    # Adapted from Rack::Utils::HeaderHash
-    class Headers < ::Hash
-      def self.from(value)
-        new(value)
-      end
-
-      def self.allocate
-        new_self = super
-        new_self.initialize_names
-        new_self
-      end
-
-      def initialize(hash = nil)
-        super()
-        @names = {}
-        update(hash || {})
-      end
-
-      def initialize_names
-        @names = {}
-      end
-
-      # on dup/clone, we need to duplicate @names hash
-      def initialize_copy(other)
-        super
-        @names = other.names.dup
-      end
-
-      # need to synchronize concurrent writes to the shared KeyMap
-      keymap_mutex = Mutex.new
-
-      # symbol -> string mapper + cache
-      KeyMap = Hash.new do |map, key|
-        value = if key.respond_to?(:to_str)
-                  key
-                else
-                  key.to_s.split('_') # user_agent: %w(user agent)
-                     .each(&:capitalize!) # => %w(User Agent)
-                     .join('-') # => "User-Agent"
-                end
-        keymap_mutex.synchronize { map[key] = value }
-      end
-      KeyMap[:etag] = 'ETag'
-
-      def [](key)
-        key = KeyMap[key]
-        super(key) || super(@names[key.downcase])
-      end
-
-      def []=(key, val)
-        key = KeyMap[key]
-        key = (@names[key.downcase] ||= key)
-        # join multiple values with a comma
-        val = val.to_ary.join(', ') if val.respond_to?(:to_ary)
-        super(key, val)
-      end
-
-      def fetch(key, *args, &block)
-        key = KeyMap[key]
-        key = @names.fetch(key.downcase, key)
-        super(key, *args, &block)
-      end
-
-      def delete(key)
-        key = KeyMap[key]
-        key = @names[key.downcase]
-        return unless key
-
-        @names.delete key.downcase
-        super(key)
-      end
-
-      def include?(key)
-        @names.include? key.downcase
-      end
-
-      alias has_key? include?
-      alias member? include?
-      alias key? include?
-
-      def merge!(other)
-        other.each { |k, v| self[k] = v }
-        self
-      end
-
-      alias update merge!
-
-      def merge(other)
-        hash = dup
-        hash.merge! other
-      end
-
-      def replace(other)
-        clear
-        @names.clear
-        update other
-        self
-      end
-
-      def to_hash
-        ::Hash.new.update(self)
-      end
-
-      def parse(header_string)
-        return unless header_string && !header_string.empty?
-
-        headers = header_string.split(/\r\n/)
-
-        # Find the last set of response headers.
-        start_index = headers.rindex { |x| x.match(%r{^HTTP/}) } || 0
-        last_response = headers.slice(start_index, headers.size)
-
-        last_response
-          .tap { |a| a.shift if a.first.start_with?('HTTP/') }
-          .map { |h| h.split(/:\s*/, 2) } # split key and value
-          .reject { |p| p[0].nil? } # ignore blank lines
-          .each { |key, value| add_parsed(key, value) }
-      end
-
-      protected
-
-      attr_reader :names
-
-      private
-
-      # Join multiple values with a comma.
-      def add_parsed(key, value)
-        self[key] ? self[key] << ', ' << value : self[key] = value
-      end
-    end
-  end
-end