dchelimsky-rspec 1.1.11.7 → 1.1.12

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

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

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

data/lib/spec/story/given_scenario.rb

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

@@ -1,57 +0,0 @@
-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
-      def self.run_options # :nodoc:
-        Spec::Runner.options
-      end
-      
-      def self.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 self.scenario_runner # :nodoc:
-        @scenario_runner ||= ScenarioRunner.new
-      end
-      
-      def self.world_creator # :nodoc:
-        @world_creator ||= World
-      end
-      
-      def self.create_story_runner
-        Runner::StoryRunner.new(scenario_runner, world_creator)
-      end
-      
-      # Use this to register a customer output formatter.
-      def self.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 self.register_exit_hook # :nodoc:
-        at_exit do
-          exit Runner.story_runner.run_stories unless $!
-        end
-      end
-      
-      def self.dry_run
-        run_options.dry_run
-      end
-      
-    end
-  end
-end

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

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

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