mdap 0.1.0

data/vendor/bundle/ruby/2.7.0/gems/rspec-mocks-3.9.1/lib/rspec/mocks/instance_method_stasher.rb

@@ -0,0 +1,146 @@
+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/ruby/2.7.0/gems/rspec-mocks-3.9.1/lib/rspec/mocks/marshal_extension.rb

@@ -0,0 +1,41 @@
+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/ruby/2.7.0/gems/rspec-mocks-3.9.1/lib/rspec/mocks/matchers/expectation_customization.rb

@@ -0,0 +1,20 @@
+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/ruby/2.7.0/gems/rspec-mocks-3.9.1/lib/rspec/mocks/matchers/have_received.rb

@@ -0,0 +1,134 @@
+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/ruby/2.7.0/gems/rspec-mocks-3.9.1/lib/rspec/mocks/matchers/receive.rb

@@ -0,0 +1,132 @@
+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