rspec 1.0.0 → 1.3.1

data/lib/spec/runner/heckle_runner.rb

@@ -1,72 +1,72 @@
-begin
-  require 'rubygems'
-  require 'heckle'
-rescue LoadError ; raise "You must gem install heckle to use --heckle" ; end
+if Spec::Ruby.version.to_f < 1.9
+  begin
+    require 'rubygems' unless ENV['NO_RUBYGEMS']
+    require 'heckle'
+  rescue LoadError ; raise "You must gem install heckle to use --heckle" ; end
 
-module Spec
-  module Runner
-    # Creates a new Heckler configured to heckle all methods in the classes
-    # whose name matches +filter+
-    class HeckleRunner
-      def initialize(filter, heckle_class=Heckler)
-        @filter = filter
-        @heckle_class = heckle_class
-      end
-      
-      # Runs all the contexts held by +behaviour_runner+ once for each of the 
-      # methods in the matched classes.
-      def heckle_with(behaviour_runner)
-        if @filter =~ /(.*)[#\.](.*)/
-          heckle_method($1, $2)
-        else
-          heckle_class_or_module(@filter)
+  module Spec
+    module Runner
+      # Creates a new Heckler configured to heckle all methods in the classes
+      # whose name matches +filter+
+      class HeckleRunner
+        def initialize(filter, heckle_class=Heckler)
+          @filter = filter
+          @heckle_class = heckle_class
         end
-      end
       
-      def heckle_method(class_name, method_name)
-        verify_constant(class_name)
-        heckle = @heckle_class.new(class_name, method_name, behaviour_runner)
-        heckle.validate
-      end
+        # Runs all the example groups held by +rspec_options+ once for each of the
+        # methods in the matched classes.
+        def heckle_with
+          if @filter =~ /(.*)[#\.](.*)/
+            heckle_method($1, $2)
+          else
+            heckle_class_or_module(@filter)
+          end
+        end
       
-      def heckle_class_or_module(class_or_module_name)
-        verify_constant(class_or_module_name)
-        pattern = /^#{class_or_module_name}/
-        classes = []
-        ObjectSpace.each_object(Class) do |klass|
-          classes << klass if klass.name =~ pattern
+        def heckle_method(class_name, method_name)
+          verify_constant(class_name)
+          heckle = @heckle_class.new(class_name, method_name, Spec::Runner.options)
+          heckle.validate
         end
+      
+        def heckle_class_or_module(class_or_module_name)
+          verify_constant(class_or_module_name)
+          pattern = /^#{class_or_module_name}/
+          classes = []
+          ObjectSpace.each_object(Class) do |klass|
+            classes << klass if klass.name =~ pattern
+          end
         
-        classes.each do |klass|
-          klass.instance_methods(false).each do |method_name|
-            heckle = @heckle_class.new(klass.name, method_name, behaviour_runner)
-            heckle.validate
+          classes.each do |klass|
+            klass.instance_methods(false).each do |method_name|
+              heckle = @heckle_class.new(klass.name, method_name, Spec::Runner.options)
+              heckle.validate
+            end
           end
         end
-      end
       
-      def verify_constant(name)
-        begin
-          # This is defined in Heckle
-          name.to_class
-        rescue
-          raise "Heckling failed - \"#{name}\" is not a known class or module"
+        def verify_constant(name)
+          begin
+            # This is defined in Heckle
+            name.to_class
+          rescue
+            raise "Heckling failed - \"#{name}\" is not a known class or module"
+          end
         end
       end
-    end
     
-    #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, behaviour_runner)
-        super(klass_name, method_name)
-        @behaviour_runner = behaviour_runner
-      end
+      class Heckler < Heckle
+        def initialize(klass_name, method_name, rspec_options)
+          super(klass_name, method_name)
+          @rspec_options = rspec_options
+        end
+
+        def tests_pass?
+          @rspec_options.run_examples
+        end
 
-      def tests_pass?
-        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
   end
-end
+end

data/lib/spec/runner/{heckle_runner_win.rb → heckle_runner_unsupported.rb}

@@ -1,10 +1,10 @@
-module Spec
-  module Runner
-    # Dummy implementation for Windows that just fails (Heckle is not supported on Windows)
-    class HeckleRunner
-      def initialize(filter)
-        raise "Heckle not supported on Windows"
-      end
-    end
-  end
-end
+module Spec
+  module Runner
+    # Dummy implementation for Windows that just fails (Heckle is not supported on Windows)
+    class HeckleRunner
+      def initialize(filter)
+        raise "Heckle is not supported on Windows or Ruby 1.9"
+      end
+    end
+  end
+end

data/lib/spec/runner/line_number_query.rb

@@ -0,0 +1,78 @@
+module Spec
+  module Runner
+    # Parses a spec file and finds the nearest example for a given line number.
+    class LineNumberQuery
+      attr_reader :best_match
+
+      def initialize(run_options)
+        @best_match = {}
+        @run_options = run_options
+      end
+
+      def spec_name_for(file, line_number)
+        best_match.clear
+        file = File.expand_path(file)
+        determine_best_match(file, line_number)
+        if best_match[:example_group]
+          if best_match[:example]
+            "#{best_match[:example_group].description} #{best_match[:example].description}"
+          else
+            best_match[:example_group].description
+          end
+        else
+          nil
+        end
+      end
+
+      def example_line_for(file, line_number)
+        determine_best_match(file, line_number)
+        best_match[:line]
+      end
+    
+    protected
+    
+      def determine_best_match(file, line_number)
+        best_match.clear
+        file = File.expand_path(file)
+        @run_options.example_groups.each do |example_group|
+          next unless example_group.location
+          consider_example_group_for_best_match(example_group, file, line_number)
+
+          example_group.examples.each do |example|
+            consider_example_for_best_match(example, example_group, file, line_number)
+          end
+        end
+      end
+
+      def consider_example_group_for_best_match(example_group, file, line_number)
+        example_group_file, example_group_line = parse_location(example_group.location)
+        if is_best_match?(file, line_number, example_group_file, example_group_line)
+          best_match.clear
+          best_match[:example_group] = example_group
+          best_match[:line] = example_group_line
+        end
+      end
+
+      def consider_example_for_best_match(example, example_group, file, line_number)
+        example_file, example_line = parse_location(example.location)
+        if is_best_match?(file, line_number, example_file, example_line)
+          best_match.clear
+          best_match[:example_group] = example_group
+          best_match[:example] = example
+          best_match[:line] = example_line
+        end
+      end
+
+      def is_best_match?(file, line_number, example_file, example_line)
+        file == File.expand_path(example_file) &&
+                example_line <= line_number &&
+                example_line > best_match[:line].to_i
+      end
+      
+      def parse_location(location)
+        location =~ /(.*)\:(\d*)(\:|$)/
+        return $1, Integer($2)
+      end
+    end
+  end
+end

data/lib/spec/runner/option_parser.rb

@@ -3,24 +3,27 @@ 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
-      }
+    class OptionParser < ::OptionParser
+      class << self
+        def parse(args, err, out)
+          parser = new(err, out)
+          parser.parse(args)
+          parser.options
+        end
+
+        def spec_command?
+          $0.split('/').last == 'spec'
+        end
+      end
+
+      attr_reader :options
 
-      COMMAND_LINE = {
-        :diff =>    ["-D", "--diff [FORMAT]", "Show diff of objects that are expected to be equal when they are not",
+      OPTIONS = {
+        :pattern => ["-p", "--pattern [PATTERN]","Limit files loaded to those matching this pattern. Defaults to '**/*_spec.rb'",
+                                                 "Separate multiple patterns with commas.",
+                                                 "Applies only to directories named on the command line (files",
+                                                 "named explicitly on the command line will be loaded regardless)."],
+        :diff =>    ["-D", "--diff [FORMAT]","Show diff of objects that are expected to be equal when they are not",
                                              "Builtin formats: unified|u|context|c",
                                              "You can also specify a custom differ class",
                                              "(in which case you should also specify --require)"],
@@ -28,39 +31,40 @@ module Spec
         :example => ["-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 thatfile will be executed. If the file is empty,",
+                                                          "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"],
         :specification => ["-s", "--specification [NAME]", "DEPRECATED - use -e instead", "(This will be removed when autotest works with -e)"],
-        :line => ["-l", "--line LINE_NUMBER", Integer, "Execute behaviout or specification at given line.",
-                                                       "(does not work for dynamically generated specs)"],
-        :format => ["-f", "--format FORMAT[:WHERE]",  "Specifies what format to use for output. Specify WHERE to tell",
+        :line => ["-l", "--line LINE_NUMBER", Integer, "Execute example group or example at given line.",
+                                                       "(does not work for dynamically generated examples)"],
+        :format => ["-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",
+                                                    "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",
+                                                    "Builtin formats:",
+                                                    "silent|l                 : No output",                                                    "progress|p               : Text-based progress bar",
+                                                    "profile|o                : Text-based progress bar with profiling of 10 slowest examples",
+                                                    "specdoc|s                : Code example doc strings",
+                                                    "nested|n                 : Code example doc strings with nested groups indented",
+                                                    "html|h                   : A nice HTML report",
+                                                    "failing_examples|e       : Write all failing examples - input for --example",
+                                                    "failing_example_groups|g : Write all failing example groups - 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)"],
         :require => ["-r", "--require FILE", "Require FILE before running specs",
-                                          "Useful for loading custom formatters or other extensions.",
-                                          "If this option is used it must come before the others"],
+                                             "Useful for loading custom formatters or other extensions.",
+                                             "If this option is used it must come before the others"],
         :backtrace => ["-b", "--backtrace", "Output full backtrace"],
         :loadby => ["-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."],
+                                               "STRATEGY can currently only be 'mtime' (File modification time)",
+                                               "By default, spec files are loaded in alphabetical order if --loadby",
+                                               "is not specified."],
         :reverse => ["-R", "--reverse", "Run examples in reverse order"],
         :timeout => ["-t", "--timeout FLOAT", "Interrupt and fail each example that doesn't complete in the",
                                               "specified time"],
@@ -73,153 +77,148 @@ module Spec
         :dry_run => ["-d", "--dry-run", "Invokes formatters without executing the examples."],
         :options_file => ["-O", "--options PATH", "Read options from a file"],
         :generate_options => ["-G", "--generate-options PATH", "Generate an options file for --options"],
-        :runner => ["-U", "--runner RUNNER", "Use a custom BehaviourRunner."],
+        :runner => ["-U", "--runner RUNNER", "Use a custom Runner."],
+        :debug => ["-u", "--debugger", "Enable ruby-debugging."],
         :drb => ["-X", "--drb", "Run examples via DRb. (For example against script/spec_server)"],
+        :drb_port => ["--port PORT", "Port for DRb server. (Ignored without --drb)"],
         :version => ["-v", "--version", "Show version"],
         :help => ["-h", "--help", "You're looking at it"]
       }
 
-      def initialize
-        @spec_parser = SpecParser.new
+      def initialize(err, out)
+        super()
+        @error_stream = err
+        @out_stream = out
+        @options = Options.new(@error_stream, @out_stream)
+
         @file_factory = File
-      end
 
-      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?(Options)
-        options.create_behaviour_runner
+        self.banner = "Usage: spec (FILE(:LINE)?|DIRECTORY|GLOB)+ [options]"
+        self.separator ""
+        on(*OPTIONS[:pattern])          {|pattern| @options.filename_pattern = pattern}
+        on(*OPTIONS[:diff])             {|diff| @options.parse_diff(diff)}
+        on(*OPTIONS[:colour])           {@options.colour = true}
+        on(*OPTIONS[:example])          {|example| @options.parse_example(example)}
+        on(*OPTIONS[:specification])    {|example| @options.parse_example(example)}
+        on(*OPTIONS[:line])             {|line_number| @options.line_number = line_number.to_i}
+        on(*OPTIONS[:format])           {|format| @options.parse_format(format)}
+        on(*OPTIONS[:require])          {|requires| invoke_requires(requires)}
+        on(*OPTIONS[:backtrace])        {@options.backtrace_tweaker = NoisyBacktraceTweaker.new}
+        on(*OPTIONS[:loadby])           {|loadby| @options.loadby = loadby}
+        on(*OPTIONS[:reverse])          {@options.reverse = true}
+        on(*OPTIONS[:timeout])          {|timeout| @options.timeout = timeout.to_f}
+        on(*OPTIONS[:heckle])           {|heckle| @options.load_heckle_runner(heckle)}
+        on(*OPTIONS[:dry_run])          {@options.dry_run = true}
+        on(*OPTIONS[:options_file])     {|options_file|}
+        on(*OPTIONS[:generate_options]) {|options_file|}
+        on(*OPTIONS[:runner])           {|runner|  @options.user_input_for_runner = runner}
+        on(*OPTIONS[:debug])            {@options.debug = true}
+        on(*OPTIONS[:drb])              {}
+        on(*OPTIONS[:drb_port])         {|port| @options.drb_port = port}
+        on(*OPTIONS[:version])          {parse_version}
+        on("--autospec")                {@options.autospec = true}
+        on_tail(*OPTIONS[:help])        {parse_help}
       end
 
-      def parse(args, err, out, warn_if_no_files)
-        options_file = nil
-        args_copy = args.dup
-        options = Options.new
-
-        opts = ::OptionParser.new do |opts|
-          opts.banner = "Usage: spec (FILE|DIRECTORY|GLOB)+ [options]"
-          opts.separator ""
-
-          def opts.rspec_on(name, &block)
-            on(*COMMAND_LINE[name], &block)
-          end
-
-          opts.rspec_on(:diff) {|diff| options.parse_diff(diff, out, err)}
-
-          opts.rspec_on(:colour) {options.colour = true}
-
-          opts.rspec_on(:example) {|example| options.parse_example(example)}
-
-          opts.rspec_on(:specification) {|example| options.parse_example(example)}
-
-          opts.rspec_on(:line) {|line_number| options.line_number = line_number.to_i}
-
-          opts.rspec_on(:format) {|format| options.parse_format(format, out, err)}
-
-          opts.rspec_on(:require) {|req| options.parse_require(req)}
-
-          opts.rspec_on(:backtrace) {options.backtrace_tweaker = NoisyBacktraceTweaker.new}
-
-          opts.rspec_on(:loadby) {|loadby| options.loadby = loadby}
+      def order!(argv, &blk)
+        @argv = argv.dup
+        @argv = (@argv.empty? & self.class.spec_command?) ? ['--help'] : @argv
 
-          opts.rspec_on(:reverse) {options.reverse = true}
+        # Parse options file first
+        parse_file_options(:options_file, :parse_options_file)
 
-          opts.rspec_on(:timeout) {|timeout| options.timeout = timeout.to_f}
+        @options.argv = @argv.dup
+        return if parse_file_options(:generate_options, :write_options_file)
+        return if parse_drb
 
-          opts.rspec_on(:heckle) {|heckle| options.parse_heckle(heckle)}
-          
-          opts.rspec_on(:dry_run) {options.dry_run = true}
-
-          opts.rspec_on(:options_file) do |options_file|
-            return parse_options_file(options_file, out, err, args_copy, warn_if_no_files)
-          end
-
-          opts.rspec_on(:generate_options) do |options_file|
-            options.parse_generate_options(options_file, args_copy, out)
+        super(@argv) do |file|
+          if file =~ /^(.+):(\d+)$/
+            file = $1
+            @options.line_number = $2.to_i
           end
 
-          opts.rspec_on(:runner) do |runner|
-            options.parse_runner(runner, out, err)
-          end
+          @options.files << file
+          blk.call(file) if blk
+        end
 
-          opts.rspec_on(:drb) do
-            return parse_drb(args_copy, out, err, warn_if_no_files)
-          end
+        @options
+      end
 
-          opts.rspec_on(:version) {parse_version(out)}
+    protected
 
-          opts.on_tail(*COMMAND_LINE[:help]) {parse_help(opts, out)}
+      def invoke_requires(requires)
+        requires.split(",").each do |file|
+          require file
         end
-        opts.parse!(args)
+      end
 
-        if args.empty? && warn_if_no_files
-          err.puts "No files specified."
-          err.puts opts
-          exit(6) if err == $stderr
+      def parse_file_options(option_name, action)
+        # Remove the file option and the argument before handling the file
+        options_file = nil
+        options_list = OPTIONS[option_name][0..1]
+        options_list[1].gsub!(" PATH", "")
+        options_list.each do |option|
+          if index = @argv.index(option)
+            @argv.delete_at(index)
+            options_file = @argv.delete_at(index)
+          end
         end
-
-        if options.line_number
-          set_spec_from_line_number(options, args, err)
+        
+        if options_file.nil? &&
+           File.exist?('spec/spec.opts') &&
+           !@argv.any?{|a| a =~ /^\-/ }
+             options_file = 'spec/spec.opts'
         end
 
-        if options.formatters.empty?
-          options.formatters << Formatter::ProgressBarFormatter.new(out)
+        if options_file
+          send(action, options_file)
+          return true
+        else
+          return false
         end
-
-        options
       end
 
-      def parse_options_file(options_file, out_stream, error_stream, args_copy, warn_if_no_files)
-        # 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)
+      def parse_options_file(options_file)
+        option_file_args = File.readlines(options_file).map {|l| l.chomp.split " "}.flatten
+        @argv.push(*option_file_args)
+      end
 
-        new_args = args_copy + IO.readlines(options_file).map {|l| l.chomp.split " "}.flatten
-        return CommandLine.run(new_args, error_stream, out_stream, true, warn_if_no_files)
+      def write_options_file(options_file)
+        File.open(options_file, 'w') do |io|
+          io.puts @argv.join("\n")
+        end
+        @out_stream.puts "\nOptions written to #{options_file}. You can now use these options with:"
+        @out_stream.puts "spec --options #{options_file}"
+        @options.examples_should_not_be_run
       end
 
-      def parse_drb(args_copy, out_stream, error_stream, warn_if_no_files)
-        # Remove the --drb option
-        index = args_copy.index("-X") || args_copy.index("--drb")
-        args_copy.delete_at(index)
+      def parse_drb
+        argv = @options.argv
+        is_drb = false
+        is_drb ||= argv.delete(OPTIONS[:drb][0])
+        is_drb ||= argv.delete(OPTIONS[:drb][1])
+        return false unless is_drb
+        if DrbCommandLine.run(self.class.parse(argv, @error_stream, @out_stream))
+          @options.examples_should_not_be_run
+          true
+        else
+          @error_stream.puts "Running specs locally:"
+          false
+        end
+      end
 
-        return DrbCommandLine.run(args_copy, error_stream, out_stream, true, warn_if_no_files)
+      def parse_version
+        @out_stream.puts ::Spec::VERSION::SUMMARY
+        exit if stdout?
       end
 
-      def parse_version(out_stream)
-        out_stream.puts ::Spec::VERSION::DESCRIPTION
-        exit if out_stream == $stdout
+      def parse_help
+        @out_stream.puts self
+        exit if stdout?
       end
 
-      def parse_help(opts, out_stream)
-        out_stream.puts opts
-        exit if out_stream == $stdout
-      end      
-
-      def set_spec_from_line_number(options, args, err)
-        if options.examples.empty?
-          if args.length == 1
-            if @file_factory.file?(args[0])
-              source = @file_factory.open(args[0])
-              example = @spec_parser.spec_name_for(source, options.line_number)
-              options.parse_example(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
-            else
-              err.puts "#{args[0]} does not exist"
-              exit(2) if err == $stderr
-            end
-          else
-            err.puts "Only one file can be specified when using the --line option: #{args.inspect}"
-            exit(3) if err == $stderr
-          end
-        else
-          err.puts "You cannot use both --line and --example"
-          exit(4) if err == $stderr
-        end
+      def stdout?
+        @out_stream == $stdout
       end
     end
   end