rspec-expectations 3.0.0.beta1 → 3.0.0.beta2

data/features/test_frameworks/{test_unit.feature → minitest.feature}

@@ -1,18 +1,18 @@
-Feature: Test::Unit integration
+Feature: Minitest integration
 
-  RSpec-expectations is a stand-alone gem that can be used without the rest of
-  RSpec. If you like the way Test::Unit (or MiniTest) organizes tests, but
-  prefer RSpec's approach to expressing expectations, you can have both.
+  rspec-expectations is a stand-alone gem that can be used without the rest of
+  RSpec. If you like minitest as your test runner, but prefer RSpec's
+  approach to expressing expectations, you can have both.
 
-  The one downside is that failures are reported as errors with MiniTest.
+  To integrate rspec-expectations with minitest, require `rspec/expectations/minitest_integration`.
 
-  Scenario: use rspec/expectations with Test::Unit
+  Scenario: use rspec/expectations with minitest
     Given a file named "rspec_expectations_test.rb" with:
       """ruby
-      require 'test/unit'
-      require 'rspec/expectations'
+      require 'minitest/autorun'
+      require 'rspec/expectations/minitest_integration'
 
-      class RSpecExpectationsTest < Test::Unit::TestCase
+      class RSpecExpectationsTest < Minitest::Test
         RSpec::Matchers.define :be_an_integer do
           match { |actual| Integer === actual }
         end
@@ -30,7 +30,7 @@ Feature: Test::Unit integration
         end
 
         def test_failing_expectation
-          expect([1,2]).to be_empty
+          expect([1, 2]).to be_empty
         end
 
         def test_custom_matcher_with_deprecation_warning
@@ -39,6 +39,6 @@ Feature: Test::Unit integration
       end
       """
      When I run `ruby rspec_expectations_test.rb`
-     Then the output should contain "3 tests, 0 assertions, 0 failures, 1 errors" or "3 tests, 0 assertions, 1 failures, 0 errors"
+     Then the output should contain "3 runs, 3 assertions, 1 failures, 0 errors"
       And the output should contain "expected empty? to return true, got false"
       And the output should contain "be_an_int is deprecated"

data/lib/rspec/expectations.rb

@@ -1,42 +1,49 @@
 require 'rspec/support/caller_filter'
 require 'rspec/support/warnings'
 
-require 'rspec/expectations/extensions'
 require 'rspec/matchers'
 require 'rspec/expectations/expectation_target'
 require 'rspec/matchers/configuration'
 require 'rspec/expectations/fail_with'
-require 'rspec/expectations/errors'
 require 'rspec/expectations/handler'
 require 'rspec/expectations/version'
-require 'rspec/expectations/differ'
+require 'rspec/expectations/diff_presenter'
 
 module RSpec
-  # RSpec::Expectations adds two instance methods to every object:
+  # RSpec::Expectations provides a simple, readable API to express
+  # the expected outcomes in a code example. To express an expected
+  # outcome, wrap an object or block in `expect`, call `to` or `to_not`
+  # (aliased as `not_to`) and pass it a matcher object:
   #
-  #     should(matcher=nil)
-  #     should_not(matcher=nil)
+  #     expect(order.total).to eq(Money.new(5.55, :USD))
+  #     expect(list).to include(user)
+  #     expect(message).not_to match(/foo/)
+  #     expect { do_something }.to raise_error
   #
-  # Both methods take an optional matcher object (See
-  # [RSpec::Matchers](../RSpec/Matchers)).  When `should` is invoked with a
-  # matcher, it turns around and calls `matcher.matches?(self)`.  For example,
+  # The last form (the block form) is needed to match against ruby constructs
+  # that are not objects, but can only be observed when executing a block
+  # of code. This includes raising errors, throwing symbols, yielding,
+  # and changing values.
+  #
+  # When `expect(...).to` is invoked with a matcher, it turns around
+  # and calls `matcher.matches?(<object wrapped by expect>)`.  For example,
   # in the expression:
   #
-  #     order.total.should eq(Money.new(5.55, :USD))
+  #     expect(order.total).to eq(Money.new(5.55, :USD))
   #
-  # the `should` method invokes the equivalent of `eq.matches?(order.total)`. If
-  # `matches?` returns true, the expectation is met and execution continues. If
-  # `false`, then the spec fails with the message returned by
-  # `eq.failure_message_for_should`.
+  # ...`eq(Money.new(5.55, :USD))` returns a matcher object, and it results
+  # in the equivalent of `eq.matches?(order.total)`. If `matches?` returns
+  # `true`, the expectation is met and execution continues. If `false`, then
+  # the spec fails with the message returned by `eq.failure_message`.
   #
   # Given the expression:
   #
-  #     order.entries.should_not include(entry)
+  #     expect(order.entries).not_to include(entry)
   #
-  # the `should_not` method invokes the equivalent of
+  # ...the `not_to` method (also available as `to_not`) invokes the equivalent of
   # `include.matches?(order.entries)`, but it interprets `false` as success, and
   # `true` as a failure, using the message generated by
-  # `eq.failure_message_for_should_not`.
+  # `eq.failure_message_when_negated`.
   #
   # rspec-expectations ships with a standard set of useful matchers, and writing
   # your own matchers is quite simple.
@@ -45,31 +52,13 @@ module RSpec
   # built-in matchers that ship with rspec-expectations, and how to write your
   # own custom matchers.
   module Expectations
-
-    # @api private
-    KERNEL_METHOD_METHOD = ::Kernel.instance_method(:method)
-
-    # @api private
+    # Exception raised when an expectation fails.
     #
-    # 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)
-    if RUBY_VERSION.to_i >= 2
-      def self.method_handle_for(object, method_name)
-        KERNEL_METHOD_METHOD.bind(object).call(method_name)
-      end
-    else
-      def self.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
+    # @note We subclass Exception so that in a stub implementation if
+    # the user sets an expectation, it can't be caught in their
+    # code by a bare `rescue`.
+    # @api public
+    ExpectationNotMetError = Class.new(::Exception)
   end
 end
+

data/lib/rspec/expectations/diff_presenter.rb

@@ -0,0 +1,141 @@
+require 'diff/lcs'
+require "rspec/expectations/encoded_string"
+require "rspec/expectations/differ"
+require 'diff/lcs/hunk'
+require 'pp'
+
+module RSpec
+  module Expectations
+    class DiffPresenter
+      def diff_as_string(actual, expected)
+        @encoding = pick_encoding actual, expected
+
+        @actual   = EncodedString.new(actual, @encoding)
+        @expected = EncodedString.new(expected, @encoding)
+
+        output = EncodedString.new("\n", @encoding)
+
+        hunks.each_cons(2) do |prev_hunk, current_hunk|
+          begin
+            if current_hunk.overlaps?(prev_hunk)
+              add_old_hunk_to_hunk(current_hunk, prev_hunk)
+            else
+              add_to_output(output, prev_hunk.diff(format).to_s)
+            end
+          ensure
+            add_to_output(output, "\n")
+          end
+        end
+
+        if hunks.last
+          finalize_output(output, hunks.last.diff(format).to_s)
+        end
+
+        color_diff output
+      rescue Encoding::CompatibilityError
+        handle_encoding_errors
+      end
+
+      def diff_as_object(actual, expected)
+        actual_as_string = object_to_string(actual)
+        expected_as_string = object_to_string(expected)
+        diff_as_string(actual_as_string, expected_as_string)
+      end
+
+    private
+
+      def hunks
+        @hunks ||= Differ.new(@actual, @expected).hunks
+      end
+
+      def finalize_output(output, final_line)
+        add_to_output(output, final_line)
+        add_to_output(output, "\n")
+      end
+
+      def add_to_output(output, string)
+        output << string
+      end
+
+      def add_old_hunk_to_hunk(hunk, oldhunk)
+        hunk.merge(oldhunk)
+      end
+
+      def format
+        :unified
+      end
+
+      def color(text, color_code)
+        "\e[#{color_code}m#{text}\e[0m"
+      end
+
+      def red(text)
+        color(text, 31)
+      end
+
+      def green(text)
+        color(text, 32)
+      end
+
+      def blue(text)
+        color(text, 34)
+      end
+
+      def normal(text)
+        color(text, 0)
+      end
+
+      def color_diff(diff)
+        return diff unless RSpec::Matchers.configuration.color?
+
+        diff.lines.map { |line|
+          case line[0].chr
+          when "+"
+            green line
+          when "-"
+            red line
+          when "@"
+            line[1].chr == "@" ? blue(line) : normal(line)
+          else
+            normal(line)
+          end
+        }.join
+      end
+
+      def object_to_string(object)
+        object = Matchers::Composable.surface_descriptions_in(object)
+        case object
+        when Hash
+          object.keys.sort_by { |k| k.to_s }.map do |key|
+            pp_key   = PP.singleline_pp(key, "")
+            pp_value = PP.singleline_pp(object[key], "")
+
+            "#{pp_key} => #{pp_value},"
+          end.join("\n")
+        when String
+          object =~ /\n/ ? object : object.inspect
+        else
+          PP.pp(object,"")
+        end
+      end
+
+      if String.method_defined?(:encoding)
+        def pick_encoding(source_a, source_b)
+          Encoding.compatible?(source_a, source_b) || Encoding.default_external
+        end
+      else
+        def pick_encoding(source_a, source_b)
+        end
+      end
+
+      def handle_encoding_errors
+        if @actual.source_encoding != @expected.source_encoding
+          "Could not produce a diff because the encoding of the actual string (#{@actual.source_encoding}) "+
+            "differs from the encoding of the expected string (#{@expected.source_encoding})"
+        else
+          "Could not produce a diff because of the encoding of the string (#{@expected.source_encoding})"
+        end
+      end
+    end
+  end
+end

data/lib/rspec/expectations/differ.rb

@@ -1,154 +1,44 @@
-require 'diff/lcs'
-require 'diff/lcs/hunk'
-require 'pp'
-
 module RSpec
   module Expectations
     class Differ
-
-      # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
-      def diff_as_string(input_data_new, input_data_old)
-        encoding = pick_encoding input_data_new, input_data_old
-        output = matching_encoding("", encoding)
-        data_old = input_data_old.split(matching_encoding("\n", encoding)).map! { |e| e.chomp }
-        data_new = input_data_new.split(matching_encoding("\n", encoding)).map! { |e| e.chomp }
-        diffs = Diff::LCS.diff(data_old, data_new)
-        return output if diffs.empty?
-        oldhunk = hunk = nil
-        file_length_difference = 0
-        diffs.each do |piece|
-          begin
-            hunk = Diff::LCS::Hunk.new(
-              data_old, data_new, piece, context_lines, file_length_difference
-            )
-            file_length_difference = hunk.file_length_difference
-            next unless oldhunk
-            # Hunks may overlap, which is why we need to be careful when our
-            # diff includes lines of context. Otherwise, we might print
-            # redundant lines.
-            if (context_lines > 0) and hunk.overlaps?(oldhunk)
-              if hunk.respond_to?(:merge)
-                # diff-lcs 1.2.x
-                hunk.merge(oldhunk)
-              else
-                # diff-lcs 1.1.3
-                hunk.unshift(oldhunk)
-              end
-            else
-              output << matching_encoding(oldhunk.diff(format).to_s, encoding)
-            end
-          ensure
-            oldhunk = hunk
-            output << matching_encoding("\n", encoding)
-          end
-        end
-        #Handle the last remaining hunk
-        output << matching_encoding(oldhunk.diff(format).to_s, encoding)
-        output << matching_encoding("\n", encoding)
-        color_diff output
-      rescue Encoding::CompatibilityError
-        if input_data_new.encoding != input_data_old.encoding
-          "Could not produce a diff because the encoding of the actual string (#{input_data_old.encoding}) "+
-          "differs from the encoding of the expected string (#{input_data_new.encoding})"
-        else
-          "Could not produce a diff because of the encoding of the string (#{input_data_old.encoding})"
-        end
+      def initialize(actual, expected)
+        @actual = actual
+        @expected = expected
       end
 
-      def diff_as_object(actual, expected)
-        actual_as_string = object_to_string(actual)
-        expected_as_string = object_to_string(expected)
-        if diff = diff_as_string(actual_as_string, expected_as_string)
-          color_diff diff
+      def hunks
+        @file_length_difference = 0
+        @hunks ||= diffs.map do |piece|
+          build_hunk(piece)
         end
       end
 
-    protected
-
-      def format
-        :unified
-      end
-
-      def context_lines
-        3
-      end
-
-      def color(text, color_code)
-        "\e[#{color_code}m#{text}\e[0m"
-      end
-
-      def red(text)
-        color(text, 31)
-      end
+    private
 
-      def green(text)
-        color(text, 32)
+      def diffs
+        Diff::LCS.diff(expected_lines, actual_lines)
       end
 
-      def blue(text)
-        color(text, 34)
+      def expected_lines
+        @expected.split("\n").map! { |e| e.chomp }
       end
 
-      def color_diff(diff)
-        return diff unless RSpec::Matchers.configuration.color?
-
-        diff.lines.map { |line|
-          case line[0].chr
-          when "+"
-            green line
-          when "-"
-            red line
-          when "@"
-            line[1].chr == "@" ? blue(line) : line
-          else
-            line
-          end
-        }.join
+      def actual_lines
+        @actual.split("\n").map! { |e| e.chomp }
       end
 
-      def object_to_string(object)
-        case object
-        when Hash
-          object.keys.sort_by { |k| k.to_s }.map do |key|
-            pp_key   = PP.singleline_pp(key, "")
-            pp_value = PP.singleline_pp(object[key], "")
-
-            # on 1.9.3 PP seems to minimise to US-ASCII, ensure we're matching source encoding
-            #
-            # note, PP is used to ensure the ordering of the internal values of key/value e.g.
-            # <# a: b: c:> not <# c: a: b:>
-            encoding = pick_encoding pp_key, pp_value
-            matching_encoding("#{pp_key} => #{pp_value}", encoding)
-          end.join(",\n")
-        when String
-          object =~ /\n/ ? object : object.inspect
-        else
-          PP.pp(object,"")
+      def build_hunk(piece)
+        Diff::LCS::Hunk.new(
+          expected_lines, actual_lines, piece, context_lines, @file_length_difference
+        ).tap do |h|
+          @file_length_difference = h.file_length_difference
         end
       end
 
-    private
-
-      if String.method_defined?(:encoding)
-        def pick_encoding(source_a, source_b)
-          Encoding.compatible?(source_a, source_b) || Encoding.default_external
-        end
-
-        def matching_encoding(string, encoding)
-          string.encode encoding
-        rescue Encoding::UndefinedConversionError
-          string.encode(encoding, :undef => :replace)
-        end
-      else
-        def pick_encoding(source_a, source_b)
-        end
-
-        def matching_encoding(string, encoding)
-          string
-        end
+      def context_lines
+        3
       end
-    end
 
+    end
   end
 end
-