rspec 1.0.0 → 1.3.1

data/lib/spec/interop/test/unit/testsuite_adapter.rb

@@ -0,0 +1,36 @@
+require 'test/unit/testsuite'
+
+module Test
+  module Unit
+    class TestSuiteAdapter < TestSuite
+      attr_reader :example_group, :examples
+      alias_method :tests, :examples
+      def initialize(example_group)
+        @example_group = example_group
+        @examples = example_group.examples
+      end
+
+      def name
+        example_group.description
+      end
+
+      def run(*args)
+        return true unless args.empty?
+        example_group.run(Spec::Runner.options)
+      end
+
+      def size
+        example_group.number_of_examples
+      end
+
+      def delete(example)
+        examples.delete example
+      end
+
+      def empty?
+        examples.empty?
+      end
+    end
+  end
+end
+

data/lib/spec/interop/test/unit/ui/console/testrunner.rb

@@ -0,0 +1,61 @@
+require 'test/unit/ui/console/testrunner'
+
+module Test
+  module Unit
+    module UI
+      module Console
+        class TestRunner
+
+          alias_method :started_without_rspec, :started
+          def started_with_rspec(result)
+            @result = result
+            @need_to_output_started = true
+          end
+          alias_method :started, :started_with_rspec
+
+          alias_method :test_started_without_rspec, :test_started
+          def test_started_with_rspec(name)
+            if @need_to_output_started
+              if @rspec_io
+                @rspec_io.rewind
+                output(@rspec_io.read)
+              end
+              output("Started")
+              @need_to_output_started = false
+            end
+            test_started_without_rspec(name)
+          end
+          alias_method :test_started, :test_started_with_rspec
+
+          alias_method :test_finished_without_rspec, :test_finished
+          def test_finished_with_rspec(name)
+            test_finished_without_rspec(name)
+            @ran_test = true
+          end
+          alias_method :test_finished, :test_finished_with_rspec
+
+          alias_method :finished_without_rspec, :finished
+          def finished_with_rspec(elapsed_time)
+            @ran_test ||= false
+            if @ran_test
+              finished_without_rspec(elapsed_time)
+            end
+          end
+          alias_method :finished, :finished_with_rspec
+          
+          alias_method :setup_mediator_without_rspec, :setup_mediator
+          def setup_mediator_with_rspec
+            orig_io = @io
+            @io = StringIO.new
+            setup_mediator_without_rspec
+          ensure
+            @rspec_io = @io
+            @io = orig_io
+          end
+          alias_method :setup_mediator, :setup_mediator_with_rspec
+          
+        end
+      end
+    end
+  end
+end

data/lib/spec/interop/test.rb

@@ -0,0 +1,44 @@
+require 'spec'
+
+if Spec::Ruby.version.to_f >= 1.9
+  gem 'test-unit','= 1.2.3'
+end
+
+require 'test/unit'
+
+if Spec::Ruby.version.to_f >= 1.9
+  require 'test/unit/version'
+  if Test::Unit::VERSION > '1.2.3'
+    raise <<-MESSAGE
+#{'*' * 50}
+Required: test-unit-1.2.3
+Loaded:   test-unit-#{Test::Unit::VERSION}
+
+With ruby-1.9, rspec-#{Spec::VERSION::STRING} requires test-unit-1.2.3, and
+tries to force it with "gem 'test-unit', '= 1.2.3'" in:
+
+  #{__FILE__}
+  
+Unfortunately, test-unit-#{Test::Unit::VERSION} was loaded anyway. While we are
+aware of this bug we have not been able to track down its source.
+Until we do, you have two alternatives:
+
+* uninstall test-unit-#{Test::Unit::VERSION}
+* use 'script/spec' instead of 'rake spec'
+#{'*' * 50}
+MESSAGE
+  end
+end
+
+
+require 'test/unit/testresult'
+
+require 'spec/interop/test/unit/testcase'
+require 'spec/interop/test/unit/testsuite_adapter'
+require 'spec/interop/test/unit/autorunner'
+require 'spec/interop/test/unit/testresult'
+require 'spec/interop/test/unit/ui/console/testrunner'
+
+Spec::Example::ExampleGroupFactory.default(Test::Unit::TestCase)
+
+Test::Unit.run = true

data/lib/spec/matchers/be.rb

@@ -1,183 +1,219 @@
+require 'spec/matchers/dsl'
+
+Spec::Matchers.define :be_true do
+  match do |actual|
+    !!actual
+  end
+end
+
+Spec::Matchers.define :be_false do
+  match do |actual|
+    !actual
+  end
+end
+
+Spec::Matchers.define :be_nil do
+  match do |actual|
+    actual.nil?
+  end
+
+  failure_message_for_should do |actual|
+    "expected nil, got #{actual.inspect}"
+  end
+
+  failure_message_for_should_not do
+    "expected not nil, got nil"
+  end
+end
+
 module Spec
   module Matchers
-    
+
     class Be #:nodoc:
-      def initialize(*args)
-        @expected = parse_expected(args.shift)
+      include Spec::Matchers::Pretty
+      
+      def initialize(*args, &block)
         @args = args
-        @comparison = ""
       end
       
       def matches?(actual)
         @actual = actual
-        return true if match_or_compare unless handling_predicate?
-        if handling_predicate?
-          begin
-            return @result = actual.__send__(predicate, *@args)
-          rescue => predicate_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
-
-          # This supports should_exist > target.exists? in the old world.
-          # We should consider deprecating that ability as in the new world
-          # you can't write "should exist" unless you have your own custom matcher.
-          begin
-            return @result = actual.__send__(present_tense_predicate, *@args)
-          rescue
-            raise predicate_error
-          end
-        end
-        return false
+        !!@actual
+      end
+
+      def failure_message_for_should
+        "expected #{@actual.inspect} to evaluate to true"
+      end
+      
+      def failure_message_for_should_not
+        "expected #{@actual.inspect} to evaluate to false"
       end
       
-      def failure_message
-        return "expected #{@comparison}#{expected}, got #{@actual.inspect}" unless handling_predicate?
-        return "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
+      def description
+        "be"
+      end
+
+      [:==, :<, :<=, :>=, :>, :===].each do |operator|
+        define_method operator do |operand|
+          BeComparedTo.new(operand, operator)
+        end
+      end
+
+    private
+
+      def args_to_s
+        @args.empty? ? "" : parenthesize(inspected_args.join(', '))
       end
       
-      def negative_failure_message
-        return "expected not #{expected}, got #{@actual.inspect}" unless handling_predicate?
-        return "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
+      def parenthesize(string)
+        return "(#{string})"
       end
       
-      def expected
-        return true if @expected == :true
-        return false if @expected == :false
-        return "nil" if @expected == :nil
-        return @expected.inspect
+      def inspected_args
+        @args.collect{|a| a.inspect}
       end
       
-      def match_or_compare
-        return @actual == true if @expected == :true
-        return @actual == false if @expected == :false
-        return @actual.nil? if @expected == :nil
-        return @actual < @expected if @less_than
-        return @actual <= @expected if @less_than_or_equal
-        return @actual >= @expected if @greater_than_or_equal
-        return @actual > @expected if @greater_than
-        return @actual == @expected if @double_equal
-        return @actual === @expected if @triple_equal
-        return @actual.equal?(@expected)
+      def expected_to_sentence
+        split_words(@expected)
       end
       
-      def ==(expected)
-        @double_equal = true
-        @comparison = "== "
-        @expected = expected
-        self
+      def args_to_sentence
+        to_sentence(@args)
       end
+        
+    end
 
-      def ===(expected)
-        @triple_equal = true
-        @comparison = "=== "
-        @expected = expected
-        self
+    class BeComparedTo < Be
+
+      def initialize(operand, operator)
+        @expected, @operator = operand, operator
+        @args = []
       end
 
-      def <(expected)
-        @less_than = true
-        @comparison = "< "
-        @expected = expected
-        self
+      def matches?(actual)
+        @actual = actual
+        @actual.__send__(@operator, @expected)
       end
 
-      def <=(expected)
-        @less_than_or_equal = true
-        @comparison = "<= "
-        @expected = expected
-        self
+      def failure_message_for_should
+        "expected #{@operator} #{@expected}, got #{@actual.inspect}"
+      end
+      
+      def failure_message_for_should_not
+        message = <<-MESSAGE
+'should_not be #{@operator} #{@expected}' not only FAILED,
+it is a bit confusing.
+          MESSAGE
+          
+        raise message << ([:===,:==].include?(@operator) ?
+          "It might be more clearly expressed without the \"be\"?" :
+          "It might be more clearly expressed in the positive?")
       end
 
-      def >=(expected)
-        @greater_than_or_equal = true
-        @comparison = ">= "
-        @expected = expected
-        self
+      def description
+        "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
       end
 
-      def >(expected)
-        @greater_than = true
-        @comparison = "> "
-        @expected = expected
-        self
+    end
+
+    class BePredicate < Be
+
+      def initialize(*args, &block)
+        @expected = parse_expected(args.shift)
+        @args = args
+        @block = block
       end
       
-      def description
-        "#{prefix_to_sentence}#{comparison}#{expected_to_sentence}#{args_to_sentence}"
-      end
-
-      private
-        def parse_expected(expected)
-          if Symbol === expected
-            @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
+      def matches?(actual)
+        @actual = actual
+        begin
+          return @result = actual.__send__(predicate, *@args, &@block)
+        rescue NameError => predicate_missing_error
+          "this needs to be here or rcov will not count this branch even though it's executed in a code example"
         end
 
-        def predicate
-          "#{@expected.to_s}?".to_sym
-        end
-        
-        def present_tense_predicate
-          "#{@expected.to_s}s?".to_sym
-        end
-        
-        def args_to_s
-          return "" if @args.empty?
-          inspected_args = @args.collect{|a| a.inspect}
-          return "(#{inspected_args.join(', ')})"
-        end
-        
-        def comparison
-          @comparison
-        end
-        
-        def expected_to_sentence
-          split_words(@expected)
-        end
-        
-        def prefix_to_sentence
-          split_words(@prefix)
+        begin
+          return @result = actual.__send__(present_tense_predicate, *@args, &@block)
+        rescue NameError
+          raise predicate_missing_error
         end
+      end
+      
+      def failure_message_for_should
+        "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
+      end
+      
+      def failure_message_for_should_not
+        "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
+      end
 
-        def split_words(sym)
-          sym.to_s.gsub(/_/,' ')
-        end
+      def description
+        "#{prefix_to_sentence}#{expected_to_sentence}#{args_to_sentence}"
+      end
+
+    private
+
+      def predicate
+        "#{@expected}?".to_sym
+      end
+      
+      def present_tense_predicate
+        "#{@expected}s?".to_sym
+      end
+      
+      def parse_expected(expected)
+        @prefix, expected = prefix_and_expected(expected)
+        expected
+      end
+
+      def prefix_and_expected(symbol)
+        symbol.to_s =~ /^(be_(an?_)?)(.*)/
+        return $1, $3
+      end
+
+      def prefix_to_sentence
+        split_words(@prefix)
+      end
+
+    end
+
+    class BeSameAs < Be
+      
+      def initialize(*args, &block)
+        @expected = args.shift
+        @args = args
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        @actual.equal?(@expected)
+      end
+
+      def failure_message_for_should
+        "expected #{@expected}, got #{@actual.inspect}"
+      end
+      
+      def failure_message_for_should_not
+        "expected not #{@expected}, got #{@actual.inspect}"
+      end
+
+      def description
+        "be #{expected_to_sentence}#{args_to_sentence}"
+      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:
     #   should be_true
     #   should be_false
     #   should be_nil
-    #   should be_arbitrary_predicate(*args)
+    #   should be_[arbitrary_predicate](*args)
     #   should_not be_nil
-    #   should_not be_arbitrary_predicate(*args)
+    #   should_not be_[arbitrary_predicate](*args)
     #
-    # Given true, false, or nil, will pass if actual is
-    # true, false or nil (respectively).
+    # Given true, false, or nil, will pass if actual value is
+    # true, false or nil (respectively). Given no args means
+    # the caller should satisfy an if condition (to be or not to be). 
     #
     # Predicates are any Ruby method that ends in a "?" and returns true or false.
     # Given be_ followed by arbitrary_predicate (without the "?"), RSpec will match
@@ -195,12 +231,19 @@ module Spec
     #   target.should_not be_nil
     #
     #   collection.should be_empty #passes if target.empty?
-    #   "this string".should be_an_intance_of(String)
-    #
     #   target.should_not be_empty #passes unless target.empty?
     #   target.should_not be_old_enough(16) #passes unless target.old_enough?(16)
     def be(*args)
-      Matchers::Be.new(*args)
+      args.empty? ?
+        Matchers::Be.new :
+        Matchers::BeSameAs.new(*args)
     end
+
+    # passes if target.kind_of?(klass)
+    def be_a(klass)
+      be_a_kind_of(klass)
+    end
+    
+    alias_method :be_an, :be_a
   end
 end

data/lib/spec/matchers/be_close.rb

@@ -1,26 +1,5 @@
 module Spec
   module Matchers
-
-    class BeClose #:nodoc:
-      def initialize(expected, delta)
-        @expected = expected
-        @delta = delta
-      end
-      
-      def matches?(actual)
-        @actual = actual
-        (@actual - @expected).abs < @delta
-      end
-      
-      def failure_message
-        "expected #{@expected} +/- (< #{@delta}), got #{@actual}"
-      end
-      
-      def description
-        "be close to #{@expected} (within +- #{@delta})"
-      end
-    end
-    
     # :call-seq:
     #   should be_close(expected, delta)
     #   should_not be_close(expected, delta)
@@ -31,7 +10,23 @@ module Spec
     #
     #   result.should be_close(3.0, 0.5)
     def be_close(expected, delta)
-      Matchers::BeClose.new(expected, delta)
+      Matcher.new :be_close, expected, delta do |_expected_, _delta_|
+        match do |actual|
+          (actual - _expected_).abs < _delta_
+        end
+
+        failure_message_for_should do |actual|
+          "expected #{_expected_} +/- (< #{_delta_}), got #{actual}"
+        end
+
+        failure_message_for_should_not do |actual|
+          "expected #{_expected_} +/- (< #{_delta_}), got #{actual}"
+        end
+
+        description do
+          "be close to #{_expected_} (within +- #{_delta_})"
+        end
+      end
     end
   end
-end
+end

data/lib/spec/matchers/be_instance_of.rb

@@ -0,0 +1,26 @@
+module Spec
+  module Matchers
+    # :call-seq:
+    #   should be_instance_of(expected)
+    #   should be_an_instance_of(expected)
+    #   should_not be_instance_of(expected)
+    #   should_not be_an_instance_of(expected)
+    #
+    # Passes if actual.instance_of?(expected)
+    #
+    # == Examples
+    #
+    #   5.should be_instance_of(Fixnum)
+    #   5.should_not be_instance_of(Numeric)
+    #   5.should_not be_instance_of(Float)
+    def be_an_instance_of(expected)
+      Matcher.new :be_an_instance_of, expected do |_expected_|
+        match do |actual|
+          actual.instance_of?(_expected_)
+        end
+      end
+    end
+    
+    alias_method :be_instance_of, :be_an_instance_of
+  end
+end

data/lib/spec/matchers/be_kind_of.rb

@@ -0,0 +1,26 @@
+module Spec
+  module Matchers
+    # :call-seq:
+    #   should be_kind_of(expected)
+    #   should be_a_kind_of(expected)
+    #   should_not be_kind_of(expected)
+    #   should_not be_a_kind_of(expected)
+    #
+    # Passes if actual.kind_of?(expected)
+    #
+    # == Examples
+    #
+    #   5.should be_kind_of(Fixnum)
+    #   5.should be_kind_of(Numeric)
+    #   5.should_not be_kind_of(Float)
+    def be_a_kind_of(expected)
+      Matcher.new :be_a_kind_of, expected do |_expected_|
+        match do |actual|
+          actual.kind_of?(_expected_)
+        end
+      end
+    end
+    
+    alias_method :be_kind_of, :be_a_kind_of
+  end
+end