spree 0.8.1 → 0.8.2

data/vendor/plugins/rspec/lib/spec/story/runner/scenario_collector.rb

@@ -1,18 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,137 +0,0 @@
- 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

@@ -1,247 +0,0 @@
-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