takuya-lvm-snapshot 0.1.0

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

@@ -0,0 +1,171 @@
+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/bundle/ruby/2.7.0/gems/rspec-mocks-3.12.1/lib/rspec/mocks/verifying_double.rb

@@ -0,0 +1,121 @@
+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
+
+      # Redefining `__send__` causes ruby to issue a warning.
+      old, $VERBOSE = $VERBOSE, nil
+      def __send__(name, *args, &block)
+        @__sending_message = name
+        super
+      ensure
+        @__sending_message = nil
+      end
+      $VERBOSE = 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/bundle/ruby/2.7.0/gems/rspec-mocks-3.12.1/lib/rspec/mocks/verifying_message_expectation.rb

@@ -0,0 +1,55 @@
+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
+      ruby2_keywords(:with) if respond_to?(:ruby2_keywords, true)
+
+    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/bundle/ruby/2.7.0/gems/rspec-mocks-3.12.1/lib/rspec/mocks/verifying_proxy.rb

@@ -0,0 +1,220 @@
+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/bundle/ruby/2.7.0/gems/rspec-mocks-3.12.1/lib/rspec/mocks/version.rb

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

data/bundle/ruby/2.7.0/gems/rspec-mocks-3.12.1/lib/rspec/mocks.rb

@@ -0,0 +1,133 @@
+require 'rspec/support'
+RSpec::Support.require_rspec_support 'caller_filter'
+RSpec::Support.require_rspec_support 'warnings'
+RSpec::Support.require_rspec_support 'ruby_features'
+
+RSpec::Support.define_optimized_require_for_rspec(:mocks) { |f| require_relative f }
+
+%w[
+  instance_method_stasher
+  method_double
+  argument_matchers
+  example_methods
+  proxy
+  test_double
+  argument_list_matcher
+  message_expectation
+  order_group
+  error_generator
+  space
+  mutate_const
+  targets
+  syntax
+  configuration
+  verifying_double
+  version
+].each { |name| RSpec::Support.require_rspec_mocks name }
+
+# Share the top-level RSpec namespace, because we are a core supported
+# extension.
+module RSpec
+  # Contains top-level utility methods. While this contains a few
+  # public methods, these are not generally meant to be called from
+  # a test or example. They exist primarily for integration with
+  # test frameworks (such as rspec-core).
+  module Mocks
+    # Performs per-test/example setup. This should be called before
+    # an test or example begins.
+    def self.setup
+      @space_stack << (@space = space.new_scope)
+    end
+
+    # Verifies any message expectations that were set during the
+    # test or example. This should be called at the end of an example.
+    def self.verify
+      space.verify_all
+    end
+
+    # Cleans up all test double state (including any methods that were
+    # redefined on partial doubles). This _must_ be called after
+    # each example, even if an error was raised during the example.
+    def self.teardown
+      space.reset_all
+      @space_stack.pop
+      @space = @space_stack.last || @root_space
+    end
+
+    # Adds an allowance (stub) on `subject`
+    #
+    # @param subject the subject to which the message will be added
+    # @param message a symbol, representing the message that will be
+    #                added.
+    # @param opts a hash of options, :expected_from is used to set the
+    #             original call site
+    # @yield an optional implementation for the allowance
+    #
+    # @example Defines the implementation of `foo` on `bar`, using the passed block
+    #   x = 0
+    #   RSpec::Mocks.allow_message(bar, :foo) { x += 1 }
+    def self.allow_message(subject, message, opts={}, &block)
+      space.proxy_for(subject).add_stub(message, opts, &block)
+    end
+
+    # Sets a message expectation on `subject`.
+    # @param subject the subject on which the message will be expected
+    # @param message a symbol, representing the message that will be
+    #                expected.
+    # @param opts a hash of options, :expected_from is used to set the
+    #             original call site
+    # @yield an optional implementation for the expectation
+    #
+    # @example Expect the message `foo` to receive `bar`, then call it
+    #   RSpec::Mocks.expect_message(bar, :foo)
+    #   bar.foo
+    def self.expect_message(subject, message, opts={}, &block)
+      space.proxy_for(subject).add_message_expectation(message, opts, &block)
+    end
+
+    # Call the passed block and verify mocks after it has executed. This allows
+    # mock usage in arbitrary places, such as a `before(:all)` hook.
+    #
+    # @return [Object] the return value from the block
+    def self.with_temporary_scope
+      setup
+
+      begin
+        result = yield
+        verify
+        result
+      ensure
+        teardown
+      end
+    end
+
+    class << self
+      # @private
+      attr_reader :space
+    end
+    @space_stack = []
+    @root_space  = @space = RSpec::Mocks::RootSpace.new
+
+    # @private
+    IGNORED_BACKTRACE_LINE = 'this backtrace line is ignored'
+
+    # To speed up boot time a bit, delay loading optional or rarely
+    # used features until their first use.
+    autoload :AnyInstance,      "rspec/mocks/any_instance"
+    autoload :ExpectChain,      "rspec/mocks/message_chain"
+    autoload :StubChain,        "rspec/mocks/message_chain"
+    autoload :MarshalExtension, "rspec/mocks/marshal_extension"
+
+    # Namespace for mock-related matchers.
+    module Matchers
+      # @private
+      # just a "tag" for rspec-mock matchers detection
+      module Matcher; end
+
+      autoload :HaveReceived,        "rspec/mocks/matchers/have_received"
+      autoload :Receive,             "rspec/mocks/matchers/receive"
+      autoload :ReceiveMessageChain, "rspec/mocks/matchers/receive_message_chain"
+      autoload :ReceiveMessages,     "rspec/mocks/matchers/receive_messages"
+    end
+  end
+end