opal-rspec 0.8.0 → 1.0.0

data/rspec-expectations/upstream/features/test_frameworks/minitest.feature

@@ -36,9 +36,76 @@ Feature: Minitest integration
         def test_custom_matcher_with_deprecation_warning
           expect(1).to be_an_int
         end
+
+        def test_using_aggregate_failures
+          aggregate_failures do
+            expect(1).to be_even
+            expect(2).to be_odd
+          end
+        end
       end
       """
      When I run `ruby rspec_expectations_test.rb`
-     Then the output should contain "3 runs, 3 assertions, 1 failures, 0 errors"
-      And the output should contain "expected `[1, 2].empty?` to return true, got false"
+     Then the output should contain "4 runs, 5 assertions, 2 failures, 0 errors"
+      And the output should contain "expected `[1, 2].empty?` to be truthy, got false"
       And the output should contain "be_an_int is deprecated"
+      And the output should contain "Got 2 failures from failure aggregation block"
+
+  Scenario: use rspec/expectations with minitest/spec
+    Given a file named "rspec_expectations_spec.rb" with:
+      """ruby
+      require 'minitest/autorun'
+      require 'minitest/spec'
+      require 'rspec/expectations/minitest_integration'
+
+      describe "Using RSpec::Expectations with Minitest::Spec" do
+        RSpec::Matchers.define :be_an_integer do
+          match { |actual| Integer === actual }
+        end
+
+        it 'passes an expectation' do
+          expect(1 + 3).to eq 4
+        end
+
+        it 'fails an expectation' do
+          expect([1, 2]).to be_empty
+        end
+
+        it 'passes a block expectation' do
+          expect { 1 / 0 }.to raise_error(ZeroDivisionError)
+        end
+
+        it 'fails a block expectation' do
+          expect { 1 / 1 }.to raise_error(ZeroDivisionError)
+        end
+
+        it 'passes a negative expectation (using `not_to`)' do
+          expect(1).not_to eq 2
+        end
+
+        it 'fails a negative expectation (using `to_not`)' do
+          expect(1).to_not eq 1
+        end
+
+        it 'fails multiple expectations' do
+          aggregate_failures do
+            expect(1).to be_even
+            expect(2).to be_odd
+          end
+        end
+
+        it 'passes a minitest expectation' do
+          expect(1 + 3).must_equal 4
+        end
+
+        it 'fails a minitest expectation' do
+          expect([1, 2]).must_be :empty?
+        end
+      end
+      """
+     When I run `ruby rspec_expectations_spec.rb`
+     Then the output should contain "9 runs, 10 assertions, 5 failures, 0 errors"
+      And the output should contain "expected `[1, 2].empty?` to be truthy, got false"
+      And the output should contain "expected ZeroDivisionError but nothing was raised"
+      And the output should contain "Got 2 failures from failure aggregation block"
+      And the output should contain "Expected [1, 2] to be empty?"

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

@@ -0,0 +1,253 @@
+module RSpec
+  module Expectations
+    # @private
+    class BlockSnippetExtractor # rubocop:disable Metrics/ClassLength
+      # rubocop should properly handle `Struct.new {}` as an inner class definition.
+
+      attr_reader :proc, :method_name
+
+      def self.try_extracting_single_line_body_of(proc, method_name)
+        lines = new(proc, method_name).body_content_lines
+        return nil unless lines.count == 1
+        lines.first
+      rescue Error
+        nil
+      end
+
+      def initialize(proc, method_name)
+        @proc = proc
+        @method_name = method_name.to_s.freeze
+      end
+
+      # Ideally we should properly handle indentations of multiline snippet,
+      # but it's not implemented yet since because we use result of this method only when it's a
+      # single line and implementing the logic introduces additional complexity.
+      def body_content_lines
+        raw_body_lines.map(&:strip).reject(&:empty?)
+      end
+
+    private
+
+      def raw_body_lines
+        raw_body_snippet.split("\n")
+      end
+
+      def raw_body_snippet
+        block_token_extractor.body_tokens.map(&:string).join
+      end
+
+      def block_token_extractor
+        @block_token_extractor ||= BlockTokenExtractor.new(method_name, source, beginning_line_number)
+      end
+
+      if RSpec.respond_to?(:world)
+        def source
+          raise TargetNotFoundError unless File.exist?(file_path)
+          RSpec.world.source_from_file(file_path)
+        end
+      else
+        RSpec::Support.require_rspec_support 'source'
+        def source
+          raise TargetNotFoundError unless File.exist?(file_path)
+          @source ||= RSpec::Support::Source.from_file(file_path)
+        end
+      end
+
+      def file_path
+        source_location.first
+      end
+
+      def beginning_line_number
+        source_location.last
+      end
+
+      def source_location
+        proc.source_location || raise(TargetNotFoundError)
+      end
+
+      Error = Class.new(StandardError)
+      TargetNotFoundError = Class.new(Error)
+      AmbiguousTargetError = Class.new(Error)
+
+      # @private
+      # Performs extraction of block body snippet using tokens,
+      # which cannot be done with node information.
+      BlockTokenExtractor = Struct.new(:method_name, :source, :beginning_line_number) do
+        attr_reader :state, :body_tokens
+
+        def initialize(*)
+          super
+          parse!
+        end
+
+        private
+
+        def parse!
+          @state = :initial
+
+          catch(:finish) do
+            source.tokens.each do |token|
+              invoke_state_handler(token)
+            end
+          end
+        end
+
+        def finish!
+          throw :finish
+        end
+
+        def invoke_state_handler(token)
+          __send__("#{state}_state", token)
+        end
+
+        def initial_state(token)
+          @state = :after_method_call if token.location == block_locator.method_call_location
+        end
+
+        def after_method_call_state(token)
+          @state = :after_opener if handle_opener_token(token)
+        end
+
+        def after_opener_state(token)
+          if handle_closer_token(token)
+            finish_or_find_next_block_if_incorrect!
+          elsif pipe_token?(token)
+            finalize_pending_tokens!
+            @state = :after_beginning_of_args
+          else
+            pending_tokens << token
+            handle_opener_token(token)
+            @state = :after_beginning_of_body unless token.type == :on_sp
+          end
+        end
+
+        def after_beginning_of_args_state(token)
+          @state = :after_beginning_of_body if pipe_token?(token)
+        end
+
+        def after_beginning_of_body_state(token)
+          if handle_closer_token(token)
+            finish_or_find_next_block_if_incorrect!
+          else
+            pending_tokens << token
+            handle_opener_token(token)
+          end
+        end
+
+        def pending_tokens
+          @pending_tokens ||= []
+        end
+
+        def finalize_pending_tokens!
+          pending_tokens.freeze.tap do
+            @pending_tokens = nil
+          end
+        end
+
+        def finish_or_find_next_block_if_incorrect!
+          body_tokens = finalize_pending_tokens!
+
+          if correct_block?(body_tokens)
+            @body_tokens = body_tokens
+            finish!
+          else
+            @state = :after_method_call
+          end
+        end
+
+        def handle_opener_token(token)
+          opener_token?(token).tap do |boolean|
+            opener_token_stack.push(token) if boolean
+          end
+        end
+
+        def opener_token?(token)
+          token.type == :on_lbrace || (token.type == :on_kw && token.string == 'do')
+        end
+
+        def handle_closer_token(token)
+          if opener_token_stack.last.closed_by?(token)
+            opener_token_stack.pop
+            opener_token_stack.empty?
+          else
+            false
+          end
+        end
+
+        def opener_token_stack
+          @opener_token_stack ||= []
+        end
+
+        def pipe_token?(token)
+          token.type == :on_op && token.string == '|'
+        end
+
+        def correct_block?(body_tokens)
+          return true if block_locator.body_content_locations.empty?
+          content_location = block_locator.body_content_locations.first
+          content_location.between?(body_tokens.first.location, body_tokens.last.location)
+        end
+
+        def block_locator
+          @block_locator ||= BlockLocator.new(method_name, source, beginning_line_number)
+        end
+      end
+
+      # @private
+      # Locates target block with node information (semantics), which tokens don't have.
+      BlockLocator = Struct.new(:method_name, :source, :beginning_line_number) do
+        def method_call_location
+          @method_call_location ||= method_ident_node.location
+        end
+
+        def body_content_locations
+          @body_content_locations ||= block_body_node.map(&:location).compact
+        end
+
+        private
+
+        def method_ident_node
+          method_call_node = block_wrapper_node.children.first
+          method_call_node.find do |node|
+            method_ident_node?(node)
+          end
+        end
+
+        def block_body_node
+          block_node = block_wrapper_node.children[1]
+          block_node.children.last
+        end
+
+        def block_wrapper_node
+          case candidate_block_wrapper_nodes.size
+          when 1
+            candidate_block_wrapper_nodes.first
+          when 0
+            raise TargetNotFoundError
+          else
+            raise AmbiguousTargetError
+          end
+        end
+
+        def candidate_block_wrapper_nodes
+          @candidate_block_wrapper_nodes ||= candidate_method_ident_nodes.map do |method_ident_node|
+            block_wrapper_node = method_ident_node.each_ancestor.find { |node| node.type == :method_add_block }
+            next nil unless block_wrapper_node
+            method_call_node = block_wrapper_node.children.first
+            method_call_node.include?(method_ident_node) ? block_wrapper_node : nil
+          end.compact
+        end
+
+        def candidate_method_ident_nodes
+          source.nodes_by_line_number[beginning_line_number].select do |node|
+            method_ident_node?(node)
+          end
+        end
+
+        def method_ident_node?(node)
+          node.type == :@ident && node.args.first == method_name
+        end
+      end
+    end
+  end
+end

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

@@ -18,6 +18,19 @@ module RSpec
     #
     #   RSpec::Expectations.configuration
     class Configuration
+      # @private
+      FALSE_POSITIVE_BEHAVIOURS =
+        {
+          :warn    => lambda { |message| RSpec.warning message },
+          :raise   => lambda { |message| raise ArgumentError, message },
+          :nothing => lambda { |_| true },
+        }
+
+      def initialize
+        @on_potential_false_positives = :warn
+        @strict_predicate_matchers = false
+      end
+
       # Configures the supported syntax.
       # @param [Array<Symbol>, Symbol] values the syntaxes to enable
       # @example
@@ -44,6 +57,20 @@ module RSpec
         end
       end
 
+      # Configures the maximum character length that RSpec will print while
+      # formatting an object. You can set length to nil to prevent RSpec from
+      # doing truncation.
+      # @param [Fixnum] length the number of characters to limit the formatted output to.
+      # @example
+      #   RSpec.configure do |rspec|
+      #     rspec.expect_with :rspec do |c|
+      #       c.max_formatted_output_length = 200
+      #     end
+      #   end
+      def max_formatted_output_length=(length)
+        RSpec::Support::ObjectFormatter.default_instance.max_formatted_output_length = length
+      end
+
       # The list of configured syntaxes.
       # @return [Array<Symbol>] the list of configured syntaxes.
       # @example
@@ -71,7 +98,7 @@ module RSpec
         # Delegates to rspec-core's color option if rspec-core
         # is loaded; otherwise you can set it here.
         def color?
-          @color
+          defined?(@color) && @color
         end
       end
 
@@ -133,6 +160,62 @@ module RSpec
           backtrace
         end
       end
+
+      # Configures whether RSpec will warn about matcher use which will
+      # potentially cause false positives in tests.
+      #
+      # @param [Boolean] boolean
+      def warn_about_potential_false_positives=(boolean)
+        if boolean
+          self.on_potential_false_positives = :warn
+        elsif warn_about_potential_false_positives?
+          self.on_potential_false_positives = :nothing
+        else
+          # no-op, handler is something else
+        end
+      end
+      #
+      # Configures what RSpec will do about matcher use which will
+      # potentially cause false positives in tests.
+      #
+      # @param [Symbol] behavior can be set to :warn, :raise or :nothing
+      def on_potential_false_positives=(behavior)
+        unless FALSE_POSITIVE_BEHAVIOURS.key?(behavior)
+          raise ArgumentError, "Supported values are: #{FALSE_POSITIVE_BEHAVIOURS.keys}"
+        end
+        @on_potential_false_positives = behavior
+      end
+
+      # Configures RSpec to check predicate matchers to `be(true)` / `be(false)` (strict),
+      # or `be_truthy` / `be_falsey` (not strict).
+      # Historically, the default was `false`, but `true` is recommended.
+      def strict_predicate_matchers=(flag)
+        raise ArgumentError, "Pass `true` or `false`" unless flag == true || flag == false
+        @strict_predicate_matchers = flag
+      end
+
+      attr_reader :strict_predicate_matchers
+
+      def strict_predicate_matchers?
+        @strict_predicate_matchers
+      end
+
+      # Indicates what RSpec will do about matcher use which will
+      # potentially cause false positives in tests, generally you want to
+      # avoid such scenarios so this defaults to `true`.
+      attr_reader :on_potential_false_positives
+
+      # Indicates whether RSpec will warn about matcher use which will
+      # potentially cause false positives in tests, generally you want to
+      # avoid such scenarios so this defaults to `true`.
+      def warn_about_potential_false_positives?
+        on_potential_false_positives == :warn
+      end
+
+      # @private
+      def false_positives_handler
+        FALSE_POSITIVE_BEHAVIOURS.fetch(@on_potential_false_positives)
+      end
     end
 
     # The configuration object.

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

@@ -21,6 +21,12 @@ module RSpec
       # `nil` is a valid value to pass.
       UndefinedValue = Module.new
 
+      # @note this name aligns with `Minitest::Expectation` so that our
+      #   {InstanceMethods} module can be included in that class when
+      #   used in a Minitest context.
+      # @return [Object] the target of the expectation
+      attr_reader :target
+
       # @api private
       def initialize(value)
         @target = value
@@ -36,43 +42,89 @@ module RSpec
         elsif block
           raise ArgumentError, "You cannot pass both an argument and a block to `expect`."
         else
-          new(value)
+          ValueExpectationTarget.new(value)
+        end
+      end
+
+      # Defines instance {ExpectationTarget} instance methods. These are defined
+      # in a module so we can include it in `Minitest::Expectation` when
+      # `rspec/expectations/minitest_integration` is loaded in order to
+      # support usage with Minitest.
+      module InstanceMethods
+        # Runs the given expectation, passing if `matcher` returns true.
+        # @example
+        #   expect(value).to eq(5)
+        #   expect { perform }.to raise_error
+        # @param [Matcher]
+        #   matcher
+        # @param [String, Proc] message optional message to display when the expectation fails
+        # @return [Boolean] true if the expectation succeeds (else raises)
+        # @see RSpec::Matchers
+        def to(matcher=nil, message=nil, &block)
+          prevent_operator_matchers(:to) unless matcher
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(target, matcher, message, &block)
+        end
+
+        # Runs the given expectation, passing if `matcher` returns false.
+        # @example
+        #   expect(value).not_to eq(5)
+        # @param [Matcher]
+        #   matcher
+        # @param [String, Proc] message optional message to display when the expectation fails
+        # @return [Boolean] false if the negative expectation succeeds (else raises)
+        # @see RSpec::Matchers
+        def not_to(matcher=nil, message=nil, &block)
+          prevent_operator_matchers(:not_to) unless matcher
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(target, matcher, message, &block)
+        end
+        alias to_not not_to
+
+      private
+
+        def prevent_operator_matchers(verb)
+          raise ArgumentError, "The expect syntax does not support operator matchers, " \
+                               "so you must pass a matcher to `##{verb}`."
         end
       end
 
-      # Runs the given expectation, passing if `matcher` returns true.
-      # @example
-      #   expect(value).to eq(5)
-      #   expect { perform }.to raise_error
-      # @param [Matcher]
-      #   matcher
-      # @param [String or Proc] message optional message to display when the expectation fails
-      # @return [Boolean] true if the expectation succeeds (else raises)
-      # @see RSpec::Matchers
+      include InstanceMethods
+    end
+
+    # @private
+    # Validates the provided matcher to ensure it supports block
+    # expectations, in order to avoid user confusion when they
+    # use a block thinking the expectation will be on the return
+    # value of the block rather than the block itself.
+    class ValueExpectationTarget < ExpectationTarget
       def to(matcher=nil, message=nil, &block)
-        prevent_operator_matchers(:to) unless matcher
-        RSpec::Expectations::PositiveExpectationHandler.handle_matcher(@target, matcher, message, &block)
+        enforce_value_expectation(matcher)
+        super
       end
 
-      # Runs the given expectation, passing if `matcher` returns false.
-      # @example
-      #   expect(value).not_to eq(5)
-      # @param [Matcher]
-      #   matcher
-      # @param [String or Proc] message optional message to display when the expectation fails
-      # @return [Boolean] false if the negative expectation succeeds (else raises)
-      # @see RSpec::Matchers
       def not_to(matcher=nil, message=nil, &block)
-        prevent_operator_matchers(:not_to) unless matcher
-        RSpec::Expectations::NegativeExpectationHandler.handle_matcher(@target, matcher, message, &block)
+        enforce_value_expectation(matcher)
+        super
       end
-      alias to_not not_to
 
     private
 
-      def prevent_operator_matchers(verb)
-        raise ArgumentError, "The expect syntax does not support operator matchers, " \
-                             "so you must pass a matcher to `##{verb}`."
+      def enforce_value_expectation(matcher)
+        return if supports_value_expectations?(matcher)
+
+        RSpec.deprecate(
+          "expect(value).to #{RSpec::Support::ObjectFormatter.format(matcher)}",
+          :message =>
+            "The implicit block expectation syntax is deprecated, you should pass " \
+            "a block rather than an argument to `expect` to use the provided " \
+            "block expectation matcher or the matcher must implement " \
+            "`supports_value_expectations?`. e.g  `expect { value }.to " \
+            "#{RSpec::Support::ObjectFormatter.format(matcher)}` not " \
+            "`expect(value).to #{RSpec::Support::ObjectFormatter.format(matcher)}`"
+        )
+      end
+
+      def supports_value_expectations?(matcher)
+        !matcher.respond_to?(:supports_value_expectations?) || matcher.supports_value_expectations?
       end
     end
 
@@ -98,21 +150,13 @@ module RSpec
       def enforce_block_expectation(matcher)
         return if supports_block_expectations?(matcher)
 
-        raise ExpectationNotMetError, "You must pass an argument rather than " \
-          "a block to use the provided matcher (#{description_of matcher}), or " \
-          "the matcher must implement `supports_block_expectations?`."
+        raise ExpectationNotMetError, "You must pass an argument rather than a block to `expect` to use the provided " \
+          "matcher (#{RSpec::Support::ObjectFormatter.format(matcher)}), or the matcher must implement " \
+          "`supports_block_expectations?`."
       end
 
       def supports_block_expectations?(matcher)
-        matcher.supports_block_expectations?
-      rescue NoMethodError
-        false
-      end
-
-      def description_of(matcher)
-        matcher.description
-      rescue NoMethodError
-        matcher.inspect
+        matcher.respond_to?(:supports_block_expectations?) && matcher.supports_block_expectations?
       end
     end
   end

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

@@ -1,12 +1,18 @@
-RSpec::Support.require_rspec_support 'differ'
-
 module RSpec
   module Expectations
     class << self
+      # @private
+      class Differ
+        # @private
+        OBJECT_PREPARER = lambda do |object|
+          RSpec::Matchers::Composable.surface_descriptions_in(object)
+        end
+      end
+
       # @private
       def differ
         RSpec::Support::Differ.new(
-          :object_preparer => lambda { |object| RSpec::Matchers::Composable.surface_descriptions_in(object) },
+          :object_preparer => Differ::OBJECT_PREPARER,
           :color => RSpec::Matchers.configuration.color?
         )
       end
@@ -24,10 +30,9 @@ module RSpec
                                "appropriate failure_message[_when_negated] method to return a string?"
         end
 
-        diff = differ.diff(actual, expected)
-        message = "#{message}\nDiff:#{diff}" unless diff.empty?
+        message = ::RSpec::Matchers::ExpectedsForMultipleDiffs.from(expected).message_with_diff(message, differ, actual)
 
-        raise RSpec::Expectations::ExpectationNotMetError, message
+        RSpec::Support.notify_failure(RSpec::Expectations::ExpectationNotMetError.new message)
       end
     end
   end