scoot 0.0.4

data/.bundle/gems/ruby/2.2.0/gems/rspec-mocks-3.3.2/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

data/.bundle/gems/ruby/2.2.0/gems/rspec-mocks-3.3.2/lib/rspec/mocks/any_instance/proxy.rb

@@ -0,0 +1,116 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @private
+      # The `AnyInstance::Recorder` is responsible for redefining the klass's
+      # instance method in order to add any stubs/expectations the first time
+      # the method is called. It's not capable of updating a stub on an instance
+      # that's already been previously stubbed (either directly, or via
+      # `any_instance`).
+      #
+      # This proxy sits in front of the recorder and delegates both to it
+      # and to the `RSpec::Mocks::Proxy` for each already mocked or stubbed
+      # instance of the class, in order to propogates changes to the instances.
+      #
+      # Note that unlike `RSpec::Mocks::Proxy`, this proxy class is stateless
+      # and is not persisted in `RSpec::Mocks.space`.
+      #
+      # Proxying for the message expectation fluent interface (typically chained
+      # off of the return value of one of these methods) is provided by the
+      # `FluentInterfaceProxy` class below.
+      class Proxy
+        def initialize(recorder, target_proxies)
+          @recorder       = recorder
+          @target_proxies = target_proxies
+        end
+
+        def klass
+          @recorder.klass
+        end
+
+        def stub(method_name_or_method_map, &block)
+          if Hash === method_name_or_method_map
+            method_name_or_method_map.each do |method_name, return_value|
+              stub(method_name).and_return(return_value)
+            end
+          else
+            perform_proxying(__method__, [method_name_or_method_map], block) do |proxy|
+              proxy.add_stub(method_name_or_method_map, &block)
+            end
+          end
+        end
+
+        def unstub(method_name)
+          perform_proxying(__method__, [method_name], nil) do |proxy|
+            proxy.remove_stub_if_present(method_name)
+          end
+        end
+
+        def stub_chain(*chain, &block)
+          perform_proxying(__method__, chain, block) do |proxy|
+            Mocks::StubChain.stub_chain_on(proxy.object, *chain, &block)
+          end
+        end
+
+        def expect_chain(*chain, &block)
+          perform_proxying(__method__, chain, block) do |proxy|
+            Mocks::ExpectChain.expect_chain_on(proxy.object, *chain, &block)
+          end
+        end
+
+        def should_receive(method_name, &block)
+          perform_proxying(__method__, [method_name], block) do |proxy|
+            # Yeah, this is a bit odd...but if we used `add_message_expectation`
+            # then it would act like `expect_every_instance_of(klass).to receive`.
+            # The any_instance recorder takes care of validating that an instance
+            # received the message.
+            proxy.add_stub(method_name, &block)
+          end
+        end
+
+        def should_not_receive(method_name, &block)
+          perform_proxying(__method__, [method_name], block) do |proxy|
+            proxy.add_message_expectation(method_name, &block).never
+          end
+        end
+
+      private
+
+        def perform_proxying(method_name, args, block, &target_proxy_block)
+          recorder_value = @recorder.__send__(method_name, *args, &block)
+          proxy_values   = @target_proxies.map(&target_proxy_block)
+          FluentInterfaceProxy.new([recorder_value] + proxy_values)
+        end
+      end
+
+      # @private
+      # Delegates messages to each of the given targets in order to
+      # provide the fluent interface that is available off of message
+      # expectations when dealing with `any_instance`.
+      #
+      # `targets` will typically contain 1 of the `AnyInstance::Recorder`
+      # return values and N `MessageExpectation` instances (one per instance
+      # of the `any_instance` klass).
+      class FluentInterfaceProxy
+        def initialize(targets)
+          @targets = targets
+        end
+
+        if RUBY_VERSION.to_f > 1.8
+          def respond_to_missing?(method_name, include_private=false)
+            super || @targets.first.respond_to?(method_name, include_private)
+          end
+        else
+          def respond_to?(method_name, include_private=false)
+            super || @targets.first.respond_to?(method_name, include_private)
+          end
+        end
+
+        def method_missing(*args, &block)
+          return_values = @targets.map { |t| t.__send__(*args, &block) }
+          FluentInterfaceProxy.new(return_values)
+        end
+      end
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/rspec-mocks-3.3.2/lib/rspec/mocks/any_instance/recorder.rb

@@ -0,0 +1,264 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # Given a class `TheClass`, `TheClass.any_instance` returns a `Recorder`,
+      # which records stubs and message expectations for later playback on
+      # instances of `TheClass`.
+      #
+      # Further constraints are stored in instances of [Chain](Chain).
+      #
+      # @see AnyInstance
+      # @see Chain
+      class Recorder
+        # @private
+        attr_reader :message_chains, :stubs, :klass
+
+        def initialize(klass)
+          @message_chains = MessageChains.new
+          @stubs = Hash.new { |hash, key| hash[key] = [] }
+          @observed_methods = []
+          @played_methods = {}
+          @klass = klass
+          @expectation_set = false
+        end
+
+        # Initializes the recording a stub to be played back against any
+        # instance of this object that invokes the submitted method.
+        #
+        # @see Methods#stub
+        def stub(method_name, &block)
+          observe!(method_name)
+          message_chains.add(method_name, StubChain.new(self, method_name, &block))
+        end
+
+        # Initializes the recording a stub chain to be played back against any
+        # instance of this object that invokes the method matching the first
+        # argument.
+        #
+        # @see Methods#stub_chain
+        def stub_chain(*method_names_and_optional_return_values, &block)
+          normalize_chain(*method_names_and_optional_return_values) do |method_name, args|
+            observe!(method_name)
+            message_chains.add(method_name, StubChainChain.new(self, *args, &block))
+          end
+        end
+
+        # @private
+        def expect_chain(*method_names_and_optional_return_values, &block)
+          @expectation_set = true
+          normalize_chain(*method_names_and_optional_return_values) do |method_name, args|
+            observe!(method_name)
+            message_chains.add(method_name, ExpectChainChain.new(self, *args, &block))
+          end
+        end
+
+        # Initializes the recording a message expectation to be played back
+        # against any instance of this object that invokes the submitted
+        # method.
+        #
+        # @see Methods#should_receive
+        def should_receive(method_name, &block)
+          @expectation_set = true
+          observe!(method_name)
+          message_chains.add(method_name, PositiveExpectationChain.new(self, method_name, &block))
+        end
+
+        # The opposite of `should_receive`
+        #
+        # @see Methods#should_not_receive
+        def should_not_receive(method_name, &block)
+          should_receive(method_name, &block).never
+        end
+
+        # Removes any previously recorded stubs, stub_chains or message
+        # expectations that use `method_name`.
+        #
+        # @see Methods#unstub
+        def unstub(method_name)
+          unless @observed_methods.include?(method_name.to_sym)
+            AnyInstance.error_generator.raise_method_not_stubbed_error(method_name)
+          end
+          message_chains.remove_stub_chains_for!(method_name)
+          stubs[method_name].clear
+          stop_observing!(method_name) unless message_chains.has_expectation?(method_name)
+        end
+
+        # @api private
+        #
+        # Used internally to verify that message expectations have been
+        # fulfilled.
+        def verify
+          return unless @expectation_set
+          return if message_chains.all_expectations_fulfilled?
+
+          AnyInstance.error_generator.raise_second_instance_received_message_error(message_chains.unfulfilled_expectations)
+        end
+
+        # @private
+        def stop_all_observation!
+          @observed_methods.each { |method_name| restore_method!(method_name) }
+        end
+
+        # @private
+        def playback!(instance, method_name)
+          RSpec::Mocks.space.ensure_registered(instance)
+          message_chains.playback!(instance, method_name)
+          @played_methods[method_name] = instance
+          received_expected_message!(method_name) if message_chains.has_expectation?(method_name)
+        end
+
+        # @private
+        def instance_that_received(method_name)
+          @played_methods[method_name]
+        end
+
+        # @private
+        def build_alias_method_name(method_name)
+          "__#{method_name}_without_any_instance__"
+        end
+
+        # @private
+        def already_observing?(method_name)
+          @observed_methods.include?(method_name) || super_class_observing?(method_name)
+        end
+
+        # @private
+        def notify_received_message(_object, message, args, _blk)
+          has_expectation = false
+
+          message_chains.each_unfulfilled_expectation_matching(message, *args) do |expectation|
+            has_expectation = true
+            expectation.expectation_fulfilled!
+          end
+
+          return unless has_expectation
+
+          restore_method!(message)
+          mark_invoked!(message)
+        end
+
+      protected
+
+        def stop_observing!(method_name)
+          restore_method!(method_name)
+          @observed_methods.delete(method_name)
+          super_class_observers_for(method_name).each do |ancestor|
+            ::RSpec::Mocks.space.
+              any_instance_recorder_for(ancestor).stop_observing!(method_name)
+          end
+        end
+
+      private
+
+        def ancestor_is_an_observer?(method_name)
+          lambda do |ancestor|
+            unless ancestor == @klass
+              ::RSpec::Mocks.space.
+                any_instance_recorder_for(ancestor).already_observing?(method_name)
+            end
+          end
+        end
+
+        def super_class_observers_for(method_name)
+          @klass.ancestors.select(&ancestor_is_an_observer?(method_name))
+        end
+
+        def super_class_observing?(method_name)
+          @klass.ancestors.any?(&ancestor_is_an_observer?(method_name))
+        end
+
+        def normalize_chain(*args)
+          args.shift.to_s.split('.').map { |s| s.to_sym }.reverse.each { |a| args.unshift a }
+          yield args.first, args
+        end
+
+        def received_expected_message!(method_name)
+          message_chains.received_expected_message!(method_name)
+          restore_method!(method_name)
+          mark_invoked!(method_name)
+        end
+
+        def restore_method!(method_name)
+          if public_protected_or_private_method_defined?(build_alias_method_name(method_name))
+            restore_original_method!(method_name)
+          else
+            remove_dummy_method!(method_name)
+          end
+        end
+
+        def restore_original_method!(method_name)
+          return unless @klass.instance_method(method_name).owner == @klass
+
+          alias_method_name = build_alias_method_name(method_name)
+          @klass.class_exec do
+            remove_method method_name
+            alias_method method_name, alias_method_name
+            remove_method alias_method_name
+          end
+        end
+
+        def remove_dummy_method!(method_name)
+          @klass.class_exec do
+            remove_method method_name
+          end
+        end
+
+        def backup_method!(method_name)
+          alias_method_name = build_alias_method_name(method_name)
+          @klass.class_exec do
+            alias_method alias_method_name, method_name
+          end if public_protected_or_private_method_defined?(method_name)
+        end
+
+        def public_protected_or_private_method_defined?(method_name)
+          MethodReference.method_defined_at_any_visibility?(@klass, method_name)
+        end
+
+        def observe!(method_name)
+          allow_no_prepended_module_definition_of(method_name)
+
+          if RSpec::Mocks.configuration.verify_partial_doubles?
+            unless public_protected_or_private_method_defined?(method_name)
+              AnyInstance.error_generator.raise_does_not_implement_error(@klass, method_name)
+            end
+          end
+
+          stop_observing!(method_name) if already_observing?(method_name)
+          @observed_methods << method_name
+          backup_method!(method_name)
+          recorder = self
+          @klass.__send__(:define_method, method_name) do |*args, &blk|
+            recorder.playback!(self, method_name)
+            __send__(method_name, *args, &blk)
+          end
+        end
+
+        def mark_invoked!(method_name)
+          backup_method!(method_name)
+          recorder = self
+          @klass.__send__(:define_method, method_name) do |*_args, &_blk|
+            invoked_instance = recorder.instance_that_received(method_name)
+            inspect = "#<#{self.class}:#{object_id} #{instance_variables.map { |name| "#{name}=#{instance_variable_get name}" }.join(', ')}>"
+            AnyInstance.error_generator.raise_message_already_received_by_other_instance_error(
+              method_name, inspect, invoked_instance
+            )
+          end
+        end
+
+        if Support::RubyFeatures.module_prepends_supported?
+          def allow_no_prepended_module_definition_of(method_name)
+            prepended_modules = RSpec::Mocks::Proxy.prepended_modules_of(@klass)
+            problem_mod = prepended_modules.find { |mod| mod.method_defined?(method_name) }
+            return unless problem_mod
+
+            AnyInstance.error_generator.raise_not_supported_with_prepend_error(method_name, problem_mod)
+          end
+        else
+          def allow_no_prepended_module_definition_of(_method_name)
+            # nothing to do; prepends aren't supported on this version of ruby
+          end
+        end
+      end
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/rspec-mocks-3.3.2/lib/rspec/mocks/any_instance/stub_chain.rb

@@ -0,0 +1,46 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @private
+      class StubChain < Chain
+        # @private
+        def expectation_fulfilled?
+          true
+        end
+
+      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)
+
+          stub = proxy.add_stub(method_name, opts, &@expectation_block)
+          @recorder.stubs[stub.message] << stub
+
+          if RSpec::Mocks.configuration.yield_receiver_to_any_instance_implementation_blocks?
+            stub.and_yield_receiver_to_implementation
+          end
+
+          stub
+        end
+
+        def invocation_order
+          @invocation_order ||= {
+            :with => [nil],
+            :and_return => [:with, nil],
+            :and_raise => [:with, nil],
+            :and_yield => [:with, nil],
+            :and_call_original => [:with, nil],
+            :and_wrap_original => [:with, nil]
+          }
+        end
+
+        def verify_invocation_order(rspec_method_name, *_args, &_block)
+          return if invocation_order[rspec_method_name].include?(last_message)
+          raise NoMethodError, "Undefined method #{rspec_method_name}"
+        end
+      end
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/rspec-mocks-3.3.2/lib/rspec/mocks/any_instance/stub_chain_chain.rb

@@ -0,0 +1,27 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @private
+      class StubChainChain < StubChain
+        def initialize(*args)
+          super
+          @expectation_fulfilled = false
+        end
+
+      private
+
+        def create_message_expectation_on(instance)
+          ::RSpec::Mocks::StubChain.stub_chain_on(instance, *@expectation_args, &@expectation_block)
+        end
+
+        def invocation_order
+          @invocation_order ||= {
+            :and_return => [nil],
+            :and_raise => [nil],
+            :and_yield => [nil]
+          }
+        end
+      end
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/rspec-mocks-3.3.2/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/.bundle/gems/ruby/2.2.0/gems/rspec-mocks-3.3.2/lib/rspec/mocks/argument_list_matcher.rb

@@ -0,0 +1,100 @@
+# 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
+
+      # @api public
+      # @param [Array] 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?(*args)
+        Support::FuzzyMatcher.values_match?(resolve_expected_args_based_on(args), args)
+      end
+
+      # @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