logstash-output-scalyr 0.1.5 → 0.1.6

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/Rakefile

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new(:spec)
-
-task default: :spec

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/examples/client_spec.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-# Requires Ruby with rspec and faraday gems.
-# rspec client_spec.rb
-
-require 'faraday'
-require 'json'
-
-# Example API client
-class Client
-  def initialize(conn)
-    @conn = conn
-  end
-
-  def sushi(jname)
-    res = @conn.get("/#{jname}")
-    data = JSON.parse(res.body)
-    data['name']
-  end
-end
-
-Rspec.describe Client do
-  let(:stubs)  { Faraday::Adapter::Test::Stubs.new }
-  let(:conn)   { Faraday.new { |b| b.adapter(:test, stubs) } }
-  let(:client) { Client.new(conn) }
-
-  it 'parses name' do
-    stubs.get('/ebi') do |env|
-      # optional: you can inspect the Faraday::Env
-      expect(env.url.path).to eq('/ebi')
-      [
-        200,
-        { 'Content-Type': 'application/javascript' },
-        '{"name": "shrimp"}'
-      ]
-    end
-
-    # uncomment to trigger stubs.verify_stubbed_calls failure
-    # stubs.get('/unused') { [404, {}, ''] }
-
-    expect(client.sushi('ebi')).to eq('shrimp')
-    stubs.verify_stubbed_calls
-  end
-
-  it 'handles 404' do
-    stubs.get('/ebi') do
-      [
-        404,
-        { 'Content-Type': 'application/javascript' },
-        '{}'
-      ]
-    end
-    expect(client.sushi('ebi')).to be_nil
-    stubs.verify_stubbed_calls
-  end
-
-  it 'handles exception' do
-    stubs.get('/ebi') do
-      raise Faraday::ConnectionFailed, nil
-    end
-
-    expect { client.sushi('ebi') }.to raise_error(Faraday::ConnectionFailed)
-    stubs.verify_stubbed_calls
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/examples/client_test.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-# Requires Ruby with test-unit and faraday gems.
-# ruby client_test.rb
-
-require 'faraday'
-require 'json'
-require 'test/unit'
-
-# Example API client
-class Client
-  def initialize(conn)
-    @conn = conn
-  end
-
-  def sushi(jname)
-    res = @conn.get("/#{jname}")
-    data = JSON.parse(res.body)
-    data['name']
-  end
-end
-
-# Example API client test
-class ClientTest < Test::Unit::TestCase
-  def test_sushi_name
-    stubs = Faraday::Adapter::Test::Stubs.new
-    stubs.get('/ebi') do |env|
-      # optional: you can inspect the Faraday::Env
-      assert_equal '/ebi', env.url.path
-      [
-        200,
-        { 'Content-Type': 'application/javascript' },
-        '{"name": "shrimp"}'
-      ]
-    end
-
-    # uncomment to trigger stubs.verify_stubbed_calls failure
-    # stubs.get('/unused') { [404, {}, ''] }
-
-    cli = client(stubs)
-    assert_equal 'shrimp', cli.sushi('ebi')
-    stubs.verify_stubbed_calls
-  end
-
-  def test_sushi_404
-    stubs = Faraday::Adapter::Test::Stubs.new
-    stubs.get('/ebi') do
-      [
-        404,
-        { 'Content-Type': 'application/javascript' },
-        '{}'
-      ]
-    end
-
-    cli = client(stubs)
-    assert_nil cli.sushi('ebi')
-    stubs.verify_stubbed_calls
-  end
-
-  def test_sushi_exception
-    stubs = Faraday::Adapter::Test::Stubs.new
-    stubs.get('/ebi') do
-      raise Faraday::ConnectionFailed, nil
-    end
-
-    cli = client(stubs)
-    assert_raise Faraday::ConnectionFailed do
-      cli.sushi('ebi')
-    end
-    stubs.verify_stubbed_calls
-  end
-
-  def client(stubs)
-    conn = Faraday.new do |builder|
-      builder.adapter :test, stubs
-    end
-    Client.new(conn)
-  end
-end

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

@@ -1,166 +0,0 @@
-# frozen_string_literal: true
-
-require 'cgi'
-require 'set'
-require 'forwardable'
-require 'faraday/middleware_registry'
-require 'faraday/dependency_loader'
-
-# This is the main namespace for Faraday.
-#
-# It provides methods to create {Connection} objects, and HTTP-related
-# methods to use directly.
-#
-# @example Helpful class methods for easy usage
-#   Faraday.get "http://faraday.com"
-#
-# @example Helpful class method `.new` to create {Connection} objects.
-#   conn = Faraday.new "http://faraday.com"
-#   conn.get '/'
-#
-module Faraday
-  VERSION = '1.0.1'
-  METHODS_WITH_QUERY = %w[get head delete trace].freeze
-  METHODS_WITH_BODY = %w[post put patch].freeze
-
-  class << self
-    # The root path that Faraday is being loaded from.
-    #
-    # This is the root from where the libraries are auto-loaded.
-    #
-    # @return [String]
-    attr_accessor :root_path
-
-    # Gets or sets the path that the Faraday libs are loaded from.
-    # @return [String]
-    attr_accessor :lib_path
-
-    # @overload default_adapter
-    #   Gets the Symbol key identifying a default Adapter to use
-    #   for the default {Faraday::Connection}. Defaults to `:net_http`.
-    #   @return [Symbol] the default adapter
-    # @overload default_adapter=(adapter)
-    #   Updates default adapter while resetting {.default_connection}.
-    #   @return [Symbol] the new default_adapter.
-    attr_reader :default_adapter
-
-    # Documented below, see default_connection
-    attr_writer :default_connection
-
-    # Tells Faraday to ignore the environment proxy (http_proxy).
-    # Defaults to `false`.
-    # @return [Boolean]
-    attr_accessor :ignore_env_proxy
-
-    # Initializes a new {Connection}.
-    #
-    # @param url [String,Hash] The optional String base URL to use as a prefix
-    #           for all requests.  Can also be the options Hash. Any of these
-    #           values will be set on every request made, unless overridden
-    #           for a specific request.
-    # @param options [Hash]
-    # @option options [String] :url Base URL
-    # @option options [Hash] :params Hash of unencoded URI query params.
-    # @option options [Hash] :headers Hash of unencoded HTTP headers.
-    # @option options [Hash] :request Hash of request options.
-    # @option options [Hash] :ssl Hash of SSL options.
-    # @option options [Hash] :proxy Hash of Proxy options.
-    # @return [Faraday::Connection]
-    #
-    # @example With an URL argument
-    #   Faraday.new 'http://faraday.com'
-    #   # => Faraday::Connection to http://faraday.com
-    #
-    # @example With an URL argument and an options hash
-    #   Faraday.new 'http://faraday.com', params: { page: 1 }
-    #   # => Faraday::Connection to http://faraday.com?page=1
-    #
-    # @example With everything in an options hash
-    #   Faraday.new url: 'http://faraday.com',
-    #               params: { page: 1 }
-    #   # => Faraday::Connection to http://faraday.com?page=1
-    def new(url = nil, options = {}, &block)
-      options = default_connection_options.merge(options)
-      Faraday::Connection.new(url, options, &block)
-    end
-
-    # @private
-    # Internal: Requires internal Faraday libraries.
-    #
-    # @param libs [Array] one or more relative String names to Faraday classes.
-    # @return [void]
-    def require_libs(*libs)
-      libs.each do |lib|
-        require "#{lib_path}/#{lib}"
-      end
-    end
-
-    alias require_lib require_libs
-
-    # Documented elsewhere, see default_adapter reader
-    def default_adapter=(adapter)
-      @default_connection = nil
-      @default_adapter = adapter
-    end
-
-    def respond_to_missing?(symbol, include_private = false)
-      default_connection.respond_to?(symbol, include_private) || super
-    end
-
-    private
-
-    # Internal: Proxies method calls on the Faraday constant to
-    # .default_connection.
-    def method_missing(name, *args, &block)
-      if default_connection.respond_to?(name)
-        default_connection.send(name, *args, &block)
-      else
-        super
-      end
-    end
-  end
-
-  self.ignore_env_proxy = false
-  self.root_path = File.expand_path __dir__
-  self.lib_path = File.expand_path 'faraday', __dir__
-  self.default_adapter = :net_http
-
-  # @overload default_connection
-  #   Gets the default connection used for simple scripts.
-  #   @return [Faraday::Connection] a connection configured with
-  #   the default_adapter.
-  # @overload default_connection=(connection)
-  #   @param connection [Faraday::Connection]
-  #   Sets the default {Faraday::Connection} for simple scripts that
-  #   access the Faraday constant directly, such as
-  #   <code>Faraday.get "https://faraday.com"</code>.
-  def self.default_connection
-    @default_connection ||= Connection.new(default_connection_options)
-  end
-
-  # Gets the default connection options used when calling {Faraday#new}.
-  #
-  # @return [Faraday::ConnectionOptions]
-  def self.default_connection_options
-    @default_connection_options ||= ConnectionOptions.new
-  end
-
-  # Sets the default options used when calling {Faraday#new}.
-  #
-  # @param options [Hash, Faraday::ConnectionOptions]
-  def self.default_connection_options=(options)
-    @default_connection = nil
-    @default_connection_options = ConnectionOptions.from(options)
-  end
-
-  unless defined?(::Faraday::Timer)
-    require 'timeout'
-    Timer = Timeout
-  end
-
-  require_libs 'utils', 'options', 'connection', 'rack_builder', 'parameters',
-               'middleware', 'adapter', 'request', 'response', 'error',
-               'file_part', 'param_part'
-
-  require_lib 'autoload' unless ENV['FARADAY_NO_AUTOLOAD']
-end

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

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # Base class for all Faraday adapters. Adapters are
-  # responsible for fulfilling a Faraday request.
-  class Adapter
-    extend MiddlewareRegistry
-    extend DependencyLoader
-
-    CONTENT_LENGTH = 'Content-Length'
-
-    register_middleware File.expand_path('adapter', __dir__),
-                        test: [:Test, 'test'],
-                        net_http: [:NetHttp, 'net_http'],
-                        net_http_persistent: [
-                          :NetHttpPersistent,
-                          'net_http_persistent'
-                        ],
-                        typhoeus: [:Typhoeus, 'typhoeus'],
-                        patron: [:Patron, 'patron'],
-                        em_synchrony: [:EMSynchrony, 'em_synchrony'],
-                        em_http: [:EMHttp, 'em_http'],
-                        excon: [:Excon, 'excon'],
-                        rack: [:Rack, 'rack'],
-                        httpclient: [:HTTPClient, 'httpclient']
-
-    # This module marks an Adapter as supporting parallel requests.
-    module Parallelism
-      attr_writer :supports_parallel
-      def supports_parallel?
-        @supports_parallel
-      end
-
-      def inherited(subclass)
-        super
-        subclass.supports_parallel = supports_parallel?
-      end
-    end
-
-    extend Parallelism
-    self.supports_parallel = false
-
-    def initialize(_app = nil, opts = {}, &block)
-      @app = ->(env) { env.response }
-      @connection_options = opts
-      @config_block = block
-    end
-
-    # Yields or returns an adapter's configured connection. Depends on
-    # #build_connection being defined on this adapter.
-    #
-    # @param env [Faraday::Env, Hash] The env object for a faraday request.
-    #
-    # @return The return value of the given block, or the HTTP connection object
-    #         if no block is given.
-    def connection(env)
-      conn = build_connection(env)
-      return conn unless block_given?
-
-      yield conn
-    end
-
-    # Close any persistent connections. The adapter should still be usable
-    # after calling close.
-    def close
-      # Possible implementation:
-      #   @app.close if @app.respond_to?(:close)
-    end
-
-    def call(env)
-      env.clear_body if env.needs_body?
-      env.response = Response.new
-    end
-
-    private
-
-    def save_response(env, status, body, headers = nil, reason_phrase = nil)
-      env.status = status
-      env.body = body
-      env.reason_phrase = reason_phrase&.to_s&.strip
-      env.response_headers = Utils::Headers.new.tap do |response_headers|
-        response_headers.update headers unless headers.nil?
-        yield(response_headers) if block_given?
-      end
-
-      env.response.finish(env) unless env.parallel?
-      env.response
-    end
-
-    # Fetches either a read, write, or open timeout setting. Defaults to the
-    # :timeout value if a more specific one is not given.
-    #
-    # @param type [Symbol] Describes which timeout setting to get: :read,
-    #                      :write, or :open.
-    # @param options [Hash] Hash containing Symbol keys like :timeout,
-    #                       :read_timeout, :write_timeout, :open_timeout, or
-    #                       :timeout
-    #
-    # @return [Integer, nil] Timeout duration in seconds, or nil if no timeout
-    #                        has been set.
-    def request_timeout(type, options)
-      key = TIMEOUT_KEYS.fetch(type) do
-        msg = "Expected :read, :write, :open. Got #{type.inspect} :("
-        raise ArgumentError, msg
-      end
-      options[key] || options[:timeout]
-    end
-
-    TIMEOUT_KEYS = {
-      read: :read_timeout,
-      open: :open_timeout,
-      write: :write_timeout
-    }.freeze
-  end
-end

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

@@ -1,286 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # EventMachine adapter. This adapter is useful for either asynchronous
-    # requests when in an EM reactor loop, or for making parallel requests in
-    # synchronous code.
-    class EMHttp < Faraday::Adapter
-      # Options is a module containing helpers to convert the Faraday env object
-      # into options hashes for EMHTTP method calls.
-      module Options
-        # @return [Hash]
-        def connection_config(env)
-          options = {}
-          configure_proxy(options, env)
-          configure_timeout(options, env)
-          configure_socket(options, env)
-          configure_ssl(options, env)
-          options
-        end
-
-        def request_config(env)
-          options = {
-            body: read_body(env),
-            head: env[:request_headers]
-            # keepalive: true,
-            # file: 'path/to/file', # stream data off disk
-          }
-          configure_compression(options, env)
-          options
-        end
-
-        def read_body(env)
-          body = env[:body]
-          body.respond_to?(:read) ? body.read : body
-        end
-
-        # Reads out proxy settings from env into options
-        def configure_proxy(options, env)
-          proxy = request_options(env)[:proxy]
-          return unless proxy
-
-          options[:proxy] = {
-            host: proxy[:uri].host,
-            port: proxy[:uri].port,
-            authorization: [proxy[:user], proxy[:password]]
-          }
-        end
-
-        # Reads out host and port settings from env into options
-        def configure_socket(options, env)
-          bind = request_options(env)[:bind]
-          return unless bind
-
-          options[:bind] = {
-            host: bind[:host],
-            port: bind[:port]
-          }
-        end
-
-        # Reads out SSL certificate settings from env into options
-        def configure_ssl(options, env)
-          return unless env[:url].scheme == 'https' && env[:ssl]
-
-          options[:ssl] = {
-            cert_chain_file: env[:ssl][:ca_file],
-            verify_peer: env[:ssl].fetch(:verify, true)
-          }
-        end
-
-        # Reads out timeout settings from env into options
-        def configure_timeout(options, env)
-          req = request_options(env)
-          options[:inactivity_timeout] = request_timeout(:read, req)
-          options[:connect_timeout] = request_timeout(:open, req)
-        end
-
-        # Reads out compression header settings from env into options
-        def configure_compression(options, env)
-          return unless (env[:method] == :get) &&
-                        !options[:head].key?('accept-encoding')
-
-          options[:head]['accept-encoding'] = 'gzip, compressed'
-        end
-
-        def request_options(env)
-          env[:request]
-        end
-      end
-
-      include Options
-
-      dependency 'em-http'
-
-      self.supports_parallel = true
-
-      # @return [Manager]
-      def self.setup_parallel_manager(_options = nil)
-        Manager.new
-      end
-
-      def call(env)
-        super
-        perform_request env
-        @app.call env
-      end
-
-      def perform_request(env)
-        if parallel?(env)
-          manager = env[:parallel_manager]
-          manager.add do
-            perform_single_request(env)
-              .callback { env[:response].finish(env) }
-          end
-        elsif EventMachine.reactor_running?
-          # EM is running: instruct upstream that this is an async request
-          env[:parallel_manager] = true
-          perform_single_request(env)
-            .callback { env[:response].finish(env) }
-            .errback do
-              # TODO: no way to communicate the error in async mode
-              raise NotImplementedError
-            end
-        else
-          error = nil
-          # start EM, block until request is completed
-          EventMachine.run do
-            perform_single_request(env)
-              .callback { EventMachine.stop }
-              .errback do |client|
-                error = error_message(client)
-                EventMachine.stop
-              end
-          end
-          raise_error(error) if error
-        end
-      rescue EventMachine::Connectify::CONNECTError => e
-        if e.message.include?('Proxy Authentication Required')
-          raise Faraday::ConnectionFailed,
-                %(407 "Proxy Authentication Required ")
-        end
-
-        raise Faraday::ConnectionFailed, e
-      rescue StandardError => e
-        if defined?(::OpenSSL::SSL::SSLError) && \
-           e.is_a?(::OpenSSL::SSL::SSLError)
-          raise Faraday::SSLError, e
-        end
-
-        raise
-      end
-
-      # TODO: reuse the connection to support pipelining
-      def perform_single_request(env)
-        req = create_request(env)
-        req = req.setup_request(env[:method], request_config(env))
-        req.callback do |client|
-          if env[:request].stream_response?
-            warn "Streaming downloads for #{self.class.name} " \
-              'are not yet implemented.'
-            env[:request].on_data.call(
-              client.response,
-              client.response.bytesize
-            )
-          end
-          status = client.response_header.status
-          reason = client.response_header.http_reason
-          save_response(env, status, client.response, nil, reason) do |headers|
-            client.response_header.each do |name, value|
-              headers[name.to_sym] = value
-            end
-          end
-        end
-      end
-
-      def create_request(env)
-        EventMachine::HttpRequest.new(
-          env[:url], connection_config(env).merge(@connection_options)
-        )
-      end
-
-      def error_message(client)
-        client.error || 'request failed'
-      end
-
-      def raise_error(msg)
-        error_class = Faraday::ClientError
-        if timeout_message?(msg)
-          error_class = Faraday::TimeoutError
-          msg = 'request timed out'
-        elsif msg == Errno::ECONNREFUSED
-          error_class = Faraday::ConnectionFailed
-          msg = 'connection refused'
-        elsif msg == 'connection closed by server'
-          error_class = Faraday::ConnectionFailed
-        end
-        raise error_class, msg
-      end
-
-      def timeout_message?(msg)
-        msg == Errno::ETIMEDOUT ||
-          (msg.is_a?(String) && msg.include?('timeout error'))
-      end
-
-      # @return [Boolean]
-      def parallel?(env)
-        !!env[:parallel_manager]
-      end
-
-      # This parallel manager is designed to start an EventMachine loop
-      # and block until all registered requests have been completed.
-      class Manager
-        # @see reset
-        def initialize
-          reset
-        end
-
-        # Re-initializes instance variables
-        def reset
-          @registered_procs = []
-          @num_registered = 0
-          @num_succeeded = 0
-          @errors = []
-          @running = false
-        end
-
-        # @return [Boolean]
-        def running?
-          @running
-        end
-
-        def add(&block)
-          if running?
-            perform_request { yield }
-          else
-            @registered_procs << block
-          end
-          @num_registered += 1
-        end
-
-        def run
-          if @num_registered.positive?
-            @running = true
-            EventMachine.run do
-              @registered_procs.each do |proc|
-                perform_request(&proc)
-              end
-            end
-            unless @errors.empty?
-              raise Faraday::ClientError, @errors.first || 'connection failed'
-            end
-          end
-        ensure
-          reset
-        end
-
-        def perform_request
-          client = yield
-          client.callback do
-            @num_succeeded += 1
-            check_finished
-          end
-          client.errback do
-            @errors << client.error
-            check_finished
-          end
-        end
-
-        def check_finished
-          EventMachine.stop if @num_succeeded + @errors.size == @num_registered
-        end
-      end
-    end
-  end
-end
-
-if Faraday::Adapter::EMHttp.loaded?
-  begin
-    require 'openssl'
-  rescue LoadError
-    warn 'Warning: no such file to load -- openssl. ' \
-      'Make sure it is installed if you want HTTPS support'
-  else
-    require 'faraday/adapter/em_http_ssl_patch'
-  end
-end