rspec 0.5.3 → 0.5.4

data/doc/src/tutorials/stack_spec.rb

@@ -0,0 +1,41 @@
+require 'stack'
+
+context "A new stack" do
+  setup do
+    @stack = Stack.new
+  end
+
+  specify "should be empty" do
+    @stack.should_be_empty
+  end
+end
+
+context "An empty stack" do
+  setup do
+    @stack = Stack.new
+  end
+
+  specify "should keep its mouth shut when you send it 'push'" do
+    lambda { @stack.push Object.new }.should.not.raise
+  end
+end
+  
+context "A stack with one item" do
+  setup do
+    @stack = Stack.new
+    @stack.push "one item"
+  end
+
+  specify "should not be empty" do
+    @stack.should_not_be_empty
+  end
+
+  specify "should return top when you send it 'top'" do
+    @stack.top.should_equal "one item"
+  end
+  
+  specify "should not be empty after 'top'" do
+    @stack.top
+    @stack.should_not_be_empty
+  end
+end

data/examples/airport_spec.rb

@@ -6,7 +6,7 @@ class Airport
   end
   
   def need?(thing)
-    thing != :cables
+    false unless [:cables, :electricity].include? thing
   end
 end
 
@@ -25,16 +25,16 @@ topic "Airport at home" do
   end
   
   fact "should always work" do
-    @airport.should.be.working
+    @airport.should_be_working
   end
 
   must "not need cables" do
-    @airport.should.not.need :cables
+    @airport.should_not_need :cables
   end
 
   must "not need electricity" do
     # This will fail...
-    @airport.should.not.need :electricity
+    @airport.should_not_need :electricity
   end
   
   teardown do

data/examples/{spec_framework_spec.rb → bdd_framework_spec.rb}

@@ -1,28 +1,27 @@
 require File.dirname(__FILE__) + '/../lib/spec'
 
-class SpecFramework
+class BddFramework
   def intuitive?
     true
   end
   
   def adopted_quickly?
-    false
+    true
   end
 end
 
-context "Spec framework" do
+context "BDD framework" do
 
   setup do
-    @spec_framework = SpecFramework.new
+    @bdd_framework = BddFramework.new
   end
 
   specify "should be adopted quickly" do
-    #this will fail
-    @spec_framework.should.be.adopted_quickly
+    @bdd_framework.should_be_adopted_quickly
   end
   
   specify "should be intuitive" do
-    @spec_framework.should.be.intuitive
+    @bdd_framework.should_be_intuitive
   end
 
 end

data/examples/mocking_spec.rb

@@ -8,9 +8,4 @@ context "Mocker" do
     mock.poke
   end
 
-  specify "should fail when expected message not received" do
-    mock = mock("poke me")
-    mock.should.receive(:poke)
-  end
-
 end

data/examples/stack_spec.rb

@@ -8,11 +8,11 @@ context "An empty stack" do
   end
   
   specify "should accept an item when sent push" do
-    lambda { @stack.push Object.new }.should.not.raise
+    lambda { @stack.push Object.new }.should_not_raise
   end
   
   specify "should complain when sent top" do
-    lambda { @stack.top }.should.raise StackUnderflowError
+    lambda { @stack.top }.should_raise StackUnderflowError
   end
   
   specify "should complain when sent pop" do
@@ -21,7 +21,8 @@ context "An empty stack" do
   
 end
 
-  context "A stack with one item" do
+context "A stack with one item" do
+
   setup do
     @stack = Stack.new
     @stack.push 3
@@ -52,6 +53,7 @@ end
 end
 
 context "An almost full stack (with one item less than capacity)" do
+  
   setup do
     @stack = Stack.new
     (1..9).each { |i| @stack.push i }
@@ -110,7 +112,4 @@ context "A full stack" do
     @stack.pop.should.be 9
   end
   
-end
-
-
-
+end

data/examples/sugar_spec.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/../lib/spec'
+
+context "Underscore sugar" do
+  specify "should be available for regular objects" do
+    1.should_equal 1
+    lambda { 1.should_not_equal 1 }.should_raise
+  end
+
+  specify "should be available for mocks" do
+    sweetened = mock "sweetened"
+    sweetened.should_receive :salt
+    sweetened.salt
+  end
+end

data/lib/spec/api.rb

@@ -1,5 +1,8 @@
 require 'spec/api/exceptions'
-require 'spec/api/mock'
-require 'spec/api/duck_type'
+require 'spec/api/mocks/argument_expectation'
+require 'spec/api/mocks/order_group'
+require 'spec/api/mocks/message_expectation'
+require 'spec/api/mocks/mock'
 require 'spec/api/expectations'
 require 'spec/api/helper'
+require 'spec/api/sugar'

data/lib/spec/api/helper/should_base.rb

@@ -1,38 +1,33 @@
+class TrueClass; def inspect_for_expectation_not_met_error; "<true>" end end
+class FalseClass; def inspect_for_expectation_not_met_error; "<false>" end end
+class NilClass; def inspect_for_expectation_not_met_error; "nil" end end
+class Class; def inspect_for_expectation_not_met_error; "<#{name}>" end end
+class Proc; def inspect_for_expectation_not_met_error; "<Proc>" end end
+class Array; def inspect_for_expectation_not_met_error; "#{inspect}" end end
+class String; def inspect_for_expectation_not_met_error; "#{inspect}" end end
+class Object
+  def inspect_for_expectation_not_met_error
+    return "#{self.class} #{inspect}" if inspect.include? "<"
+    return "#{self.class} <#{inspect}>" unless inspect.include? "<"
+  end
+end
+
 module Spec
   
   class ShouldBase
 
 		def default_message(expectation, expected=:no_expectation_specified)
-      message = wrap(@target)
-      message += " #{expectation}"
+      message = "#{@target.inspect_for_expectation_not_met_error} #{expectation}"
       if (expected != :no_expectation_specified)
-        message += " " + wrap(expected)
+        message << " " << expected.inspect_for_expectation_not_met_error
       end
       message
    	end
-   	
-   	def wrap(obj)
-		  if obj == true
-		   "<true>"
-		  elsif obj == false
-		   "<false>"
-		  elsif obj.nil?
-		    "nil"
-		  elsif obj.kind_of? Proc
-		    "<Proc>"
-	    elsif (obj.kind_of? Array) || (obj.kind_of? String)
-	      "#{obj.inspect}"
-	    elsif obj.inspect.include? "<"
-        "#{obj.class} #{obj.inspect}"
-      else
-        "#{obj.class} <#{obj.inspect}>"
-      end
- 	  end
 
 		def fail_with_message(message)
 			Kernel::raise(Spec::Api::ExpectationNotMetError.new(message))
 		end
-
+		
   end
   
 end

data/lib/spec/api/helper/should_helper.rb

@@ -64,11 +64,12 @@ module Spec
     def raise(exception=Exception)
       begin
         @target.call
-        fail_with_message(default_message("should raise", exception.inspect))
       rescue exception
-      rescue
-        fail_with_message(default_message("should raise", exception.inspect))
+        return
+      rescue => e
+        fail_with_message("#{default_message("should raise", exception)} but raised #{e.inspect}")
       end
+      fail_with_message("#{default_message("should raise", exception)} but raised nothing")
     end
     
     def throw(symbol)

data/lib/spec/api/helper/should_negator.rb

@@ -48,8 +48,9 @@ module Spec
     def raise(exception=Exception)
       begin
         @target.call
-      rescue exception
-        fail_with_message(default_message("should not raise", exception.inspect))
+      rescue exception => e
+        fail_with_message("#{default_message("should not raise", exception)}") if e.instance_of? exception
+        fail_with_message("#{default_message("should not raise", exception)} but raised #{e.inspect}") unless e.instance_of? exception
       rescue
         true
       end

data/lib/spec/api/mocks/argument_expectation.rb

@@ -0,0 +1,104 @@
+module Spec
+  module Api
+  
+    class LiteralArgConstraint
+      def initialize(literal)
+        @literal_value = literal
+      end
+      
+      def matches?(value)
+        @literal_value == value
+      end
+    end
+    
+    class AnyArgConstraint
+      def initialize(ignore)
+      end
+      
+      def matches?(value)
+        true
+      end
+    end
+    
+    class NumericArgConstraint
+      def initialize(ignore)
+      end
+      
+      def matches?(value)
+        value.is_a?(Numeric)
+      end
+    end
+    
+    class BooleanArgConstraint
+      def initialize(ignore)
+      end
+      
+      def matches?(value)
+        return true if value.is_a?(TrueClass)
+        return true if value.is_a?(FalseClass)
+        false
+      end
+    end
+    
+    class StringArgConstraint
+      def initialize(ignore)
+      end
+      
+      def matches?(value)
+        value.is_a?(String)
+      end
+    end
+    
+    class DuckTypeArgConstraint
+      def initialize(*methods_to_respond_do)
+        @methods_to_respond_do = methods_to_respond_do
+      end
+  
+      def matches?(value)
+        @methods_to_respond_do.all? { |sym| value.respond_to?(sym) }
+      end
+    end
+
+    class ArgumentExpectation
+    
+      @@constraint_classes = Hash.new { |hash, key| LiteralArgConstraint}
+      @@constraint_classes[:anything] = AnyArgConstraint
+      @@constraint_classes[:numeric] = NumericArgConstraint
+      @@constraint_classes[:boolean] = BooleanArgConstraint
+      @@constraint_classes[:string] = StringArgConstraint
+      
+      def initialize(args)
+        if args == [:any_args] then @expected_params = nil
+        elsif args == [:no_args] then @expected_params = []
+        else @expected_params = process_arg_constraints(args)
+        end
+      end
+      
+      def process_arg_constraints(constraints)
+        constraints.collect do |constraint| 
+          convert_constraint(constraint)
+        end
+      end
+      
+      def convert_constraint(constraint)
+        return @@constraint_classes[constraint].new(constraint) if constraint.is_a?(Symbol)
+        return constraint if constraint.is_a?(DuckTypeArgConstraint)
+        return LiteralArgConstraint.new(constraint)
+      end
+      
+      def check_args(args)
+        return true if @expected_params.nil?
+        return true if @expected_params == args
+        return constraints_match?(args)
+      end
+      
+      def constraints_match?(args)
+        return false if args.length != @expected_params.length
+        @expected_params.each_index { |i| return false unless @expected_params[i].matches?(args[i]) }
+        return true
+      end
+  
+    end
+    
+  end
+end

data/lib/spec/api/{mock.rb → mocks/message_expectation.rb}

@@ -1,65 +1,10 @@
 module Spec
   module Api
-    class Mock
-
-      DEFAULT_OPTIONS = {
-        :null_object => false
-      }
-      # Creates a new mock with a +name+ (that will be used in error messages only)
-      # Options:
-      # * <tt>:null_object</tt> - if true, the mock object acts as a forgiving null object allowing any message to be sent to it.
-      def initialize(name, options={})
-        @name = name
-        @options = DEFAULT_OPTIONS.dup.merge(options)
-        @expectations = []
-      end
-      
-      def should
-        self
-      end
-
-      def receive(sym, &block)
-        expected_from = caller(1)[0]
-        expectation = MessageExpectation.new(@name, expected_from, sym, block_given? ? block : nil)
-        @expectations << expectation
-        expectation
-      end
-
-      def __verify
-        @expectations.each do |expectation|
-          expectation.verify_messages_received
-        end
-      end
-
-      def method_missing(sym, *args, &block)
-        # TODO: use find_expectation(sym, args) which will lookup based on sym, args and strict mode.
-        if expectation = find_matching_expectation(sym, *args)
-          expectation.verify_message(args, block)
-        else
-          begin
-            # act as null object if method is missing and we ignore them. return value too!
-            @options[:null_object] ? self : super(sym, *args, &block)
-          rescue NoMethodError
-            
-            arg_message = args.collect{|arg| "<#{arg}:#{arg.class.name}>"}.join(", ")
-            
-            Kernel::raise Spec::Api::MockExpectationError, "Mock '#{@name}' received unexpected message '#{sym.to_s}' with [#{arg_message}]"
-          end
-        end
-      end
-
-    private
-
-      def find_matching_expectation(sym, *args)
-        expectation = @expectations.find {|expectation| expectation.matches(sym, args)}
-      end
-
-    end
 
     # Represents the expection of the reception of a message
     class MessageExpectation
-
-      def initialize(mock_name, expected_from, sym, block)
+    
+      def initialize(mock_name, expectation_ordering, expected_from, sym, block)
         @mock_name = mock_name
         @expected_from = expected_from
         @sym = sym
@@ -67,33 +12,21 @@ module Spec
         @block = proc {}
         @received_count = 0
         @expected_received_count = 1
-        @expected_params = nil
+        @args_expectation = ArgumentExpectation.new([:any_args])
         @consecutive = false
         @exception_to_raise = nil
         @symbol_to_throw = nil
         @any_seen = false
         @at_seen = false
         @and_seen = false
+        @ordering = expectation_ordering
+        @ordered = false
       end
   
       def matches(sym, args)
-        @sym == sym and (@expected_params.nil? or @expected_params == args or constraints_match?(args))
-      end
-      
-      def constraints_match?(args)
-        return true if @expected_params.length == 1 and @expected_params[0] == :any_args
-        return false if args.length != @expected_params.length
-        @expected_params.each_index do |i|
-          next if @expected_params[i] == :anything
-          next if @expected_params[i] == :numeric and args[i].is_a?Numeric
-          next if @expected_params[i] == :boolean and args[i].is_a?TrueClass or args[i].is_a?FalseClass
-          next if @expected_params[i] == :string and args[i].is_a?String
-          next if @expected_params[i].is_a? DuckType and @expected_params[i].walks_like? args[i]
-          return false unless args[i] == @expected_params[i]
-        end
-        return true
+        @sym == sym and @args_expectation.check_args(args)
       end
-      
+       
       def make_count_message(count)
         return "at least #{pretty_print(count.abs)}" if count < 0
         return pretty_print(count) if count > 0
@@ -105,53 +38,63 @@ module Spec
         return "twice" if count == 2
         return "#{count} times"
       end
-
+      
       # This method is called at the end of a spec, after teardown.
       def verify_messages_received
         # TODO: this doesn't provide good enough error messages to fix the error.
         # Error msg should tell exactly what went wrong. (AH).
-    
+        
         return if @expected_received_count == :any
         return if (@expected_received_count < 0) && (@received_count >= @expected_received_count.abs)
         return if @expected_received_count == @received_count
     
-        expected_signature = nil
-        if @expected_params.nil?
-          expected_signature = @sym
-        else
-          params = @expected_params.collect{|param| "<#{param}:#{param.class.name}>"}.join(", ")
-          expected_signature = "#{@sym}(#{params})"
-        end
-    
         count_message = make_count_message(@expected_received_count)
 
-        message = "Mock '#{@mock_name}' expected #{expected_signature} #{count_message}, but received it #{@received_count} times"
+        message = "Mock '#{@mock_name}' expected '#{@sym}' #{count_message}, but received it #{@received_count} times"
         begin
-          Kernel::raise Spec::Api::MockExpectationError, message
+          Kernel::raise(Spec::Api::MockExpectationError, message)
         rescue => error
           error.backtrace.insert(0, @expected_from)
           Kernel::raise error
         end
       end
 
+      def handle_order_constraint
+        return unless @ordered
+        return @ordering.consume(@self) if @ordering.ready_for?(self)
+        message = "Mock '#{@mock_name}' received '#{@sym}' out of order"
+        Kernel::raise(Spec::Api::MockExpectationError, message) 
+      end
+      
       # This method is called when a method is invoked on a mock
       def verify_message(args, block)
+        
+        handle_order_constraint
+        
         unless @method_block.nil?
           begin
             result = @method_block.call(*args)
           rescue Spec::Api::ExpectationNotMetError => detail
-            Kernel::raise Spec::Api::MockExpectationError, "Call expectation violated with: " + $!
+            Kernel::raise Spec::Api::MockExpectationError, "Call expectation violated with: " + detail
           end
           @received_count += 1
           return result
         end
     
-        args << block unless block.nil?
-        @received_count += 1
-        
         Kernel::raise @exception_to_raise.new unless @exception_to_raise.nil?
         Kernel::throw @symbol_to_throw unless @symbol_to_throw.nil?
-        
+        unless @args_to_yield.nil?
+          if block.nil?
+            Kernel::raise Spec::Api::MockExpectationError, "Expected block to be passed"
+          end
+          if @args_to_yield.length != block.arity
+            Kernel::raise Spec::Api::MockExpectationError, "Wrong arity of passed block. Expected #{@args_to_yield.size}"
+          end
+          block.call @args_to_yield
+        end
+
+        args << block unless block.nil?
+        @received_count += 1        
         value = @block.call(*args)
     
         return value unless @consecutive
@@ -160,11 +103,7 @@ module Spec
       end
 
       def with(*args)
-        if args == [:any_args] then @expected_params = nil
-        elsif args == [:no_args] then @expected_params = []
-        else @expected_params = args
-        end
-
+        @args_expectation = ArgumentExpectation.new(args)
         self
       end
       
@@ -249,6 +188,18 @@ module Spec
         @and_seen = false
         @symbol_to_throw = symbol
       end
+      
+      def ordered
+        @ordering.register(self)
+        @ordered = true
+        self
+      end
+      
+      def yield(*args)
+        return self unless @and_seen
+        @and_seen = false
+        @args_to_yield = args
+      end
   
     end
   end