pangea-core 0.2.0 → 0.3.0

data/vendor/bundle/ruby/3.3.0/gems/rspec-mocks-3.13.7/lib/rspec/mocks/argument_list_matcher.rb

@@ -0,0 +1,117 @@
+# We intentionally do not use the `RSpec::Support.require...` methods
+# here so that this file can be loaded individually, as documented
+# below.
+require 'rspec/mocks/argument_matchers'
+require 'rspec/support/fuzzy_matcher'
+
+module RSpec
+  module Mocks
+    # Wrapper for matching arguments against a list of expected values. Used by
+    # the `with` method on a `MessageExpectation`:
+    #
+    #     expect(object).to receive(:message).with(:a, 'b', 3)
+    #     object.message(:a, 'b', 3)
+    #
+    # Values passed to `with` can be literal values or argument matchers that
+    # match against the real objects .e.g.
+    #
+    #     expect(object).to receive(:message).with(hash_including(:a => 'b'))
+    #
+    # Can also be used directly to match the contents of any `Array`. This
+    # enables 3rd party mocking libs to take advantage of rspec's argument
+    # matching without using the rest of rspec-mocks.
+    #
+    #     require 'rspec/mocks/argument_list_matcher'
+    #     include RSpec::Mocks::ArgumentMatchers
+    #
+    #     arg_list_matcher = RSpec::Mocks::ArgumentListMatcher.new(123, hash_including(:a => 'b'))
+    #     arg_list_matcher.args_match?(123, :a => 'b')
+    #
+    # This class is immutable.
+    #
+    # @see ArgumentMatchers
+    class ArgumentListMatcher
+      # @private
+      attr_reader :expected_args
+
+      # @api public
+      # @param [Array] expected_args a list of expected literals and/or argument matchers
+      #
+      # Initializes an `ArgumentListMatcher` with a collection of literal
+      # values and/or argument matchers.
+      #
+      # @see ArgumentMatchers
+      # @see #args_match?
+      def initialize(*expected_args)
+        @expected_args = expected_args
+        ensure_expected_args_valid!
+      end
+      ruby2_keywords :initialize if respond_to?(:ruby2_keywords, true)
+
+      # @api public
+      # @param [Array] actual_args
+      #
+      # Matches each element in the `expected_args` against the element in the same
+      # position of the arguments passed to `new`.
+      #
+      # @see #initialize
+      def args_match?(*actual_args)
+        expected_args = resolve_expected_args_based_on(actual_args)
+
+        return false if expected_args.size != actual_args.size
+
+        if RUBY_VERSION >= "3"
+          # If the expectation was set with keywords, while the actual method was called with a positional hash argument, they don't match.
+          # If the expectation was set without keywords, e.g., with({a: 1}), then it fine to call it with either foo(a: 1) or foo({a: 1}).
+          # This corresponds to Ruby semantics, as if the method was def foo(options).
+          if Hash === expected_args.last && Hash === actual_args.last
+            if !Hash.ruby2_keywords_hash?(actual_args.last) && Hash.ruby2_keywords_hash?(expected_args.last)
+              return false
+            end
+          end
+        end
+
+        Support::FuzzyMatcher.values_match?(expected_args, actual_args)
+      end
+      ruby2_keywords :args_match? if respond_to?(:ruby2_keywords, true)
+
+      # @private
+      # Resolves abstract arg placeholders like `no_args` and `any_args` into
+      # a more concrete arg list based on the provided `actual_args`.
+      def resolve_expected_args_based_on(actual_args)
+        return [] if [ArgumentMatchers::NoArgsMatcher::INSTANCE] == expected_args
+
+        any_args_index = expected_args.index { |a| ArgumentMatchers::AnyArgsMatcher::INSTANCE == a }
+        return expected_args unless any_args_index
+
+        replace_any_args_with_splat_of_anything(any_args_index, actual_args.count)
+      end
+
+    private
+
+      def replace_any_args_with_splat_of_anything(before_count, actual_args_count)
+        any_args_count  = actual_args_count   - expected_args.count + 1
+        after_count     = expected_args.count - before_count        - 1
+
+        any_args = 1.upto(any_args_count).map { ArgumentMatchers::AnyArgMatcher::INSTANCE }
+        expected_args.first(before_count) + any_args + expected_args.last(after_count)
+      end
+
+      def ensure_expected_args_valid!
+        if expected_args.count { |a| ArgumentMatchers::AnyArgsMatcher::INSTANCE == a } > 1
+          raise ArgumentError, "`any_args` can only be passed to " \
+                "`with` once but you have passed it multiple times."
+        elsif expected_args.count > 1 && expected_args.any? { |a| ArgumentMatchers::NoArgsMatcher::INSTANCE == a }
+          raise ArgumentError, "`no_args` can only be passed as a " \
+                "singleton argument to `with` (i.e. `with(no_args)`), " \
+                "but you have passed additional arguments."
+        end
+      end
+
+      # Value that will match all argument lists.
+      #
+      # @private
+      MATCH_ALL = new(ArgumentMatchers::AnyArgsMatcher::INSTANCE)
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/rspec-mocks-3.13.7/lib/rspec/mocks/argument_matchers.rb

@@ -0,0 +1,366 @@
+# This cannot take advantage of our relative requires, since this file is a
+# dependency of `rspec/mocks/argument_list_matcher.rb`. See comment there for
+# details.
+require 'rspec/support/matcher_definition'
+
+module RSpec
+  module Mocks
+    # ArgumentMatchers are placeholders that you can include in message
+    # expectations to match arguments against a broader check than simple
+    # equality.
+    #
+    # With the exception of `any_args` and `no_args`, they all match against
+    # the arg in same position in the argument list.
+    #
+    # @see ArgumentListMatcher
+    module ArgumentMatchers
+      # Acts like an arg splat, matching any number of args at any point in an arg list.
+      #
+      # @example
+      #   expect(object).to receive(:message).with(1, 2, any_args)
+      #
+      #   # matches any of these:
+      #   object.message(1, 2)
+      #   object.message(1, 2, 3)
+      #   object.message(1, 2, 3, 4)
+      def any_args
+        AnyArgsMatcher::INSTANCE
+      end
+
+      # Matches any argument at all.
+      #
+      # @example
+      #   expect(object).to receive(:message).with(anything)
+      def anything
+        AnyArgMatcher::INSTANCE
+      end
+
+      # Matches no arguments.
+      #
+      # @example
+      #   expect(object).to receive(:message).with(no_args)
+      def no_args
+        NoArgsMatcher::INSTANCE
+      end
+
+      # Matches if the actual argument responds to the specified messages.
+      #
+      # @example
+      #   expect(object).to receive(:message).with(duck_type(:hello))
+      #   expect(object).to receive(:message).with(duck_type(:hello, :goodbye))
+      def duck_type(*args)
+        DuckTypeMatcher.new(*args)
+      end
+
+      # Matches a boolean value.
+      #
+      # @example
+      #   expect(object).to receive(:message).with(boolean())
+      def boolean
+        BooleanMatcher::INSTANCE
+      end
+
+      # Matches a hash that includes the specified key(s) or key/value pairs.
+      # Ignores any additional keys.
+      #
+      # @example
+      #   expect(object).to receive(:message).with(hash_including(:key => val))
+      #   expect(object).to receive(:message).with(hash_including(:key))
+      #   expect(object).to receive(:message).with(hash_including(:key, :key2 => val2))
+      def hash_including(*args)
+        HashIncludingMatcher.new(ArgumentMatchers.anythingize_lonely_keys(*args))
+      end
+
+      # Matches a hash that doesn't include the specified key(s) or key/value.
+      #
+      # @example
+      #   expect(object).to receive(:message).with(hash_excluding(:key => val))
+      #   expect(object).to receive(:message).with(hash_excluding(:key))
+      #   expect(object).to receive(:message).with(hash_excluding(:key, :key2 => :val2))
+      def hash_excluding(*args)
+        HashExcludingMatcher.new(ArgumentMatchers.anythingize_lonely_keys(*args))
+      end
+
+      # Matches an array that includes the specified items at least once.
+      # Ignores duplicates and additional values
+      #
+      # @example
+      #   expect(object).to receive(:message).with(array_including(1,2,3))
+      #   expect(object).to receive(:message).with(array_including([1,2,3]))
+      def array_including(*args)
+        actually_an_array = Array === args.first && args.count == 1 ? args.first : args
+        ArrayIncludingMatcher.new(actually_an_array)
+      end
+
+      # Matches an array that excludes the specified items.
+      #
+      # @example
+      #   expect(object).to receive(:message).with(array_excluding(1,2,3))
+      #   expect(object).to receive(:message).with(array_excluding([1,2,3]))
+      def array_excluding(*args)
+        actually_an_array = Array === args.first && args.count == 1 ? args.first : args
+        ArrayExcludingMatcher.new(actually_an_array)
+      end
+
+      alias_method :hash_not_including, :hash_excluding
+
+      # Matches if `arg.instance_of?(klass)`
+      #
+      # @example
+      #   expect(object).to receive(:message).with(instance_of(Thing))
+      def instance_of(klass)
+        InstanceOf.new(klass)
+      end
+
+      alias_method :an_instance_of, :instance_of
+
+      # Matches if `arg.kind_of?(klass)`
+      #
+      # @example
+      #   expect(object).to receive(:message).with(kind_of(Thing))
+      def kind_of(klass)
+        KindOf.new(klass)
+      end
+
+      alias_method :a_kind_of, :kind_of
+
+      # @private
+      def self.anythingize_lonely_keys(*args)
+        hash = Hash === args.last ? args.delete_at(-1) : {}
+        args.each { | arg | hash[arg] = AnyArgMatcher::INSTANCE }
+        hash
+      end
+
+      # Intended to be subclassed by stateless, immutable argument matchers.
+      # Provides a `<klass name>::INSTANCE` constant for accessing a global
+      # singleton instance of the matcher. There is no need to construct
+      # multiple instance since there is no state. It also facilities the
+      # special case logic we need for some of these matchers, by making it
+      # easy to do comparisons like: `[klass::INSTANCE] == args` rather than
+      # `args.count == 1 && klass === args.first`.
+      #
+      # @private
+      class SingletonMatcher
+        private_class_method :new
+
+        def self.inherited(subklass)
+          subklass.const_set(:INSTANCE, subklass.send(:new))
+        end
+      end
+
+      # @private
+      class AnyArgsMatcher < SingletonMatcher
+        def description
+          "*(any args)"
+        end
+      end
+
+      # @private
+      class AnyArgMatcher < SingletonMatcher
+        def ===(_other)
+          true
+        end
+
+        def description
+          "anything"
+        end
+      end
+
+      # @private
+      class NoArgsMatcher < SingletonMatcher
+        def description
+          "no args"
+        end
+      end
+
+      # @private
+      class BooleanMatcher < SingletonMatcher
+        def ===(value)
+          true == value || false == value
+        end
+
+        def description
+          "boolean"
+        end
+      end
+
+      # @private
+      class BaseHashMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ===(predicate, actual)
+          @expected.__send__(predicate) do |k, v|
+            actual.key?(k) && Support::FuzzyMatcher.values_match?(v, actual[k])
+          end
+        rescue NoMethodError
+          false
+        end
+
+        def description(name)
+          "#{name}(#{formatted_expected_hash.inspect.sub(/^\{/, "").sub(/\}$/, "")})"
+        end
+
+      private
+
+        def formatted_expected_hash
+          Hash[
+            @expected.map do |k, v|
+              k = RSpec::Support.rspec_description_for_object(k)
+              v = RSpec::Support.rspec_description_for_object(v)
+
+              [k, v]
+            end
+          ]
+        end
+      end
+
+      # @private
+      class HashIncludingMatcher < BaseHashMatcher
+        def ===(actual)
+          super(:all?, actual)
+        end
+
+        def description
+          super("hash_including")
+        end
+      end
+
+      # @private
+      class HashExcludingMatcher < BaseHashMatcher
+        def ===(actual)
+          super(:none?, actual)
+        end
+
+        def description
+          super("hash_not_including")
+        end
+      end
+
+      # @private
+      class ArrayIncludingMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ===(actual)
+          actual = actual.uniq
+          return true if (actual & @expected).count >= @expected.count
+
+          @expected.uniq.all? do |expected_element|
+            actual.any? do |actual_element|
+              RSpec::Support::FuzzyMatcher.values_match?(expected_element, actual_element)
+            end
+          end
+        rescue NoMethodError
+          false
+        end
+
+        def description
+          "array_including(#{formatted_expected_values})"
+        end
+
+      private
+
+        def formatted_expected_values
+          @expected.map do |x|
+            RSpec::Support.rspec_description_for_object(x)
+          end.join(", ")
+        end
+      end
+
+      # @private
+      class ArrayExcludingMatcher
+        def initialize(unexpected)
+          @unexpected = unexpected.uniq
+        end
+
+        def ===(actual)
+          actual = actual.uniq
+          return false unless (actual & @unexpected).empty?
+
+          actual.none? do |actual_element|
+            @unexpected.any? do |unexpected_element|
+              RSpec::Support::FuzzyMatcher.values_match?(unexpected_element, actual_element)
+            end
+          end
+        rescue NoMethodError
+          false
+        end
+
+        def description
+          "array_excluding(#{formatted_unexpected_values})"
+        end
+
+      private
+
+        def formatted_unexpected_values
+          @unexpected.map do |x|
+            RSpec::Support.rspec_description_for_object(x)
+          end.join(", ")
+        end
+      end
+
+      # @private
+      class DuckTypeMatcher
+        def initialize(*methods_to_respond_to)
+          @methods_to_respond_to = methods_to_respond_to
+        end
+
+        def ===(value)
+          @methods_to_respond_to.all? { |message| value.respond_to?(message) }
+        end
+
+        def description
+          "duck_type(#{@methods_to_respond_to.map(&:inspect).join(', ')})"
+        end
+      end
+
+      # @private
+      class InstanceOf
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def ===(actual)
+          actual.instance_of?(@klass)
+        end
+
+        def description
+          "an_instance_of(#{@klass.name})"
+        end
+      end
+
+      # @private
+      class KindOf
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def ===(actual)
+          actual.kind_of?(@klass)
+        end
+
+        def description
+          "kind of #{@klass.name}"
+        end
+      end
+
+      matcher_namespace = name + '::'
+      ::RSpec::Support.register_matcher_definition do |object|
+        # This is the best we have for now. We should tag all of our matchers
+        # with a module or something so we can test for it directly.
+        #
+        # (Note Module#parent in ActiveSupport is defined in a similar way.)
+        begin
+          object.class.name.include?(matcher_namespace)
+        rescue NoMethodError
+          # Some objects, like BasicObject, don't implement standard
+          # reflection methods.
+          false
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/rspec-mocks-3.13.7/lib/rspec/mocks/configuration.rb

@@ -0,0 +1,212 @@
+module RSpec
+  module Mocks
+    # Provides configuration options for rspec-mocks.
+    class Configuration
+      def initialize
+        @allow_message_expectations_on_nil = nil
+        @yield_receiver_to_any_instance_implementation_blocks = true
+        @verify_doubled_constant_names = false
+        @transfer_nested_constants = false
+        @verify_partial_doubles = false
+        @temporarily_suppress_partial_double_verification = false
+        @color = false
+      end
+
+      # Sets whether RSpec will warn, ignore, or fail a test when
+      # expectations are set on nil.
+      # By default, when this flag is not set, warning messages are issued when
+      # expectations are set on nil. This is to prevent false-positives and to
+      # catch potential bugs early on.
+      # When set to `true`, warning messages are suppressed.
+      # When set to `false`, it will raise an error.
+      #
+      # @example
+      #   RSpec.configure do |config|
+      #     config.mock_with :rspec do |mocks|
+      #       mocks.allow_message_expectations_on_nil = false
+      #     end
+      #   end
+      attr_accessor :allow_message_expectations_on_nil
+
+      def yield_receiver_to_any_instance_implementation_blocks?
+        @yield_receiver_to_any_instance_implementation_blocks
+      end
+
+      # Sets whether or not RSpec will yield the receiving instance of a
+      # message to blocks that are used for any_instance stub implementations.
+      # When set, the first yielded argument will be the receiving instance.
+      # Defaults to `true`.
+      #
+      # @example
+      #   RSpec.configure do |rspec|
+      #     rspec.mock_with :rspec do |mocks|
+      #       mocks.yield_receiver_to_any_instance_implementation_blocks = false
+      #     end
+      #   end
+      attr_writer :yield_receiver_to_any_instance_implementation_blocks
+
+      # Adds `stub` and `should_receive` to the given
+      # modules or classes. This is usually only necessary
+      # if you application uses some proxy classes that
+      # "strip themselves down" to a bare minimum set of
+      # methods and remove `stub` and `should_receive` in
+      # the process.
+      #
+      # @example
+      #   RSpec.configure do |rspec|
+      #     rspec.mock_with :rspec do |mocks|
+      #       mocks.add_stub_and_should_receive_to Delegator
+      #     end
+      #   end
+      #
+      def add_stub_and_should_receive_to(*modules)
+        modules.each do |mod|
+          Syntax.enable_should(mod)
+        end
+      end
+
+      # Provides the ability to set either `expect`,
+      # `should` or both syntaxes. RSpec uses `expect`
+      # syntax by default. This is needed if you want to
+      # explicitly enable `should` syntax and/or explicitly
+      # disable `expect` syntax.
+      #
+      # @example
+      #   RSpec.configure do |rspec|
+      #     rspec.mock_with :rspec do |mocks|
+      #       mocks.syntax = [:expect, :should]
+      #     end
+      #  end
+      #
+      def syntax=(*values)
+        syntaxes = values.flatten
+        if syntaxes.include?(:expect)
+          Syntax.enable_expect
+        else
+          Syntax.disable_expect
+        end
+
+        if syntaxes.include?(:should)
+          Syntax.enable_should
+        else
+          Syntax.disable_should
+        end
+      end
+
+      # Returns an array with a list of syntaxes
+      # that are enabled.
+      #
+      # @example
+      #   unless RSpec::Mocks.configuration.syntax.include?(:expect)
+      #     raise "this RSpec extension gem requires the rspec-mocks `:expect` syntax"
+      #   end
+      #
+      def syntax
+        syntaxes = []
+        syntaxes << :should  if Syntax.should_enabled?
+        syntaxes << :expect if Syntax.expect_enabled?
+        syntaxes
+      end
+
+      def verify_doubled_constant_names?
+        !!@verify_doubled_constant_names
+      end
+
+      # When this is set to true, an error will be raised when
+      # `instance_double` or `class_double` is given the name of an undefined
+      # constant. You probably only want to set this when running your entire
+      # test suite, with all production code loaded. Setting this for an
+      # isolated unit test will prevent you from being able to isolate it!
+      attr_writer :verify_doubled_constant_names
+
+      # Provides a way to perform customisations when verifying doubles.
+      #
+      # @example
+      #  RSpec::Mocks.configuration.before_verifying_doubles do |ref|
+      #    ref.some_method!
+      #  end
+      def before_verifying_doubles(&block)
+        verifying_double_callbacks << block
+      end
+      alias :when_declaring_verifying_double :before_verifying_doubles
+
+      # @api private
+      # Returns an array of blocks to call when verifying doubles
+      def verifying_double_callbacks
+        @verifying_double_callbacks ||= []
+      end
+
+      def transfer_nested_constants?
+        !!@transfer_nested_constants
+      end
+
+      # Sets the default for the `transfer_nested_constants` option when
+      # stubbing constants.
+      attr_writer :transfer_nested_constants
+
+      # When set to true, partial mocks will be verified the same as object
+      # doubles. Any stubs will have their arguments checked against the original
+      # method, and methods that do not exist cannot be stubbed.
+      def verify_partial_doubles=(val)
+        @verify_partial_doubles = !!val
+      end
+
+      def verify_partial_doubles?
+        @verify_partial_doubles
+      end
+
+      # @private
+      # Used to track whether we are temporarily suppressing verifying partial
+      # doubles with `without_partial_double_verification { ... }`
+      attr_accessor :temporarily_suppress_partial_double_verification
+
+      if ::RSpec.respond_to?(:configuration)
+        def color?
+          ::RSpec.configuration.color_enabled?
+        end
+      else
+        # Indicates whether or not diffs should be colored.
+        # Delegates to rspec-core's color option if rspec-core
+        # is loaded; otherwise you can set it here.
+        attr_writer :color
+
+        # Indicates whether or not diffs should be colored.
+        # Delegates to rspec-core's color option if rspec-core
+        # is loaded; otherwise you can set it here.
+        def color?
+          @color
+        end
+      end
+
+      # Monkey-patch `Marshal.dump` to enable dumping of mocked or stubbed
+      # objects. By default this will not work since RSpec mocks works by
+      # adding singleton methods that cannot be serialized. This patch removes
+      # these singleton methods before serialization. Setting to falsey removes
+      # the patch.
+      #
+      # This method is idempotent.
+      def patch_marshal_to_support_partial_doubles=(val)
+        if val
+          RSpec::Mocks::MarshalExtension.patch!
+        else
+          RSpec::Mocks::MarshalExtension.unpatch!
+        end
+      end
+
+      # @api private
+      # Resets the configured syntax to the default.
+      def reset_syntaxes_to_default
+        self.syntax = [:should, :expect]
+        RSpec::Mocks::Syntax.warn_about_should!
+      end
+    end
+
+    # Mocks specific configuration, as distinct from `RSpec.configuration`
+    # which is core RSpec configuration.
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    configuration.reset_syntaxes_to_default
+  end
+end