pictrails 0.5.0

data/vendor/plugins/rspec/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/vendor/plugins/rspec/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/vendor/plugins/rspec/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/vendor/plugins/rspec/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