logstash-output-scalyr 0.1.5 → 0.1.6

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # ConnectionOptions contains the configurable properties for a Faraday
-  # connection object.
-  class ConnectionOptions < Options.new(:request, :proxy, :ssl, :builder, :url,
-                                        :parallel_manager, :params, :headers,
-                                        :builder_class)
-
-    options request: RequestOptions, ssl: SSLOptions
-
-    memoized(:request) { self.class.options_for(:request).new }
-
-    memoized(:ssl) { self.class.options_for(:ssl).new }
-
-    memoized(:builder_class) { RackBuilder }
-
-    def new_builder(block)
-      builder_class.new(&block)
-    end
-  end
-end

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

@@ -1,181 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # @!attribute method
-  #   @return [Symbol] HTTP method (`:get`, `:post`)
-  #
-  # @!attribute body
-  #   @return [String] The request body that will eventually be converted to a
-  #   string.
-  #
-  # @!attribute url
-  #   @return [URI] URI instance for the current request.
-  #
-  # @!attribute request
-  #   @return [Hash] options for configuring the request.
-  #   Options for configuring the request.
-  #
-  #   - `:timeout`  open/read timeout Integer in seconds
-  #   - `:open_timeout` - read timeout Integer in seconds
-  #   - `:on_data`      - Proc for streaming
-  #   - `:proxy`        - Hash of proxy options
-  #       - `:uri`        - Proxy Server URI
-  #       - `:user`       - Proxy server username
-  #       - `:password`   - Proxy server password
-  #
-  # @!attribute request_headers
-  #   @return [Hash] HTTP Headers to be sent to the server.
-  #
-  # @!attribute ssl
-  #   @return [Hash] options for configuring SSL requests
-  #
-  # @!attribute parallel_manager
-  #   @return [Object] sent if the connection is in parallel mode
-  #
-  # @!attribute params
-  #   @return [Hash]
-  #
-  # @!attribute response
-  #   @return [Response]
-  #
-  # @!attribute response_headers
-  #   @return [Hash] HTTP headers from the server
-  #
-  # @!attribute status
-  #   @return [Integer] HTTP response status code
-  #
-  # @!attribute reason_phrase
-  #   @return [String]
-  class Env < Options.new(:method, :request_body, :url, :request,
-                          :request_headers, :ssl, :parallel_manager, :params,
-                          :response, :response_headers, :status,
-                          :reason_phrase, :response_body)
-
-    # rubocop:disable Naming/ConstantName
-    ContentLength = 'Content-Length'
-    StatusesWithoutBody = Set.new [204, 304]
-    SuccessfulStatuses = (200..299).freeze
-    # rubocop:enable Naming/ConstantName
-
-    # A Set of HTTP verbs that typically send a body.  If no body is set for
-    # these requests, the Content-Length header is set to 0.
-    MethodsWithBodies = Set.new(Faraday::METHODS_WITH_BODY.map(&:to_sym))
-
-    options request: RequestOptions,
-            request_headers: Utils::Headers, response_headers: Utils::Headers
-
-    extend Forwardable
-
-    def_delegators :request, :params_encoder
-
-    # Build a new Env from given value. Respects and updates `custom_members`.
-    #
-    # @param value [Object] a value fitting Option.from(v).
-    # @return [Env] from given value
-    def self.from(value)
-      env = super(value)
-      if value.respond_to?(:custom_members)
-        env.custom_members.update(value.custom_members)
-      end
-      env
-    end
-
-    # @param key [Object]
-    def [](key)
-      return self[current_body] if key == :body
-
-      if in_member_set?(key)
-        super(key)
-      else
-        custom_members[key]
-      end
-    end
-
-    # @param key [Object]
-    # @param value [Object]
-    def []=(key, value)
-      if key == :body
-        super(current_body, value)
-        return
-      end
-
-      if in_member_set?(key)
-        super(key, value)
-      else
-        custom_members[key] = value
-      end
-    end
-
-    def current_body
-      !!status ? :response_body : :request_body
-    end
-
-    def body
-      self[:body]
-    end
-
-    def body=(value)
-      self[:body] = value
-    end
-
-    # @return [Boolean] true if status is in the set of {SuccessfulStatuses}.
-    def success?
-      SuccessfulStatuses.include?(status)
-    end
-
-    # @return [Boolean] true if there's no body yet, and the method is in the
-    # set of {MethodsWithBodies}.
-    def needs_body?
-      !body && MethodsWithBodies.include?(method)
-    end
-
-    # Sets content length to zero and the body to the empty string.
-    def clear_body
-      request_headers[ContentLength] = '0'
-      self.body = +''
-    end
-
-    # @return [Boolean] true if the status isn't in the set of
-    # {StatusesWithoutBody}.
-    def parse_body?
-      !StatusesWithoutBody.include?(status)
-    end
-
-    # @return [Boolean] true if there is a parallel_manager
-    def parallel?
-      !!parallel_manager
-    end
-
-    def inspect
-      attrs = [nil]
-      members.each do |mem|
-        if (value = send(mem))
-          attrs << "@#{mem}=#{value.inspect}"
-        end
-      end
-      attrs << "@custom=#{custom_members.inspect}" unless custom_members.empty?
-      %(#<#{self.class}#{attrs.join(' ')}>)
-    end
-
-    # @private
-    def custom_members
-      @custom_members ||= {}
-    end
-
-    # @private
-    if members.first.is_a?(Symbol)
-      def in_member_set?(key)
-        self.class.member_set.include?(key.to_sym)
-      end
-    else
-      def in_member_set?(key)
-        self.class.member_set.include?(key.to_s)
-      end
-    end
-
-    # @private
-    def self.member_set
-      @member_set ||= Set.new(members)
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # ProxyOptions contains the configurable properties for the proxy
-  # configuration used when making an HTTP request.
-  class ProxyOptions < Options.new(:uri, :user, :password)
-    extend Forwardable
-    def_delegators :uri, :scheme, :scheme=, :host, :host=, :port, :port=,
-                   :path, :path=
-
-    def self.from(value)
-      case value
-      when String
-        value = { uri: Utils.URI(value) }
-      when URI
-        value = { uri: value }
-      when Hash, Options
-        if (uri = value.delete(:uri))
-          value[:uri] = Utils.URI(uri)
-        end
-      end
-      super(value)
-    end
-
-    memoized(:user) { uri&.user && Utils.unescape(uri.user) }
-    memoized(:password) { uri&.password && Utils.unescape(uri.password) }
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # RequestOptions contains the configurable properties for a Faraday request.
-  class RequestOptions < Options.new(:params_encoder, :proxy, :bind,
-                                     :timeout, :open_timeout, :read_timeout,
-                                     :write_timeout, :boundary, :oauth,
-                                     :context, :on_data)
-
-    def []=(key, value)
-      if key && key.to_sym == :proxy
-        super(key, value ? ProxyOptions.from(value) : nil)
-      else
-        super(key, value)
-      end
-    end
-
-    def stream_response?
-      on_data.is_a?(Proc)
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # SSL-related options.
-  #
-  # @!attribute verify
-  #   @return [Boolean] whether to verify SSL certificates or not
-  #
-  # @!attribute ca_file
-  #   @return [String] CA file
-  #
-  # @!attribute ca_path
-  #   @return [String] CA path
-  #
-  # @!attribute verify_mode
-  #   @return [Integer] Any `OpenSSL::SSL::` constant (see https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL.html)
-  #
-  # @!attribute cert_store
-  #   @return [OpenSSL::X509::Store] certificate store
-  #
-  # @!attribute client_cert
-  #   @return [String, OpenSSL::X509::Certificate] client certificate
-  #
-  # @!attribute client_key
-  #   @return [String, OpenSSL::PKey::RSA, OpenSSL::PKey::DSA] client key
-  #
-  # @!attribute certificate
-  #   @return [OpenSSL::X509::Certificate] certificate (Excon only)
-  #
-  # @!attribute private_key
-  #   @return [OpenSSL::PKey::RSA, OpenSSL::PKey::DSA] private key (Excon only)
-  #
-  # @!attribute verify_depth
-  #   @return [Integer] maximum depth for the certificate chain verification
-  #
-  # @!attribute version
-  #   @return [String, Symbol] SSL version (see https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html#method-i-ssl_version-3D)
-  #
-  # @!attribute min_version
-  #   @return [String, Symbol] minimum SSL version (see https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html#method-i-min_version-3D)
-  #
-  # @!attribute max_version
-  #   @return [String, Symbol] maximum SSL version (see https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html#method-i-max_version-3D)
-  class SSLOptions < Options.new(:verify, :ca_file, :ca_path, :verify_mode,
-                                 :cert_store, :client_cert, :client_key,
-                                 :certificate, :private_key, :verify_depth,
-                                 :version, :min_version, :max_version)
-
-    # @return [Boolean] true if should verify
-    def verify?
-      verify != false
-    end
-
-    # @return [Boolean] true if should not verify
-    def disable?
-      !verify?
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # Multipart value used to POST data with a content type.
-  class ParamPart
-    # @param value [String] Uploaded content as a String.
-    # @param content_type [String] String content type of the value.
-    # @param content_id [String] Optional String of this value's Content-ID.
-    #
-    # @return [Faraday::ParamPart]
-    def initialize(value, content_type, content_id = nil)
-      @value = value
-      @content_type = content_type
-      @content_id = content_id
-    end
-
-    # Converts this value to a form part.
-    #
-    # @param boundary [String] String multipart boundary that must not exist in
-    #   the content exactly.
-    # @param key [String] String key name for this value.
-    #
-    # @return [Faraday::Parts::Part]
-    def to_part(boundary, key)
-      Faraday::Parts::Part.new(boundary, key, value, headers)
-    end
-
-    # Returns a Hash of String key/value pairs.
-    #
-    # @return [Hash]
-    def headers
-      {
-        'Content-Type' => content_type,
-        'Content-ID' => content_id
-      }
-    end
-
-    # The content to upload.
-    #
-    # @return [String]
-    attr_reader :value
-
-    # The value's content type.
-    #
-    # @return [String]
-    attr_reader :content_type
-
-    # The value's content ID, if given.
-    #
-    # @return [String, nil]
-    attr_reader :content_id
-  end
-end

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

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-require 'faraday/encoders/nested_params_encoder'
-require 'faraday/encoders/flat_params_encoder'

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

@@ -1,248 +0,0 @@
-# frozen_string_literal: true
-
-require 'faraday/adapter_registry'
-
-module Faraday
-  # A Builder that processes requests into responses by passing through an inner
-  # middleware stack (heavily inspired by Rack).
-  #
-  # @example
-  #   Faraday::Connection.new(url: 'http://sushi.com') do |builder|
-  #     builder.request  :url_encoded  # Faraday::Request::UrlEncoded
-  #     builder.adapter  :net_http     # Faraday::Adapter::NetHttp
-  #   end
-  class RackBuilder
-    # Used to detect missing arguments
-    NO_ARGUMENT = Object.new
-
-    attr_accessor :handlers
-
-    # Error raised when trying to modify the stack after calling `lock!`
-    class StackLocked < RuntimeError; end
-
-    # borrowed from ActiveSupport::Dependencies::Reference &
-    # ActionDispatch::MiddlewareStack::Middleware
-    class Handler
-      REGISTRY = Faraday::AdapterRegistry.new
-
-      attr_reader :name
-
-      def initialize(klass, *args, &block)
-        @name = klass.to_s
-        REGISTRY.set(klass) if klass.respond_to?(:name)
-        @args = args
-        @block = block
-      end
-
-      def klass
-        REGISTRY.get(@name)
-      end
-
-      def inspect
-        @name
-      end
-
-      def ==(other)
-        if other.is_a? Handler
-          name == other.name
-        elsif other.respond_to? :name
-          klass == other
-        else
-          @name == other.to_s
-        end
-      end
-
-      def build(app = nil)
-        klass.new(app, *@args, &@block)
-      end
-    end
-
-    def initialize(handlers = [], adapter = nil, &block)
-      @adapter = adapter
-      @handlers = handlers
-      if block_given?
-        build(&block)
-      elsif @handlers.empty?
-        # default stack, if nothing else is configured
-        request :url_encoded
-        self.adapter Faraday.default_adapter
-      end
-    end
-
-    def build(options = {})
-      raise_if_locked
-      @handlers.clear unless options[:keep]
-      yield(self) if block_given?
-      adapter(Faraday.default_adapter) unless @adapter
-    end
-
-    def [](idx)
-      @handlers[idx]
-    end
-
-    # Locks the middleware stack to ensure no further modifications are made.
-    def lock!
-      @handlers.freeze
-    end
-
-    def locked?
-      @handlers.frozen?
-    end
-
-    def use(klass, *args, &block)
-      if klass.is_a? Symbol
-        use_symbol(Faraday::Middleware, klass, *args, &block)
-      else
-        raise_if_locked
-        raise_if_adapter(klass)
-        @handlers << self.class::Handler.new(klass, *args, &block)
-      end
-    end
-
-    def request(key, *args, &block)
-      use_symbol(Faraday::Request, key, *args, &block)
-    end
-
-    def response(key, *args, &block)
-      use_symbol(Faraday::Response, key, *args, &block)
-    end
-
-    def adapter(klass = NO_ARGUMENT, *args, &block)
-      return @adapter if klass == NO_ARGUMENT
-
-      klass = Faraday::Adapter.lookup_middleware(klass) if klass.is_a?(Symbol)
-      @adapter = self.class::Handler.new(klass, *args, &block)
-    end
-
-    ## methods to push onto the various positions in the stack:
-
-    def insert(index, *args, &block)
-      raise_if_locked
-      index = assert_index(index)
-      handler = self.class::Handler.new(*args, &block)
-      @handlers.insert(index, handler)
-    end
-
-    alias insert_before insert
-
-    def insert_after(index, *args, &block)
-      index = assert_index(index)
-      insert(index + 1, *args, &block)
-    end
-
-    def swap(index, *args, &block)
-      raise_if_locked
-      index = assert_index(index)
-      @handlers.delete_at(index)
-      insert(index, *args, &block)
-    end
-
-    def delete(handler)
-      raise_if_locked
-      @handlers.delete(handler)
-    end
-
-    # Processes a Request into a Response by passing it through this Builder's
-    # middleware stack.
-    #
-    # @param connection [Faraday::Connection]
-    # @param request [Faraday::Request]
-    #
-    # @return [Faraday::Response]
-    def build_response(connection, request)
-      app.call(build_env(connection, request))
-    end
-
-    # The "rack app" wrapped in middleware. All requests are sent here.
-    #
-    # The builder is responsible for creating the app object. After this,
-    # the builder gets locked to ensure no further modifications are made
-    # to the middleware stack.
-    #
-    # Returns an object that responds to `call` and returns a Response.
-    def app
-      @app ||= begin
-        lock!
-        to_app
-      end
-    end
-
-    def to_app
-      # last added handler is the deepest and thus closest to the inner app
-      # adapter is always the last one
-      @handlers.reverse.inject(@adapter.build) do |app, handler|
-        handler.build(app)
-      end
-    end
-
-    def ==(other)
-      other.is_a?(self.class) &&
-        @handlers == other.handlers &&
-        @adapter == other.adapter
-    end
-
-    def dup
-      self.class.new(@handlers.dup, @adapter.dup)
-    end
-
-    # ENV Keys
-    # :method - a symbolized request method (:get, :post)
-    # :body   - the request body that will eventually be converted to a string.
-    # :url    - URI instance for the current request.
-    # :status           - HTTP response status code
-    # :request_headers  - hash of HTTP Headers to be sent to the server
-    # :response_headers - Hash of HTTP headers from the server
-    # :parallel_manager - sent if the connection is in parallel mode
-    # :request - Hash of options for configuring the request.
-    #   :timeout      - open/read timeout Integer in seconds
-    #   :open_timeout - read timeout Integer in seconds
-    #   :proxy        - Hash of proxy options
-    #     :uri        - Proxy Server URI
-    #     :user       - Proxy server username
-    #     :password   - Proxy server password
-    # :ssl - Hash of options for configuring SSL requests.
-    def build_env(connection, request)
-      exclusive_url = connection.build_exclusive_url(
-        request.path, request.params,
-        request.options.params_encoder
-      )
-
-      Env.new(request.method, request.body, exclusive_url,
-              request.options, request.headers, connection.ssl,
-              connection.parallel_manager)
-    end
-
-    private
-
-    LOCK_ERR = "can't modify middleware stack after making a request"
-
-    def raise_if_locked
-      raise StackLocked, LOCK_ERR if locked?
-    end
-
-    def raise_if_adapter(klass)
-      return unless is_adapter?(klass)
-
-      raise 'Adapter should be set using the `adapter` method, not `use`'
-    end
-
-    def adapter_set?
-      !@adapter.nil?
-    end
-
-    def is_adapter?(klass) # rubocop:disable Naming/PredicateName
-      klass.ancestors.include?(Faraday::Adapter)
-    end
-
-    def use_symbol(mod, key, *args, &block)
-      use(mod.lookup_middleware(key), *args, &block)
-    end
-
-    def assert_index(index)
-      idx = index.is_a?(Integer) ? index : @handlers.index(index)
-      raise "No such handler: #{index.inspect}" unless idx
-
-      idx
-    end
-  end
-end