dchelimsky-rspec 1.1.10

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

@@ -0,0 +1,70 @@
+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
+        end
+        
+        attr_accessor :stories, :scenarios, :current_story
+        
+        def initialize(scenario_runner, world_creator = World)
+          StoryRunner.current_story_runner = self
+          @scenario_runner = scenario_runner
+          @world_creator = world_creator
+          @stories = []
+          @scenarios_by_story = {}
+          @scenarios = []
+          @listeners = []
+        end
+        
+        def Story(title, narrative, params = {}, &body)
+          story = Story.new(title, narrative, params, &body)
+          @stories << story
+          
+          # collect scenarios
+          collector = ScenarioCollector.new(story)
+          story.run_in(collector)
+          @scenarios += collector.scenarios
+          @scenarios_by_story[story.title] = collector.scenarios
+        end
+        
+        def run_stories
+          return if @stories.empty?
+          @listeners.each { |l| l.run_started(scenarios.size) }
+          success = true
+          @stories.each do |story|
+            story.assign_steps_to(World)
+            @current_story = story
+            @listeners.each { |l| l.story_started(story.title, story.narrative) }
+            scenarios = @scenarios_by_story[story.title]
+            scenarios.each do |scenario|
+              type = story[:type] || Object
+              args = story[:args] || []
+              world = @world_creator.create(type, *args)
+              success = success & @scenario_runner.run(scenario, world)
+            end
+            @listeners.each { |l| l.story_ended(story.title, story.narrative) }
+            World.step_mother.clear
+          end
+          unique_steps = (World.step_names.collect {|n| Regexp === n ? n.source : n.to_s}).uniq.sort
+          @listeners.each { |l| l.collected_steps(unique_steps) }
+          @listeners.each { |l| l.run_ended }
+          return success
+        end
+        
+        def add_listener(listener)
+          @listeners << listener
+        end
+        
+        def scenario_from_current_story(scenario_name)
+          @scenarios_by_story[@current_story.title].find {|s| s.name == scenario_name }
+        end
+      end
+    end
+  end
+end

data/lib/spec/story/runner.rb

@@ -0,0 +1,59 @@
+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:
+          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 $!
+          end
+        end
+        
+        def dry_run
+          run_options.dry_run
+        end
+        
+      end
+    end
+  end
+end

data/lib/spec/story/scenario.rb

@@ -0,0 +1,14 @@
+
+module Spec
+  module Story
+    class Scenario
+      attr_accessor :name, :body, :story
+      
+      def initialize(story, name, &body)
+        @story = story
+        @name = name
+        @body = body
+      end
+    end
+  end
+end

data/lib/spec/story/step.rb

@@ -0,0 +1,70 @@
+module Spec
+  module Story
+    class Step
+      PARAM_PATTERN = /([^\\]|^)(\$(?!\$)\w*)/
+      PARAM_OR_GROUP_PATTERN = /(\$(?!\$)\w*)|\(.*?\)/
+      
+      attr_reader :name
+      
+      def initialize(name, &block)
+        init_name(name)
+        init_expression(name)
+        block_given? ? init_module(name, &block) : set_pending
+      end
+
+      def perform(instance, *args)
+        raise Spec::Example::ExamplePendingError.new("Not Yet Implemented") if pending?
+        instance.extend(@mod)
+        instance.__send__(sanitize(@name), *args)
+      end
+
+      def matches?(name)
+        !(name.strip =~ @expression).nil?
+      end
+            
+      def parse_args(name)
+        name.strip.match(@expression)[1..-1]
+      end
+
+      private
+      
+      def sanitize(a_string_or_regexp)
+        return a_string_or_regexp.source if Regexp == a_string_or_regexp
+        a_string_or_regexp.to_s
+      end
+
+      def init_module(name, &block)
+        sanitized_name = sanitize(name)
+        @mod = Module.new do
+          define_method(sanitized_name, &block)
+        end
+      end
+    
+      def set_pending
+        @pending = true
+      end
+      
+      def pending?
+        @pending == true
+      end
+      
+      def init_name(name)
+        @name = name
+      end
+    
+      def init_expression(string_or_regexp)
+        if String === string_or_regexp
+          expression = string_or_regexp.dup
+          %w<? ( ) [ ] { } ^ !>.each {|c| expression.gsub! c, "\\#{c}"}
+        elsif Regexp === string_or_regexp
+          expression = string_or_regexp.source
+        end
+        while expression =~ PARAM_PATTERN
+          expression.sub!($2, "(.*?)")
+        end
+        @expression = Regexp.new("\\A#{expression}\\Z", Regexp::MULTILINE)
+      end
+
+    end
+  end
+end

data/lib/spec/story/step_group.rb

@@ -0,0 +1,89 @@
+module Spec
+  module Story
+
+    class StepGroupHash < Hash
+      def initialize
+        super do |h,k|
+          h[k] = Spec::Story::StepGroup.new
+        end
+      end
+    end
+
+    class StepGroup
+      def self.steps(&block)
+        @step_group ||= StepGroup.new(false)
+        @step_group.instance_eval(&block) if block
+        @step_group
+      end
+      
+      def initialize(init_defaults=true, &block)
+        @hash_of_lists_of_steps = Hash.new {|h, k| h[k] = []}
+        if init_defaults
+          self.class.steps.add_to(self)
+        end
+        instance_eval(&block) if block
+      end
+      
+      def find(type, name)
+        @hash_of_lists_of_steps[type].each do |step|
+          return step if step.matches?(name)
+        end
+        return nil
+      end
+
+      def GivenScenario(name, &block)
+        create_matcher(:given_scenario, name, &block)
+      end
+      
+      def Given(name, &block)
+        create_matcher(:given, name, &block)
+      end
+      
+      def When(name, &block)
+        create_matcher(:when, name, &block)
+      end
+      
+      def Then(name, &block)
+        create_matcher(:then, name, &block)
+      end
+
+      alias :given_scenario :GivenScenario
+      alias :given :Given
+      alias :when :When
+      alias :then :Then
+      
+      def add(type, steps)
+        (@hash_of_lists_of_steps[type] << steps).flatten!
+      end
+      
+      def clear
+        @hash_of_lists_of_steps.clear
+      end
+      
+      def empty?
+        [:given_scenario, :given, :when, :then].each do |type|
+          return false unless @hash_of_lists_of_steps[type].empty?
+        end
+        return true
+      end
+      
+      def add_to(other_step_matchers)
+        [:given_scenario, :given, :when, :then].each do |type|
+          other_step_matchers.add(type, @hash_of_lists_of_steps[type])
+        end
+      end
+      
+      def <<(other_step_matchers)
+        other_step_matchers.add_to(self) if other_step_matchers.respond_to?(:add_to)
+      end
+      
+      # TODO - make me private
+      def create_matcher(type, name, &block)
+        matcher = Step.new(name, &block)
+        @hash_of_lists_of_steps[type] << matcher
+        matcher
+      end
+      
+    end
+  end
+end

data/lib/spec/story/step_mother.rb

@@ -0,0 +1,38 @@
+module Spec
+  module Story
+    class StepMother
+      def initialize
+        @steps = StepGroup.new
+      end
+      
+      def use(new_step_group)
+        @steps << new_step_group
+      end
+      
+      def store(type, step)
+        @steps.add(type, step)
+      end
+      
+      def find(type, unstripped_name)
+        name = unstripped_name.strip
+        if @steps.find(type, name).nil?
+          @steps.add(type,
+          Step.new(name) do
+            raise Spec::Example::ExamplePendingError.new("Unimplemented step: #{name}")
+          end
+          )
+        end
+        @steps.find(type, name)
+      end
+      
+      def clear
+        @steps.clear
+      end
+      
+      def empty?
+        @steps.empty?
+      end
+      
+    end
+  end
+end

data/lib/spec/story/story.rb

@@ -0,0 +1,39 @@
+module Spec
+  module Story
+    class Story
+      attr_reader :title, :narrative
+      
+      def initialize(title, narrative, params = {}, &body)
+        @body = body
+        @title = title
+        @narrative = narrative
+        @params = params
+      end
+      
+      def [](key)
+        @params[key]
+      end
+      
+      def run_in(obj)
+        obj.instance_eval(&@body)
+      end
+      
+      def assign_steps_to(assignee)
+        if steps=@params[:steps_for]
+          steps = [steps] unless steps.is_a?(Array)
+          steps.each do |step|
+            if step.is_a?(StepGroup)
+              assignee.use(step)
+            else
+              assignee.use(steps_for(step))
+            end
+          end
+        end
+      end
+      
+      def steps_for(key)
+        $rspec_story_steps[key]
+      end
+    end
+  end
+end

data/lib/spec/story/world.rb

@@ -0,0 +1,128 @@
+require 'spec/expectations'
+require 'spec/matchers'
+require 'spec/example/pending'
+
+module Spec
+  module Story
+=begin
+  A World represents the actual instance a scenario will run in.
+  
+  The runner ensures any instance variables and methods defined anywhere
+  in a story block are available to all the scenarios. This includes
+  variables that are created or referenced inside Given, When and Then
+  blocks.
+=end
+    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)
+
+          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
+        end
+        
+        def errors
+          @errors ||= []
+        end
+        
+        def dry_run
+          ::Spec::Story::Runner.dry_run
+        end
+      end # end of class << self
+      
+      def start_collecting_errors
+        errors.clear
+      end
+      
+      def errors
+        World.errors
+      end
+      
+      def GivenScenario(name)
+        World.run_given_scenario_with_suspended_listeners(self, :'given scenario', name, GivenScenario.new(name))
+        @__previous_step = :given
+      end
+      
+      def Given(name, *args, &block)
+        World.store_and_call self, :given, name, *args, &block
+        @__previous_step = :given
+      end
+      
+      def When(name, *args, &block)
+        World.store_and_call self, :when, name, *args, &block
+        @__previous_step = :when
+      end
+      
+      def Then(name, *args, &block)
+        World.store_and_call self, :then, name, *args, &block
+        @__previous_step = :then
+      end
+      
+      def And(name, *args, &block)
+        World.store_and_call self, @__previous_step, name, *args, &block
+      end
+    end
+  end
+end