dchelimsky-rspec 1.1.10

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/extensions/regexp.rb

@@ -0,0 +1,9 @@
+class Regexp
+  def step_name
+    self.source.gsub '\\$', '$$'
+  end
+  
+  def arg_regexp
+    ::Spec::Story::Step::PARAM_OR_GROUP_PATTERN
+  end
+end

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

@@ -0,0 +1,9 @@
+class String
+  def step_name
+    self
+  end
+  
+  def arg_regexp
+    ::Spec::Story::Step::PARAM_OR_GROUP_PATTERN
+  end
+end

data/lib/spec/story/extensions.rb

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

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/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(story_runner=Spec::Story::Runner.story_runner)
+          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, 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,54 @@
+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
+
+          unless scenario.body
+            @listeners.each { |l| l.scenario_pending(scenario.story.title, scenario.name, '') }
+            return true
+          end
+          
+          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) }
+              return false
+            end
+          end
+          true
+        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

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

@@ -0,0 +1,137 @@
+ module Spec
+  module Story
+    module Runner
+
+      class StoryMediator
+        def initialize(step_group, runner, options={})
+          @step_group = step_group
+          @stories = []
+          @runner = runner
+          @options = options
+        end
+        
+        def stories
+          @stories.collect { |p| p.to_proc }
+        end
+        
+        def create_story(title, narrative)
+          @stories << Story.new(title, narrative, @step_group, @options)
+        end
+        
+        def create_scenario(title)
+          current_story.add_scenario Scenario.new(title)
+        end
+        
+        def create_given(name)
+          current_scenario.add_step Step.new('Given', name)
+        end
+        
+        def create_given_scenario(name)
+          current_scenario.add_step Step.new('GivenScenario', name)
+        end
+        
+        def create_when(name)
+          current_scenario.add_step Step.new('When', name)
+        end
+        
+        def create_then(name)
+          current_scenario.add_step Step.new('Then', name)
+        end
+        
+        def last_step
+          current_scenario.last_step
+        end
+        
+        def add_to_last(name)
+          last_step.name << name
+        end
+        
+        def run_stories
+          stories.each { |story| @runner.instance_eval(&story) }
+        end
+        
+        private
+        def current_story
+          @stories.last
+        end
+        
+        def current_scenario
+          current_story.current_scenario
+        end
+        
+        class Story
+          def initialize(title, narrative, step_group, options)
+            @title = title
+            @narrative = narrative
+            @scenarios = []
+            @step_group = step_group
+            @options = options
+          end
+          
+          def to_proc
+            title = @title
+            narrative = @narrative
+            scenarios = @scenarios.collect { |scenario| scenario.to_proc }
+            options = @options.merge(:steps_for => @step_group)
+            lambda do
+              Story title, narrative, options do
+                scenarios.each { |scenario| instance_eval(&scenario) }
+              end
+            end
+          end
+          
+          def add_scenario(scenario)
+            @scenarios << scenario
+          end
+          
+          def current_scenario
+            @scenarios.last
+          end
+        end
+        
+        class Scenario
+          def initialize(name)
+            @name = name
+            @steps = []
+          end
+          
+          def to_proc
+            name = @name
+            steps = @steps.collect { |step| step.to_proc }
+            lambda do
+              Scenario name do
+                steps.each { |step| instance_eval(&step) }
+              end
+            end
+          end
+          
+          def add_step(step)
+            @steps << step
+          end
+          
+          def last_step
+            @steps.last
+          end
+        end
+        
+        class Step
+          attr_reader :name
+          
+          def initialize(type, name)
+            @type = type
+            @name = name
+          end
+          
+          def to_proc
+            type = @type
+            name = @name
+            lambda do
+              send(type, name)
+            end
+          end
+        end
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,247 @@
+module Spec
+  module Story
+    module Runner
+      
+      class IllegalStepError < StandardError
+        def initialize(state, event)
+          super("Illegal attempt to create a #{event} after a #{state}")
+        end
+      end
+
+      class StoryParser
+        def initialize(story_mediator)
+          @story_mediator = story_mediator
+          @current_story_lines = []
+          transition_to(:starting_state)
+        end
+        
+        def parse(lines)
+          lines.reject! {|line| line == ""}
+          until lines.empty?
+            process_line(lines.shift)
+          end
+          @state.eof
+        end
+        
+        def process_line(line)
+          line.strip!
+          case line
+          when /^#/                 then @state.comment(line)
+          when /^Story: /           then @state.story(line)
+          when /^Scenario: /        then @state.scenario(line)
+          when /^Given:? /          then @state.given(line)
+          when /^GivenScenario:? /  then @state.given_scenario(line)
+          when /^When:? /           then @state.event(line)
+          when /^Then:? /           then @state.outcome(line)
+          when /^And:? /            then @state.one_more_of_the_same(line)
+          else                           @state.other(line)
+          end
+        end
+
+        def init_story(title)
+          @current_story_lines.clear
+          add_story_line(title)
+        end
+        
+        def add_story_line(line)
+          @current_story_lines << line
+        end
+        
+        def create_story()
+          unless @current_story_lines.empty?
+            @story_mediator.create_story(@current_story_lines[0].gsub("Story: ",""), @current_story_lines[1..-1].join("\n"))
+            @current_story_lines.clear
+          end
+        end
+        
+        def create_scenario(title)
+          @story_mediator.create_scenario(title.gsub("Scenario: ",""))
+        end
+        
+        def create_given(name)
+          @story_mediator.create_given(name)
+        end
+        
+        def create_given_scenario(name)
+          @story_mediator.create_given_scenario(name)
+        end
+        
+        def create_when(name)
+          @story_mediator.create_when(name)
+        end
+        
+        def create_then(name)
+          @story_mediator.create_then(name)
+        end
+        
+        def add_to_last(line)
+          @story_mediator.add_to_last("\n#{line}")
+        end
+
+        def transition_to(key)
+          @state = states[key]
+        end
+        
+        def states
+          @states ||= {
+            :starting_state => StartingState.new(self),
+            :story_state => StoryState.new(self),
+            :scenario_state => ScenarioState.new(self),
+            :given_state => GivenState.new(self),
+            :when_state => WhenState.new(self),
+            :then_state => ThenState.new(self)
+          }
+        end
+        
+        class State
+          def initialize(parser)
+            @parser = parser
+          end
+          
+          def story(line)
+            @parser.init_story(line)
+            @parser.transition_to(:story_state)
+          end
+
+          def scenario(line)
+            @parser.create_scenario(line)
+            @parser.transition_to(:scenario_state)
+          end
+
+          def given(line)
+            @parser.create_given(remove_tag_from(:given, line))
+            @parser.transition_to(:given_state)
+          end
+          
+          def given_scenario(line)
+            @parser.create_given_scenario(remove_tag_from(:givenscenario, line))
+            @parser.transition_to(:given_state)
+          end
+          
+          def event(line)
+            @parser.create_when(remove_tag_from(:when, line))
+            @parser.transition_to(:when_state)
+          end
+          
+          def outcome(line)
+            @parser.create_then(remove_tag_from(:then, line))
+            @parser.transition_to(:then_state)
+          end
+
+          def remove_tag_from(tag, line)
+            tokens = line.split
+            # validation of tag can go here
+            tokens[0].downcase.match(/#{tag.to_s}:?/) ? 
+                                (tokens[1..-1].join(' ')) : line
+          end
+
+          def eof
+          end
+          
+          def other(line)
+            # no-op - supports header text before the first story in a file
+          end
+          
+          def comment(line)
+          end
+        end
+        
+        class StartingState < State
+          def initialize(parser)
+            @parser = parser
+          end
+        end
+        
+        class StoryState < State
+          def one_more_of_the_same(line)
+            other(line)
+          end
+
+          def story(line)
+            @parser.create_story
+            @parser.add_story_line(line)
+          end
+          
+          def scenario(line)
+            @parser.create_story
+            @parser.create_scenario(line)
+            @parser.transition_to(:scenario_state)
+          end
+          
+          def given(line)
+            other(line)
+          end
+          
+          def event(line)
+            other(line)
+          end
+          
+          def outcome(line)
+            other(line)
+          end
+          
+          def other(line)
+            @parser.add_story_line(line)
+          end
+          
+          def eof
+            @parser.create_story
+          end
+        end
+
+        class ScenarioState < State
+          def one_more_of_the_same(line)
+            raise IllegalStepError.new("Scenario", "And")
+          end
+
+          def scenario(line)
+            @parser.create_scenario(line)
+          end
+        end
+        
+        class GivenState < State
+          def one_more_of_the_same(line)
+            @parser.create_given(remove_tag_from(:and, line))
+          end
+          
+          def given(line)
+            @parser.create_given(remove_tag_from(:given, line))
+          end
+          
+          def other(line)
+            @parser.add_to_last(line)
+          end
+        end
+        
+        class WhenState < State
+          def one_more_of_the_same(line)
+            @parser.create_when(remove_tag_from(:and ,line))
+          end
+
+          def event(line)
+            @parser.create_when(remove_tag_from(:when ,line))
+          end
+
+          def other(line)
+            @parser.add_to_last(line)
+          end
+        end
+
+        class ThenState < State
+          def one_more_of_the_same(line)
+            @parser.create_then(remove_tag_from(:and ,line))
+          end
+
+          def outcome(line)
+            @parser.create_then(remove_tag_from(:then ,line))
+          end
+
+          def other(line)
+            @parser.add_to_last(line)
+          end
+        end
+
+      end
+    end
+  end
+end