rspec-core 2.99.0 → 3.0.0

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

@@ -1,5 +1,5 @@
-require 'rspec/core/formatters/base_formatter'
-require 'rspec/core/formatters/console_codes'
+RSpec::Support.require_rspec_core "formatters/base_formatter"
+RSpec::Support.require_rspec_core "formatters/console_codes"
 
 module RSpec
   module Core
@@ -11,319 +11,67 @@ module RSpec
       # @see RSpec::Core::Formatters::BaseFormatter
       # @see RSpec::Core::Reporter
       class BaseTextFormatter < BaseFormatter
-        def message(message)
-          output.puts message
-        end
-
-        def dump_failures
-          return if failed_examples.empty?
-          output.puts
-          output.puts "Failures:"
-          failed_examples.each_with_index do |example, index|
-            output.puts
-            pending_fixed?(example) ? dump_pending_fixed(example, index) : dump_failure(example, index)
-            dump_backtrace(example)
-          end
-        end
+        Formatters.register self, :message, :dump_summary, :dump_failures,
+                                  :dump_pending, :seed
 
+        # @method message
         # @api public
         #
-        # Colorizes the output red for failure, yellow for
-        # pending, and green otherwise.
+        # Used by the reporter to send messages to the output stream.
         #
-        # @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)
-          else
-            color(summary, 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))
-          dump_commands_to_rerun_failed_examples
+        # @param notification [MessageNotification] containing message
+        def message(notification)
+          output.puts notification.message
         end
 
+        # @method dump_failures
         # @api public
         #
-        # Outputs commands which can be used to re-run failed examples.
+        # Dumps detailed information about each example failure.
         #
-        def dump_commands_to_rerun_failed_examples
-          return if failed_examples.empty?
-          output.puts
-          output.puts("Failed examples:")
-          output.puts
-
-          failed_examples.each do |example|
-            output.puts(failure_color("rspec #{RSpec::Core::Metadata::relative_path(example.location)}") + " " + detail_color("# #{example.full_description}"))
-          end
+        # @param notification [NullNotification]
+        def dump_failures(notification)
+          return if notification.failure_notifications.empty?
+          output.puts notification.fully_formatted_failed_examples
         end
 
+        # @method dump_summary
         # @api public
         #
-        # Outputs the slowest examples and example groups in a report when using `--profile COUNT` (default 10).
+        # This method is invoked after the dumping of examples and failures. Each parameter
+        # is assigned to a corresponding attribute.
         #
-        def dump_profile
-          dump_profile_slowest_examples
-          dump_profile_slowest_example_groups
+        # @param summary [SummaryNotification] containing duration, example_count,
+        #                                      failure_count and pending_count
+        def dump_summary(summary)
+          output.puts summary.fully_formatted
         end
 
-        def dump_profile_slowest_examples
-          number_of_examples = RSpec.configuration.profile_examples
-          sorted_examples = examples.sort_by {|example|
-            example.execution_result[:run_time] }.reverse.first(number_of_examples)
-
-          total, slows = [examples, sorted_examples].map {|exs|
-            exs.inject(0.0) {|i, e| i + e.execution_result[:run_time] }}
-
-          time_taken = slows / total
-          percentage = '%.1f' % ((time_taken.nan? ? 0.0 : time_taken) * 100)
-
-          output.puts "\nTop #{sorted_examples.size} slowest examples (#{format_seconds(slows)} seconds, #{percentage}% of total time):\n"
-
-          sorted_examples.each do |example|
-            output.puts "  #{example.full_description}"
-            output.puts detail_color("    #{failure_color(format_seconds(example.execution_result[:run_time]))} #{failure_color("seconds")} #{format_caller(example.location)}")
-          end
+        # @private
+        def dump_pending(notification)
+          return if notification.pending_examples.empty?
+          output.puts notification.fully_formatted_pending_examples
         end
 
-        def dump_profile_slowest_example_groups
-          number_of_examples = RSpec.configuration.profile_examples
-          example_groups = {}
-
-          examples.each do |example|
-            location = example.example_group.parent_groups.last.metadata[:example_group][:location]
-
-            example_groups[location] ||= Hash.new(0)
-            example_groups[location][:total_time]  += example.execution_result[:run_time]
-            example_groups[location][:count]       += 1
-            example_groups[location][:description] = example.example_group.top_level_description unless example_groups[location].has_key?(:description)
-          end
-
-          # stop if we've only one example group
-          return if example_groups.keys.length <= 1
-
-          example_groups.each do |loc, hash|
-            hash[:average] = hash[:total_time].to_f / hash[:count]
-          end
-
-          sorted_groups = example_groups.sort_by {|_, hash| -hash[:average]}.first(number_of_examples)
-
-          output.puts "\nTop #{sorted_groups.size} slowest example groups:"
-          sorted_groups.each do |loc, hash|
-            average = "#{failure_color(format_seconds(hash[:average]))} #{failure_color("seconds")} average"
-            total   = "#{format_seconds(hash[:total_time])} seconds"
-            count   = pluralize(hash[:count], "example")
-            output.puts "  #{hash[:description]}"
-            output.puts detail_color("    #{average} (#{total} / #{count}) #{loc}")
-          end
+        # @private
+        def seed(notification)
+          return unless notification.seed_used?
+          output.puts notification.fully_formatted
         end
 
         # @api public
         #
-        # Outputs summary with number of examples, failures and pending.
+        # Invoked at the very end, `close` allows the formatter to clean
+        # up resources, e.g. open streams, etc.
         #
-        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
-          unless pending_examples.empty?
-            output.puts
-            output.puts "Pending:"
-            pending_examples.each do |pending_example|
-              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)}")
-              # instance_variable_get is a hack to avoid a deprecation warning,
-              # it's only for 2.99.
-              if pending_example.execution_result[:exception] \
-                && RSpec.configuration.instance_variable_get(:@show_failures_in_pending_blocks)
-                dump_failure_info(pending_example)
-                dump_backtrace(pending_example)
-              end
-            end
-          end
-        end
-
-        def seed(number)
-          output.puts
-          output.puts "Randomized with seed #{number}"
-          output.puts
-        end
-
-        def close
+        # @param notification [NullNotification]
+        def close(notification)
           return unless IO === output
           return if output.closed? || output == $stdout
 
           output.close
         end
 
-        def self.const_missing(name)
-          base = "RSpec::Core::Formatters::"
-          case name
-            when :VT100_COLORS then
-              RSpec.deprecate("#{base}#{name}", :replacement => "#{base}ConsoleCodes::VT100_CODES")
-              RSpec::Core::Formatters::ConsoleCodes::VT100_CODES
-            when :VT100_COLOR_CODES then
-              RSpec.deprecate("#{base}#{name}", :replacement => "#{base}ConsoleCodes::VT100_CODE_VALUES")
-              require 'set'
-              RSpec::Core::Formatters::ConsoleCodes::VT100_CODES.to_set
-          else
-            super
-          end
-        end
-
-        def color_code_for(code_or_symbol)
-          ConsoleCodes.console_code_for(code_or_symbol)
-        end
-
-        def colorize(text, code_or_symbol)
-          ConsoleCodes.wrap(text, code_or_symbol)
-        end
-
-      protected
-
-        def bold(text)
-          ConsoleCodes.wrap(text, :bold)
-        end
-
-        def color(text, color_code)
-          ConsoleCodes.wrap(text, color_code)
-        end
-
-        def failure_color(text)
-          color(text, RSpec.configuration.failure_color)
-        end
-
-        def success_color(text)
-          color(text, RSpec.configuration.success_color)
-        end
-
-        def pending_color(text)
-          color(text, RSpec.configuration.pending_color)
-        end
-
-        def fixed_color(text)
-          color(text, RSpec.configuration.fixed_color)
-        end
-
-        def detail_color(text)
-          color(text, RSpec.configuration.detail_color)
-        end
-
-        def default_color(text)
-          color(text, RSpec.configuration.default_color)
-        end
-
-        def red(text)
-          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#red", :replacement => "#failure_color")
-          color(text, :red)
-        end
-
-        def green(text)
-          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#green", :replacement => "#success_color")
-          color(text, :green)
-        end
-
-        def yellow(text)
-          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#yellow", :replacement => "#pending_color")
-          color(text, :yellow)
-        end
-
-        def blue(text)
-          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#blue", :replacement => "#fixed_color")
-          color(text, :blue)
-        end
-
-        def magenta(text)
-          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#magenta")
-          color(text, :magenta)
-        end
-
-        def cyan(text)
-          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#cyan", :replacement => "#detail_color")
-          color(text, :cyan)
-        end
-
-        def white(text)
-          RSpec.deprecate("RSpec::Core::Formatters::BaseTextFormatter#white", :replacement => "#default_color")
-          color(text, :white)
-        end
-
-        def short_padding
-          '  '
-        end
-
-        def long_padding
-          '     '
-        end
-
-      private
-
-        def format_caller(caller_info)
-          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|
-            output.puts detail_color("#{long_padding}# #{backtrace_info}")
-          end
-        end
-
-        def dump_pending_fixed(example, index)
-          output.puts "#{short_padding}#{index.next}) #{example.full_description} FIXED"
-          output.puts fixed_color("#{long_padding}Expected pending '#{example.metadata[:execution_result][:pending_message]}' to fail. No Error was raised.")
-        end
-
-        def pending_fixed?(example)
-          example.execution_result[:pending_fixed]
-        end
-
-        def dump_failure(example, index)
-          output.puts "#{short_padding}#{index.next}) #{example.full_description}"
-          dump_failure_info(example)
-        end
-
-        def dump_failure_info(example)
-          exception = example.execution_result[:exception]
-          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/
-          exception.message.to_s.split("\n").each { |line| output.puts "#{long_padding}  #{failure_color(line)}" } if exception.message
-
-          if shared_group = find_shared_group(example)
-            dump_shared_failure_info(shared_group)
-          end
-        end
-
-        def exception_class_name_for(exception)
-          name = exception.class.name.to_s
-          name ="(anonymous error class)" if name == ''
-          name
-        end
-
-        def dump_shared_failure_info(group)
-          output.puts "#{long_padding}Shared Example Group: \"#{group.metadata[:shared_group_name]}\" called from " +
-            "#{backtrace_line(group.metadata[:example_group][:location])}"
-        end
-
-        def find_shared_group(example)
-          group_and_parent_groups(example).find {|group| group.metadata[:shared_group_name]}
-        end
-
-        def group_and_parent_groups(example)
-          example.example_group.parent_groups + [example.example_group]
-        end
       end
     end
   end

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

@@ -1,7 +1,10 @@
 module RSpec
   module Core
     module Formatters
+      # ConsoleCodes provides helpers for formatting console output
+      # with ANSI codes, e.g. color's and bold.
       module ConsoleCodes
+        # @private
         VT100_CODES =
           {
             :black   => 30,
@@ -14,12 +17,20 @@ module RSpec
             :white   => 37,
             :bold    => 1,
           }
+        # @private
         VT100_CODE_VALUES = VT100_CODES.invert
 
         module_function
 
+        # Fetches the correct code for the supplied symbol, or checks
+        # that a code is valid. Defaults to white (37).
+        #
+        # @param code_or_symbol [Symbol, Fixnum] Symbol or code to check
+        # @return [Fixnum] a console code
         def console_code_for(code_or_symbol)
-          if VT100_CODE_VALUES.has_key?(code_or_symbol)
+          if RSpec.configuration.respond_to?(:"#{code_or_symbol}_color")
+            console_code_for configuration_color(code_or_symbol)
+          elsif VT100_CODE_VALUES.has_key?(code_or_symbol)
             code_or_symbol
           else
             VT100_CODES.fetch(code_or_symbol) do
@@ -28,6 +39,13 @@ module RSpec
           end
         end
 
+        # Wraps a piece of text in ANSI codes with the supplied code. Will
+        # only apply the control code if `RSpec.configuration.color_enabled?`
+        # returns true.
+        #
+        # @param text [String] the text to wrap
+        # @param code_or_symbol [Symbol, Fixnum] the desired control code
+        # @return [String] the wrapped text
         def wrap(text, code_or_symbol)
           if RSpec.configuration.color_enabled?
             "\e[#{console_code_for(code_or_symbol)}m#{text}\e[0m"
@@ -36,6 +54,11 @@ module RSpec
           end
         end
 
+        # @private
+        def configuration_color(code)
+          RSpec.configuration.__send__(:"#{code}_color")
+        end
+
       end
     end
   end

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

@@ -1,10 +1,13 @@
-require 'rspec/core/formatters/helpers'
+RSpec::Support.require_rspec_core "formatters/helpers"
 require 'set'
 
 module RSpec
   module Core
     module Formatters
+      # @private
       class DeprecationFormatter
+        Formatters.register self, :deprecation, :deprecation_summary
+
         attr_reader :count, :deprecation_stream, :summary_stream
 
         def initialize(deprecation_stream, summary_stream)
@@ -13,6 +16,7 @@ module RSpec
           @seen_deprecations = Set.new
           @count = 0
         end
+        alias :output :deprecation_stream
 
         def printer
           @printer ||= case deprecation_stream
@@ -25,24 +29,20 @@ module RSpec
                        end
         end
 
-        def deprecation(data)
-          return if @seen_deprecations.include?(data)
+        def deprecation(notification)
+          return if @seen_deprecations.include? notification
 
           @count += 1
-          printer.print_deprecation_message data
-          @seen_deprecations << data
+          printer.print_deprecation_message notification
+          @seen_deprecations << notification
         end
 
-        def deprecation_summary
+        def deprecation_summary(notification)
           printer.deprecation_summary
         end
 
-        def start(example_count=nil)
-          #no-op to fix #966
-        end
-
         def deprecation_message_for(data)
-          if data[:message]
+          if data.message
             SpecifiedDeprecationMessage.new(data)
           else
             GeneratedDeprecationMessage.new(data)
@@ -62,7 +62,7 @@ module RSpec
 
         SpecifiedDeprecationMessage = Struct.new(:type) do
           def initialize(data)
-            @message = data[:message]
+            @message = data.message
             super deprecation_type_for(data)
           end
 
@@ -85,20 +85,20 @@ module RSpec
           end
 
           def deprecation_type_for(data)
-            data[:message].gsub(/(\w+\/)+\w+\.rb:\d+/, '')
+            data.message.gsub(/(\w+\/)+\w+\.rb:\d+/, '')
           end
         end
 
         GeneratedDeprecationMessage = Struct.new(:type) do
           def initialize(data)
             @data = data
-            super data.fetch(:type, data[:deprecated])
+            super data.deprecated
           end
 
           def to_s
-            msg =  "#{@data[:deprecated]} is deprecated."
-            msg << " Use #{@data[:replacement]} instead." if @data[:replacement]
-            msg << " Called from #{@data[:call_site]}." if @data[:call_site]
+            msg =  "#{@data.deprecated} is deprecated."
+            msg << " Use #{@data.replacement} instead." if @data.replacement
+            msg << " Called from #{@data.call_site}." if @data.call_site
             msg
           end
 
@@ -109,6 +109,7 @@ module RSpec
           end
         end
 
+        # @private
         class ImmediatePrinter
           attr_reader :deprecation_stream, :summary_stream, :deprecation_formatter
 
@@ -130,11 +131,10 @@ module RSpec
           end
         end
 
+        # @private
         class DelayedPrinter
           TOO_MANY_USES_LIMIT = 4
 
-          include ::RSpec::Core::Formatters::Helpers
-
           attr_reader :deprecation_stream, :summary_stream, :deprecation_formatter
 
           def initialize(deprecation_stream, summary_stream, deprecation_formatter)
@@ -166,7 +166,7 @@ module RSpec
             print_deferred_deprecation_warnings
             deprecation_stream.puts RAISE_ERROR_CONFIG_NOTICE
 
-            summary_stream.puts "\n#{pluralize(deprecation_formatter.count, 'deprecation warning')} total"
+            summary_stream.puts "\n#{Helpers.pluralize(deprecation_formatter.count, 'deprecation warning')} total"
           end
 
           def print_deferred_deprecation_warnings
@@ -179,23 +179,21 @@ module RSpec
           end
         end
 
+        # @private
         # Not really a stream, but is usable in place of one.
         class RaiseErrorStream
-          include ::RSpec::Core::Formatters::Helpers
-
           def puts(message)
             raise DeprecationError, message
           end
 
           def summarize(summary_stream, deprecation_count)
-            summary_stream.puts "\n#{pluralize(deprecation_count, 'deprecation')} found."
+            summary_stream.puts "\n#{Helpers.pluralize(deprecation_count, 'deprecation')} found."
           end
         end
 
+        # @private
         # Wraps a File object and provides file-specific operations.
         class FileStream
-          include ::RSpec::Core::Formatters::Helpers
-
           def initialize(file)
             @file = file
 
@@ -211,7 +209,7 @@ module RSpec
           end
 
           def summarize(summary_stream, deprecation_count)
-            summary_stream.puts "\n#{pluralize(deprecation_count, 'deprecation')} logged to #{@file.path}"
+            summary_stream.puts "\n#{Helpers.pluralize(deprecation_count, 'deprecation')} logged to #{@file.path}"
             puts RAISE_ERROR_CONFIG_NOTICE
           end
         end
@@ -219,6 +217,7 @@ module RSpec
       end
     end
 
+    # Deprecation Error
     DeprecationError = Class.new(StandardError)
   end
 end

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

@@ -1,57 +1,58 @@
-require 'rspec/core/formatters/base_text_formatter'
+RSpec::Support.require_rspec_core "formatters/base_text_formatter"
 
 module RSpec
   module Core
     module Formatters
+      # @private
       class DocumentationFormatter < BaseTextFormatter
+        Formatters.register self, :example_group_started, :example_group_finished,
+                                  :example_passed, :example_pending, :example_failed
+
         def initialize(output)
-          super(output)
+          super
           @group_level = 0
         end
 
-        def example_group_started(example_group)
-          super(example_group)
-
+        def example_group_started(notification)
           output.puts if @group_level == 0
-          output.puts "#{current_indentation}#{example_group.description.strip}"
+          output.puts "#{current_indentation}#{notification.group.description.strip}"
 
           @group_level += 1
         end
 
-        def example_group_finished(example_group)
+        def example_group_finished(notification)
           @group_level -= 1
         end
 
-        def example_passed(example)
-          super(example)
-          output.puts passed_output(example)
+        def example_passed(passed)
+          output.puts passed_output(passed.example)
         end
 
-        def example_pending(example)
-          super(example)
-          output.puts pending_output(example, example.execution_result[:pending_message])
+        def example_pending(pending)
+          output.puts pending_output(pending.example, pending.example.execution_result.pending_message)
         end
 
-        def example_failed(example)
-          super(example)
-          output.puts failure_output(example, example.execution_result[:exception])
+        def example_failed(failure)
+          output.puts failure_output(failure.example, failure.example.execution_result.exception)
         end
 
-        def failure_output(example, exception)
-          failure_color("#{current_indentation}#{example.description.strip} (FAILED - #{next_failure_index})")
+      private
+
+        def passed_output(example)
+          ConsoleCodes.wrap("#{current_indentation}#{example.description.strip}", :success)
         end
 
-        def next_failure_index
-          @next_failure_index ||= 0
-          @next_failure_index += 1
+        def pending_output(example, message)
+          ConsoleCodes.wrap("#{current_indentation}#{example.description.strip} (PENDING: #{message})", :pending)
         end
 
-        def passed_output(example)
-          success_color("#{current_indentation}#{example.description.strip}")
+        def failure_output(example, exception)
+          ConsoleCodes.wrap("#{current_indentation}#{example.description.strip} (FAILED - #{next_failure_index})", :failure)
         end
 
-        def pending_output(example, message)
-          pending_color("#{current_indentation}#{example.description.strip} (PENDING: #{message})")
+        def next_failure_index
+          @next_failure_index ||= 0
+          @next_failure_index += 1
         end
 
         def current_indentation
@@ -61,6 +62,7 @@ module RSpec
         def example_group_chain
           example_group.parent_groups.reverse
         end
+
       end
     end
   end