rspec 1.0.8 → 1.1.0

data/lib/spec/dsl/example.rb

@@ -1,135 +0,0 @@
-require 'timeout'
-
-module Spec
-  module DSL
-    class Example
-      # The global sequence number of this example
-      attr_accessor :number
-      
-      def initialize(description, options={}, &example_block)
-        @from = caller(0)[3]
-        @options = options
-        @example_block = example_block
-        @description = description
-        @description_generated_proc = lambda { |desc| @generated_description = desc }
-      end
-      
-      def run(reporter, before_each_block, after_each_block, dry_run, execution_context, timeout=nil)
-        @dry_run = dry_run
-        reporter.example_started(self)
-        return reporter.example_finished(self) if dry_run
-
-        errors = []
-        location = nil
-        Timeout.timeout(timeout) do
-          before_each_ok = before_example(execution_context, errors, &before_each_block)
-          example_ok = run_example(execution_context, errors) if before_each_ok
-          after_each_ok = after_example(execution_context, errors, &after_each_block)
-          location = failure_location(before_each_ok, example_ok, after_each_ok)
-        end
-
-        ExampleShouldRaiseHandler.new(@from, @options).handle(errors)
-        reporter.example_finished(self, errors.first, location, @example_block.nil?) if reporter
-      end
-      
-      def matches?(matcher, specified_examples)
-        matcher.example_desc = description
-        matcher.matches?(specified_examples)
-      end
-      
-      def description
-        @description == :__generate_description ? generated_description : @description
-      end
-      
-      def to_s
-        description
-      end
-
-    private
-      
-      def generated_description
-        return @generated_description if @generated_description
-        if @dry_run
-          "NO NAME (Because of --dry-run)"
-        else
-          if @failed
-            "NO NAME (Because of Error raised in matcher)"
-          else
-            "NO NAME (Because there were no expectations)"
-          end
-        end
-      end
-      
-      def before_example(execution_context, errors, &behaviour_before_block)
-        setup_mocks(execution_context)
-        Spec::Matchers.description_generated(@description_generated_proc)
-        
-        builder = CompositeProcBuilder.new
-        before_proc = builder.proc(&append_errors(errors))
-        execution_context.instance_eval(&before_proc)
-        
-        execution_context.instance_eval(&behaviour_before_block) if behaviour_before_block
-        return errors.empty?
-      rescue Exception => e
-        @failed = true
-        errors << e
-        return false
-      end
-
-      def run_example(execution_context, errors)
-        begin
-          execution_context.instance_eval(&@example_block) if @example_block
-          return true
-        rescue Exception => e
-          @failed = true
-          errors << e
-          return false
-        end
-      end
-
-      def after_example(execution_context, errors, &behaviour_after_each)
-        execution_context.instance_eval(&behaviour_after_each) if behaviour_after_each
-
-        begin
-          verify_mocks(execution_context)
-        ensure
-          teardown_mocks(execution_context)
-        end
-
-        Spec::Matchers.unregister_description_generated(@description_generated_proc)
-
-        builder = CompositeProcBuilder.new
-        after_proc = builder.proc(&append_errors(errors))
-        execution_context.instance_eval(&after_proc)
-
-        return errors.empty?
-      rescue Exception => e
-        @failed = true
-        errors << e
-        return false
-      end
-      
-      def setup_mocks(execution_context)
-        execution_context.setup_mocks_for_rspec if execution_context.respond_to?(:setup_mocks_for_rspec)
-      end
-      
-      def verify_mocks(execution_context)
-        execution_context.verify_mocks_for_rspec if execution_context.respond_to?(:verify_mocks_for_rspec)
-      end
-      
-      def teardown_mocks(execution_context)
-        execution_context.teardown_mocks_for_rspec if execution_context.respond_to?(:teardown_mocks_for_rspec)
-      end
-      
-      def append_errors(errors)
-        proc {|error| errors << error}
-      end
-      
-      def failure_location(before_each_ok, example_ok, after_each_ok)
-        return 'before(:each)' unless before_each_ok
-        return description unless example_ok
-        return 'after(:each)' unless after_each_ok
-      end
-    end
-  end
-end

data/lib/spec/dsl/example_matcher.rb

@@ -1,40 +0,0 @@
-module Spec
-  module DSL
-    class ExampleMatcher
-
-      attr_writer :example_desc
-      def initialize(behaviour_desc, example_desc=nil)
-        @behaviour_desc = behaviour_desc
-        @example_desc = example_desc
-      end
-      
-      def matches?(specified_examples)
-        specified_examples.each do |specified_example|
-          return true if matches_literal_example?(specified_example) || matches_example_not_considering_modules?(specified_example)
-        end
-        false
-      end
-      
-      private
-        def matches_literal_example?(specified_example)
-          specified_example =~ /(^#{context_regexp} #{example_regexp}$|^#{context_regexp}$|^#{example_regexp}$)/
-        end
-
-        def matches_example_not_considering_modules?(specified_example)
-          specified_example =~ /(^#{context_regexp_not_considering_modules} #{example_regexp}$|^#{context_regexp_not_considering_modules}$|^#{example_regexp}$)/
-        end
-
-        def context_regexp
-          Regexp.escape(@behaviour_desc)
-        end
-
-        def context_regexp_not_considering_modules
-          Regexp.escape(@behaviour_desc.split('::').last)
-        end
-        
-        def example_regexp
-          Regexp.escape(@example_desc)
-        end
-    end
-  end
-end

data/lib/spec/dsl/example_should_raise_handler.rb

@@ -1,74 +0,0 @@
-module Spec
-  module DSL
-    class ExampleShouldRaiseHandler
-      def initialize(file_and_line_number, opts)
-        @file_and_line_number = file_and_line_number
-        @options = opts
-        @expected_error_class = determine_error_class(opts)
-        @expected_error_message = determine_error_message(opts)
-      end
-  
-      def determine_error_class(opts)
-        if candidate = opts[:should_raise]
-          if candidate.is_a?(Class)
-            return candidate
-          elsif candidate.is_a?(Array)
-            return candidate[0]
-          else
-            return Exception
-          end
-        end
-      end
-  
-      def determine_error_message(opts)
-        if candidate = opts[:should_raise]
-          if candidate.is_a?(Array)
-            return candidate[1]
-          end
-        end
-        return nil
-      end
-  
-      def build_message(exception=nil)
-        if @expected_error_message.nil?
-          message = "example block expected #{@expected_error_class.to_s}"
-        else
-          message = "example block expected #{@expected_error_class.new(@expected_error_message.to_s).inspect}"
-        end
-        message << " but raised #{exception.inspect}" if exception
-        message << " but nothing was raised" unless exception
-        message << "\n"
-        message << @file_and_line_number
-      end
-  
-      def error_matches?(error)
-        return false unless error.kind_of?(@expected_error_class)
-        unless @expected_error_message.nil?
-          if @expected_error_message.is_a?(Regexp)
-            return false unless error.message =~ @expected_error_message
-          else
-            return false unless error.message == @expected_error_message
-          end
-        end
-        return true
-      end
-
-      def handle(errors)
-        if @expected_error_class
-          if errors.empty?
-            errors << Spec::Expectations::ExpectationNotMetError.new(build_message)
-          else
-            error_to_remove = errors.detect do |error|
-              error_matches?(error)
-            end
-            if error_to_remove.nil?
-              errors.insert(0,Spec::Expectations::ExpectationNotMetError.new(build_message(errors[0])))
-            else
-              errors.delete(error_to_remove)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/spec/runner/behaviour_runner.rb

@@ -1,123 +0,0 @@
-module Spec
-  module Runner
-    class BehaviourRunner
-      
-      def initialize(options, arg=nil)
-        @behaviours = []
-        @options = options
-      end
-    
-      def add_behaviour(behaviour)
-        if !specified_examples.nil? && !specified_examples.empty?
-          behaviour.retain_examples_matching!(specified_examples)
-        end
-        @behaviours << behaviour if behaviour.number_of_examples != 0 && !behaviour.shared?
-      end
-      
-      # Runs all behaviours and returns the number of failures.
-      def run(paths, exit_when_done)
-        prepare!(paths)
-        begin
-          run_behaviours
-        rescue Interrupt
-        ensure
-          report_end
-        end
-        failure_count = report_dump
-        
-        heckle if(failure_count == 0 && !@options.heckle_runner.nil?)
-        
-        if(exit_when_done)
-          exit_code = (failure_count == 0) ? 0 : 1
-          exit(exit_code)
-        end
-        failure_count
-      end
-      
-      def report_end
-        @options.reporter.end
-      end
-      
-      def report_dump
-        @options.reporter.dump
-      end
-      
-      def prepare!(paths)
-        unless paths.nil? # It's nil when running single specs with ruby
-          paths = find_paths(paths)
-          sorted_paths = sort_paths(paths)
-          load_specs(sorted_paths) # This will populate @behaviours via callbacks to add_behaviour
-        end
-        @options.reporter.start(number_of_examples)
-        @behaviours.reverse! if @options.reverse
-        set_sequence_numbers
-      end
-
-      def run_behaviours
-        @behaviours.each do |behaviour|
-          behaviour.run(@options.reporter, @options.dry_run, @options.reverse, @options.timeout)
-        end
-      end
-    
-      def number_of_examples
-        @behaviours.inject(0) {|sum, behaviour| sum + behaviour.number_of_examples}
-      end
-      
-      FILE_SORTERS = {
-        'mtime' => lambda {|file_a, file_b| File.mtime(file_b) <=> File.mtime(file_a)}
-      }
-      
-      def sorter(paths)
-        FILE_SORTERS[@options.loadby]
-      end
-      
-      def sort_paths(paths)
-        sorter = sorter(paths)
-        paths = paths.sort(&sorter) unless sorter.nil?
-        paths
-      end
-
-    private
-      
-      # Sets the #number on each Example
-      def set_sequence_numbers
-        number = 0
-        @behaviours.each do |behaviour|
-          number = behaviour.set_sequence_numbers(number, @options.reverse)
-        end
-      end
-      
-      def find_paths(paths)
-        result = []
-        paths.each do |path|
-          if File.directory?(path)
-            result += Dir["#{path}/**/*.rb"]
-          elsif File.file?(path)
-            result << path
-          else
-            raise "File or directory not found: #{path}"
-          end
-        end
-        result
-      end
-      
-      def load_specs(paths)
-        paths.each do |path|
-          load path
-        end
-      end
-      
-      def specified_examples
-        @options.examples
-      end
-      
-      def heckle
-        heckle_runner = @options.heckle_runner
-        @options.heckle_runner = nil
-        behaviour_runner = self.class.new(@options)
-        behaviour_runner.instance_variable_set(:@behaviours, @behaviours)
-        heckle_runner.heckle_with(behaviour_runner)
-      end
-    end
-  end
-end

data/lib/spec/runner/extensions/kernel.rb

@@ -1,50 +0,0 @@
-module Kernel
-  # Creates and registers an instance of a Spec::DSL::Behaviour (or a subclass).
-  # The instantiated behaviour class depends on the directory of the file
-  # calling this method. For example, Spec::Rails will use different
-  # classes for specs living in <tt>spec/models</tt>, <tt>spec/helpers</tt>, 
-  # <tt>spec/views</tt> and <tt>spec/controllers</tt>.
-  #
-  # It is also possible to override autodiscovery of the behaviour class 
-  # with an options Hash as the last argument:
-  #
-  #   describe "name", :behaviour_type => :something_special do ...
-  #
-  # The reason for using different behaviour classes is to have
-  # different matcher methods available from within the <tt>describe</tt>
-  # block.
-  #
-  # See Spec::DSL::BehaviourFactory#add_behaviour_class for details about 
-  # how to register special Spec::DSL::Behaviour implementations.
-  #
-  def describe(*args, &block)
-    raise ArgumentError if args.empty?
-    args << {} unless Hash === args.last
-    args.last[:spec_path] = caller(0)[1]
-    register_behaviour(Spec::DSL::BehaviourFactory.create(*args, &block))
-  end
-  alias :context :describe
-  
-  def respond_to(*names)
-    Spec::Matchers::RespondTo.new(*names)
-  end
-  
-private
-
-  def register_behaviour(behaviour)
-    if behaviour.shared?
-      Spec::DSL::Behaviour.add_shared_behaviour(behaviour)
-    else
-      behaviour_runner.add_behaviour(behaviour)
-    end
-  end
-
-  def behaviour_runner
-    # TODO: Figure out a better way to get this considered "covered" and keep this statement on multiple lines 
-    unless $behaviour_runner; \
-      $behaviour_runner = ::Spec::Runner::OptionParser.new.create_behaviour_runner(ARGV.dup, STDERR, STDOUT, false); \
-      at_exit { $behaviour_runner.run(nil, false) }; \
-    end
-    $behaviour_runner
-  end
-end

data/lib/spec/runner/extensions/object.rb

@@ -1,32 +0,0 @@
-# The following copyright applies to Object#copy_instance_variables_from,
-# which we borrowed from active_support.
-#
-# Copyright (c) 2004 David Heinemeier Hansson
-# 
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-# 
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-class Object
-  # From active_support
-  def copy_instance_variables_from(object, exclude = []) # :nodoc:
-    exclude += object.protected_instance_variables if object.respond_to? :protected_instance_variables
-    
-    instance_variables = object.instance_variables - exclude.map { |name| name.to_s }
-    instance_variables.each { |name| instance_variable_set(name, object.instance_variable_get(name)) }
-  end
-end