rspec 1.0.5 → 1.0.6

data/lib/spec/runner/backtrace_tweaker.rb

@@ -33,7 +33,8 @@ module Spec
           /Ruby\.tmbundle\/Support\/tmruby.rb:/,
           /RSpec\.tmbundle\/Support\/lib/,
           /temp_textmate\./,
-          /mock_frameworks\/rspec/
+          /mock_frameworks\/rspec/,
+          /spec_server/
         ]
       end
       

data/lib/spec/runner/behaviour_runner.rb

@@ -2,34 +2,28 @@ module Spec
   module Runner
     class BehaviourRunner
       
-      def initialize(options)
+      def initialize(options, arg=nil)
         @behaviours = []
         @options = options
       end
     
       def add_behaviour(behaviour)
-        if !specified_examples.nil? && !specified_examples.empty? #&& behaviour.matches?(specified_examples)
-          behaviour.retain_examples_matching!(specified_examples) #if behaviour.matches?(specified_examples)
+        if !specified_examples.nil? && !specified_examples.empty?
+          behaviour.retain_examples_matching!(specified_examples)
         end
         @behaviours << behaviour if behaviour.number_of_examples != 0 && !behaviour.shared?
       end
       
-      # Runs all contexts and returns the number of failures.
+      # Runs all behaviours and returns the number of failures.
       def run(paths, exit_when_done)
-        unless paths.nil? # It's nil when running single specs with ruby
-          paths = find_paths(paths)
-          sorted_paths = sort_paths(paths)
-          load_specs(sorted_paths) 
-        end
-        @options.reporter.start(number_of_examples)
-        behaviours = @options.reverse ? @behaviours.reverse : @behaviours
+        prepare!(paths)
         begin
-          run_behaviours(behaviours)
+          run_behaviours
         rescue Interrupt
         ensure
-          @options.reporter.end
+          report_end
         end
-        failure_count = @options.reporter.dump
+        failure_count = report_dump
         
         heckle if(failure_count == 0 && !@options.heckle_runner.nil?)
         
@@ -39,9 +33,28 @@ module Spec
         end
         failure_count
       end
+      
+      def report_end
+        @options.reporter.end
+      end
+      
+      def report_dump
+        @options.reporter.dump
+      end
+      
+      def prepare!(paths)
+        unless paths.nil? # It's nil when running single specs with ruby
+          paths = find_paths(paths)
+          sorted_paths = sort_paths(paths)
+          load_specs(sorted_paths) # This will populate @behaviours via callbacks to add_behaviour
+        end
+        @options.reporter.start(number_of_examples)
+        @behaviours.reverse! if @options.reverse
+        set_sequence_numbers
+      end
 
-      def run_behaviours(behaviours)
-        behaviours.each do |behaviour|
+      def run_behaviours
+        @behaviours.each do |behaviour|
           behaviour.run(@options.reporter, @options.dry_run, @options.reverse, @options.timeout)
         end
       end
@@ -66,6 +79,14 @@ module Spec
 
     private
       
+      # Sets the #number on each Example
+      def set_sequence_numbers
+        number = 0
+        @behaviours.each do |behaviour|
+          number = behaviour.set_sequence_numbers(number, @options.reverse)
+        end
+      end
+      
       def find_paths(paths)
         result = []
         paths.each do |path|

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

@@ -24,26 +24,27 @@ module Spec
         def add_behaviour(name)
         end
 
-        # This method is invoked when an example starts. +name+ is the name of the
-        # example.
-        def example_started(name)
+        # This method is invoked when an +example+ starts.
+        def example_started(example)
         end
 
-        # This method is invoked when an example passes. +name+ is the name of the
-        # example.
-        def example_passed(name)
+        # This method is invoked when an +example+ passes.
+        def example_passed(example)
         end
 
-        # This method is invoked when an example fails, i.e. an exception occurred
-        # inside it (such as a failed should or other exception). +name+ is the name
-        # of the example. +counter+ is the sequence number of the failure
-        # (starting at 1) and +failure+ is the associated Failure object.
-        def example_failed(name, counter, failure)
+        # This method is invoked when an +example+ fails, i.e. an exception occurred
+        # inside it (such as a failed should or other exception). +counter+ is the 
+        # sequence number of the failure (starting at 1) and +failure+ is the associated 
+        # Failure object.
+        def example_failed(example, counter, failure)
         end
         
-        # This method is invoked when an example is not yet implemented (i.e. has not been provided a block). 
+        # This method is invoked when an example is not yet implemented (i.e. has not
+        # been provided a block), or when an ExamplePendingError is raised.
         # +name+ is the name of the example.
-        def example_not_implemented(name)
+        # +message+ is the message from the ExamplePendingError, if it exists, or the
+        # default value of "Not Yet Implemented"
+        def example_pending(behaviour_name, example_name, message)
         end
 
         # This method is invoked after all of the examples have executed. The next method
@@ -58,10 +59,17 @@ module Spec
         def dump_failure(counter, failure)
         end
       
-        # This method is invoked at the very end.
-        def dump_summary(duration, example_count, failure_count, not_implemented_count)
+        # This method is invoked after the dumping of examples and failures.
+        def dump_summary(duration, example_count, failure_count, pending_count)
+        end
+        
+        # This gets invoked after the summary if option is set to do so.
+        def dump_pending
         end
 
+        # This method is invoked at the very end. Allows the formatter to clean up, like closing open streams.
+        def close
+        end
       end
     end
   end

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

@@ -25,38 +25,47 @@ module Spec
           @colour = false
           @dry_run = false
           @snippet_extractor = SnippetExtractor.new
+          @pending_examples = []
+        end
+        
+        def example_pending(behaviour_name, example_name, message)
+          @pending_examples << ["#{behaviour_name} #{example_name}", message]
         end
         
         def colour=(colour)
           @colour = colour
           begin ; require 'Win32/Console/ANSI' if @colour && PLATFORM =~ /win32/ ; rescue LoadError ; raise "You must gem install win32console to use colour on Windows" ; end
-	      end
+        end
 
         def dump_failure(counter, failure)
           @output.puts
           @output.puts "#{counter.to_s})"
+          @output.puts colourise("#{failure.header}\n#{failure.exception.message}", failure)
+          @output.puts format_backtrace(failure.exception.backtrace)
+          @output.flush
+        end
+        
+        def colourise(s, failure)
           if(failure.expectation_not_met?)
-            @output.puts red(failure.header)
-            @output.puts red(failure.exception.message)
+            red(s)
+          elsif(failure.pending_fixed?)
+            blue(s)
           else
-            @output.puts magenta(failure.header)
-            @output.puts magenta(failure.exception.message)
+            magenta(s)
           end
-          @output.puts format_backtrace(failure.exception.backtrace)
-          @output.flush
         end
       
-        def dump_summary(duration, example_count, failure_count, not_implemented_count)
+        def dump_summary(duration, example_count, failure_count, pending_count)
           return if @dry_run
           @output.puts
           @output.puts "Finished in #{duration} seconds"
           @output.puts
 
           summary = "#{example_count} example#{'s' unless example_count == 1}, #{failure_count} failure#{'s' unless failure_count == 1}"
-          summary << ", #{not_implemented_count} not implemented" if not_implemented_count > 0  
+          summary << ", #{pending_count} pending" if pending_count > 0  
 
           if failure_count == 0
-            if not_implemented_count > 0
+            if pending_count > 0
               @output.puts yellow(summary)
             else
               @output.puts green(summary)
@@ -65,8 +74,26 @@ module Spec
             @output.puts red(summary)
           end
           @output.flush
+          dump_pending
         end
 
+        def dump_pending
+          unless @pending_examples.empty?
+            @output.puts
+            @output.puts "Pending:"
+            @pending_examples.each do |pending_example|
+              @output.puts "#{pending_example[0]} (#{pending_example[1]})" 
+            end
+          end
+          @output.flush
+        end
+        
+        def close
+          if IO === @output
+            @output.close 
+          end
+        end
+        
         def format_backtrace(backtrace)
           return "" if backtrace.nil?
           backtrace.map { |line| backtrace_line(line) }.join("\n")
@@ -91,10 +118,11 @@ module Spec
           end
         end
         
-        def red(text); colour(text, "\e[31m"); end
         def green(text); colour(text, "\e[32m"); end
+        def red(text); colour(text, "\e[31m"); end
         def magenta(text); colour(text, "\e[35m"); end
         def yellow(text); colour(text, "\e[33m"); end
+        def blue(text); colour(text, "\e[34m"); end
         
       end
     end

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

@@ -3,10 +3,14 @@ module Spec
     module Formatter
       class FailingBehavioursFormatter < BaseTextFormatter      
         def add_behaviour(behaviour_name)
-          @behaviour_name = behaviour_name
+          if behaviour_name =~ /(.*) \(druby.*\)$/
+            @behaviour_name = $1
+          else
+            @behaviour_name = behaviour_name
+          end
         end
       
-        def example_failed(name, counter, failure)
+        def example_failed(example, counter, failure)
           unless @behaviour_name.nil?
             @output.puts @behaviour_name 
             @behaviour_name = nil
@@ -17,7 +21,7 @@ module Spec
         def dump_failure(counter, failure)
         end
 
-        def dump_summary(duration, example_count, failure_count, not_implemented_count)
+        def dump_summary(duration, example_count, failure_count, pending_count)
         end
       end
     end

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

@@ -6,15 +6,15 @@ module Spec
           @behaviour_name = behaviour_name
         end
       
-        def example_failed(name, counter, failure)
-          @output.puts "#{@behaviour_name} #{name}"
+        def example_failed(example, counter, failure)
+          @output.puts "#{@behaviour_name} #{example.description}"
           @output.flush
         end
 
         def dump_failure(counter, failure)
         end
 
-        def dump_summary(duration, example_count, failure_count, not_implemented_count)
+        def dump_summary(duration, example_count, failure_count, pending_count)
         end
       end
     end

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

@@ -1,7 +1,10 @@
+require 'erb'
+
 module Spec
   module Runner
     module Formatter
       class HtmlFormatter < BaseTextFormatter
+        include ERB::Util # for the #h method
         
         def initialize(output)
           super
@@ -14,7 +17,7 @@ module Spec
           @current_behaviour_number
         end
         
-        # The number of the currently running example
+        # The number of the currently running example (a global counter)
         def current_example_number
           @current_example_number
         end
@@ -37,7 +40,7 @@ module Spec
           end
           @output.puts "<div class=\"behaviour\">"
           @output.puts "  <dl>"
-          @output.puts "  <dt id=\"behaviour_#{current_behaviour_number}\">#{escape(name)}</dt>"
+          @output.puts "  <dt id=\"behaviour_#{current_behaviour_number}\">#{h(name)}</dt>"
           @output.flush
         end
 
@@ -47,26 +50,28 @@ module Spec
           @output.flush
         end
 
-        def example_passed(name)
-          @current_example_number += 1
+        def example_started(example)
+          @current_example_number = example.number
+        end
+
+        def example_passed(example)
           move_progress
-          @output.puts "    <dd class=\"spec passed\"><span class=\"passed_spec_name\">#{escape(name)}</span></dd>"
+          @output.puts "    <dd class=\"spec passed\"><span class=\"passed_spec_name\">#{h(example.description)}</span></dd>"
           @output.flush
         end
 
-        def example_failed(name, counter, failure)
+        def example_failed(example, counter, failure)
           extra = extra_failure_content(failure)
-          
-          @current_example_number += 1
+          failure_style = failure.pending_fixed? ? 'pending_fixed' : 'failed'
           @output.puts "    <script type=\"text/javascript\">makeRed('rspec-header');</script>" unless @header_red
           @header_red = true
           @output.puts "    <script type=\"text/javascript\">makeRed('behaviour_#{current_behaviour_number}');</script>" unless @behaviour_red
           @behaviour_red = true
           move_progress
-          @output.puts "    <dd class=\"spec failed\">"
-          @output.puts "      <span class=\"failed_spec_name\">#{escape(name)}</span>"
+          @output.puts "    <dd class=\"spec #{failure_style}\">"
+          @output.puts "      <span class=\"failed_spec_name\">#{h(example.description)}</span>"
           @output.puts "      <div class=\"failure\" id=\"failure_#{counter}\">"
-          @output.puts "        <div class=\"message\"><pre>#{escape(failure.exception.message)}</pre></div>" unless failure.exception.nil?
+          @output.puts "        <div class=\"message\"><pre>#{h(failure.exception.message)}</pre></div>" unless failure.exception.nil?
           @output.puts "        <div class=\"backtrace\"><pre>#{format_backtrace(failure.exception.backtrace)}</pre></div>" unless failure.exception.nil?
           @output.puts extra unless extra == ""
           @output.puts "      </div>"
@@ -74,14 +79,14 @@ module Spec
           @output.flush
         end
 
-        def example_not_implemented(name)
-          @current_example_number += 1
+        def example_pending(behaviour_name, example_name, message)
           @output.puts "    <script type=\"text/javascript\">makeYellow('rspec-header');</script>" unless @header_red
           @output.puts "    <script type=\"text/javascript\">makeYellow('behaviour_#{current_behaviour_number}');</script>" unless @behaviour_red
           move_progress
-          @output.puts "    <dd class=\"spec not_implemented\"><span class=\"not_implemented_spec_name\">#{escape(name)}</span></dd>"
+          @output.puts "    <dd class=\"spec not_implemented\"><span class=\"not_implemented_spec_name\">#{h(example_name)}</span></dd>"
           @output.flush
         end
+
         # Override this method if you wish to output extra HTML for a failed spec. For example, you
         # could output links to images or other files produced during the specs.
         #
@@ -90,24 +95,20 @@ module Spec
         end
         
         def move_progress
-          percent_done = @example_count == 0 ? 100.0 : (current_example_number.to_f / @example_count.to_f * 1000).to_i / 10.0
+          percent_done = @example_count == 0 ? 100.0 : ((current_example_number + 1).to_f / @example_count.to_f * 1000).to_i / 10.0
           @output.puts "    <script type=\"text/javascript\">moveProgressBar('#{percent_done}');</script>"
           @output.flush
         end
-        
-        def escape(string)
-          string.gsub(/&/n, '&amp;').gsub(/\"/n, '&quot;').gsub(/>/n, '&gt;').gsub(/</n, '&lt;')
-        end
 
         def dump_failure(counter, failure)
         end
 
-        def dump_summary(duration, example_count, failure_count, not_implemented_count)
+        def dump_summary(duration, example_count, failure_count, pending_count)
           if @dry_run
             totals = "This was a dry-run"
           else
             totals = "#{example_count} example#{'s' unless example_count == 1}, #{failure_count} failure#{'s' unless failure_count == 1}"
-            totals << ", #{not_implemented_count} not implemented" if not_implemented_count > 0  
+            totals << ", #{pending_count} pending" if pending_count > 0  
           end
           @output.puts "<script type=\"text/javascript\">document.getElementById('duration').innerHTML = \"Finished in <strong>#{duration} seconds</strong>\";</script>"
           @output.puts "<script type=\"text/javascript\">document.getElementById('totals').innerHTML = \"#{totals}\";</script>"
@@ -264,6 +265,12 @@ dd.spec.not_implemented {
   background: #FCFB98; color: #131313;
 }
 
+dd.spec.pending_fixed {
+  border-left: 5px solid #0000C2;
+  border-bottom: 1px solid #0000C2;
+  color: #0000C2; background: #D3FBFF;
+}
+
 .backtrace {
   color: #000;
   font-size: 12px;
@@ -303,10 +310,10 @@ a {
 
 .ruby .offending { background-color: gray; }
 .ruby .linenum {
-	width: 75px;
-	padding: 0.1em 1em 0.2em 0;
-	color: #000000;
-	background-color: #FFFBD3;
+  width: 75px;
+  padding: 0.1em 1em 0.2em 0;
+  color: #000000;
+  background-color: #FFFBD3;
 }
 EOF
         end

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

@@ -5,18 +5,19 @@ module Spec
         def add_behaviour(name)
         end
       
-        def example_failed(name, counter, failure)
-          @output.print failure.expectation_not_met? ? red('F') : magenta('F')
+        def example_failed(example, counter, failure)
+          @output.print colourise('F', failure)
           @output.flush
         end
 
-        def example_passed(name)
+        def example_passed(example)
           @output.print green('.')
           @output.flush
         end
       
-        def example_not_implemented(name)
-          @output.print yellow('*')
+        def example_pending(behaviour_name, example_name, message)
+          super
+          @output.print yellow('P')
           @output.flush
         end