rspec-core 2.0.0.beta.12 → 2.0.0.beta.13

data/lib/rspec/core/example.rb

@@ -2,7 +2,7 @@ module RSpec
   module Core
     class Example
 
-      attr_reader :metadata, :example_block
+      attr_reader :metadata, :example_block, :options
 
       def self.delegate_to_metadata(*keys)
         keys.each do |key|
@@ -33,7 +33,7 @@ module RSpec
       def run(example_group_instance, reporter)
         @in_block = false
         @example_group_instance = example_group_instance
-        @example_group_instance.running_example = self
+        @example_group_instance.example = self
 
         run_started
 
@@ -43,10 +43,10 @@ module RSpec
           run_before_each
           pending_declared_in_example = catch(:pending_declared_in_example) do
             @in_block = true
-            if @example_group_class.around_eachs.empty?
+            if @example_group_class.hooks[:around][:each].empty?
               @example_group_instance.instance_eval(&example_block) unless pending
             else
-              @example_group_class.around_eachs.first.call(AroundProxy.new(self, &example_block))
+              @example_group_class.hooks[:around][:each].first.call(AroundProxy.new(self, &example_block))
             end
             throw :pending_declared_in_example, false
           end
@@ -62,7 +62,7 @@ module RSpec
         rescue Exception => e
           exception ||= e
         ensure
-          @example_group_instance.running_example = nil
+          @example_group_instance.example = nil
         end
 
         if exception

data/lib/rspec/core/example_group.rb

@@ -6,7 +6,12 @@ module RSpec
       include Let
       include Pending
 
-      attr_accessor :running_example
+      attr_accessor :example
+
+      def running_example
+        RSpec.deprecate('running_example', 'example')
+        example
+      end
 
       def self.world
         RSpec.world
@@ -135,36 +140,30 @@ module RSpec
         @before_all_ivars ||= {}
       end
 
-      def self.eval_before_alls(running_example)
+      def self.eval_before_alls(example)
         return if descendant_filtered_examples.empty?
-        superclass.before_all_ivars.each { |ivar, val| running_example.instance_variable_set(ivar, val) }
-        world.run_hook(:before, :all, self, running_example)
+        superclass.before_all_ivars.each { |ivar, val| example.instance_variable_set(ivar, val) }
+        world.run_hook_filtered(:before, :all, self, example)
 
-        until before_alls.empty?
-          running_example.instance_eval &before_alls.shift
-        end
-        running_example.instance_variables.each { |ivar| before_all_ivars[ivar] = running_example.instance_variable_get(ivar) }
+        run_hook!(:before, :all, example, :reverse => true)
+        example.instance_variables.each { |ivar| before_all_ivars[ivar] = example.instance_variable_get(ivar) }
       end
 
-      def self.eval_before_eachs(running_example)
-        world.run_hook(:before, :each, self, running_example)
-        ancestors.reverse.each { |ancestor| ancestor.before_eachs.each { |blk| running_example.instance_eval(&blk) } }
+      def self.eval_before_eachs(example)
+        world.run_hook_filtered(:before, :each, self, example)
+        ancestors.reverse.each { |ancestor| ancestor.run_hook(:before, :each, example) }
       end
 
-      def self.eval_after_eachs(running_example)
-        ancestors.each { |ancestor| ancestor.after_eachs.reverse.each { |blk| running_example.instance_eval(&blk) } }
-        world.run_hook(:after, :each, self, running_example)
+      def self.eval_after_eachs(example)
+        ancestors.each { |ancestor| ancestor.run_hook(:after, :each, example, :reverse => true) }
+        world.run_hook_filtered(:after, :each, self, example)
       end
 
-      def self.eval_after_alls(running_example)
+      def self.eval_after_alls(example)
         return if descendant_filtered_examples.empty?
-        before_all_ivars.each { |ivar, val| running_example.instance_variable_set(ivar, val) }
-        ancestors.each do |ancestor|
-          until ancestor.after_alls.empty?
-            running_example.instance_eval &ancestor.after_alls.pop
-          end
-        end
-        world.run_hook(:after, :all, self, running_example)
+        before_all_ivars.each { |ivar, val| example.instance_variable_set(ivar, val) }
+        ancestors.each {|ancestor| ancestor.run_hook!(:after, :all, example) }
+        world.run_hook_filtered(:after, :all, self, example)
       end
 
       def self.run(reporter)
@@ -172,9 +171,8 @@ module RSpec
         reporter.add_example_group(self)
         begin
           eval_before_alls(example_group_instance)
-          result_for_this_group = run_examples(example_group_instance, reporter)
-          results_for_descendants = children.map {|child| child.run(reporter)}
-          result_for_this_group && (children.empty? ? true : results_for_descendants)
+          run_examples(example_group_instance, reporter) && 
+            children.map {|child| child.run(reporter)}.all?
         ensure
           eval_after_alls(example_group_instance)
         end

data/lib/rspec/core/formatters/base_text_formatter.rb

@@ -38,12 +38,10 @@ module RSpec
         def dump_summary
           failure_count = failed_examples.size
           pending_count = pending_examples.size
-          
 
-            output.puts "\nFinished in #{format_seconds(duration)} seconds\n"
+          output.puts "\nFinished in #{format_seconds(duration)} seconds\n"
 
-          summary = "#{example_count} example#{'s' unless example_count == 1}, #{failure_count} failures"
-          summary << ", #{pending_count} pending" if pending_count > 0  
+          summary = summary_line(example_count, failure_count, pending_count)
 
           if failure_count == 0
             if pending_count > 0
@@ -68,6 +66,17 @@ module RSpec
           output.flush
         end
 
+        def summary_line(example_count, failure_count, pending_count)
+          summary = pluralize(example_count, "example")
+          summary << ", " << pluralize(failure_count, "failure")
+          summary << ", #{pending_count} pending" if pending_count > 0  
+          summary
+        end
+
+        def pluralize(count, string)
+          "#{count} #{string}#{'s' unless count == 1}"
+        end
+
         def format_caller(caller_info)
           caller_info.to_s.split(':in `block').first
         end

data/lib/rspec/core/hooks.rb

@@ -1,49 +1,82 @@
 module RSpec
   module Core
     module Hooks
-      def before_blocks
-        @before_blocks ||= { :all => [], :each => [] }
-      end
+      class Hook
+        attr_reader :options
+
+        def initialize(options, block)
+          @options = options
+          @block = block
+        end
+
+        def options_apply?(group)
+          !group || group.all_apply?(options)
+        end
+
+        def call
+          @block.call
+        end
 
-      def after_blocks
-        @after_blocks  ||= { :all => [], :each => [] }
+        def to_proc
+          @block
+        end
       end
 
-      def around_blocks
-        @around_blocks ||= { :each => [] }
+      def hooks
+        @hooks ||= { 
+          :around => { :each => [] },
+          :before => { :each => [], :all => [], :suite => [] }, 
+          :after => { :each => [], :all => [], :suite => [] } 
+        }
       end
 
-      def before_eachs
-        before_blocks[:each]
+      def before(scope=:each, options={}, &block)
+        hooks[:before][scope] << Hook.new(options, block)
       end
 
-      def before_alls
-        before_blocks[:all]
+      def after(scope=:each, options={}, &block)
+        hooks[:after][scope] << Hook.new(options, block)
       end
 
-      def before(type=:each, &block)
-        before_blocks[type] << block
+      def around(scope=:each, &block)
+        RSpec::deprecate("around", "before and after")
+        hooks[:around][scope] << block
       end
 
-      def after_eachs
-        after_blocks[:each]
+      # Runs all of the blocks stored with the hook in the context of the
+      # example. If no example is provided, just calls the hook directly.
+      def run_hook(hook, scope, example=nil, options={})
+        if options[:reverse]
+          hooks[hook][scope].reverse.each &run_hook_in(example)
+        else
+          hooks[hook][scope].each &run_hook_in(example)
+        end
       end
 
-      def after_alls
-        after_blocks[:all]
+      # Just like run_hook, except it removes the blocks as it evalutes them,
+      # ensuring that they will only be run once.
+      def run_hook!(hook, scope, example, options={})
+        until hooks[hook][scope].empty?
+          if options[:reverse] 
+            example.instance_eval &hooks[hook][scope].shift
+          else
+            example.instance_eval &hooks[hook][scope].pop
+          end
+        end
       end
 
-      def after(type=:each, &block)
-        after_blocks[type] << block
+      def run_hook_filtered(hook, scope, group, example)
+        find_hook(hook, scope, group).each &run_hook_in(example)
       end
 
-      def around_eachs
-        around_blocks[:each]
+      def find_hook(hook, scope, group)
+        hooks[hook][scope].select {|hook| hook.options_apply?(group)}
       end
 
-      def around(type=:each, &block)
-        RSpec::deprecate("around", "before and after")
-        around_blocks[type] << block
+    private
+
+      def run_hook_in(example)
+        lambda {|hook| example ? example.instance_eval(&hook) : hook.call}
       end
     end
   end

data/lib/rspec/core/metadata.rb

@@ -139,7 +139,7 @@ EOM
       end
 
       def described_class_from(args)
-        if args.first.is_a?(String)
+        if args.first.is_a?(String) || args.first.is_a?(Symbol)
           superclass_metadata[:example_group][:describes]
         else
           args.first

data/lib/rspec/core/pending.rb

@@ -2,12 +2,12 @@ module RSpec
   module Core
     module Pending
       def pending(message = 'No reason given')
-        running_example.metadata[:pending] = true
-        running_example.metadata[:execution_result][:pending_message] = message
+        example.metadata[:pending] = true
+        example.metadata[:execution_result][:pending_message] = message
         if block_given?
           begin
             result = yield
-            running_example.metadata[:pending] = false
+            example.metadata[:pending] = false
           rescue Exception => e
           end
           raise RSpec::Core::PendingExampleFixedError.new if result

data/lib/rspec/core/rake_task.rb

@@ -35,16 +35,20 @@ module RSpec
       # Use rcov for code coverage? defaults to false
       attr_accessor :rcov
 
+      # Path to rcov.  You can set this to 'bundle exec rcov' if you bundle rcov.
+      attr_accessor :rcov_path
+
       # The options to pass to rcov.  Defaults to blank
       attr_accessor :rcov_opts
 
       def initialize(*args)
         @name = args.shift || :spec
-        @pattern, @rcov_opts, @ruby_opts = nil, nil, nil
+        @pattern, @rcov_path, @rcov_opts, @ruby_opts = nil, nil, nil, nil
         @warning, @rcov = false, false
         @fail_on_error = true
 
         yield self if block_given?
+        @rcov_path ||= 'rcov'
         @pattern ||= './spec/**/*_spec.rb'
         define
       end
@@ -58,18 +62,30 @@ module RSpec
             if files_to_run.empty?
               puts "No examples matching #{pattern} could be found"
             else
-              cmd_parts = [rcov ? 'rcov' : RUBY]
-              cmd_parts += rcov ? [rcov_opts] : [ruby_opts]
-              cmd_parts << '-Ilib'
-              cmd_parts << '-Ispec'
+              cmd_parts = [ '-Ilib', '-Ispec' ]
               cmd_parts << "-w" if warning
-              cmd_parts += files_to_run.collect { |fn| %["#{fn}"] }
-              cmd = cmd_parts.join(" ")
-              puts cmd if verbose
-              unless system(cmd)
-                STDERR.puts failure_message if failure_message
-                raise("Command #{cmd} failed") if fail_on_error
+
+              if rcov
+                command_to_run = rcov_command(cmd_parts)
+                command_to_run.inspect if verbose
+
+                unless system(command_to_run)
+                  STDERR.puts failure_message if failure_message
+                  raise("#{command_to_run} failed") if fail_on_error
+                end
+              else
+                cmd_parts.concat(files_to_run)
+                puts cmd.inspect if verbose
+
+                require 'rspec/core'
+                RSpec::Core::Runner.disable_at_exit_hook!
+
+                unless RSpec::Core::Runner.run(cmd_parts, $stderr, $stdout)
+                  STDERR.puts failure_message if failure_message
+                  raise("RSpec::Core::Runner.run with args #{cmd_parts.inspect} failed") if fail_on_error
+                end
               end
+
             end
           end
         end
@@ -81,6 +97,27 @@ module RSpec
         FileList[ pattern ].to_a
       end
 
+      private
+
+      def rcov_command(cmd_parts)
+        cmd_parts.unshift runner_options
+        cmd_parts.unshift runner
+        cmd_parts.unshift bundler
+        cmd_parts += files_to_run.map { |fn| %["#{fn}"] }
+        cmd_parts.join(" ")
+      end
+
+      def runner
+        rcov ? rcov_path : RUBY
+      end
+
+      def runner_options
+        rcov ? [rcov_opts] : [ruby_opts]
+      end
+
+      def bundler
+        File.exist?("./Gemfile") ? "bundle exec " : ""
+      end
     end
 
   end

data/lib/rspec/core/runner.rb

@@ -4,12 +4,20 @@ module RSpec
   module Core
     class Runner
 
+      def self.at_exit_hook_disabled?
+        @no_at_exit_hook ||= false
+      end
+
+      def self.disable_at_exit_hook!
+        @no_at_exit_hook = true
+      end
+
       def self.installed_at_exit?
         @installed_at_exit ||= false
       end
 
       def self.autorun
-        return if installed_at_exit? || running_in_drb?
+        return if at_exit_hook_disabled? || installed_at_exit? || running_in_drb?
         @installed_at_exit = true
         at_exit { run(ARGV, $stderr, $stdout) ? exit(0) : exit(1) }
       end
@@ -20,19 +28,22 @@ module RSpec
       end
 
       def self.run(args, err, out)
-        if args.any? {|a| %w[--drb -X].include? a}
-          run_over_drb(args, err, out) || run_in_process(args, err, out)
+        options = ConfigurationOptions.new(args)
+        options.parse_options
+
+        if options.options[:drb]
+          run_over_drb(options, err, out) || run_in_process(options, err, out)
         else
-          run_in_process(args, err, out)
+          run_in_process(options, err, out)
         end
       end
 
-      def self.run_over_drb(args, err, out)
-        DRbCommandLine.new(args).run(err, out)
+      def self.run_over_drb(options, err, out)
+        DRbCommandLine.new(options).run(err, out)
       end
 
-      def self.run_in_process(args, err, out)
-        CommandLine.new(args).run(err, out)
+      def self.run_in_process(options, err, out)
+        CommandLine.new(options).run(err, out)
       end
 
     end

data/lib/rspec/core/subject.rb

@@ -80,12 +80,12 @@ module RSpec
       end
 
       def attribute_of_subject
-        original_subject.send(running_example.description) if using_attribute?
+        original_subject.send(example.description) if using_attribute?
       end
 
       def using_attribute?
-        running_example.in_block? &&
-        running_example.metadata[:attribute_of_subject]
+        example.in_block? &&
+        example.metadata[:attribute_of_subject]
       end
 
     end

data/lib/rspec/core/world.rb

@@ -67,15 +67,11 @@ module RSpec
           end
         end      
       end
-      
-      def run_hook(hook, scope, group, example)
-        find_hook(hook, scope, group).each { |blk| example.instance_eval(&blk) }
-      end
+
+      include RSpec::Core::Hooks
 
       def find_hook(hook, scope, group)
-        RSpec.configuration.hooks[hook][scope].select do |filters, block|
-          group.all_apply?(filters)
-        end.map { |filters, block| block }
+        RSpec.configuration.find_hook(hook, scope, group)
       end
 
     private