rspec 0.0.10 → 0.1.0

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

@@ -1,70 +0,0 @@
-module Spec
-  module Story
-    module Runner
-      class StoryRunner
-        class << self
-          attr_accessor :current_story_runner
-          
-          def scenario_from_current_story(scenario_name)
-            current_story_runner.scenario_from_current_story(scenario_name)
-          end
-        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)
-        !(matches = name.match(@expression)).nil?
-      end
-            
-      def parse_args(name)
-        name.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.gsub!($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

data/lib/spec/story/step_mother.rb

@@ -1,37 +0,0 @@
-module Spec
-  module Story
-    class StepMother
-      def initialize
-        @steps = StepGroup.new
-      end
-      
-      def use(new_step_group)
-        @steps << new_step_group
-      end
-      
-      def store(type, step)
-        @steps.add(type, step)
-      end
-      
-      def find(type, name)
-        if @steps.find(type, name).nil?
-          @steps.add(type,
-          Step.new(name) do
-            raise Spec::Example::ExamplePendingError.new("Unimplemented step: #{name}")
-          end
-          )
-        end
-        @steps.find(type, name)
-      end
-      
-      def clear
-        @steps.clear
-      end
-      
-      def empty?
-        @steps.empty?
-      end
-      
-    end
-  end
-end

data/lib/spec/story/story.rb

@@ -1,39 +0,0 @@
-module Spec
-  module Story
-    class Story
-      attr_reader :title, :narrative
-      
-      def initialize(title, narrative, params = {}, &body)
-        @body = body
-        @title = title
-        @narrative = narrative
-        @params = params
-      end
-      
-      def [](key)
-        @params[key]
-      end
-      
-      def run_in(obj)
-        obj.instance_eval(&@body)
-      end
-      
-      def assign_steps_to(assignee)
-        if steps=@params[:steps_for]
-          steps = [steps] unless steps.is_a?(Array)
-          steps.each do |step|
-            if step.is_a?(StepGroup)
-              assignee.use(step)
-            else
-              assignee.use(steps_for(step))
-            end
-          end
-        end
-      end
-      
-      def steps_for(key)
-        $rspec_story_steps[key]
-      end
-    end
-  end
-end

data/lib/spec/story/world.rb

@@ -1,128 +0,0 @@
-require 'spec/expectations'
-require 'spec/matchers'
-require 'spec/example/pending'
-
-module Spec
-  module Story
-=begin
-  A World represents the actual instance a scenario will run in.
-  
-  The runner ensures any instance variables and methods defined anywhere
-  in a story block are available to all the scenarios. This includes
-  variables that are created or referenced inside Given, When and Then
-  blocks.
-=end
-    module World
-      include ::Spec::Example::Pending
-      include ::Spec::Matchers
-      # store steps and listeners in the singleton metaclass.
-      # This serves both to keep them out of the way of runtime Worlds
-      # and to make them available to all instances.
-      class << self
-        def create(cls = Object, *args)
-          cls.new(*args).extend(World)
-        end
-        
-        def listeners
-          @listeners ||= []
-        end
-        
-        def add_listener(listener)
-          listeners() << listener
-        end
-        
-        def step_mother
-          @step_mother ||= StepMother.new
-        end
-                
-        def use(steps)
-          step_mother.use(steps)
-        end
-        
-        def step_names
-          @step_names ||= []
-        end
-
-        def run_given_scenario_with_suspended_listeners(world, type, name, scenario)
-          current_listeners = Array.new(listeners)
-          begin
-            listeners.each { |l| l.found_scenario(type, name) }
-            @listeners.clear
-            scenario.perform(world, name) unless dry_run
-          ensure
-            @listeners.replace(current_listeners)
-          end
-        end
-        
-        def store_and_call(world, type, name, *args, &block)
-          if block_given?
-            step_mother.store(type, Step.new(name, &block))
-          end
-          step = step_mother.find(type, name)
-
-          step_name = step.name
-          step_names << step_name
-          
-          # It's important to have access to the parsed args here, so
-          # we can give them to the listeners. The HTML reporter needs
-          # the args so it can style them. See the generated output in
-          # story_server/prototype/rspec_stories.html (generated by rake stories)
-          args = step.parse_args(name) if args.empty?
-          begin
-            listeners.each { |l| l.step_upcoming(type, step_name, *args) }
-            step.perform(world, *args) unless dry_run
-            listeners.each { |l| l.step_succeeded(type, step_name, *args) }
-          rescue Exception => e
-            case e
-            when Spec::Example::ExamplePendingError
-              @listeners.each { |l| l.step_pending(type, step_name, *args) }
-            else
-              @listeners.each { |l| l.step_failed(type, step_name, *args) }
-            end
-            errors << e
-          end
-        end
-        
-        def errors
-          @errors ||= []
-        end
-        
-        def dry_run
-          ::Spec::Story::Runner.dry_run
-        end
-      end # end of class << self
-      
-      def start_collecting_errors
-        errors.clear
-      end
-      
-      def errors
-        World.errors
-      end
-      
-      def GivenScenario(name)
-        World.run_given_scenario_with_suspended_listeners(self, :'given scenario', name, GivenScenario.new(name))
-        @__previous_step = :given
-      end
-      
-      def Given(name, *args, &block)
-        World.store_and_call self, :given, name, *args, &block
-        @__previous_step = :given
-      end
-      
-      def When(name, *args, &block)
-        World.store_and_call self, :when, name, *args, &block
-        @__previous_step = :when
-      end
-      
-      def Then(name, *args, &block)
-        World.store_and_call self, :then, name, *args, &block
-        @__previous_step = :then
-      end
-      
-      def And(name, *args, &block)
-        World.store_and_call self, @__previous_step, name, *args, &block
-      end
-    end
-  end
-end