rspec-core 3.0.0.beta1 → 3.0.0.beta2

data/lib/rspec/core/filter_manager.rb

@@ -102,34 +102,16 @@ module RSpec
 
         private
 
-        def without_conditional_filters
-          reject {|k,v| CONDITIONAL_FILTERS[k] == v}
-        end
-      end
-
-      module BackwardCompatibility
-        def merge(orig, opposite, *updates)
-          _warn_deprecated_keys(updates.last)
-          super
-        end
-
-        def reverse_merge(orig, opposite, *updates)
-          _warn_deprecated_keys(updates.last)
-          super
-        end
-
-        # Supports a use case that probably doesn't exist: overriding the
-        # if/unless procs.
-        def _warn_deprecated_keys(updates)
-          _warn_deprecated_key(:unless, updates) if updates.has_key?(:unless)
-          _warn_deprecated_key(:if, updates)     if updates.has_key?(:if)
-        end
-
-        # Emits a deprecation warning for keys that will not be supported in
-        # the future.
-        def _warn_deprecated_key(key, updates)
-          RSpec.deprecate("FilterManager#exclude(#{key.inspect} => #{updates[key].inspect})")
-          @exclusions[key] = updates.delete(key)
+        if RUBY_VERSION.to_f < 2.1
+          def without_conditional_filters
+            # On 1.8.7, Hash#reject returns a hash but Hash#select returns an array.
+            reject {|k,v| CONDITIONAL_FILTERS[k] == v}
+          end
+        else
+          def without_conditional_filters
+            # On ruby 2.1 #reject on a subclass of Hash emits warnings, but #select does not.
+            select {|k,v| CONDITIONAL_FILTERS[k] != v}
+          end
         end
       end
 
@@ -138,7 +120,6 @@ module RSpec
       def initialize
         @exclusions = ExclusionFilterHash.new
         @inclusions = InclusionFilterHash.new
-        extend(BackwardCompatibility)
       end
 
       def add_location(file_path, line_numbers)
@@ -147,8 +128,8 @@ module RSpec
         #   { "path/to/file.rb" => [37, 42] }
         locations = @inclusions.delete(:locations) || Hash.new {|h,k| h[k] = []}
         locations[File.expand_path(file_path)].push(*line_numbers)
-        @inclusions.replace(:locations => locations)
-        @exclusions.clear
+
+        replace_filters :locations => locations
       end
 
       def empty?
@@ -175,26 +156,36 @@ module RSpec
         @exclusions.empty? ? false : example.any_apply?(@exclusions)
       end
 
-      def include(*args)
-        unless_standalone(*args) { merge(@inclusions, @exclusions, *args) }
+      def include(*filters)
+        set_standalone_filter(*filters) || merge(@inclusions, @exclusions, *filters)
       end
 
-      def include!(*args)
-        unless_standalone(*args) { replace(@inclusions, @exclusions, *args) }
+      def include!(*filters)
+        set_standalone_filter(*filters) || replace(@inclusions, @exclusions, *filters)
       end
 
-      def include_with_low_priority(*args)
-        unless_standalone(*args) { reverse_merge(@inclusions, @exclusions, *args) }
+      def include_with_low_priority(*filters)
+        set_standalone_filter(*filters) || reverse_merge(@inclusions, @exclusions, *filters)
       end
 
       def include?(example)
         @inclusions.empty? ? true : example.any_apply?(@inclusions)
       end
 
-      private
+    private
 
-      def unless_standalone(*args)
-        is_standalone_filter?(args.last) ? @inclusions.replace(args.last) : yield unless already_set_standalone_filter?
+      def set_standalone_filter(*args)
+        if already_set_standalone_filter?
+          true
+        elsif is_standalone_filter?(args.last)
+          replace_filters(args.last)
+          true
+        end
+      end
+
+      def replace_filters(rule)
+        @inclusions.replace(rule)
+        @exclusions.clear
       end
 
       def merge(orig, opposite, *updates)

data/lib/rspec/core/formatters.rb

@@ -1,3 +1,5 @@
+require 'rspec/core/formatters/legacy_formatter'
+
 # ## Built-in Formatters
 #
 # * progress (default) - prints dots for passing examples, `F` for failures, `*` for pending
@@ -51,4 +53,139 @@
 # @see RSpec::Core::Formatters::BaseTextFormatter
 # @see RSpec::Core::Reporter
 module RSpec::Core::Formatters
+  autoload :DocumentationFormatter, 'rspec/core/formatters/documentation_formatter'
+  autoload :HtmlFormatter,          'rspec/core/formatters/html_formatter'
+  autoload :ProgressFormatter,      'rspec/core/formatters/progress_formatter'
+  autoload :JsonFormatter,          'rspec/core/formatters/json_formatter'
+
+  def self.register(formatter_class, *notifications)
+    Loader.formatters[formatter_class] = notifications
+  end
+
+  # @api private
+  #
+  # `RSpec::Core::Formatters::Loader` is an internal class for
+  # managing formatters used by a particular configuration. It is
+  # not expected to be used directly, but only through the configuration
+  # interface.
+  class Loader
+    # @api private
+    #
+    # Internal formatters are stored here when loaded
+    def self.formatters
+      @formatters ||= {}
+    end
+
+    # @api private
+    def initialize(reporter)
+      @formatters = []
+      @reporter = reporter
+    end
+    attr_reader :formatters, :reporter
+
+    # @api private
+    def setup_default(output_stream, deprecation_stream)
+      if @formatters.empty?
+        add 'progress', output_stream
+      end
+      unless @formatters.any? { |formatter| DeprecationFormatter === formatter }
+        add DeprecationFormatter, deprecation_stream, output_stream
+      end
+    end
+
+    # @api private
+    def add(formatter_to_use, *paths)
+      formatter_class = find_formatter(formatter_to_use)
+
+      args = paths.map { |p| String === p ? file_at(p) : p }
+
+      if !Loader.formatters[formatter_class].nil?
+        formatter = formatter_class.new(*args)
+        @reporter.register_listener formatter, *notifications_for(formatter_class)
+      else
+        formatter = LegacyFormatter.new(formatter_class, *args)
+        @reporter.register_listener formatter, *formatter.notifications
+      end
+
+      @formatters << formatter unless duplicate_formatter_exists?(formatter)
+      if formatter.is_a?(LegacyFormatter)
+        RSpec.warn_deprecation "The #{formatter_class} formatter uses the deprecated formatter interface.\n Formatter added at: #{::RSpec::CallerFilter.first_non_rspec_line}"
+      end
+
+      formatter
+    end
+
+  private
+
+    def find_formatter(formatter_to_use)
+      built_in_formatter(formatter_to_use) ||
+      custom_formatter(formatter_to_use)   ||
+      (raise ArgumentError, "Formatter '#{formatter_to_use}' unknown - maybe you meant 'documentation' or 'progress'?.")
+    end
+
+    def duplicate_formatter_exists?(new_formatter)
+      @formatters.any? do |formatter|
+        formatter.class === new_formatter && formatter.output == new_formatter.output
+      end
+    end
+
+    def built_in_formatter(key)
+      case key.to_s
+      when 'd', 'doc', 'documentation'
+        DocumentationFormatter
+      when 'h', 'html'
+        HtmlFormatter
+      when 'p', 'progress'
+        ProgressFormatter
+      when 'j', 'json'
+        JsonFormatter
+      end
+    end
+
+    def notifications_for(formatter_class)
+      formatter_class.ancestors.inject(Set.new) do |notifications, klass|
+        notifications + Loader.formatters.fetch(klass) { Set.new }
+      end
+    end
+
+    def custom_formatter(formatter_ref)
+      if Class === formatter_ref
+        formatter_ref
+      elsif string_const?(formatter_ref)
+        begin
+          formatter_ref.gsub(/^::/,'').split('::').inject(Object) { |const,string| const.const_get string }
+        rescue NameError
+          require( path_for(formatter_ref) ) ? retry : raise
+        end
+      end
+    end
+
+    def string_const?(str)
+      str.is_a?(String) && /\A[A-Z][a-zA-Z0-9_:]*\z/ =~ str
+    end
+
+    def path_for(const_ref)
+      underscore_with_fix_for_non_standard_rspec_naming(const_ref)
+    end
+
+    def underscore_with_fix_for_non_standard_rspec_naming(string)
+      underscore(string).sub(%r{(^|/)r_spec($|/)}, '\\1rspec\\2')
+    end
+
+    # activesupport/lib/active_support/inflector/methods.rb, line 48
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+
+    def file_at(path)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.new(path, 'w')
+    end
+  end
 end

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

@@ -5,16 +5,20 @@ module RSpec
   module Core
     module Formatters
       # RSpec's built-in formatters are all subclasses of RSpec::Core::Formatters::BaseTextFormatter,
-      # but the BaseTextFormatter documents all of the methods needed to be implemented by a formatter,
-      # as they are called from the reporter.
+      # but the BaseTextFormatter documents all of the notifications implemented as part of the standard
+      # interface. The reporter will issue these during a normal test suite run, but a formatter will
+      # only receive those notifications it has registered itself to receive.
       #
       # @see RSpec::Core::Formatters::BaseTextFormatter
       # @see RSpec::Core::Reporter
       class BaseFormatter
+
+        # all formatters inheriting from this formatter will receive these notifications
+        Formatters.register self, :start, :example_group_started, :example_started,
+                                  :example_pending, :example_failed, :close
         include Helpers
         attr_accessor :example_group
-        attr_reader :duration, :examples, :output
-        attr_reader :example_count, :pending_count, :failure_count
+        attr_reader :examples, :output
         attr_reader :failed_examples, :pending_examples
 
         # @api public
@@ -39,9 +43,9 @@ module RSpec
         # is {#example_group_started}.
         #
         # @param example_count
-        def start(example_count)
+        def start(notification)
           start_sync_output
-          @example_count = example_count
+          @example_count = notification.count
         end
 
         # @api public
@@ -54,17 +58,16 @@ module RSpec
         # {#example_pending}, or {#example_group_finished}.
         #
         # @param example_group
-        def example_group_started(example_group)
-          @example_group = example_group
+        def example_group_started(notification)
+          @example_group = notification.group
         end
 
+        # @method example_group_finished
         # @api public
         #
         # Invoked at the end of the execution of each example group.
         #
         # @param example_group subclass of `RSpec::Core::ExampleGroup`
-        def example_group_finished(example_group)
-        end
 
         # @api public
         #
@@ -72,24 +75,23 @@ module RSpec
         #
         # @param example instance of subclass of `RSpec::Core::ExampleGroup`
         # @return [Array]
-        def example_started(example)
-          examples << example
+        def example_started(notification)
+          examples << notification.example
         end
 
+        # @method example_passed
         # @api public
         #
         # Invoked when an example passes.
         #
         # @param example instance of subclass of `RSpec::Core::ExampleGroup`
-        def example_passed(example)
-        end
 
         # Invoked when an example is pending.
         #
         # @param example instance of subclass of `RSpec::Core::ExampleGroup`
         # @return [Array]
-        def example_pending(example)
-          @pending_examples << example
+        def example_pending(notification)
+          @pending_examples << notification.example
         end
 
         # @api public
@@ -98,26 +100,25 @@ module RSpec
         #
         # @param example instance of subclass of `RSpec::Core::ExampleGroup`
         # @return [Array]
-        def example_failed(example)
-          @failed_examples << example
+        def example_failed(notification)
+          @failed_examples << notification.example
         end
 
+        # @method message
         # @api public
         #
         # Used by the reporter to send messages to the output stream.
         #
         # @param [String] message
-        def message(message)
-        end
 
+        # @method stop
         # @api public
         #
         # Invoked after all examples have executed, before dumping post-run reports.
         #
         # @return [nil]
-        def stop
-        end
 
+        # @method start_dump
         # @api public
         #
         # This method is invoked after all of the examples have executed. The next method
@@ -125,17 +126,15 @@ module RSpec
         # (BaseTextFormatter then calls {#dump_failure} once for each failed example.)
         #
         # @return [nil]
-        def start_dump
-        end
 
+        # @method dump_failures
         # @api public
         #
         # Dumps detailed information about each example failure.
         #
         # @return [nil]
-        def dump_failures
-        end
 
+        # @method dump_summary
         # @api public
         #
         # This method is invoked after the dumping of examples and failures. Each parameter
@@ -145,40 +144,28 @@ module RSpec
         # @param example_count
         # @param failure_count
         # @param pending_count
-        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
 
+        # @method dump_pending
         # @api public
         #
         # Outputs a report of pending examples.  This gets invoked
         # after the summary if option is set to do so.
         #
         # @return [nil]
-        def dump_pending
-        end
 
+        # @method dump_profile
         # @api public
         #
         # This methods is invoked form formatters to show slowest examples and example groups
         # when using `--profile COUNT` (default 10).
         #
         # @return [nil]
-        def dump_profile
-        end
-
-        # @private not intended for use outside RSpec.
-        def seed(number)
-        end
 
         # @api public
         #
         # Invoked at the very end, `close` allows the formatter to clean
         # up resources, e.g. open streams, etc.
-        def close
+        def close(notification)
           restore_sync_output
         end
 

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

@@ -11,11 +11,14 @@ module RSpec
       # @see RSpec::Core::Formatters::BaseFormatter
       # @see RSpec::Core::Reporter
       class BaseTextFormatter < BaseFormatter
-        def message(message)
-          output.puts message
+        Formatters.register self, :message, :dump_summary, :dump_failures,
+                                  :dump_profile, :dump_pending, :seed
+
+        def message(notification)
+          output.puts notification.message
         end
 
-        def dump_failures
+        def dump_failures(notification)
           return if failed_examples.empty?
           output.puts
           output.puts "Failures:"
@@ -33,20 +36,19 @@ module RSpec
         #
         # @param [String] string
         def colorise_summary(summary)
-          if failure_count > 0
-            color(summary, RSpec.configuration.failure_color)
-          elsif pending_count > 0
-            color(summary, RSpec.configuration.pending_color)
+          if summary.failure_count > 0
+            color(summary.summary_line, RSpec.configuration.failure_color)
+          elsif summary.pending_count > 0
+            color(summary.summary_line, RSpec.configuration.pending_color)
           else
-            color(summary, RSpec.configuration.success_color)
+            color(summary.summary_line, RSpec.configuration.success_color)
           end
         end
 
-        def dump_summary(duration, example_count, failure_count, pending_count)
-          super(duration, example_count, failure_count, pending_count)
-          dump_profile unless mute_profile_output?(failure_count)
-          output.puts "\nFinished in #{format_duration(duration)}\n"
-          output.puts colorise_summary(summary_line(example_count, failure_count, pending_count))
+        def dump_summary(summary)
+          dump_profile unless mute_profile_output?(summary.failure_count)
+          output.puts "\nFinished in #{format_duration(summary.duration)}\n"
+          output.puts colorise_summary(summary)
           dump_commands_to_rerun_failed_examples
         end
 
@@ -74,6 +76,7 @@ module RSpec
           dump_profile_slowest_example_groups
         end
 
+        # @api private
         def dump_profile_slowest_examples
           sorted_examples = slowest_examples
 
@@ -88,6 +91,7 @@ module RSpec
           end
         end
 
+        # @api private
         def dump_profile_slowest_example_groups
 
           sorted_groups = slowest_groups
@@ -103,18 +107,7 @@ module RSpec
           end
         end
 
-        # @api public
-        #
-        # Outputs summary with number of examples, failures and pending.
-        #
-        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 dump_pending
+        def dump_pending(notification)
           unless pending_examples.empty?
             output.puts
             output.puts "Pending:"
@@ -122,22 +115,18 @@ module RSpec
               output.puts pending_color("  #{pending_example.full_description}")
               output.puts detail_color("    # #{pending_example.execution_result[:pending_message]}")
               output.puts detail_color("    # #{format_caller(pending_example.location)}")
-              if pending_example.execution_result[:exception] \
-                && RSpec.configuration.show_failures_in_pending_blocks?
-                dump_failure_info(pending_example)
-                dump_backtrace(pending_example)
-              end
             end
           end
         end
 
-        def seed(number)
+        def seed(notification)
+          return unless notification.seed_used?
           output.puts
-          output.puts "Randomized with seed #{number}"
+          output.puts "Randomized with seed #{notification.seed}"
           output.puts
         end
 
-        def close
+        def close(notification)
           output.close if IO === output && output != $stdout
         end
 
@@ -251,8 +240,8 @@ module RSpec
           configuration.backtrace_formatter.backtrace_line(caller_info.to_s.split(':in `block').first)
         end
 
-        def dump_backtrace(example)
-          format_backtrace(example.execution_result[:exception].backtrace, example).each do |backtrace_info|
+        def dump_backtrace(example, key = :exception)
+          format_backtrace(example.execution_result[key].backtrace, example).each do |backtrace_info|
             output.puts detail_color("#{long_padding}# #{backtrace_info}")
           end
         end
@@ -271,8 +260,8 @@ module RSpec
           dump_failure_info(example)
         end
 
-        def dump_failure_info(example)
-          exception = example.execution_result[:exception]
+        def dump_failure_info(example, key = :exception)
+          exception = example.execution_result[key]
           exception_class_name = exception_class_name_for(exception)
           output.puts "#{long_padding}#{failure_color("Failure/Error:")} #{failure_color(read_failed_line(exception, example).strip)}"
           output.puts "#{long_padding}#{failure_color(exception_class_name)}:" unless exception_class_name =~ /RSpec/