jscop 0.1.2 → 0.1.3

data/vendor/cache/ruby/2.6.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/cache/ruby/2.6.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

data/vendor/cache/ruby/2.6.0/gems/rspec-mocks-3.9.1/lib/rspec/mocks/matchers/receive_message_chain.rb

@@ -1,82 +0,0 @@
-RSpec::Support.require_rspec_mocks 'matchers/expectation_customization'
-
-module RSpec
-  module Mocks
-    module Matchers
-      # @private
-      class ReceiveMessageChain
-        include Matcher
-
-        def initialize(chain, &block)
-          @chain = chain
-          @block = block
-          @recorded_customizations  = []
-        end
-
-        [:with, :and_return, :and_throw, :and_raise, :and_yield, :and_call_original].each do |msg|
-          define_method(msg) do |*args, &block|
-            @recorded_customizations << ExpectationCustomization.new(msg, args, block)
-            self
-          end
-        end
-
-        def name
-          "receive_message_chain"
-        end
-
-        def description
-          "receive message chain #{formatted_chain}"
-        end
-
-        def setup_allowance(subject, &block)
-          chain = StubChain.stub_chain_on(subject, *@chain, &(@block || block))
-          replay_customizations(chain)
-        end
-
-        def setup_any_instance_allowance(subject, &block)
-          proxy = ::RSpec::Mocks.space.any_instance_proxy_for(subject)
-          chain = proxy.stub_chain(*@chain, &(@block || block))
-          replay_customizations(chain)
-        end
-
-        def setup_any_instance_expectation(subject, &block)
-          proxy = ::RSpec::Mocks.space.any_instance_proxy_for(subject)
-          chain = proxy.expect_chain(*@chain, &(@block || block))
-          replay_customizations(chain)
-        end
-
-        def setup_expectation(subject, &block)
-          chain = ExpectChain.expect_chain_on(subject, *@chain, &(@block || block))
-          replay_customizations(chain)
-        end
-
-        def setup_negative_expectation(*_args)
-          raise NegationUnsupportedError,
-                "`expect(...).not_to receive_message_chain` is not supported " \
-                "since it doesn't really make sense. What would it even mean?"
-        end
-
-        alias matches? setup_expectation
-        alias does_not_match? setup_negative_expectation
-
-      private
-
-        def replay_customizations(chain)
-          @recorded_customizations.each do |customization|
-            customization.playback_onto(chain)
-          end
-        end
-
-        def formatted_chain
-          @formatted_chain ||= @chain.map do |part|
-            if Hash === part
-              part.keys.first.to_s
-            else
-              part.to_s
-            end
-          end.join(".")
-        end
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.6.0/gems/rspec-mocks-3.9.1/lib/rspec/mocks/matchers/receive_messages.rb

@@ -1,77 +0,0 @@
-module RSpec
-  module Mocks
-    module Matchers
-      # @private
-      class ReceiveMessages
-        include Matcher
-
-        def initialize(message_return_value_hash)
-          @message_return_value_hash = message_return_value_hash
-          @backtrace_line = CallerFilter.first_non_rspec_line
-        end
-
-        def name
-          "receive_messages"
-        end
-
-        def description
-          "receive messages: #{@message_return_value_hash.inspect}"
-        end
-
-        def setup_expectation(subject)
-          warn_about_block if block_given?
-          each_message_on(proxy_on(subject)) do |host, message, return_value|
-            host.add_simple_expectation(message, return_value, @backtrace_line)
-          end
-        end
-        alias matches? setup_expectation
-
-        def setup_negative_expectation(_subject)
-          raise NegationUnsupportedError,
-                "`expect(...).to_not receive_messages` is not supported since it " \
-                "doesn't really make sense. What would it even mean?"
-        end
-        alias does_not_match? setup_negative_expectation
-
-        def setup_allowance(subject)
-          warn_about_block if block_given?
-          each_message_on(proxy_on(subject)) do |host, message, return_value|
-            host.add_simple_stub(message, return_value)
-          end
-        end
-
-        def setup_any_instance_expectation(subject)
-          warn_about_block if block_given?
-          each_message_on(any_instance_of(subject)) do |host, message, return_value|
-            host.should_receive(message).and_return(return_value)
-          end
-        end
-
-        def setup_any_instance_allowance(subject)
-          warn_about_block if block_given?
-          any_instance_of(subject).stub(@message_return_value_hash)
-        end
-
-        def warn_about_block
-          raise "Implementation blocks aren't supported with `receive_messages`"
-        end
-
-      private
-
-        def proxy_on(subject)
-          ::RSpec::Mocks.space.proxy_for(subject)
-        end
-
-        def any_instance_of(subject)
-          ::RSpec::Mocks.space.any_instance_proxy_for(subject)
-        end
-
-        def each_message_on(host)
-          @message_return_value_hash.each do |message, value|
-            yield host, message, value
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.6.0/gems/rspec-mocks-3.9.1/lib/rspec/mocks/message_chain.rb

@@ -1,87 +0,0 @@
-module RSpec
-  module Mocks
-    # @private
-    class MessageChain
-      attr_reader :object, :chain, :block
-
-      def initialize(object, *chain, &blk)
-        @object = object
-        @chain, @block = format_chain(*chain, &blk)
-      end
-
-      # @api private
-      def setup_chain
-        if chain.length > 1
-          if (matching_stub = find_matching_stub)
-            chain.shift
-            chain_on(matching_stub.invoke(nil), *chain, &@block)
-          elsif (matching_expectation = find_matching_expectation)
-            chain.shift
-            chain_on(matching_expectation.invoke_without_incrementing_received_count(nil), *chain, &@block)
-          else
-            next_in_chain = Double.new
-            expectation(object, chain.shift) { next_in_chain }
-            chain_on(next_in_chain, *chain, &@block)
-          end
-        else
-          expectation(object, chain.shift, &@block)
-        end
-      end
-
-    private
-
-      def chain_on(object, *chain, &block)
-        initialize(object, *chain, &block)
-        setup_chain
-      end
-
-      def format_chain(*chain, &blk)
-        if Hash === chain.last
-          hash = chain.pop
-          hash.each do |k, v|
-            chain << k
-            blk = Proc.new { v }
-          end
-        end
-        return chain.join('.').split('.'), blk
-      end
-
-      def find_matching_stub
-        ::RSpec::Mocks.space.proxy_for(object).
-          __send__(:find_matching_method_stub, chain.first.to_sym)
-      end
-
-      def find_matching_expectation
-        ::RSpec::Mocks.space.proxy_for(object).
-          __send__(:find_matching_expectation, chain.first.to_sym)
-      end
-    end
-
-    # @private
-    class ExpectChain < MessageChain
-      # @api private
-      def self.expect_chain_on(object, *chain, &blk)
-        new(object, *chain, &blk).setup_chain
-      end
-
-    private
-
-      def expectation(object, message, &return_block)
-        ::RSpec::Mocks.expect_message(object, message, {}, &return_block)
-      end
-    end
-
-    # @private
-    class StubChain < MessageChain
-      def self.stub_chain_on(object, *chain, &blk)
-        new(object, *chain, &blk).setup_chain
-      end
-
-    private
-
-      def expectation(object, message, &return_block)
-        ::RSpec::Mocks.allow_message(object, message, {}, &return_block)
-      end
-    end
-  end
-end