rspec 1.0.0 → 1.3.1

data/lib/autotest/rspec.rb

@@ -0,0 +1,54 @@
+require 'autotest'
+
+Autotest.add_hook :initialize do |at|
+  at.clear_mappings
+  # watch out for Ruby bug (1.8.6): %r(/) != /\//
+  at.add_mapping(%r%^spec/.*_spec\.rb$%) { |filename, _|
+    filename
+  }
+  at.add_mapping(%r%^lib/(.*)\.rb$%) { |_, m|
+    ["spec/#{m[1]}_spec.rb"]
+  }
+  at.add_mapping(%r%^spec/(spec_helper|shared/.*)\.rb$%) {
+    at.files_matching %r%^spec/.*_spec\.rb$%
+  }
+end
+
+class RspecCommandError < StandardError; end
+
+class Autotest::Rspec < Autotest
+  
+  SPEC_PROGRAM = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'spec'))
+
+  def initialize
+    super
+    self.failed_results_re = /^\d+\)\n(?:\e\[\d*m)?(?:.*?in )?'([^\n]*)'(?: FAILED)?(?:\e\[\d*m)?\n\n?(.*?(\n\n\(.*?)?)\n\n/m
+    self.completed_re = /\n(?:\e\[\d*m)?\d* examples?/m
+  end
+
+  def consolidate_failures(failed)
+    filters = new_hash_of_arrays
+    failed.each do |spec, trace|
+      if trace =~ /\n(\.\/)?(.*spec\.rb):[\d]+:/
+        filters[$2] << spec
+      end
+    end
+    return filters
+  end
+
+  def make_test_cmd(files_to_test)
+    files_to_test.empty? ? '' :
+      "#{ruby} #{SPEC_PROGRAM} --autospec #{normalize(files_to_test).keys.flatten.join(' ')} #{add_options_if_present}"
+  end
+
+  def normalize(files_to_test)
+    files_to_test.keys.inject({}) do |result, filename|
+      result[File.expand_path(filename)] = []
+      result
+    end
+  end
+
+  def add_options_if_present # :nodoc:
+    File.exist?("spec/spec.opts") ? "-O #{File.join('spec','spec.opts')} " : ""
+  end
+end

data/lib/spec/adapters/mock_frameworks/flexmock.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+#
+#  Created by Jim Weirich on 2007-04-10.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+require 'flexmock/rspec'
+
+module Spec
+  module Adapters
+    module MockFramework
+      include FlexMock::MockContainer
+      def setup_mocks_for_rspec
+        # No setup required
+      end
+      def verify_mocks_for_rspec
+        flexmock_verify
+      end
+      def teardown_mocks_for_rspec
+        flexmock_close
+      end
+    end
+  end
+end

data/{plugins → lib/spec/adapters}/mock_frameworks/mocha.rb

@@ -1,12 +1,16 @@
-require 'rubygems'
-gem 'mocha'
+require 'rubygems' unless ENV['NO_RUBYGEMS']
 require 'mocha/standalone'
 require 'mocha/object'
 
 module Spec
-  module Plugins
+  module Adapters
     module MockFramework
-      include Mocha::Standalone
+      # Mocha::Standalone was deprecated as of Mocha 0.9.7.  
+      begin
+        include Mocha::API
+      rescue NameError
+        include Mocha::Standalone
+      end
       def setup_mocks_for_rspec
         mocha_setup
       end

data/lib/spec/adapters/mock_frameworks/rr.rb

@@ -0,0 +1,22 @@
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+require 'rr'
+
+patterns = ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS
+patterns.push(RR::Errors::BACKTRACE_IDENTIFIER)
+
+module Spec
+  module Adapters
+    module MockFramework
+      include RR::Extensions::InstanceMethods
+      def setup_mocks_for_rspec
+        RR::Space.instance.reset
+      end
+      def verify_mocks_for_rspec
+        RR::Space.instance.verify_doubles
+      end
+      def teardown_mocks_for_rspec
+        RR::Space.instance.reset
+      end
+    end
+  end
+end

data/lib/spec/adapters/mock_frameworks/rspec.rb

@@ -0,0 +1,21 @@
+require 'spec/mocks/framework'
+require 'spec/mocks/extensions'
+
+module Spec
+  module Adapters
+    unless defined?(MockFramework)
+      module MockFramework
+        include Spec::Mocks::ExampleMethods
+        def setup_mocks_for_rspec
+          $rspec_mocks ||= Spec::Mocks::Space.new
+        end
+        def verify_mocks_for_rspec
+          $rspec_mocks.verify_all
+        end
+        def teardown_mocks_for_rspec
+          $rspec_mocks.reset_all
+        end
+      end
+    end
+  end
+end

data/lib/spec/autorun.rb

@@ -0,0 +1,3 @@
+require 'spec'
+
+Spec::Runner.autorun

data/lib/spec/deprecation.rb

@@ -0,0 +1,41 @@
+module Spec
+  class << self
+    def deprecate(method, alternate_method=nil)
+      return if Spec::Runner.configuration.suppress_deprecation_warnings?
+      message = <<-NOTICE
+
+*****************************************************************
+DEPRECATION WARNING: you are using deprecated behaviour that will
+be removed from a future version of RSpec.
+
+#{caller(0)[2]}
+
+* #{method} is deprecated.
+NOTICE
+      if alternate_method
+        message << <<-ADDITIONAL
+* please use #{alternate_method} instead.
+ADDITIONAL
+      end
+
+      message << "*****************************************************************"
+      warn(message)
+    end
+
+    def warn(message)
+      Kernel.warn(message)
+    end
+
+  end
+
+  class HashWithDeprecationNotice < Hash
+    def initialize(method, alternate_method=nil, &block)
+      @method, @alternate_method = method, alternate_method
+    end
+    def []=(k,v)
+      Spec.deprecate(@method, @alternate_method)
+      super
+    end
+  end
+end
+

data/lib/spec/dsl/main.rb

@@ -0,0 +1,93 @@
+module Spec
+  module DSL
+    module Main
+      include Spec::Example::ArgsAndOptions
+
+      # Creates and returns a class that includes the ExampleGroupMethods
+      # module. Which ExampleGroup type is created 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 example group
+      # type with an options Hash as the last argument:
+      #
+      #   describe "name", :type => :something_special do ...
+      #
+      # The reason for using different example group classes is to have different
+      # matcher methods available from within the <tt>describe</tt> block.
+      #
+      # See Spec::Example::ExampleGroupFactory#register for details about how to
+      # register special implementations.
+      #
+      def describe(*args, &block)
+        raise Spec::Example::NoDescriptionError.new("example group", caller(0)[1]) if args.empty?
+        add_options(args, :scope => self)
+        set_location(args.options, caller(0)[1])
+        Spec::Example::ExampleGroupFactory.create_example_group(*args, &block)
+      end
+      alias :context :describe unless defined?(IRB::Context)
+
+      # Creates an example group that can be shared by other example groups
+      #
+      # == Examples
+      #
+      #  share_examples_for "All Editions" do
+      #    it "all editions behaviour" ...
+      #  end
+      #
+      #  describe SmallEdition do
+      #    it_should_behave_like "All Editions"
+      #
+      #    it "should do small edition stuff" do
+      #      ...
+      #    end
+      #  end
+      def share_examples_for(*args, &block)
+        add_options(args)
+        set_location(args.options, caller(0)[1])
+        Spec::Example::ExampleGroupFactory.create_shared_example_group(*args, &block)
+      end
+      alias :shared_examples_for :share_examples_for
+
+      # Creates a Shared Example Group and assigns it to a constant
+      #
+      #  share_as :AllEditions do
+      #    it "should do all editions stuff" ...
+      #  end
+      #
+      #  describe SmallEdition do
+      #    it_should_behave_like AllEditions
+      #
+      #    it "should do small edition stuff" do
+      #      ...
+      #    end
+      #  end
+      #
+      # And, for those of you who prefer to use something more like Ruby, you
+      # can just include the module directly
+      #
+      #  describe SmallEdition do
+      #    include AllEditions
+      #
+      #    it "should do small edition stuff" do
+      #      ...
+      #    end
+      #  end
+      def share_as(name, &block)
+        Spec.deprecate("share_as","shared_examples_for")
+        begin
+          args = [name]
+          add_options(args)
+          set_location(args.options, caller(0)[1])
+          Object.const_set(name, Spec::Example::ExampleGroupFactory.create_shared_example_group(*args, &block))
+        rescue NameError => e
+          raise NameError.new(e.message + "\nThe first argument to share_as must be a legal name for a constant\n")
+        end
+      end
+    end
+  end
+end
+
+include Spec::DSL::Main

data/lib/spec/dsl.rb

@@ -1,10 +1 @@
-require 'spec/dsl/description'
-require 'spec/dsl/configuration'
-require 'spec/dsl/behaviour_callbacks'
-require 'spec/dsl/behaviour'
-require 'spec/dsl/behaviour_eval'
-require 'spec/dsl/composite_proc_builder'
-require 'spec/dsl/example'
-require 'spec/dsl/example_matcher'
-require 'spec/dsl/example_should_raise_handler'
-require 'spec/dsl/behaviour_factory'
+require 'spec/dsl/main'

data/lib/spec/example/args_and_options.rb

@@ -0,0 +1,27 @@
+module Spec
+  module Example
+    module ArgsAndOptions
+      def args_and_options(*args) # :nodoc:
+        options = Hash === args.last ? args.pop : {}
+        return args, options
+      end
+
+      def add_options(args, options={}) # :nodoc:
+        args << {} unless Hash === args.last
+        args.extend WithOptions
+        args.options.merge!(options)
+        args.options
+      end
+
+      def set_location(options, location) # :nodoc:
+        options[:location] ||= location
+      end
+
+      module WithOptions # :nodoc:
+        def options
+          last
+        end
+      end
+    end
+  end
+end

data/lib/spec/example/before_and_after_hooks.rb

@@ -0,0 +1,93 @@
+module Spec
+  module Example
+    module BeforeAndAfterHooks
+      class << self
+        def before_suite_parts # :nodoc:
+          @before_suite_parts ||= []
+        end
+
+        def after_suite_parts # :nodoc:
+          @after_suite_parts ||= []
+        end
+      end
+
+      # Registers a block to be executed before examples. <tt>scope</tt> can be
+      # <tt>:each</tt> (default), <tt>:all</tt>, or <tt>:suite</tt>. When
+      # <tt>:each</tt>, the block is executed before each example. When
+      # <tt>:all</tt>, the block is executed only once before any examples are
+      # run.
+      def append_before(scope = :each, &block)
+        before_parts(scope) << block
+      end
+      alias_method :before, :append_before
+
+      # Registers a block to be executed before each example.
+      # This method prepends +block+ to existing before blocks.
+      #
+      # See <tt>append_before</tt> for scoping semantics.
+      def prepend_before(scope = :each, &block)
+        before_parts(scope).unshift(block)
+      end
+
+      # Registers a block to be executed after each example.
+      # This method prepends +block+ to existing after blocks.
+      #
+      # See <tt>append_before</tt> for scoping semantics.
+      def prepend_after(scope = :each, &block)
+        after_parts(scope).unshift(block)
+      end
+      alias_method :after, :prepend_after
+
+      # Registers a block to be executed after each example.
+      # This method appends +block+ to existing after blocks.
+      #
+      # See <tt>append_before</tt> for scoping semantics.
+      def append_after(scope = :each, &block)
+        after_parts(scope) << block
+      end
+
+      def before_each_parts # :nodoc:
+        @before_each_parts ||= []
+      end
+
+      def after_each_parts # :nodoc:
+        @after_each_parts ||= []
+      end
+
+      def before_all_parts # :nodoc:
+        @before_all_parts ||= []
+      end
+
+      def after_all_parts # :nodoc:
+        @after_all_parts ||= []
+      end
+
+      def before_suite_parts # :nodoc:
+        BeforeAndAfterHooks.before_suite_parts
+      end
+
+      def after_suite_parts # :nodoc:
+        BeforeAndAfterHooks.after_suite_parts
+      end
+
+    private
+
+      def before_parts(scope)
+        case scope
+        when :each; before_each_parts
+        when :all; before_all_parts
+        when :suite; before_suite_parts
+        end
+      end
+
+      def after_parts(scope)
+        case scope
+        when :each; after_each_parts
+        when :all; after_all_parts
+        when :suite; after_suite_parts
+        end
+      end
+
+    end
+  end
+end

data/lib/spec/example/errors.rb

@@ -0,0 +1,25 @@
+module Spec
+  module Example
+    class ExamplePendingError < StandardError; end
+
+    class NotYetImplementedError < ExamplePendingError
+      MESSAGE = "Not Yet Implemented"
+      def initialize
+        super(MESSAGE)
+      end
+    end
+
+    class PendingExampleFixedError < StandardError; end
+
+    class NoDescriptionError < ArgumentError
+      class << self
+        def message(kind, location)
+          "No description supplied for #{kind} declared on #{location}"
+        end
+      end
+      def initialize(kind, location)
+        super(self.class.message(kind, location))
+      end
+    end
+  end
+end

data/lib/spec/example/example_group.rb

@@ -0,0 +1,10 @@
+module Spec
+  module Example
+    # Base class for customized example groups. Use this if you
+    # want to make a custom example group.
+    class ExampleGroup
+      extend Spec::Example::ExampleGroupMethods
+      include Spec::Example::ExampleMethods
+    end
+  end
+end

data/lib/spec/example/example_group_factory.rb

@@ -0,0 +1,82 @@
+module Spec
+  module Example
+
+    class ExampleGroupFactory
+      module ClassMethods
+        include Spec::Example::ArgsAndOptions
+
+        def reset
+          @example_group_types = nil
+          default(ExampleGroup)
+        end
+
+        def example_group_creation_listeners
+          @example_group_creation_listeners ||= []
+        end
+
+        def register_example_group(klass)
+          example_group_creation_listeners.each do |listener|
+            listener.register_example_group(klass)
+          end
+        end
+
+        def create_shared_example_group(*args, &example_group_block) # :nodoc:
+          ::Spec::Example::SharedExampleGroup.register(*args, &example_group_block)
+        end
+
+        def create_example_group(*args, &block)
+          raise ArgumentError if args.empty? || block.nil?
+          add_options(args)
+          superclass = determine_superclass(args.last)
+          superclass.describe(*args, &block)
+        end
+
+        # Registers an example group class +klass+ with the symbol +type+. For
+        # example:
+        #
+        #   Spec::Example::ExampleGroupFactory.register(:farm, FarmExampleGroup)
+        #
+        # With that you can append a hash with :type => :farm to the describe
+        # method and it will load an instance of FarmExampleGroup.
+        #
+        #   describe Pig, :type => :farm do
+        #     ...
+        #
+        # If you don't use the hash explicitly, <tt>describe</tt> will
+        # implicitly use an instance of FarmExampleGroup for any file loaded
+        # from the <tt>./spec/farm</tt> directory.
+        def register(key, example_group_class)
+          @example_group_types[key.to_sym] = example_group_class
+        end
+
+        # Sets the default ExampleGroup class
+        def default(example_group_class)
+          Spec.__send__ :remove_const, :ExampleGroup if Spec.const_defined?(:ExampleGroup)
+          Spec.const_set(:ExampleGroup, example_group_class)
+          old = @example_group_types
+          @example_group_types = Hash.new(example_group_class)
+          @example_group_types.merge!(old) if old
+        end
+
+        def [](key)
+          @example_group_types[key]
+        end
+
+      protected
+
+        def determine_superclass(opts)
+          if type = opts[:type]
+            self[type]
+          elsif opts[:location] =~ /spec(\\|\/)(#{@example_group_types.keys.sort_by{|k| k.to_s.length}.reverse.join('|')})/
+            self[$2 == '' ? nil : $2.to_sym]
+          else
+            self[nil]
+          end
+        end
+
+      end
+      extend ClassMethods
+      self.reset
+    end
+  end
+end

data/lib/spec/example/example_group_hierarchy.rb

@@ -0,0 +1,53 @@
+module Spec
+  module Example
+    class ExampleGroupHierarchy < Array
+      def initialize(example_group_class)
+        push example_group_class
+        if example_group_class.respond_to?(:superclass) && example_group_class.superclass.respond_to?(:example_group_hierarchy)
+          unshift example_group_class.superclass.example_group_hierarchy
+          flatten!
+        end
+      end
+
+      def run_before_all(example)
+        example.eval_each_fail_fast(before_all_parts)
+      end
+
+      def run_before_each(example)
+        example.eval_each_fail_fast(before_each_parts)
+      end
+
+      def run_after_each(example)
+        example.eval_each_fail_slow(after_each_parts)
+      end
+
+      def run_after_all(example)
+        example.eval_each_fail_slow(after_all_parts)
+      end
+
+      def before_all_parts
+        @before_all_parts ||= collect {|klass| klass.before_all_parts}.flatten
+      end
+
+      def before_each_parts
+        @before_each_parts ||= collect {|klass| klass.before_each_parts}.flatten
+      end
+
+      def after_each_parts
+        @after_each_parts ||= reverse.collect {|klass| klass.after_each_parts}.flatten
+      end
+
+      def after_all_parts
+        @after_all_parts ||= reverse.collect {|klass| klass.after_all_parts}.flatten
+      end
+
+      def nested_descriptions
+        @nested_descriptions ||= collect {|eg| nested_description_from(eg) == "" ? nil : nested_description_from(eg) }.compact
+      end
+
+      def nested_description_from(example_group)
+        example_group.description_args.join
+      end
+    end
+  end
+end