rspec 1.0.8 → 1.1.0

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

@@ -0,0 +1,16 @@
+require 'spec/runner/formatter/html_formatter'
+
+module Spec
+  module Runner
+    module Formatter
+      # Formats backtraces so they're clickable by TextMate
+      class TextMateFormatter < HtmlFormatter
+        def backtrace_line(line)
+          line.gsub(/([^:]*\.rb):(\d*)/) do
+            "<a href=\"txmt://open?url=file://#{File.expand_path($1)}&line=#{$2}\">#{$1}:#{$2}</a> "
+          end
+        end
+      end
+    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 +behaviour_runner+ once for each of the 
+      # Runs all the example groups held by +rspec_options+ once for each of the
       # methods in the matched classes.
-      def heckle_with(behaviour_runner)
+      def heckle_with
         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, behaviour_runner)
+        heckle = @heckle_class.new(class_name, method_name, rspec_options)
         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, behaviour_runner)
+            heckle = @heckle_class.new(klass.name, method_name, rspec_options)
             heckle.validate
           end
         end
@@ -57,16 +57,16 @@ 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, behaviour_runner)
+      def initialize(klass_name, method_name, rspec_options)
         super(klass_name, method_name)
-        @behaviour_runner = behaviour_runner
+        @rspec_options = rspec_options
       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
+        success = @rspec_options.run_examples
+        success
       end
+
     end
   end
 end

data/lib/spec/runner/option_parser.rb

@@ -3,23 +3,18 @@ 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
+      end
+
+      attr_reader :options
 
-      COMMAND_LINE = {
+      OPTIONS = {
         :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",
@@ -43,13 +38,17 @@ module Spec
                                                     "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",
+                                                    "Builtin formats for examples: ",
+                                                    "progress|p               : Text progress",
+                                                    "profile|o                : Text progress with profiling of 10 slowest examples",
+                                                    "specdoc|s                : Example doc as text",
+                                                    "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",
+                                                    " ",
+                                                    "Builtin formats for stories: ",
+                                                    "plain|p              : Plain Text",
                                                     "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)"],
@@ -73,155 +72,158 @@ 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."],
         :drb => ["-X", "--drb", "Run examples via DRb. (For example against script/spec_server)"],
         :version => ["-v", "--version", "Show version"],
         :help => ["-h", "--help", "You're looking at it"]
       }
 
-      def initialize
+      def initialize(err, out)
+        super()
+        @error_stream = err
+        @out_stream = out
+        @options = Options.new(@error_stream, @out_stream)
+
         @spec_parser = SpecParser.new
         @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.configure
-        options.behaviour_runner
-      end
-
-      def parse(args, err, out, warn_if_no_files)
-        options_file = nil
-        args_copy = args.dup
-        options = Options.new(err, out)
-
-        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)}
-
-          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)}
-
-          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}
-
-          opts.rspec_on(:reverse) {options.reverse = true}
-
-          opts.rspec_on(:timeout) {|timeout| options.timeout = timeout.to_f}
-
-          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)
-          end
-
-          opts.rspec_on(:runner) do |runner|
-            options.runner_arg = runner
-          end
-
-          opts.rspec_on(:drb) do
-            return parse_drb(args_copy, out, err, warn_if_no_files)
-          end
-
-          opts.rspec_on(:version) {parse_version(out)}
-
-          opts.on_tail(*COMMAND_LINE[:help]) {parse_help(opts, out)}
+        self.banner = "Usage: spec (FILE|DIRECTORY|GLOB)+ [options]"
+        self.separator ""
+        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| parse_options_file(options_file)}
+        on(*OPTIONS[:generate_options]) do |options_file|
         end
-        opts.parse!(args)
-
-        if args.empty? && warn_if_no_files
-          err.puts "No files specified."
-          err.puts opts
-          exit(6) if err == $stderr
+        on(*OPTIONS[:runner]) do |runner|
+          @options.user_input_for_runner = runner
         end
+        on(*OPTIONS[:drb]) {}
+        on(*OPTIONS[:version]) {parse_version}
+        on_tail(*OPTIONS[:help]) {parse_help}
+      end
 
-        if options.line_number
-          set_spec_from_line_number(options, args, err)
+      def order!(argv, &blk)
+        @argv = argv
+        @options.argv = @argv.dup
+        return if parse_generate_options
+        return if parse_drb
+        
+        super(@argv) do |file|
+          @options.files << file
+          blk.call(file) if blk
         end
 
-        if options.formatters.empty?
-          options.formatters << Formatter::ProgressBarFormatter.new(out)
+        if @options.line_number
+          set_spec_from_line_number
         end
 
-        options
+        @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)
-
-        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)
+      protected
+      def invoke_requires(requires)
+        requires.split(",").each do |file|
+          require file
+        end
+      end
+      
+      def parse_options_file(options_file)
+        option_file_args = IO.readlines(options_file).map {|l| l.chomp.split " "}.flatten
+        @argv.push(*option_file_args)
       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_generate_options
+        # Remove the --generate-options option and the argument before writing to file
+        options_file = nil
+        ['-G', '--generate-options'].each do |option|
+          if index = @argv.index(option)
+            @argv.delete_at(index)
+            options_file = @argv.delete_at(index)
+          end
+        end
+        
+        if options_file
+          write_generated_options(options_file)
+          return true
+        else
+          return false
+        end
+      end
+      
+      def write_generated_options(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
 
-        return DrbCommandLine.run(args_copy, error_stream, out_stream, true, warn_if_no_files)
+      def parse_drb
+        is_drb = false
+        argv = @options.argv
+        is_drb ||= argv.delete(OPTIONS[:drb][0])
+        is_drb ||= argv.delete(OPTIONS[:drb][1])
+        return nil unless is_drb
+        @options.examples_should_not_be_run
+        DrbCommandLine.run(
+          self.class.parse(argv, @error_stream, @out_stream)
+        )
+        true
       end
 
-      def parse_version(out_stream)
-        out_stream.puts ::Spec::VERSION::DESCRIPTION
-        exit if out_stream == $stdout
+      def parse_version
+        @out_stream.puts ::Spec::VERSION::DESCRIPTION
+        exit if stdout?
       end
 
-      def parse_help(opts, out_stream)
-        out_stream.puts opts
-        exit if out_stream == $stdout
+      def parse_help
+        @out_stream.puts self
+        exit if 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
+      def set_spec_from_line_number
+        if @options.examples.empty?
+          if @options.files.length == 1
+            if @file_factory.file?(@options.files[0])
+              source = @file_factory.open(@options.files[0])
+              example = @spec_parser.spec_name_for(source, @options.line_number)
+              @options.parse_example(example)
+            elsif @file_factory.directory?(@options.files[0])
+              @error_stream.puts "You must specify one file, not a directory when using the --line option"
+              exit(1) if stderr?
             else
-              err.puts "#{args[0]} does not exist"
-              exit(2) if err == $stderr
+              @error_stream.puts "#{@options.files[0]} does not exist"
+              exit(2) if stderr?
             end
           else
-            err.puts "Only one file can be specified when using the --line option: #{args.inspect}"
-            exit(3) if err == $stderr
+            @error_stream.puts "Only one file can be specified when using the --line option: #{@options.files.inspect}"
+            exit(3) if stderr?
           end
         else
-          err.puts "You cannot use both --line and --example"
-          exit(4) if err == $stderr
+          @error_stream.puts "You cannot use both --line and --example"
+          exit(4) if stderr?
         end
       end
+
+      def stdout?
+        @out_stream == $stdout
+      end
+
+      def stderr?
+        @error_stream == $stderr
+      end
     end
   end
 end

data/lib/spec/runner/options.rb

@@ -1,32 +1,40 @@
 module Spec
   module Runner
     class Options
-      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
+      FILE_SORTERS = {
+        'mtime' => lambda {|file_a, file_b| File.mtime(file_b) <=> File.mtime(file_a)}
       }
-      
+
+      EXAMPLE_FORMATTERS = { # Load these lazily for better speed
+               'specdoc' => ['spec/runner/formatter/specdoc_formatter',                'Formatter::SpecdocFormatter'],
+                     's' => ['spec/runner/formatter/specdoc_formatter',                'Formatter::SpecdocFormatter'],
+                  'html' => ['spec/runner/formatter/html_formatter',                   'Formatter::HtmlFormatter'],
+                     'h' => ['spec/runner/formatter/html_formatter',                   'Formatter::HtmlFormatter'],
+              'progress' => ['spec/runner/formatter/progress_bar_formatter',           'Formatter::ProgressBarFormatter'],
+                     'p' => ['spec/runner/formatter/progress_bar_formatter',           'Formatter::ProgressBarFormatter'],
+      'failing_examples' => ['spec/runner/formatter/failing_examples_formatter',       'Formatter::FailingExamplesFormatter'],
+                     'e' => ['spec/runner/formatter/failing_examples_formatter',       'Formatter::FailingExamplesFormatter'],
+'failing_example_groups' => ['spec/runner/formatter/failing_example_groups_formatter', 'Formatter::FailingExampleGroupsFormatter'],
+                     'g' => ['spec/runner/formatter/failing_example_groups_formatter', 'Formatter::FailingExampleGroupsFormatter'],
+               'profile' => ['spec/runner/formatter/profile_formatter',                'Formatter::ProfileFormatter'],
+                     'o' => ['spec/runner/formatter/profile_formatter',                'Formatter::ProfileFormatter'],
+              'textmate' => ['spec/runner/formatter/text_mate_formatter',              'Formatter::TextMateFormatter']
+      }
+
+      STORY_FORMATTERS = {
+        'plain' => ['spec/runner/formatter/story/plain_text_formatter', 'Formatter::Story::PlainTextFormatter'],
+            'p' => ['spec/runner/formatter/story/plain_text_formatter', 'Formatter::Story::PlainTextFormatter'],
+         'html' => ['spec/runner/formatter/story/html_formatter',       'Formatter::Story::HtmlFormatter'],
+            'h' => ['spec/runner/formatter/story/html_formatter',       'Formatter::Story::HtmlFormatter']
+      }
+
       attr_accessor(
         :backtrace_tweaker,
-        :colour,
         :context_lines,
         :diff_format,
-        :differ_class,
         :dry_run,
+        :profile,
         :examples,
-        :failure_file,
-        :formatters,
-        :generate,
         :heckle_runner,
         :line_number,
         :loadby,
@@ -34,69 +42,83 @@ module Spec
         :reverse,
         :timeout,
         :verbose,
-        :runner_arg,
-        :behaviour_runner
+        :user_input_for_runner,
+        :error_stream,
+        :output_stream,
+        # TODO: BT - Figure out a better name
+        :argv
       )
+      attr_reader :colour, :differ_class, :files, :example_groups
 
-      def initialize(err, out)
-        @err, @out = err, out
+      def initialize(error_stream, output_stream)
+        @error_stream = error_stream
+        @output_stream = output_stream
         @backtrace_tweaker = QuietBacktraceTweaker.new
         @examples = []
-        @formatters = []
         @colour = false
+        @profile = false
         @dry_run = false
+        @reporter = Reporter.new(self)
+        @context_lines = 3
+        @diff_format  = :unified
+        @files = []
+        @example_groups = []
+        @examples_run = false
+        @examples_should_be_run = nil
+        @user_input_for_runner = nil
       end
 
-      def configure
-        configure_formatters
-        create_reporter
-        configure_differ
-        create_behaviour_runner
+      def add_example_group(example_group)
+        @example_groups << example_group
       end
 
-      def create_behaviour_runner
-        return nil if @generate
-        @behaviour_runner = if @runner_arg
-          klass_name, arg = split_at_colon(@runner_arg)
-          runner_type = load_class(klass_name, 'behaviour runner', '--runner')
-          runner_type.new(self, arg)
-        else
-          BehaviourRunner.new(self)
-        end
+      def remove_example_group(example_group)
+        @example_groups.delete(example_group)
       end
 
-      def configure_formatters
-        @formatters.each do |formatter|
-          formatter.colour = @colour if formatter.respond_to?(:colour=)
-          formatter.dry_run = @dry_run if formatter.respond_to?(:dry_run=)
+      def run_examples
+        return true unless examples_should_be_run?
+        runner = custom_runner || ExampleGroupRunner.new(self)
+
+        runner.load_files(files_to_load)
+        if example_groups.empty?
+          true
+        else
+          success = runner.run
+          @examples_run = true
+          heckle if heckle_runner
+          success
         end
       end
 
-      def create_reporter
-        @reporter = Reporter.new(@formatters, @backtrace_tweaker)
+      def examples_run?
+        @examples_run
       end
 
-      def configure_differ
-        if @differ_class
-          Spec::Expectations.differ = @differ_class.new(@diff_format, @context_lines, @colour)
+      def examples_should_not_be_run
+        @examples_should_be_run = false
+      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
 
       def parse_diff(format)
-        @context_lines = 3
         case format
-          when :context, 'context', 'c'
-            @diff_format  = :context
-          when :unified, 'unified', 'u', '', nil
-            @diff_format  = :unified
-        end
-
-        if [:context,:unified].include? @diff_format
-          require 'spec/expectations/differs/default'
-          @differ_class = Spec::Expectations::Differs::Default
+        when :context, 'context', 'c'
+          @diff_format  = :context
+          default_differ
+        when :unified, 'unified', 'u', '', nil
+          @diff_format  = :unified
+          default_differ
         else
           @diff_format  = :custom
-          @differ_class = load_class(format, 'differ', '--diff')
+          self.differ_class = load_class(format, 'differ', '--diff')
         end
       end
 
@@ -109,67 +131,123 @@ module Spec
       end
 
       def parse_format(format_arg)
-        format, where = split_at_colon(format_arg)
-        # This funky regexp checks whether we have a FILE_NAME or not
-        if where.nil?
+        format, where = ClassAndArgumentsParser.parse(format_arg)
+        unless where
           raise "When using several --format options only one of them can be without a file" if @out_used
-          where = @out
+          where = @output_stream
           @out_used = true
         end
-
-        formatter_type = BUILT_IN_FORMATTERS[format] || load_class(format, 'formatter', '--format')
-        @formatters << formatter_type.new(where)
+        @format_options ||= []
+        @format_options << [format, where]
+      end
+      
+      def formatters
+        @format_options ||= [['progress', @output_stream]]
+        @formatters ||= load_formatters(@format_options, EXAMPLE_FORMATTERS)
       end
 
-      def parse_require(req)
-        req.split(",").each{|file| require file}
+      def story_formatters
+        @format_options ||= [['plain', @output_stream]]
+        @formatters ||= load_formatters(@format_options, STORY_FORMATTERS)
+      end
+      
+      def load_formatters(format_options, formatters)
+        format_options.map do |format, where|
+          formatter_type = if formatters[format]
+            require formatters[format][0]
+            eval(formatters[format][1], binding, __FILE__, __LINE__)
+          else
+            load_class(format, 'formatter', '--format')
+          end
+          formatter_type.new(self, where)
+        end
       end
 
-      def parse_heckle(heckle)
-        heckle_require = [/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM} ? 'spec/runner/heckle_runner_unsupported' : 'spec/runner/heckle_runner'
-        require heckle_require
+      def load_heckle_runner(heckle)
+        suffix = [/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM} ? '_unsupported' : ''
+        require "spec/runner/heckle_runner#{suffix}"
         @heckle_runner = HeckleRunner.new(heckle)
       end
 
-      def parse_generate_options(options_file, args_copy, out_stream)
-        # Remove the --generate-options option and the argument before writing to file
-        index = args_copy.index("-G") || args_copy.index("--generate-options")
-        args_copy.delete_at(index)
-        args_copy.delete_at(index)
-        File.open(options_file, 'w') do |io|
-          io.puts args_copy.join("\n")
+      def number_of_examples
+        @example_groups.inject(0) do |sum, example_group|
+          sum + example_group.number_of_examples
         end
-        out_stream.puts "\nOptions written to #{options_file}. You can now use these options with:"
-        out_stream.puts "spec --options #{options_file}"
-        @generate = true
       end
 
-      def split_at_colon(s)
-        if s =~ /([a-zA-Z_]+(?:::[a-zA-Z_]+)*):?(.*)/
-          arg = $2 == "" ? nil : $2
-          [$1, arg]
-        else
-          raise "Couldn't parse #{s.inspect}"
-        end
+      protected
+      def examples_should_be_run?
+        return @examples_should_be_run unless @examples_should_be_run.nil?
+        @examples_should_be_run = true
       end
       
+      def differ_class=(klass)
+        return unless klass
+        @differ_class = klass
+        Spec::Expectations.differ = self.differ_class.new(self)
+      end
+
       def load_class(name, kind, option)
         if name =~ /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/
           arg = $2 == "" ? nil : $2
           [$1, arg]
         else
           m = "#{name.inspect} is not a valid class name"
-          @err.puts m
+          @error_stream.puts m
           raise m
         end
         begin
           eval(name, binding, __FILE__, __LINE__)
         rescue NameError => e
-          @err.puts "Couldn't find #{kind} class #{name}"
-          @err.puts "Make sure the --require option is specified *before* #{option}"
+          @error_stream.puts "Couldn't find #{kind} class #{name}"
+          @error_stream.puts "Make sure the --require option is specified *before* #{option}"
           if $_spec_spec ; raise e ; else exit(1) ; end
         end
       end
+      
+      def files_to_load
+        result = []
+        sorted_files.each do |file|
+          if test ?d, file
+            result += Dir[File.expand_path("#{file}/**/*.rb")]
+          elsif test ?f, file
+            result << file
+          else
+            raise "File or directory not found: #{file}"
+          end
+        end
+        result
+      end
+      
+      def custom_runner
+        return nil unless custom_runner?
+        klass_name, arg = ClassAndArgumentsParser.parse(user_input_for_runner)
+        runner_type = load_class(klass_name, 'behaviour runner', '--runner')
+        return runner_type.new(self, arg)
+      end
+
+      def custom_runner?
+        return user_input_for_runner ? true : false
+      end
+      
+      def heckle
+        returns = self.heckle_runner.heckle_with
+        self.heckle_runner = nil
+        returns
+      end
+      
+      def sorted_files
+        return sorter ? files.sort(&sorter) : files
+      end
+
+      def sorter
+        FILE_SORTERS[loadby]
+      end
+
+      def default_differ
+        require 'spec/expectations/differs/default'
+        self.differ_class = Spec::Expectations::Differs::Default
+      end
     end
   end
 end