rspec 0.5.3 → 0.5.4

data/lib/spec/runner/context_runner.rb

@@ -3,50 +3,39 @@ require File.dirname(__FILE__) + '/../../spec'
 module Spec
   module Runner
     class ContextRunner
+      attr_reader :standalone
       
-      def self.standalone(context, args=ARGV)
-        context_runner = ContextRunner.new(args, true)
-        context_runner.add_context context
-        context_runner.run
-      end
- 
-      def initialize(args, standalone=false, err=$stderr)
-        options = OptionParser.parse(args, standalone, err)
+      def initialize(reporter, standalone, dry_run, single_spec=nil)
         @contexts = []
-        @out = options.out
-        @out = File.open(@out, 'w') if @out.is_a? String
-        @doc = options.doc
-        @listener = RDocFormatter.new(@out) if @doc
-        @listener = SimpleTextReporter.new(@out, options.verbose) unless @doc
+        @reporter = reporter
+        @standalone = standalone
+        @dry_run = dry_run
+        @single_spec = single_spec
       end
     
       def add_context(context)
+        return if !@single_spec.nil? unless context.matches?@single_spec
+        context.isolate @single_spec if context.matches?@single_spec
         @contexts << context
-        self
       end
       
-      def run
-        run_specs unless @doc
-        run_docs if @doc
-      end
-    
-      private
-      
-      def run_specs
-        @listener.start
+      def run(exit_when_done=false)
+        @reporter.start number_of_specs
         @contexts.each do |context|
-          context.run(@listener)
+          context.run(@reporter, @dry_run)
+        end
+        @reporter.end
+        failure_count = @reporter.dump
+        if(exit_when_done)
+          exit_code = (failure_count == 0) ? 0 : 1
+          exit!(exit_code)
         end
-        @listener.end
-        @listener.dump
       end
     
-      def run_docs
-        @contexts.each do |context|
-          context.run_docs(@listener)
-        end
+      def number_of_specs
+        @contexts.inject(0) {|sum, context| sum + context.number_of_specs}
       end
-
+      
     end
   end
 end

data/lib/spec/runner/execution_context.rb

@@ -5,14 +5,14 @@ module Spec
         @spec = spec
       end
       
-      def mock(name)
-        mock = Api::Mock.new(name)
+      def mock(name, options={})
+        mock = Api::Mock.new(name, options)
         @spec.add_mock(mock)
         mock
       end
       
       def duck_type(*args)
-        return Api::DuckType.new(*args)
+        return Api::DuckTypeArgConstraint.new(*args)
       end
       
       def violated(message="")

data/lib/spec/runner/kernel_ext.rb

@@ -1,5 +1,14 @@
 module Kernel
   def context(name, &block)
-    Spec::Runner::Context.new(name, &block)
+    context = Spec::Runner::Context.new(name, &block)
+    runner = context_runner
+    runner.add_context(context)
+    runner.run if runner.standalone
+  end
+  
+private
+  
+  def context_runner
+    $context_runner || ::Spec::Runner::OptionParser.create_context_runner(ARGV.dup, true, STDERR, STDOUT)
   end
 end

data/lib/spec/runner/option_parser.rb

@@ -1,34 +1,50 @@
 require 'ostruct'
 require 'optparse'
+
 module Spec
   module Runner
     class OptionParser
 
-      def self.parse(args, standalone=false, err=$stderr, out=$stdout)
+      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)
+        reporter = Reporter.new(formatter, options.backtrace_tweaker) 
+        ContextRunner.new(reporter, standalone, options.dry_run, options.spec_name)
+      end
+
+      def self.parse(args, standalone, err, out)
         options = OpenStruct.new
         options.out = out
-        options.verbose = false
-        options.doc = false
+        options.formatter_type = ProgressBarFormatter
+        options.backtrace_tweaker = QuietBacktraceTweaker.new
+        options.spec_name = nil
 
         opts = ::OptionParser.new do |opts|
           opts.banner = "Usage: spec [options] (FILE|DIRECTORY)+"
           opts.separator ""
 
-          opts.on("-o", "--of [FILE]", "Set the output file (defaults to STDOUT)") do |outfile|
-            options.out = StringIO.new if outfile == "stringio"
-            options.out = outfile unless outfile.nil? or outfile == "stringio"
-            exit if outfile.nil?
+          opts.on("-b", "--backtrace", "Output full backtrace") do
+            options.backtrace_tweaker = NoisyBacktraceTweaker.new
           end
-
-          opts.on("-v", "--verbose", "Verbose output") do
-            options.verbose = true
+          
+          opts.on("-f", "--format FORMAT", "Output format (specdoc|s|rdoc|r)") do |format|
+            options.formatter_type = SpecdocFormatter if format == 'specdoc'
+            options.formatter_type = SpecdocFormatter if format == 's'
+            options.formatter_type = RdocFormatter if format == 'rdoc'
+            options.formatter_type = RdocFormatter if format == 'r'
+            options.dry_run = true if format == 'rdoc'
           end
 
-          opts.on("-d", "--doc", "Output specdoc only") do
-            options.doc = true
+          opts.on("-d", "--dry-run", "Don't execute specs") do
+            options.dry_run = true
+          end
+          
+          opts.on("-s", "--spec SPECIFICATION_NAME", "Execute a single specification") do |spec_name|
+            options.spec_name = spec_name
           end
 
-          opts.on("--version", "Show version") do
+          opts.on("-v", "--version", "Show version") do
             out.puts ::Spec::VERSION::DESCRIPTION
             exit if out == $stdout
           end
@@ -37,13 +53,15 @@ module Spec
             out.puts opts
             exit if out == $stdout
           end
-
+          
         end
         opts.parse!(args)
+
         if args.empty?
           err.puts opts unless standalone
           exit if err == $stderr unless standalone
         end
+
         options
       end
     end

data/lib/spec/runner/progress_bar_formatter.rb

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

data/lib/spec/runner/rdoc_formatter.rb

@@ -1,17 +1,27 @@
 module Spec
   module Runner
-    class RDocFormatter
-      def initialize(output=STDOUT)
-        @output = output
+    class RdocFormatter < BaseTextFormatter
+      def initialize(output, dry_run=false)
+        super(output, true) # always dry
       end
   
-      def add_context(name)
+      def add_context(name, first)
         @output << "# #{name}\n"
       end
   
-      def add_spec(name)
+      def spec_passed(name)
         @output << "# * #{name}\n"
       end
+
+      def spec_failed(name, counter)
+        @output << "# * #{name} [#{counter} - FAILED]\n"
+      end
+      
+      def dump_failure(counter, failure)
+      end
+      
+      def start_dump
+      end
     end
   end
 end

data/lib/spec/runner/reporter.rb

@@ -0,0 +1,100 @@
+module Spec
+  module Runner
+    class Reporter
+      # TODO: remove this attr_reader!!
+      attr_reader :formatter
+      
+      def initialize(formatter, backtrace_tweaker)
+        @formatter = formatter
+        @context_names = []
+        @failures = []
+        @spec_names = []
+        @backtrace_tweaker = backtrace_tweaker
+      end
+  
+      def add_context(name)
+        #TODO - @context_names.empty? tells the formatter whether this is the first context or not - that's a little slippery
+        @formatter.add_context(name, @context_names.empty?)
+        @context_names << name
+      end
+      
+      def add_spec(name, error=nil, failure_location=nil)
+        if error.nil?
+          spec_passed(name)
+        else
+          @backtrace_tweaker.tweak_backtrace(error, failure_location)
+          spec_failed(name, Failure.new(@context_names.last, name, error))
+        end
+      end
+      
+      def start(number_of_specs=0)
+        @start_time = Time.new
+      end
+  
+      def end
+        @end_time = Time.new
+      end
+  
+      # Dumps the summary and returns the total number of failures
+      def dump
+        @formatter.start_dump
+        dump_failures
+        @formatter.dump_summary(duration, @context_names.length, @spec_names.length, @failures.length)
+        @failures.length
+      end
+
+      private
+  
+      def dump_failures
+        return if @failures.empty?
+        @failures.inject(1) do |index, failure|
+          @formatter.dump_failure(index, failure)
+          index + 1
+        end
+      end
+
+      def duration
+        return @end_time - @start_time unless (@end_time.nil? or @start_time.nil?)
+        return "0.0"
+      end
+
+      def spec_passed(name)
+        @spec_names << name
+        @formatter.spec_passed(name)
+      end
+
+      def spec_failed(name, failure)
+        @spec_names << name
+        @failures << failure
+        @formatter.spec_failed(name, @failures.length)
+      end
+
+      class Failure
+        def initialize(context_name, spec_name, error)
+          @context_name = context_name
+          @spec_name = spec_name
+          @error = error
+        end
+
+        def header
+          "#{class_name} in '#{@context_name} #{@spec_name}'"
+        end
+
+        def message
+          @error.message
+        end
+
+        def backtrace
+          @error.backtrace.join("\n") unless @error.backtrace.nil?
+        end
+
+        private
+
+        def class_name
+          @error.class.name.split('::').last
+        end
+
+      end
+    end
+  end
+end

data/lib/spec/runner/specdoc_formatter.rb

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

data/lib/spec/runner/specification.rb

@@ -6,37 +6,57 @@ module Spec
         @name = name
         @block = block
         @mocks = []
-        @errors = []
       end
     
-      def run(reporter=nil, setup_block=nil, teardown_block=nil)
-        execution_context = ::Spec::Runner::ExecutionContext.new(self)
-        begin
-          execution_context.instance_exec(&setup_block) unless setup_block.nil?
-          execution_context.instance_exec(&@block)
-        rescue => e
-          @errors << e
-        end
+      def run(reporter=nil, setup_block=nil, teardown_block=nil, dry_run=false)
+        if dry_run
+          reporter.add_spec(@name)
+        else
+          execution_context = ::Spec::Runner::ExecutionContext.new(self)
+          errors = []
+          begin
+            execution_context.instance_exec(&setup_block) unless setup_block.nil?
+            setup_ok = true
+            execution_context.instance_exec(&@block)
+            spec_ok = true
+          rescue => e
+            errors << e
+          end
 
-        begin
-          execution_context.instance_exec(&teardown_block) unless teardown_block.nil?
-          @mocks.each do |mock|
-            mock.__verify
+          begin
+            execution_context.instance_exec(&teardown_block) unless teardown_block.nil?
+            teardown_ok = true
+            @mocks.each do |mock|
+              mock.__verify
+            end
+          rescue => e
+            errors << e
           end
-        rescue => e
-          @errors << e
-        end
 
-        reporter.add_spec(@name, @errors) unless reporter.nil?
-      end
-    
-      def run_docs(reporter)
-        reporter.add_spec(@name)
+          reporter.add_spec(@name, first_error(errors), failure_location(setup_ok, spec_ok, teardown_ok)) unless reporter.nil?
+        end
       end
-    
+      
       def add_mock(mock)
         @mocks << mock
       end
+      
+      def matches? name
+        name == @name
+      end
+
+      private
+      
+      def first_error errors
+        errors[0]
+      end
+      
+      def failure_location(setup_ok, spec_ok, teardown_ok)
+        return 'setup' unless setup_ok
+        return @name unless spec_ok
+        return 'teardown' unless teardown_ok
+      end
+    
     end
   end
 end

data/lib/spec/version.rb

@@ -3,7 +3,7 @@ module Spec
     unless defined? MAJOR
       MAJOR = 0
       MINOR = 5
-      TINY  = 3
+      TINY  = 4
 
       STRING = [MAJOR, MINOR, TINY].join('.')