rspec-expectations 2.7.0 → 2.8.0.rc1

data/lib/rspec/matchers/base_matcher.rb

@@ -0,0 +1,41 @@
+module RSpec
+  module Matchers
+    # Used _internally_ as a base class for matchers that ship with
+    # rspec-expectations.
+    #
+    # ### 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
+    # class. If/when this changes, we will announce it and remove this warning.
+    module BaseMatcher
+      include RSpec::Matchers::Pretty
+
+      attr_reader :actual, :expected
+
+      def initialize(expected=nil)
+        @expected = expected
+      end
+
+      def matches?(actual)
+        @actual = actual
+      end
+
+      def failure_message_for_should
+        "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"
+      end
+
+      def failure_message_for_should_not
+        "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"
+      end
+
+      def description
+        expected ? "#{name_to_sentence} #{expected.inspect}" : name_to_sentence
+      end
+
+      def diffable?
+        false
+      end
+    end
+  end
+end

data/lib/rspec/matchers/be.rb

@@ -2,34 +2,53 @@ require 'rspec/matchers/dsl'
 
 module RSpec
   module Matchers
+    class BeTrue
+      include BaseMatcher
 
-    # @method be_true
-    RSpec::Matchers.define :be_true do
-      match do |actual|
-        actual
+      def matches?(actual)
+        super(actual)
       end
     end
 
-    RSpec::Matchers.define :be_false do
-      match do |actual|
-        !actual
+    # Passes if actual is truthy (anything but false or nil)
+    def be_true
+      BeTrue.new
+    end
+
+    class BeFalse
+      include BaseMatcher
+
+      def matches?(actual)
+        !super(actual)
       end
     end
 
-    RSpec::Matchers.define :be_nil do
-      match do |actual|
-        actual.nil?
+    # Passes if actual is falsy (false or nil)
+    def be_false
+      BeFalse.new
+    end
+
+    class BeNil
+      include BaseMatcher
+
+      def matches?(actual)
+        super(actual).nil?
       end
 
-      failure_message_for_should do |actual|
+      def failure_message_for_should
         "expected: nil\n     got: #{actual.inspect}"
       end
 
-      failure_message_for_should_not do
+      def failure_message_for_should_not
         "expected: not nil\n     got: nil"
       end
     end
 
+    # Passes if actual is nil
+    def be_nil
+      BeNil.new
+    end
+
     class Be
       include RSpec::Matchers::Pretty
       

data/lib/rspec/matchers/be_instance_of.rb

@@ -1,24 +1,22 @@
 module RSpec
   module Matchers
-    # :call-seq:
-    #   should be_instance_of(expected)
-    #   should be_an_instance_of(expected)
-    #   should_not be_instance_of(expected)
-    #   should_not be_an_instance_of(expected)
-    #
+    class BeAnInstanceOf
+      include BaseMatcher
+
+      def matches?(actual)
+        super(actual).instance_of?(expected)
+      end
+    end
+
     # Passes if actual.instance_of?(expected)
     #
-    # == Examples
+    # @example
     #
     #   5.should be_instance_of(Fixnum)
     #   5.should_not be_instance_of(Numeric)
     #   5.should_not be_instance_of(Float)
     def be_an_instance_of(expected)
-      Matcher.new :be_an_instance_of, expected do |_expected_|
-        match do |actual|
-          actual.instance_of?(_expected_)
-        end
-      end
+      BeAnInstanceOf.new(expected)
     end
     
     alias_method :be_instance_of, :be_an_instance_of

data/lib/rspec/matchers/be_kind_of.rb

@@ -1,24 +1,22 @@
 module RSpec
   module Matchers
-    # :call-seq:
-    #   should be_kind_of(expected)
-    #   should be_a_kind_of(expected)
-    #   should_not be_kind_of(expected)
-    #   should_not be_a_kind_of(expected)
-    #
+    class BeAKindOf
+      include BaseMatcher
+
+      def matches?(actual)
+        super(actual).kind_of?(expected)
+      end
+    end
+
     # Passes if actual.kind_of?(expected)
     #
-    # == Examples
+    # @example
     #
     #   5.should be_kind_of(Fixnum)
     #   5.should be_kind_of(Numeric)
     #   5.should_not be_kind_of(Float)
     def be_a_kind_of(expected)
-      Matcher.new :be_a_kind_of, expected do |_expected_|
-        match do |actual|
-          actual.kind_of?(_expected_)
-        end
-      end
+      BeAKindOf.new(expected)
     end
     
     alias_method :be_kind_of, :be_a_kind_of

data/lib/rspec/matchers/be_within.rb

@@ -1,37 +1,47 @@
 module RSpec
   module Matchers
-    # Passes if actual == expected +/- delta
-    #
-    # == Examples
-    #
-    #   result.should be_within(0.5).of(3.0)
-    #   result.should_not be_within(0.5).of(3.0)
-    def be_within(delta)
-      Matcher.new :be_within, delta do |_delta_|
-        chain :of do |_expected_|
-          @_expected = _expected_
-        end
+    class BeWithin
+      include BaseMatcher
 
-        match do |actual|
-          unless defined?(@_expected)
-            raise ArgumentError.new("You must set an expected value using #of: be_within(#{_delta_}).of(expected_value)")
-          end
-          (actual - @_expected).abs < _delta_
-        end
+      attr_reader :delta
 
-        failure_message_for_should do |actual|
-          "expected #{actual} to #{description}"
-        end
+      def initialize(delta)
+        @delta = delta
+      end
 
-        failure_message_for_should_not do |actual|
-          "expected #{actual} not to #{description}"
+      def matches?(actual)
+        unless defined?(@expected)
+          raise ArgumentError.new("You must set an expected value using #of: be_within(#{delta}).of(expected_value)")
         end
+        (super(actual) - expected).abs < delta
+      end
 
-        description do
-          "be within #{_delta_} of #{@_expected}"
-        end
+      def of(expected)
+        @expected = expected
+        self
+      end
+
+      def failure_message_for_should
+        "expected #{actual} to #{description}"
+      end
+
+      def failure_message_for_should_not
+        "expected #{actual} not to #{description}"
+      end
+
+      def description
+        "be within #{delta} of #{expected}"
       end
     end
+
+    # Passes if actual == expected +/- delta
+    #
+    # @example
+    #
+    #   result.should be_within(0.5).of(3.0)
+    #   result.should_not be_within(0.5).of(3.0)
+    def be_within(delta)
+      BeWithin.new(delta)
+    end
   end
 end
-

data/lib/rspec/matchers/block_aliases.rb

@@ -7,8 +7,9 @@ module RSpec
     end
 
     # Extends the submitted block with aliases to and to_not
-    # for should and should_not. Allows expectations like this:
+    # for should and should_not.
     #
+    # @example
     #   expect { this_block }.to change{this.expression}.from(old_value).to(new_value)
     #   expect { this_block }.to raise_error
     def expect(&block)

data/lib/rspec/matchers/change.rb

@@ -141,7 +141,7 @@ MESSAGE
     # do/end, as <tt>{ ... }</tt> binds to the +change+ method, whereas do/end
     # would errantly bind to the +should+ or +should_not+ method.
     #
-    # == Examples
+    # @example
     #
     #   lambda {
     #     team.add_player(player) 

data/lib/rspec/matchers/cover.rb

@@ -1,35 +1,36 @@
 module RSpec
   module Matchers
-    # :call-seq:
-    #   should cover(expected)
-    #   should_not cover(expected)
-    #
+    class Cover
+      include BaseMatcher
+
+      def initialize(*expected)
+        super(expected)
+      end
+
+      def matches?(range)
+        expected.all? {|e| super(range).cover?(e)}
+      end
+
+      def does_not_match?(range)
+        @actual = range
+        expected.none? {|e| range.cover?(e)}
+      end
+    end
+
     # Passes if actual covers expected. This works for
     # Ranges. You can also pass in multiple args
     # and it will only pass if all args are found in Range.
     #
-    # == Examples
+    # @example
     #   (1..10).should cover(5)
     #   (1..10).should cover(4, 6)
     #   (1..10).should cover(4, 6, 11) # will fail
     #   (1..10).should_not cover(11)
     #   (1..10).should_not cover(5)    # will fail
     #
-    # == Warning: Ruby >= 1.9 only
+    # ### Warning:: Ruby >= 1.9 only
     def cover(*values)
-      Matcher.new :cover, *values do |*_values|
-        match_for_should do |range|
-          _values.all? &covered_by(range)
-        end
-
-        match_for_should_not do |range|
-          _values.none? &covered_by(range)
-        end
-
-        def covered_by(range)
-          lambda {|value| range.cover?(value)}
-        end
-      end
+      Cover.new(*values)
     end
   end
 end

data/lib/rspec/matchers/eq.rb

@@ -1,45 +1,35 @@
 module RSpec
   module Matchers
+    class Eq
+      include BaseMatcher
+
+      def matches?(actual)
+        super(actual) == expected
+      end
+
+      def failure_message_for_should
+        "\nexpected: #{expected.inspect}\n     got: #{actual.inspect}\n\n(compared using ==)\n"
+      end
+
+      def failure_message_for_should_not
+        "\nexpected: value != #{expected.inspect}\n     got: #{actual.inspect}\n\n(compared using ==)\n"
+      end
+
+      def diffable?
+        true
+      end
+    end
+
     # Passes if <tt>actual == expected</tt>.
     #
     # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
     #
-    # == Examples
+    # @example
     #
     #   5.should eq(5)
     #   5.should_not eq(3)
     def eq(expected)
-      Matcher.new :eq, expected do |_expected_|
-
-        diffable
-
-        match do |actual|
-          actual == _expected_
-        end
-
-        failure_message_for_should do |actual|
-          <<-MESSAGE
-
-expected: #{_expected_.inspect}
-     got: #{actual.inspect}
-
-(compared using ==)
-MESSAGE
-        end
-
-        failure_message_for_should_not do |actual|
-          <<-MESSAGE
-
-expected #{actual.inspect} not to equal #{_expected_.inspect}
-
-(compared using ==)
-MESSAGE
-        end
-
-        description do
-          "eq #{_expected_}"
-        end
-      end
+      Eq.new(expected)
     end
   end
 end

data/lib/rspec/matchers/eql.rb

@@ -1,41 +1,35 @@
 module RSpec
   module Matchers
+    class Eql
+      include BaseMatcher
+
+      def matches?(actual)
+        super(actual).eql?(expected)
+      end
+
+      def failure_message_for_should
+        "\nexpected: #{expected.inspect}\n     got: #{actual.inspect}\n\n(compared using eql?)\n"
+      end
+
+      def failure_message_for_should_not
+        "\nexpected: value != #{expected.inspect}\n     got: #{actual.inspect}\n\n(compared using eql?)\n"
+      end
+
+      def diffable?
+        true
+      end
+    end
+
     # Passes if +actual.eql?(expected)+
     #
     # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
     #
-    # == Examples
+    # @example
     #
     #   5.should eql(5)
     #   5.should_not eql(3)
     def eql(expected)
-      Matcher.new :eql, expected do |_expected_|
-
-        diffable
-
-        match do |actual|
-          actual.eql?(_expected_)
-        end
-
-        failure_message_for_should do |actual|
-          <<-MESSAGE
-
-expected #{_expected_.inspect}
-     got #{actual.inspect}
-
-(compared using eql?)
-MESSAGE
-        end
-
-        failure_message_for_should_not do |actual|
-          <<-MESSAGE
-
-expected #{actual.inspect} not to equal #{_expected_.inspect}
-
-(compared using eql?)
-MESSAGE
-        end
-      end
+      Eql.new(expected)
     end
   end
 end