opal-rspec 0.4.0.beta3 → 0.4.0.beta4

data/vendor_lib/rspec/mocks/verifying_proxy.rb

@@ -0,0 +1,151 @@
+require 'rspec/mocks/verifying_message_expecation'
+require 'rspec/mocks/method_reference'
+
+module RSpec
+  module Mocks
+
+    module VerifyingProxyMethods
+      def add_stub(location, method_name, opts={}, &implementation)
+        ensure_implemented(method_name)
+        super
+      end
+
+      def add_simple_stub(method_name, *args)
+        ensure_implemented(method_name)
+        super
+      end
+
+      def add_message_expectation(location, method_name, opts={}, &block)
+        ensure_implemented(method_name)
+        super
+      end
+
+      def ensure_implemented(method_name)
+        return unless @doubled_module.defined?
+
+        method_reference[method_name].when_unimplemented do
+          @error_generator.raise_unimplemented_error(
+            @doubled_module,
+            method_name
+          )
+        end
+      end
+    end
+
+    # A verifying proxy mostly acts like a normal proxy, except that it
+    # contains extra logic to try and determine the validity of any expectation
+    # set on it. This includes whether or not methods have been defined and the
+    # arity of method calls.
+    #
+    # In all other ways this behaves like a normal proxy. It only adds the
+    # verification behaviour to specific methods then delegates to the parent
+    # implementation.
+    #
+    # These checks are only activated if the doubled class has already been
+    # loaded, otherwise they are disabled. This allows for testing in
+    # isolation.
+    #
+    # @api private
+    class VerifyingProxy < Proxy
+      include VerifyingProxyMethods
+
+      def initialize(object, order_group, name, method_reference_class)
+        super(object, order_group)
+        @object                 = object
+        @doubled_module         = name
+        @method_reference_class = method_reference_class
+
+        # A custom method double is required to pass through a way to lookup
+        # methods to determine their arity. This is only relevant if the doubled
+        # class is loaded.
+        @method_doubles = Hash.new do |h, k|
+          h[k] = VerifyingMethodDouble.new(@object, k, self, method_reference[k])
+        end
+      end
+
+      def method_reference
+        @method_reference ||= Hash.new do |h, k|
+          h[k] = @method_reference_class.new(@doubled_module, k)
+        end
+      end
+    end
+
+    class VerifyingPartialMockProxy < PartialMockProxy
+      include VerifyingProxyMethods
+
+      def initialize(object, expectation_ordering)
+        super(object, expectation_ordering)
+        @doubled_module = DirectObjectReference.new(object)
+
+        # A custom method double is required to pass through a way to lookup
+        # methods to determine their arity.
+        @method_doubles = Hash.new do |h, k|
+          h[k] = VerifyingExistingMethodDouble.new(object, k, self)
+        end
+      end
+
+      def method_reference
+        @method_doubles
+      end
+    end
+
+    # @api private
+    class VerifyingMethodDouble < MethodDouble
+      def initialize(object, method_name, proxy, method_reference)
+        super(object, method_name, proxy)
+        @method_reference = method_reference
+      end
+
+      def message_expectation_class
+        VerifyingMessageExpectation
+      end
+
+      def add_expectation(*arg)
+        super.tap { |x| x.method_reference = @method_reference }
+      end
+
+      def proxy_method_invoked(obj, *args, &block)
+        ensure_arity!(args.length)
+        super
+      end
+
+    private
+
+      def ensure_arity!(arity)
+        @method_reference.when_defined do |method|
+          calculator = ArityCalculator.new(method)
+          unless calculator.within_range?(arity)
+            raise ArgumentError, "wrong number of arguments (#{arity} for #{method.arity})"
+          end
+        end
+      end
+    end
+
+    # @api private
+    #
+    # A VerifyingMethodDouble fetches the method to verify against from the
+    # original object, using a MethodReference. This works for pure doubles,
+    # but when the original object is itself the one being modified we need to
+    # collapse the reference and the method double into a single object so that
+    # we can access the original pristine method definition.
+    class VerifyingExistingMethodDouble < VerifyingMethodDouble
+      def initialize(object, method_name, proxy)
+        super(object, method_name, proxy, self)
+
+        @valid_method = object.respond_to?(method_name)
+
+        # Trigger an eager find of the original method since if we find it any
+        # later we end up getting a stubbed method with incorrect arity.
+        save_original_method!
+      end
+
+      def when_defined
+        yield original_method
+      end
+
+      def when_unimplemented
+        yield unless @valid_method
+      end
+    end
+  end
+end

data/vendor_lib/rspec/mocks/version.rb

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

data/vendor_lib/rspec/mocks.rb

@@ -0,0 +1,100 @@
+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/caller_filter.rb

@@ -0,0 +1,56 @@
+module RSpec
+  # Consistent implementation for "cleaning" the caller method to strip out
+  # non-rspec lines. This enables errors to be reported at the call site in
+  # the code using the library, which is far more useful than the particular
+  # internal method that raised an error.
+  class CallerFilter
+
+    RSPEC_LIBS = %w[
+      core
+      mocks
+      expectations
+      support
+      matchers
+      rails
+    ]
+
+    ADDITIONAL_TOP_LEVEL_FILES = %w[ autorun ]
+
+    LIB_REGEX = %r{/lib/rspec/(#{(RSPEC_LIBS + ADDITIONAL_TOP_LEVEL_FILES).join('|')})(\.rb|/)}
+
+    if RUBY_VERSION >= '2.0.0'
+      def self.first_non_rspec_line
+        # `caller` is an expensive method that scales linearly with the size of
+        # the stack. The performance hit for fetching it in chunks is small,
+        # and since the target line is probably near the top of the stack, the
+        # overall improvement of a chunked search like this is significant.
+        #
+        # See benchmarks/caller.rb for measurements.
+
+        # Initial value here is mostly arbitrary, but is chosen to give good
+        # performance on the common case of creating a double.
+        increment = 5
+        i         = 1
+        line      = nil
+
+        while !line
+          stack = caller(i, increment)
+          raise "No non-lib lines in stack" unless stack
+
+          line = stack.find { |l| l !~ LIB_REGEX }
+
+          i         += increment
+          increment *= 2 # The choice of two here is arbitrary.
+        end
+
+        line
+      end
+    else
+      # Earlier rubies do not support the two argument form of `caller`. This
+      # fallback is logically the same, but slower.
+      def self.first_non_rspec_line
+        caller.find { |line| line !~ LIB_REGEX }
+      end
+    end
+  end
+end

data/vendor_lib/rspec/support/spec/deprecation_helpers.rb

@@ -0,0 +1,29 @@
+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/in_sub_process.rb

@@ -0,0 +1,40 @@
+module RSpec
+  module Support
+    module InSubProcess
+      if Process.respond_to?(:fork) && !(RUBY_PLATFORM == 'java' && RUBY_VERSION == '1.8.7')
+        # Useful as a way to isolate a global change to a subprocess.
+        def in_sub_process
+          readme, writeme = IO.pipe
+
+          pid = Process.fork do
+            exception = nil
+            begin
+              yield
+            rescue Exception => e
+              exception = e
+            end
+
+            writeme.write Marshal.dump(exception)
+
+            readme.close
+            writeme.close
+            exit! # prevent at_exit hooks from running (e.g. minitest)
+          end
+
+          writeme.close
+          Process.waitpid(pid)
+
+          exception = Marshal.load(readme.read)
+          readme.close
+
+          raise exception if exception
+        end
+      else
+        def in_sub_process
+          pending "This spec requires forking to work properly, " +
+                  "and your platform does not support forking"
+        end
+      end
+    end
+  end
+end

data/vendor_lib/rspec/support/spec/stderr_splitter.rb

@@ -0,0 +1,50 @@
+require 'stringio'
+
+module RSpec
+  module Support
+    class StdErrSplitter < (defined?(::BasicObject) ? ::BasicObject : ::Object)
+      def initialize(original)
+        @orig_stderr    = original
+        @output_tracker = ::StringIO.new
+      end
+
+      respond_to_name = (::RUBY_VERSION.to_f < 1.9) ? :respond_to? : :respond_to_missing?
+      define_method respond_to_name do |*args|
+        @orig_stderr.respond_to?(*args) || super
+      end
+
+      def method_missing(name, *args, &block)
+        @output_tracker.__send__(name, *args, &block)
+        @orig_stderr.__send__(name, *args, &block)
+      end
+
+      def ==(other)
+        @orig_stderr == other
+      end
+
+      # To work around JRuby error:
+      # TypeError: $stderr must have write method, RSpec::StdErrSplitter given
+      def write(*args)
+        @orig_stderr.write(*args)
+        @output_tracker.write(*args)
+      end
+
+      def has_output?
+        !output.empty?
+      end
+
+      def reset!
+        @output_tracker = ::StringIO.new
+      end
+
+      def verify_example!(example)
+        example.send(:fail,"Warnings were generated: #{output}") if has_output?
+        reset!
+      end
+
+      def output
+        @output_tracker.string
+      end
+    end
+  end
+end

data/vendor_lib/rspec/support/spec.rb

@@ -0,0 +1,14 @@
+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/version.rb

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

data/vendor_lib/rspec/support/warnings.rb

@@ -0,0 +1,41 @@
+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

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

data/vendor_lib/rspec/version.rb

@@ -0,0 +1,5 @@
+module RSpec # :nodoc:
+  module Version # :nodoc:
+    STRING = '3.0.0.beta1'
+  end
+end

data/vendor_lib/rspec-expectations.rb

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

data/vendor_lib/rspec.rb

@@ -0,0 +1,3 @@
+require 'rspec/core'
+require 'rspec/version'
+