rspec 0.0.10 → 0.1.0

data/lib/spec/runner/reporter.rb

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

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

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

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

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

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

@@ -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,60 +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
-      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

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