rspec-core 2.0.0.beta.19 → 2.0.0.beta.20

data/lib/rspec/core/extensions.rb

@@ -0,0 +1,4 @@
+require 'rspec/core/extensions/object'
+require 'rspec/core/extensions/kernel'
+require 'rspec/core/extensions/instance_eval_with_args'
+require 'rspec/core/extensions/module_eval_with_args'

data/lib/rspec/core/extensions/instance_eval_with_args.rb

@@ -0,0 +1,39 @@
+module RSpec
+  module Core
+    module Extensions
+      module InstanceEvalWithArgs
+        # based on Bounded Spec InstanceExec (Mauricio Fernandez)
+        # http://eigenclass.org/hiki/bounded+space+instance_exec
+        # - uses singleton_class instead of global InstanceExecHelper module
+        # - this keeps it scoped to classes/modules that include this module
+        # - only necessary for ruby 1.8.6
+        def instance_eval_with_args(*args, &block)
+          return instance_exec(*args, &block) if respond_to?(:instance_exec)
+
+          # If there are no args and the block doesn't expect any, there's no
+          # need to fake instance_exec with our hack below.
+          # Notes:
+          #   * lambda { }.arity # => -1
+          #   * lambda { || }.arity # => 0
+          #   * lambda { |*a| }.arity # -1
+          return instance_eval(&block) if block.arity < 1 && args.size.zero?
+
+          singleton_class = (class << self; self; end)
+          begin
+            orig_critical, Thread.critical = Thread.critical, true
+            n = 0
+            n += 1 while respond_to?(method_name="__instance_exec#{n}")
+            singleton_class.module_eval{ define_method(method_name, &block) }
+          ensure
+            Thread.critical = orig_critical
+          end
+          begin
+            return send(method_name, *args)
+          ensure
+            singleton_class.module_eval{ remove_method(method_name) } rescue nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/core/extensions/module_eval_with_args.rb

@@ -0,0 +1,54 @@
+module RSpec
+  module Core
+    module Extensions
+      module ModuleEvalWithArgs
+        include InstanceEvalWithArgs
+
+        def module_eval_with_args(*args, &block)
+          # ruby > 1.8.6
+          return module_exec(*args, &block) if respond_to?(:module_exec)
+
+          # If there are no args and the block doesn't expect any, there's no
+          # need to fake module_exec with our hack below.
+          # Notes:
+          #   * lambda { }.arity # => -1
+          #   * lambda { || }.arity # => 0
+          #   * lambda { |*a| }.arity # -1
+          return module_eval(&block) if block.arity < 1 && args.size.zero?
+
+          instance_eval_with_args(*args, &block)
+
+          # The only difference between instance_eval and module_eval is static method defs.
+          #   * `def foo` in instance_eval defines a singleton method on the instance
+          #   * `def foo` in class/module_eval defines an instance method for the class/module
+          # Here we deal with this difference by defining instance methods on the
+          # class/module and removing the singleton definitions.
+          singleton_class = class << self; self; end
+          extract_static_instance_method_defs_from(block).each do |m_name, m_def|
+            define_method(m_name, &m_def)
+            singleton_class.send(:remove_method, m_name)
+          end
+        end
+
+        private
+
+        def extract_static_instance_method_defs_from(block)
+          klass = Class.new do
+            # swallow any missing class method errors;
+            # we only care to capture the raw method definitions here.
+            def self.method_missing(*a); end
+
+            # skip any dynamic method definitions
+            def self.define_method(*a); end
+
+            # run the block so our instance methods get defined
+            class_eval(&block)
+          end
+
+          instance = klass.new
+          klass.instance_methods(false).inject({}) { |h, m| h[m] = instance.method(m); h }
+        end
+      end
+    end
+  end
+end

data/lib/rspec/core/{object_extensions.rb → extensions/object.rb}

@@ -12,4 +12,6 @@ module RSpec
   end
 end
 
-include RSpec::Core::ObjectExtensions
+class Object
+  include RSpec::Core::ObjectExtensions
+end

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

@@ -5,47 +5,19 @@ module RSpec
       class BaseFormatter
         include Helpers
         attr_accessor :example_group
-        attr_reader :example_count, :duration, :examples, :output
+        attr_reader :duration, :examples, :output
+        attr_reader :example_count, :pending_count, :failure_count
+        attr_reader :failed_examples, :pending_examples
 
         def initialize(output)
           @output = output
-          @example_count = 0
+          @example_count = @pending_count = @failure_count = 0
           @examples = []
+          @failed_examples = []
+          @pending_examples = []
           @example_group = nil
         end
 
-        def pending_examples
-          @pending_examples ||= ::RSpec.world.find(examples, :execution_result => { :status => 'pending' })
-        end
-
-        def pending_count
-          pending_examples.size
-        end
-
-        def failed_examples
-          @failed_examples ||= ::RSpec.world.find(examples, :execution_result => { :status => 'failed' })
-        end
-
-        def failure_count
-          failed_examples.size
-        end
-
-        def report(count)
-          sync_output do
-            start(count)
-            begin
-              yield self
-              stop
-              start_dump
-              dump_summary(duration, example_count, failure_count, pending_count)
-              dump_pending
-              dump_failures
-            ensure
-              close
-            end
-          end
-        end
-
         # This method is invoked before any examples are run, right after
         # they have all been collected. This can be useful for special
         # formatters that need to provide progress on feedback (graphical ones)
@@ -53,8 +25,8 @@ module RSpec
         # This will only be invoked once, and the next one to be invoked
         # is #example_group_started
         def start(example_count)
+          start_sync_output
           @example_count = example_count
-          @start = Time.now
         end
 
         # This method is invoked at the beginning of the execution of each example group.
@@ -79,16 +51,17 @@ module RSpec
         end
 
         def example_pending(example)
+          @pending_examples << example
         end
 
         def example_failed(example)
+          @failed_examples << example
         end
 
         def message(message)
         end
 
         def stop
-          @duration = Time.now - @start
         end
 
         # This method is invoked after all of the examples have executed. The next method
@@ -102,6 +75,10 @@ module RSpec
 
         # This method is invoked after the dumping of examples and failures.
         def dump_summary(duration, example_count, failure_count, pending_count)
+          @duration = duration
+          @example_count = example_count
+          @failure_count = failure_count
+          @pending_count = pending_count
         end
 
         # This gets invoked after the summary if option is set to do so.
@@ -110,6 +87,7 @@ module RSpec
 
         # This method is invoked at the very end. Allows the formatter to clean up, like closing open streams.
         def close
+          restore_sync_output
         end
 
         def format_backtrace(backtrace, example)
@@ -150,13 +128,12 @@ module RSpec
           end
         end
 
-        def sync_output
-          begin
-            old_sync, output.sync = output.sync, true if output_supports_sync
-            yield
-          ensure
-            output.sync = old_sync if output_supports_sync and !output.closed?
-          end
+        def start_sync_output
+          @old_sync, output.sync = output.sync, true if output_supports_sync
+        end
+
+        def restore_sync_output
+          output.sync = @old_sync if output_supports_sync and !output.closed?
         end
 
         def output_supports_sync

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

@@ -9,26 +9,28 @@ module RSpec
         end
 
         def dump_failures
+          return if failed_examples.empty?
           output.puts
-          failed_examples.each_with_index do |failed_example, index|
-            exception = failed_example.execution_result[:exception_encountered]
-            padding = '    '
+          output.puts "Failures:"
+          failed_examples.each_with_index do |example, index|
+            output.puts if index > 0
+            exception = example.execution_result[:exception_encountered]
+            short_padding = '  '
+            padding = '     '
             if exception.is_a?(RSpec::Core::PendingExampleFixedError)
-              output.puts "#{index.next}) #{failed_example.full_description} FIXED"
-              output.puts "#{padding}Expected pending '#{failed_example.metadata[:execution_result][:pending_message]}' to fail. No Error was raised."
+              output.puts "#{short_padding}#{index.next}) #{example.full_description} FIXED"
+              output.puts "#{padding}Expected pending '#{example.metadata[:execution_result][:pending_message]}' to fail. No Error was raised."
             else
-              output.puts "#{index.next}) #{failed_example.full_description}"
-              output.puts "#{padding}Failure/Error: #{read_failed_line(exception, failed_example).strip}"
+              output.puts "#{short_padding}#{index.next}) #{example.full_description}"
+              output.puts "#{padding}Failure/Error: #{read_failed_line(exception, example).strip}"
               exception.message.split("\n").each do |line|
                 output.puts "#{padding}#{red(line)}"
               end
             end
 
-            format_backtrace(exception.backtrace, failed_example).each do |backtrace_info|
+            format_backtrace(exception.backtrace, example).each do |backtrace_info|
               output.puts grey("#{padding}# #{backtrace_info}")
             end
-
-            output.puts
           end
         end
 
@@ -45,6 +47,7 @@ module RSpec
         end
 
         def dump_summary(duration, example_count, failure_count, pending_count)
+          super(duration, example_count, failure_count, pending_count)
           output.puts "\nFinished in #{format_seconds(duration)} seconds\n"
 
           output.puts colorise_summary(summary_line(example_count, failure_count, pending_count))

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

@@ -10,7 +10,7 @@ module RSpec
         end
 
         def example_group_started(example_group)
-          super
+          super(example_group)
 
           example_group_chain.each_with_index do |nested_example_group, i|
             unless nested_example_group == @previous_nested_example_groups[i]
@@ -23,17 +23,17 @@ module RSpec
         end
 
         def example_passed(example)
-          super
+          super(example)
           output.puts passed_output(example)
         end
 
         def example_pending(example)
-          super
+          super(example)
           output.puts pending_output(example, example.execution_result[:pending_message])
         end
 
         def example_failed(example)
-          super
+          super(example)
           output.puts failure_output(example, example.execution_result[:exception_encountered])
         end
 

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

@@ -15,7 +15,7 @@ module RSpec
         end
 
         def initialize(output)
-          super
+          super(output)
           @example_group_number = 0
           @example_number = 0
           @header_red = nil
@@ -32,14 +32,14 @@ module RSpec
         end
 
         def start(example_count)
-          super
+          super(example_count)
           @output.puts html_header
           @output.puts report_header
           @output.flush
         end
 
         def example_group_started(example_group)
-          super
+          super(example_group)
           @example_group_red = false
           @example_group_number += 1
           unless example_group_number == 1
@@ -59,7 +59,7 @@ module RSpec
         end
 
         def example_started(example)
-          super
+          super(example)
           @example_number += 1
         end
 

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

@@ -5,22 +5,22 @@ module RSpec
       class ProgressFormatter < BaseTextFormatter
 
         def example_passed(example)
-          super
+          super(example)
           output.print green('.')
         end
 
         def example_pending(example)
-          super
+          super(example)
           output.print yellow('*')
         end
 
         def example_failed(example)
-          super
+          super(example)
           output.print red('F')
         end
 
         def start_dump
-          super
+          super()
           output.puts
         end
 

data/lib/rspec/core/rake_task.rb

@@ -67,7 +67,7 @@ module RSpec
               puts "No examples matching #{pattern} could be found"
             else
               puts spec_command.inspect if verbose
-              unless system(spec_command)
+              unless ruby("-S #{spec_command}")
                 STDERR.puts failure_message if failure_message
                 raise("#{spec_command} failed") if fail_on_error
               end

data/lib/rspec/core/reporter.rb

@@ -0,0 +1,65 @@
+module RSpec::Core
+  class Reporter
+    def initialize(*formatters)
+      @formatters = formatters
+      @failure_count = @pending_count = 0
+    end
+
+    def report(count)
+      start(count)
+      begin
+        yield self
+        stop
+        notify :start_dump
+        notify :dump_pending
+        notify :dump_failures
+        notify :dump_summary, @duration, @example_count, @failure_count, @pending_count
+      ensure
+        notify :close
+      end
+    end
+
+    def start(example_count)
+      @example_count = example_count
+      @start = Time.now
+      notify :start, example_count
+    end
+
+    def message(message)
+      notify :message, message
+    end
+
+    def example_group_started(group)
+      notify :example_group_started, group
+    end
+
+    def example_started(example)
+      notify :example_started, example
+    end
+
+    def example_passed(example)
+      notify :example_passed, example
+    end
+
+    def example_failed(example)
+      @failure_count += 1
+      notify :example_failed, example
+    end
+
+    def example_pending(example)
+      @pending_count += 1
+      notify :example_pending, example
+    end
+
+    def stop
+      @duration = Time.now - @start
+      notify :stop
+    end
+
+    def notify(method, *args, &block)
+      @formatters.each do |formatter|
+        formatter.send method, *args, &block
+      end
+    end
+  end
+end

data/lib/rspec/core/subject.rb

@@ -99,7 +99,7 @@ module RSpec
             example do
               self.class.class_eval do
                 define_method(:subject) do
-                  attribute.to_s.split('.').inject(super) do |target, method|
+                  attribute.to_s.split('.').inject(super()) do |target, method|
                     target.send(method)
                   end
                 end