rspec 1.0.8 → 1.1.0

data/lib/spec/runner/reporter.rb

@@ -1,40 +1,52 @@
 module Spec
   module Runner
     class Reporter
+      attr_reader :options, :example_groups
       
-      def initialize(formatters, backtrace_tweaker)
-        @formatters = formatters
-        @backtrace_tweaker = backtrace_tweaker
-        clear!
+      def initialize(options)
+        @options = options
+        @options.reporter = self
+        clear
       end
       
-      def add_behaviour(name)
-        @formatters.each{|f| f.add_behaviour(name)}
-        @behaviour_names << name
+      def add_example_group(example_group)
+        formatters.each do |f|
+          f.add_example_group(example_group)
+        end
+        example_groups << example_group
       end
       
-      def example_started(name)
-        @formatters.each{|f| f.example_started(name)}
+      def example_started(example)
+        formatters.each{|f| f.example_started(example)}
       end
       
-      def example_finished(name, error=nil, failure_location=nil, not_implemented = false)
-        @example_names << name
+      def example_finished(example, error=nil)
+        @examples << example
         
-        if not_implemented
-          example_pending(@behaviour_names.last, name)
-        elsif error.nil?
-          example_passed(name)
-        elsif Spec::DSL::ExamplePendingError === error
-          example_pending(@behaviour_names.last, name, error.message)
+        if error.nil?
+          example_passed(example)
+        elsif Spec::Example::ExamplePendingError === error
+          example_pending(example_groups.last, example, error.message)
         else
-          example_failed(name, error, failure_location)
+          example_failed(example, error)
+        end
+      end
+
+      def failure(example, error)
+        backtrace_tweaker.tweak_backtrace(error)
+        example_name = "#{example_groups.last.description} #{example.description}"
+        failure = Failure.new(example_name, error)
+        @failures << failure
+        formatters.each do |f|
+          f.example_failed(example, @failures.length, failure)
         end
       end
+      alias_method :example_failed, :failure
 
       def start(number_of_examples)
-        clear!
+        clear
         @start_time = Time.new
-        @formatters.each{|f| f.start(number_of_examples)}
+        formatters.each{|f| f.start(number_of_examples)}
       end
   
       def end
@@ -43,22 +55,31 @@ module Spec
   
       # Dumps the summary and returns the total number of failures
       def dump
-        @formatters.each{|f| f.start_dump}
+        formatters.each{|f| f.start_dump}
+        dump_pending
         dump_failures
-        @formatters.each do |f| 
-          f.dump_summary(duration, @example_names.length, @failures.length, @pending_count)
+        formatters.each do |f|
+          f.dump_summary(duration, @examples.length, @failures.length, @pending_count)
           f.close
         end
         @failures.length
       end
 
     private
+
+      def formatters
+        @options.formatters
+      end
+
+      def backtrace_tweaker
+        @options.backtrace_tweaker
+      end
   
-      def clear!
-        @behaviour_names = []
+      def clear
+        @example_groups = []
         @failures = []
         @pending_count = 0
-        @example_names = []
+        @examples = []
         @start_time = nil
         @end_time = nil
       end
@@ -66,31 +87,28 @@ module Spec
       def dump_failures
         return if @failures.empty?
         @failures.inject(1) do |index, failure|
-          @formatters.each{|f| f.dump_failure(index, failure)}
+          formatters.each{|f| f.dump_failure(index, failure)}
           index + 1
         end
       end
+      def dump_pending
+        formatters.each{|f| f.dump_pending}
+      end
 
       def duration
         return @end_time - @start_time unless (@end_time.nil? or @start_time.nil?)
         return "0.0"
       end
       
-      def example_passed(name)
-        @formatters.each{|f| f.example_passed(name)}
-      end
-
-      def example_failed(name, error, failure_location)
-        @backtrace_tweaker.tweak_backtrace(error, failure_location)
-        example_name = "#{@behaviour_names.last} #{name}"
-        failure = Failure.new(example_name, error)
-        @failures << failure
-        @formatters.each{|f| f.example_failed(name, @failures.length, failure)}
+      def example_passed(example)
+        formatters.each{|f| f.example_passed(example)}
       end
       
-      def example_pending(behaviour_name, example_name, message="Not Yet Implemented")
+      def example_pending(example_group, example, message="Not Yet Implemented")
         @pending_count += 1
-        @formatters.each{|f| f.example_pending(behaviour_name, example_name, message)}
+        formatters.each do |f|
+          f.example_pending(example_group.description, example, message)
+        end
       end
       
       class Failure
@@ -112,7 +130,7 @@ module Spec
         end
         
         def pending_fixed?
-          @exception.is_a?(Spec::DSL::PendingFixedError)
+          @exception.is_a?(Spec::Example::PendingExampleFixedError)
         end
 
         def expectation_not_met?

data/lib/spec/runner/spec_parser.rb

@@ -4,12 +4,12 @@ module Spec
     class SpecParser
       def spec_name_for(io, line_number)
         source  = io.read
-        behaviour, behaviour_line = behaviour_at_line(source, line_number)
+        example_group, example_group_line = example_group_at_line(source, line_number)
         example, example_line = example_at_line(source, line_number)
-        if behaviour && example && (behaviour_line < example_line)
-          "#{behaviour} #{example}"
-        elsif behaviour
-          behaviour
+        if example_group && example && (example_group_line < example_line)
+          "#{example_group} #{example}"
+        elsif example_group
+          example_group
         else
           nil
         end
@@ -17,7 +17,7 @@ module Spec
 
     protected
 
-      def behaviour_at_line(source, line_number)
+      def example_group_at_line(source, line_number)
         find_above(source, line_number, /^\s*(context|describe)\s+(.*)\s+do/)
       end
 
@@ -40,8 +40,11 @@ module Spec
       
       def parse_description(str)
         return str[1..-2] if str =~ /^['"].*['"]$/
-        if matches = /^(.*)\s*,\s*['"](.*)['"]$/.match(str)
-          return ::Spec::DSL::Description.generate_description(matches[1], matches[2])
+        if matches = /^['"](.*)['"](,.*)?$/.match(str)
+          return ::Spec::Example::ExampleGroupMethods.description_text(matches[1])
+        end
+        if matches = /^(.*)\s*,\s*['"](.*)['"](,.*)?$/.match(str)
+          return ::Spec::Example::ExampleGroupMethods.description_text(matches[1], matches[2])
         end
         return str
       end

data/lib/spec/story.rb

@@ -0,0 +1,10 @@
+require 'spec'
+require 'spec/story/extensions'
+require 'spec/story/given_scenario'
+require 'spec/story/runner'
+require 'spec/story/scenario'
+require 'spec/story/step'
+require 'spec/story/step_group'
+require 'spec/story/step_mother'
+require 'spec/story/story'
+require 'spec/story/world'

data/lib/spec/story/extensions.rb

@@ -0,0 +1 @@
+require 'spec/story/extensions/main'

data/lib/spec/story/extensions/main.rb

@@ -0,0 +1,86 @@
+module Spec
+  module Story
+    module Extensions
+      module Main
+        def Story(title, narrative, params = {}, &body)
+          ::Spec::Story::Runner.story_runner.Story(title, narrative, params, &body)
+        end
+      
+        # Calling this deprecated is silly, since it hasn't been released yet. But, for
+        # those who are reading this - this will be deleted before the 1.1 release.
+        def run_story(*args, &block)
+          runner = Spec::Story::Runner::PlainTextStoryRunner.new(*args)
+          runner.instance_eval(&block) if block
+          runner.run
+        end
+      
+        # Creates (or appends to an existing) a namespaced group of steps for use in Stories
+        #
+        # == Examples
+        #
+        #   # Creating a new group
+        #   steps_for :forms do
+        #     When("user enters $value in the $field field") do ... end
+        #     When("user submits the $form form") do ... end
+        #   end
+        def steps_for(tag, &block)
+          steps = rspec_story_steps[tag]
+          steps.instance_eval(&block) if block
+          steps
+        end
+      
+        # Creates a context for running a Plain Text Story with specific groups of Steps. 
+        # Also supports adding arbitrary steps that will only be accessible to
+        # the Story being run.
+        #
+        # == Examples
+        #
+        #   # Run a Story with one group of steps
+        #   with_steps_for :checking_accounts do
+        #     run File.dirname(__FILE__) + "/withdraw_cash"
+        #   end
+        #
+        #   # Run a Story, adding steps that are only available for this Story
+        #   with_steps_for :accounts do
+        #     Given "user is logged in as account administrator"
+        #     run File.dirname(__FILE__) + "/reconcile_accounts"
+        #   end
+        #
+        #   # Run a Story with steps from two groups
+        #   with_steps_for :checking_accounts, :savings_accounts do
+        #     run File.dirname(__FILE__) + "/transfer_money"
+        #   end
+        #
+        #   # Run a Story with a specific Story extension
+        #   with_steps_for :login, :navigation do
+        #     run File.dirname(__FILE__) + "/user_changes_password", :type => RailsStory
+        #   end
+        def with_steps_for(*tags, &block)
+          steps = Spec::Story::StepGroup.new do
+            extend StoryRunnerStepGroupAdapter
+          end
+          tags.each {|tag| steps << rspec_story_steps[tag]}
+          steps.instance_eval(&block) if block
+          steps
+        end
+
+      private
+
+        module StoryRunnerStepGroupAdapter
+          def run(path, options={})
+            runner = Spec::Story::Runner::PlainTextStoryRunner.new(path, options)
+            runner.steps << self
+            runner.run
+          end
+        end
+        
+        def rspec_story_steps  # :nodoc:
+          $rspec_story_steps ||= Spec::Story::StepGroupHash.new
+        end
+                
+      end
+    end
+  end
+end
+
+include Spec::Story::Extensions::Main

data/lib/spec/story/given_scenario.rb

@@ -0,0 +1,14 @@
+module Spec
+  module Story
+    class GivenScenario
+      def initialize(name)
+        @name = name
+      end
+      
+      def perform(instance, ignore_name)
+        scenario = Runner::StoryRunner.scenario_from_current_story(@name)
+        Runner::ScenarioRunner.new.run(scenario, instance)
+      end
+    end
+  end
+end

data/lib/spec/story/runner.rb

@@ -0,0 +1,58 @@
+require 'spec/story/runner/scenario_collector.rb'
+require 'spec/story/runner/scenario_runner.rb'
+require 'spec/story/runner/story_runner.rb'
+require 'spec/story/runner/story_parser.rb'
+require 'spec/story/runner/story_mediator.rb'
+require 'spec/story/runner/plain_text_story_runner.rb'
+
+module Spec
+  module Story
+    module Runner
+      class << self
+        def run_options # :nodoc:
+          @run_options ||= ::Spec::Runner::OptionParser.parse(ARGV, $stderr, $stdout)
+        end
+        
+        def story_runner # :nodoc:
+          unless @story_runner
+            @story_runner = StoryRunner.new(scenario_runner, world_creator)
+            run_options.story_formatters.each do |formatter|
+              register_listener(formatter)
+            end
+            Runner.register_exit_hook
+          end
+          @story_runner
+        end
+        
+        def scenario_runner # :nodoc:
+          @scenario_runner ||= ScenarioRunner.new
+        end
+        
+        def world_creator # :nodoc:
+          @world_creator ||= World
+        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:
+          # TODO - when story runner uses test/unit runners like example runner does we can kill
+          # this and also the assorted Kernel.stub!(:at_exit) in examples
+          at_exit do
+            Runner.story_runner.run_stories unless $!
+          end
+          # TODO exit with non-zero status if run fails
+        end
+        
+        def dry_run
+          run_options.dry_run
+        end
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Spec
+  module Story
+    module Runner
+      class PlainTextStoryRunner
+        # You can initialize a PlainTextStoryRunner with the path to the
+        # story file or a block, in which you can define the path using load.
+        #
+        # == Examples
+        #   
+        #   PlainTextStoryRunner.new('path/to/file')
+        #
+        #   PlainTextStoryRunner.new do |runner|
+        #     runner.load 'path/to/file'
+        #   end
+        def initialize(*args)
+          @options = Hash === args.last ? args.pop : {}
+          @story_file = args.empty? ? nil : args.shift
+          yield self if block_given?
+        end
+        
+        def []=(key, value)
+          @options[key] = value
+        end
+        
+        def load(path)
+          @story_file = path
+        end
+        
+        def run
+          raise "You must set a path to the file with the story. See the RDoc." if @story_file.nil?
+          mediator = Spec::Story::Runner::StoryMediator.new(steps, Spec::Story::Runner.story_runner, @options)
+          parser = Spec::Story::Runner::StoryParser.new(mediator)
+
+          story_text = File.read(@story_file)          
+          parser.parse(story_text.split("\n"))
+
+          mediator.run_stories
+        end
+        
+        def steps
+          @step_group ||= Spec::Story::StepGroup.new
+          yield @step_group if block_given?
+          @step_group
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Spec
+  module Story
+    module Runner
+      class ScenarioCollector
+        attr_accessor :scenarios
+        
+        def initialize(story)
+          @story = story
+          @scenarios = []
+        end
+        
+        def Scenario(name, &body)
+          @scenarios << Scenario.new(@story, name, &body)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Spec
+  module Story
+    module Runner
+      class ScenarioRunner
+        def initialize
+          @listeners = []
+        end
+        
+        def run(scenario, world)
+          @listeners.each { |l| l.scenario_started(scenario.story.title, scenario.name) }
+          run_story_ignoring_scenarios(scenario.story, world)
+          
+          world.start_collecting_errors
+          world.instance_eval(&scenario.body)
+          if world.errors.empty?
+            @listeners.each { |l| l.scenario_succeeded(scenario.story.title, scenario.name) }
+          else
+            if Spec::Example::ExamplePendingError === (e = world.errors.first)
+              @listeners.each { |l| l.scenario_pending(scenario.story.title, scenario.name, e.message) }
+            else
+              @listeners.each { |l| l.scenario_failed(scenario.story.title, scenario.name, e) }
+            end
+          end
+        end
+        
+        def add_listener(listener)
+          @listeners << listener
+        end
+        
+        private
+        
+        def run_story_ignoring_scenarios(story, world)
+          class << world
+            def Scenario(name, &block)
+              # do nothing
+            end
+          end
+          story.run_in(world)
+          class << world
+            remove_method(:Scenario)
+          end
+        end
+      end
+    end
+  end
+end