rspec 1.1.12 → 1.2.0

data/lib/spec/matchers/extensions/instance_exec.rb

@@ -0,0 +1,25 @@
+require 'spec/ruby'
+
+if ::Spec::Ruby.version < "1.8.7"
+  # based on Bounded Spec InstanceExec (Mauricio Fernandez)
+  # http://eigenclass.org/hiki/bounded+space+instance_exec
+  class Object
+    module InstanceExecHelper; end
+    include InstanceExecHelper
+    def instance_exec(*args, &block)
+      begin
+        orig_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(method_name="__instance_exec#{n}")
+        InstanceExecHelper.module_eval{ define_method(method_name, &block) }
+      ensure
+        Thread.critical = orig_critical
+      end
+      begin
+        return send(method_name, *args)
+      ensure
+        InstanceExecHelper.module_eval{ remove_method(method_name) } rescue nil
+      end
+    end
+  end
+end

data/lib/spec/matchers/generated_descriptions.rb

@@ -38,11 +38,11 @@ or this:
 
 it { should matcher }
 
-the runner expects the matcher to have a #describe method. You should either
+the runner expects the matcher to have a #description method. You should either
 add a String to the example this matcher is being used in, or give it a
 description method. Then you won't have to suffer this lengthy warning again.
 MESSAGE
     end
   end
 end
-      
+      

data/lib/spec/matchers/has.rb

@@ -1,18 +1,35 @@
 module Spec
   module Matchers
-    def has(sym, *args) # :nodoc:
-      simple_matcher do |actual, matcher|
-        matcher.failure_message          = "expected ##{predicate(sym)}(#{args[0].inspect}) to return true, got false"
-        matcher.negative_failure_message = "expected ##{predicate(sym)}(#{args[0].inspect}) to return false, got true"
-        matcher.description              = "have key #{args[0].inspect}"
-        actual.__send__(predicate(sym), *args)
+    
+    class Has
+      
+      def initialize(expected, *args)
+        @expected, @args = expected, args
       end
-    end
+      
+      def matches?(actual)
+        actual.__send__(predicate(@expected), *@args)
+      end
+      
+      def failure_message_for_should
+        "expected ##{predicate(@expected)}(#{@args[0].inspect}) to return true, got false"
+      end
+      
+      def failure_message_for_should_not
+        "expected ##{predicate(@expected)}(#{@args[0].inspect}) to return false, got true"
+      end
+      
+      def description
+        "have key #{@args[0].inspect}"
+      end
+    
+    private
     
-  private
-    def predicate(sym)
-      "#{sym.to_s.sub("have_","has_")}?".to_sym
+      def predicate(sym)
+        "#{sym.to_s.sub("have_","has_")}?".to_sym
+      end
+      
     end
-
+    
   end
 end

data/lib/spec/matchers/have.rb

@@ -36,11 +36,11 @@ module Spec
         "expected #{@collection_name} to be a collection but it does not respond to #length or #size"
       end
     
-      def failure_message
+      def failure_message_for_should
         "expected #{relative_expectation} #{@collection_name}, got #{@given}"
       end
 
-      def negative_failure_message
+      def failure_message_for_should_not
         if @relativity == :exactly
           return "expected target not to have #{@expected} #{@collection_name}, got #{@given}"
         elsif @relativity == :at_most

data/lib/spec/matchers/include.rb

@@ -25,11 +25,11 @@ module Spec
         true
       end
       
-      def failure_message
+      def failure_message_for_should
         _message
       end
       
-      def negative_failure_message
+      def failure_message_for_should_not
         _message("not ")
       end
       

data/lib/spec/matchers/match.rb

@@ -1,5 +1,28 @@
 module Spec
   module Matchers
+    class Match
+      def initialize(expected)
+        @expected = expected
+      end
+
+      def matches?(actual)
+        @actual = actual
+        actual =~ @expected
+      end
+
+      def failure_message_for_should
+        return "expected #{@actual.inspect} to match #{@expected.inspect}", @expected, @actual
+      end
+
+      def failure_message_for_should_not
+        return "expected #{@actual.inspect} not to match #{@expected.inspect}", @expected, @actual
+      end
+
+      def description
+        "match #{@expected.inspect}"
+      end
+    end
+    
     
     # :call-seq:
     #   should match(regexp)
@@ -10,13 +33,8 @@ module Spec
     # == Examples
     #
     #   email.should match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
-    def match(regexp)
-      simple_matcher do |actual, matcher|
-        matcher.failure_message          = "expected #{actual.inspect} to match #{regexp.inspect}", regexp, actual
-        matcher.negative_failure_message = "expected #{actual.inspect} not to match #{regexp.inspect}", regexp, actual
-        matcher.description              = "match #{regexp.inspect}"
-        actual =~ regexp
-      end
+    def match(expected)
+      Match.new(expected)
     end
   end
 end

data/lib/spec/matchers/match_array.rb

@@ -11,10 +11,10 @@ module Spec
         @actual = actual        
         @extra_items = difference_between_arrays(@actual, @expected)
         @missing_items = difference_between_arrays(@expected, @actual)
-        @extra_items.empty? && @missing_items.empty?
+        @extra_items.empty? & @missing_items.empty?
       end
 
-      def failure_message
+      def failure_message_for_should
         message =  "expected collection contained:  #{@expected.sort.inspect}\n"
         message += "actual collection contained:    #{@actual.sort.inspect}\n"
         message += "the missing elements were:      #{@missing_items.sort.inspect}\n" unless @missing_items.empty?
@@ -22,7 +22,7 @@ module Spec
         message
       end
       
-      def negative_failure_message
+      def failure_message_for_should_not
         "Matcher does not support should_not"
       end
       

data/lib/spec/matchers/matcher.rb

@@ -0,0 +1,51 @@
+module Spec
+  module Matchers
+    class Matcher
+      def initialize(name, expected=nil, &block_passed_to_init)
+        @name = name
+        @expected = expected
+        @block = block_passed_to_init
+        @messages = {
+          :description => lambda {"#{name_to_sentence} #{expected}"},
+          :failure_message_for_should => lambda {|actual| "expected #{actual} to #{name_to_sentence} #{expected}"},
+          :failure_message_for_should_not => lambda {|actual| "expected #{actual} not to #{name_to_sentence} #{expected}"}
+        }
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        instance_exec @expected, &@block
+        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
+      
+    private
+
+      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
+        @name_to_sentence ||= @name.to_s.gsub(/_/,' ')
+      end
+    
+    end
+  end
+end

data/lib/spec/matchers/method_missing.rb

@@ -1,8 +1,8 @@
 module Spec
   module Matchers
     def method_missing(sym, *args, &block) # :nodoc:
-      return Matchers::Be.new(sym, *args) if sym.starts_with?("be_")
-      return has(sym, *args) if sym.starts_with?("have_")
+      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

data/lib/spec/matchers/operator_matcher.rb

@@ -4,15 +4,16 @@ module Spec
     class OperatorMatcher
       class << self
         def registry
-          @registry ||= Hash.new {|h,k| h[k] = {}}
+          @registry ||= {}
         end
 
         def register(klass, operator, matcher)
+          registry[klass] ||= {}
           registry[klass][operator] = matcher
         end
 
         def get(klass, operator)
-          registry[klass][operator]
+          registry[klass] && registry[klass][operator]
         end
       end
 
@@ -25,9 +26,7 @@ module Spec
           if matcher = OperatorMatcher.get(@actual.class, operator)
             @actual.send(::Spec::Matchers.last_should, matcher.new(expected))
           else
-            ::Spec::Matchers.last_matcher = self
-            @operator, @expected = operator, expected
-            __delegate_operator(@actual, operator, expected)
+            eval_match(@actual, operator, expected)
           end
         end
       end
@@ -43,6 +42,14 @@ module Spec
       def description
         "#{@operator} #{@expected.inspect}"
       end
+      
+    private
+      
+      def eval_match(actual, operator, expected)
+        ::Spec::Matchers.last_matcher = self
+        @operator, @expected = operator, expected
+        __delegate_operator(actual, operator, expected)
+      end
 
     end
 

data/lib/spec/matchers/raise_error.rb

@@ -31,7 +31,7 @@ module Spec
           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
+        return (@raised_expected_error & @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
       end
       
       def eval_block
@@ -55,11 +55,11 @@ module Spec
         end
       end
       
-      def failure_message
+      def failure_message_for_should
         @eval_block ? @given_error.message : "expected #{expected_error}#{given_error}"
       end
 
-      def negative_failure_message
+      def failure_message_for_should_not
         "expected no #{expected_error}#{given_error}"
       end
       

data/lib/spec/matchers/respond_to.rb

@@ -16,16 +16,15 @@ module Spec
         return @names_not_responded_to.empty?
       end
       
-      def failure_message
+      def failure_message_for_should
         "expected #{@actual.inspect} to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}#{with_arity}"
       end
       
-      def negative_failure_message
+      def failure_message_for_should_not
         "expected #{@actual.inspect} not to respond to #{@names.collect {|name| name.inspect }.join(', ')}"
       end
       
       def description
-        # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here
         "respond to #{pp_names}#{with_arity}"
       end
       
@@ -51,6 +50,7 @@ module Spec
       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

data/lib/spec/matchers/satisfy.rb

@@ -6,18 +6,18 @@ module Spec
         @block = block
       end
       
-      def matches?(given, &block)
+      def matches?(actual, &block)
         @block = block if block
-        @given = given
-        @block.call(given)
+        @actual = actual
+        @block.call(actual)
       end
       
-      def failure_message
-        "expected #{@given} to satisfy block"
+      def failure_message_for_should
+        "expected #{@actual} to satisfy block"
       end
 
-      def negative_failure_message
-        "expected #{@given} not to satisfy block"
+      def failure_message_for_should_not
+        "expected #{@actual} not to satisfy block"
       end
     end
     

data/lib/spec/matchers/throw_symbol.rb

@@ -35,15 +35,13 @@ module Spec
             if @expected_arg.nil?
               return @caught_symbol == @expected_symbol
             else
-              # puts [@caught_symbol, @expected_symbol].inspect
-              # puts [@caught_arg, @expected_arg].inspect
-              return @caught_symbol == @expected_symbol && @caught_arg == @expected_arg
+              return (@caught_symbol == @expected_symbol) & (@caught_arg == @expected_arg)
             end
           end
         end
       end
 
-      def failure_message
+      def failure_message_for_should
         if @caught_symbol
           "expected #{expected}, got #{@caught_symbol.inspect}"
         else
@@ -51,7 +49,7 @@ module Spec
         end
       end
       
-      def negative_failure_message
+      def failure_message_for_should_not
         if @expected_symbol
           "expected #{expected} not to be thrown"
         else

data/lib/spec/mocks.rb

@@ -105,11 +105,11 @@ module Spec
   #   my_mock.should_receive(:sym).with(*args)
   #   my_mock.should_not_receive(:sym).with(*args)
   #
-  # == Argument Constraints using Expression Matchers
+  # == Argument Matchers
   #
   # Arguments that are passed to #with are compared with actual arguments received
   # using == by default. In cases in which you want to specify things about the arguments
-  # rather than the arguments themselves, you can use any of the Expression Matchers.
+  # rather than the arguments themselves, you can use any of RSpec's Expression Matchers.
   # They don't all make syntactic sense (they were primarily designed for use with
   # Spec::Expectations), but you are free to create your own custom Spec::Matchers.
   #
@@ -120,7 +120,7 @@ module Spec
   #
   #   my_mock.should_receive(:sym).with(no_args())
   #   my_mock.should_receive(:sym).with(any_args())
-  #   my_mock.should_receive(:sym).with(1, an_instance_of(Numeric), "b") #2nd argument can any type of Numeric
+  #   my_mock.should_receive(:sym).with(1, kind_of(Numeric), "b") #2nd argument can any kind of Numeric
   #   my_mock.should_receive(:sym).with(1, boolean(), "b") #2nd argument can true or false
   #   my_mock.should_receive(:sym).with(1, /abc/, "b") #2nd argument can be any String matching the submitted Regexp
   #   my_mock.should_receive(:sym).with(1, anything(), "b") #2nd argument can be anything at all

data/lib/spec/mocks/argument_expectation.rb

@@ -6,37 +6,37 @@ module Spec
       
       def initialize(args, &block)
         @args = args
-        @constraints_block = block
+        @matchers_block = block
         
-        if ArgumentConstraints::AnyArgsConstraint === args.first
+        if ArgumentMatchers::AnyArgsMatcher === args.first
           @match_any_args = true
-        elsif ArgumentConstraints::NoArgsConstraint === args.first
-          @constraints = []
+        elsif ArgumentMatchers::NoArgsMatcher === args.first
+          @matchers = []
         else
-          @constraints = args.collect {|arg| constraint_for(arg)}
+          @matchers = args.collect {|arg| matcher_for(arg)}
         end
       end
       
-      def constraint_for(arg)
-        return ArgumentConstraints::MatcherConstraint.new(arg)   if is_matcher?(arg)
-        return ArgumentConstraints::RegexpConstraint.new(arg) if arg.is_a?(Regexp)
-        return ArgumentConstraints::EqualityProxy.new(arg)
+      def matcher_for(arg)
+        return ArgumentMatchers::MatcherMatcher.new(arg)   if is_matcher?(arg)
+        return ArgumentMatchers::RegexpMatcher.new(arg) if arg.is_a?(Regexp)
+        return ArgumentMatchers::EqualityProxy.new(arg)
       end
       
       def is_matcher?(obj)
-        return obj.respond_to?(:matches?) && obj.respond_to?(:description)
+        return obj.respond_to?(:matches?) & obj.respond_to?(:description)
       end
       
       def args_match?(given_args)
-        match_any_args? || constraints_block_matches?(given_args) || constraints_match?(given_args)
+        match_any_args? || matchers_block_matches?(given_args) || matchers_match?(given_args)
       end
       
-      def constraints_block_matches?(given_args)
-        @constraints_block ? @constraints_block.call(*given_args) : nil
+      def matchers_block_matches?(given_args)
+        @matchers_block ? @matchers_block.call(*given_args) : nil
       end
       
-      def constraints_match?(given_args)
-        @constraints == given_args
+      def matchers_match?(given_args)
+        @matchers == given_args
       end
       
       def match_any_args?