opal-rspec 0.8.0 → 1.0.0.alpha1

data/rspec-expectations/upstream/lib/rspec/expectations/failure_aggregator.rb

@@ -0,0 +1,212 @@
+module RSpec
+  module Expectations
+    # @private
+    class FailureAggregator
+      attr_reader :block_label, :metadata
+
+      def aggregate
+        RSpec::Support.with_failure_notifier(self) do
+          begin
+            yield
+          rescue ExpectationNotMetError => e
+            # Normally, expectation failures will be notified via the `call` method, below,
+            # but since the failure notifier uses a thread local variable, failing expectations
+            # in another thread will still raise. We handle that here and categorize it as part
+            # of `failures` rather than letting it fall through and be categorized as part of
+            # `other_errors`.
+            failures << e
+          rescue Support::AllExceptionsExceptOnesWeMustNotRescue => e
+            # While it is normally a bad practice to rescue `Exception`, it's important we do
+            # so here. It's low risk (`notify_aggregated_failures` below will re-raise the exception,
+            # or raise a `MultipleExpectationsNotMetError` that includes the exception), and it's
+            # essential that the user is notified of expectation failures that may have already
+            # occurred in the `aggregate_failures` block. Those expectation failures may provide
+            # important diagnostics for understanding why this exception occurred, and if we simply
+            # allowed this exception to be raised as-is, it would (wrongly) suggest to the user
+            # that the expectation passed when it did not, which would be quite confusing.
+            other_errors << e
+          end
+        end
+
+        notify_aggregated_failures
+      end
+
+      def failures
+        @failures ||= []
+      end
+
+      def other_errors
+        @other_errors ||= []
+      end
+
+      # This method is defined to satisfy the callable interface
+      # expected by `RSpec::Support.with_failure_notifier`.
+      def call(failure, options)
+        source_id = options[:source_id]
+        return if source_id && @seen_source_ids.key?(source_id)
+
+        @seen_source_ids[source_id] = true
+        assign_backtrace(failure) unless failure.backtrace
+        failures << failure
+      end
+
+    private
+
+      if RSpec::Support::Ruby.jruby? && RSpec::Support::Ruby.jruby_version < '9.2.0.0'
+        # On JRuby 9.1.x.x and before, `caller` and `raise` produce different backtraces with
+        # regards to `.java` stack frames. It's important that we use `raise` for JRuby to produce
+        # a backtrace that has a continuous common section with the raised `MultipleExpectationsNotMetError`,
+        # so that rspec-core's truncation logic can work properly on it to list the backtrace
+        # relative to the `aggregate_failures` block.
+        def assign_backtrace(failure)
+          raise failure
+        rescue failure.class => e
+          failure.set_backtrace(e.backtrace)
+        end
+      else
+        # Using `caller` performs better (and is simpler) than `raise` on most Rubies.
+        def assign_backtrace(failure)
+          failure.set_backtrace(caller)
+        end
+      end
+
+      def initialize(block_label, metadata)
+        @block_label     = block_label
+        @metadata        = metadata
+        @seen_source_ids = {} # don't want to load stdlib set
+      end
+
+      def notify_aggregated_failures
+        all_errors = failures + other_errors
+
+        case all_errors.size
+        when 0 then return true
+        when 1 then RSpec::Support.notify_failure all_errors.first
+        else RSpec::Support.notify_failure MultipleExpectationsNotMetError.new(self)
+        end
+      end
+    end
+
+    # Exception raised from `aggregate_failures` when multiple expectations fail.
+    class MultipleExpectationsNotMetError
+      # @return [String] The fully formatted exception message.
+      def message
+        @message ||= (["#{summary}:"] + enumerated_failures + enumerated_errors).join("\n\n")
+      end
+
+      # @return [Array<RSpec::Expectations::ExpectationNotMetError>] The list of expectation failures.
+      def failures
+        @failure_aggregator.failures
+      end
+
+      # @return [Array<Exception>] The list of other exceptions.
+      def other_errors
+        @failure_aggregator.other_errors
+      end
+
+      # @return [Array<Exception>] The list of expectation failures and other exceptions, combined.
+      attr_reader :all_exceptions
+
+      # @return [String] The user-assigned label for the aggregation block.
+      def aggregation_block_label
+        @failure_aggregator.block_label
+      end
+
+      # @return [Hash] The metadata hash passed to `aggregate_failures`.
+      def aggregation_metadata
+        @failure_aggregator.metadata
+      end
+
+      # @return [String] A summary of the failure, including the block label and a count of failures.
+      def summary
+        "Got #{exception_count_description} from failure aggregation " \
+        "block#{block_description}"
+      end
+
+      # return [String] A description of the failure/error counts.
+      def exception_count_description
+        failure_count = pluralize("failure", failures.size)
+        return failure_count if other_errors.empty?
+        error_count = pluralize("other error", other_errors.size)
+        "#{failure_count} and #{error_count}"
+      end
+
+    private
+
+      def initialize(failure_aggregator)
+        @failure_aggregator = failure_aggregator
+        @all_exceptions = failures + other_errors
+      end
+
+      def block_description
+        return "" unless aggregation_block_label
+        " #{aggregation_block_label.inspect}"
+      end
+
+      def pluralize(noun, count)
+        "#{count} #{noun}#{'s' unless count == 1}"
+      end
+
+      def enumerated(exceptions, index_offset)
+        exceptions.each_with_index.map do |exception, index|
+          index += index_offset
+          formatted_message = "#{yield exception}\n#{format_backtrace(exception.backtrace).first}"
+          "#{index_label index}#{indented formatted_message, index}"
+        end
+      end
+
+      def exclusion_patterns
+        patterns = %w[/lib\d*/ruby/ bin/ exe/rspec /lib/bundler/ /exe/bundle:]
+        patterns << "org/jruby/" if RSpec::Support::Ruby.jruby?
+        patterns.map! { |s| Regexp.new(s.gsub('/', File::SEPARATOR)) }
+      end
+
+      def format_backtrace(backtrace)
+        backtrace.map { |l| backtrace_line(l) }.compact.tap { |filtered| filtered.concat backtrace if filtered.empty? }
+      end
+
+      def backtrace_line(line)
+        return if [Regexp.union(RSpec::CallerFilter::IGNORE_REGEX, *exclusion_patterns)].any? { |p| line =~ p }
+
+        # It changes the current path that is relative to
+        # system root to be relative to the project root.
+        line.sub(/(\A|\s)#{File.expand_path('.')}(#{File::SEPARATOR}|\s|\Z)/, '\\1.\\2'.freeze).sub(/\A([^:]+:\d+)$/, '\\1'.freeze)
+      end
+
+      def enumerated_failures
+        enumerated(failures, 0, &:message)
+      end
+
+      def enumerated_errors
+        enumerated(other_errors, failures.size) do |error|
+          "#{error.class}: #{error.message}"
+        end
+      end
+
+      def indented(failure_message, index)
+        line_1, *rest = failure_message.strip.lines.to_a
+        first_line_indentation = ' ' * (longest_index_label_width - width_of_label(index))
+
+        first_line_indentation + line_1 + rest.map do |line|
+          line =~ /\S/ ? indentation + line : line
+        end.join
+      end
+
+      def indentation
+        @indentation ||= ' ' * longest_index_label_width
+      end
+
+      def longest_index_label_width
+        @longest_index_label_width ||= width_of_label(failures.size)
+      end
+
+      def width_of_label(index)
+        index_label(index).chars.count
+      end
+
+      def index_label(index)
+        "  #{index + 1}) "
+      end
+    end
+  end
+end

data/rspec-expectations/upstream/lib/rspec/expectations/handler.rb

@@ -21,10 +21,13 @@ module RSpec
         LegacyMatcherAdapter::RSpec1.wrap(matcher) || matcher
       end
 
-      def self.setup(handler, matcher, message)
+      def self.with_matcher(handler, matcher, message)
         check_message(message)
+        matcher = modern_matcher_from(matcher)
+        yield matcher
+      ensure
         ::RSpec::Matchers.last_expectation_handler = handler
-        ::RSpec::Matchers.last_matcher = modern_matcher_from(matcher)
+        ::RSpec::Matchers.last_matcher = matcher
       end
 
       def self.handle_failure(matcher, message, failure_message_method)
@@ -41,15 +44,21 @@ module RSpec
 
     # @private
     class PositiveExpectationHandler
-      def self.handle_matcher(actual, initial_matcher, message=nil, &block)
-        matcher = ExpectationHelper.setup(self, initial_matcher, message)
+      def self.handle_matcher(actual, initial_matcher, custom_message=nil, &block)
+        ExpectationHelper.with_matcher(self, initial_matcher, custom_message) do |matcher|
+          return ::RSpec::Matchers::BuiltIn::PositiveOperatorMatcher.new(actual) unless initial_matcher
 
-        return ::RSpec::Matchers::BuiltIn::PositiveOperatorMatcher.new(actual) unless initial_matcher
-        matcher.matches?(actual, &block) || ExpectationHelper.handle_failure(matcher, message, :failure_message)
+          match_result = matcher.matches?(actual, &block)
+          if custom_message && match_result.respond_to?(:error_generator)
+            match_result.error_generator.opts[:message] = custom_message
+          end
+
+          match_result || ExpectationHelper.handle_failure(matcher, custom_message, :failure_message)
+        end
       end
 
       def self.verb
-        "should"
+        'is expected to'
       end
 
       def self.should_method
@@ -63,11 +72,17 @@ module RSpec
 
     # @private
     class NegativeExpectationHandler
-      def self.handle_matcher(actual, initial_matcher, message=nil, &block)
-        matcher = ExpectationHelper.setup(self, initial_matcher, message)
+      def self.handle_matcher(actual, initial_matcher, custom_message=nil, &block)
+        ExpectationHelper.with_matcher(self, initial_matcher, custom_message) do |matcher|
+          return ::RSpec::Matchers::BuiltIn::NegativeOperatorMatcher.new(actual) unless initial_matcher
 
-        return ::RSpec::Matchers::BuiltIn::NegativeOperatorMatcher.new(actual) unless initial_matcher
-        !(does_not_match?(matcher, actual, &block) || ExpectationHelper.handle_failure(matcher, message, :failure_message_when_negated))
+          negated_match_result = does_not_match?(matcher, actual, &block)
+          if custom_message && negated_match_result.respond_to?(:error_generator)
+            negated_match_result.error_generator.opts[:message] = custom_message
+          end
+
+          negated_match_result || ExpectationHelper.handle_failure(matcher, custom_message, :failure_message_when_negated)
+        end
       end
 
       def self.does_not_match?(matcher, actual, &block)
@@ -79,7 +94,7 @@ module RSpec
       end
 
       def self.verb
-        "should not"
+        'is expected not to'
       end
 
       def self.should_method

data/rspec-expectations/upstream/lib/rspec/expectations/minitest_integration.rb

@@ -3,15 +3,56 @@ require 'rspec/expectations'
 Minitest::Test.class_eval do
   include ::RSpec::Matchers
 
+  # This `expect` will only be called if the user is using Minitest < 5.6
+  # or if they are _not_ using Minitest::Spec on 5.6+. Minitest::Spec on 5.6+
+  # defines its own `expect` and will have the assertions incremented via our
+  # definitions of `to`/`not_to`/`to_not` below.
   def expect(*a, &b)
-    assert(true) # so each expectation gets counted in minitest's assertion stats
+    self.assertions += 1
     super
   end
+
+  # Convert a `MultipleExpectationsNotMetError` to a `Minitest::Assertion` error so
+  # it gets counted in minitest's summary stats as a failure rather than an error.
+  # It would be nice to make `MultipleExpectationsNotMetError` subclass
+  # `Minitest::Assertion`, but Minitest's implementation does not treat subclasses
+  # the same, so this is the best we can do.
+  def aggregate_failures(*args, &block)
+    super
+  rescue RSpec::Expectations::MultipleExpectationsNotMetError => e
+    assertion_failed = Minitest::Assertion.new(e.message)
+    assertion_failed.set_backtrace e.backtrace
+    raise assertion_failed
+  end
+end
+
+# Older versions of Minitest (e.g. before 5.6) do not define
+# `Minitest::Expectation`.
+if defined?(::Minitest::Expectation)
+  Minitest::Expectation.class_eval do
+    include RSpec::Expectations::ExpectationTarget::InstanceMethods
+
+    def to(*args)
+      ctx.assertions += 1
+      super
+    end
+
+    def not_to(*args)
+      ctx.assertions += 1
+      super
+    end
+
+    def to_not(*args)
+      ctx.assertions += 1
+      super
+    end
+  end
 end
 
 module RSpec
   module Expectations
     remove_const :ExpectationNotMetError
-    ExpectationNotMetError = ::Minitest::Assertion
+    # Exception raised when an expectation fails.
+    const_set :ExpectationNotMetError, ::Minitest::Assertion
   end
 end

data/rspec-expectations/upstream/lib/rspec/expectations/syntax.rb

@@ -27,7 +27,7 @@ module RSpec
 
         RSpec.deprecate(
           "Using `#{method_name}` from rspec-expectations' old `:should` syntax without explicitly enabling the syntax",
-          :replacement => "the new `:expect` syntax or explicitly enable `:should`"
+          :replacement => "the new `:expect` syntax or explicitly enable `:should` with `config.expect_with(:rspec) { |c| c.syntax = :should }`"
         )
 
         @warn_about_should = false
@@ -41,12 +41,12 @@ module RSpec
 
         syntax_host.module_exec do
           def should(matcher=nil, message=nil, &block)
-            ::RSpec::Expectations::Syntax.warn_about_should_unless_configured(__method__)
+            ::RSpec::Expectations::Syntax.warn_about_should_unless_configured(::Kernel.__method__)
             ::RSpec::Expectations::PositiveExpectationHandler.handle_matcher(self, matcher, message, &block)
           end
 
           def should_not(matcher=nil, message=nil, &block)
-            ::RSpec::Expectations::Syntax.warn_about_should_unless_configured(__method__)
+            ::RSpec::Expectations::Syntax.warn_about_should_unless_configured(::Kernel.__method__)
             ::RSpec::Expectations::NegativeExpectationHandler.handle_matcher(self, matcher, message, &block)
           end
         end
@@ -106,7 +106,7 @@ if defined?(BasicObject)
   # that this syntax does not always play nice with delegate/proxy objects.
   # We recommend you use the non-monkeypatching `:expect` syntax instead.
   class BasicObject
-    # @method should
+    # @method should(matcher, message)
     # Passes if `matcher` returns true.  Available on every `Object`.
     # @example
     #   actual.should eq expected
@@ -118,7 +118,7 @@ if defined?(BasicObject)
     # @note This is only available when you have enabled the `:should` syntax.
     # @see RSpec::Matchers
 
-    # @method should_not
+    # @method should_not(matcher, message)
     # Passes if `matcher` returns false.  Available on every `Object`.
     # @example
     #   actual.should_not eq expected

data/rspec-expectations/upstream/lib/rspec/expectations/version.rb

@@ -2,7 +2,7 @@ module RSpec
   module Expectations
     # @private
     module Version
-      STRING = '3.1.2'
+      STRING = '3.13.0.pre'
     end
   end
 end

data/rspec-expectations/upstream/lib/rspec/expectations.rb

@@ -1,6 +1,7 @@
 require 'rspec/support'
 RSpec::Support.require_rspec_support "caller_filter"
 RSpec::Support.require_rspec_support "warnings"
+RSpec::Support.require_rspec_support "object_formatter"
 
 require 'rspec/matchers'
 
@@ -63,6 +64,19 @@ module RSpec
     # the user sets an expectation, it can't be caught in their
     # code by a bare `rescue`.
     # @api public
-    ExpectationNotMetError = Class.new(::Exception)
+    class ExpectationNotMetError < Exception
+    end
+
+    # Exception raised from `aggregate_failures` when multiple expectations fail.
+    #
+    # @note The constant is defined here but the extensive logic of this class
+    #   is lazily defined when `FailureAggregator` is autoloaded, since we do
+    #   not need to waste time defining that functionality unless
+    #   `aggregate_failures` is used.
+    class MultipleExpectationsNotMetError < ExpectationNotMetError
+    end
+
+    autoload :BlockSnippetExtractor, "rspec/expectations/block_snippet_extractor"
+    autoload :FailureAggregator,     "rspec/expectations/failure_aggregator"
   end
 end

data/rspec-expectations/upstream/lib/rspec/matchers/built_in/all.rb

@@ -73,6 +73,7 @@ module RSpec
 
         def initialize_copy(other)
           @matcher = @matcher.clone
+          @failed_objects = @failed_objects.clone
           super
         end
 

data/rspec-expectations/upstream/lib/rspec/matchers/built_in/base_matcher.rb

@@ -8,11 +8,10 @@ module RSpec
       #
       # ### Warning:
       #
-      # This class is for internal use, and subject to change without notice.  We
-      # strongly recommend that you do not base your custom matchers on this
+      # This class is for internal use, and subject to change without notice.
+      # We strongly recommend that you do not base your custom matchers on this
       # class. If/when this changes, we will announce it and remove this warning.
       class BaseMatcher
-        include RSpec::Matchers::Pretty
         include RSpec::Matchers::Composable
 
         # @api private
@@ -23,6 +22,9 @@ module RSpec
         # @private
         attr_reader :actual, :expected, :rescued_exception
 
+        # @private
+        attr_writer :matcher_name
+
         def initialize(expected=UNDEFINED)
           @expected = expected unless UNDEFINED.equal?(expected)
         end
@@ -53,11 +55,12 @@ module RSpec
         end
 
         # @api private
-        # Generates a "pretty" description using the logic in {Pretty}.
+        # Generates a description using {EnglishPhrasing}.
         # @return [String]
         def description
-          return name_to_sentence unless defined?(@expected)
-          "#{name_to_sentence}#{to_sentence @expected}"
+          desc = EnglishPhrasing.split_words(self.class.matcher_name)
+          desc << EnglishPhrasing.list(@expected) if defined?(@expected)
+          desc
         end
 
         # @api private
@@ -75,26 +78,89 @@ module RSpec
           false
         end
 
+        # @private
+        def supports_value_expectations?
+          true
+        end
+
         # @api private
         def expects_call_stack_jump?
           false
         end
 
+        # @private
+        def expected_formatted
+          RSpec::Support::ObjectFormatter.format(@expected)
+        end
+
+        # @private
+        def actual_formatted
+          RSpec::Support::ObjectFormatter.format(@actual)
+        end
+
+        # @private
+        def self.matcher_name
+          @matcher_name ||= underscore(name.split('::').last)
+        end
+
+        # @private
+        def matcher_name
+          if defined?(@matcher_name)
+            @matcher_name
+          else
+            self.class.matcher_name
+          end
+        end
+
+        # @private
+        # Borrowed from ActiveSupport.
+        def self.underscore(camel_cased_word)
+          word = camel_cased_word.to_s.dup
+          word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+          word.tr!('-', '_')
+          word.downcase!
+          word
+        end
+        private_class_method :underscore
+
       private
 
         def assert_ivars(*expected_ivars)
           return unless (expected_ivars - present_ivars).any?
-          raise "#{self.class.name} needs to supply#{to_sentence expected_ivars}"
+          ivar_list = EnglishPhrasing.list(expected_ivars)
+          raise "#{self.class.name} needs to supply#{ivar_list}"
         end
 
         if RUBY_VERSION.to_f < 1.9
+          # :nocov:
           def present_ivars
-            instance_variables.map { |v| v.to_sym }
+            instance_variables.map(&:to_sym)
           end
+          # :nocov:
         else
           alias present_ivars instance_variables
         end
 
+        # @private
+        module HashFormatting
+          # `{ :a => 5, :b => 2 }.inspect` produces:
+          #
+          #     {:a=>5, :b=>2}
+          #
+          # ...but it looks much better as:
+          #
+          #     {:a => 5, :b => 2}
+          #
+          # This is idempotent and safe to run on a string multiple times.
+          def improve_hash_formatting(inspect_string)
+            inspect_string.gsub(/(\S)=>(\S)/, '\1 => \2')
+          end
+          module_function :improve_hash_formatting
+        end
+
+        include HashFormatting
+
         # @api private
         # Provides default implementations of failure messages, based on the `description`.
         module DefaultFailureMessages
@@ -104,7 +170,7 @@ module RSpec
           # you often only need to override `description`.
           # @return [String]
           def failure_message
-            "expected #{actual.inspect} to #{description}"
+            "expected #{description_of @actual} to #{description}".dup
           end
 
           # @api private
@@ -113,13 +179,13 @@ module RSpec
           # you often only need to override `description`.
           # @return [String]
           def failure_message_when_negated
-            "expected #{actual.inspect} not to #{description}"
+            "expected #{description_of @actual} not to #{description}".dup
           end
 
           # @private
           def self.has_default_failure_messages?(matcher)
             matcher.method(:failure_message).owner == self &&
-            matcher.method(:failure_message_when_negated).owner == self
+              matcher.method(:failure_message_when_negated).owner == self
           rescue NameError
             false
           end