rspec 0.8.2 → 0.9.0

data/lib/spec/extensions.rb

@@ -0,0 +1 @@
+require 'spec/extensions/object'

data/lib/spec/extensions/object.rb

@@ -0,0 +1,6 @@
+class Object
+  def args_and_options(*args)
+    options = Hash === args.last ? args.pop : {}
+    return args, options
+  end
+end  

data/lib/spec/matchers.rb

@@ -1,5 +1,3 @@
-require 'spec/deprecated'
-require 'spec/callback'
 require 'spec/matchers/be'
 require 'spec/matchers/be_close'
 require 'spec/matchers/change'
@@ -13,6 +11,7 @@ require 'spec/matchers/raise_error'
 require 'spec/matchers/respond_to'
 require 'spec/matchers/satisfy'
 require 'spec/matchers/throw_symbol'
+require 'spec/matchers/operator_matcher'
 
 module Spec
 
@@ -124,13 +123,27 @@ module Spec
   #     ...
   #   end
   module Matchers
-    
-    class << self
-      callback_events :description_generated
+    module ModuleMethods
+      def description_generated(&callback)
+        description_generated_callbacks << callback
+      end
+
+      def unregister_description_generated(callback)
+        description_generated_callbacks.delete(callback)
+      end
+
       def generated_description=(name)
-        notify_callbacks(:description_generated, name)
+        description_generated_callbacks.each do |callback|
+          callback.call(name)
+        end
+      end
+
+      private
+      def description_generated_callbacks
+        @description_generated_callbacks ||= []
       end
     end
+    extend ModuleMethods
     
     def method_missing(sym, *args, &block) # :nodoc:
       return Matchers::Be.new(sym, *args) if sym.starts_with?("be_")
@@ -138,21 +151,6 @@ module Spec
       super
     end
 
-    deprecated do
-      # This supports sugar delegating to Matchers
-      class Matcher #:nodoc:
-        include Matchers
-
-        def respond_to?(sym)
-          if sym.to_s[0..2] == "be_"
-            return true
-          else
-            super
-          end
-        end
-      end
-    end
-    
     class MatcherError < StandardError
     end
     

data/lib/spec/matchers/be.rb

@@ -2,8 +2,8 @@ module Spec
   module Matchers
     
     class Be #:nodoc:
-      def initialize(expected=nil, *args)
-        @expected = parse_expected(expected)
+      def initialize(*args)
+        @expected = parse_expected(args.shift)
         @args = args
         @comparison = ""
       end
@@ -89,19 +89,25 @@ module Spec
       end
       
       def description
-        "be #{@comparison}#{@expected}"
+        "#{prefix_to_sentence}#{comparison}#{expected_to_sentence}#{args_to_sentence}"
       end
 
       private
         def parse_expected(expected)
           if Symbol === expected
-            ["be_an_","be_a_","be_"].each do |prefix|
-              @handling_predicate = true
-              return "#{expected.to_s.sub(prefix,"")}".to_sym if expected.starts_with?(prefix)
+            @handling_predicate = true
+            ["be_an_","be_a_","be_"].each do |@prefix|
+              return "#{expected.to_s.sub(@prefix,"")}".to_sym if expected.starts_with?(@prefix)
             end
           end
+          @prefix = "be "
           return expected
         end
+        
+        def handling_predicate?
+          return false if [:true, :false, :nil].include?(@expected)
+          return @handling_predicate
+        end
 
         def predicate
           "#{@expected.to_s}?".to_sym
@@ -113,14 +119,37 @@ module Spec
         
         def args_to_s
           return "" if @args.empty?
-          transformed_args = @args.collect{|a| a.inspect}
-          return "(#{transformed_args.join(', ')})"
+          inspected_args = @args.collect{|a| a.inspect}
+          return "(#{inspected_args.join(', ')})"
         end
         
-        def handling_predicate?
-          return false if [:true, :false, :nil].include?(@expected)
-          return @handling_predicate
+        def comparison
+          @comparison
+        end
+        
+        def expected_to_sentence
+          split_words(@expected)
+        end
+        
+        def prefix_to_sentence
+          split_words(@prefix)
+        end
+
+        def split_words(sym)
+          sym.to_s.gsub(/_/,' ')
         end
+
+        def args_to_sentence
+          case @args.length
+            when 0
+              ""
+            when 1
+              " #{@args[0]}"
+            else
+              " #{@args[0...-1].join(', ')} and #{@args[-1]}"
+          end
+        end
+        
     end
  
     # :call-seq:

data/lib/spec/matchers/be_close.rb

@@ -13,11 +13,11 @@ module Spec
       end
       
       def failure_message
-        "expected #{@expected} +/- (<#{@delta}), got #{@actual}"
+        "expected #{@expected} +/- (< #{@delta}), got #{@actual}"
       end
       
       def description
-        "be close to #{@expected} (+- #{@delta})"
+        "be close to #{@expected} (within +- #{@delta})"
       end
     end
     

data/lib/spec/matchers/operator_matcher.rb

@@ -0,0 +1,52 @@
+module Spec
+  module Matchers
+    class BaseOperatorMatcher
+      
+      def initialize(target)
+        @target = target
+      end
+
+      def ==(expected)
+        @expected = expected
+        __delegate_method_missing_to_target("==", expected)
+      end
+
+      def ===(expected)
+        @expected = expected
+        __delegate_method_missing_to_target("===", expected)
+      end
+
+      def =~(expected)
+        @expected = expected
+        __delegate_method_missing_to_target("=~", expected)
+      end
+
+      def fail_with_message(message)
+        Spec::Expectations.fail_with(message, @expected, @target)
+      end
+
+    end
+
+    class PositiveOperatorMatcher < BaseOperatorMatcher #:nodoc:
+
+      def __delegate_method_missing_to_target(operator, expected)
+        ::Spec::Matchers.generated_description = "should #{operator} #{expected.inspect}"
+        return if @target.send(operator, expected)
+        return fail_with_message("expected #{expected.inspect}, got #{@target.inspect} (using #{operator})") if ['==','==='].include?(operator)
+        return fail_with_message("expected =~ #{expected.inspect}, got #{@target.inspect}")
+      end
+
+    end
+
+    class NegativeOperatorMatcher < BaseOperatorMatcher #:nodoc:
+
+      def __delegate_method_missing_to_target(operator, expected)
+        ::Spec::Matchers.generated_description = "should not #{operator} #{expected.inspect}"
+        return unless @target.send(operator, expected)
+        return fail_with_message("expected not #{operator} #{expected.inspect}, got #{@target.inspect}")
+      end
+
+    end
+
+  end
+end

data/lib/spec/matchers/respond_to.rb

@@ -2,34 +2,44 @@ module Spec
   module Matchers
     
     class RespondTo #:nodoc:
-      def initialize(sym)
-        @sym = sym
+      def initialize(*names)
+        @names = names
+        @names_not_responded_to = []
       end
       
       def matches?(target)
-        return target.respond_to?(@sym)
+        @names.each do |name|
+          unless target.respond_to?(name)
+            @names_not_responded_to << name
+          end
+        end
+        return @names_not_responded_to.empty?
       end
       
       def failure_message
-        "expected target to respond to #{@sym.inspect}"
+        "expected target to respond to #{@names_not_responded_to.collect {|name| name.inspect }.join(', ')}"
       end
       
       def negative_failure_message
-        "expected target not to respond to #{@sym.inspect}"
+        "expected target not to respond to #{@names.collect {|name| name.inspect }.join(', ')}"
       end
       
       def description
-        "respond to ##{@sym.to_s}"
+        "respond to ##{@names.to_s}"
       end
     end
     
     # :call-seq:
-    #   should respond_to(:sym)
-    #   should_not respond_to(:sym)
+    #   should respond_to(*names)
+    #   should_not respond_to(*names)
     #
-    # Matches if the target object responds to :sym
-    def respond_to(sym)
-      Matchers::RespondTo.new(sym)
+    # 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

data/lib/spec/mocks.rb

@@ -1,5 +1,7 @@
 require 'spec/mocks/methods'
-require 'spec/mocks/mock_handler'
+require 'spec/mocks/argument_constraint_matchers'
+require 'spec/mocks/spec_methods'
+require 'spec/mocks/proxy'
 require 'spec/mocks/mock'
 require 'spec/mocks/argument_expectation'
 require 'spec/mocks/message_expectation'
@@ -7,6 +9,8 @@ require 'spec/mocks/order_group'
 require 'spec/mocks/errors'
 require 'spec/mocks/error_generator'
 require 'spec/mocks/extensions/object'
+require 'spec/mocks/space'
+
 
 module Spec
   # == Mocks and Stubs
@@ -201,32 +205,5 @@ module Spec
   #
   #   my_mock.should_receive(:<<).with("illegal value").once.and_raise(ArgumentError)
   module Mocks
-    # Shortcut for creating an instance of Spec::Mocks::Mock.
-    def mock(name, options={})
-      Spec::Mocks::Mock.new(name, options)
-    end
-
-    # Shortcut for creating an instance of Spec::Mocks::Mock with
-    # predefined method stubs.
-    #
-    # == Examples
-    #
-    #   stub_thing = stub("thing", :a => "A")
-    #   stub_thing.a == "A" => true
-    #
-    #   stub_person = stub("thing", :name => "Joe", :email => "joe@domain.com")
-    #   stub_person.name => "Joe"
-    #   stub_person.email => "joe@domain.com"
-    def stub(name, stubs={})
-      object_stub = mock(name)
-      stubs.each { |key, value| object_stub.stub!(key).and_return(value) }
-      object_stub
-    end
-
-    # Shortcut for creating an instance of Spec::Mocks::DuckTypeArgConstraint
-    def duck_type(*args)
-      return Spec::Mocks::DuckTypeArgConstraint.new(*args)
-    end
-
   end
 end

data/lib/spec/mocks/argument_constraint_matchers.rb

@@ -0,0 +1,12 @@
+module Spec
+  module Mocks
+    module ArgumentConstraintMatchers
+
+      # Shortcut for creating an instance of Spec::Mocks::DuckTypeArgConstraint
+      def duck_type(*args)
+        return Spec::Mocks::DuckTypeArgConstraint.new(*args)
+      end
+
+    end
+  end
+end

data/lib/spec/mocks/argument_expectation.rb

@@ -71,12 +71,16 @@ module Spec
     end
     
     class DuckTypeArgConstraint
-      def initialize(*methods_to_respond_do)
-        @methods_to_respond_do = methods_to_respond_do
+      def initialize(*methods_to_respond_to)
+        @methods_to_respond_to = methods_to_respond_to
       end
   
       def matches?(value)
-        @methods_to_respond_do.all? { |sym| value.respond_to?(sym) }
+        @methods_to_respond_to.all? { |sym| value.respond_to?(sym) }
+      end
+      
+      def description
+        "duck_type"
       end
     end
 
@@ -104,7 +108,6 @@ module Spec
       
       def convert_constraint(constraint)
         return @@constraint_classes[constraint].new(constraint) if constraint.is_a?(Symbol)
-        return constraint if constraint.is_a?(DuckTypeArgConstraint)
         return MatcherConstraint.new(constraint) if is_matcher?(constraint)
         return RegexpArgConstraint.new(constraint) if constraint.is_a?(Regexp)
         return LiteralArgConstraint.new(constraint)

data/lib/spec/mocks/methods.rb

@@ -2,38 +2,33 @@ module Spec
   module Mocks
     module Methods
       def should_receive(sym, opts={}, &block)
-        __mock_handler.add_message_expectation(opts[:expected_from] || caller(1)[0], sym, opts, &block)
+        __mock_proxy.add_message_expectation(opts[:expected_from] || caller(1)[0], sym, opts, &block)
       end
 
       def should_not_receive(sym, &block)
-        __mock_handler.add_negative_message_expectation(caller(1)[0], sym, &block)
+        __mock_proxy.add_negative_message_expectation(caller(1)[0], sym, &block)
       end
       
       def stub!(sym)
-        __mock_handler.add_stub(caller(1)[0], sym)
+        __mock_proxy.add_stub(caller(1)[0], sym)
       end
       
       def received_message?(sym, *args, &block) #:nodoc:
-        __mock_handler.received_message?(sym, *args, &block)
+        __mock_proxy.received_message?(sym, *args, &block)
       end
       
-      def __verify #:nodoc:
-        __mock_handler.verify
+      def rspec_verify #:nodoc:
+        __mock_proxy.verify
       end
 
-      def __reset_mock #:nodoc:
-        __mock_handler.reset
+      def rspec_reset #:nodoc:
+        __mock_proxy.reset
       end
 
-      def method_missing(sym, *args, &block) #:nodoc:
-        __mock_handler.instance_eval {@messages_received << [sym, args, block]}
-        super(sym, *args, &block)
-      end
-      
-      private
+    private
 
-      def __mock_handler
-        @mock_handler ||= MockHandler.new(self, @name, @options)
+      def __mock_proxy
+        @mock_proxy ||= Proxy.new(self, @name, @options)
       end
     end
   end

data/lib/spec/mocks/mock.rb

@@ -12,15 +12,18 @@ module Spec
       end
 
       def method_missing(sym, *args, &block)
-        __mock_handler.instance_eval {@messages_received << [sym, args, block]}
+        __mock_proxy.instance_eval {@messages_received << [sym, args, block]}
         begin
-          return self if __mock_handler.null_object?
+          return self if __mock_proxy.null_object?
           super(sym, *args, &block)
         rescue NoMethodError
-          __mock_handler.raise_unexpected_message_error sym, *args
+          __mock_proxy.raise_unexpected_message_error sym, *args
         end
       end
       
+      def inspect
+        "#<#{self.class}:#{sprintf '0x%x', self.object_id} @name=#{@name.inspect}>"
+      end
     end
   end
 end