vagrant-unbundled 1.9.5.1 → 1.9.7.1

data/vendor/bundle/ruby/2.4.0/gems/rspec-mocks-2.14.6/lib/rspec/mocks/order_group.rb

@@ -1,40 +0,0 @@
-module RSpec
-  module Mocks
-    # @private
-    class OrderGroup
-      def initialize
-        @ordering = Array.new
-      end
-
-      # @private
-      def register(expectation)
-        @ordering << expectation
-      end
-
-      # @private
-      def ready_for?(expectation)
-        @ordering.first == expectation
-      end
-
-      # @private
-      def consume
-        @ordering.shift
-      end
-
-      # @private
-      def handle_order_constraint(expectation)
-        return unless @ordering.include?(expectation)
-        return consume if ready_for?(expectation)
-        expectation.raise_out_of_order_error
-      end
-
-      def clear
-        @ordering.clear
-      end
-
-      def empty?
-        @ordering.empty?
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/rspec-mocks-2.14.6/lib/rspec/mocks/proxy.rb

@@ -1,223 +0,0 @@
-module RSpec
-  module Mocks
-    # @private
-    class Proxy
-
-      # @private
-      def initialize(object, name=nil, options={})
-        @object = object
-        @name = name
-        @error_generator = ErrorGenerator.new object, name, options
-        @expectation_ordering = RSpec::Mocks::space.expectation_ordering
-        @messages_received = []
-        @options = options
-        @already_proxied_respond_to = false
-        @null_object = false
-      end
-
-      # @private
-      attr_reader :object
-
-      # @private
-      def null_object?
-        @null_object
-      end
-
-      # @private
-      # Tells the object to ignore any messages that aren't explicitly set as
-      # stubs or message expectations.
-      def as_null_object
-        @null_object = true
-        @object
-      end
-
-      # @private
-      def already_proxied_respond_to
-        @already_proxied_respond_to = true
-      end
-
-      # @private
-      def already_proxied_respond_to?
-        @already_proxied_respond_to
-      end
-
-      # @private
-      def add_message_expectation(location, method_name, opts={}, &block)
-        meth_double = method_double[method_name]
-
-        if null_object? && !block
-          meth_double.add_default_stub(@error_generator, @expectation_ordering, location, opts) do
-            @object
-          end
-        end
-
-        meth_double.add_expectation @error_generator, @expectation_ordering, location, opts, &block
-      end
-
-      # @private
-      def build_expectation(method_name)
-        meth_double = method_double[method_name]
-
-        meth_double.build_expectation(
-          @error_generator,
-          @expectation_ordering
-        )
-      end
-
-      # @private
-      def replay_received_message_on(expectation)
-        expected_method_name = expectation.message
-        meth_double = method_double[expected_method_name]
-
-        if meth_double.expectations.any?
-          @error_generator.raise_expectation_on_mocked_method(expected_method_name)
-        end
-
-        unless null_object? || meth_double.stubs.any?
-          @error_generator.raise_expectation_on_unstubbed_method(expected_method_name)
-        end
-
-        @messages_received.each do |(actual_method_name, args, _)|
-          if expectation.matches?(actual_method_name, *args)
-            expectation.invoke(nil)
-          end
-        end
-      end
-
-      # @private
-      def check_for_unexpected_arguments(expectation)
-        @messages_received.each do |(method_name, args, _)|
-          if expectation.matches_name_but_not_args(method_name, *args)
-            raise_unexpected_message_args_error(expectation, *args)
-          end
-        end
-      end
-
-      # @private
-      def add_stub(location, method_name, opts={}, &implementation)
-        method_double[method_name].add_stub @error_generator, @expectation_ordering, location, opts, &implementation
-      end
-
-      # @private
-      def remove_stub(method_name)
-        method_double[method_name].remove_stub
-      end
-
-      def remove_single_stub(method_name, stub)
-        method_double[method_name].remove_single_stub(stub)
-      end
-
-      # @private
-      def verify
-        method_doubles.each {|d| d.verify}
-      ensure
-        reset
-      end
-
-      # @private
-      def reset
-        method_doubles.each {|d| d.reset}
-        @messages_received.clear
-      end
-
-      # @private
-      def received_message?(method_name, *args, &block)
-        @messages_received.any? {|array| array == [method_name, args, block]}
-      end
-
-      # @private
-      def has_negative_expectation?(message)
-        method_double[message].expectations.detect {|expectation| expectation.negative_expectation_for?(message)}
-      end
-
-      # @private
-      def record_message_received(message, *args, &block)
-        @messages_received << [message, args, block]
-      end
-
-      # @private
-      def message_received(message, *args, &block)
-        record_message_received message, *args, &block
-        expectation = find_matching_expectation(message, *args)
-        stub = find_matching_method_stub(message, *args)
-
-        if (stub && expectation && expectation.called_max_times?) || (stub && !expectation)
-          expectation.increase_actual_received_count! if expectation && expectation.actual_received_count_matters?
-          if expectation = find_almost_matching_expectation(message, *args)
-            expectation.advise(*args) unless expectation.expected_messages_received?
-          end
-          stub.invoke(nil, *args, &block)
-        elsif expectation
-          expectation.invoke(stub, *args, &block)
-        elsif expectation = find_almost_matching_expectation(message, *args)
-          expectation.advise(*args) if null_object? unless expectation.expected_messages_received?
-          raise_unexpected_message_args_error(expectation, *args) unless (has_negative_expectation?(message) or null_object?)
-        elsif stub = find_almost_matching_stub(message, *args)
-          stub.advise(*args)
-          raise_missing_default_stub_error(stub, *args)
-        elsif @object.is_a?(Class)
-          @object.superclass.__send__(message, *args, &block)
-        else
-          @object.__send__(:method_missing, message, *args, &block)
-        end
-      end
-
-      # @private
-      def raise_unexpected_message_error(method_name, *args)
-        @error_generator.raise_unexpected_message_error method_name, *args
-      end
-
-      # @private
-      def raise_unexpected_message_args_error(expectation, *args)
-        @error_generator.raise_unexpected_message_args_error(expectation, *args)
-      end
-
-      # @private
-      def raise_missing_default_stub_error(expectation, *args)
-        @error_generator.raise_missing_default_stub_error(expectation, *args)
-      end
-
-      private
-
-      def method_double
-        @method_double ||= Hash.new {|h,k| h[k] = MethodDouble.new(@object, k, self) }
-      end
-
-      def method_doubles
-        method_double.values
-      end
-
-      def find_matching_expectation(method_name, *args)
-        find_best_matching_expectation_for(method_name) do |expectation|
-          expectation.matches?(method_name, *args)
-        end
-      end
-
-      def find_almost_matching_expectation(method_name, *args)
-        find_best_matching_expectation_for(method_name) do |expectation|
-          expectation.matches_name_but_not_args(method_name, *args)
-        end
-      end
-
-      def find_best_matching_expectation_for(method_name)
-        first_match = nil
-
-        method_double[method_name].expectations.each do |expectation|
-          next unless yield expectation
-          return expectation unless expectation.called_max_times?
-          first_match ||= expectation
-        end
-
-        first_match
-      end
-
-      def find_matching_method_stub(method_name, *args)
-        method_double[method_name].stubs.find {|stub| stub.matches?(method_name, *args)}
-      end
-
-      def find_almost_matching_stub(method_name, *args)
-        method_double[method_name].stubs.find {|stub| stub.matches_name_but_not_args(method_name, *args)}
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/rspec-mocks-2.14.6/lib/rspec/mocks/proxy_for_nil.rb

@@ -1,37 +0,0 @@
-module RSpec
-  module Mocks
-    # @private
-    class ProxyForNil < Proxy
-
-      def initialize
-        @warn_about_expectations = true
-        super nil
-      end
-      attr_accessor :warn_about_expectations
-      alias warn_about_expectations? warn_about_expectations
-
-      def add_message_expectation(location, method_name, opts={}, &block)
-        warn(method_name) if warn_about_expectations?
-        super
-      end
-
-      def add_negative_message_expectation(location, method_name, &implementation)
-        warn(method_name) if warn_about_expectations?
-        super
-      end
-
-      def add_stub(location, method_name, opts={}, &implementation)
-        warn(method_name) if warn_about_expectations?
-        super
-      end
-
-      private
-
-      def warn method_name
-        non_rspec_caller = caller.find { |line| !line.include?('lib/rspec/mocks') }
-        Kernel.warn("An expectation of :#{method_name} was set on nil. Called from #{non_rspec_caller}. Use allow_message_expectations_on_nil to disable warnings.")
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/rspec-mocks-2.14.6/lib/rspec/mocks/space.rb

@@ -1,92 +0,0 @@
-module RSpec
-  module Mocks
-    # @api private
-    class Space
-      attr_reader :proxies, :any_instance_recorders
-
-      def initialize
-        @proxies                 = {}
-        @any_instance_recorders  = {}
-      end
-
-      def verify_all
-        proxies.each_value do |object|
-          object.verify
-        end
-
-        any_instance_recorders.each_value do |recorder|
-          recorder.verify
-        end
-      end
-
-      def reset_all
-        ConstantMutator.reset_all
-
-        proxies.each_value do |object|
-          object.reset
-        end
-
-        proxies.clear
-
-        any_instance_recorders.each_value do |recorder|
-          recorder.stop_all_observation!
-        end
-
-        any_instance_recorders.clear
-        expectation_ordering.clear
-      end
-
-      def expectation_ordering
-        @expectation_ordering ||= OrderGroup.new
-      end
-
-      def any_instance_recorder_for(klass)
-        id = klass.__id__
-        any_instance_recorders.fetch(id) do
-          any_instance_recorders[id] = AnyInstance::Recorder.new(klass)
-        end
-      end
-
-      def proxies_of(klass)
-        proxies.values.select { |proxy| klass === proxy.object }
-      end
-
-      def proxy_for(object)
-        id = id_for(object)
-        proxies.fetch(id) do
-          proxies[id] = case object
-                        when NilClass   then ProxyForNil.new
-                        when TestDouble then object.__build_mock_proxy
-                        else
-                          Proxy.new(object)
-                        end
-        end
-      end
-
-      alias ensure_registered proxy_for
-
-      def registered?(object)
-        proxies.has_key?(id_for object)
-      end
-
-      if defined?(::BasicObject) && !::BasicObject.method_defined?(:__id__) # for 1.9.2
-        require 'securerandom'
-
-        def id_for(object)
-          id = object.__id__
-
-          return id if object.equal?(::ObjectSpace._id2ref(id))
-          # this suggests that object.__id__ is proxying through to some wrapped object
-
-          object.instance_eval do
-            @__id_for_rspec_mocks_space ||= ::SecureRandom.uuid
-          end
-        end
-      else
-        def id_for(object)
-          object.__id__
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.4.0/gems/rspec-mocks-2.14.6/lib/rspec/mocks/standalone.rb

@@ -1,3 +0,0 @@
-require 'rspec/mocks'
-
-RSpec::Mocks.setup(self)

data/vendor/bundle/ruby/2.4.0/gems/rspec-mocks-2.14.6/lib/rspec/mocks/stub_chain.rb

@@ -1,51 +0,0 @@
-module RSpec
-  module Mocks
-    # @private
-    class StubChain
-      def self.stub_chain_on(object, *chain, &blk)
-        new(object, *chain, &blk).stub_chain
-      end
-
-      attr_reader :object, :chain, :block
-
-      def initialize(object, *chain, &blk)
-        @object = object
-        @chain, @block = format_chain(*chain, &blk)
-      end
-
-      def stub_chain
-        if chain.length > 1
-          if matching_stub = find_matching_stub
-            chain.shift
-            matching_stub.invoke(nil).stub_chain(*chain, &block)
-          else
-            next_in_chain = Mock.new
-            object.stub(chain.shift) { next_in_chain }
-            StubChain.stub_chain_on(next_in_chain, *chain, &block)
-          end
-        else
-          object.stub(chain.shift, &block)
-        end
-      end
-
-    private
-
-      def format_chain(*chain, &blk)
-        if Hash === chain.last
-          hash = chain.pop
-          hash.each do |k,v|
-            chain << k
-            blk = lambda { v }
-          end
-        end
-        return chain.join('.').split('.'), blk
-      end
-
-      def find_matching_stub
-        ::RSpec::Mocks.proxy_for(object).
-          __send__(:find_matching_method_stub, chain.first.to_sym)
-      end
-    end
-  end
-end
-