hatena_bookmark_client_for_ruby 0.1.0

data/vendor/bundle/ruby/2.6.0/gems/rspec-mocks-3.8.0/lib/rspec/mocks.rb

@@ -0,0 +1,130 @@
+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.
+    def self.with_temporary_scope
+      setup
+
+      begin
+        yield
+        verify
+      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

data/vendor/bundle/ruby/2.6.0/gems/rspec-mocks-3.8.0/lib/rspec/mocks/any_instance.rb

@@ -0,0 +1,11 @@
+%w[
+  any_instance/chain
+  any_instance/error_generator
+  any_instance/stub_chain
+  any_instance/stub_chain_chain
+  any_instance/expect_chain_chain
+  any_instance/expectation_chain
+  any_instance/message_chains
+  any_instance/recorder
+  any_instance/proxy
+].each { |f| RSpec::Support.require_rspec_mocks(f) }

data/vendor/bundle/ruby/2.6.0/gems/rspec-mocks-3.8.0/lib/rspec/mocks/any_instance/chain.rb

@@ -0,0 +1,110 @@
+module RSpec
+  module Mocks
+    # @private
+    module AnyInstance
+      # @private
+      class Chain
+        def initialize(recorder, *args, &block)
+          @recorder          = recorder
+          @expectation_args  = args
+          @expectation_block = block
+          @argument_list_matcher = ArgumentListMatcher::MATCH_ALL
+        end
+
+        # @private
+        #
+        # Provides convenience methods for recording customizations on message
+        # expectations.
+        module Customizations
+          # @macro [attach] record
+          #   @method $1(*args, &block)
+          #   Records the `$1` message for playback against an instance that
+          #   invokes a method stubbed or mocked using `any_instance`.
+          #
+          #   @see RSpec::Mocks::MessageExpectation#$1
+          #
+          def self.record(method_name)
+            define_method(method_name) do |*args, &block|
+              record(method_name, *args, &block)
+            end
+          end
+
+          record :and_return
+          record :and_raise
+          record :and_throw
+          record :and_yield
+          record :and_call_original
+          record :and_wrap_original
+          record :with
+          record :once
+          record :twice
+          record :thrice
+          record :exactly
+          record :times
+          record :never
+          record :at_least
+          record :at_most
+        end
+
+        include Customizations
+
+        # @private
+        def playback!(instance)
+          message_expectation = create_message_expectation_on(instance)
+          messages.inject(message_expectation) do |object, message|
+            object.__send__(*message.first, &message.last)
+          end
+        end
+
+        # @private
+        def constrained_to_any_of?(*constraints)
+          constraints.any? do |constraint|
+            messages.any? do |message|
+              message.first.first == constraint
+            end
+          end
+        end
+
+        # @private
+        def matches_args?(*args)
+          @argument_list_matcher.args_match?(*args)
+        end
+
+        # @private
+        def expectation_fulfilled!
+          @expectation_fulfilled = true
+        end
+
+        def never
+          AnyInstance.error_generator.raise_double_negation_error("expect_any_instance_of(MyClass)") if negated?
+          super
+        end
+
+        def with(*args, &block)
+          @argument_list_matcher = ArgumentListMatcher.new(*args)
+          super
+        end
+
+      private
+
+        def negated?
+          messages.any? { |(message, *_), _| message == :never }
+        end
+
+        def messages
+          @messages ||= []
+        end
+
+        def last_message
+          messages.last.first.first unless messages.empty?
+        end
+
+        def record(rspec_method_name, *args, &block)
+          verify_invocation_order(rspec_method_name, *args, &block)
+          messages << [args.unshift(rspec_method_name), block]
+          self
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-mocks-3.8.0/lib/rspec/mocks/any_instance/error_generator.rb

@@ -0,0 +1,31 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @private
+      class ErrorGenerator < ::RSpec::Mocks::ErrorGenerator
+        def raise_second_instance_received_message_error(unfulfilled_expectations)
+          __raise "Exactly one instance should have received the following " \
+                  "message(s) but didn't: #{unfulfilled_expectations.sort.join(', ')}"
+        end
+
+        def raise_does_not_implement_error(klass, method_name)
+          __raise "#{klass} does not implement ##{method_name}"
+        end
+
+        def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance)
+          __raise "The message '#{method_name}' was received by #{object_inspect} " \
+                  "but has already been received by #{invoked_instance}"
+        end
+
+        def raise_not_supported_with_prepend_error(method_name, problem_mod)
+          __raise "Using `any_instance` to stub a method (#{method_name}) that has been " \
+                  "defined on a prepended module (#{problem_mod}) is not supported."
+        end
+      end
+
+      def self.error_generator
+        @error_generator ||= ErrorGenerator.new
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-mocks-3.8.0/lib/rspec/mocks/any_instance/expect_chain_chain.rb

@@ -0,0 +1,31 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @private
+      class ExpectChainChain < StubChain
+        def initialize(*args)
+          super
+          @expectation_fulfilled = false
+        end
+
+        def expectation_fulfilled?
+          @expectation_fulfilled
+        end
+
+        def playback!(instance)
+          super.tap { @expectation_fulfilled = true }
+        end
+
+      private
+
+        def create_message_expectation_on(instance)
+          ::RSpec::Mocks::ExpectChain.expect_chain_on(instance, *@expectation_args, &@expectation_block)
+        end
+
+        def invocation_order
+          EmptyInvocationOrder
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-mocks-3.8.0/lib/rspec/mocks/any_instance/expectation_chain.rb

@@ -0,0 +1,50 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @private
+      class ExpectationChain < Chain
+        def expectation_fulfilled?
+          @expectation_fulfilled || constrained_to_any_of?(:never)
+        end
+
+        def initialize(*args, &block)
+          @expectation_fulfilled = false
+          super
+        end
+
+      private
+
+        def verify_invocation_order(_rspec_method_name, *_args, &_block)
+        end
+      end
+
+      # @private
+      class PositiveExpectationChain < ExpectationChain
+      private
+
+        def create_message_expectation_on(instance)
+          proxy = ::RSpec::Mocks.space.proxy_for(instance)
+          method_name, opts = @expectation_args
+          opts = (opts || {}).merge(:expected_form => IGNORED_BACKTRACE_LINE)
+
+          me = proxy.add_message_expectation(method_name, opts, &@expectation_block)
+          if RSpec::Mocks.configuration.yield_receiver_to_any_instance_implementation_blocks?
+            me.and_yield_receiver_to_implementation
+          end
+
+          me
+        end
+
+        ExpectationInvocationOrder =
+          {
+            :and_return => [:with, nil],
+            :and_raise => [:with, nil],
+          }.freeze
+
+        def invocation_order
+          ExpectationInvocationOrder
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-mocks-3.8.0/lib/rspec/mocks/any_instance/message_chains.rb

@@ -0,0 +1,83 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @private
+      class MessageChains
+        def initialize
+          @chains_by_method_name = Hash.new { |h, k| h[k] = [] }
+        end
+
+        # @private
+        def [](method_name)
+          @chains_by_method_name[method_name]
+        end
+
+        # @private
+        def add(method_name, chain)
+          @chains_by_method_name[method_name] << chain
+          chain
+        end
+
+        # @private
+        def remove_stub_chains_for!(method_name)
+          @chains_by_method_name[method_name].reject! do |chain|
+            StubChain === chain
+          end
+        end
+
+        # @private
+        def has_expectation?(method_name)
+          @chains_by_method_name[method_name].find do |chain|
+            ExpectationChain === chain
+          end
+        end
+
+        # @private
+        def each_unfulfilled_expectation_matching(method_name, *args)
+          @chains_by_method_name[method_name].each do |chain|
+            yield chain if !chain.expectation_fulfilled? && chain.matches_args?(*args)
+          end
+        end
+
+        # @private
+        def all_expectations_fulfilled?
+          @chains_by_method_name.all? do |_method_name, chains|
+            chains.all? { |chain| chain.expectation_fulfilled? }
+          end
+        end
+
+        # @private
+        def unfulfilled_expectations
+          @chains_by_method_name.map do |method_name, chains|
+            method_name.to_s if ExpectationChain === chains.last unless chains.last.expectation_fulfilled?
+          end.compact
+        end
+
+        # @private
+        def received_expected_message!(method_name)
+          @chains_by_method_name[method_name].each do |chain|
+            chain.expectation_fulfilled!
+          end
+        end
+
+        # @private
+        def playback!(instance, method_name)
+          raise_if_second_instance_to_receive_message(instance)
+          @chains_by_method_name[method_name].each do |chain|
+            chain.playback!(instance)
+          end
+        end
+
+      private
+
+        def raise_if_second_instance_to_receive_message(instance)
+          @instance_with_expectation ||= instance if ExpectationChain === instance
+          return unless ExpectationChain === instance
+          return if @instance_with_expectation.equal?(instance)
+
+          AnyInstance.error_generator.raise_second_instance_received_message_error(unfulfilled_expectations)
+        end
+      end
+    end
+  end
+end