rspec-core 3.0.0.beta1 → 3.0.0.beta2

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

@@ -4,8 +4,9 @@ require 'json'
 module RSpec
   module Core
     module Formatters
-
       class JsonFormatter < BaseFormatter
+        Formatters.register self, :message, :dump_summary, :stop, :close,
+                                  :dump_profile
 
         attr_reader :output_hash
 
@@ -14,32 +15,23 @@ module RSpec
           @output_hash = {}
         end
 
-        def message(message)
-          (@output_hash[:messages] ||= []) << message
+        def message(notification)
+          (@output_hash[:messages] ||= []) << notification.message
         end
 
-        def dump_summary(duration, example_count, failure_count, pending_count)
-          super(duration, example_count, failure_count, pending_count)
+        def dump_summary(summary)
           @output_hash[:summary] = {
-            :duration => duration,
-            :example_count => example_count,
-            :failure_count => failure_count,
-            :pending_count => pending_count
+            :duration => summary.duration,
+            :example_count => summary.example_count,
+            :failure_count => summary.failure_count,
+            :pending_count => summary.pending_count
           }
-          @output_hash[:summary_line] = summary_line(example_count, failure_count, pending_count)
-
-          dump_profile unless mute_profile_output?(failure_count)
-        end
+          @output_hash[:summary_line] = summary.summary_line
 
-        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
+          dump_profile unless mute_profile_output?(summary.failure_count)
         end
 
-        def stop
-          super
+        def stop(notification)
           @output_hash[:examples] = examples.map do |example|
             format_example(example).tap do |hash|
               if e=example.exception
@@ -53,7 +45,7 @@ module RSpec
           end
         end
 
-        def close
+        def close(notification)
           output.write @output_hash.to_json
           output.close if IO === output && output != $stdout
         end
@@ -64,6 +56,7 @@ module RSpec
           dump_profile_slowest_example_groups
         end
 
+        # @api private
         def dump_profile_slowest_examples
           @output_hash[:profile] = {}
           sorted_examples = slowest_examples
@@ -76,6 +69,7 @@ module RSpec
           @output_hash[:profile][:total] = sorted_examples[:total]
         end
 
+        # @api private
         def dump_profile_slowest_example_groups
           @output_hash[:profile] ||= {}
           @output_hash[:profile][:groups] = slowest_groups.map do |loc, hash|
@@ -84,13 +78,15 @@ module RSpec
         end
 
       private
+
         def format_example(example)
           {
             :description => example.description,
             :full_description => example.full_description,
             :status => example.execution_result[:status],
             :file_path => example.metadata[:file_path],
-            :line_number  => example.metadata[:line_number]
+            :line_number  => example.metadata[:line_number],
+            :run_time => example.execution_result[:run_time]
           }
         end
       end

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

@@ -0,0 +1,227 @@
+require 'rspec/core/formatters/helpers'
+require 'stringio'
+
+module RSpec
+  module Core
+    module Formatters
+
+      # The `LegacyFormatter` is used to wrap older RSpec 2.x style formatters
+      # for the new 3.x implementation. It takes care of registering all the
+      # old notifications and translating them to the older formatter.
+      #
+      # @see RSpec::Core::Formatters::BaseFormatter
+      class LegacyFormatter
+        NOTIFICATIONS = %W[start message example_group_started example_group_finished example_started
+                           example_passed example_failed example_pending start_dump dump_pending
+                           dump_failures dump_summary seed close stop deprecation deprecation_summary]
+
+        module LegacyInterface
+
+          def start(count)
+            super Notifications::CountNotification.new(count)
+          end
+
+          def example_group_started(group)
+            super Notifications::GroupNotification.new(group) if defined?(super)
+          end
+
+          def example_group_finished(group)
+            super Notifications::GroupNotification.new(group) if defined?(super)
+          end
+
+          def example_started(example)
+            super Notifications::ExampleNotification.new(example) if defined?(super)
+          end
+
+          def example_passed(example)
+            super Notifications::ExampleNotification.new(example) if defined?(super)
+          end
+
+          def example_pending(example)
+            super Notifications::ExampleNotification.new(example) if defined?(super)
+          end
+
+          def example_failed(example)
+            super Notifications::ExampleNotification.new(example) if defined?(super)
+          end
+
+          def message(message)
+            super Notifications::MessageNotification.new(message) if defined?(super)
+          end
+
+          attr_reader :duration, :example_count, :failure_count, :pending_count
+          def dump_summary(duration, examples, failures, pending)
+            @duration      = duration
+            @example_count = examples
+            @failure_count = failures
+            @pending_count = pending
+            super Notifications::SummaryNotification.new(duration, examples, failures, pending) if defined?(super)
+          end
+
+          def seed(seed)
+            super Notifications::SeedNotification.new(seed, true) if defined?(super)
+          end
+
+
+          def start_dump
+            super(Notifications::NullNotification) if defined?(super)
+          end
+
+          def dump_failures
+            super(Notifications::NullNotification) if defined?(super)
+          end
+
+          def dump_pending
+            super(Notifications::NullNotification) if defined?(super)
+          end
+
+          def dump_profile
+            super(Notifications::NullNotification) if defined?(super)
+          end
+
+          def close
+            super(Notifications::NullNotification) if defined?(super)
+          end
+
+          def stop
+            super(Notifications::NullNotification) if defined?(super)
+          end
+        end
+
+        # @api private
+        attr_reader :formatter
+
+        # @api public
+        #
+        # @param formatter
+        def initialize(formatter_class, *args)
+          if formatter_class.ancestors.include?(BaseFormatter)
+            formatter_class.class_eval do
+              include LegacyInterface
+            end
+          end
+          @formatter = formatter_class.new(*args)
+        end
+
+        # @api public
+        #
+        # This method is invoked during the setup phase to register
+        # a formatters with the reporter
+        #
+        def notifications
+          @notifications ||= NOTIFICATIONS.select { |m| @formatter.respond_to? m }
+        end
+
+        # @api public
+        #
+        # @param example_count
+        def start(notification)
+          @formatter.start notification.count
+        end
+
+        # @api public
+        #
+        # @param example_group
+        def example_group_started(notification)
+          @formatter.example_group_started notification.group
+        end
+
+        # @api public
+        #
+        # @param example_group
+        def example_group_finished(notification)
+          @formatter.example_group_finished notification.group
+        end
+
+        # @api public
+        #
+        # @param example
+        def example_started(notification)
+          @formatter.example_started notification.example
+        end
+
+        # @api public
+        #
+        # @param example
+        def example_passed(notification)
+          @formatter.example_passed notification.example
+        end
+
+        # @api public
+        #
+        # @param example
+        def example_pending(notification)
+          @formatter.example_pending notification.example
+        end
+
+        # @api public
+        #
+        # @param example
+        def example_failed(notification)
+          @formatter.example_failed notification.example
+        end
+
+        # @api public
+        #
+        # @param message
+        def message(notification)
+          @formatter.message notification.message
+        end
+
+        # @api public
+        #
+        def stop(notification)
+          @formatter.stop
+        end
+
+        # @api public
+        #
+        def start_dump(notification)
+          @formatter.start_dump
+        end
+
+        # @api public
+        #
+        def dump_failures(notification)
+          @formatter.dump_failures
+        end
+
+        # @api public
+        #
+        # @param duration
+        # @param example_count
+        # @param failure_count
+        # @param pending_count
+        def dump_summary(summary)
+          @formatter.dump_summary summary.duration, summary.example_count, summary.failure_count, summary.pending_count
+        end
+
+        # @api public
+        #
+        def dump_pending(notification)
+          @formatter.dump_pending
+        end
+
+        # @api public
+        #
+        def dump_profile(notification)
+          @formatter.dump_profile
+        end
+
+        # @api public
+        #
+        # @param seed
+        def seed(notification)
+          @formatter.seed notification.seed
+        end
+
+        # @api public
+        #
+        def close(notification)
+          @formatter.close
+        end
+
+      end
+    end
+  end
+end

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

@@ -2,31 +2,28 @@ require 'rspec/core/formatters/base_text_formatter'
 module RSpec
   module Core
     module Formatters
-
       class ProgressFormatter < BaseTextFormatter
+        Formatters.register self, :example_passed, :example_pending, :example_failed, :start_dump
 
-        def example_passed(example)
-          super(example)
+        def example_passed(notification)
           output.print success_color('.')
         end
 
-        def example_pending(example)
-          super(example)
+        def example_pending(notification)
+          super
           output.print pending_color('*')
         end
 
-        def example_failed(example)
-          super(example)
+        def example_failed(notification)
+          super
           output.print failure_color('F')
         end
 
-        def start_dump
-          super()
+        def start_dump(notification)
           output.puts
         end
 
       end
-
     end
   end
 end

data/lib/rspec/core/hooks.rb

@@ -1,167 +1,6 @@
 module RSpec
   module Core
     module Hooks
-      class Hook
-        attr_reader :block, :options
-
-        def initialize(block, options)
-          @block = block
-          @options = options
-        end
-
-        def options_apply?(example_or_group)
-          example_or_group.all_apply?(options)
-        end
-      end
-
-      class BeforeHook < Hook
-        def run(example)
-          example.instance_exec(example, &block)
-        end
-
-        def display_name
-          "before hook"
-        end
-      end
-
-      class AfterHook < Hook
-        def run(example)
-          example.instance_exec_with_rescue("in an after hook", &block)
-        end
-
-        def display_name
-          "after hook"
-        end
-      end
-
-      class AfterAllHook < Hook
-        def run(example)
-          example.instance_exec(example, &block)
-        rescue Exception => e
-          # TODO: come up with a better solution for this.
-          RSpec.configuration.reporter.message <<-EOS
-
-An error occurred in an after(:all) hook.
-  #{e.class}: #{e.message}
-  occurred at #{e.backtrace.first}
-
-EOS
-        end
-
-        def display_name
-          "after(:all) hook"
-        end
-      end
-
-      class AroundHook < Hook
-        def display_name
-          "around hook"
-        end
-      end
-
-      class BaseHookCollection
-        Array.public_instance_methods(false).each do |name|
-          define_method(name) { |*a, &b| hooks.__send__(name, *a, &b) }
-        end
-
-        attr_reader :hooks
-        protected   :hooks
-
-        alias append push
-        alias prepend unshift
-
-        def initialize(hooks=[])
-          @hooks = hooks
-        end
-      end
-
-      class HookCollection < BaseHookCollection
-        def for(example_or_group)
-          self.class.
-            new(hooks.select {|hook| hook.options_apply?(example_or_group)}).
-            with(example_or_group)
-        end
-
-        def with(example)
-          @example = example
-          self
-        end
-
-        def run
-          hooks.each {|h| h.run(@example)}
-        end
-      end
-
-      class AroundHookCollection < BaseHookCollection
-        def for(example, initial_procsy=nil)
-          self.class.new(hooks.select {|hook| hook.options_apply?(example)}).
-            with(example, initial_procsy)
-        end
-
-        def with(example, initial_procsy)
-          @example = example
-          @initial_procsy = initial_procsy
-          self
-        end
-
-        def run
-          hooks.reduce(@initial_procsy) do |procsy, around_hook|
-            procsy.wrap do
-              @example.instance_exec(procsy, &around_hook.block)
-            end
-          end.call
-        end
-      end
-
-      class GroupHookCollection < BaseHookCollection
-        def for(group)
-          @group = group
-          self
-        end
-
-        def run
-          hooks.shift.run(@group) until hooks.empty?
-        end
-      end
-
-      class HookCollections
-        def initialize(data)
-          @data = data
-        end
-
-        def [](key)
-          @data[key]
-        end
-
-        def register_globals(host, globals)
-          process(host, globals, :before, :each)
-          process(host, globals, :after,  :each)
-          process(host, globals, :around, :each)
-
-          process(host, globals, :before, :all)
-          process(host, globals, :after,  :all)
-        end
-
-        private
-
-        def process(host, globals, position, scope)
-          globals[position][scope].each do |hook|
-            next unless scope == :each || hook.options_apply?(host)
-            next if host.parent_groups.any? {|a| a.hooks[position][scope].include?(hook)}
-            self[position][scope] << hook
-          end
-        end
-      end
-
-      # @private
-      def hooks
-        @hooks ||= HookCollections.new(
-          :around => { :each => AroundHookCollection.new },
-          :before => { :each => HookCollection.new, :all => HookCollection.new, :suite => HookCollection.new },
-          :after =>  { :each => HookCollection.new, :all => HookCollection.new, :suite => HookCollection.new }
-        )
-      end
-
       # @api public
       # @overload before(&block)
       # @overload before(scope, &block)
@@ -329,7 +168,7 @@ EOS
       #       end
       #     end
       def before(*args, &block)
-        register_hook :append, :before, *args, &block
+        hooks.register :append, :before, *args, &block
       end
 
       alias_method :append_before, :before
@@ -339,7 +178,7 @@ EOS
       #
       # See #before for scoping semantics.
       def prepend_before(*args, &block)
-        register_hook :prepend, :before, *args, &block
+        hooks.register :prepend, :before, *args, &block
       end
 
       # @api public
@@ -391,7 +230,7 @@ EOS
       # Similarly, if more than one `after` is declared within any one scope,
       # they are run in reverse order of that in which they are declared.
       def after(*args, &block)
-        register_hook :prepend, :after, *args, &block
+        hooks.register :prepend, :after, *args, &block
       end
 
       alias_method :prepend_after, :after
@@ -401,7 +240,7 @@ EOS
       #
       # See #after for scoping semantics.
       def append_after(*args, &block)
-        register_hook :append, :after, *args, &block
+        hooks.register :append, :after, *args, &block
       end
 
       # @api public
@@ -449,85 +288,279 @@ EOS
       #     around(:each) {|ex| FakeFS(&ex)}
       #
       def around(*args, &block)
-        register_hook :prepend, :around, *args, &block
+        hooks.register :prepend, :around, *args, &block
+      end
+
+      # @api private
+      # Holds the various registered hooks.
+      def hooks
+        @hooks ||= HookCollections.new(self,
+          :around => { :each => AroundHookCollection.new },
+          :before => { :each => HookCollection.new, :all => HookCollection.new, :suite => HookCollection.new },
+          :after =>  { :each => HookCollection.new, :all => HookCollection.new, :suite => HookCollection.new }
+        )
       end
 
+    private
+
       # @private
-      #
-      # 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_or_group=ExampleGroup.new, initial_procsy=nil)
-        return if RSpec.configuration.dry_run?
+      class Hook
+        attr_reader :block, :options
 
-        find_hook(hook, scope, example_or_group, initial_procsy).run
+        def initialize(block, options)
+          @block = block
+          @options = options
+        end
+
+        def options_apply?(example_or_group)
+          example_or_group.all_apply?(options)
+        end
       end
 
       # @private
-      def around_each_hooks_for(example, initial_procsy=nil)
-        AroundHookCollection.new(FlatMap.flat_map(parent_groups) {|a| a.hooks[:around][:each]}).for(example, initial_procsy)
+      class BeforeHook < Hook
+        def run(example)
+          example.instance_exec(example, &block)
+        end
+
+        def display_name
+          "before hook"
+        end
       end
 
-    private
+      # @private
+      class AfterHook < Hook
+        def run(example)
+          example.instance_exec_with_rescue("in an after hook", &block)
+        end
 
-      SCOPES = [:each, :all, :suite]
+        def display_name
+          "after hook"
+        end
+      end
 
-      HOOK_TYPES = {
-        :before => Hash.new { BeforeHook },
-        :after  => Hash.new { AfterHook  },
-        :around => Hash.new { AroundHook }
-      }
+      # @private
+      class AfterAllHook < Hook
+        def run(example)
+          example.instance_exec(example, &block)
+        rescue Exception => e
+          # TODO: come up with a better solution for this.
+          RSpec.configuration.reporter.message <<-EOS
 
-      HOOK_TYPES[:after][:all] = AfterAllHook
+An error occurred in an after(:all) hook.
+  #{e.class}: #{e.message}
+  occurred at #{e.backtrace.first}
 
-      def before_all_hooks_for(group)
-        GroupHookCollection.new(hooks[:before][:all]).for(group)
-      end
+EOS
+        end
 
-      def after_all_hooks_for(group)
-        GroupHookCollection.new(hooks[:after][:all]).for(group)
+        def display_name
+          "after(:all) hook"
+        end
       end
 
-      def before_each_hooks_for(example)
-        HookCollection.new(FlatMap.flat_map(parent_groups.reverse) {|a| a.hooks[:before][:each]}).for(example)
+      # @private
+      class AroundHook < Hook
+        def display_name
+          "around hook"
+        end
       end
 
-      def after_each_hooks_for(example)
-        HookCollection.new(FlatMap.flat_map(parent_groups) {|a| a.hooks[:after][:each]}).for(example)
+      # @private
+      class BaseHookCollection
+        Array.public_instance_methods(false).each do |name|
+          define_method(name) { |*a, &b| hooks.__send__(name, *a, &b) }
+        end
+
+        attr_reader :hooks
+        protected   :hooks
+
+        alias append push
+        alias prepend unshift
+
+        def initialize(hooks=[])
+          @hooks = hooks
+        end
       end
 
-      def register_hook prepend_or_append, hook, *args, &block
-        scope, options = scope_and_options_from(*args)
-        hooks[hook][scope].send(prepend_or_append, HOOK_TYPES[hook][scope].new(block, options))
+      # @private
+      class HookCollection < BaseHookCollection
+        def for(example_or_group)
+          self.class.
+            new(hooks.select {|hook| hook.options_apply?(example_or_group)}).
+            with(example_or_group)
+        end
+
+        def with(example)
+          @example = example
+          self
+        end
+
+        def run
+          hooks.each {|h| h.run(@example)}
+        end
       end
 
-      def find_hook(hook, scope, example_or_group, initial_procsy)
-        case [hook, scope]
-        when [:before, :all]
-          before_all_hooks_for(example_or_group)
-        when [:after, :all]
-          after_all_hooks_for(example_or_group)
-        when [:around, :each]
-          around_each_hooks_for(example_or_group, initial_procsy)
-        when [:before, :each]
-          before_each_hooks_for(example_or_group)
-        when [:after, :each]
-          after_each_hooks_for(example_or_group)
-        when [:before, :suite], [:after, :suite]
-          hooks[hook][:suite].with(example_or_group)
+      # @private
+      class AroundHookCollection < BaseHookCollection
+        def for(example, initial_procsy=nil)
+          self.class.new(hooks.select {|hook| hook.options_apply?(example)}).
+            with(example, initial_procsy)
+        end
+
+        def with(example, initial_procsy)
+          @example = example
+          @initial_procsy = initial_procsy
+          self
+        end
+
+        def run
+          hooks.inject(@initial_procsy) do |procsy, around_hook|
+            procsy.wrap do
+              @example.instance_exec(procsy, &around_hook.block)
+            end
+          end.call
         end
       end
 
-      def scope_and_options_from(*args)
-        return extract_scope_from(args), Metadata.build_hash_from(args)
+      # @private
+      class GroupHookCollection < BaseHookCollection
+        def for(group)
+          @group = group
+          self
+        end
+
+        def run
+          hooks.shift.run(@group) until hooks.empty?
+        end
       end
 
-      def extract_scope_from(args)
-        if SCOPES.include?(args.first)
-          args.shift
-        elsif args.any? { |a| a.is_a?(Symbol) }
-          raise ArgumentError.new("You must explicitly give a scope (:each, :all, or :suite) when using symbols as metadata for a hook.")
-        else
-          :each
+      # @private
+      class HookCollections
+        def initialize(owner, data)
+          @owner = owner
+          @data  = data
+        end
+
+        def [](key)
+          @data[key]
+        end
+
+        def register_globals(host, globals)
+          process(host, globals, :before, :each)
+          process(host, globals, :after,  :each)
+          process(host, globals, :around, :each)
+
+          process(host, globals, :before, :all)
+          process(host, globals, :after,  :all)
+        end
+
+        def around_each_hooks_for(example, initial_procsy=nil)
+          AroundHookCollection.new(FlatMap.flat_map(@owner.parent_groups) do |a|
+            a.hooks[:around][:each]
+          end).for(example, initial_procsy)
+        end
+
+        def register(prepend_or_append, hook, *args, &block)
+          scope, options = scope_and_options_from(*args)
+          self[hook][scope].__send__(prepend_or_append, HOOK_TYPES[hook][scope].new(block, options))
+        end
+
+        # @private
+        #
+        # 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, scope, example_or_group=ExampleGroup.new, initial_procsy=nil)
+          return if RSpec.configuration.dry_run?
+
+          find_hook(hook, scope, example_or_group, initial_procsy).run
+        end
+
+        SCOPES = [:each, :all, :suite]
+
+        SCOPE_ALIASES = {
+          :example => :each,
+          :context => :all,
+        }
+
+        HOOK_TYPES = {
+          :before => Hash.new { BeforeHook },
+          :after  => Hash.new { AfterHook  },
+          :around => Hash.new { AroundHook }
+        }
+
+        HOOK_TYPES[:after][:all] = AfterAllHook
+
+      private
+
+        def process(host, globals, position, scope)
+          globals[position][scope].each do |hook|
+            next unless scope == :each || hook.options_apply?(host)
+            next if host.parent_groups.any? {|a| a.hooks[position][scope].include?(hook)}
+            self[position][scope] << hook
+          end
+        end
+
+        def scope_and_options_from(*args)
+          return extract_scope_from(args), Metadata.build_hash_from(args)
+        end
+
+        def extract_scope_from(args)
+          if known_scope?(args.first)
+            normalized_scope_for(args.shift)
+          elsif args.any? { |a| a.is_a?(Symbol) }
+            error_message = "You must explicitly give a scope (#{SCOPES.join(", ")}) or scope alias (#{SCOPE_ALIASES.keys.join(", ")}) when using symbols as metadata for a hook."
+            raise ArgumentError.new error_message
+          else
+            :each
+          end
+        end
+
+        # @api private
+        def known_scope?(scope)
+          SCOPES.include?(scope) || SCOPE_ALIASES.keys.include?(scope)
+        end
+
+        # @api private
+        def normalized_scope_for(scope)
+          SCOPE_ALIASES[scope] || scope
+        end
+
+        def find_hook(hook, scope, example_or_group, initial_procsy)
+          case [hook, scope]
+          when [:before, :all]
+            before_all_hooks_for(example_or_group)
+          when [:after, :all]
+            after_all_hooks_for(example_or_group)
+          when [:around, :each]
+            around_each_hooks_for(example_or_group, initial_procsy)
+          when [:before, :each]
+            before_each_hooks_for(example_or_group)
+          when [:after, :each]
+            after_each_hooks_for(example_or_group)
+          when [:before, :suite], [:after, :suite]
+            self[hook][:suite].with(example_or_group)
+          end
+        end
+
+        def before_all_hooks_for(group)
+          GroupHookCollection.new(self[:before][:all]).for(group)
+        end
+
+        def after_all_hooks_for(group)
+          GroupHookCollection.new(self[:after][:all]).for(group)
+        end
+
+        def before_each_hooks_for(example)
+          HookCollection.new(FlatMap.flat_map(@owner.parent_groups.reverse) do |a|
+            a.hooks[:before][:each]
+          end).for(example)
+        end
+
+        def after_each_hooks_for(example)
+          HookCollection.new(FlatMap.flat_map(@owner.parent_groups) do |a|
+            a.hooks[:after][:each]
+          end).for(example)
         end
       end
     end