rspec-core 3.3.2 → 3.4.0

data/lib/rspec/core/configuration_options.rb

@@ -64,7 +64,7 @@ module RSpec
       end
 
       def order(keys)
-        OPTIONS_ORDER.reverse.each do |key|
+        OPTIONS_ORDER.reverse_each do |key|
           keys.unshift(key) if keys.delete(key)
         end
         keys

data/lib/rspec/core/example.rb

@@ -118,6 +118,30 @@ module RSpec
         @id ||= Metadata.id_from(metadata)
       end
 
+      # @private
+      def self.parse_id(id)
+        # http://rubular.com/r/OMZSAPcAfn
+        id.match(/\A(.*?)(?:\[([\d\s:,]+)\])?\z/).captures
+      end
+
+      # Duplicates the example and overrides metadata with the provided
+      # hash.
+      #
+      # @param metadata_overrides [Hash] the hash to override the example metadata
+      # @return [Example] a duplicate of the example with modified metadata
+      def duplicate_with(metadata_overrides={})
+        new_metadata = metadata.clone.merge(metadata_overrides)
+
+        RSpec::Core::Metadata::RESERVED_KEYS.each do |reserved_key|
+          new_metadata.delete reserved_key
+        end
+
+        # don't clone the example group because the new example
+        # must belong to the same example group (not a clone).
+        Example.new(example_group, description.clone,
+                    new_metadata, new_metadata[:block])
+      end
+
       # @attr_reader
       #
       # Returns the first exception raised in the context of running this
@@ -170,6 +194,12 @@ module RSpec
         @reporter = RSpec::Core::NullReporter
       end
 
+      # Provide a human-readable representation of this class
+      def inspect
+        "#<#{self.class.name} #{description.inspect}>"
+      end
+      alias to_s inspect
+
       # @return [RSpec::Core::Reporter] the current reporter for the example
       attr_reader :reporter
 
@@ -215,14 +245,14 @@ module RSpec
               rescue Pending::SkipDeclaredInExample
                 # no-op, required metadata has already been set by the `skip`
                 # method.
-              rescue Exception => e
+              rescue AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt => e
                 set_exception(e)
               ensure
                 run_after_example
               end
             end
           end
-        rescue Exception => e
+        rescue Support::AllExceptionsExceptOnesWeMustNotRescue => e
           set_exception(e)
         ensure
           @example_group_instance = nil # if you love something... let it go
@@ -233,6 +263,20 @@ module RSpec
         RSpec.current_example = nil
       end
 
+      if RSpec::Support::Ruby.jruby? || RUBY_VERSION.to_f < 1.9
+        # :nocov:
+        # For some reason, rescuing `Support::AllExceptionsExceptOnesWeMustNotRescue`
+        # in place of `Exception` above can cause the exit status to be the wrong
+        # thing. I have no idea why. See:
+        # https://github.com/rspec/rspec-core/pull/2063#discussion_r38284978
+        # @private
+        AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = Exception
+        # :nocov:
+      else
+        # @private
+        AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = Support::AllExceptionsExceptOnesWeMustNotRescue
+      end
+
       # Wraps both a `Proc` and an {Example} for use in {Hooks#around
       # around} hooks. In around hooks we need to yield this special
       # kind of object (rather than the raw {Example}) because when
@@ -256,13 +300,15 @@ module RSpec
         attr_reader :example
 
         Example.public_instance_methods(false).each do |name|
-          next if name.to_sym == :run || name.to_sym == :inspect
+          name_sym = name.to_sym
+          next if name_sym == :run || name_sym == :inspect || name_sym == :to_s
 
           define_method(name) { |*a, &b| @example.__send__(name, *a, &b) }
         end
 
         Proc.public_instance_methods(false).each do |name|
-          next if name.to_sym == :call || name.to_sym == :inspect || name.to_sym == :to_proc
+          name_sym = name.to_sym
+          next if name_sym == :call || name_sym == :inspect || name_sym == :to_s || name_sym == :to_proc
 
           define_method(name) { |*a, &b| @proc.__send__(name, *a, &b) }
         end
@@ -386,7 +432,7 @@ module RSpec
 
       def with_around_example_hooks
         hooks.run(:around, :example, self) { yield }
-      rescue Exception => e
+      rescue Support::AllExceptionsExceptOnesWeMustNotRescue => e
         set_exception(e)
       end
 
@@ -398,6 +444,7 @@ module RSpec
       def finish(reporter)
         pending_message = execution_result.pending_message
 
+        reporter.example_finished(self)
         if @exception
           record_finished :failed
           execution_result.exception = @exception
@@ -442,7 +489,7 @@ module RSpec
 
       def verify_mocks
         @example_group_instance.verify_mocks_for_rspec if mocks_need_verification?
-      rescue Exception => e
+      rescue Support::AllExceptionsExceptOnesWeMustNotRescue => e
         set_exception(e)
       end
 
@@ -461,7 +508,7 @@ module RSpec
 
       def generate_description
         RSpec::Matchers.generated_description
-      rescue Exception => e
+      rescue Support::AllExceptionsExceptOnesWeMustNotRescue => e
         location_description + " (Got an error when generating description " \
           "from matcher: #{e.class}: #{e.message} -- #{e.backtrace.first})"
       end

data/lib/rspec/core/example_group.rb

@@ -2,6 +2,7 @@ RSpec::Support.require_rspec_support 'recursive_const_methods'
 
 module RSpec
   module Core
+    # rubocop:disable Metrics/ClassLength
     # ExampleGroup and {Example} are the main structural elements of
     # rspec-core. Consider this example:
     #
@@ -340,6 +341,27 @@ module RSpec
         find_and_eval_shared("examples", name, caller.first, *args, &block)
       end
 
+      # Clear memoized values when adding/removing examples
+      # @private
+      def self.reset_memoized
+        @descendant_filtered_examples = nil
+        @_descendants = nil
+        @parent_groups = nil
+        @declaration_line_numbers = nil
+      end
+
+      # Adds an example to the example group
+      def self.add_example(example)
+        reset_memoized
+        examples << example
+      end
+
+      # Removes an example from the example group
+      def self.remove_example(example)
+        reset_memoized
+        examples.delete example
+      end
+
       # @private
       def self.find_and_eval_shared(label, name, inclusion_location, *args, &customization_block)
         shared_block = RSpec.world.shared_example_group_registry.find(parent_groups, name)
@@ -524,9 +546,9 @@ module RSpec
         rescue Pending::SkipDeclaredInExample => ex
           for_filtered_examples(reporter) { |example| example.skip_with_exception(reporter, ex) }
           true
-        rescue Exception => ex
-          RSpec.world.wants_to_quit = true if fail_fast?
+        rescue Support::AllExceptionsExceptOnesWeMustNotRescue => ex
           for_filtered_examples(reporter) { |example| example.fail_with_exception(reporter, ex) }
+          RSpec.world.wants_to_quit = true if reporter.fail_fast_limit_met?
           false
         ensure
           run_after_context_hooks(new('after(:context) hook')) if should_run_context_hooks
@@ -557,7 +579,9 @@ module RSpec
           instance = new(example.inspect_output)
           set_ivars(instance, before_context_ivars)
           succeeded = example.run(instance, reporter)
-          RSpec.world.wants_to_quit = true if fail_fast? && !succeeded
+          if !succeeded && reporter.fail_fast_limit_met?
+            RSpec.world.wants_to_quit = true
+          end
           succeeded
         end.all?
       end
@@ -574,11 +598,6 @@ module RSpec
         false
       end
 
-      # @private
-      def self.fail_fast?
-        RSpec.configuration.fail_fast?
-      end
-
       # @private
       def self.declaration_line_numbers
         @declaration_line_numbers ||= [metadata[:line_number]] +
@@ -671,6 +690,7 @@ module RSpec
         super
       end
     end
+    # rubocop:enable Metrics/ClassLength
 
     # @private
     # Unnamed example group used by `SuiteHookContext`.

data/lib/rspec/core/example_status_persister.rb

@@ -21,24 +21,28 @@ module RSpec
       end
 
       def persist
-        write dumped_statuses
+        RSpec::Support::DirectoryMaker.mkdir_p(File.dirname(@file_name))
+        File.open(@file_name, File::RDWR | File::CREAT) do |f|
+          # lock the file while reading / persisting to avoid a race
+          # condition where parallel or unrelated spec runs race to
+          # update the same file
+          f.flock(File::LOCK_EX)
+          unparsed_previous_runs = f.read
+          f.rewind
+          f.write(dump_statuses(unparsed_previous_runs))
+          f.flush
+          f.truncate(f.pos)
+        end
       end
 
     private
 
-      def write(statuses)
-        RSpec::Support::DirectoryMaker.mkdir_p(File.dirname(@file_name))
-        File.open(@file_name, "w") { |f| f.write(statuses) }
-      end
-
-      def dumped_statuses
+      def dump_statuses(unparsed_previous_runs)
+        statuses_from_previous_runs = ExampleStatusParser.parse(unparsed_previous_runs)
+        merged_statuses = ExampleStatusMerger.merge(statuses_from_this_run, statuses_from_previous_runs)
         ExampleStatusDumper.dump(merged_statuses)
       end
 
-      def merged_statuses
-        ExampleStatusMerger.merge(statuses_from_this_run, statuses_from_previous_runs)
-      end
-
       def statuses_from_this_run
         @examples.map do |ex|
           result = ex.execution_result
@@ -50,10 +54,6 @@ module RSpec
           }
         end
       end
-
-      def statuses_from_previous_runs
-        self.class.load_from(@file_name)
-      end
     end
 
     # Merges together a list of example statuses from this run
@@ -130,7 +130,7 @@ module RSpec
       end
 
       def sort_value_from(example)
-        file, scoped_id = example.fetch(:example_id).split(Configuration::ON_SQUARE_BRACKETS)
+        file, scoped_id = Example.parse_id(example.fetch(:example_id))
         [file, *scoped_id.split(":").map(&method(:Integer))]
       end
     end

data/lib/rspec/core/formatters.rb

@@ -73,6 +73,7 @@ module RSpec::Core::Formatters
   autoload :ProfileFormatter,         'rspec/core/formatters/profile_formatter'
   autoload :JsonFormatter,            'rspec/core/formatters/json_formatter'
   autoload :BisectFormatter,          'rspec/core/formatters/bisect_formatter'
+  autoload :ExceptionPresenter,       'rspec/core/formatters/exception_presenter'
 
   # Register the formatter class
   # @param formatter_class [Class] formatter class to register

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

@@ -9,10 +9,14 @@ module RSpec
         # We've named all events with a `bisect_` prefix to prevent naming collisions.
         Formatters.register self, :bisect_starting, :bisect_original_run_complete,
                             :bisect_round_started, :bisect_individual_run_complete,
-                            :bisect_round_finished, :bisect_complete, :bisect_repro_command,
-                            :bisect_failed, :bisect_aborted
+                            :bisect_complete, :bisect_repro_command,
+                            :bisect_failed, :bisect_aborted,
+                            :bisect_round_ignoring_ids, :bisect_round_detected_multiple_culprits,
+                            :bisect_dependency_check_started, :bisect_dependency_check_passed,
+                            :bisect_dependency_check_failed
 
         def bisect_starting(notification)
+          @round_count = 0
           options = notification.original_cli_args.join(' ')
           output.puts "Bisect started using options: #{options.inspect}"
           output.print "Running suite to find failures..."
@@ -26,17 +30,35 @@ module RSpec
           output.puts "Starting bisect with #{failures} and #{non_failures}."
         end
 
+        def bisect_dependency_check_started(_notification)
+          output.print "Checking that failure(s) are order-dependent.."
+        end
+
+        def bisect_dependency_check_passed(_notification)
+          output.puts " failure appears to be order-dependent"
+        end
+
+        def bisect_dependency_check_failed(_notification)
+          output.puts " failure is not order-dependent"
+        end
+
         def bisect_round_started(notification, include_trailing_space=true)
-          search_desc = Helpers.pluralize(
-            notification.subset_size, "non-failing example"
-          )
+          @round_count += 1
+          range_desc = notification.candidate_range.description
 
-          output.print "\nRound #{notification.round}: searching for #{search_desc}" \
-                       " (of #{notification.remaining_count}) to ignore:"
+          output.print "\nRound #{@round_count}: bisecting over non-failing #{range_desc}"
           output.print " " if include_trailing_space
         end
 
-        def bisect_round_finished(notification)
+        def bisect_round_ignoring_ids(notification)
+          range_desc = notification.ignore_range.description
+
+          output.print " ignoring #{range_desc}"
+          output.print " (#{Helpers.format_duration(notification.duration)})"
+        end
+
+        def bisect_round_detected_multiple_culprits(notification)
+          output.print " multiple culprits detected - splitting candidates"
           output.print " (#{Helpers.format_duration(notification.duration)})"
         end
 
@@ -71,7 +93,7 @@ module RSpec
       # Designed to provide details for us when we need to troubleshoot bisect bugs.
       class BisectDebugFormatter < BisectProgressFormatter
         Formatters.register self, :bisect_original_run_complete, :bisect_individual_run_start,
-                            :bisect_individual_run_complete, :bisect_round_finished, :bisect_ignoring_ids
+                            :bisect_individual_run_complete, :bisect_round_ignoring_ids
 
         def bisect_original_run_complete(notification)
           output.puts " (#{Helpers.format_duration(notification.duration)})"
@@ -88,20 +110,27 @@ module RSpec
           output.print " (#{Helpers.format_duration(notification.duration)})"
         end
 
-        def bisect_round_started(notification)
-          super(notification, false)
+        def bisect_dependency_check_passed(_notification)
+          output.print "\n - Failure appears to be order-dependent"
         end
 
-        def bisect_round_finished(notification)
-          output.print "\n - Round finished"
-          super
+        def bisect_dependency_check_failed(_notification)
+          output.print "\n - Failure is not order-dependent"
         end
 
-        def bisect_ignoring_ids(notification)
+        def bisect_round_started(notification)
+          super(notification, false)
+        end
+
+        def bisect_round_ignoring_ids(notification)
           output.print "\n - #{describe_ids 'Examples we can safely ignore', notification.ids_to_ignore}"
           output.print "\n - #{describe_ids 'Remaining non-failing examples', notification.remaining_ids}"
         end
 
+        def bisect_round_detected_multiple_culprits(_notification)
+          output.print "\n - Multiple culprits detected - splitting candidates"
+        end
+
       private
 
         def describe_ids(description, ids)

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

@@ -1,3 +1,7 @@
+# encoding: utf-8
+RSpec::Support.require_rspec_core "formatters/snippet_extractor"
+RSpec::Support.require_rspec_support "encoded_string"
+
 module RSpec
   module Core
     module Formatters
@@ -11,7 +15,7 @@ module RSpec
           @exception               = exception
           @example                 = example
           @message_color           = options.fetch(:message_color)          { RSpec.configuration.failure_color }
-          @description             = options.fetch(:description_formatter)  { Proc.new { example.full_description } }.call(self)
+          @description             = options.fetch(:description)            { example.full_description }
           @detail_formatter        = options.fetch(:detail_formatter)       { Proc.new {} }
           @extra_detail_formatter  = options.fetch(:extra_detail_formatter) { Proc.new {} }
           @backtrace_formatter     = options.fetch(:backtrace_formatter)    { RSpec.configuration.backtrace_formatter }
@@ -30,8 +34,36 @@ module RSpec
           end
         end
 
-        def formatted_backtrace
-          backtrace_formatter.format_backtrace(exception_backtrace, example.metadata)
+        def formatted_backtrace(exception=@exception)
+          backtrace_formatter.format_backtrace((exception.backtrace || []), example.metadata) +
+            formatted_cause(exception)
+        end
+
+        if RSpec::Support::RubyFeatures.supports_exception_cause?
+          def formatted_cause(exception)
+            last_cause = final_exception(exception)
+            cause = []
+
+            if exception.cause
+              cause << '------------------'
+              cause << '--- Caused by: ---'
+              cause << "#{exception_class_name(last_cause)}:" unless exception_class_name(last_cause) =~ /RSpec/
+
+              encoded_string(last_cause.message.to_s).split("\n").each do |line|
+                cause << "  #{line}"
+              end
+
+              cause << ("  #{backtrace_formatter.format_backtrace(last_cause.backtrace, example.metadata).first}")
+            end
+
+            cause
+          end
+        else
+          # :nocov:
+          def formatted_cause(_)
+            []
+          end
+          # :nocov:
         end
 
         def colorized_formatted_backtrace(colorizer=::RSpec::Core::Formatters::ConsoleCodes)
@@ -41,24 +73,31 @@ module RSpec
         end
 
         def fully_formatted(failure_number, colorizer=::RSpec::Core::Formatters::ConsoleCodes)
-          alignment_basis = "#{' ' * @indentation}#{failure_number}) "
-          indentation = ' ' * alignment_basis.length
-
-          "\n#{alignment_basis}#{description_and_detail(colorizer, indentation)}" \
-          "\n#{formatted_message_and_backtrace(colorizer, indentation)}" \
-          "#{extra_detail_formatter.call(failure_number, colorizer, indentation)}"
+          lines = fully_formatted_lines(failure_number, colorizer)
+          lines.join("\n") << "\n"
         end
 
-        def failure_slash_error_line
-          @failure_slash_error_line ||= "Failure/Error: #{read_failed_line.strip}"
+        def fully_formatted_lines(failure_number, colorizer)
+          lines = [
+            description,
+            detail_formatter.call(example, colorizer),
+            formatted_message_and_backtrace(colorizer),
+            extra_detail_formatter.call(failure_number, colorizer),
+          ].compact.flatten
+
+          lines = indent_lines(lines, failure_number)
+          lines.unshift("")
+          lines
         end
 
       private
 
-        def description_and_detail(colorizer, indentation)
-          detail = detail_formatter.call(example, colorizer, indentation)
-          return (description || detail) unless description && detail
-          "#{description}\n#{indentation}#{detail}"
+        def final_exception(exception)
+          if exception.cause
+            final_exception(exception.cause)
+          else
+            exception
+          end
         end
 
         if String.method_defined?(:encoding)
@@ -80,23 +119,71 @@ module RSpec
           # :nocov:
         end
 
-        def exception_class_name
+        def indent_lines(lines, failure_number)
+          alignment_basis = "#{' ' * @indentation}#{failure_number}) "
+          indentation = ' ' * alignment_basis.length
+
+          lines.each_with_index.map do |line, index|
+            if index == 0
+              "#{alignment_basis}#{line}"
+            elsif line.empty?
+              line
+            else
+              "#{indentation}#{line}"
+            end
+          end
+        end
+
+        def exception_class_name(exception=@exception)
           name = exception.class.name.to_s
           name = "(anonymous error class)" if name == ''
           name
         end
 
         def failure_lines
-          @failure_lines ||=
-            begin
-              lines = []
-              lines << failure_slash_error_line unless (description == failure_slash_error_line)
-              lines << "#{exception_class_name}:" unless exception_class_name =~ /RSpec/
-              encoded_string(exception.message.to_s).split("\n").each do |line|
-                lines << "  #{line}"
-              end
-              lines
+          @failure_lines ||= [].tap do |lines|
+            lines.concat(failure_slash_error_lines)
+
+            sections = [failure_slash_error_lines, exception_lines]
+            if sections.any? { |section| section.size > 1 } && !exception_lines.first.empty?
+              lines << ''
             end
+
+            lines.concat(exception_lines)
+            lines.concat(extra_failure_lines)
+          end
+        end
+
+        def failure_slash_error_lines
+          lines = read_failed_lines
+          if lines.count == 1
+            lines[0] = "Failure/Error: #{lines[0].strip}"
+          else
+            least_indentation = SnippetExtractor.least_indentation_from(lines)
+            lines = lines.map { |line| line.sub(/^#{least_indentation}/, '  ') }
+            lines.unshift('Failure/Error:')
+          end
+          lines
+        end
+
+        def exception_lines
+          lines = []
+          lines << "#{exception_class_name}:" unless exception_class_name =~ /RSpec/
+          encoded_string(exception.message.to_s).split("\n").each do |line|
+            lines << (line.empty? ? line : "  #{line}")
+          end
+          lines
+        end
+
+        def extra_failure_lines
+          @extra_failure_lines ||= begin
+            lines = Array(example.metadata[:extra_failure_lines])
+            unless lines.empty?
+              lines.unshift('')
+              lines.push('')
+            end
+            lines
+          end
         end
 
         def add_shared_group_lines(lines, colorizer)
@@ -109,42 +196,41 @@ module RSpec
           lines
         end
 
-        def read_failed_line
+        def read_failed_lines
           matching_line = find_failed_line
           unless matching_line
-            return "Unable to find matching line from backtrace"
+            return ["Unable to find matching line from backtrace"]
           end
 
           file_path, line_number = matching_line.match(/(.+?):(\d+)(|:\d+)/)[1..2]
-
-          if File.exist?(file_path)
-            File.readlines(file_path)[line_number.to_i - 1] ||
-              "Unable to find matching line in #{file_path}"
-          else
-            "Unable to find #{file_path} to read failed line"
-          end
+          max_line_count = RSpec.configuration.max_displayed_failure_line_count
+          lines = SnippetExtractor.extract_expression_lines_at(file_path, line_number.to_i, max_line_count)
+          RSpec.world.source_cache.syntax_highlighter.highlight(lines)
+        rescue SnippetExtractor::NoSuchFileError
+          ["Unable to find #{file_path} to read failed line"]
+        rescue SnippetExtractor::NoSuchLineError
+          ["Unable to find matching line in #{file_path}"]
         rescue SecurityError
-          "Unable to read failed line"
+          ["Unable to read failed line"]
         end
 
         def find_failed_line
-          example_path = example.metadata[:absolute_file_path].downcase
+          line_regex = RSpec.configuration.in_project_source_dir_regex
+          loaded_spec_files = RSpec.configuration.loaded_spec_files
+
           exception_backtrace.find do |line|
             next unless (line_path = line[/(.+?):(\d+)(|:\d+)/, 1])
-            File.expand_path(line_path).downcase == example_path
-          end
+            path = File.expand_path(line_path)
+            loaded_spec_files.include?(path) || path =~ line_regex
+          end || exception_backtrace.first
         end
 
-        def formatted_message_and_backtrace(colorizer, indentation)
+        def formatted_message_and_backtrace(colorizer)
           lines = colorized_message_lines(colorizer) + colorized_formatted_backtrace(colorizer)
-
-          formatted = ""
-
-          lines.each do |line|
-            formatted << RSpec::Support::EncodedString.new("#{indentation}#{line}\n", encoding_of(formatted))
+          encoding = encoding_of("")
+          lines.map do |line|
+            RSpec::Support::EncodedString.new(line, encoding)
           end
-
-          formatted
         end
 
         def exception_backtrace
@@ -180,9 +266,9 @@ module RSpec
           def pending_options
             if @execution_result.pending_fixed?
               {
-                :description_formatter => Proc.new { "#{@example.full_description} FIXED" },
-                :message_color         => RSpec.configuration.fixed_color,
-                :failure_lines         => [
+                :description   => "#{@example.full_description} FIXED",
+                :message_color => RSpec.configuration.fixed_color,
+                :failure_lines => [
                   "Expected pending '#{@execution_result.pending_message}' to fail. No Error was raised."
                 ]
               }
@@ -205,8 +291,6 @@ module RSpec
                                                                        options[:message_color])
             )
 
-            options[:description_formatter] &&= Proc.new {}
-
             return options unless exception.aggregation_metadata[:hide_backtrace]
             options[:backtrace_formatter] = EmptyBacktraceFormatter
             options
@@ -217,7 +301,7 @@ module RSpec
           end
 
           def multiple_exception_summarizer(exception, prior_detail_formatter, color)
-            lambda do |example, colorizer, indentation|
+            lambda do |example, colorizer|
               summary = if exception.aggregation_metadata[:hide_backtrace]
                           # Since the backtrace is hidden, the subfailures will come
                           # immediately after this, and using `:` will read well.
@@ -230,27 +314,30 @@ module RSpec
 
               summary = colorizer.wrap(summary, color || RSpec.configuration.failure_color)
               return summary unless prior_detail_formatter
-              "#{prior_detail_formatter.call(example, colorizer, indentation)}\n#{indentation}#{summary}"
+              [
+                prior_detail_formatter.call(example, colorizer),
+                summary
+              ]
             end
           end
 
           def sub_failure_list_formatter(exception, message_color)
             common_backtrace_truncater = CommonBacktraceTruncater.new(exception)
 
-            lambda do |failure_number, colorizer, indentation|
-              exception.all_exceptions.each_with_index.map do |failure, index|
+            lambda do |failure_number, colorizer|
+              FlatMap.flat_map(exception.all_exceptions.each_with_index) do |failure, index|
                 options = with_multiple_error_options_as_needed(
                   failure,
-                  :description_formatter   => :failure_slash_error_line.to_proc,
-                  :indentation             => indentation.length,
+                  :description             => nil,
+                  :indentation             => 0,
                   :message_color           => message_color || RSpec.configuration.failure_color,
                   :skip_shared_group_trace => true
                 )
 
                 failure   = common_backtrace_truncater.with_truncated_backtrace(failure)
                 presenter = ExceptionPresenter.new(failure, @example, options)
-                presenter.fully_formatted("#{failure_number}.#{index + 1}", colorizer)
-              end.join
+                presenter.fully_formatted_lines("#{failure_number}.#{index + 1}", colorizer)
+              end
             end
           end