svix 0.53.1 → 0.53.2

data/vendor/bundle/ruby/2.7.0/gems/rspec-mocks-3.10.2/lib/rspec/mocks/test_double.rb

@@ -1,171 +0,0 @@
-module RSpec
-  module Mocks
-    # Implements the methods needed for a pure test double.  RSpec::Mocks::Double
-    # includes this module, and it is provided for cases where you want a
-    # pure test double without subclassing RSpec::Mocks::Double.
-    module TestDouble
-      # Creates a new test double with a `name` (that will be used in error
-      # messages only)
-      def initialize(name=nil, stubs={})
-        @__expired = false
-        if Hash === name && stubs.empty?
-          stubs = name
-          @name = nil
-        else
-          @name = name
-        end
-        assign_stubs(stubs)
-      end
-
-      # Tells the object to respond to all messages. If specific stub values
-      # are declared, they'll work as expected. If not, the receiver is
-      # returned.
-      def as_null_object
-        __mock_proxy.as_null_object
-      end
-
-      # Returns true if this object has received `as_null_object`
-      def null_object?
-        __mock_proxy.null_object?
-      end
-
-      # This allows for comparing the mock to other objects that proxy such as
-      # ActiveRecords belongs_to proxy objects. By making the other object run
-      # the comparison, we're sure the call gets delegated to the proxy
-      # target.
-      def ==(other)
-        other == __mock_proxy
-      end
-
-      # @private
-      def inspect
-        TestDoubleFormatter.format(self)
-      end
-
-      # @private
-      def to_s
-        inspect.tr('<', '[').tr('>', ']')
-      end
-
-      # @private
-      def respond_to?(message, incl_private=false)
-        __mock_proxy.null_object? ? true : super
-      end
-
-      # @private
-      def __build_mock_proxy_unless_expired(order_group)
-        __raise_expired_error || __build_mock_proxy(order_group)
-      end
-
-      # @private
-      def __disallow_further_usage!
-        @__expired = true
-      end
-
-      # Override for default freeze implementation to prevent freezing of test
-      # doubles.
-      def freeze
-        RSpec.warn_with("WARNING: you attempted to freeze a test double. This is explicitly a no-op as freezing doubles can lead to undesired behaviour when resetting tests.")
-        self
-      end
-
-    private
-
-      def method_missing(message, *args, &block)
-        proxy = __mock_proxy
-        proxy.record_message_received(message, *args, &block)
-
-        if proxy.null_object?
-          case message
-          when :to_int        then return 0
-          when :to_a, :to_ary then return nil
-          when :to_str        then return to_s
-          else return self
-          end
-        end
-
-        # Defined private and protected methods will still trigger `method_missing`
-        # when called publicly. We want ruby's method visibility error to get raised,
-        # so we simply delegate to `super` in that case.
-        # ...well, we would delegate to `super`, but there's a JRuby
-        # bug, so we raise our own visibility error instead:
-        # https://github.com/jruby/jruby/issues/1398
-        visibility = proxy.visibility_for(message)
-        if visibility == :private || visibility == :protected
-          ErrorGenerator.new(self).raise_non_public_error(
-            message, visibility
-          )
-        end
-
-        # Required wrapping doubles in an Array on Ruby 1.9.2
-        raise NoMethodError if [:to_a, :to_ary].include? message
-        proxy.raise_unexpected_message_error(message, args)
-      end
-
-      def assign_stubs(stubs)
-        stubs.each_pair do |message, response|
-          __mock_proxy.add_simple_stub(message, response)
-        end
-      end
-
-      def __mock_proxy
-        ::RSpec::Mocks.space.proxy_for(self)
-      end
-
-      def __build_mock_proxy(order_group)
-        TestDoubleProxy.new(self, order_group)
-      end
-
-      def __raise_expired_error
-        return false unless @__expired
-        ErrorGenerator.new(self).raise_expired_test_double_error
-      end
-
-      def initialize_copy(other)
-        as_null_object if other.null_object?
-        super
-      end
-    end
-
-    # A generic test double object. `double`, `instance_double` and friends
-    # return an instance of this.
-    class Double
-      include TestDouble
-    end
-
-    # @private
-    module TestDoubleFormatter
-      def self.format(dbl, unwrap=false)
-        format = "#{type_desc(dbl)}#{verified_module_desc(dbl)} #{name_desc(dbl)}"
-        return format if unwrap
-        "#<#{format}>"
-      end
-
-      class << self
-      private
-
-        def type_desc(dbl)
-          case dbl
-          when InstanceVerifyingDouble then "InstanceDouble"
-          when ClassVerifyingDouble    then "ClassDouble"
-          when ObjectVerifyingDouble   then "ObjectDouble"
-          else "Double"
-          end
-        end
-
-        # @private
-        IVAR_GET = Object.instance_method(:instance_variable_get)
-
-        def verified_module_desc(dbl)
-          return nil unless VerifyingDouble === dbl
-          "(#{IVAR_GET.bind(dbl).call(:@doubled_module).description})"
-        end
-
-        def name_desc(dbl)
-          return "(anonymous)" unless (name = IVAR_GET.bind(dbl).call(:@name))
-          name.inspect
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rspec-mocks-3.10.2/lib/rspec/mocks/verifying_double.rb

@@ -1,129 +0,0 @@
-RSpec::Support.require_rspec_mocks 'verifying_proxy'
-
-module RSpec
-  module Mocks
-    # @private
-    module VerifyingDouble
-      def respond_to?(message, include_private=false)
-        return super unless null_object?
-
-        method_ref = __mock_proxy.method_reference[message]
-
-        case method_ref.visibility
-        when :public    then true
-        when :private   then include_private
-        when :protected then include_private || RUBY_VERSION.to_f < 2.0
-        else !method_ref.unimplemented?
-        end
-      end
-
-      def method_missing(message, *args, &block)
-        # Null object conditional is an optimization. If not a null object,
-        # validity of method expectations will have been checked at definition
-        # time.
-        if null_object?
-          if @__sending_message == message
-            __mock_proxy.ensure_implemented(message)
-          else
-            __mock_proxy.ensure_publicly_implemented(message, self)
-          end
-
-          __mock_proxy.validate_arguments!(message, args)
-        end
-
-        super
-      end
-
-      # @private
-      module SilentIO
-        def self.method_missing(*); end
-        def self.respond_to?(*)
-          true
-        end
-      end
-
-      # Redefining `__send__` causes ruby to issue a warning.
-      old, $stderr = $stderr, SilentIO
-      def __send__(name, *args, &block)
-        @__sending_message = name
-        super
-      ensure
-        @__sending_message = nil
-      end
-      $stderr = old
-
-      def send(name, *args, &block)
-        __send__(name, *args, &block)
-      end
-
-      def initialize(doubled_module, *args)
-        @doubled_module = doubled_module
-
-        possible_name = args.first
-        name = if String === possible_name || Symbol === possible_name
-                 args.shift
-               end
-
-        super(name, *args)
-        @__sending_message = nil
-      end
-    end
-
-    # A mock providing a custom proxy that can verify the validity of any
-    # method stubs or expectations against the public instance methods of the
-    # given class.
-    #
-    # @private
-    class InstanceVerifyingDouble
-      include TestDouble
-      include VerifyingDouble
-
-      def __build_mock_proxy(order_group)
-        VerifyingProxy.new(self, order_group,
-                           @doubled_module,
-                           InstanceMethodReference
-        )
-      end
-    end
-
-    # An awkward module necessary because we cannot otherwise have
-    # ClassVerifyingDouble inherit from Module and still share these methods.
-    #
-    # @private
-    module ObjectVerifyingDoubleMethods
-      include TestDouble
-      include VerifyingDouble
-
-      def as_stubbed_const(options={})
-        ConstantMutator.stub(@doubled_module.const_to_replace, self, options)
-        self
-      end
-
-    private
-
-      def __build_mock_proxy(order_group)
-        VerifyingProxy.new(self, order_group,
-                           @doubled_module,
-                           ObjectMethodReference
-        )
-      end
-    end
-
-    # Similar to an InstanceVerifyingDouble, except that it verifies against
-    # public methods of the given object.
-    #
-    # @private
-    class ObjectVerifyingDouble
-      include ObjectVerifyingDoubleMethods
-    end
-
-    # Effectively the same as an ObjectVerifyingDouble (since a class is a type
-    # of object), except with Module in the inheritance chain so that
-    # transferring nested constants to work.
-    #
-    # @private
-    class ClassVerifyingDouble < Module
-      include ObjectVerifyingDoubleMethods
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rspec-mocks-3.10.2/lib/rspec/mocks/verifying_message_expectation.rb

@@ -1,54 +0,0 @@
-RSpec::Support.require_rspec_support 'method_signature_verifier'
-
-module RSpec
-  module Mocks
-    # A message expectation that knows about the real implementation of the
-    # message being expected, so that it can verify that any expectations
-    # have the valid arguments.
-    # @api private
-    class VerifyingMessageExpectation < MessageExpectation
-      # A level of indirection is used here rather than just passing in the
-      # method itself, since method look up is expensive and we only want to
-      # do it if actually needed.
-      #
-      # Conceptually the method reference makes more sense as a constructor
-      # argument since it should be immutable, but it is significantly more
-      # straight forward to build the object in pieces so for now it stays as
-      # an accessor.
-      attr_accessor :method_reference
-
-      def initialize(*args)
-        super
-      end
-
-      # @private
-      def with(*args, &block)
-        super(*args, &block).tap do
-          validate_expected_arguments! do |signature|
-            example_call_site_args = [:an_arg] * signature.min_non_kw_args
-            example_call_site_args << :kw_args_hash if signature.required_kw_args.any?
-            @argument_list_matcher.resolve_expected_args_based_on(example_call_site_args)
-          end
-        end
-      end
-
-    private
-
-      def validate_expected_arguments!
-        return if method_reference.nil?
-
-        method_reference.with_signature do |signature|
-          args     = yield signature
-          verifier = Support::LooseSignatureVerifier.new(signature, args)
-
-          unless verifier.valid?
-            # Fail fast is required, otherwise the message expectation will fail
-            # as well ("expected method not called") and clobber this one.
-            @failed_fast = true
-            @error_generator.raise_invalid_arguments_error(verifier)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rspec-mocks-3.10.2/lib/rspec/mocks/verifying_proxy.rb

@@ -1,220 +0,0 @@
-RSpec::Support.require_rspec_mocks 'verifying_message_expectation'
-RSpec::Support.require_rspec_mocks 'method_reference'
-
-module RSpec
-  module Mocks
-    # @private
-    class CallbackInvocationStrategy
-      def call(doubled_module)
-        RSpec::Mocks.configuration.verifying_double_callbacks.each do |block|
-          block.call doubled_module
-        end
-      end
-    end
-
-    # @private
-    class NoCallbackInvocationStrategy
-      def call(_doubled_module)
-      end
-    end
-
-    # @private
-    module VerifyingProxyMethods
-      def add_stub(method_name, opts={}, &implementation)
-        ensure_implemented(method_name)
-        super
-      end
-
-      def add_simple_stub(method_name, *args)
-        ensure_implemented(method_name)
-        super
-      end
-
-      def add_message_expectation(method_name, opts={}, &block)
-        ensure_implemented(method_name)
-        super
-      end
-
-      def ensure_implemented(method_name)
-        return unless method_reference[method_name].unimplemented?
-
-        @error_generator.raise_unimplemented_error(
-          @doubled_module,
-          method_name,
-          @object
-        )
-      end
-
-      def ensure_publicly_implemented(method_name, _object)
-        ensure_implemented(method_name)
-        visibility = method_reference[method_name].visibility
-
-        return if visibility == :public
-        @error_generator.raise_non_public_error(method_name, visibility)
-      end
-    end
-
-    # A verifying proxy mostly acts like a normal proxy, except that it
-    # contains extra logic to try and determine the validity of any expectation
-    # set on it. This includes whether or not methods have been defined and the
-    # validatiy of arguments on method calls.
-    #
-    # In all other ways this behaves like a normal proxy. It only adds the
-    # verification behaviour to specific methods then delegates to the parent
-    # implementation.
-    #
-    # These checks are only activated if the doubled class has already been
-    # loaded, otherwise they are disabled. This allows for testing in
-    # isolation.
-    #
-    # @private
-    class VerifyingProxy < TestDoubleProxy
-      include VerifyingProxyMethods
-
-      def initialize(object, order_group, doubled_module, method_reference_class)
-        super(object, order_group)
-        @object                 = object
-        @doubled_module         = doubled_module
-        @method_reference_class = method_reference_class
-
-        # A custom method double is required to pass through a way to lookup
-        # methods to determine their parameters. This is only relevant if the doubled
-        # class is loaded.
-        @method_doubles = Hash.new do |h, k|
-          h[k] = VerifyingMethodDouble.new(@object, k, self, method_reference[k])
-        end
-      end
-
-      def method_reference
-        @method_reference ||= Hash.new do |h, k|
-          h[k] = @method_reference_class.for(@doubled_module, k)
-        end
-      end
-
-      def visibility_for(method_name)
-        method_reference[method_name].visibility
-      end
-
-      def validate_arguments!(method_name, args)
-        @method_doubles[method_name].validate_arguments!(args)
-      end
-    end
-
-    # @private
-    DEFAULT_CALLBACK_INVOCATION_STRATEGY = CallbackInvocationStrategy.new
-
-    # @private
-    class VerifyingPartialDoubleProxy < PartialDoubleProxy
-      include VerifyingProxyMethods
-
-      def initialize(object, expectation_ordering, optional_callback_invocation_strategy=DEFAULT_CALLBACK_INVOCATION_STRATEGY)
-        super(object, expectation_ordering)
-        @doubled_module = DirectObjectReference.new(object)
-
-        # A custom method double is required to pass through a way to lookup
-        # methods to determine their parameters.
-        @method_doubles = Hash.new do |h, k|
-          h[k] = VerifyingExistingMethodDouble.for(object, k, self)
-        end
-
-        optional_callback_invocation_strategy.call(@doubled_module)
-      end
-
-      def ensure_implemented(_method_name)
-        return if Mocks.configuration.temporarily_suppress_partial_double_verification
-        super
-      end
-
-      def method_reference
-        @method_doubles
-      end
-    end
-
-    # @private
-    class VerifyingPartialClassDoubleProxy < VerifyingPartialDoubleProxy
-      include PartialClassDoubleProxyMethods
-    end
-
-    # @private
-    class VerifyingMethodDouble < MethodDouble
-      def initialize(object, method_name, proxy, method_reference)
-        super(object, method_name, proxy)
-        @method_reference = method_reference
-      end
-
-      def message_expectation_class
-        VerifyingMessageExpectation
-      end
-
-      def add_expectation(*args, &block)
-        # explict params necessary for 1.8.7 see #626
-        super(*args, &block).tap { |x| x.method_reference = @method_reference }
-      end
-
-      def add_stub(*args, &block)
-        # explict params necessary for 1.8.7 see #626
-        super(*args, &block).tap { |x| x.method_reference = @method_reference }
-      end
-
-      def proxy_method_invoked(obj, *args, &block)
-        validate_arguments!(args)
-        super
-      end
-
-      def validate_arguments!(actual_args)
-        @method_reference.with_signature do |signature|
-          verifier = Support::StrictSignatureVerifier.new(signature, actual_args)
-          raise ArgumentError, verifier.error_message unless verifier.valid?
-        end
-      end
-    end
-
-    # A VerifyingMethodDouble fetches the method to verify against from the
-    # original object, using a MethodReference. This works for pure doubles,
-    # but when the original object is itself the one being modified we need to
-    # collapse the reference and the method double into a single object so that
-    # we can access the original pristine method definition.
-    #
-    # @private
-    class VerifyingExistingMethodDouble < VerifyingMethodDouble
-      def initialize(object, method_name, proxy)
-        super(object, method_name, proxy, self)
-
-        @valid_method = object.respond_to?(method_name, true)
-
-        # Trigger an eager find of the original method since if we find it any
-        # later we end up getting a stubbed method with incorrect arity.
-        save_original_implementation_callable!
-      end
-
-      def with_signature
-        yield Support::MethodSignature.new(original_implementation_callable)
-      end
-
-      def unimplemented?
-        !@valid_method
-      end
-
-      def self.for(object, method_name, proxy)
-        if ClassNewMethodReference.applies_to?(method_name) { object }
-          VerifyingExistingClassNewMethodDouble
-        elsif Mocks.configuration.temporarily_suppress_partial_double_verification
-          MethodDouble
-        else
-          self
-        end.new(object, method_name, proxy)
-      end
-    end
-
-    # Used in place of a `VerifyingExistingMethodDouble` for the specific case
-    # of mocking or stubbing a `new` method on a class. In this case, we substitute
-    # the method signature from `#initialize` since new's signature is just `*args`.
-    #
-    # @private
-    class VerifyingExistingClassNewMethodDouble < VerifyingExistingMethodDouble
-      def with_signature
-        yield Support::MethodSignature.new(object.instance_method(:initialize))
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rspec-mocks-3.10.2/lib/rspec/mocks/version.rb

@@ -1,9 +0,0 @@
-module RSpec
-  module Mocks
-    # Version information for RSpec mocks.
-    module Version
-      # Version of RSpec mocks currently in use in SemVer format.
-      STRING = '3.10.2'
-    end
-  end
-end