opal-rspec 0.8.0.alpha3 → 1.0.0.alpha1

data/rspec-core/upstream/lib/rspec/core/invocations.rb

@@ -0,0 +1,87 @@
+module RSpec
+  module Core
+    # @private
+    module Invocations
+      # @private
+      class InitializeProject
+        def call(*_args)
+          RSpec::Support.require_rspec_core "project_initializer"
+          ProjectInitializer.new.run
+          0
+        end
+      end
+
+      # @private
+      class DRbWithFallback
+        def call(options, err, out)
+          require 'rspec/core/drb'
+          begin
+            return DRbRunner.new(options).run(err, out)
+          rescue DRb::DRbConnError
+            err.puts "No DRb server is running. Running in local process instead ..."
+          end
+          RSpec::Core::Runner.new(options).run(err, out)
+        end
+      end
+
+      # @private
+      class Bisect
+        def call(options, err, out)
+          RSpec::Support.require_rspec_core "bisect/coordinator"
+          runner = Runner.new(options).tap { |r| r.configure(err, out) }
+          formatter = bisect_formatter_klass_for(options.options[:bisect]).new(
+            out, runner.configuration.bisect_runner
+          )
+
+          success = RSpec::Core::Bisect::Coordinator.bisect_with(
+            runner, options.args, formatter
+          )
+
+          runner.exit_code(success)
+        end
+
+      private
+
+        def bisect_formatter_klass_for(argument)
+          return Formatters::BisectDebugFormatter if argument == "verbose"
+          Formatters::BisectProgressFormatter
+        end
+      end
+
+      # @private
+      class PrintVersion
+        def call(_options, _err, out)
+          overall_version = RSpec::Core::Version::STRING
+          unless overall_version =~ /[a-zA-Z]+/
+            overall_version = overall_version.split('.').first(2).join('.')
+          end
+
+          out.puts "RSpec #{overall_version}"
+
+          [:Core, :Expectations, :Mocks, :Rails, :Support].each do |const_name|
+            lib_name = const_name.to_s.downcase
+            begin
+              require "rspec/#{lib_name}/version"
+            rescue LoadError
+              # Not worth mentioning libs that are not installed
+              nil
+            else
+              out.puts "  - rspec-#{lib_name} #{RSpec.const_get(const_name)::Version::STRING}"
+            end
+          end
+
+          0
+        end
+      end
+
+      # @private
+      PrintHelp = Struct.new(:parser, :hidden_options) do
+        def call(_options, _err, out)
+          # Removing the hidden options from the output.
+          out.puts parser.to_s.gsub(/^\s+(#{hidden_options.join('|')})\b.*$\n/, '')
+          0
+        end
+      end
+    end
+  end
+end

data/rspec-core/upstream/lib/rspec/core/memoized_helpers.rb

@@ -1,3 +1,5 @@
+RSpec::Support.require_rspec_support 'reentrant_mutex'
+
 module RSpec
   module Core
     # This module is included in {ExampleGroup}, making the methods
@@ -8,7 +10,7 @@ module RSpec
       # @note `subject` was contributed by Joe Ferris to support the one-liner
       #   syntax embraced by shoulda matchers:
       #
-      #       describe Widget do
+      #       RSpec.describe Widget do
       #         it { is_expected.to validate_presence_of(:name) }
       #         # or
       #         it { should validate_presence_of(:name) }
@@ -20,8 +22,8 @@ module RSpec
       #
       # @example
       #
-      #   # explicit declaration of subject
-      #   describe Person do
+      #   # Explicit declaration of subject.
+      #   RSpec.describe Person do
       #     subject { Person.new(:birthdate => 19.years.ago) }
       #     it "should be eligible to vote" do
       #       subject.should be_eligible_to_vote
@@ -29,35 +31,33 @@ module RSpec
       #     end
       #   end
       #
-      #   # implicit subject => { Person.new }
-      #   describe Person do
+      #   # Implicit subject => { Person.new }.
+      #   RSpec.describe Person do
       #     it "should be eligible to vote" do
       #       subject.should be_eligible_to_vote
       #       # ^ ^ explicit reference to subject not recommended
       #     end
       #   end
       #
-      #   # one-liner syntax - expectation is set on the subject
-      #   describe Person do
+      #   # One-liner syntax - expectation is set on the subject.
+      #   RSpec.describe Person do
       #     it { is_expected.to be_eligible_to_vote }
       #     # or
       #     it { should be_eligible_to_vote }
       #   end
       #
-      # @note Because `subject` is designed to create state that is reset between
-      #   each example, and `before(:context)` is designed to setup state that is
-      #   shared across _all_ examples in an example group, `subject` is _not_
-      #   intended to be used in a `before(:context)` hook.
+      # @note Because `subject` is designed to create state that is reset
+      #   between each example, and `before(:context)` is designed to setup
+      #   state that is shared across _all_ examples in an example group,
+      #   `subject` is _not_ intended to be used in a `before(:context)` hook.
       #
       # @see #should
       # @see #should_not
       # @see #is_expected
       def subject
-        __memoized.fetch(:subject) do
-          __memoized[:subject] = begin
-            described = described_class || self.class.metadata.fetch(:description_args).first
-            Class === described ? described.new : described
-          end
+        __memoized.fetch_or_store(:subject) do
+          described = described_class || self.class.metadata.fetch(:description_args).first
+          Class === described ? described.new : described
         end
       end
 
@@ -67,7 +67,7 @@ module RSpec
       #
       # @example
       #
-      #   describe Person do
+      #   RSpec.describe Person do
       #     it { should be_eligible_to_vote }
       #   end
       #
@@ -78,6 +78,7 @@ module RSpec
       # @note If you are using RSpec's newer expect-based syntax you may
       #       want to use `is_expected.to` instead of `should`.
       def should(matcher=nil, message=nil)
+        enforce_value_expectation(matcher, 'should')
         RSpec::Expectations::PositiveExpectationHandler.handle_matcher(subject, matcher, message)
       end
 
@@ -86,7 +87,7 @@ module RSpec
       #
       # @example
       #
-      #   describe Person do
+      #   RSpec.describe Person do
       #     it { should_not be_eligible_to_vote }
       #   end
       #
@@ -97,6 +98,7 @@ module RSpec
       # @note If you are using RSpec's newer expect-based syntax you may
       #       want to use `is_expected.to_not` instead of `should_not`.
       def should_not(matcher=nil, message=nil)
+        enforce_value_expectation(matcher, 'should_not')
         RSpec::Expectations::NegativeExpectationHandler.handle_matcher(subject, matcher, message)
       end
 
@@ -119,33 +121,105 @@ module RSpec
         expect(subject)
       end
 
+      # @private
+      # should just be placed in private section,
+      # but Ruby issues warnings on private attributes.
+      # and expanding it to the equivalent method upsets Rubocop,
+      # b/c it should obviously be a reader
+      attr_reader :__memoized
+      private :__memoized
+
     private
 
       # @private
-      def __memoized
-        @__memoized ||= {}
+      def initialize(*)
+        __init_memoized
+        super
+      end
+
+      # @private
+      def __init_memoized
+        @__memoized = if RSpec.configuration.threadsafe?
+                        ThreadsafeMemoized.new
+                      else
+                        NonThreadSafeMemoized.new
+                      end
+      end
+
+      # @private
+      def enforce_value_expectation(matcher, method_name)
+        return if matcher_supports_value_expectations?(matcher)
+
+        RSpec.deprecate(
+          "#{method_name} #{RSpec::Support::ObjectFormatter.format(matcher)}",
+          :message =>
+            "The implicit block expectation syntax is deprecated, you should pass " \
+            "a block to `expect` to use the provided block expectation matcher " \
+            "(#{RSpec::Support::ObjectFormatter.format(matcher)}), " \
+            "or the matcher must implement `supports_value_expectations?`."
+        )
+      end
+
+      def matcher_supports_value_expectations?(matcher)
+        matcher.supports_value_expectations?
+      rescue
+        true
+      end
+
+      # @private
+      class ThreadsafeMemoized
+        def initialize
+          @memoized = {}
+          @mutex = Support::ReentrantMutex.new
+        end
+
+        def fetch_or_store(key)
+          @memoized.fetch(key) do # only first access pays for synchronization
+            @mutex.synchronize do
+              @memoized.fetch(key) { @memoized[key] = yield }
+            end
+          end
+        end
+      end
+
+      # @private
+      class NonThreadSafeMemoized
+        def initialize
+          @memoized = {}
+        end
+
+        def fetch_or_store(key)
+          @memoized.fetch(key) { @memoized[key] = yield }
+        end
       end
 
       # Used internally to customize the behavior of the
       # memoized hash when used in a `before(:context)` hook.
       #
       # @private
-      class ContextHookMemoizedHash
+      class ContextHookMemoized
         def self.isolate_for_context_hook(example_group_instance)
-          hash = self
+          exploding_memoized = self
 
           example_group_instance.instance_exec do
-            @__memoized = hash
+            @__memoized = exploding_memoized
 
             begin
               yield
             ensure
-              @__memoized = nil
+              # This is doing a reset instead of just isolating for context hook.
+              # Really, this should set the old @__memoized back into place.
+              #
+              # Caller is the before and after context hooks
+              # which are both called from self.run
+              # I didn't look at why it made tests fail, maybe an object was getting reused in RSpec tests,
+              # if so, then that probably already works, and its the tests that are wrong.
+              __init_memoized
             end
           end
         end
 
-        def self.fetch(key, &_block)
+        def self.fetch_or_store(key, &_block)
           description = if key == :subject
                           "subject"
                         else
@@ -206,25 +280,26 @@ EOS
         #   maybe 3 declarations) in any given example group, but that can
         #   quickly degrade with overuse. YMMV.
         #
-        # @note `let` uses an `||=` conditional that has the potential to
-        #   behave in surprising ways in examples that spawn separate threads,
-        #   though we have yet to see this in practice. You've been warned.
+        # @note `let` can be configured to be threadsafe or not.
+        #   If it is threadsafe, it will take longer to access the value.
+        #   If it is not threadsafe, it may behave in surprising ways in examples
+        #   that spawn separate threads. Specify this on `RSpec.configure`
         #
         # @note Because `let` is designed to create state that is reset between
-        #   each example, and `before(:context)` is designed to setup state that is
-        #   shared across _all_ examples in an example group, `let` is _not_
+        #   each example, and `before(:context)` is designed to setup state that
+        #   is shared across _all_ examples in an example group, `let` is _not_
         #   intended to be used in a `before(:context)` hook.
         #
         # @example
         #
-        #   describe Thing do
+        #   RSpec.describe Thing do
         #     let(:thing) { Thing.new }
         #
         #     it "does something" do
-        #       # first invocation, executes block, memoizes and returns result
+        #       # First invocation, executes block, memoizes and returns result.
         #       thing.do_something
         #
-        #       # second invocation, returns the memoized value
+        #       # Second invocation, returns the memoized value.
         #       thing.should be_something
         #     end
         #   end
@@ -232,14 +307,40 @@ EOS
           # We have to pass the block directly to `define_method` to
           # allow it to use method constructs like `super` and `return`.
           raise "#let or #subject called without a block" if block.nil?
-          MemoizedHelpers.module_for(self).__send__(:define_method, name, &block)
+
+          # A list of reserved words that can't be used as a name for a memoized helper
+          # Matches for both symbols and passed strings
+          if [:initialize, :to_s].include?(name.to_sym)
+            raise ArgumentError, "#let or #subject called with reserved name `#{name}`"
+          end
+
+          our_module = MemoizedHelpers.module_for(self)
+
+          # If we have a module clash in our helper module
+          # then we need to remove it to prevent a warning.
+          #
+          # Note we do not check ancestor modules (see: `instance_methods(false)`)
+          # as we can override them.
+          if our_module.instance_methods(false).include?(name)
+            our_module.__send__(:remove_method, name)
+          end
+          our_module.__send__(:define_method, name, &block)
+
+          # If we have a module clash in the example module
+          # then we need to remove it to prevent a warning.
+          #
+          # Note we do not check ancestor modules (see: `instance_methods(false)`)
+          # as we can override them.
+          if instance_methods(false).include?(name)
+            remove_method(name)
+          end
 
           # Apply the memoization. The method has been defined in an ancestor
           # module so we can use `super` here to get the value.
           if block.arity == 1
-            define_method(name) { __memoized.fetch(name) { |k| __memoized[k] = super(RSpec.current_example, &nil) } }
+            define_method(name) { __memoized.fetch_or_store(name) { super(RSpec.current_example, &nil) } }
           else
-            define_method(name) { __memoized.fetch(name) { |k| __memoized[k] = super(&nil) } }
+            define_method(name) { __memoized.fetch_or_store(name) { super(&nil) } }
           end
         end
 
@@ -267,7 +368,7 @@ EOS
         #     end
         #   end
         #
-        #   describe Thing do
+        #   RSpec.describe Thing do
         #     after(:example) { Thing.reset_count }
         #
         #     context "using let" do
@@ -302,8 +403,8 @@ EOS
         end
 
         # Declares a `subject` for an example group which can then be wrapped
-        # with `expect` using `is_expected` to make it the target of an expectation
-        # in a concise, one-line example.
+        # with `expect` using `is_expected` to make it the target of an
+        # expectation in a concise, one-line example.
         #
         # Given a `name`, defines a method with that name which returns the
         # `subject`. This lets you declare the subject once and access it
@@ -312,19 +413,24 @@ EOS
         #
         # When given a `name`, calling `super` in the block is not supported.
         #
+        # @note `subject` can be configured to be threadsafe or not.
+        #   If it is threadsafe, it will take longer to access the value.
+        #   If it is not threadsafe, it may behave in surprising ways in examples
+        #   that spawn separate threads. Specify this on `RSpec.configure`
+        #
         # @param name [String,Symbol] used to define an accessor with an
         #   intention revealing name
         # @param block defines the value to be returned by `subject` in examples
         #
         # @example
         #
-        #   describe CheckingAccount, "with $50" do
+        #   RSpec.describe CheckingAccount, "with $50" do
         #     subject { CheckingAccount.new(Money.new(50, :USD)) }
         #     it { is_expected.to have_a_balance_of(Money.new(50, :USD)) }
         #     it { is_expected.not_to be_overdrawn }
         #   end
         #
-        #   describe CheckingAccount, "with a non-zero starting balance" do
+        #   RSpec.describe CheckingAccount, "with a non-zero starting balance" do
         #     subject(:account) { CheckingAccount.new(Money.new(50, :USD)) }
         #     it { is_expected.not_to be_overdrawn }
         #     it "has a balance equal to the starting balance" do
@@ -348,9 +454,9 @@ EOS
           end
         end
 
-        # Just like `subject`, except the block is invoked by an implicit `before`
-        # hook. This serves a dual purpose of setting up state and providing a
-        # memoized reference to that state.
+        # Just like `subject`, except the block is invoked by an implicit
+        # `before` hook. This serves a dual purpose of setting up state and
+        # providing a memoized reference to that state.
         #
         # @example
         #
@@ -372,7 +478,7 @@ EOS
         #     end
         #   end
         #
-        #   describe Thing do
+        #   RSpec.describe Thing do
         #     after(:example) { Thing.reset_count }
         #
         #     context "using subject" do
@@ -422,9 +528,9 @@ EOS
       def self.module_for(example_group)
         get_constant_or_yield(example_group, :LetDefinitions) do
           mod = Module.new do
-            include Module.new {
+            include(Module.new {
               example_group.const_set(:NamedSubjectPreventSuper, self)
-            }
+            })
           end
 
           example_group.const_set(:LetDefinitions, mod)
@@ -443,6 +549,7 @@ EOS
         # Gets the named constant or yields.
         # On 1.8, const_defined? / const_get do not take into
         # account the inheritance hierarchy.
+        # :nocov:
         def self.get_constant_or_yield(example_group, name)
           if example_group.const_defined?(name)
             example_group.const_get(name)
@@ -450,6 +557,7 @@ EOS
             yield
           end
         end
+        # :nocov:
       else
         # @private
         #