rspec 1.1.11 → 1.1.12

data/lib/spec/runner/option_parser.rb

@@ -10,6 +10,10 @@ module Spec
           parser.parse(args)
           parser.options
         end
+
+        def spec_command?
+          $0.split('/').last == 'spec'
+        end
       end
 
       attr_reader :options
@@ -34,8 +38,8 @@ module Spec
                                                           "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 behaviour or specification at given line.",
-                                                       "(does not work for dynamically generated specs)"],
+        :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",
@@ -115,10 +119,10 @@ module Spec
         on(*OPTIONS[:version])          {parse_version}
         on_tail(*OPTIONS[:help])        {parse_help}
       end
-
+      
       def order!(argv, &blk)
         @argv = argv.dup
-        @argv = (@argv.empty? && Spec.spec_command?) ? ['--help'] : @argv 
+        @argv = (@argv.empty? && self.class.spec_command?) ? ['--help'] : @argv 
         @options.argv = @argv.dup
         return if parse_generate_options
         return if parse_drb

data/lib/spec/runner/options.rb

@@ -40,7 +40,6 @@ module Spec
         :diff_format,
         :dry_run,
         :profile,
-        :examples,
         :heckle_runner,
         :line_number,
         :loadby,
@@ -51,12 +50,10 @@ module Spec
         :user_input_for_runner,
         :error_stream,
         :output_stream,
-        :before_suite_parts,
-        :after_suite_parts,
         # TODO: BT - Figure out a better name
         :argv
       )
-      attr_reader :colour, :differ_class, :files, :example_groups
+      attr_reader :colour, :differ_class, :files, :examples, :example_groups
       
       def initialize(error_stream, output_stream)
         @error_stream = error_stream
@@ -76,7 +73,6 @@ module Spec
         @examples_run = false
         @examples_should_be_run = nil
         @user_input_for_runner = nil
-        @before_suite_parts = []
         @after_suite_parts = []
       end
 
@@ -123,6 +119,14 @@ module Spec
           end
         end
       end
+      
+      def before_suite_parts
+        Spec::Example::BeforeAndAfterHooks.before_suite_parts
+      end
+      
+      def after_suite_parts
+        Spec::Example::BeforeAndAfterHooks.after_suite_parts
+      end
 
       def examples_run?
         @examples_run
@@ -130,7 +134,17 @@ module Spec
 
       def examples_should_not_be_run
         @examples_should_be_run = false
-      end      
+      end
+      
+      def predicate_matchers
+        # TODO - don't like this dependency - perhaps store these in here instead?
+        Spec::Runner.configuration.predicate_matchers
+      end
+      
+      def mock_framework
+        # TODO - don't like this dependency - perhaps store this in here instead?
+        Spec::Runner.configuration.mock_framework
+      end
 
       def colour=(colour)
         @colour = colour
@@ -163,7 +177,7 @@ module Spec
 
       def parse_example(example)
         if(File.file?(example))
-          @examples = File.open(example).read.split("\n")
+          @examples = [File.open(example).read.split("\n")].flatten
         else
           @examples = [example]
         end
@@ -209,11 +223,8 @@ module Spec
       end
 
       def number_of_examples
-        total = 0
-        @example_groups.each do |example_group|
-          total += example_group.number_of_examples
-        end
-        total
+        return examples.size unless examples.empty?
+        @example_groups.inject(0) {|sum, group| sum + group.number_of_examples}
       end
 
       def files_to_load
@@ -232,6 +243,10 @@ module Spec
         result
       end
       
+      def dry_run?
+        @dry_run == true
+      end
+      
       protected
       def examples_should_be_run?
         return @examples_should_be_run unless @examples_should_be_run.nil?
@@ -265,7 +280,7 @@ module Spec
       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')
+        runner_type = load_class(klass_name, 'example group runner', '--runner')
         return runner_type.new(self, arg)
       end
 
@@ -299,7 +314,7 @@ module Spec
               error_stream.puts "You must specify one file, not a directory when using the --line option"
               exit(1) if stderr?
             else
-              example = SpecParser.new.spec_name_for(files[0], line_number)
+              example = SpecParser.new(self).spec_name_for(files[0], line_number)
               @examples = [example]
             end
           else

data/lib/spec/runner/reporter.rb

@@ -159,7 +159,7 @@ module Spec
 
         protected
         def example_name
-          @example.__full_description
+          @example.full_description
         end
       end
     end

data/lib/spec/runner/spec_parser.rb

@@ -4,15 +4,16 @@ module Spec
     class SpecParser
       attr_reader :best_match
 
-      def initialize
+      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)
-        Spec::Runner.options.example_groups.each do |example_group|
-          consider_example_groups_for_best_match example_group, file, line_number
+        @run_options.example_groups.each do |example_group|
+          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
@@ -31,8 +32,8 @@ module Spec
 
     protected
 
-      def consider_example_groups_for_best_match(example_group, file, line_number)
-        parsed_backtrace = parse_backtrace(example_group.registration_backtrace)
+      def consider_example_group_for_best_match(example_group, file, line_number)
+        parsed_backtrace = parse_backtrace(example_group.backtrace)
         parsed_backtrace.each do |example_file, example_line|
           if is_best_match?(file, line_number, example_file, example_line)
             best_match.clear
@@ -43,7 +44,7 @@ module Spec
       end
 
       def consider_example_for_best_match(example, example_group, file, line_number)
-        parsed_backtrace = parse_backtrace(example.implementation_backtrace)
+        parsed_backtrace = parse_backtrace(example.backtrace)
         parsed_backtrace.each do |example_file, example_line|
           if is_best_match?(file, line_number, example_file, example_line)
             best_match.clear
@@ -61,9 +62,10 @@ module Spec
       end
 
       def parse_backtrace(backtrace)
-        backtrace.collect do |trace_line|
-          split_line = trace_line.split(':')
-          [split_line[0], Integer(split_line[1])]
+        Array(backtrace).collect do |trace_line|
+          trace_line =~ /(.*)\:(\d*)(\:|$)/
+          file, number = $1, $2
+          [file, Integer(number)]
         end
       end
     end

data/lib/spec/story/runner.rb

@@ -8,52 +8,50 @@ require 'spec/story/runner/plain_text_story_runner.rb'
 module Spec
   module Story
     module Runner
-      class << self
-        def run_options # :nodoc:
-          Spec::Runner.options
-        end
-        
-        def story_runner # :nodoc:
-          unless @story_runner
-            @story_runner = create_story_runner
-            run_options.story_formatters.each do |formatter|
-              register_listener(formatter)
-            end
-            self.register_exit_hook
-          end
-          @story_runner
-        end
-        
-        def scenario_runner # :nodoc:
-          @scenario_runner ||= ScenarioRunner.new
-        end
-        
-        def world_creator # :nodoc:
-          @world_creator ||= World
-        end
-        
-        def create_story_runner
-          Runner::StoryRunner.new(scenario_runner, world_creator)
-        end
-        
-        # Use this to register a customer output formatter.
-        def register_listener(listener)
-          story_runner.add_listener(listener) # run_started, story_started, story_ended, #run_ended
-          world_creator.add_listener(listener) # found_scenario, step_succeeded, step_failed, step_failed
-          scenario_runner.add_listener(listener) # scenario_started, scenario_succeeded, scenario_pending, scenario_failed
-        end
-        
-        def register_exit_hook # :nodoc:
-          at_exit do
-            exit Runner.story_runner.run_stories unless $!
+      def self.run_options # :nodoc:
+        Spec::Runner.options
+      end
+      
+      def self.story_runner # :nodoc:
+        unless @story_runner
+          @story_runner = create_story_runner
+          run_options.story_formatters.each do |formatter|
+            register_listener(formatter)
           end
+          self.register_exit_hook
         end
-        
-        def dry_run
-          run_options.dry_run
+        @story_runner
+      end
+      
+      def self.scenario_runner # :nodoc:
+        @scenario_runner ||= ScenarioRunner.new
+      end
+      
+      def self.world_creator # :nodoc:
+        @world_creator ||= World
+      end
+      
+      def self.create_story_runner
+        Runner::StoryRunner.new(scenario_runner, world_creator)
+      end
+      
+      # Use this to register a customer output formatter.
+      def self.register_listener(listener)
+        story_runner.add_listener(listener) # run_started, story_started, story_ended, #run_ended
+        world_creator.add_listener(listener) # found_scenario, step_succeeded, step_failed, step_failed
+        scenario_runner.add_listener(listener) # scenario_started, scenario_succeeded, scenario_pending, scenario_failed
+      end
+      
+      def self.register_exit_hook # :nodoc:
+        at_exit do
+          exit Runner.story_runner.run_stories unless $!
         end
-        
       end
+      
+      def self.dry_run
+        run_options.dry_run
+      end
+      
     end
   end
 end

data/lib/spec/story/runner/story_runner.rb

@@ -2,12 +2,16 @@ module Spec
   module Story
     module Runner
       class StoryRunner
-        class << self
-          attr_accessor :current_story_runner
-          
-          def scenario_from_current_story(scenario_name)
-            current_story_runner.scenario_from_current_story(scenario_name)
-          end
+        def self.current_story_runner
+          @current_story_runner
+        end
+
+        def self.current_story_runner=(current_story_runner)
+          @current_story_runner = current_story_runner
+        end
+
+        def self.scenario_from_current_story(scenario_name)
+          current_story_runner.scenario_from_current_story(scenario_name)
         end
         
         attr_accessor :stories, :scenarios, :current_story

data/lib/spec/story/world.rb

@@ -15,82 +15,78 @@ module Spec
     module World
       include ::Spec::Example::Pending
       include ::Spec::Matchers
-      # store steps and listeners in the singleton metaclass.
-      # This serves both to keep them out of the way of runtime Worlds
-      # and to make them available to all instances.
-      class << self
-        def create(cls = Object, *args)
-          cls.new(*args).extend(World)
-        end
-        
-        def listeners
-          @listeners ||= []
-        end
-        
-        def add_listener(listener)
-          listeners() << listener
-        end
-        
-        def step_mother
-          @step_mother ||= StepMother.new
-        end
-                
-        def use(steps)
-          step_mother.use(steps)
-        end
-        
-        def step_names
-          @step_names ||= []
-        end
 
-        def run_given_scenario_with_suspended_listeners(world, type, name, scenario)
-          current_listeners = Array.new(listeners)
-          begin
-            listeners.each { |l| l.found_scenario(type, name) }
-            @listeners.clear
-            scenario.perform(world, name) unless dry_run
-          ensure
-            @listeners.replace(current_listeners)
-          end
-        end
-        
-        def store_and_call(world, type, name, *args, &block)
-          if block_given?
-            step_mother.store(type, Step.new(name, &block))
-          end
-          step = step_mother.find(type, name)
+      def self.create(cls = Object, *args)
+        cls.new(*args).extend(World)
+      end
+      
+      def self.listeners
+        @listeners ||= []
+      end
+      
+      def self.add_listener(listener)
+        listeners() << listener
+      end
+      
+      def self.step_mother
+        @step_mother ||= StepMother.new
+      end
+              
+      def self.use(steps)
+        step_mother.use(steps)
+      end
+      
+      def self.step_names
+        @step_names ||= []
+      end
 
-          step_name = step.name
-          step_names << step_name
-          
-          # It's important to have access to the parsed args here, so
-          # we can give them to the listeners. The HTML reporter needs
-          # the args so it can style them. See the generated output in
-          # story_server/prototype/rspec_stories.html (generated by rake stories)
-          args = step.parse_args(name) if args.empty?
-          begin
-            listeners.each { |l| l.step_upcoming(type, step_name, *args) }
-            step.perform(world, *args) unless dry_run
-            listeners.each { |l| l.step_succeeded(type, step_name, *args) }
-          rescue Exception => e
-            case e
-            when Spec::Example::ExamplePendingError
-              @listeners.each { |l| l.step_pending(type, step_name, *args) }
-            else
-              @listeners.each { |l| l.step_failed(type, step_name, *args) }
-            end
-            errors << e
-          end
+      def self.run_given_scenario_with_suspended_listeners(world, type, name, scenario)
+        current_listeners = Array.new(listeners)
+        begin
+          listeners.each { |l| l.found_scenario(type, name) }
+          @listeners.clear
+          scenario.perform(world, name) unless dry_run
+        ensure
+          @listeners.replace(current_listeners)
         end
-        
-        def errors
-          @errors ||= []
+      end
+      
+      def self.store_and_call(world, type, name, *args, &block)
+        if block_given?
+          step_mother.store(type, Step.new(name, &block))
         end
+        step = step_mother.find(type, name)
+
+        step_name = step.name
+        step_names << step_name
         
-        def dry_run
-          ::Spec::Story::Runner.dry_run
+        # It's important to have access to the parsed args here, so
+        # we can give them to the listeners. The HTML reporter needs
+        # the args so it can style them. See the generated output in
+        # story_server/prototype/rspec_stories.html (generated by rake stories)
+        args = step.parse_args(name) if args.empty?
+        begin
+          listeners.each { |l| l.step_upcoming(type, step_name, *args) }
+          step.perform(world, *args) unless dry_run
+          listeners.each { |l| l.step_succeeded(type, step_name, *args) }
+        rescue Exception => e
+          case e
+          when Spec::Example::ExamplePendingError
+            @listeners.each { |l| l.step_pending(type, step_name, *args) }
+          else
+            @listeners.each { |l| l.step_failed(type, step_name, *args) }
+          end
+          errors << e
         end
-      end # end of class << self
+      end
+      
+      def self.errors
+        @errors ||= []
+      end
+      
+      def self.dry_run
+        ::Spec::Story::Runner.dry_run
+      end
       
       def start_collecting_errors
         errors.clear