opal-rspec 0.4.3 → 0.5.0.beta1

data/vendor_lib/rspec/mocks/syntax.rb

@@ -1,374 +0,0 @@
-module RSpec
-  module Mocks
-    # @api private
-    # Provides methods for enabling and disabling the available syntaxes
-    # provided by rspec-mocks.
-    module Syntax
-      # @api private
-      def self.warn_about_should!
-        @warn_about_should = true
-      end
-
-      # @api private
-      def self.warn_unless_should_configured(method_name)
-        if @warn_about_should
-          RSpec.deprecate(
-            "Using `#{method_name}` from rspec-mocks' old `:should` syntax without explicitly enabling the syntax",
-            :replacement => "the new `:expect` syntax or explicitly enable `:should`"
-          )
-
-          @warn_about_should = false
-        end
-      end
-
-      # @api private
-      # Enables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
-      def self.enable_should(syntax_host = default_should_syntax_host)
-        @warn_about_should = false
-        return if should_enabled?(syntax_host)
-
-        syntax_host.class_exec do
-          def should_receive(message, opts={}, &block)
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            opts[:expected_from] ||= CallerFilter.first_non_rspec_line
-            ::RSpec::Mocks.expect_message(self, message, opts, &block)
-          end
-
-          def should_not_receive(message, &block)
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            opts = {:expected_from => CallerFilter.first_non_rspec_line}
-            ::RSpec::Mocks.expect_message(self, message, opts, &block).never
-          end
-
-          def stub(message_or_hash, opts={}, &block)
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            if ::Hash === message_or_hash
-              message_or_hash.each {|message, value| stub(message).and_return value }
-            else
-              opts[:expected_from] = CallerFilter.first_non_rspec_line
-              ::RSpec::Mocks.allow_message(self, message_or_hash, opts, &block)
-            end
-          end
-
-          def unstub(message)
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            ::RSpec::Mocks.space.proxy_for(self).remove_stub(message)
-          end
-
-          def stub_chain(*chain, &blk)
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            ::RSpec::Mocks::StubChain.stub_chain_on(self, *chain, &blk)
-          end
-
-          def as_null_object
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            @_null_object = true
-            ::RSpec::Mocks.proxy_for(self).as_null_object
-          end
-
-          def null_object?
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            defined?(@_null_object)
-          end
-
-          def received_message?(message, *args, &block)
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            ::RSpec::Mocks.proxy_for(self).received_message?(message, *args, &block)
-          end
-
-          unless Class.respond_to? :any_instance
-            Class.class_exec do
-              def any_instance
-                ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-                ::RSpec::Mocks.any_instance_recorder_for(self)
-              end
-            end
-          end
-        end
-      end
-
-      # @api private
-      # Disables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
-      def self.disable_should(syntax_host = default_should_syntax_host)
-        return unless should_enabled?(syntax_host)
-
-        syntax_host.class_exec do
-          undef should_receive
-          undef should_not_receive
-          undef stub
-          undef unstub
-          undef stub_chain
-          undef as_null_object
-          undef null_object?
-          undef received_message?
-        end
-
-        Class.class_exec do
-          undef any_instance
-        end
-      end
-
-      # @api private
-      # Enables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc).
-      def self.enable_expect(syntax_host = ::RSpec::Mocks::ExampleMethods)
-        return if expect_enabled?(syntax_host)
-
-        syntax_host.class_exec do
-          def receive(method_name, &block)
-            Matchers::Receive.new(method_name, block)
-          end
-
-          def receive_messages(message_return_value_hash)
-            matcher = Matchers::ReceiveMessages.new(message_return_value_hash)
-            matcher.warn_about_block if block_given?
-            matcher
-          end
-
-          def allow(target)
-            AllowanceTarget.new(target)
-          end
-
-          def expect_any_instance_of(klass)
-            AnyInstanceExpectationTarget.new(klass)
-          end
-
-          def allow_any_instance_of(klass)
-            AnyInstanceAllowanceTarget.new(klass)
-          end
-        end
-
-        RSpec::Mocks::ExampleMethods::ExpectHost.class_exec do
-          def expect(target)
-            ExpectationTarget.new(target)
-          end
-        end
-      end
-
-      # @api private
-      # Disables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc).
-      def self.disable_expect(syntax_host = ::RSpec::Mocks::ExampleMethods)
-        return unless expect_enabled?(syntax_host)
-
-        syntax_host.class_exec do
-          undef receive
-          undef receive_messages
-          undef allow
-          undef expect_any_instance_of
-          undef allow_any_instance_of
-        end
-
-        RSpec::Mocks::ExampleMethods::ExpectHost.class_exec do
-          undef expect
-        end
-      end
-
-      # @api private
-      # Indicates whether or not the should syntax is enabled.
-      def self.should_enabled?(syntax_host = default_should_syntax_host)
-        syntax_host.method_defined?(:should_receive)
-      end
-
-      # @api private
-      # Indicates whether or not the expect syntax is enabled.
-      def self.expect_enabled?(syntax_host = ::RSpec::Mocks::ExampleMethods)
-        syntax_host.method_defined?(:allow)
-      end
-
-      # @api private
-      # Determines where the methods like `should_receive`, and `stub` are added.
-      def self.default_should_syntax_host
-        # JRuby 1.7.4 introduces a regression whereby `defined?(::BasicObject) => nil`
-        # yet `BasicObject` still exists and patching onto ::Object breaks things
-        # e.g. SimpleDelegator expectations won't work
-        #
-        # See: https://github.com/jruby/jruby/issues/814
-        if defined?(JRUBY_VERSION) && JRUBY_VERSION == '1.7.4' && RUBY_VERSION.to_f > 1.8
-          return ::BasicObject
-        end
-
-        # On 1.8.7, Object.ancestors.last == Kernel but
-        # things blow up if we include `RSpec::Mocks::Methods`
-        # into Kernel...not sure why.
-        return Object unless defined?(::BasicObject)
-
-        # MacRuby has BasicObject but it's not the root class.
-        return Object unless Object.ancestors.last == ::BasicObject
-
-        ::BasicObject
-      end
-
-      # @method should_receive
-      # Sets an expectation that this object should receive a message before
-      # the end of the example.
-      #
-      # @example
-      #
-      #     logger = double('logger')
-      #     thing_that_logs = ThingThatLogs.new(logger)
-      #     logger.should_receive(:log)
-      #     thing_that_logs.do_something_that_logs_a_message
-      #
-      # @note This is only available when you have enabled the `should` syntax.
-
-      # @method should_not_receive
-      # Sets and expectation that this object should _not_ receive a message
-      # during this example.
-
-      # @method stub
-      # Tells the object to respond to the message with the specified value.
-      #
-      # @example
-      #
-      #     counter.stub(:count).and_return(37)
-      #     counter.stub(:count => 37)
-      #     counter.stub(:count) { 37 }
-      #
-      # @note This is only available when you have enabled the `should` syntax.
-
-      # @method unstub
-      # Removes a stub. On a double, the object will no longer respond to
-      # `message`. On a real object, the original method (if it exists) is
-      # restored.
-      #
-      # This is rarely used, but can be useful when a stub is set up during a
-      # shared `before` hook for the common case, but you want to replace it
-      # for a special case.
-      #
-      # @note This is only available when you have enabled the `should` syntax.
-
-      # @method stub_chain
-      # @overload stub_chain(method1, method2)
-      # @overload stub_chain("method1.method2")
-      # @overload stub_chain(method1, method_to_value_hash)
-      #
-      # Stubs a chain of methods.
-      #
-      # ## Warning:
-      #
-      # Chains can be arbitrarily long, which makes it quite painless to
-      # violate the Law of Demeter in violent ways, so you should consider any
-      # use of `stub_chain` a code smell. Even though not all code smells
-      # indicate real problems (think fluent interfaces), `stub_chain` still
-      # results in brittle examples.  For example, if you write
-      # `foo.stub_chain(:bar, :baz => 37)` in a spec and then the
-      # implementation calls `foo.baz.bar`, the stub will not work.
-      #
-      # @example
-      #
-      #     double.stub_chain("foo.bar") { :baz }
-      #     double.stub_chain(:foo, :bar => :baz)
-      #     double.stub_chain(:foo, :bar) { :baz }
-      #
-      #     # Given any of ^^ these three forms ^^:
-      #     double.foo.bar # => :baz
-      #
-      #     # Common use in Rails/ActiveRecord:
-      #     Article.stub_chain("recent.published") { [Article.new] }
-      #
-      # @note This is only available when you have enabled the `should` syntax.
-
-      # @method as_null_object
-      # 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.
-      #
-      # @note This is only available when you have enabled the `should` syntax.
-
-      # @method null_object?
-      # Returns true if this object has received `as_null_object`
-      #
-      # @note This is only available when you have enabled the `should` syntax.
-
-      # @method any_instance
-      # Used to set stubs and message expectations on any instance of a given
-      # class. Returns a [Recorder](Recorder), which records messages like
-      # `stub` and `should_receive` for later playback on instances of the
-      # class.
-      #
-      # @example
-      #
-      #     Car.any_instance.should_receive(:go)
-      #     race = Race.new
-      #     race.cars << Car.new
-      #     race.go # assuming this delegates to all of its cars
-      #             # this example would pass
-      #
-      #     Account.any_instance.stub(:balance) { Money.new(:USD, 25) }
-      #     Account.new.balance # => Money.new(:USD, 25))
-      #
-      # @return [Recorder]
-      #
-      # @note This is only available when you have enabled the `should` syntax.
-
-      # @method expect
-      # Used to wrap an object in preparation for setting a mock expectation
-      # on it.
-      #
-      # @example
-      #
-      #   expect(obj).to receive(:foo).with(5).and_return(:return_value)
-      #
-      # @note This method is usually provided by rspec-expectations, unless
-      #   you are using rspec-mocks w/o rspec-expectations, in which case it
-      #   is only made available if you enable the `expect` syntax.
-
-      # @method allow
-      # Used to wrap an object in preparation for stubbing a method
-      # on it.
-      #
-      # @example
-      #
-      #   allow(dbl).to receive(:foo).with(5).and_return(:return_value)
-      #
-      # @note This is only available when you have enabled the `expect` syntax.
-
-      # @method expect_any_instance_of
-      # Used to wrap a class in preparation for setting a mock expectation
-      # on instances of it.
-      #
-      # @example
-      #
-      #   expect_any_instance_of(MyClass).to receive(:foo)
-      #
-      # @note This is only available when you have enabled the `expect` syntax.
-
-      # @method allow_any_instance_of
-      # Used to wrap a class in preparation for stubbing a method
-      # on instances of it.
-      #
-      # @example
-      #
-      #   allow_any_instance_of(MyClass).to receive(:foo)
-      #
-      # @note This is only available when you have enabled the `expect` syntax.
-
-      # @method receive
-      # Used to specify a message that you expect or allow an object
-      # to receive. The object returned by `receive` supports the same
-      # fluent interface that `should_receive` and `stub` have always
-      # supported, allowing you to constrain the arguments or number of
-      # times, and configure how the object should respond to the message.
-      #
-      # @example
-      #
-      #   expect(obj).to receive(:hello).with("world").exactly(3).times
-      #
-      # @note This is only available when you have enabled the `expect` syntax.
-      #
-      # @method receive_messages
-      # Shorthand syntax used to setup message(s), and their return value(s),
-      # that you expect or allow an object to receive. The method takes a hash
-      # of messages and their respective return values. Unlike with `receive`,
-      # you cannot apply further customizations using a block or the fluent
-      # interface.
-      #
-      # @example
-      #
-      #   allow(obj).to receive_messages(:speak => "Hello World")
-      #   allow(obj).to receive_messages(:speak => "Hello", :meow => "Meow")
-      #
-      # @note This is only available when you have enabled the `expect` syntax.
-    end
-  end
-end
-

data/vendor_lib/rspec/mocks/test_double.rb

@@ -1,109 +0,0 @@
-module RSpec
-  module Mocks
-    # Implements the methods needed for a pure test double.  RSpec::Mocks::Mock
-    # includes this module, and it is provided for cases where you want a
-    # pure test double without subclassing RSpec::Mocks::Mock.
-    module TestDouble
-      # Extends the TestDouble module onto the given object and
-      # initializes it as a test double.
-      #
-      # @example
-      #
-      #   module = Module.new
-      #   RSpec::Mocks::TestDouble.extend_onto(module, "MyMixin", :foo => "bar")
-      #   module.foo  #=> "bar"
-      def self.extend_onto(object, name=nil, stubs={})
-        object.extend self
-        object.send(:__initialize_as_test_double, name, stubs)
-      end
-
-      # Creates a new test double with a `name` (that will be used in error
-      # messages only)
-      def initialize(name=nil, stubs={})
-        __initialize_as_test_double(name, 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
-        "#<#{self.class}:#{sprintf '0x%x', self.object_id} @name=#{@name.inspect}>"
-      end
-
-      # @private
-      def to_s
-        inspect.gsub('<','[').gsub('>',']')
-      end
-
-      alias_method :to_str, :to_s
-
-      # @private
-      def respond_to?(message, incl_private=false)
-        __mock_proxy.null_object? ? true : super
-      end
-
-      # @private
-      def __build_mock_proxy(order_group)
-        Proxy.new(self, order_group, @name)
-      end
-
-    private
-
-      def __initialize_as_test_double(name=nil, stubs={})
-        if Hash === name && stubs.empty?
-          stubs = name
-          @name = nil
-        else
-          @name = name
-        end
-        assign_stubs(stubs)
-      end
-
-      def method_missing(message, *args, &block)
-        if __mock_proxy.null_object?
-          case message
-          when :to_int        then return 0
-          when :to_a, :to_ary then return nil
-          end
-        end
-        __mock_proxy.record_message_received(message, *args, &block)
-
-        begin
-          __mock_proxy.null_object? ? self : super
-        rescue NameError
-          # Required wrapping doubles in an Array on Ruby 1.9.2
-          raise NoMethodError if [:to_a, :to_ary].include? message
-          __mock_proxy.raise_unexpected_message_error(message, *args)
-        end
-      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.proxy_for(self)
-      end
-    end
-  end
-end

data/vendor_lib/rspec/mocks/version.rb

@@ -1,7 +0,0 @@
-module RSpec
-  module Mocks
-    module Version
-      STRING = '3.0.0.beta1'
-    end
-  end
-end

data/vendor_lib/rspec/mocks.rb

@@ -1,100 +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_exec 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) {
-          CallerFilter.first_non_rspec_line
-        }
-        ::RSpec::Mocks.proxy_for(subject).
-          add_stub(orig_caller, 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
-      # @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) {
-          CallerFilter.first_non_rspec_line
-        }
-        ::RSpec::Mocks.proxy_for(subject).
-          add_message_expectation(orig_caller, message, 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_lib/rspec/support/spec/deprecation_helpers.rb

@@ -1,29 +0,0 @@
-module RSpecHelpers
-  def expect_deprecation_with_call_site(file, line)
-    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
-      expect(options[:call_site]).to include([file, line].join(':'))
-    end
-  end
-
-  def allow_deprecation
-    allow(RSpec.configuration.reporter).to receive(:deprecation)
-  end
-
-  def expect_warning_without_call_site(expected = //)
-    expect(::Kernel).to receive(:warn) do |message|
-      expect(message).to match expected
-      expect(message).to_not match(/Called from/)
-    end
-  end
-
-  def expect_warning_with_call_site(file, line, expected = //)
-    expect(::Kernel).to receive(:warn) do |message|
-      expect(message).to match expected
-      expect(message).to match(/Called from #{file}:#{line}/)
-    end
-  end
-
-  def allow_warning
-    allow(::Kernel).to receive(:warn)
-  end
-end

data/vendor_lib/rspec/support/spec.rb

@@ -1,14 +0,0 @@
-require 'rspec/support/spec/deprecation_helpers'
-require 'rspec/support/spec/stderr_splitter'
-
-warning_preventer = $stderr = RSpec::Support::StdErrSplitter.new($stderr)
-
-RSpec.configure do |c|
-  c.include RSpecHelpers
-  c.before do
-    warning_preventer.reset!
-  end
-  c.after do |example|
-    warning_preventer.verify_example!(example)
-  end
-end

data/vendor_lib/rspec/support/warnings.rb

@@ -1,41 +0,0 @@
-module RSpec
-
-  unless respond_to?(:deprecate)
-
-    # @private
-    #
-    # Used internally to print deprecation warnings
-    # when rspec-core isn't loaded
-    def self.deprecate(deprecated, options = {})
-      warn_with "DEPRECATION: #{deprecated} is deprecated.", options
-    end
-  end
-
-  unless respond_to?(:warn_deprecation)
-
-    # @private
-    #
-    # Used internally to print deprecation warnings
-    # when rspec-core isn't loaded
-    def self.warn_deprecation(message)
-      warn_with "DEPRECATION: \n #{message}"
-    end
-  end
-
-  # @private
-  #
-  # Used internally to print warnings
-  def self.warning(text, options={})
-    warn_with "WARNING: #{text}.", options
-  end
-
-  # @private
-  #
-  # Used internally to print longer warnings
-  def self.warn_with(message, options = {})
-    call_site = options.fetch(:call_site) { CallerFilter.first_non_rspec_line }
-    message << " Called from #{call_site}." if call_site
-    ::Kernel.warn message
-  end
-
-end

data/vendor_lib/rspec/support.rb

@@ -1,6 +0,0 @@
-require "rspec/support/version"
-
-module RSpec
-  module Support
-  end
-end

data/vendor_lib/rspec-expectations.rb

@@ -1 +0,0 @@
-require "rspec/expectations"