logstash-output-scalyr 0.1.5 → 0.1.10.beta

data/vendor/bundle/jruby/2.5.0/gems/rspec-mocks-3.9.1/lib/rspec/mocks/instance_method_stasher.rb

@@ -1,146 +0,0 @@
-module RSpec
-  module Mocks
-    # @private
-    class InstanceMethodStasher
-      def initialize(object, method)
-        @object = object
-        @method = method
-        @klass = (class << object; self; end)
-
-        @original_method = nil
-        @method_is_stashed = false
-      end
-
-      attr_reader :original_method
-
-      if RUBY_VERSION.to_f < 1.9
-        # @private
-        def method_is_stashed?
-          @method_is_stashed
-        end
-
-        # @private
-        def stash
-          return if !method_defined_directly_on_klass? || @method_is_stashed
-
-          @klass.__send__(:alias_method, stashed_method_name, @method)
-          @method_is_stashed = true
-        end
-
-        # @private
-        def stashed_method_name
-          "obfuscated_by_rspec_mocks__#{@method}"
-        end
-
-        # @private
-        def restore
-          return unless @method_is_stashed
-
-          if @klass.__send__(:method_defined?, @method)
-            @klass.__send__(:undef_method, @method)
-          end
-          @klass.__send__(:alias_method, @method, stashed_method_name)
-          @klass.__send__(:remove_method, stashed_method_name)
-          @method_is_stashed = false
-        end
-      else
-
-        # @private
-        def method_is_stashed?
-          !!@original_method
-        end
-
-        # @private
-        def stash
-          return unless method_defined_directly_on_klass?
-          @original_method ||= ::RSpec::Support.method_handle_for(@object, @method)
-          @klass.__send__(:undef_method, @method)
-        end
-
-        # @private
-        def restore
-          return unless @original_method
-
-          if @klass.__send__(:method_defined?, @method)
-            @klass.__send__(:undef_method, @method)
-          end
-
-          handle_restoration_failures do
-            @klass.__send__(:define_method, @method, @original_method)
-          end
-
-          @original_method = nil
-        end
-      end
-
-      if RUBY_DESCRIPTION.include?('2.0.0p247') || RUBY_DESCRIPTION.include?('2.0.0p195')
-        # ruby 2.0.0-p247 and 2.0.0-p195 both have a bug that we can't work around :(.
-        # https://bugs.ruby-lang.org/issues/8686
-        def handle_restoration_failures
-          yield
-        rescue TypeError
-          RSpec.warn_with(
-            "RSpec failed to properly restore a partial double (#{@object.inspect}) " \
-            "to its original state due to a known bug in MRI 2.0.0-p195 & p247 " \
-            "(https://bugs.ruby-lang.org/issues/8686). This object may remain " \
-            "screwed up for the rest of this process. Please upgrade to 2.0.0-p353 or above.",
-            :call_site => nil, :use_spec_location_as_call_site => true
-          )
-        end
-      else
-        def handle_restoration_failures
-          # No known reasons for restoration to fail on other rubies.
-          yield
-        end
-      end
-
-    private
-
-      # @private
-      def method_defined_directly_on_klass?
-        method_defined_on_klass? && method_owned_by_klass?
-      end
-
-      # @private
-      def method_defined_on_klass?(klass=@klass)
-        MethodReference.method_defined_at_any_visibility?(klass, @method)
-      end
-
-      def method_owned_by_klass?
-        owner = @klass.instance_method(@method).owner
-
-        # On Ruby 2.0.0+ the owner of a method on a class which has been
-        # `prepend`ed may actually be an instance, e.g.
-        # `#<MyClass:0x007fbb94e3cd10>`, rather than the expected `MyClass`.
-        owner = owner.class unless Module === owner
-
-        # On some 1.9s (e.g. rubinius) aliased methods
-        # can report the wrong owner. Example:
-        # class MyClass
-        #   class << self
-        #     alias alternate_new new
-        #   end
-        # end
-        #
-        # MyClass.owner(:alternate_new) returns `Class` when incorrect,
-        # but we need to consider the owner to be `MyClass` because
-        # it is not actually available on `Class` but is on `MyClass`.
-        # Hence, we verify that the owner actually has the method defined.
-        # If the given owner does not have the method defined, we assume
-        # that the method is actually owned by @klass.
-        #
-        # On 1.8, aliased methods can also report the wrong owner. Example:
-        # module M
-        #   def a; end
-        #   module_function :a
-        #   alias b a
-        #   module_function :b
-        # end
-        # The owner of M.b is the raw Module object, instead of the expected
-        # singleton class of the module
-        return true if RUBY_VERSION < '1.9' && owner == @object
-        owner == @klass || !(method_defined_on_klass?(owner))
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rspec-mocks-3.9.1/lib/rspec/mocks/marshal_extension.rb

@@ -1,41 +0,0 @@
-module RSpec
-  module Mocks
-    # Support for `patch_marshal_to_support_partial_doubles` configuration.
-    #
-    # @private
-    class MarshalExtension
-      def self.patch!
-        return if Marshal.respond_to?(:dump_with_rspec_mocks)
-
-        Marshal.instance_eval do
-          class << self
-            def dump_with_rspec_mocks(object, *rest)
-              if !::RSpec::Mocks.space.registered?(object) || NilClass === object
-                dump_without_rspec_mocks(object, *rest)
-              else
-                dump_without_rspec_mocks(object.dup, *rest)
-              end
-            end
-
-            alias_method :dump_without_rspec_mocks, :dump
-            undef_method :dump
-            alias_method :dump, :dump_with_rspec_mocks
-          end
-        end
-      end
-
-      def self.unpatch!
-        return unless Marshal.respond_to?(:dump_with_rspec_mocks)
-
-        Marshal.instance_eval do
-          class << self
-            undef_method :dump_with_rspec_mocks
-            undef_method :dump
-            alias_method :dump, :dump_without_rspec_mocks
-            undef_method :dump_without_rspec_mocks
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rspec-mocks-3.9.1/lib/rspec/mocks/matchers/expectation_customization.rb

@@ -1,20 +0,0 @@
-module RSpec
-  module Mocks
-    module Matchers
-      # @private
-      class ExpectationCustomization
-        attr_accessor :block
-
-        def initialize(method_name, args, block)
-          @method_name = method_name
-          @args        = args
-          @block       = block
-        end
-
-        def playback_onto(expectation)
-          expectation.__send__(@method_name, *@args, &@block)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rspec-mocks-3.9.1/lib/rspec/mocks/matchers/have_received.rb

@@ -1,134 +0,0 @@
-module RSpec
-  module Mocks
-    module Matchers
-      # @private
-      class HaveReceived
-        include Matcher
-
-        COUNT_CONSTRAINTS = %w[exactly at_least at_most times time once twice thrice]
-        ARGS_CONSTRAINTS = %w[with]
-        CONSTRAINTS = COUNT_CONSTRAINTS + ARGS_CONSTRAINTS + %w[ordered]
-
-        def initialize(method_name, &block)
-          @method_name = method_name
-          @block = block
-          @constraints = []
-          @subject = nil
-        end
-
-        def name
-          "have_received"
-        end
-
-        def matches?(subject, &block)
-          @block ||= block
-          @subject = subject
-          @expectation = expect
-          mock_proxy.ensure_implemented(@method_name)
-
-          expected_messages_received_in_order?
-        end
-
-        def does_not_match?(subject)
-          @subject = subject
-          ensure_count_unconstrained
-          @expectation = expect.never
-          mock_proxy.ensure_implemented(@method_name)
-          expected_messages_received_in_order?
-        end
-
-        def failure_message
-          capture_failure_message
-        end
-
-        def failure_message_when_negated
-          capture_failure_message
-        end
-
-        def description
-          (@expectation ||= expect).description_for("have received")
-        end
-
-        CONSTRAINTS.each do |expectation|
-          define_method expectation do |*args|
-            @constraints << [expectation, *args]
-            self
-          end
-        end
-
-        def setup_expectation(subject, &block)
-          notify_failure_message unless matches?(subject, &block)
-        end
-
-        def setup_negative_expectation(subject, &block)
-          notify_failure_message unless does_not_match?(subject, &block)
-        end
-
-        def setup_allowance(_subject, &_block)
-          disallow("allow", " as it would have no effect")
-        end
-
-        def setup_any_instance_allowance(_subject, &_block)
-          disallow("allow_any_instance_of")
-        end
-
-        def setup_any_instance_expectation(_subject, &_block)
-          disallow("expect_any_instance_of")
-        end
-
-        def setup_any_instance_negative_expectation(_subject, &_block)
-          disallow("expect_any_instance_of")
-        end
-
-      private
-
-        def disallow(type, reason="")
-          RSpec::Mocks.error_generator.raise_have_received_disallowed(type, reason)
-        end
-
-        def expect
-          expectation = mock_proxy.build_expectation(@method_name)
-          apply_constraints_to expectation
-          expectation
-        end
-
-        def apply_constraints_to(expectation)
-          @constraints.each do |constraint|
-            expectation.send(*constraint)
-          end
-        end
-
-        def ensure_count_unconstrained
-          return unless count_constraint
-          RSpec::Mocks.error_generator.raise_cant_constrain_count_for_negated_have_received_error(count_constraint)
-        end
-
-        def count_constraint
-          @constraints.map(&:first).find do |constraint|
-            COUNT_CONSTRAINTS.include?(constraint)
-          end
-        end
-
-        def capture_failure_message
-          RSpec::Support.with_failure_notifier(Proc.new { |err, _opt| return err.message }) do
-            notify_failure_message
-          end
-        end
-
-        def notify_failure_message
-          mock_proxy.check_for_unexpected_arguments(@expectation)
-          @expectation.generate_error
-        end
-
-        def expected_messages_received_in_order?
-          mock_proxy.replay_received_message_on @expectation, &@block
-          @expectation.expected_messages_received? && @expectation.ensure_expected_ordering_received!
-        end
-
-        def mock_proxy
-          RSpec::Mocks.space.proxy_for(@subject)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/rspec-mocks-3.9.1/lib/rspec/mocks/matchers/receive.rb

@@ -1,132 +0,0 @@
-RSpec::Support.require_rspec_mocks 'matchers/expectation_customization'
-
-module RSpec
-  module Mocks
-    module Matchers
-      # @private
-      class Receive
-        include Matcher
-
-        def initialize(message, block)
-          @message                 = message
-          @block                   = block
-          @recorded_customizations = []
-        end
-
-        def name
-          "receive"
-        end
-
-        def description
-          describable.description_for("receive")
-        end
-
-        def setup_expectation(subject, &block)
-          warn_if_any_instance("expect", subject)
-          @describable = setup_mock_proxy_method_substitute(subject, :add_message_expectation, block)
-        end
-        alias matches? setup_expectation
-
-        def setup_negative_expectation(subject, &block)
-          # ensure `never` goes first for cases like `never.and_return(5)`,
-          # where `and_return` is meant to raise an error
-          @recorded_customizations.unshift ExpectationCustomization.new(:never, [], nil)
-
-          warn_if_any_instance("expect", subject)
-
-          setup_expectation(subject, &block)
-        end
-        alias does_not_match? setup_negative_expectation
-
-        def setup_allowance(subject, &block)
-          warn_if_any_instance("allow", subject)
-          setup_mock_proxy_method_substitute(subject, :add_stub, block)
-        end
-
-        def setup_any_instance_expectation(subject, &block)
-          setup_any_instance_method_substitute(subject, :should_receive, block)
-        end
-
-        def setup_any_instance_negative_expectation(subject, &block)
-          setup_any_instance_method_substitute(subject, :should_not_receive, block)
-        end
-
-        def setup_any_instance_allowance(subject, &block)
-          setup_any_instance_method_substitute(subject, :stub, block)
-        end
-
-        MessageExpectation.public_instance_methods(false).each do |method|
-          next if method_defined?(method)
-
-          define_method(method) do |*args, &block|
-            @recorded_customizations << ExpectationCustomization.new(method, args, block)
-            self
-          end
-        end
-
-      private
-
-        def describable
-          @describable ||= DefaultDescribable.new(@message)
-        end
-
-        def warn_if_any_instance(expression, subject)
-          return unless AnyInstance::Proxy === subject
-
-          RSpec.warning(
-            "`#{expression}(#{subject.klass}.any_instance).to` " \
-            "is probably not what you meant, it does not operate on " \
-            "any instance of `#{subject.klass}`. " \
-            "Use `#{expression}_any_instance_of(#{subject.klass}).to` instead."
-          )
-        end
-
-        def setup_mock_proxy_method_substitute(subject, method, block)
-          proxy = ::RSpec::Mocks.space.proxy_for(subject)
-          setup_method_substitute(proxy, method, block)
-        end
-
-        def setup_any_instance_method_substitute(subject, method, block)
-          proxy = ::RSpec::Mocks.space.any_instance_proxy_for(subject)
-          setup_method_substitute(proxy, method, block)
-        end
-
-        def setup_method_substitute(host, method, block, *args)
-          args << @message.to_sym
-          block = move_block_to_last_customization(block)
-
-          expectation = host.__send__(method, *args, &(@block || block))
-
-          @recorded_customizations.each do |customization|
-            customization.playback_onto(expectation)
-          end
-          expectation
-        end
-
-        def move_block_to_last_customization(block)
-          last = @recorded_customizations.last
-          return block unless last
-
-          last.block ||= block
-          nil
-        end
-
-        # MessageExpectation objects are able to describe themselves in detail.
-        # We use this as a fall back when a MessageExpectation is not available.
-        # @private
-        class DefaultDescribable
-          def initialize(message)
-            @message = message
-          end
-
-          # This is much simpler for the `any_instance` case than what the
-          # user may want, but I'm not up for putting a bunch of effort
-          # into full descriptions for `any_instance` expectations at this point :(.
-          def description_for(verb)
-            "#{verb} #{@message}"
-          end
-        end
-      end
-    end
-  end
-end