rspec 0.5.12 → 0.5.13

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

@@ -0,0 +1,27 @@
+module Spec
+  module Runner
+    module Formatter
+      class ProgressBarFormatter < BaseTextFormatter
+        def add_context(name, first)
+          @output << "\n" if first
+          @output.flush
+        end
+      
+        def spec_failed(name, counter, failure)
+          @output << 'F'
+          @output.flush
+        end
+      
+        def spec_passed(name)
+          @output << '.'
+          @output.flush
+        end
+      
+        def start_dump
+          @output << "\n"
+          @output.flush
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Spec
+  module Runner
+    module Formatter
+      class RdocFormatter < BaseTextFormatter
+        def add_context(name, first)
+          @output << "# #{name}\n"
+          @output.flush
+        end
+  
+        def spec_passed(name)
+          @output << "# * #{name}\n"
+          @output.flush
+        end
+
+        def spec_failed(name, counter, failure)
+          @output << "# * #{name} [#{counter} - FAILED]\n"
+          @output.flush
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Spec
+  module Runner
+    module Formatter
+      class SpecdocFormatter < BaseTextFormatter      
+        def add_context(name, first)
+          @output << "\n#{name}\n"
+          @output.flush
+        end
+      
+        def spec_failed(name, counter, failure)
+          @output << "- #{name} (FAILED - #{counter})\n"
+          @output.flush
+        end
+      
+        def spec_passed(name)
+          @output << "- #{name}\n"
+          @output.flush
+        end
+      end
+    end
+  end
+end

data/lib/spec/runner/option_parser.rb

@@ -16,7 +16,7 @@ module Spec
       def self.parse(args, standalone, err, out)
         options = OpenStruct.new
         options.out = out
-        options.formatter_type = ProgressBarFormatter
+        options.formatter_type = Formatter::ProgressBarFormatter
         options.backtrace_tweaker = QuietBacktraceTweaker.new
         options.spec_name = nil
 
@@ -24,25 +24,24 @@ module Spec
           opts.banner = "Usage: spec [options] (FILE|DIRECTORY|GLOB)+"
           opts.separator ""
 
-          opts.on("-b", "--backtrace", "Output full backtrace") do
-            options.backtrace_tweaker = NoisyBacktraceTweaker.new
+          opts.on("--diff", "Show unified diff of Strings that are expected to be equal when they are not") do
+            require 'spec/api/helper/diff'
           end
           
-          opts.on("-r", "--require FILE", "Require FILE before running specs",
-                                          "Useful for loading custom formatters or other extensions") do |req|
-            require req
+          opts.on("-s", "--spec SPECIFICATION_NAME", "Execute a single specification") do |spec_name|
+            options.spec_name = spec_name
           end
-          
+
           opts.on("-f", "--format FORMAT", "Builtin formats: specdoc|s|rdoc|r|html|h", 
                                            "You can also specify a custom formatter class",
                                            "(in which case you should also specify --require)") do |format|
             case format
               when 'specdoc', 's'
-                options.formatter_type = SpecdocFormatter
+                options.formatter_type = Formatter::SpecdocFormatter
               when 'html', 'h'
-                options.formatter_type = HtmlFormatter
+                options.formatter_type = Formatter::HtmlFormatter
               when 'rdoc', 'r'
-                options.formatter_type = RdocFormatter
+                options.formatter_type = Formatter::RdocFormatter
                 options.dry_run = true
             else
               begin
@@ -55,18 +54,19 @@ module Spec
             end
           end
 
-          opts.on("-d", "--dry-run", "Don't execute specs") do
-            options.dry_run = true
+          opts.on("-r", "--require FILE", "Require FILE before running specs",
+                                          "Useful for loading custom formatters or other extensions") do |req|
+            require req
           end
           
-          opts.on("--diff", "Show unified diff of Strings that are expected to be equal when they are not") do
-            require 'spec/api/helper/diff'
+          opts.on("-b", "--backtrace", "Output full backtrace") do
+            options.backtrace_tweaker = NoisyBacktraceTweaker.new
           end
           
-          opts.on("-s", "--spec SPECIFICATION_NAME", "Execute a single specification") do |spec_name|
-            options.spec_name = spec_name
+          opts.on("-d", "--dry-run", "Don't execute specs") do
+            options.dry_run = true
           end
-
+          
           opts.on("-v", "--version", "Show version") do
             out.puts ::Spec::VERSION::DESCRIPTION
             exit if out == $stdout

data/lib/spec/runner/reporter.rb

@@ -93,7 +93,7 @@ module Spec
         private
 
         def class_name
-          @exception.class.name.split('::').last
+          @exception.class.name #.split('::').last
         end
 
       end

data/lib/spec/version.rb

@@ -3,7 +3,7 @@ module Spec
     unless defined? MAJOR
       MAJOR  = 0
       MINOR  = 5
-      TINY   = 12
+      TINY   = 13
 
       STRING = [MAJOR, MINOR, TINY].join('.')
       TAG    = "REL_" + [MAJOR, MINOR, TINY].join('_')

data/test/spec/api/helper/arbitrary_predicate_test.rb

@@ -6,102 +6,102 @@ module Spec
 
       class ArbitraryPredicateTest < Test::Unit::TestCase
 
-        # should.be.xxx
+        # should.be.funny
 
-        def test_should_be_xxx_should_raise_when_target_doesnt_understand_xxx
+        def test_should_be_funny_should_raise_when_target_doesnt_understand_funny
           assert_raise(NoMethodError) do
-            5.should.be.xxx
+            5.should.be.funny
           end
         end
 
-        def test_should_be_xxx_should_raise_when_sending_xxx_to_target_returns_false
-          mock = XxxMock.new(false)
+        def test_should_be_funny_should_raise_when_sending_funny_to_target_returns_false
+          mock = HandCodedMock.new(false)
           assert_raise(ExpectationNotMetError) do
-            mock.should.be.xxx
+            mock.should.be.funny
           end
           mock.__verify
         end
 
-        def test_should_be_xxx_should_raise_when_sending_xxx_to_target_returns_nil
-          mock = XxxMock.new(nil)
+        def test_should_be_funny_should_raise_when_sending_funny_to_target_returns_nil
+          mock = HandCodedMock.new(nil)
           assert_raise(ExpectationNotMetError) do
-            mock.should.be.xxx
+            mock.should.be.funny
           end
           mock.__verify
         end
 
-        def test_should_be_xxx_should_not_raise_when_sending_xxx_to_target_returns_true
-          mock = XxxMock.new(true)
+        def test_should_be_funny_should_not_raise_when_sending_funny_to_target_returns_true
+          mock = HandCodedMock.new(true)
           assert_nothing_raised do
-            mock.should.be.xxx
+            mock.should.be.funny
           end
           mock.__verify
         end
 
-        def test_should_be_xxx_should_not_raise_when_sending_xxx_to_target_returns_something_other_than_true_false_or_nil
-          mock = XxxMock.new(5)
+        def test_should_be_funny_should_not_raise_when_sending_funny_to_target_returns_something_other_than_true_false_or_nil
+          mock = HandCodedMock.new(5)
           assert_nothing_raised do
-            mock.should.be.xxx
+            mock.should.be.funny
           end
           mock.__verify
         end
 
-        # should.be.xxx(args)
+        # should.be.funny(args)
   
-        def test_should_be_xxx_with_args_passes_args_properly
-           mock = XxxMock.new(true)
+        def test_should_be_funny_with_args_passes_args_properly
+           mock = HandCodedMock.new(true)
           assert_nothing_raised do
-            mock.should.be.yyy(1, 2, 3)
+            mock.should.be.hungry(1, 2, 3)
           end
           mock.__verify
         end
 
-        # should.not.be.xxx
+        # should.not.be.funny
 
-        def test_should_not_be_xxx_should_raise_when_target_doesnt_understand_xxx
+        def test_should_not_be_funny_should_raise_when_target_doesnt_understand_funny
           assert_raise(NoMethodError) do
-            5.should.not.be.xxx
+            5.should.not.be.funny
           end
         end
 
-        def test_should_not_be_xxx_should_raise_when_sending_xxx_to_target_returns_true
-          mock = XxxMock.new(true)
+        def test_should_not_be_funny_should_raise_when_sending_funny_to_target_returns_true
+          mock = HandCodedMock.new(true)
           assert_raise(ExpectationNotMetError) do
-            mock.should.not.be.xxx
+            mock.should.not.be.funny
           end
           mock.__verify
         end
 
-        def test_should_not_be_xxx_shouldnt_raise_when_sending_xxx_to_target_returns_nil
-          mock = XxxMock.new(nil)
+        def test_should_not_be_funny_shouldnt_raise_when_sending_funny_to_target_returns_nil
+          mock = HandCodedMock.new(nil)
           assert_nothing_raised do
-            mock.should.not.be.xxx
+            mock.should.not.be.funny
           end
           mock.__verify
         end
 
-        def test_should_not_be_xxx_shouldnt_raise_when_sending_xxx_to_target_returns_false
-          mock = XxxMock.new(false)
+        def test_should_not_be_funny_shouldnt_raise_when_sending_funny_to_target_returns_false
+          mock = HandCodedMock.new(false)
           assert_nothing_raised do
-            mock.should.not.be.xxx
+            mock.should.not.be.funny
           end
           mock.__verify
         end
 
-        def test_should_not_be_xxx_should_raise_when_sending_xxx_to_target_returns_something_other_than_true_false_or_nil
-          mock = XxxMock.new(5)
+        def test_should_not_be_funny_should_raise_when_sending_funny_to_target_returns_something_other_than_true_false_or_nil
+          mock = HandCodedMock.new(5)
           assert_raise(ExpectationNotMetError) do
-            mock.should.not.be.xxx
+            mock.should.not.be.funny
           end
           mock.__verify
         end
   
-        # should.be.xxx(args)
+        # should.be.funny(args)
   
-        def test_should_not_be_xxx_with_args_passes_args_properly
-           mock = XxxMock.new(false)
+        def test_should_not_be_funny_with_args_passes_args_properly
+           mock = HandCodedMock.new(false)
           assert_nothing_raised do
-            mock.should.not.be.yyy(1, 2, 3)
+            mock.should.not.be.hungry(1, 2, 3)
           end
           mock.__verify
         end

data/test/spec/api/helper/diff_test.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/../../../test_helper'
 
 module Spec
   class DiffTest < Test::Unit::TestCase
-    def test_should_output_unified_diff
+    def test_should_output_unified_diff_of_two_strings
       expected = <<-EOF
 foo
 bar

data/test/spec/api/helper/identity_test.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/../../../test_helper'
 module Spec
   module Api
     module Helper
-      class IdentityTest < Test::Unit::TestCase
+      class ShouldBeTest < Test::Unit::TestCase
 
         def setup
           @dummy = 'dummy'
@@ -12,51 +12,58 @@ module Spec
           @nil_var = nil
         end
 
-        def test_should_be_same_as_should_not_raise_when_objects_are_same
+        def test_should_not_raise_when_objects_are_same
           assert_nothing_raised do
             @dummy.should.be @dummy
           end
         end
 
-        def test_should_be_same_as_should_raise_when_objects_are_not_same
+        def test_should_raise_when_objects_are_not_same
           assert_raise(ExpectationNotMetError) do
             @dummy.should.be @equal_dummy
           end
         end
 
-        def test_should_be_nil_should_not_raise_when_object_is_nil
+        def test_should_not_raise_when_both_objects_are_nil
           assert_nothing_raised do
             @nil_var.should.be nil
           end  
         end
 
-        def test_should_be_nil_should_raise_when_object_is_not_nil
+        def test_should_raise_when_object_is_not_nil
           assert_raise(ExpectationNotMetError) do
             @dummy.should.be nil
           end
         end
+      end
 
-        # should.not.be
+      class ShouldNotBeTest < Test::Unit::TestCase
+        def setup
+          @dummy = 'dummy'
+          @equal_dummy = 'dummy'
+          @another_dummy  = 'another_dummy'
+          @nil_var = nil
+        end
 
-        def test_should_not_be_same_as_should_not_raise_when_objects_are_not_same
+        def test_should_not_raise_when_objects_are_not_same
           assert_nothing_raised do
             @dummy.should.not.be @equal_dummy
           end
         end
 
-        def test_should_not_be_same_as_should_raise_when_objects_are_not_same
+        def test_should_raise_when_objects_are_same
           assert_raise(ExpectationNotMetError) do
             @dummy.should.not.be @dummy
           end
         end
 
-        def test_should_not_be_nil_should_not_raise_when_object_is_not_nil
+        def test_should_not_raise_when_left_is_not_nil_and_right_is_nil
           assert_nothing_raised do
             @dummy.should.not.be nil
           end  
         end
 
-        def test_should_not_be_nil_should_raise_when_object_is_nil
+        def test_should_raise_when_both_objects_are_nil
           assert_raise(ExpectationNotMetError) do
             @nil_var.should.not.be nil
           end

data/test/spec/api/helper/{equality_test.rb → object_equality_test.rb}

@@ -3,52 +3,38 @@ require File.dirname(__FILE__) + '/../../../test_helper'
 module Spec
   module Api
     module Helper
-      class EqualityTest < Test::Unit::TestCase
+      class ShouldEqualTest < Test::Unit::TestCase
 
-        def setup
-          @dummy = 'dummy'
-          @equal_dummy = 'dummy'
-          @another_dummy  = 'another_dummy'
-          @nil_var = nil
-        end
-
-        # should.equal
-  
-        def test_should_equal_should_not_raise_when_objects_are_equal
+        def test_should_not_raise_when_objects_are_equal
           assert_nothing_raised do
-            @dummy.should.equal @equal_dummy
+            'apple'.should.equal 'apple'
           end
         end
   
-        def test_should_equal_should_raise_when_objects_are_not_equal
+        def test_should_raise_when_objects_are_not_equal
           assert_raise(ExpectationNotMetError) do
-            @dummy.should.equal @another_dummy
+            'apple'.should.equal 'orange'
           end
-        end
-        
-        def test_should_raise_nice_message
-          begin
-            "foo\nbar\nzap".should_equal "foo\nzap\nbar"
-          rescue ExpectationNotMetError => e
-            assert_equal "\"foo\\nbar\\nzap\" should equal \"foo\\nzap\\nbar\"", e.message
-          end
-        end
+        end        
+      end
 
-        # should.not.equal
+      class ShouldNotEqualTest < Test::Unit::TestCase
 
-        def test_should_not_equal_should_not_raise_when_objects_are_not_equal
+        def test_should_not_raise_when_objects_are_not_equal
           assert_nothing_raised do
-            @dummy.should.not.equal @another_dummy
+            'apple'.should.not.equal 'orange'
           end
         end
 
         def test_should_not_equal_should_raise_when_objects_are_equal
           assert_raise(ExpectationNotMetError) do
-            @dummy.should.not.equal @equal_dummy
+            'apple'.should.not.equal 'apple'
           end
         end
+      end
 
-        def test_should_be_close_good_cases
+      class ShouldBeCloseTest < Test::Unit::TestCase
+        def test_should_not_raise_when_values_are_within_bounds
           assert_nothing_raised do
             3.5.should.be.close 3.5, 0.5
             3.5.should.be.close 3.1, 0.5
@@ -58,7 +44,7 @@ module Spec
           end
         end
         
-        def test_should_be_close_failing_cases
+        def test_should_raise_when_values_are_outside_bounds
           assert_raise(ExpectationNotMetError) do
             3.5.should.be.close 3.0, 0.5
           end