rspec 1.1.12 → 1.2.0

data/lib/spec/example/before_and_after_hooks.rb

@@ -37,21 +37,14 @@ module Spec
         after_parts(*args) << block
       end
 
-      # TODO - deprecate this unless there is a reason why it exists
-      def remove_after(scope, &block) # :nodoc:
-        after_each_parts.delete(block)
-      end
-
-      # Deprecated. Use before(:each)
-      def setup(&block)
-        before(:each, &block)
+      def before_each_parts # :nodoc:
+        @before_each_parts ||= []
       end
 
-      # Deprecated. Use after(:each)
-      def teardown(&block)
-        after(:each, &block)
+      def after_each_parts # :nodoc:
+        @after_each_parts ||= []
       end
-
+      
       def before_all_parts # :nodoc:
         @before_all_parts ||= []
       end
@@ -60,14 +53,6 @@ module Spec
         @after_all_parts ||= []
       end
 
-      def before_each_parts # :nodoc:
-        @before_each_parts ||= []
-      end
-
-      def after_each_parts # :nodoc:
-        @after_each_parts ||= []
-      end
-      
       def before_suite_parts
         BeforeAndAfterHooks.before_suite_parts
       end

data/lib/spec/example/errors.rb

@@ -3,9 +3,9 @@ module Spec
     class ExamplePendingError < StandardError
       attr_reader :pending_caller
 
-      def initialize(message=nil)
-        super
-        @pending_caller = caller[2]
+      def initialize(message=nil, pending_caller=nil)
+        super(message)
+        @pending_caller = pending_caller || caller[2]
       end
     end
     

data/lib/spec/example/example_description.rb

@@ -0,0 +1,15 @@
+module Spec
+  module Example
+    class ExampleDescription
+      attr_reader :description, :options, :backtrace
+      
+      def initialize(description, options={}, backtrace=nil)
+        @description, @options, @backtrace = description, options, backtrace
+      end
+      
+      def ==(other)
+        (other.description == description) & (other.backtrace == backtrace)
+      end
+    end
+  end
+end

data/lib/spec/example/example_group.rb

@@ -5,22 +5,7 @@ module Spec
     class ExampleGroup
       extend Spec::Example::ExampleGroupMethods
       include Spec::Example::ExampleMethods
-
-      def initialize(defined_description, options={}, &implementation)
-        @_options = options
-        @_defined_description = defined_description
-        @_implementation = implementation || pending_implementation
-        @_backtrace = caller
-      end
-      
-    private
-      
-      def pending_implementation
-        error = NotYetImplementedError.new(caller)
-        lambda { raise(error) }
-      end
     end
   end
 end
 
-Spec::ExampleGroup = Spec::Example::ExampleGroup

data/lib/spec/example/example_group_factory.rb

@@ -1,5 +1,6 @@
 module Spec
   module Example
+    
     class ExampleGroupFactory
       module ClassMethods
         def reset
@@ -7,13 +8,27 @@ module Spec
           default(ExampleGroup)
         end
 
-        def registered_or_ancestor_of_registered?(example_group_classes) # :nodoc:
-          example_group_classes.each do |example_group_class|
-            return false unless registered_types.any? do |registered_type|
-              registered_type.ancestors.include? example_group_class
-            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
-          return true
+        end
+
+        def create_shared_example_group(*args, &example_group_block) # :nodoc:
+          ::Spec::Example::add_spec_path_to(args)
+          ::Spec::Example::SharedExampleGroup.register(*args, &example_group_block)
+        end
+        
+        def create_example_group(*args, &block)
+          raise ArgumentError if args.empty?
+          raise ArgumentError unless block
+          Spec::Example::add_spec_path_to(args)
+          superclass = determine_superclass(args.last)
+          superclass.describe(*args, &block)
         end
 
         # Registers an example group class +klass+ with the symbol +type+. For
@@ -31,44 +46,22 @@ module Spec
         # 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] = 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 get(key=nil)
-          if @example_group_types.values.include?(key)
-            key
-          else
-            @example_group_types[key]
-          end
-        end
-        
-        def create_example_group(*args, &block)
-          raise ArgumentError if args.empty?
-          raise ArgumentError unless block
-          Spec::Example::add_spec_path_to(args)
-          superclass = determine_superclass(args.last)
-          superclass.describe(*args, &block)
-        end
-        
-        def create_shared_example_group(*args, &block)
-          Spec::Example::add_spec_path_to(args)
-          SharedExampleGroup.register(*args, &block)
+        def [](key)
+          @example_group_types[key]
         end
-        
-        def include_constants_in(context, &block)
-          if (Spec::Ruby.version.to_f >= 1.9 && Module === context && !(Class === context))
-            return lambda {include context;instance_eval(&block)}
-          end
-          block
-        end
-        
+
         def assign_scope(scope, args)
           args.last[:scope] = scope
         end
@@ -76,18 +69,13 @@ module Spec
       protected
 
         def determine_superclass(opts)
-          key = if opts[:type]
-            opts[:type]
-          elsif opts[:spec_path] =~ /spec(\\|\/)(#{@example_group_types.keys.join('|')})/
-            $2 == '' ? nil : $2.to_sym
+          if type = opts[:type]
+            self[type]
+          elsif opts[:spec_path] =~ /spec(\\|\/)(#{@example_group_types.keys.sort_by{|k| k.to_s.length}.reverse.join('|')})/
+            self[$2 == '' ? nil : $2.to_sym]
+          else
+            self[nil]
           end
-          get(key)
-        end
-        
-      private
-        
-        def registered_types
-          @example_group_types.values
         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

data/lib/spec/example/example_group_methods.rb

@@ -4,23 +4,18 @@ module Spec
     module ExampleGroupMethods
       class << self
         attr_accessor :matcher_class
-
-        def description_text(*args)
-          args.inject("") do |description, arg|
-            description << " " unless (description == "" || arg.to_s =~ /^(\s|\.|#)/)
-            description << arg.to_s
-          end
-        end
-
-        def example_group_creation_listeners
-          @example_group_creation_listeners ||= []
-        end
       end
 
       include Spec::Example::BeforeAndAfterHooks
+      include Spec::Example::Subject::ExampleGroupMethods
+      include Spec::Example::PredicateMatchers
 
-      attr_reader :description_options, :spec_path
-      alias :options :description_options
+      attr_reader :options, :spec_path
+      
+      def inherited(klass) # :nodoc:
+        super
+        ExampleGroupFactory.register_example_group(klass)
+      end
       
       # Provides the backtrace up to where this example_group was declared.
       def backtrace
@@ -36,21 +31,6 @@ WARNING
         backtrace
       end
       
-      def description_args
-        @description_args ||= []
-      end
-
-      def inherited(klass)
-        super
-        register_example_group(klass)
-      end
-      
-      def register_example_group(klass)
-        ExampleGroupMethods.example_group_creation_listeners.each do |l|
-          l.register_example_group(klass)
-        end
-      end
-      
       # Makes the describe/it syntax available from a class. For example:
       #
       #   class StackSpec < Spec::ExampleGroup
@@ -70,9 +50,9 @@ WARNING
           Spec::Example::add_spec_path_to(args)
           options = args.last
           if options[:shared]
-            create_shared_example_group(*args, &example_group_block)
+            ExampleGroupFactory.create_shared_example_group(*args, &example_group_block)
           else
-            create_example_group_subclass(*args, &example_group_block)
+            subclass(*args, &example_group_block)
           end
         else
           set_description(*args)
@@ -80,26 +60,6 @@ WARNING
       end
       alias :context :describe
       
-      def create_shared_example_group(*args, &example_group_block) # :nodoc:
-        SharedExampleGroup.register(*args, &example_group_block)
-      end
-      
-      # Creates a new subclass of self, with a name "under" our own name.
-      # Example:
-      #
-      #   x = Foo::Bar.subclass('Zap'){}
-      #   x.name # => Foo::Bar::Zap_1
-      #   x.superclass.name # => Foo::Bar
-      def create_example_group_subclass(*args, &example_group_block) # :nodoc:
-        @class_count ||= 0
-        @class_count += 1
-        klass = const_set("Subclass_#{@class_count}", Class.new(self))
-        klass.set_description(*args)
-        example_group_block = ExampleGroupFactory.include_constants_in(args.last[:scope], &example_group_block)
-        klass.module_eval(&example_group_block)
-        klass
-      end
-      
       # Use this to pull in examples from shared example groups.
       def it_should_behave_like(*shared_example_groups)
         shared_example_groups.each do |group|
@@ -107,44 +67,18 @@ WARNING
         end
       end
       
-      # :call-seq:
-      #   predicate_matchers[matcher_name] = method_on_object
-      #   predicate_matchers[matcher_name] = [method1_on_object, method2_on_object]
-      #
-      # Dynamically generates a custom matcher that will match
-      # a predicate on your class. RSpec provides a couple of these
-      # out of the box:
-      #
-      #   exist (for state expectations)
-      #     File.should exist("path/to/file")
-      #
-      #   an_instance_of (for mock argument constraints)
-      #     mock.should_receive(:message).with(an_instance_of(String))
-      #
-      # == Examples
-      #
-      #   class Fish
-      #     def can_swim?
-      #       true
-      #     end
-      #   end
-      #
-      #   describe Fish do
-      #     predicate_matchers[:swim] = :can_swim?
-      #     it "should swim" do
-      #       Fish.new.should swim
-      #     end
-      #   end
-      def predicate_matchers
-        @predicate_matchers ||= {}
-      end
-
       # Creates an instance of the current example group class and adds it to
       # a collection of examples of the current example group.
-      def example(description=nil, options={}, &implementation)
-        e = new(description, options, &implementation)
-        example_objects << e
-        e
+      def example(description=nil, options={}, backtrace=nil, &implementation)
+        example_description = ExampleDescription.new(description, options, backtrace || caller(0)[1])
+        example_descriptions << example_description
+        example_implementations[example_description] = implementation || pending_implementation
+        example_description
+      end
+      
+      def pending_implementation
+        error = Spec::Example::NotYetImplementedError.new(caller)
+        lambda { raise(error) }
       end
 
       alias_method :it, :example
@@ -157,105 +91,101 @@ WARNING
       
       alias_method :xit, :xexample
       alias_method :xspecify, :xexample
-
+      
       def run(run_options)
         examples = examples_to_run(run_options)
-        run_options.reporter.add_example_group(self) unless examples.empty?
+        notify(run_options.reporter) unless examples.empty?
         return true if examples.empty?
         return dry_run(examples, run_options) if run_options.dry_run?
 
-        plugin_mock_framework(run_options)
-        define_methods_from_predicate_matchers(run_options)
+        define_methods_from_predicate_matchers
 
         success, before_all_instance_variables = run_before_all(run_options)
         success, after_all_instance_variables  = execute_examples(success, before_all_instance_variables, examples, run_options)
         success                                = run_after_all(success, after_all_instance_variables, run_options)
       end
 
+      def set_description(*args)
+        @description_args, @options = Spec::Example.args_and_options(*args)
+        @backtrace = caller(1)
+        @spec_path = File.expand_path(options[:spec_path]) if options[:spec_path]
+        self
+      end
+      
+      def notify(listener) # :nodoc:
+        listener.add_example_group(self)
+      end
+
       def description
-        result = ExampleGroupMethods.description_text(*description_parts)
-        (result.nil? || result == "") ? to_s : result
+        @description ||= build_description_from(*description_parts) || to_s
       end
       
       def described_type
-        description_parts.reverse.find {|part| part.is_a?(Module)}
+        @described_type ||= description_parts.reverse.find {|part| part.is_a?(Module)}
       end
       
-      # Defines an explicit subject for an example group which can then be the
-      # implicit receiver (through delegation) of calls to +should+.
-      #
-      # == Examples
-      #
-      #   describe CheckingAccount, "with $50" do
-      #     subject { CheckingAccount.new(:amount => 50, :currency => :USD) }
-      #     it { should have_a_balance_of(50, :USD)}
-      #     it { should_not be_overdrawn}
-      #   end
-      #
-      # See +ExampleMethods#should+ for more information about this approach.
-      def subject(&block)
-        @_subject_block = block
+      def described_class
+        @described_class ||= Class === described_type ? described_type : nil
       end
       
-      def subject_block
-        @_subject_block || lambda {nil}
+      def description_args
+        @description_args ||= []
       end
       
       def description_parts #:nodoc:
-        example_group_hierarchy.inject([]) do |parts, example_group_class|
+        @description_parts ||= example_group_hierarchy.inject([]) do |parts, example_group_class|
           [parts << example_group_class.description_args].flatten
         end
       end
-
-      def set_description(*args)
-        args, options = Spec::Example.args_and_options(*args)
-        @description_args = args
-        @description_options = options
-        @description_text = ExampleGroupMethods.description_text(*args)
-        @backtrace = caller(1)
-        @spec_path = File.expand_path(options[:spec_path]) if options[:spec_path]
-        self
+      
+      def example_descriptions # :nodoc:
+        @example_descriptions ||= []
       end
       
+      def example_implementations # :nodoc:
+        @example_implementations ||= {}
+      end
+            
       def examples(run_options=nil) #:nodoc:
-        examples = example_objects.dup
-        add_method_examples(examples)
-        (run_options && run_options.reverse) ? examples.reverse : examples
+        (run_options && run_options.reverse) ? example_descriptions.reverse : example_descriptions
       end
 
       def number_of_examples #:nodoc:
-        examples.length
+        example_descriptions.length
       end
 
-      # Only used from RSpec's own examples
-      def reset # :nodoc:
-        @before_all_parts = nil
-        @after_all_parts = nil
-        @before_each_parts = nil
-        @after_each_parts = nil
-      end
-
-      def run_before_each(example)
-        example.eval_each_fail_fast(all_before_each_parts)
+      def example_group_hierarchy
+        @example_group_hierarchy ||= ExampleGroupHierarchy.new(self)
       end
       
-      def all_before_each_parts
-        unless @all_before_each_parts
-          @all_before_each_parts = []
-          example_group_hierarchy.each do |example_group_class|
-            @all_before_each_parts += example_group_class.before_each_parts
+      def filtered_description(filter)
+        build_description_from(
+          *nested_descriptions.collect do |description|
+            description =~ filter ? $1 : description
           end
-        end
-        @all_before_each_parts
+        )
+      end
+      
+      def nested_descriptions
+        example_group_hierarchy.nested_descriptions
       end
+      
+      def include_constants_in(mod)
+        include mod if (Spec::Ruby.version.to_f >= 1.9) & (Module === mod) & !(Class === mod)
+      end
+      
+    private
 
-      def run_after_each(example)
-        example_group_hierarchy.reverse.each do |example_group_class|
-          example.eval_each_fail_slow(example_group_class.after_each_parts)
-        end
+      def subclass(*args, &example_group_block)
+        @class_count ||= 0
+        @class_count += 1
+        klass = const_set("Subclass_#{@class_count}", Class.new(self))
+        klass.set_description(*args)
+        klass.include_constants_in(args.last[:scope])
+        klass.module_eval(&example_group_block)
+        klass
       end
 
-    private
       def dry_run(examples, run_options)
         examples.each do |example|
           run_options.reporter.example_started(example)
@@ -264,14 +194,13 @@ WARNING
       end
 
       def run_before_all(run_options)
+        return [true,{}] if example_group_hierarchy.before_all_parts.empty?
         before_all = new("before(:all)")
         begin
-          example_group_hierarchy.each do |example_group_class|
-            before_all.eval_each_fail_fast(example_group_class.before_all_parts)
-          end
+          example_group_hierarchy.run_before_all(before_all)
           return [true, before_all.instance_variable_hash]
         rescue Exception => e
-          run_options.reporter.failure(before_all, e)
+          run_options.reporter.example_failed(ExampleDescription.new("before(:all)"), e)
           return [false, before_all.instance_variable_hash]
         end
       end
@@ -280,29 +209,30 @@ WARNING
         return [success, instance_variables] unless success
 
         after_all_instance_variables = instance_variables
-        examples.each do |example_group_instance|
+        
+        examples.each do |example|
+          example_group_instance = new(example.description,example.options,&example_implementations[example])
           success &= example_group_instance.execute(run_options, instance_variables)
           after_all_instance_variables = example_group_instance.instance_variable_hash
         end
+        
         return [success, after_all_instance_variables]
       end
-
+      
       def run_after_all(success, instance_variables, run_options)
+        return success if example_group_hierarchy.after_all_parts.empty?
         after_all = new("after(:all)")
         after_all.set_instance_variables_from_hash(instance_variables)
-        example_group_hierarchy.reverse.each do |example_group_class|
-          after_all.eval_each_fail_slow(example_group_class.after_all_parts)
-        end
+        example_group_hierarchy.run_after_all(after_all)
         return success
       rescue Exception => e
-        run_options.reporter.failure(after_all, e)
+        run_options.reporter.example_failed(ExampleDescription.new("after(:all)"), e)
         return false
       end
-
+      
       def examples_to_run(run_options)
-        all_examples = examples(run_options)
-        return all_examples unless specified_examples?(run_options)
-        all_examples.reject do |example|
+        return example_descriptions unless specified_examples?(run_options)
+        example_descriptions.reject do |example|
           matcher = ExampleGroupMethods.matcher_class.
             new(description.to_s, example.description)
           !matcher.matches?(run_options.examples)
@@ -310,68 +240,21 @@ WARNING
       end
 
       def specified_examples?(run_options)
-        run_options.examples && !run_options.examples.empty?
+        !run_options.examples.empty?
       end
 
-      def example_objects
-        @example_objects ||= []
-      end
-
-      class ExampleGroupHierarchy < Array
-        def initialize(example_group_class)
-          current_class = example_group_class
-          while current_class.kind_of?(ExampleGroupMethods)
-            unshift(current_class)
-            break unless current_class.respond_to? :superclass
-            current_class = current_class.superclass
-          end
-        end
+      def method_added(name) # :nodoc:
+        example(name.to_s, {}, caller(0)[1]) {__send__ name.to_s} if example_method?(name.to_s)
       end
       
-      def example_group_hierarchy
-        @example_group_hierarchy ||= ExampleGroupHierarchy.new(self)
-      end
-
-      def plugin_mock_framework(run_options)
-        case mock_framework = run_options.mock_framework
-        when Module
-          include mock_framework
-        else
-          require mock_framework
-          include Spec::Adapters::MockFramework
-        end
-      end
-
-      def define_methods_from_predicate_matchers(run_options) # :nodoc:
-        all_predicate_matchers = predicate_matchers.merge(
-          run_options.predicate_matchers
-        )
-        all_predicate_matchers.each_pair do |matcher_method, method_on_object|
-          define_method matcher_method do |*args|
-            eval("be_#{method_on_object.to_s.gsub('?','')}(*args)")
-          end
-        end
-      end
-
-      def add_method_examples(examples)
-        instance_methods.each do |method_name|
-          if example_method?(method_name)
-            examples << new(method_name) do
-              __send__(method_name)
-            end
-          end
-        end
-      end
-
       def example_method?(method_name)
         should_method?(method_name)
       end
 
       def should_method?(method_name)
         !(method_name =~ /^should(_not)?$/) &&
-        method_name =~ /^should/ && (
-          [-1,0].include?(instance_method(method_name).arity)
-        )
+        method_name =~ /^should/ &&
+        instance_method(method_name).arity < 1
       end
 
       def include_shared_example_group(shared_example_group)
@@ -387,6 +270,13 @@ WARNING
         end
       end
 
+      def build_description_from(*args)
+        text = args.inject("") do |description, arg|
+          description << " " unless (description == "" || arg.to_s =~ /^(\s|\.|#)/)
+          description << arg.to_s
+        end
+        text == "" ? nil : text
+      end
     end
 
   end