logstash-output-scalyr 0.1.5 → 0.1.6

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

@@ -1,116 +0,0 @@
-module RSpec
-  module Mocks
-    module AnyInstance
-      # @private
-      # The `AnyInstance::Recorder` is responsible for redefining the klass's
-      # instance method in order to add any stubs/expectations the first time
-      # the method is called. It's not capable of updating a stub on an instance
-      # that's already been previously stubbed (either directly, or via
-      # `any_instance`).
-      #
-      # This proxy sits in front of the recorder and delegates both to it
-      # and to the `RSpec::Mocks::Proxy` for each already mocked or stubbed
-      # instance of the class, in order to propogates changes to the instances.
-      #
-      # Note that unlike `RSpec::Mocks::Proxy`, this proxy class is stateless
-      # and is not persisted in `RSpec::Mocks.space`.
-      #
-      # Proxying for the message expectation fluent interface (typically chained
-      # off of the return value of one of these methods) is provided by the
-      # `FluentInterfaceProxy` class below.
-      class Proxy
-        def initialize(recorder, target_proxies)
-          @recorder       = recorder
-          @target_proxies = target_proxies
-        end
-
-        def klass
-          @recorder.klass
-        end
-
-        def stub(method_name_or_method_map, &block)
-          if Hash === method_name_or_method_map
-            method_name_or_method_map.each do |method_name, return_value|
-              stub(method_name).and_return(return_value)
-            end
-          else
-            perform_proxying(__method__, [method_name_or_method_map], block) do |proxy|
-              proxy.add_stub(method_name_or_method_map, &block)
-            end
-          end
-        end
-
-        def unstub(method_name)
-          perform_proxying(__method__, [method_name], nil) do |proxy|
-            proxy.remove_stub_if_present(method_name)
-          end
-        end
-
-        def stub_chain(*chain, &block)
-          perform_proxying(__method__, chain, block) do |proxy|
-            Mocks::StubChain.stub_chain_on(proxy.object, *chain, &block)
-          end
-        end
-
-        def expect_chain(*chain, &block)
-          perform_proxying(__method__, chain, block) do |proxy|
-            Mocks::ExpectChain.expect_chain_on(proxy.object, *chain, &block)
-          end
-        end
-
-        def should_receive(method_name, &block)
-          perform_proxying(__method__, [method_name], block) do |proxy|
-            # Yeah, this is a bit odd...but if we used `add_message_expectation`
-            # then it would act like `expect_every_instance_of(klass).to receive`.
-            # The any_instance recorder takes care of validating that an instance
-            # received the message.
-            proxy.add_stub(method_name, &block)
-          end
-        end
-
-        def should_not_receive(method_name, &block)
-          perform_proxying(__method__, [method_name], block) do |proxy|
-            proxy.add_message_expectation(method_name, &block).never
-          end
-        end
-
-      private
-
-        def perform_proxying(method_name, args, block, &target_proxy_block)
-          recorder_value = @recorder.__send__(method_name, *args, &block)
-          proxy_values   = @target_proxies.map(&target_proxy_block)
-          FluentInterfaceProxy.new([recorder_value] + proxy_values)
-        end
-      end
-
-      # @private
-      # Delegates messages to each of the given targets in order to
-      # provide the fluent interface that is available off of message
-      # expectations when dealing with `any_instance`.
-      #
-      # `targets` will typically contain 1 of the `AnyInstance::Recorder`
-      # return values and N `MessageExpectation` instances (one per instance
-      # of the `any_instance` klass).
-      class FluentInterfaceProxy
-        def initialize(targets)
-          @targets = targets
-        end
-
-        if RUBY_VERSION.to_f > 1.8
-          def respond_to_missing?(method_name, include_private=false)
-            super || @targets.first.respond_to?(method_name, include_private)
-          end
-        else
-          def respond_to?(method_name, include_private=false)
-            super || @targets.first.respond_to?(method_name, include_private)
-          end
-        end
-
-        def method_missing(*args, &block)
-          return_values = @targets.map { |t| t.__send__(*args, &block) }
-          FluentInterfaceProxy.new(return_values)
-        end
-      end
-    end
-  end
-end

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

@@ -1,294 +0,0 @@
-module RSpec
-  module Mocks
-    module AnyInstance
-      # Given a class `TheClass`, `TheClass.any_instance` returns a `Recorder`,
-      # which records stubs and message expectations for later playback on
-      # instances of `TheClass`.
-      #
-      # Further constraints are stored in instances of [Chain](Chain).
-      #
-      # @see AnyInstance
-      # @see Chain
-      class Recorder
-        # @private
-        attr_reader :message_chains, :stubs, :klass
-
-        def initialize(klass)
-          @message_chains = MessageChains.new
-          @stubs = Hash.new { |hash, key| hash[key] = [] }
-          @observed_methods = []
-          @played_methods = {}
-          @backed_up_method_owner = {}
-          @klass = klass
-          @expectation_set = false
-
-          return unless RSpec::Mocks.configuration.verify_partial_doubles?
-          RSpec::Mocks.configuration.verifying_double_callbacks.each do |block|
-            block.call(ObjectReference.for(klass))
-          end
-        end
-
-        # Initializes the recording a stub to be played back against any
-        # instance of this object that invokes the submitted method.
-        #
-        # @see Methods#stub
-        def stub(method_name, &block)
-          observe!(method_name)
-          message_chains.add(method_name, StubChain.new(self, method_name, &block))
-        end
-
-        # Initializes the recording a stub chain to be played back against any
-        # instance of this object that invokes the method matching the first
-        # argument.
-        #
-        # @see Methods#stub_chain
-        def stub_chain(*method_names_and_optional_return_values, &block)
-          normalize_chain(*method_names_and_optional_return_values) do |method_name, args|
-            observe!(method_name)
-            message_chains.add(method_name, StubChainChain.new(self, *args, &block))
-          end
-        end
-
-        # @private
-        def expect_chain(*method_names_and_optional_return_values, &block)
-          @expectation_set = true
-          normalize_chain(*method_names_and_optional_return_values) do |method_name, args|
-            observe!(method_name)
-            message_chains.add(method_name, ExpectChainChain.new(self, *args, &block))
-          end
-        end
-
-        # Initializes the recording a message expectation to be played back
-        # against any instance of this object that invokes the submitted
-        # method.
-        #
-        # @see Methods#should_receive
-        def should_receive(method_name, &block)
-          @expectation_set = true
-          observe!(method_name)
-          message_chains.add(method_name, PositiveExpectationChain.new(self, method_name, &block))
-        end
-
-        # The opposite of `should_receive`
-        #
-        # @see Methods#should_not_receive
-        def should_not_receive(method_name, &block)
-          should_receive(method_name, &block).never
-        end
-
-        # Removes any previously recorded stubs, stub_chains or message
-        # expectations that use `method_name`.
-        #
-        # @see Methods#unstub
-        def unstub(method_name)
-          unless @observed_methods.include?(method_name.to_sym)
-            AnyInstance.error_generator.raise_method_not_stubbed_error(method_name)
-          end
-          message_chains.remove_stub_chains_for!(method_name)
-          stubs[method_name].clear
-          stop_observing!(method_name) unless message_chains.has_expectation?(method_name)
-        end
-
-        # @api private
-        #
-        # Used internally to verify that message expectations have been
-        # fulfilled.
-        def verify
-          return unless @expectation_set
-          return if message_chains.all_expectations_fulfilled?
-
-          AnyInstance.error_generator.raise_second_instance_received_message_error(message_chains.unfulfilled_expectations)
-        end
-
-        # @private
-        def stop_all_observation!
-          @observed_methods.each { |method_name| restore_method!(method_name) }
-        end
-
-        # @private
-        def playback!(instance, method_name)
-          RSpec::Mocks.space.ensure_registered(instance)
-          message_chains.playback!(instance, method_name)
-          @played_methods[method_name] = instance
-          received_expected_message!(method_name) if message_chains.has_expectation?(method_name)
-        end
-
-        # @private
-        def instance_that_received(method_name)
-          @played_methods[method_name]
-        end
-
-        # @private
-        def build_alias_method_name(method_name)
-          "__#{method_name}_without_any_instance__"
-        end
-
-        # @private
-        def already_observing?(method_name)
-          @observed_methods.include?(method_name) || super_class_observing?(method_name)
-        end
-
-        # @private
-        def notify_received_message(_object, message, args, _blk)
-          has_expectation = false
-
-          message_chains.each_unfulfilled_expectation_matching(message, *args) do |expectation|
-            has_expectation = true
-            expectation.expectation_fulfilled!
-          end
-
-          return unless has_expectation
-
-          restore_method!(message)
-          mark_invoked!(message)
-        end
-
-      protected
-
-        def stop_observing!(method_name)
-          restore_method!(method_name)
-          @observed_methods.delete(method_name)
-          super_class_observers_for(method_name).each do |ancestor|
-            ::RSpec::Mocks.space.
-              any_instance_recorder_for(ancestor).stop_observing!(method_name)
-          end
-        end
-
-      private
-
-        def ancestor_is_an_observer?(method_name)
-          lambda do |ancestor|
-            unless ancestor == @klass
-              ::RSpec::Mocks.space.
-                any_instance_recorder_for(ancestor).already_observing?(method_name)
-            end
-          end
-        end
-
-        def super_class_observers_for(method_name)
-          @klass.ancestors.select(&ancestor_is_an_observer?(method_name))
-        end
-
-        def super_class_observing?(method_name)
-          @klass.ancestors.any?(&ancestor_is_an_observer?(method_name))
-        end
-
-        def normalize_chain(*args)
-          args.shift.to_s.split('.').map { |s| s.to_sym }.reverse.each { |a| args.unshift a }
-          yield args.first, args
-        end
-
-        def received_expected_message!(method_name)
-          message_chains.received_expected_message!(method_name)
-          restore_method!(method_name)
-          mark_invoked!(method_name)
-        end
-
-        def restore_method!(method_name)
-          if public_protected_or_private_method_defined?(build_alias_method_name(method_name))
-            restore_original_method!(method_name)
-          else
-            remove_dummy_method!(method_name)
-          end
-        end
-
-        def restore_original_method!(method_name)
-          return unless @klass.instance_method(method_name).owner == @klass
-
-          alias_method_name = build_alias_method_name(method_name)
-          @klass.class_exec(@backed_up_method_owner) do |backed_up_method_owner|
-            remove_method method_name
-
-            # A @klass can have methods implemented (see Method#owner) in @klass
-            # or inherited from a superclass. In ruby 2.2 and earlier, we can copy
-            # a method regardless of the 'owner' and restore it to @klass after
-            # because a call to 'super' from @klass's copied method would end up
-            # calling the original class's superclass's method.
-            #
-            # With the commit below, available starting in 2.3.0, ruby changed
-            # this behavior and a call to 'super' from the method copied to @klass
-            # will call @klass's superclass method, which is the original
-            # implementer of this method!  This leads to very strange errors
-            # if @klass's copied method calls 'super', since it would end up
-            # calling itself, the original method implemented in @klass's
-            # superclass.
-            #
-            # For ruby 2.3 and above, we need to only restore methods that
-            # @klass originally owned.
-            #
-            # https://github.com/ruby/ruby/commit/c8854d2ca4be9ee6946e6d17b0e17d9ef130ee81
-            if RUBY_VERSION < "2.3" || backed_up_method_owner[method_name.to_sym] == self
-              alias_method method_name, alias_method_name
-            end
-            remove_method alias_method_name
-          end
-        end
-
-        def remove_dummy_method!(method_name)
-          @klass.class_exec do
-            remove_method method_name
-          end
-        end
-
-        def backup_method!(method_name)
-          return unless public_protected_or_private_method_defined?(method_name)
-
-          alias_method_name = build_alias_method_name(method_name)
-          @backed_up_method_owner[method_name.to_sym] ||= @klass.instance_method(method_name).owner
-          @klass.class_exec do
-            alias_method alias_method_name, method_name
-          end
-        end
-
-        def public_protected_or_private_method_defined?(method_name)
-          MethodReference.method_defined_at_any_visibility?(@klass, method_name)
-        end
-
-        def observe!(method_name)
-          allow_no_prepended_module_definition_of(method_name)
-
-          if RSpec::Mocks.configuration.verify_partial_doubles? && !Mocks.configuration.temporarily_suppress_partial_double_verification
-            unless public_protected_or_private_method_defined?(method_name)
-              AnyInstance.error_generator.raise_does_not_implement_error(@klass, method_name)
-            end
-          end
-
-          stop_observing!(method_name) if already_observing?(method_name)
-          @observed_methods << method_name
-          backup_method!(method_name)
-          recorder = self
-          @klass.__send__(:define_method, method_name) do |*args, &blk|
-            recorder.playback!(self, method_name)
-            __send__(method_name, *args, &blk)
-          end
-        end
-
-        def mark_invoked!(method_name)
-          backup_method!(method_name)
-          recorder = self
-          @klass.__send__(:define_method, method_name) do |*_args, &_blk|
-            invoked_instance = recorder.instance_that_received(method_name)
-            inspect = "#<#{self.class}:#{object_id} #{instance_variables.map { |name| "#{name}=#{instance_variable_get name}" }.join(', ')}>"
-            AnyInstance.error_generator.raise_message_already_received_by_other_instance_error(
-              method_name, inspect, invoked_instance
-            )
-          end
-        end
-
-        if Support::RubyFeatures.module_prepends_supported?
-          def allow_no_prepended_module_definition_of(method_name)
-            prepended_modules = RSpec::Mocks::Proxy.prepended_modules_of(@klass)
-            problem_mod = prepended_modules.find { |mod| mod.method_defined?(method_name) }
-            return unless problem_mod
-
-            AnyInstance.error_generator.raise_not_supported_with_prepend_error(method_name, problem_mod)
-          end
-        else
-          def allow_no_prepended_module_definition_of(_method_name)
-            # nothing to do; prepends aren't supported on this version of ruby
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-module RSpec
-  module Mocks
-    module AnyInstance
-      # @private
-      class StubChain < Chain
-        # @private
-        def expectation_fulfilled?
-          true
-        end
-
-      private
-
-        def create_message_expectation_on(instance)
-          proxy = ::RSpec::Mocks.space.proxy_for(instance)
-          method_name, opts = @expectation_args
-          opts = (opts || {}).merge(:expected_form => IGNORED_BACKTRACE_LINE)
-
-          stub = proxy.add_stub(method_name, opts, &@expectation_block)
-          @recorder.stubs[stub.message] << stub
-
-          if RSpec::Mocks.configuration.yield_receiver_to_any_instance_implementation_blocks?
-            stub.and_yield_receiver_to_implementation
-          end
-
-          stub
-        end
-
-        InvocationOrder =
-          {
-            :and_return => [:with, nil],
-            :and_raise => [:with, nil],
-            :and_yield => [:with, :and_yield, nil],
-            :and_throw => [:with, nil],
-            :and_call_original => [:with, nil],
-            :and_wrap_original => [:with, nil]
-          }.freeze
-
-        EmptyInvocationOrder = {}.freeze
-
-        def invocation_order
-          InvocationOrder
-        end
-
-        def verify_invocation_order(rspec_method_name, *_args, &_block)
-          return if invocation_order.fetch(rspec_method_name, [nil]).include?(last_message)
-          raise NoMethodError, "Undefined method #{rspec_method_name}"
-        end
-      end
-    end
-  end
-end