rspec 1.1.12 → 1.2.0

data/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

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

@@ -1,74 +0,0 @@
-module Spec
-  module Story
-    module Runner
-      class StoryRunner
-        def self.current_story_runner
-          @current_story_runner
-        end
-
-        def self.current_story_runner=(current_story_runner)
-          @current_story_runner = current_story_runner
-        end
-
-        def self.scenario_from_current_story(scenario_name)
-          current_story_runner.scenario_from_current_story(scenario_name)
-        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/scenario.rb

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

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

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