rspec 0.8.2 → 0.9.0

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

@@ -2,24 +2,22 @@ module Spec
   module Runner
     module Formatter
       class ProgressBarFormatter < BaseTextFormatter
-        def add_context(name, first)
-          @output.puts if first
-          STDOUT.flush
+        def add_behaviour(name)
         end
       
-        def spec_failed(name, counter, failure)
+        def example_failed(name, counter, failure)
           @output.print failure.expectation_not_met? ? red('F') : magenta('F')
-          STDOUT.flush
+          @output.flush
         end
 
-        def spec_passed(name)
+        def example_passed(name)
           @output.print green('.')
-          STDOUT.flush
+          @output.flush
         end
       
         def start_dump
           @output.puts
-          STDOUT.flush
+          @output.flush
         end
       end
     end

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

@@ -2,19 +2,19 @@ module Spec
   module Runner
     module Formatter
       class RdocFormatter < BaseTextFormatter
-        def add_context(name, first)
+        def add_behaviour(name)
           @output.print "# #{name}\n"
-          STDOUT.flush
+          @output.flush
         end
   
-        def spec_passed(name)
+        def example_passed(name)
           @output.print "# * #{name}\n"
-          STDOUT.flush
+          @output.flush
         end
 
-        def spec_failed(name, counter, failure)
+        def example_failed(name, counter, failure)
           @output.print "# * #{name} [#{counter} - FAILED]\n"
-          STDOUT.flush
+          @output.flush
         end
       end
     end

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

@@ -0,0 +1,52 @@
+module Spec
+  module Runner
+    module Formatter
+      # This class extracts code snippets by looking at the backtrace of the passed error
+      class SnippetExtractor #:nodoc:
+        class NullConverter; def convert(code, pre); code; end; end #:nodoc:
+        begin; require 'rubygems'; require 'syntax/convertors/html'; @@converter = Syntax::Convertors::HTML.for_syntax "ruby"; rescue LoadError => e; @@converter = NullConverter.new; end
+        
+        def snippet(error)
+          raw_code, line = snippet_for(error.backtrace[0])
+          highlighted = @@converter.convert(raw_code, false)
+          highlighted << "\n<span class=\"comment\"># gem install syntax to get syntax highlighting</span>" if @@converter.is_a?(NullConverter)
+          post_process(highlighted, line)
+        end
+        
+        def snippet_for(error_line)
+          if error_line =~ /(.*):(\d+)/
+            file = $1
+            line = $2.to_i
+            [lines_around(file, line), line]
+          else
+            ["# Couldn't get snippet for #{error_line}", 1]
+          end
+        end
+        
+        def lines_around(file, line)
+          if File.file?(file)
+            lines = File.open(file).read.split("\n")
+            min = [0, line-3].max
+            max = [line+1, lines.length-1].min
+            selected_lines = []
+            selected_lines.join("\n")
+            lines[min..max].join("\n")
+          else
+            "# Couldn't get snippet for #{file}"
+          end
+        end
+        
+        def post_process(highlighted, offending_line)
+          new_lines = []
+          highlighted.split("\n").each_with_index do |line, i|
+            new_line = "<span class=\"linenum\">#{offending_line+i-2}</span>#{line}"
+            new_line = "<span class=\"offending\">#{new_line}</span>" if i == 2
+            new_lines << new_line
+          end
+          new_lines.join("\n")
+        end
+        
+      end
+    end
+  end
+end

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

@@ -2,20 +2,20 @@ module Spec
   module Runner
     module Formatter
       class SpecdocFormatter < BaseTextFormatter      
-        def add_context(name, first)
+        def add_behaviour(name)
           @output.puts
           @output.puts name
-          STDOUT.flush
+          @output.flush
         end
       
-        def spec_failed(name, counter, failure)
+        def example_failed(name, counter, failure)
           @output.puts failure.expectation_not_met? ? red("- #{name} (FAILED - #{counter})") : magenta("- #{name} (ERROR - #{counter})")
-          STDOUT.flush
+          @output.flush
         end
       
-        def spec_passed(name)
+        def example_passed(name)
           @output.print green("- #{name}\n")
-          STDOUT.flush
+          @output.flush
         end
       end
     end

data/lib/spec/runner/heckle_runner.rb

@@ -13,9 +13,9 @@ module Spec
         @heckle_class = heckle_class
       end
       
-      # Runs all the contexts held by +context_runner+ once for each of the 
+      # Runs all the contexts held by +behaviour_runner+ once for each of the 
       # methods in the matched classes.
-      def heckle_with(context_runner)
+      def heckle_with(behaviour_runner)
         if @filter =~ /(.*)[#\.](.*)/
           heckle_method($1, $2)
         else
@@ -25,7 +25,7 @@ module Spec
       
       def heckle_method(class_name, method_name)
         verify_constant(class_name)
-        heckle = @heckle_class.new(class_name, method_name, context_runner)
+        heckle = @heckle_class.new(class_name, method_name, behaviour_runner)
         heckle.validate
       end
       
@@ -39,7 +39,7 @@ module Spec
         
         classes.each do |klass|
           klass.instance_methods(false).each do |method_name|
-            heckle = @heckle_class.new(klass.name, method_name, context_runner)
+            heckle = @heckle_class.new(klass.name, method_name, behaviour_runner)
             heckle.validate
           end
         end
@@ -57,13 +57,14 @@ module Spec
     
     #Supports Heckle 1.2 and prior (earlier versions used Heckle::Base)
     class Heckler < (Heckle.const_defined?(:Base) ? Heckle::Base : Heckle)
-      def initialize(klass_name, method_name, context_runner)
+      def initialize(klass_name, method_name, behaviour_runner)
         super(klass_name, method_name)
-        @context_runner = context_runner
+        @behaviour_runner = behaviour_runner
       end
 
       def tests_pass?
-        failure_count = @context_runner.run(false)
+        paths = [] # We can pass an empty array of paths - our specs are already loaded.
+        failure_count = @behaviour_runner.run(paths, false)
         failure_count == 0
       end
     end

data/lib/spec/runner/option_parser.rb

@@ -1,27 +1,40 @@
-require 'ostruct'
 require 'optparse'
-require 'spec/runner/spec_parser'
-require 'spec/runner/formatter'
-require 'spec/runner/backtrace_tweaker'
-require 'spec/runner/reporter'
-require 'spec/runner/context_runner'
+require 'stringio'
 
 module Spec
   module Runner
     class OptionParser
+      BUILT_IN_FORMATTERS = {
+        'specdoc'  => Formatter::SpecdocFormatter,
+        's'        => Formatter::SpecdocFormatter,
+        'html'     => Formatter::HtmlFormatter,
+        'h'        => Formatter::HtmlFormatter,
+        'rdoc'     => Formatter::RdocFormatter,
+        'r'        => Formatter::RdocFormatter,
+        'progress' => Formatter::ProgressBarFormatter,
+        'p'        => Formatter::ProgressBarFormatter,
+        'failing_examples' => Formatter::FailingExamplesFormatter,
+        'e'        => Formatter::FailingExamplesFormatter,
+        'failing_behaviours' => Formatter::FailingBehavioursFormatter,
+        'b'        => Formatter::FailingBehavioursFormatter
+      }
+
       def initialize
         @spec_parser = SpecParser.new
         @file_factory = File
       end
 
-      def create_context_runner(args, err, out, warn_if_no_files)
+      def create_behaviour_runner(args, err, out, warn_if_no_files)
         options = parse(args, err, out, warn_if_no_files)
         # Some exit points in parse (--generate-options, --drb) don't return the options, 
         # but hand over control. In that case we don't want to continue.
-        return nil unless options.is_a?(OpenStruct)
+        return nil unless options.is_a?(Options)
 
-        formatter = options.formatter_type.new(options.out, options.dry_run, options.colour)
-        options.reporter = Reporter.new(formatter, options.backtrace_tweaker) 
+        options.formatters.each do |formatter|
+          formatter.colour = options.colour if formatter.respond_to?(:colour=)
+          formatter.dry_run = options.dry_run if formatter.respond_to?(:dry_run=)
+        end
+        options.reporter = Reporter.new(options.formatters, options.backtrace_tweaker) 
 
         # this doesn't really belong here.
         # it should, but the way things are coupled, it doesn't
@@ -30,21 +43,24 @@ module Spec
         end
 
         unless options.generate
-          ContextRunner.new(options)  
+          if options.runner_type
+            options.runner_type.new(options)
+          else
+            BehaviourRunner.new(options)  
+          end
         end
       end
 
       def parse(args, err, out, warn_if_no_files)
         options_file = nil
         args_copy = args.dup
-        options = OpenStruct.new
-        options.out = (out == STDOUT ? Kernel : out)
-        options.formatter_type = Formatter::ProgressBarFormatter
+        options = Options.new
+        options.formatters = []
         options.backtrace_tweaker = QuietBacktraceTweaker.new
-        options.spec_name = nil
+        options.examples = []
 
         opts = ::OptionParser.new do |opts|
-          opts.banner = "Usage: spec [options] (FILE|DIRECTORY|GLOB)+"
+          opts.banner = "Usage: spec (FILE|DIRECTORY|GLOB)+ [options]"
           opts.separator ""
 
           opts.on("-D", "--diff [FORMAT]", "Show diff of objects that are expected to be equal when they are not",
@@ -82,38 +98,74 @@ module Spec
             options.colour = true
           end
           
-          opts.on("-s", "--spec SPECIFICATION_NAME", "Execute context or specification with matching name") do |spec_name|
-            options.spec_name = spec_name
+          opts.on("-e", "--example [NAME|FILE_NAME]", "Execute example(s) with matching name(s). If the argument is",
+                                                      "the path to an existing file (typically generated by a previous",
+                                                      "run using --format failing_examples:file.txt), then the examples",
+                                                      "on each line of that file will be executed. If the file is empty,",
+                                                      "all examples will be run (as if --example was not specified).",
+                                                      " ",
+                                                      "If the argument is not an existing file, then it is treated as",
+                                                      "an example name directly, causing RSpec to run just the example",
+                                                      "matching that name") do |example|
+            if(File.file?(example))
+              options.examples = File.open(example).read.split("\n")
+            else
+              options.examples = [example]
+            end
           end
-          
-          opts.on("-l", "--line LINE_NUMBER", Integer, "Execute context or specification at given line") do |line_number|
+
+          opts.on("-s", "--spec [NAME]", "DEPRECATED - use -e instead", "(This will be removed when autotest works with -e)") do |example|
+            if(File.file?(example))
+              options.examples = File.open(example).read.split("\n")
+            else
+              options.examples = [example]
+            end
+          end
+
+          opts.on("-l", "--line LINE_NUMBER", Integer, "Execute behaviour or example at given line.",
+                                                       "(does not work for dynamically generated specs)") do |line_number|
             options.line_number = line_number.to_i
           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 = Formatter::SpecdocFormatter
-              when 'html', 'h'
-                options.formatter_type = Formatter::HtmlFormatter
-              when 'rdoc', 'r'
-                options.formatter_type = Formatter::RdocFormatter
-                options.dry_run = true
+          opts.on("-f", "--format FORMAT[:WHERE]",  "Specifies what format to use for output. Specify WHERE to tell", 
+                                                    "the formatter where to write the output. All built-in formats", 
+                                                    "expect WHERE to be a file name, and will write to STDOUT if it's",
+                                                    "not specified. The --format option may be specified several times",
+                                                    "if you want several outputs",
+                                                    " ",
+                                                    "Builtin formats: ",
+                                                    "progress|p           : Text progress", 
+                                                    "specdoc|s            : Behaviour doc as text", 
+                                                    "rdoc|r               : Behaviour doc as RDoc", 
+                                                    "html|h               : A nice HTML report", 
+                                                    "failing_examples|e   : Write all failing examples - input for --example", 
+                                                    "failing_behaviours|b : Write all failing behaviours - input for --example", 
+                                                    " ",
+                                                    "FORMAT can also be the name of a custom formatter class",
+                                                    "(in which case you should also specify --require to load it)") do |format|
+            
+            where = out
+            # This funky regexp checks whether we have a FILE_NAME or not
+            if (format =~ /([a-zA-Z_]+(?:::[a-zA-Z_]+)*):?(.*)/) && ($2 != '')
+              format = $1
+              where = $2
             else
-              begin
-                options.formatter_type = eval(format)
-              rescue NameError
-                err.puts "Couldn't find formatter class #{format}"
-                err.puts "Make sure the --require option is specified *before* --format"
-                exit if out == $stdout
-              end
+              raise "When using several --format options only one of them can be without a file" if @out_used
+              @out_used = true
+            end
+
+            begin
+              formatter_type = BUILT_IN_FORMATTERS[format] || eval(format)
+              options.formatters << formatter_type.new(where)
+            rescue NameError
+              err.puts "Couldn't find formatter class #{format}"
+              err.puts "Make sure the --require option is specified *before* --format"
+              exit if out == $stdout
             end
           end
 
           opts.on("-r", "--require FILE", "Require FILE before running specs",
-                                          "Useful for loading custom formatters or other extensions",
+                                          "Useful for loading custom formatters or other extensions.",
                                           "If this option is used it must come before the others") do |req|
             req.split(",").each{|file| require file}
           end
@@ -121,31 +173,45 @@ module Spec
           opts.on("-b", "--backtrace", "Output full backtrace") do
             options.backtrace_tweaker = NoisyBacktraceTweaker.new
           end
+          
+          opts.on("-L", "--loadby STRATEGY", "Specify the strategy by which spec files should be loaded.",
+                                              "STRATEGY can currently only be 'mtime' (File modification time)",
+                                              "By default, spec files are loaded in alphabetical order if --loadby",
+                                              "is not specified.") do |loadby|
+            options.loadby = loadby
+          end
+
+          opts.on("-R", "--reverse", "Run examples in reverse order") do
+            options.reverse = true
+          end
+          
+          opts.on("-t", "--timeout FLOAT", "Interrupt and fail each example that doesn't complete in the",
+                                             "specified time") do |timeout|
+            options.timeout = timeout.to_f
+          end
 
-          opts.on("-H", "--heckle CODE", "If all specs pass, this will run your specs many times, mutating",
-                                         "the specced code a little each time. The intent is that specs",
-                                         "*should* fail, and RSpec will tell you if they don't.",
-                                         "CODE should be either Some::Module, Some::Class or Some::Fabulous#method}") do |heckle|
+          opts.on("-H", "--heckle CODE", "If all examples pass, this will mutate the classes and methods", 
+                                         "identified by CODE little by little and run all the examples again",
+                                         "for each mutation. The intent is that for each mutation, at least",
+                                         "one example *should* fail, and RSpec will tell you if this is not the",
+                                         "case. CODE should be either Some::Module, Some::Class or",
+                                         "Some::Fabulous#method") do |heckle|
             heckle_runner = PLATFORM == 'i386-mswin32' ? 'spec/runner/heckle_runner_win' : 'spec/runner/heckle_runner'
             require heckle_runner
             options.heckle_runner = HeckleRunner.new(heckle)
           end
           
-          opts.on("-d", "--dry-run", "Don't execute specs") do
+          opts.on("-d", "--dry-run", "Invokes formatters without executing the examples.") do
             options.dry_run = true
           end
           
-          opts.on("-o", "--out OUTPUT_FILE", "Path to output file (defaults to STDOUT)") do |out_file|
-            options.out = File.new(out_file, 'w')
-          end
-          
           opts.on("-O", "--options PATH", "Read options from a file") do |options_file|
             # Remove the --options option and the argument before writing to file
             index = args_copy.index("-O") || args_copy.index("--options")
             args_copy.delete_at(index)
             args_copy.delete_at(index)
 
-            new_args = args_copy + IO.readlines(options_file).each {|s| s.chomp!}
+            new_args = args_copy + IO.readlines(options_file).map {|l| l.chomp.split " "}.flatten
             return CommandLine.run(new_args, err, out, true, warn_if_no_files)
           end
 
@@ -162,12 +228,22 @@ module Spec
             out.puts "spec --options #{options_file}"
             options.generate = true
           end
+
+          opts.on("-U", "--runner RUNNER", "Use a custom BehaviourRunner.") do |runner|
+            begin
+              options.runner_type = eval(runner)
+            rescue NameError
+              err.puts "Couldn't find behaviour runner class #{runner}"
+              err.puts "Make sure the --require option is specified."
+              exit if out == $stdout
+            end
+          end
           
-          opts.on("-X", "--drb", "Run specs via DRb. (For example against script/rails_spec_server)") do |options_file|
-            # Remove the --options option and the argument before writing to file
+          opts.on("-X", "--drb", "Run examples via DRb. (For example against script/spec_server)") do |options_file|
+            # Remove the --drb option
             index = args_copy.index("-X") || args_copy.index("--drb")
             args_copy.delete_at(index)
-
+            
             return DrbCommandLine.run(args_copy, err, out, true, warn_if_no_files)
           end
 
@@ -193,16 +269,21 @@ module Spec
         if options.line_number
           set_spec_from_line_number(options, args, err)
         end
+        
+        if options.formatters.empty?
+          options.formatters << Formatter::ProgressBarFormatter.new(out)
+        end
 
         options
       end
       
       def set_spec_from_line_number(options, args, err)
-        unless options.spec_name
+        if options.examples.empty?
           if args.length == 1
             if @file_factory.file?(args[0])
               source = @file_factory.open(args[0])
-              options.spec_name = @spec_parser.spec_name_for(source, options.line_number)
+              example = @spec_parser.spec_name_for(source, options.line_number)
+              options.examples = [example]
             elsif @file_factory.directory?(args[0])
               err.puts "You must specify one file, not a directory when using the --line option"
               exit(1) if err == $stderr
@@ -215,7 +296,7 @@ module Spec
             exit(3) if err == $stderr
           end
         else
-          err.puts "You cannot use both --line and --spec"
+          err.puts "You cannot use both --line and --example"
           exit(4) if err == $stderr
         end
       end