rspec-core 3.3.0 → 3.4.0

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,45 @@ 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
-          exception.backtrace.find do |line|
+          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
+        end
 
-          formatted
+        def exception_backtrace
+          exception.backtrace || []
         end
 
         # @private
@@ -176,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."
                 ]
               }
@@ -201,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
@@ -213,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.
@@ -226,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
 

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

@@ -92,7 +92,7 @@ module RSpec
         # Given a list of example ids, organizes them into a compact, ordered list.
         def self.organize_ids(ids)
           grouped = ids.inject(Hash.new { |h, k| h[k] = [] }) do |hash, id|
-            file, id = id.split(Configuration::ON_SQUARE_BRACKETS)
+            file, id = Example.parse_id(id)
             hash[file] << id
             hash
           end

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

@@ -137,12 +137,12 @@ module RSpec
         # spec. For example, you could output links to images or other files
         # produced during the specs.
         def extra_failure_content(failure)
-          RSpec::Support.require_rspec_core "formatters/snippet_extractor"
-          backtrace = failure.exception.backtrace.map do |line|
+          RSpec::Support.require_rspec_core "formatters/html_snippet_extractor"
+          backtrace = (failure.exception.backtrace || []).map do |line|
             RSpec.configuration.backtrace_formatter.backtrace_line(line)
           end
           backtrace.compact!
-          @snippet_extractor ||= SnippetExtractor.new
+          @snippet_extractor ||= HtmlSnippetExtractor.new
           "    <pre class=\"ruby\"><code>#{@snippet_extractor.snippet(backtrace)}</code></pre>"
         end
       end

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

@@ -33,10 +33,10 @@ module RSpec
             "<span class='duration'>#{formatted_run_time}s</span></dd>"
         end
 
-        # rubocop:disable Style/ParameterLists
+        # rubocop:disable Metrics/ParameterLists
         def print_example_failed(pending_fixed, description, run_time, failure_id,
                                  exception, extra_content)
-          # rubocop:enable Style/ParameterLists
+          # rubocop:enable Metrics/ParameterLists
           formatted_run_time = "%.5f" % run_time
 
           @output.puts "    <dd class=\"example #{pending_fixed ? 'pending_fixed' : 'failed'}\">"
@@ -139,7 +139,6 @@ module RSpec
 EOF
         # rubocop:enable LineLength
 
-        # rubocop:disable LineLength
         GLOBAL_SCRIPTS = <<-EOF
 
 function addClass(element_id, classname) {

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

@@ -0,0 +1,116 @@
+module RSpec
+  module Core
+    module Formatters
+      # @api private
+      #
+      # Extracts code snippets by looking at the backtrace of the passed error
+      # and applies synax highlighting and line numbers using html.
+      class HtmlSnippetExtractor
+        # @private
+        module NullConverter
+          def self.convert(code)
+            %Q(#{code}\n<span class="comment"># Install the coderay gem to get syntax highlighting</span>)
+          end
+        end
+
+        # @private
+        module CoderayConverter
+          def self.convert(code)
+            CodeRay.scan(code, :ruby).html(:line_numbers => false)
+          end
+        end
+
+        # rubocop:disable Style/ClassVars
+        @@converter = NullConverter
+        begin
+          require 'coderay'
+          @@converter = CoderayConverter
+          # rubocop:disable Lint/HandleExceptions
+        rescue LoadError
+          # it'll fall back to the NullConverter assigned above
+          # rubocop:enable Lint/HandleExceptions
+        end
+
+        # rubocop:enable Style/ClassVars
+
+        # @api private
+        #
+        # Extract lines of code corresponding to  a backtrace.
+        #
+        # @param backtrace [String] the backtrace from a test failure
+        # @return [String] highlighted code snippet indicating where the test
+        #   failure occured
+        #
+        # @see #post_process
+        def snippet(backtrace)
+          raw_code, line = snippet_for(backtrace[0])
+          highlighted = @@converter.convert(raw_code)
+          post_process(highlighted, line)
+        end
+        # rubocop:enable Style/ClassVars
+
+        # @api private
+        #
+        # Create a snippet from a line of code.
+        #
+        # @param error_line [String] file name with line number (i.e.
+        #   'foo_spec.rb:12')
+        # @return [String] lines around the target line within the file
+        #
+        # @see #lines_around
+        def snippet_for(error_line)
+          if error_line =~ /(.*):(\d+)/
+            file = Regexp.last_match[1]
+            line = Regexp.last_match[2].to_i
+            [lines_around(file, line), line]
+          else
+            ["# Couldn't get snippet for #{error_line}", 1]
+          end
+        end
+
+        # @api private
+        #
+        # Extract lines of code centered around a particular line within a
+        # source file.
+        #
+        # @param file [String] filename
+        # @param line [Fixnum] line number
+        # @return [String] lines around the target line within the file (2 above
+        #   and 1 below).
+        def lines_around(file, line)
+          if File.file?(file)
+            lines = File.read(file).split("\n")
+            min = [0, line - 3].max
+            max = [line + 1, lines.length - 1].min
+            selected_lines = []
+            selected_lines.join("\n")
+            lines[min..max].join("\n")
+          else
+            "# Couldn't get snippet for #{file}"
+          end
+        rescue SecurityError
+          "# Couldn't get snippet for #{file}"
+        end
+
+        # @api private
+        #
+        # Adds line numbers to all lines and highlights the line where the
+        # failure occurred using html `span` tags.
+        #
+        # @param highlighted [String] syntax-highlighted snippet surrounding the
+        #   offending line of code
+        # @param offending_line [Fixnum] line where failure occured
+        # @return [String] completed snippet
+        def post_process(highlighted, offending_line)
+          new_lines = []
+          highlighted.split("\n").each_with_index do |line, i|
+            new_line = "<span class=\"linenum\">#{offending_line + i - 2}</span>#{line}"
+            new_line = "<span class=\"offending\">#{new_line}</span>" if i == 2
+            new_lines << new_line
+          end
+          new_lines.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -66,6 +66,15 @@ module RSpec
         # @param notification [ExampleNotification] containing example subclass
         #   of `RSpec::Core::Example`
 
+        # @method example_finished
+        # @api public
+        # @group Example Notifications
+        #
+        # Invoked at the end of the execution of each example.
+        #
+        # @param notification [ExampleNotification] containing example subclass
+        #   of `RSpec::Core::Example`
+
         # @method example_passed
         # @api public
         # @group Example Notifications