opal-rspec 0.4.3 → 0.5.0.beta1

data/rspec-mocks/benchmarks/method_defined_at_any_visibility.rb

@@ -0,0 +1,101 @@
+require 'benchmark'
+
+n = 1_000_000
+
+Foo = Class.new do
+  1.upto(n) do |i|
+    define_method(:"public_method_#{i}") { }
+    define_method(:"protected_method_#{i}") { }
+    protected :"protected_method_#{i}"
+    define_method(:"private_method_#{i}") { }
+    private :"protected_method_#{i}"
+  end
+end
+
+Benchmark.benchmark do |bm|
+  puts "#{n} times - ruby #{RUBY_VERSION}"
+
+  puts
+  puts "using method_defined? and private_method_defined?"
+  puts
+
+  [:public, :protected, :private, :undefined].each do |vis|
+    puts "  - #{vis} methods"
+
+    3.times do
+      GC.start
+
+      bm.report do
+        n.times do |i|
+          name = :"#{vis}_method_#{i}"
+          Foo.method_defined?(name) || Foo.private_method_defined?(name)
+        end
+      end
+    end
+  end
+
+  puts
+  puts "using public_method_defined?, protected_method_defined? and private_method_defined?"
+  puts
+
+  [:public, :protected, :private, :undefined].each do |vis|
+    puts "  - #{vis} methods"
+
+    3.times do
+      GC.start
+
+      bm.report do
+        n.times do |i|
+          name = :"#{vis}_method_#{i}"
+          Foo.public_method_defined?(name) ||
+          Foo.protected_method_defined?(name)
+          Foo.private_method_defined?(name)
+        end
+      end
+    end
+  end
+end
+
+=begin
+
+1000000 times - ruby 2.0.0
+
+using method_defined? and private_method_defined?
+
+  - public methods
+   1.410000   0.040000   1.450000 (  1.462588)
+   1.380000   0.000000   1.380000 (  1.372015)
+   1.370000   0.000000   1.370000 (  1.372362)
+  - protected methods
+   1.410000   0.000000   1.410000 (  1.402750)
+   1.440000   0.000000   1.440000 (  1.442719)
+   1.460000   0.010000   1.470000 (  1.464763)
+  - private methods
+   1.390000   0.000000   1.390000 (  1.393956)
+   1.340000   0.000000   1.340000 (  1.349340)
+   1.360000   0.000000   1.360000 (  1.361910)
+  - undefined methods
+   3.260000   0.050000   3.310000 (  3.316372)
+   1.260000   0.010000   1.270000 (  1.266557)
+   1.250000   0.000000   1.250000 (  1.248734)
+
+using public_method_defined?, protected_method_defined? and private_method_defined?
+
+  - public methods
+   1.550000   0.000000   1.550000 (  1.550655)
+   1.540000   0.010000   1.550000 (  1.543906)
+   1.540000   0.000000   1.540000 (  1.538267)
+  - protected methods
+   1.590000   0.000000   1.590000 (  1.598310)
+   1.600000   0.000000   1.600000 (  1.595205)
+   1.600000   0.000000   1.600000 (  1.604186)
+  - private methods
+   1.530000   0.000000   1.530000 (  1.530080)
+   1.560000   0.000000   1.560000 (  1.562656)
+   1.560000   0.000000   1.560000 (  1.569161)
+  - undefined methods
+   1.300000   0.000000   1.300000 (  1.298066)
+   1.310000   0.000000   1.310000 (  1.310737)
+   1.290000   0.000000   1.290000 (  1.288307)
+
+=end

data/rspec-mocks/benchmarks/thread_safety.rb

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
+
+require 'benchmark'
+require 'rspec/mocks'
+
+Benchmark.bm do |bm|
+  bm.report("fetching a proxy") do
+    RSpec::Mocks.with_temporary_scope do
+      o = Object.new
+      100000.times {
+        RSpec::Mocks.space.proxy_for(o)
+      }
+    end
+  end
+end
+
+# Without synchronize (not thread-safe):
+#
+#       user     system      total        real
+# fetching a proxy  0.120000   0.000000   0.120000 (  0.141333)
+#
+# With synchronize (thread-safe):
+#       user     system      total        real
+# fetching a proxy  0.180000   0.000000   0.180000 (  0.189553)

data/rspec-mocks/benchmarks/transfer_nested_constants.rb

@@ -0,0 +1,77 @@
+$LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
+
+require 'benchmark'
+require 'rspec/mocks'
+
+N = ENV.fetch('N', 10000).to_i
+M = ENV.fetch('M', 5).to_i
+
+puts "#{N} times, #{M} constants - ruby #{RUBY_VERSION}"
+puts
+
+class A
+  M.times do |x|
+    const_set("C#{x}", Object.new)
+  end
+end
+
+Benchmark.bm(20) do |bm|
+  RSpec::Mocks.setup(self)
+
+  bm.report("with constants") do
+    N.times do
+      class_double('A').as_stubbed_const(:transfer_nested_constants => true)
+    end
+  end
+
+  bm.report("without constants") do
+    N.times do
+      class_double('A').as_stubbed_const(:transfer_nested_constants => false)
+    end
+  end
+end
+
+# > for n in 1 10000; do for m in 0 5 100; do echo; \
+#     env N=$n M=$m ruby benchmarks/transfer_nested_constants.rb; \
+#   echo; done; done
+#
+# 1 times, 0 constants - ruby 2.0.0
+#
+#                            user     system      total        real
+# with constants         0.000000   0.000000   0.000000 (  0.000180)
+# without constants      0.000000   0.000000   0.000000 (  0.000071)
+#
+#
+# 1 times, 5 constants - ruby 2.0.0
+#
+#                            user     system      total        real
+# with constants         0.000000   0.000000   0.000000 (  0.000197)
+# without constants      0.000000   0.000000   0.000000 (  0.000123)
+#
+#
+# 1 times, 100 constants - ruby 2.0.0
+#
+#                            user     system      total        real
+# with constants         0.000000   0.000000   0.000000 (  0.000433)
+# without constants      0.000000   0.000000   0.000000 (  0.000115)
+#
+#
+# 10000 times, 0 constants - ruby 2.0.0
+#
+#                            user     system      total        real
+# with constants         0.900000   0.020000   0.920000 (  0.935583)
+# without constants      0.660000   0.010000   0.670000 (  0.680178)
+#
+#
+# 10000 times, 5 constants - ruby 2.0.0
+#
+#                            user     system      total        real
+# with constants         1.080000   0.020000   1.100000 (  1.114722)
+# without constants      0.720000   0.020000   0.740000 (  0.741976)
+#
+#
+# 10000 times, 100 constants - ruby 2.0.0
+#
+#                            user     system      total        real
+# with constants         3.870000   0.110000   3.980000 (  4.000176)
+# without constants      0.930000   0.010000   0.940000 (  0.947197)

data/rspec-mocks/features/step_definitions/additional_cli_steps.rb

@@ -0,0 +1,21 @@
+Then /^the example(?:s)? should(?: all)? pass$/ do
+  step %q{the output should contain "0 failures"}
+  step %q{the exit status should be 0}
+end
+
+Then /^the examples should all fail, producing the following output:$/ do |table|
+  step %q{the exit status should be 1}
+  examples, failures = all_output.match(/(\d+) examples?, (\d+) failures?/).captures.map(&:to_i)
+
+  expect(examples).to be > 0
+  expect(examples).to eq(failures)
+
+  lines = table.raw.flatten.reject(&:empty?)
+  expect(all_output).to include(*lines)
+end
+
+Then /^it should fail with the following output:$/ do |table|
+  step %q{the exit status should be 1}
+  lines = table.raw.flatten.reject(&:empty?)
+  expect(all_output).to include(*lines)
+end

data/rspec-mocks/features/support/disallow_certain_apis.rb

@@ -0,0 +1,24 @@
+# This file is designed to prevent the use of certain APIs that
+# we don't want used from our cukes, since they function as documentation.
+
+if defined?(Cucumber)
+  require 'shellwords'
+  Before('~@allow-old-syntax') do
+    set_env('SPEC_OPTS', "-r#{Shellwords.escape(__FILE__)}")
+  end
+else
+  module DisallowOneLinerShould
+    def should(*)
+      raise "one-liner should is not allowed"
+    end
+
+    def should_not(*)
+      raise "one-liner should_not is not allowed"
+    end
+  end
+
+  RSpec.configure do |rspec|
+    rspec.disable_monkey_patching!
+    rspec.include DisallowOneLinerShould
+  end
+end

data/rspec-mocks/features/support/env.rb

@@ -0,0 +1,22 @@
+require 'aruba/cucumber'
+require 'rspec/expectations'
+
+Before do
+  if RUBY_PLATFORM =~ /java/ || defined?(Rubinius)
+    @aruba_timeout_seconds = 60
+  else
+    @aruba_timeout_seconds = 5
+  end
+end
+
+Aruba.configure do |config|
+  config.before_cmd do |cmd|
+    set_env('JRUBY_OPTS', "-X-C #{ENV['JRUBY_OPTS']}") # disable JIT since these processes are so short lived
+  end
+end if RUBY_PLATFORM == 'java'
+
+Aruba.configure do |config|
+  config.before_cmd do |cmd|
+    set_env('RBXOPT', "-Xint=true #{ENV['RBXOPT']}") # disable JIT since these processes are so short lived
+  end
+end if defined?(Rubinius)

data/rspec-mocks/features/support/rubinius.rb

@@ -0,0 +1,6 @@
+# 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_lib → rspec-mocks/lib}/rspec/mocks/any_instance/chain.rb

@@ -1,13 +1,20 @@
 module RSpec
   module Mocks
+    # @private
     module AnyInstance
+      # @private
       class Chain
         def initialize(recorder, *args, &block)
           @recorder          = recorder
           @expectation_args  = args
           @expectation_block = block
+          @argument_list_matcher = ArgumentListMatcher::MATCH_ALL
         end
 
+        # @private
+        #
+        # Provides convenience methods for recording customizations on message
+        # expectations.
         module Customizations
           # @macro [attach] record
           #   @method $1(*args, &block)
@@ -30,7 +37,7 @@ module RSpec
           record :with
           record :once
           record :twice
-          record :any_number_of_times
+          record :thrice
           record :exactly
           record :times
           record :never
@@ -57,6 +64,11 @@ module RSpec
           end
         end
 
+        # @private
+        def matches_args?(*args)
+          @argument_list_matcher.args_match?(*args)
+        end
+
         # @private
         def expectation_fulfilled!
           @expectation_fulfilled = true
@@ -67,7 +79,12 @@ module RSpec
           super
         end
 
-        private
+        def with(*args, &block)
+          @argument_list_matcher = ArgumentListMatcher.new(*args)
+          super
+        end
+
+      private
 
         def negated?
           messages.any? { |(message, *_), _| message == :never }

data/rspec-mocks/lib/rspec/mocks/any_instance/expect_chain_chain.rb

@@ -0,0 +1,35 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @private
+      class ExpectChainChain < StubChain
+        def initialize(*args)
+          super
+          @expectation_fulfilled = false
+        end
+
+        def expectation_fulfilled?
+          @expectation_fulfilled
+        end
+
+        def playback!(instance)
+          super.tap { @expectation_fulfilled = true }
+        end
+
+      private
+
+        def create_message_expectation_on(instance)
+          ::RSpec::Mocks::ExpectChain.expect_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/{vendor_lib → rspec-mocks/lib}/rspec/mocks/any_instance/expectation_chain.rb

@@ -1,10 +1,10 @@
 module RSpec
   module Mocks
     module AnyInstance
-      # @api private
+      # @private
       class ExpectationChain < Chain
         def expectation_fulfilled?
-          @expectation_fulfilled || constrained_to_any_of?(:never, :any_number_of_times)
+          @expectation_fulfilled || constrained_to_any_of?(:never)
         end
 
         def initialize(*args, &block)
@@ -12,20 +12,22 @@ module RSpec
           super
         end
 
-        private
-        def verify_invocation_order(rspec_method_name, *args, &block)
+      private
+
+        def verify_invocation_order(_rspec_method_name, *_args, &_block)
         end
       end
 
-      # @api private
+      # @private
       class PositiveExpectationChain < ExpectationChain
-
-        private
+      private
 
         def create_message_expectation_on(instance)
-          proxy = ::RSpec::Mocks.proxy_for(instance)
-          expected_from = IGNORED_BACKTRACE_LINE
-          me = proxy.add_message_expectation(expected_from, *@expectation_args, &@expectation_block)
+          proxy = ::RSpec::Mocks.space.proxy_for(instance)
+          method_name, opts = @expectation_args
+          opts = (opts || {}).merge(:expected_form => IGNORED_BACKTRACE_LINE)
+
+          me = proxy.add_message_expectation(method_name, opts, &@expectation_block)
           if RSpec::Mocks.configuration.yield_receiver_to_any_instance_implementation_blocks?
             me.and_yield_receiver_to_implementation
           end
@@ -44,4 +46,3 @@ module RSpec
     end
   end
 end
-

data/{vendor_lib → rspec-mocks/lib}/rspec/mocks/any_instance/message_chains.rb

@@ -32,9 +32,16 @@ module RSpec
           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_by_method_name.all? do |_method_name, chains|
             chains.all? { |chain| chain.expectation_fulfilled? }
           end
         end
@@ -61,13 +68,16 @@ module RSpec
           end
         end
 
-        private
+      private
 
         def raise_if_second_instance_to_receive_message(instance)
           @instance_with_expectation ||= instance if ExpectationChain === instance
-          if ExpectationChain === instance && !@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
+          return unless ExpectationChain === instance
+          return if @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

data/rspec-mocks/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