rspec-expectations 2.0.0.a1

data/lib/rspec/matchers/match.rb

@@ -0,0 +1,21 @@
+module Rspec
+  module Matchers
+    # :call-seq:
+    #   should match(pattern)
+    #   should_not match(pattern)
+    #
+    # Given a Regexp or String, passes if actual.match(pattern)
+    #
+    # == Examples
+    #
+    #   email.should match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
+    #   email.should match("@example.com")
+    def match(expected)
+      Matcher.new :match, expected do |_expected_|
+        match do |actual|
+          actual.match(_expected_)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/matchers/match_array.rb

@@ -0,0 +1,71 @@
+module Rspec
+  module Matchers
+
+    class MatchArray #:nodoc:
+      include Rspec::Matchers::Pretty
+      
+      def initialize(expected)
+        @expected = expected
+      end
+
+      def matches?(actual)
+        @actual = actual        
+        @extra_items = difference_between_arrays(@actual, @expected)
+        @missing_items = difference_between_arrays(@expected, @actual)
+        @extra_items.empty? & @missing_items.empty?
+      end
+
+      def failure_message_for_should
+        message =  "expected collection contained:  #{safe_sort(@expected).inspect}\n"
+        message += "actual collection contained:    #{safe_sort(@actual).inspect}\n"
+        message += "the missing elements were:      #{safe_sort(@missing_items).inspect}\n" unless @missing_items.empty?
+        message += "the extra elements were:        #{safe_sort(@extra_items).inspect}\n"   unless @extra_items.empty?
+        message
+      end
+      
+      def failure_message_for_should_not
+        "Matcher does not support should_not"
+      end
+      
+      def description
+        "contain exactly #{_pretty_print(@expected)}"
+      end
+
+      private
+
+        def safe_sort(array)
+          array.all?{|item| item.respond_to?(:<=>)} ? array.sort : array
+        end
+
+        def difference_between_arrays(array_1, array_2)
+          difference = array_1.dup
+          array_2.each do |element|
+            if index = difference.index(element)
+              difference.delete_at(index)
+            end
+          end
+          difference
+        end
+
+
+    end
+
+    # :call-seq:
+    #   should =~ expected
+    #
+    # Passes if actual contains all of the expected regardless of order. 
+    # This works for collections. Pass in multiple args  and it will only 
+    # pass if all args are found in collection.
+    #
+    # NOTE: there is no should_not version of array.should =~ other_array
+    # 
+    # == Examples
+    #
+    #   [1,2,3].should   =~ [1,2,3]   # => would pass
+    #   [1,2,3].should   =~ [2,3,1]   # => would pass
+    #   [1,2,3,4].should =~ [1,2,3]   # => would fail
+    #   [1,2,2,3].should =~ [1,2,3]   # => would fail
+    #   [1,2,3].should   =~ [1,2,3,4] # => would fail
+    OperatorMatcher.register(Array, '=~', Rspec::Matchers::MatchArray)
+  end
+end

data/lib/rspec/matchers/matcher.rb

@@ -0,0 +1,86 @@
+module Rspec
+  module Matchers
+    class Matcher
+      include Rspec::Matchers::Pretty
+      
+      attr_reader :expected, :actual
+      
+      def initialize(name, *expected, &declarations)
+        @name     = name
+        @expected = expected
+        @actual   = nil
+        @diffable = false
+        @messages = {
+          :description => lambda {"#{name_to_sentence}#{expected_to_sentence}"},
+          :failure_message_for_should => lambda {|actual| "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"},
+          :failure_message_for_should_not => lambda {|actual| "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"}
+        }
+        making_declared_methods_public do
+          instance_exec(*@expected, &declarations)
+        end
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        instance_exec(@actual,    &@match_block)
+      end
+      
+      def description(&block)
+        cache_or_call_cached(:description, &block)
+      end
+      
+      def failure_message_for_should(&block)
+        cache_or_call_cached(:failure_message_for_should, @actual, &block)
+      end
+      
+      def failure_message_for_should_not(&block)
+        cache_or_call_cached(:failure_message_for_should_not, @actual, &block)
+      end
+      
+      def match(&block)
+        @match_block = block
+      end
+      
+      def diffable?
+        @diffable
+      end
+      
+      def diffable
+        @diffable = true
+      end
+            
+    private
+
+      def making_declared_methods_public # :nodoc:
+        # Our home-grown instance_exec in ruby 1.8.6 results in any methods
+        # declared in the block eval'd by instance_exec in the block to which we
+        # are yielding here are scoped private. This is NOT the case for Ruby
+        # 1.8.7 or 1.9.
+        # 
+        # Also, due some crazy scoping that I don't understand, these methods
+        # are actually available in the specs (something about the matcher being
+        # defined in the scope of Rspec::Matchers or within an example), so not
+        # doing the following will not cause specs to fail, but they *will*
+        # cause features to fail and that will make users unhappy. So don't.
+        orig_private_methods = private_methods
+        yield
+        st = (class << self; self; end)
+        (private_methods - orig_private_methods).each {|m| st.__send__ :public, m}
+      end
+
+      def cache_or_call_cached(key, actual=nil, &block)
+        block ? @messages[key] = block : 
+                actual.nil? ? @messages[key].call : @messages[key].call(actual)
+      end
+    
+      def name_to_sentence
+        split_words(@name)
+      end
+      
+      def expected_to_sentence
+        to_sentence(@expected)
+      end
+    
+    end
+  end
+end

data/lib/rspec/matchers/method_missing.rb

@@ -0,0 +1,9 @@
+module Rspec
+  module Matchers
+    def method_missing(sym, *args, &block) # :nodoc:
+      return Matchers::Be.new(sym, *args) if sym.to_s =~ /^be_/
+      return Matchers::Has.new(sym, *args) if sym.to_s =~ /^have_/
+      super
+    end
+  end
+end

data/lib/rspec/matchers/operator_matcher.rb

@@ -0,0 +1,78 @@
+module Rspec
+  module Matchers
+
+    class OperatorMatcher
+      class << self
+        def registry
+          @registry ||= {}
+        end
+
+        def register(klass, operator, matcher)
+          registry[klass] ||= {}
+          registry[klass][operator] = matcher
+        end
+
+        def get(klass, operator)
+          registry[klass] && registry[klass][operator]
+        end
+      end
+
+      def initialize(actual)
+        @actual = actual
+      end
+
+      def self.use_custom_matcher_or_delegate(operator)
+        define_method(operator) do |expected|
+          if matcher = OperatorMatcher.get(@actual.class, operator)
+            @actual.send(::Rspec::Matchers.last_should, matcher.new(expected))
+          else
+            eval_match(@actual, operator, expected)
+          end
+        end
+      end
+
+      ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
+        use_custom_matcher_or_delegate operator
+      end
+
+      def fail_with_message(message)
+        Rspec::Expectations.fail_with(message, @expected, @actual)
+      end
+
+      def description
+        "#{@operator} #{@expected.inspect}"
+      end
+      
+    private
+      
+      def eval_match(actual, operator, expected)
+        ::Rspec::Matchers.last_matcher = self
+        @operator, @expected = operator, expected
+        __delegate_operator(actual, operator, expected)
+      end
+
+    end
+
+    class PositiveOperatorMatcher < OperatorMatcher #:nodoc:
+      def __delegate_operator(actual, operator, expected)
+        if actual.__send__(operator, expected)
+          true
+        elsif ['==','===', '=~'].include?(operator)
+          fail_with_message("expected: #{expected.inspect},\n     got: #{actual.inspect} (using #{operator})") 
+        else
+          fail_with_message("expected: #{operator} #{expected.inspect},\n     got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+        end
+      end
+
+    end
+
+    class NegativeOperatorMatcher < OperatorMatcher #:nodoc:
+      def __delegate_operator(actual, operator, expected)
+        return false unless actual.__send__(operator, expected)
+        return fail_with_message("expected not: #{operator} #{expected.inspect},\n         got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+      end
+
+    end
+
+  end
+end

data/lib/rspec/matchers/pretty.rb

@@ -0,0 +1,37 @@
+module Rspec
+  module Matchers
+    module Pretty
+      def split_words(sym)
+        sym.to_s.gsub(/_/,' ')
+      end
+
+      def to_sentence(words)
+        words = words.map{|w| w.inspect}
+        case words.length
+          when 0
+            ""
+          when 1
+            " #{words[0]}"
+          when 2
+            " #{words[0]} and #{words[1]}"
+          else
+            " #{words[0...-1].join(', ')}, and #{words[-1]}"
+        end
+      end
+
+      def _pretty_print(array)
+        result = ""
+        array.each_with_index do |item, index|
+          if index < (array.length - 2)
+            result << "#{item.inspect}, "
+          elsif index < (array.length - 1)
+            result << "#{item.inspect} and "
+          else
+            result << "#{item.inspect}"
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/rspec/matchers/raise_error.rb

@@ -0,0 +1,129 @@
+module Rspec
+  module Matchers
+    class RaiseError #:nodoc:
+      def initialize(expected_error_or_message=Exception, expected_message=nil, &block)
+        @block = block
+        @actual_error = nil
+        case expected_error_or_message
+        when String, Regexp
+          @expected_error, @expected_message = Exception, expected_error_or_message
+        else
+          @expected_error, @expected_message = expected_error_or_message, expected_message
+        end
+      end
+
+      def matches?(given_proc)
+        @raised_expected_error = false
+        @with_expected_message = false
+        @eval_block = false
+        @eval_block_passed = false
+        begin
+          given_proc.call
+        rescue @expected_error => @actual_error
+          @raised_expected_error = true
+          @with_expected_message = verify_message
+        rescue Exception => @actual_error
+          # This clause should be empty, but rcov will not report it as covered
+          # unless something (anything) is executed within the clause
+          rcov_error_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0"
+        end
+
+        unless negative_expectation?
+          eval_block if @raised_expected_error && @with_expected_message && @block
+        end
+      ensure
+        return (@raised_expected_error & @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
+      end
+      
+      def eval_block
+        @eval_block = true
+        begin
+          @block[@actual_error]
+          @eval_block_passed = true
+        rescue Exception => err
+          @actual_error = err
+        end
+      end
+
+      def verify_message
+        case @expected_message
+        when nil
+          true
+        when Regexp
+          @expected_message =~ @actual_error.message
+        else
+          @expected_message == @actual_error.message
+        end
+      end
+      
+      def failure_message_for_should
+        @eval_block ? @actual_error.message : "expected #{expected_error}#{given_error}"
+      end
+
+      def failure_message_for_should_not
+        "expected no #{expected_error}#{given_error}"
+      end
+      
+      def description
+        "raise #{expected_error}"
+      end
+      
+      private
+        def expected_error
+          case @expected_message
+          when nil
+            @expected_error
+          when Regexp
+            "#{@expected_error} with message matching #{@expected_message.inspect}"
+          else
+            "#{@expected_error} with #{@expected_message.inspect}"
+          end
+        end
+
+        def given_error
+          @actual_error.nil? ? " but nothing was raised" : ", got #{@actual_error.inspect}"
+        end
+        
+        def negative_expectation?
+          # YES - I'm a bad person... help me find a better way - ryand
+          caller.first(3).find { |s| s =~ /should_not/ }
+        end
+    end
+    
+    # :call-seq:
+    #   should raise_error()
+    #   should raise_error(NamedError)
+    #   should raise_error(NamedError, String)
+    #   should raise_error(NamedError, Regexp)
+    #   should raise_error() { |error| ... }
+    #   should raise_error(NamedError) { |error| ... }
+    #   should raise_error(NamedError, String) { |error| ... }
+    #   should raise_error(NamedError, Regexp) { |error| ... }
+    #   should_not raise_error()
+    #   should_not raise_error(NamedError)
+    #   should_not raise_error(NamedError, String)
+    #   should_not raise_error(NamedError, Regexp)
+    #
+    # With no args, matches if any error is raised.
+    # With a named error, matches only if that specific error is raised.
+    # With a named error and messsage specified as a String, matches only if both match.
+    # With a named error and messsage specified as a Regexp, matches only if both match.
+    # Pass an optional block to perform extra verifications on the exception matched
+    #
+    # == Examples
+    #
+    #   lambda { do_something_risky }.should raise_error
+    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError)
+    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError) { |error| error.data.should == 42 }
+    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, "that was too risky")
+    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, /oo ri/)
+    #
+    #   lambda { do_something_risky }.should_not raise_error
+    #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError)
+    #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, "that was too risky")
+    #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, /oo ri/)
+    def raise_error(error=Exception, message=nil, &block)
+      Matchers::RaiseError.new(error, message, &block)
+    end
+  end
+end

data/lib/rspec/matchers/respond_to.rb

@@ -0,0 +1,71 @@
+module Rspec
+  module Matchers
+    
+    class RespondTo #:nodoc:
+      def initialize(*names)
+        @names = names
+        @expected_arity = nil
+        @names_not_responded_to = []
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        @names.each do |name|
+          @names_not_responded_to << name unless actual.respond_to?(name) && matches_arity?(actual, name)
+        end
+        return @names_not_responded_to.empty?
+      end
+      
+      def failure_message_for_should
+        "expected #{@actual.inspect} to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}#{with_arity}"
+      end
+      
+      def failure_message_for_should_not
+        "expected #{@actual.inspect} not to respond to #{@names.collect {|name| name.inspect }.join(', ')}"
+      end
+      
+      def description
+        "respond to #{pp_names}#{with_arity}"
+      end
+      
+      def with(n)
+        @expected_arity = n
+        self
+      end
+      
+      def argument
+        self
+      end
+      alias :arguments :argument
+      
+    private
+      
+      def matches_arity?(actual, name)
+        @expected_arity.nil?? true : @expected_arity == actual.method(name).arity 
+      end
+      
+      def with_arity
+        @expected_arity.nil?? "" :
+          " with #{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
+      end
+      
+      def pp_names
+        # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here
+        @names.length == 1 ? "##{@names.first}" : @names.inspect
+      end
+    end
+    
+    # :call-seq:
+    #   should respond_to(*names)
+    #   should_not respond_to(*names)
+    #
+    # Matches if the target object responds to all of the names
+    # provided. Names can be Strings or Symbols.
+    #
+    # == Examples
+    # 
+    def respond_to(*names)
+      Matchers::RespondTo.new(*names)
+    end
+  end
+end