rspec 0.0.10

data/lib/spec/runner/reporter.rb

@@ -0,0 +1,147 @@
+module Spec
+  module Runner
+    class Reporter
+      attr_reader :options, :example_groups
+      
+      def initialize(options)
+        @options = options
+        @options.reporter = self
+        clear
+      end
+      
+      def add_example_group(example_group)
+        formatters.each do |f|
+          f.add_example_group(example_group)
+        end
+        example_groups << example_group
+      end
+      
+      def example_started(example)
+        formatters.each{|f| f.example_started(example)}
+      end
+      
+      def example_finished(example, error=nil)
+        @examples << example
+        
+        if error.nil?
+          example_passed(example)
+        elsif Spec::Example::ExamplePendingError === error
+          example_pending(example, error.message)
+        else
+          example_failed(example, error)
+        end
+      end
+
+      def failure(example, error)
+        backtrace_tweaker.tweak_backtrace(error)
+        failure = Failure.new(example, error)
+        @failures << failure
+        formatters.each do |f|
+          f.example_failed(example, @failures.length, failure)
+        end
+      end
+      alias_method :example_failed, :failure
+
+      def start(number_of_examples)
+        clear
+        @start_time = Time.new
+        formatters.each{|f| f.start(number_of_examples)}
+      end
+  
+      def end
+        @end_time = Time.new
+      end
+  
+      # Dumps the summary and returns the total number of failures
+      def dump
+        formatters.each{|f| f.start_dump}
+        dump_pending
+        dump_failures
+        formatters.each do |f|
+          f.dump_summary(duration, @examples.length, @failures.length, @pending_count)
+          f.close
+        end
+        @failures.length
+      end
+
+    private
+
+      def formatters
+        @options.formatters
+      end
+
+      def backtrace_tweaker
+        @options.backtrace_tweaker
+      end
+  
+      def clear
+        @example_groups = []
+        @failures = []
+        @pending_count = 0
+        @examples = []
+        @start_time = nil
+        @end_time = nil
+      end
+  
+      def dump_failures
+        return if @failures.empty?
+        @failures.inject(1) do |index, failure|
+          formatters.each{|f| f.dump_failure(index, failure)}
+          index + 1
+        end
+      end
+
+      def dump_pending
+        formatters.each{|f| f.dump_pending}
+      end
+
+      def duration
+        return @end_time - @start_time unless (@end_time.nil? or @start_time.nil?)
+        return "0.0"
+      end
+      
+      def example_passed(example)
+        formatters.each{|f| f.example_passed(example)}
+      end
+      
+      def example_pending(example, message="Not Yet Implemented")
+        @pending_count += 1
+        formatters.each do |f|
+          f.example_pending(example, message)
+        end
+      end
+      
+      class Failure
+        attr_reader :example, :exception
+        
+        def initialize(example, exception)
+          @example = example
+          @exception = exception
+        end
+
+        def header
+          if expectation_not_met?
+            "'#{example_name}' FAILED"
+          elsif pending_fixed?
+            "'#{example_name}' FIXED"
+          else
+            "#{@exception.class.name} in '#{example_name}'"
+          end
+        end
+        
+        def pending_fixed?
+          @exception.is_a?(Spec::Example::PendingExampleFixedError)
+        end
+
+        def expectation_not_met?
+          @exception.is_a?(Spec::Expectations::ExpectationNotMetError)
+        end
+
+        protected
+        def example_name
+          @example.__full_description
+        end
+      end
+    end
+  end
+end

data/lib/spec/runner/spec_parser.rb

@@ -0,0 +1,71 @@
+module Spec
+  module Runner
+    # Parses a spec file and finds the nearest example for a given line number.
+    class SpecParser
+      attr_reader :best_match
+
+      def initialize
+        @best_match = {}
+      end
+
+      def spec_name_for(file, line_number)
+        best_match.clear
+        file = File.expand_path(file)
+        rspec_options.example_groups.each do |example_group|
+          consider_example_groups_for_best_match example_group, file, line_number
+
+          example_group.examples.each do |example|
+            consider_example_for_best_match example, example_group, file, line_number
+          end
+        end
+        if best_match[:example_group]
+          if best_match[:example]
+            "#{best_match[:example_group].description} #{best_match[:example].description}"
+          else
+            best_match[:example_group].description
+          end
+        else
+          nil
+        end
+      end
+
+    protected
+
+      def consider_example_groups_for_best_match(example_group, file, line_number)
+        parsed_backtrace = parse_backtrace(example_group.registration_backtrace)
+        parsed_backtrace.each do |example_file, example_line|
+          if is_best_match?(file, line_number, example_file, example_line)
+            best_match.clear
+            best_match[:example_group] = example_group
+            best_match[:line] = example_line
+          end
+        end
+      end
+
+      def consider_example_for_best_match(example, example_group, file, line_number)
+        parsed_backtrace = parse_backtrace(example.implementation_backtrace)
+        parsed_backtrace.each do |example_file, example_line|
+          if is_best_match?(file, line_number, example_file, example_line)
+            best_match.clear
+            best_match[:example_group] = example_group
+            best_match[:example] = example
+            best_match[:line] = example_line
+          end
+        end
+      end
+
+      def is_best_match?(file, line_number, example_file, example_line)
+        file == File.expand_path(example_file) &&
+        example_line <= line_number &&
+        example_line > best_match[:line].to_i
+      end
+
+      def parse_backtrace(backtrace)
+        backtrace.collect do |trace_line|
+          split_line = trace_line.split(':')
+          [split_line[0], Integer(split_line[1])]
+        end
+      end
+    end
+  end
+end

data/lib/spec/story.rb

@@ -0,0 +1,10 @@
+require 'spec'
+require 'spec/story/extensions'
+require 'spec/story/given_scenario'
+require 'spec/story/runner'
+require 'spec/story/scenario'
+require 'spec/story/step'
+require 'spec/story/step_group'
+require 'spec/story/step_mother'
+require 'spec/story/story'
+require 'spec/story/world'

data/lib/spec/story/extensions.rb

@@ -0,0 +1,3 @@
+require 'spec/story/extensions/main'
+require 'spec/story/extensions/string'
+require 'spec/story/extensions/regexp'

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

@@ -0,0 +1,86 @@
+module Spec
+  module Story
+    module Extensions
+      module Main
+        def Story(title, narrative, params = {}, &body)
+          ::Spec::Story::Runner.story_runner.Story(title, narrative, params, &body)
+        end
+      
+        # Calling this deprecated is silly, since it hasn't been released yet. But, for
+        # those who are reading this - this will be deleted before the 1.1 release.
+        def run_story(*args, &block)
+          runner = Spec::Story::Runner::PlainTextStoryRunner.new(*args)
+          runner.instance_eval(&block) if block
+          runner.run
+        end
+      
+        # Creates (or appends to an existing) a namespaced group of steps for use in Stories
+        #
+        # == Examples
+        #
+        #   # Creating a new group
+        #   steps_for :forms do
+        #     When("user enters $value in the $field field") do ... end
+        #     When("user submits the $form form") do ... end
+        #   end
+        def steps_for(tag, &block)
+          steps = rspec_story_steps[tag]
+          steps.instance_eval(&block) if block
+          steps
+        end
+      
+        # Creates a context for running a Plain Text Story with specific groups of Steps. 
+        # Also supports adding arbitrary steps that will only be accessible to
+        # the Story being run.
+        #
+        # == Examples
+        #
+        #   # Run a Story with one group of steps
+        #   with_steps_for :checking_accounts do
+        #     run File.dirname(__FILE__) + "/withdraw_cash"
+        #   end
+        #
+        #   # Run a Story, adding steps that are only available for this Story
+        #   with_steps_for :accounts do
+        #     Given "user is logged in as account administrator"
+        #     run File.dirname(__FILE__) + "/reconcile_accounts"
+        #   end
+        #
+        #   # Run a Story with steps from two groups
+        #   with_steps_for :checking_accounts, :savings_accounts do
+        #     run File.dirname(__FILE__) + "/transfer_money"
+        #   end
+        #
+        #   # Run a Story with a specific Story extension
+        #   with_steps_for :login, :navigation do
+        #     run File.dirname(__FILE__) + "/user_changes_password", :type => RailsStory
+        #   end
+        def with_steps_for(*tags, &block)
+          steps = Spec::Story::StepGroup.new do
+            extend StoryRunnerStepGroupAdapter
+          end
+          tags.each {|tag| steps << rspec_story_steps[tag]}
+          steps.instance_eval(&block) if block
+          steps
+        end
+
+      private
+
+        module StoryRunnerStepGroupAdapter
+          def run(path, options={})
+            runner = Spec::Story::Runner::PlainTextStoryRunner.new(path, options)
+            runner.steps << self
+            runner.run
+          end
+        end
+        
+        def rspec_story_steps  # :nodoc:
+          $rspec_story_steps ||= Spec::Story::StepGroupHash.new
+        end
+                
+      end
+    end
+  end
+end
+
+include Spec::Story::Extensions::Main

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

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

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

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

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

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

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