rspec 0.6.3 → 0.6.4

data/lib/spec/expectations/should_negator.rb

@@ -0,0 +1,71 @@
+module Spec
+  module Expectations
+    class ShouldNegator < ShouldBase
+    
+      def initialize(target)
+        @target = target
+        @be_seen = false
+      end
+  
+      def satisfy
+        fail_with_message "Supplied expectation was satisfied, but should not have been" if (yield @target)
+      end
+        
+      def equal(expected)
+        fail_with_message(default_message("should not equal", expected)) if (@target == expected)
+      end
+    
+      def be(expected = :no_arg)
+        @be_seen = true
+        return self if (expected == :no_arg)
+        fail_with_message(default_message("should not be", expected)) if (@target.equal?(expected))
+      end
+
+      def an_instance_of expected_class
+        fail_with_message(default_message("should not be an instance of", expected_class)) if @target.instance_of? expected_class
+      end
+    
+      def a_kind_of expected_class
+        fail_with_message(default_message("should not be a kind of", expected_class)) if @target.kind_of? expected_class
+      end
+
+      def respond_to message
+        fail_with_message(default_message("should not respond to", message)) if @target.respond_to? message
+      end
+    
+      def match(expected)
+          fail_with_message(default_message("should not match", expected)) if (@target =~ expected)
+      end
+    
+      def raise(exception=Exception, message=nil)
+        begin
+          @target.call
+        rescue exception => e
+          return unless message.nil? || e.message == message
+          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
+      end
+    
+      def throw(symbol=:___this_is_a_symbol_that_will_likely_never_occur___)
+        begin
+          catch symbol do
+            @target.call
+            return true
+          end
+          fail_with_message(default_message("should not throw", symbol.inspect))
+        rescue NameError
+          true
+        end
+      end
+
+      def method_missing(original_sym, *args)
+        actual_sym = find_supported_sym(original_sym)      
+        return unless @target.__send__(actual_sym, *args)
+        fail_with_message(default_message("should not#{@be_seen ? ' be' : ''} #{original_sym}" + (args.empty? ? '' : (' ' + args.join(', ')))))
+      end
+    end
+  end
+end

data/lib/spec/{api → expectations}/sugar.rb

@@ -1,19 +1,19 @@
 module Spec
-  module Api
+  module Expectations
     # This module adds syntactic sugar that allows usage of should_* instead of should.*
     module UnderscoreSugar
-      module SugarizeForRspec; end
+      module SweetTooth; end
 
-      def sugarize_for_rspec!
+      def handle_underscores_for_rspec!
         original_method_missing = instance_method(:method_missing)
         class_eval do
-          include SugarizeForRspec # This is meant to add a signature to the object that sugarization occurred.
+          include SweetTooth # This is meant to add a signature to the object that sugarization occurred.
           def method_missing(sym, *args, &block)
             _method_missing(sym, args, block)
           end
 
           define_method :_method_missing do |sym, args, block|
-            return original_method_missing.bind(self).call(sym, *args, &block) unless __is_sweetened?(sym)
+            return original_method_missing.bind(self).call(sym, *args, &block) unless __sweetened?(sym)
 
             object = self
             calls = sym.to_s.split("_")
@@ -27,7 +27,7 @@ module Spec
             return object.__send__(calls.join("_"), *args, &block)
           end
 
-          def __is_sweetened?(sym) #:nodoc:
+          def __sweetened?(sym) #:nodoc:
             return true if sym.to_s =~ /^should_/
           end
         end
@@ -37,7 +37,7 @@ module Spec
 end
 
 class Module
-  include Spec::Api::UnderscoreSugar
+  include Spec::Expectations::UnderscoreSugar
 end
 
-Object.sugarize_for_rspec!
+Object.handle_underscores_for_rspec!

data/lib/spec/mocks.rb

@@ -0,0 +1,5 @@
+require 'spec/mocks/mock'
+require 'spec/mocks/argument_expectation'
+require 'spec/mocks/message_expectation'
+require 'spec/mocks/order_group'
+require 'spec/mocks/exceptions'

data/lib/spec/{api/mocks → mocks}/argument_expectation.rb

@@ -1,5 +1,5 @@
 module Spec
-  module Api
+  module Mocks
   
     class LiteralArgConstraint
       def initialize(literal)

data/lib/spec/{api → mocks}/exceptions.rb

@@ -1,12 +1,10 @@
 module Spec
-  module Api
-    class ExpectationNotMetError < StandardError
-    end
-    
+  module Mocks
     class MockExpectationError < StandardError
     end
-
+    
     class AmbiguousReturnError < StandardError
     end
   end
 end
+

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

@@ -1,17 +1,17 @@
 module Spec
-  module Api
+  module Mocks
 
     # Represents the expection of the reception of a message
     class MessageExpectation
     
-      def initialize(mock_name, expectation_ordering, expected_from, sym, method_block)
+      def initialize(mock_name, expectation_ordering, expected_from, sym, method_block, expected_received_count=1)
         @mock_name = mock_name
         @expected_from = expected_from
         @sym = sym
         @method_block = method_block
         @return_block = lambda {}
         @received_count = 0
-        @expected_received_count = 1
+        @expected_received_count = expected_received_count
         @args_expectation = ArgumentExpectation.new([:any_args])
         @consecutive = false
         @exception_to_raise = nil
@@ -53,7 +53,7 @@ module Spec
 
         message = "Mock '#{@mock_name}' expected '#{@sym}' #{count_message}, but received it #{@received_count} times"
         begin
-          Kernel::raise(Spec::Api::MockExpectationError, message)
+          Kernel::raise(Spec::Mocks::MockExpectationError, message)
         rescue => error
           error.backtrace.insert(0, @expected_from)
           Kernel::raise error
@@ -64,7 +64,7 @@ module Spec
         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) 
+        Kernel::raise(Spec::Mocks::MockExpectationError, message) 
       end
       
       # This method is called when a method is invoked on a mock
@@ -91,17 +91,17 @@ module Spec
       def invoke_method_block(args)
         begin
           @method_block.call(*args)
-        rescue Spec::Api::ExpectationNotMetError => detail
-          Kernel::raise Spec::Api::MockExpectationError, "Call expectation violated with: " + detail
+        rescue Spec::Expectations::ExpectationNotMetError => detail
+          Kernel::raise Spec::Mocks::MockExpectationError, "Call expectation violated with: " + detail
         end
       end
       
       def invoke_with_yield(block)
         if block.nil?
-          Kernel::raise Spec::Api::MockExpectationError, "Expected block to be passed"
+          Kernel::raise Spec::Mocks::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}"
+          Kernel::raise Spec::Mocks::MockExpectationError, "Wrong arity of passed block. Expected #{@args_to_yield.size}"
         end
         block.call(*@args_to_yield)
       end
@@ -196,5 +196,11 @@ module Spec
         self
       end
     end
+    
+    class NegativeMessageExpectation < MessageExpectation
+      def initialize(mock_name, expectation_ordering, expected_from, sym, method_block)
+        super mock_name, expectation_ordering, expected_from, sym, method_block, 0
+      end
+    end
   end
 end

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

@@ -1,11 +1,6 @@
 module Spec
-  module Api
-    class Mock
-      # Remove all methods so they can be mocked too
-      (public_instance_methods - ['__id__', '__send__', 'nil?']).each do |m|
-        undef_method m
-      end
-
+  module Mocks
+    module MockInstanceMethods
       # 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.
@@ -15,17 +10,15 @@ module Spec
         @expectations = []
         @expectation_ordering = OrderGroup.new
       end
-      
+
       def should_receive(sym, &block)
-        expected_from = caller(1)[0]
-        expectation = MessageExpectation.new(@name, @expectation_ordering, expected_from, sym, block_given? ? block : nil)
-        @expectations << expectation
-        expectation
+        add MessageExpectation, caller(1)[0], sym, &block
       end
       
       def should_not_receive(sym, &block)
+        add NegativeMessageExpectation, caller(1)[0], sym, &block
       end
-
+      
       def __verify #:nodoc:
         @expectations.each do |expectation|
           expectation.verify_messages_received
@@ -33,30 +26,55 @@ module Spec
       end
 
       def method_missing(sym, *args, &block)
-        if expectation = find_matching_expectation(sym, *args)
-          expectation.invoke(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}' with [#{arg_message}]"
-          end
+        begin
+          return self if @options[:null_object]
+          super(sym, *args, &block)
+        rescue NoMethodError
+          arg_message = args.collect{|arg| "<#{arg}:#{arg.class.name}>"}.join(", ")
+          Kernel::raise Spec::Mocks::MockExpectationError, "Mock '#{@name}' received unexpected message '#{sym}' with [#{arg_message}]"
         end
       end
-
+      
     private
 
       DEFAULT_OPTIONS = {
         :null_object => false
       }
+
+      def add(expectation_class, expected_from, sym, &block)
+        define_expected_method(sym)
+        expectation = expectation_class.send(:new, @name, @expectation_ordering, expected_from, sym, block_given? ? block : nil)
+        @expectations << expectation
+        expectation
+      end
+
+      def metaclass
+        class << self; self; end
+      end
+    
+      def define_expected_method(sym)
+        metaclass.__send__ :class_eval, %{
+          def #{sym}(*args, &block)
+            message_received :#{sym}, *args, &block # ?
+          end
+        }
+      end
+    
+      def message_received(sym, *args, &block)
+        if expectation = find_matching_expectation(sym, *args)
+          expectation.invoke(args, block)
+        else
+          method_missing(sym, *args, &block)
+        end
+      end
       
       def find_matching_expectation(sym, *args)
         expectation = @expectations.find {|expectation| expectation.matches(sym, args)}
       end
-
     end
-
+    
+    class Mock
+      include MockInstanceMethods
+    end
   end
 end

data/lib/spec/{api/mocks → mocks}/order_group.rb

@@ -1,5 +1,5 @@
 module Spec
-  module Api
+  module Mocks
     class OrderGroup
       def initialize
         @ordering = Array.new

data/lib/spec/runner/backtrace_tweaker.rb

@@ -25,8 +25,11 @@ module Spec
         error.backtrace.collect! do |line|
           line = tweak_instance_exec_line line, spec_name
           line = nil if line =~ /\/lib\/ruby\//
-          line = nil if line =~ /\/lib\/spec\/api\//
+          line = nil if line =~ /\/lib\/spec\/expectations\//
+          line = nil if line =~ /\/lib\/spec\/mocks\//
+          line = nil if line =~ /\/lib\/spec\/rake\//
           line = nil if line =~ /\/lib\/spec\/runner\//
+          line = nil if line =~ /\/lib\/spec\/stubs\//
           line = nil if line =~ /bin\/spec:/
           line = nil if line =~ /lib\/rspec_on_rails/
           line = nil if line =~ /script\/rails_spec/

data/lib/spec/runner/execution_context.rb

@@ -5,19 +5,28 @@ module Spec
         def initialize(spec)
           @spec = spec
         end
-        
+
         def mock(name, options={})
-          mock = Api::Mock.new(name, options)
+          mock = Spec::Mocks::Mock.new(name, options)
           @spec.add_mock(mock)
           mock
         end
 
+        def stub(object, name="")
+          stub_space.create_stub(object, name)
+        end
+
         def duck_type(*args)
-          return Api::DuckTypeArgConstraint.new(*args)
+          return Spec::Mocks::DuckTypeArgConstraint.new(*args)
         end
 
         def violated(message="")
-          raise Spec::Api::ExpectationNotMetError.new(message)
+          raise Spec::Expectations::ExpectationNotMetError.new(message)
+        end
+
+        private
+        def stub_space
+          @spec.stub_space
         end
       end
       include InstanceMethods

data/lib/spec/runner/formatter/base_text_formatter.rb

@@ -5,10 +5,16 @@ module Spec
       # non-text based ones too - just ignore the +output+ constructor
       # argument.
       class BaseTextFormatter
-        def initialize(output, dry_run=false)
-          @dry_run = dry_run
+        def initialize(output, dry_run=false, colour=false)
           @output = output
-        end
+          @dry_run = dry_run
+          @colour = colour
+          begin
+            require 'Win32/Console/ANSI' if @colour && PLATFORM =~ /win32/
+          rescue LoadError
+            raise "You must gem install win32console to use --color on Windows"
+          end
+	      end
 
         # This method is invoked before any specs are run, right after
         # they have all been collected. This can be useful for special
@@ -55,22 +61,29 @@ module Spec
         # of the associated spec. +failure+ is a Failure object, which contains detailed
         # information about the failure.
         def dump_failure(counter, failure)
-          @output << "\n"
-          @output << counter.to_s << ")\n"
-          @output << "#{failure.header}\n"
-          @output << "#{failure.message}\n"
-          @output << "#{failure.backtrace}\n"
+          @output.puts
+          @output.puts "#{counter.to_s})"
+          @output.puts failure.header
+          @output.puts failure.message
+          @output.puts failure.backtrace
           @output.flush
         end
       
         # This method is invoked at the very end.
         def dump_summary(duration, spec_count, failure_count)
           return if @dry_run
-          @output << "\n"
-          @output << "Finished in " << (duration).to_s << " seconds\n\n"
-          @output << "#{spec_count} specification#{'s' unless spec_count == 1}, "
-          @output << "#{failure_count} failure#{'s' unless failure_count == 1}"
-          @output << "\n"
+          if @colour && @output == STDOUT
+            colour_prefix = (failure_count == 0 ? "\e[32m" : "\e[31m")
+            colour_postfix = "\e[0m"
+            summary_output = Kernel
+          else
+            colour_prefix = colour_postfix = ""
+            summary_output = @output
+          end
+          @output.puts
+          @output.puts "Finished in #{duration} seconds"
+          @output.puts
+          summary_output.puts "#{colour_prefix}#{spec_count} specification#{'s' unless spec_count == 1}, #{failure_count} failure#{'s' unless failure_count == 1}#{colour_postfix}"
           @output.flush
         end
       end

data/lib/spec/runner/formatter/html_formatter.rb

@@ -2,7 +2,7 @@ module Spec
   module Runner
     module Formatter
       class HtmlFormatter < BaseTextFormatter
-        def initialize(output, dry_run=false)
+        def initialize(output, dry_run=false, colour=false)
           super
           @current_count = 0
         end

data/lib/spec/runner/option_parser.rb

@@ -8,7 +8,7 @@ module Spec
       def self.create_context_runner(args, standalone, err, out=STDOUT)
         options = parse(args, standalone, err, out)
 
-        formatter = options.formatter_type.new(options.out, options.dry_run)
+        formatter = options.formatter_type.new(options.out, options.dry_run, options.colour)
         reporter = Reporter.new(formatter, options.backtrace_tweaker) 
         ContextRunner.new(reporter, standalone, options.dry_run, options.spec_name)
       end
@@ -25,7 +25,11 @@ module Spec
           opts.separator ""
 
           opts.on("--diff", "Show unified diff of Strings that are expected to be equal when they are not") do
-            require 'spec/api/helper/diff'
+            require 'spec/expectations/diff'
+          end
+          
+          opts.on("-c", "--colour", "--color", "Show coloured (red/green) output") do
+            options.colour = true
           end
           
           opts.on("-s", "--spec SPECIFICATION_NAME", "Execute a single specification") do |spec_name|