vagrant-unbundled 1.9.5.1 → 1.9.7.1

data/vendor/bundle/ruby/2.4.0/gems/rspec-mocks-2.14.6/features/support/rubinius.rb

@@ -1,6 +0,0 @@
-# Required until https://github.com/rubinius/rubinius/issues/2430 is resolved
-ENV['RBXOPT'] = "#{ENV["RBXOPT"]} -Xcompiler.no_rbc"
-
-Around "@unsupported-on-rbx" do |scenario, block|
-  block.call unless defined?(Rubinius)
-end

data/vendor/bundle/ruby/2.4.0/gems/rspec-mocks-2.14.6/features/test_frameworks/test_unit.feature

@@ -1,43 +0,0 @@
-Feature: Test::Unit integration
-
-  rspec-mocks is a stand-alone gem that can be used without the rest of
-  RSpec. If you like the way Test::Unit (or MiniTest) organizes tests, but
-  prefer RSpec's approach to mocking/stubbing/doubles etc, you can have both.
-
-  The one downside is that failures are reported as errors with MiniTest.
-
-  Scenario: use rspec/mocks with Test::Unit
-    Given a file named "rspec_mocks_test.rb" with:
-      """ruby
-      require 'test/unit'
-      require 'rspec/mocks'
-
-      class RSpecMocksTest < Test::Unit::TestCase
-        def setup
-          RSpec::Mocks.setup(Object)
-          RSpec::Mocks.setup(self)
-        end
-
-        def test_passing_expectation
-          obj = Object.new
-          expect(obj).to receive(:message)
-          obj.message
-        end
-
-        def test_failing_expectation
-          obj = Object.new
-          expect(obj).to_not receive(:message)
-          obj.message
-        end
-
-        def test_with_deprecation_warning
-          obj = Object.new
-          obj.stub(:old_message) { RSpec.deprecate(:old_message, :replacement => :message) }
-          obj.old_message
-        end
-      end
-      """
-     When I run `ruby rspec_mocks_test.rb`
-     Then the output should contain "3 tests, 0 assertions, 0 failures, 1 errors" or "3 tests, 0 assertions, 1 failures, 0 errors"
-     And the output should contain "expected: 0 times with any arguments"
-     And the output should contain "old_message is deprecated. Use message instead."

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

@@ -1,96 +0,0 @@
-require 'rspec/mocks/framework'
-require 'rspec/mocks/version'
-
-module RSpec
-
-  module Mocks
-    class << self
-      attr_accessor :space
-
-      def setup(host)
-        (class << host; self; end).class_eval do
-          include RSpec::Mocks::ExampleMethods
-        end
-        self.space ||= RSpec::Mocks::Space.new
-      end
-
-      def verify
-        space.verify_all
-      end
-
-      def teardown
-        space.reset_all
-      end
-
-      def proxy_for(object)
-        space.proxy_for(object)
-      end
-
-      def proxies_of(klass)
-        space.proxies_of(klass)
-      end
-
-      def any_instance_recorder_for(klass)
-        space.any_instance_recorder_for(klass)
-      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
-      # @param block 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 allow_message(subject, message, opts={}, &block)
-        orig_caller = opts.fetch(:expected_from) { caller(1)[0] }
-        ::RSpec::Mocks.proxy_for(subject).
-          add_stub(orig_caller, message.to_sym, 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
-      # @param block 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 expect_message(subject, message, opts={}, &block)
-        orig_caller = opts.fetch(:expected_from) { caller(1)[0] }
-        ::RSpec::Mocks.proxy_for(subject).
-          add_message_expectation(orig_caller, message.to_sym, opts, &block)
-      end
-
-      # @api private
-      KERNEL_METHOD_METHOD = ::Kernel.instance_method(:method)
-
-      # @api private
-      # Used internally to get a method handle for a particular object
-      # and method name.
-      #
-      # Includes handling for a few special cases:
-      #
-      #   - Objects that redefine #method (e.g. an HTTPRequest struct)
-      #   - BasicObject subclasses that mixin a Kernel dup (e.g. SimpleDelegator)
-      def method_handle_for(object, method_name)
-        if ::Kernel === object
-          KERNEL_METHOD_METHOD.bind(object).call(method_name)
-        else
-          object.method(method_name)
-        end
-      end
-    end
-
-    # @private
-    IGNORED_BACKTRACE_LINE = 'this backtrace line is ignored'
-  end
-end
-

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

@@ -1,94 +0,0 @@
-module RSpec
-  module Mocks
-    module AnyInstance
-      class Chain
-        def initialize(recorder, *args, &block)
-          @recorder          = recorder
-          @expectation_args  = args
-          @expectation_block = block
-        end
-
-        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)
-            class_eval(<<-EOM, __FILE__, __LINE__ + 1)
-              def #{method_name}(*args, &block)
-                record(:#{method_name}, *args, &block)
-              end
-            EOM
-          end
-
-          record :and_return
-          record :and_raise
-          record :and_throw
-          record :and_yield
-          record :and_call_original
-          record :with
-          record :once
-          record :twice
-          record :any_number_of_times
-          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 expectation_fulfilled!
-          @expectation_fulfilled = true
-        end
-
-        def never
-          ErrorGenerator.raise_double_negation_error("expect_any_instance_of(MyClass)") if negated?
-          super
-        end
-
-        private
-
-        def negated?
-          messages.any? { |(message, *_), _| message.to_sym == :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.4.0/gems/rspec-mocks-2.14.6/lib/rspec/mocks/any_instance/expectation_chain.rb

@@ -1,42 +0,0 @@
-module RSpec
-  module Mocks
-    module AnyInstance
-      # @api private
-      class ExpectationChain < Chain
-        def expectation_fulfilled?
-          @expectation_fulfilled || constrained_to_any_of?(:never, :any_number_of_times)
-        end
-
-        def initialize(*args, &block)
-          @expectation_fulfilled = false
-          super
-        end
-
-        private
-        def verify_invocation_order(rspec_method_name, *args, &block)
-        end
-      end
-
-      # @api private
-      class PositiveExpectationChain < ExpectationChain
-
-        private
-
-        def create_message_expectation_on(instance)
-          proxy = ::RSpec::Mocks.proxy_for(instance)
-          expected_from = IGNORED_BACKTRACE_LINE
-          proxy.add_message_expectation(expected_from, *@expectation_args, &@expectation_block)
-        end
-
-        def invocation_order
-          @invocation_order ||= {
-            :with => [nil],
-            :and_return => [:with, nil],
-            :and_raise => [:with, nil]
-          }
-        end
-      end
-    end
-  end
-end
-

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

@@ -1,60 +0,0 @@
-module RSpec
-  module Mocks
-    module AnyInstance
-      # @private
-      class MessageChains < Hash
-        def initialize
-          super {|h,k| h[k] = []}
-        end
-
-        # @private
-        def add(method_name, chain)
-          self[method_name] << chain
-          chain
-        end
-
-        # @private
-        def remove_stub_chains_for!(method_name)
-          self[method_name].reject! {|chain| chain.is_a?(StubChain)}
-        end
-
-        # @private
-        def has_expectation?(method_name)
-          self[method_name].find {|chain| chain.is_a?(ExpectationChain)}
-        end
-
-        # @private
-        def all_expectations_fulfilled?
-          all? {|method_name, chains| chains.all? {|chain| chain.expectation_fulfilled?}}
-        end
-
-        # @private
-        def unfulfilled_expectations
-          map do |method_name, chains|
-            method_name.to_s if chains.last.is_a?(ExpectationChain) unless chains.last.expectation_fulfilled?
-          end.compact
-        end
-
-        # @private
-        def received_expected_message!(method_name)
-          self[method_name].each {|chain| chain.expectation_fulfilled!}
-        end
-
-        # @private
-        def playback!(instance, method_name)
-          raise_if_second_instance_to_receive_message(instance)
-          self[method_name].each {|chain| chain.playback!(instance)}
-        end
-
-        private
-
-        def raise_if_second_instance_to_receive_message(instance)
-          @instance_with_expectation ||= instance if instance.is_a?(ExpectationChain)
-          if instance.is_a?(ExpectationChain) && !@instance_with_expectation.equal?(instance)
-            raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{unfulfilled_expectations.sort.join(', ')}"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,208 +0,0 @@
-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
-
-        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_or_method_map, &block)
-          if method_name_or_method_map.is_a?(Hash)
-            method_name_or_method_map.each do |method_name, return_value|
-              stub(method_name).and_return(return_value)
-            end
-          else
-            observe!(method_name_or_method_map)
-            message_chains.add(method_name_or_method_map, StubChain.new(self, method_name_or_method_map, &block))
-          end
-        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
-
-        # 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
-
-        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)
-            raise RSpec::Mocks::MockExpectationError, "The method `#{method_name}` was not stubbed or was already unstubbed"
-          end
-          message_chains.remove_stub_chains_for!(method_name)
-          ::RSpec::Mocks.proxies_of(@klass).each do |proxy|
-            stubs[method_name].each { |stub| proxy.remove_single_stub(method_name, stub) }
-          end
-          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
-          if @expectation_set && !message_chains.all_expectations_fulfilled?
-            raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{message_chains.unfulfilled_expectations.sort.join(', ')}"
-          end
-        end
-
-        # @private
-        def stub!(*)
-          raise "stub! is not supported on any_instance. Use stub instead."
-        end
-
-        # @private
-        def unstub!(*)
-          raise "unstub! is not supported on any_instance. Use unstub instead."
-        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
-
-        def build_alias_method_name(method_name)
-          "__#{method_name}_without_any_instance__"
-        end
-
-        def already_observing?(method_name)
-          @observed_methods.include?(method_name)
-        end
-
-        private
-
-        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)
-          alias_method_name = build_alias_method_name(method_name)
-          @klass.class_eval 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_eval do
-            remove_method method_name
-          end
-        end
-
-        def backup_method!(method_name)
-          alias_method_name = build_alias_method_name(method_name)
-          @klass.class_eval 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)
-          @klass.method_defined?(method_name) || @klass.private_method_defined?(method_name)
-        end
-
-        def stop_observing!(method_name)
-          restore_method!(method_name)
-          @observed_methods.delete(method_name)
-        end
-
-        def observe!(method_name)
-          stop_observing!(method_name) if already_observing?(method_name)
-          @observed_methods << method_name
-          backup_method!(method_name)
-          @klass.class_eval(<<-EOM, __FILE__, __LINE__ + 1)
-            def #{method_name}(*args, &blk)
-              klass = ::RSpec::Mocks.method_handle_for(self, :#{method_name}).owner
-              ::RSpec::Mocks.any_instance_recorder_for(klass).playback!(self, :#{method_name})
-              self.__send__(:#{method_name}, *args, &blk)
-            end
-          EOM
-        end
-
-        def mark_invoked!(method_name)
-          backup_method!(method_name)
-          @klass.class_eval(<<-EOM, __FILE__, __LINE__ + 1)
-            def #{method_name}(*args, &blk)
-              method_name = :#{method_name}
-              klass = ::RSpec::Mocks.method_handle_for(self, :#{method_name}).owner
-              invoked_instance = ::RSpec::Mocks.any_instance_recorder_for(klass).instance_that_received(method_name)
-              raise RSpec::Mocks::MockExpectationError, "The message '#{method_name}' was received by \#{self.inspect} but has already been received by \#{invoked_instance}"
-            end
-          EOM
-        end
-      end
-    end
-  end
-end