rspec-core 2.99.0 → 3.0.0

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

@@ -1,48 +1,26 @@
 module RSpec
   module Core
-    module BacktraceFormatter
-      extend self
-
-      def format_backtrace(backtrace, options = {})
-        return "" unless backtrace
-        return backtrace if options[:full_backtrace] == true
-
-        if at_exit_index = backtrace.index(RSpec::Core::Runner::AT_EXIT_HOOK_BACKTRACE_LINE)
-          backtrace = backtrace[0, at_exit_index]
-        end
-
-        cleansed = backtrace.map { |line| backtrace_line(line) }.compact
-        cleansed.empty? ? backtrace : cleansed
-      end
-
-    protected
-
-      def backtrace_line(line)
-        return nil if RSpec.configuration.backtrace_formatter.exclude?(line)
-        RSpec::Core::Metadata::relative_path(line)
-      rescue SecurityError
-        nil
-      end
-    end
-
     module Formatters
+      # Formatters helpers
       module Helpers
-        include BacktraceFormatter
 
+        # @private
         SUB_SECOND_PRECISION = 5
+
+        # @private
         DEFAULT_PRECISION = 2
 
         # @api private
         #
         # Formats seconds into a human-readable string.
         #
-        # @param [Float, Fixnum] duration in seconds
+        # @param duration [Float, Fixnum] in seconds
         # @return [String] human-readable time
         #
         # @example
         #    format_duration(1) #=>  "1 minute 1 second"
         #    format_duration(135.14) #=> "2 minutes 15.14 seconds"
-        def format_duration(duration)
+        def self.format_duration(duration)
           precision = case
                       when duration < 1;    SUB_SECOND_PRECISION
                       when duration < 120;  DEFAULT_PRECISION
@@ -65,7 +43,7 @@ module RSpec
         # Formats seconds to have 5 digits of precision with trailing zeros removed if the number
         # is less than 1 or with 2 digits of precision if the number is greater than zero.
         #
-        # @param [Float] float
+        # @param float [Float]
         # @return [String] formatted float
         #
         # @example
@@ -76,7 +54,7 @@ module RSpec
         # The precision used is set in {Helpers::SUB_SECOND_PRECISION} and {Helpers::DEFAULT_PRECISION}.
         #
         # @see #strip_trailing_zeroes
-        def format_seconds(float, precision = nil)
+        def self.format_seconds(float, precision = nil)
           precision ||= (float < 1) ? SUB_SECOND_PRECISION : DEFAULT_PRECISION
           formatted = sprintf("%.#{precision}f", float)
           strip_trailing_zeroes(formatted)
@@ -86,25 +64,25 @@ module RSpec
         #
         # Remove trailing zeros from a string.
         #
-        # @param [String] string string with trailing zeros
+        # @param string [String] string with trailing zeros
         # @return [String] string with trailing zeros removed
-        def strip_trailing_zeroes(string)
+        def self.strip_trailing_zeroes(string)
           stripped = string.sub(/[^1-9]+$/, '')
           stripped.empty? ? "0" : stripped
         end
+        private_class_method :strip_trailing_zeroes
 
         # @api private
         #
         # Pluralize a word based on a count.
         #
-        # @param [Fixnum] count number of objects
-        # @param [String] string word to be pluralized
+        # @param count [Fixnum] number of objects
+        # @param string [String] word to be pluralized
         # @return [String] pluralized word
-        def pluralize(count, string)
+        def self.pluralize(count, string)
           "#{count} #{string}#{'s' unless count.to_f == 1}"
         end
       end
-
     end
   end
 end

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

@@ -1,75 +1,59 @@
-require 'rspec/core/formatters/base_text_formatter'
-require 'rspec/core/formatters/html_printer'
+RSpec::Support.require_rspec_core "formatters/base_text_formatter"
+RSpec::Support.require_rspec_core "formatters/html_printer"
 
 module RSpec
   module Core
     module Formatters
-      class HtmlFormatter < BaseTextFormatter
+      # @private
+      class HtmlFormatter < BaseFormatter
+        Formatters.register self, :start, :example_group_started, :start_dump,
+                                  :example_started, :example_passed, :example_failed,
+                                  :example_pending, :dump_summary
 
         def initialize(output)
           super(output)
+          @failed_examples = []
           @example_group_number = 0
           @example_number = 0
           @header_red = nil
           @printer = HtmlPrinter.new(output)
         end
 
-        private
-        def method_missing(m, *a, &b)
-          # no-op
-        end
-
-        public
-        def message(message)
-        end
-
-        # The number of the currently running example_group
-        def example_group_number
-          @example_group_number
-        end
-
-        # The number of the currently running example (a global counter)
-        def example_number
-          @example_number
-        end
-
-        def start(example_count)
-          super(example_count)
+        def start(notification)
+          super
           @printer.print_html_start
           @printer.flush
         end
 
-        def example_group_started(example_group)
-          super(example_group)
+        def example_group_started(notification)
+          super
           @example_group_red = false
           @example_group_number += 1
 
           unless example_group_number == 1
             @printer.print_example_group_end
           end
-          @printer.print_example_group_start( example_group_number, example_group.description, example_group.parent_groups.size )
+          @printer.print_example_group_start( example_group_number, notification.group.description, notification.group.parent_groups.size )
           @printer.flush
         end
 
-        def start_dump
+        def start_dump(notification)
           @printer.print_example_group_end
           @printer.flush
         end
 
-        def example_started(example)
-          super(example)
+        def example_started(notification)
           @example_number += 1
         end
 
-        def example_passed(example)
+        def example_passed(passed)
           @printer.move_progress(percent_done)
-          @printer.print_example_passed( example.description, example.execution_result[:run_time] )
+          @printer.print_example_passed( passed.example.description, passed.example.execution_result.run_time )
           @printer.flush
         end
 
-        def example_failed(example)
-          super(example)
-
+        def example_failed(failure)
+          @failed_examples << failure.example
           unless @header_red
             @header_red = true
             @printer.make_header_red
@@ -82,21 +66,23 @@ module RSpec
 
           @printer.move_progress(percent_done)
 
-          exception = example.metadata[:execution_result][:exception]
+          example = failure.example
+
+          exception = failure.exception
           exception_details = if exception
             {
               :message => exception.message,
-              :backtrace => format_backtrace(exception.backtrace, example).join("\n")
+              :backtrace => failure.formatted_backtrace.join("\n")
             }
           else
             false
           end
-          extra = extra_failure_content(exception)
+          extra = extra_failure_content(failure)
 
           @printer.print_example_failed(
-            example.execution_result[:pending_fixed],
+            example.execution_result.pending_fixed,
             example.description,
-            example.execution_result[:run_time],
+            example.execution_result.run_time,
             @failed_examples.size,
             exception_details,
             (extra == "") ? false : extra,
@@ -105,24 +91,36 @@ module RSpec
           @printer.flush
         end
 
-        def example_pending(example)
+        def example_pending(pending)
+          example = pending.example
 
           @printer.make_header_yellow unless @header_red
           @printer.make_example_group_header_yellow(example_group_number) unless @example_group_red
           @printer.move_progress(percent_done)
-          @printer.print_example_pending( example.description, example.metadata[:execution_result][:pending_message] )
+          @printer.print_example_pending( example.description, example.execution_result.pending_message )
           @printer.flush
         end
 
-        # Override this method if you wish to output extra HTML for a failed spec. For example, you
-        # could output links to images or other files produced during the specs.
-        #
-        def extra_failure_content(exception)
-          require 'rspec/core/formatters/snippet_extractor'
-          backtrace = exception.backtrace.map {|line| backtrace_line(line)}
-          backtrace.compact!
-          @snippet_extractor ||= SnippetExtractor.new
-          "    <pre class=\"ruby\"><code>#{@snippet_extractor.snippet(backtrace)}</code></pre>"
+        def dump_summary(summary)
+          @printer.print_summary(
+            summary.duration,
+            summary.example_count,
+            summary.failure_count,
+            summary.pending_count
+          )
+          @printer.flush
+        end
+
+      private
+
+        # The number of the currently running example_group
+        def example_group_number
+          @example_group_number
+        end
+
+        # The number of the currently running example (a global counter)
+        def example_number
+          @example_number
         end
 
         def percent_done
@@ -133,22 +131,17 @@ module RSpec
           result
         end
 
-        def dump_failures
-        end
-
-        def dump_pending
+        # Override this method if you wish to output extra HTML for a failed 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 {|line| RSpec.configuration.backtrace_formatter.backtrace_line(line)}
+          backtrace.compact!
+          @snippet_extractor ||= SnippetExtractor.new
+          "    <pre class=\"ruby\"><code>#{@snippet_extractor.snippet(backtrace)}</code></pre>"
         end
 
-        def dump_summary(duration, example_count, failure_count, pending_count)
-          @printer.print_summary(
-            dry_run?,
-            duration,
-            example_count,
-            failure_count,
-            pending_count
-          )
-          @printer.flush
-        end
       end
     end
   end

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

@@ -3,6 +3,7 @@ require 'erb'
 module RSpec
   module Core
     module Formatters
+      # @private
       class HtmlPrinter
         include ERB::Util # for the #h method
         def initialize(output)
@@ -19,18 +20,18 @@ module RSpec
           @output.puts "</div>"
         end
 
-        def print_example_group_start( group_id, description, number_of_parents  )
+        def print_example_group_start(group_id, description, number_of_parents)
           @output.puts "<div id=\"div_group_#{group_id}\" class=\"example_group passed\">"
           @output.puts "  <dl #{indentation_style(number_of_parents)}>"
           @output.puts "  <dt id=\"example_group_#{group_id}\" class=\"passed\">#{h(description)}</dt>"
         end
 
-        def print_example_passed( description, run_time )
+        def print_example_passed(description, run_time)
           formatted_run_time = sprintf("%.5f", run_time)
           @output.puts "    <dd class=\"example passed\"><span class=\"passed_spec_name\">#{h(description)}</span><span class='duration'>#{formatted_run_time}s</span></dd>"
         end
 
-        def print_example_failed( pending_fixed, description, run_time, failure_id, exception, extra_content, escape_backtrace = false )
+        def print_example_failed(pending_fixed, description, run_time, failure_id, exception, extra_content, escape_backtrace = false)
           formatted_run_time = sprintf("%.5f", run_time)
 
           @output.puts "    <dd class=\"example #{pending_fixed ? 'pending_fixed' : 'failed'}\">"
@@ -50,19 +51,14 @@ module RSpec
           @output.puts "    </dd>"
         end
 
-        def print_example_pending( description, pending_message )
+        def print_example_pending(description, pending_message)
           @output.puts "    <dd class=\"example not_implemented\"><span class=\"not_implemented_spec_name\">#{h(description)} (PENDING: #{h(pending_message)})</span></dd>"
         end
 
-        def print_summary( was_dry_run, duration, example_count, failure_count, pending_count )
-          # TODO - kill dry_run?
-          if was_dry_run
-            totals = "This was a dry-run"
-          else
-            totals =  "#{example_count} example#{'s' unless example_count == 1}, "
-            totals << "#{failure_count} failure#{'s' unless failure_count == 1}"
-            totals << ", #{pending_count} pending" if pending_count > 0
-          end
+        def print_summary(duration, example_count, failure_count, pending_count)
+          totals =  "#{example_count} example#{'s' unless example_count == 1}, "
+          totals << "#{failure_count} failure#{'s' unless failure_count == 1}"
+          totals << ", #{pending_count} pending" if pending_count > 0
 
           formatted_duration = sprintf("%.5f", duration)
 
@@ -78,7 +74,7 @@ module RSpec
           @output.flush
         end
 
-        def move_progress( percent_done )
+        def move_progress(percent_done)
           @output.puts "    <script type=\"text/javascript\">moveProgressBar('#{percent_done}');</script>"
           @output.flush
         end
@@ -101,14 +97,12 @@ module RSpec
           @output.puts "    <script type=\"text/javascript\">makeYellow('example_group_#{group_id}');</script>"
         end
 
+      private
 
-        private
-
-        def indentation_style( number_of_parents )
+        def indentation_style(number_of_parents)
           "style=\"margin-left: #{(number_of_parents - 1) * 15}px;\""
         end
 
-
         REPORT_HEADER = <<-EOF
 <div class="rspec-report">
 

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

@@ -1,11 +1,12 @@
-require 'rspec/core/formatters/base_formatter'
+RSpec::Support.require_rspec_core "formatters/base_formatter"
 require 'json'
 
 module RSpec
   module Core
     module Formatters
-
+      # @private
       class JsonFormatter < BaseFormatter
+        Formatters.register self, :message, :dump_summary, :dump_profile, :stop, :close
 
         attr_reader :output_hash
 
@@ -14,40 +15,23 @@ module RSpec
           @output_hash = {}
         end
 
-        def message(message)
-          (@output_hash[:messages] ||= []) << message
+        def message(notification)
+          (@output_hash[:messages] ||= []) << notification.message
         end
 
-        def dump_summary(duration, example_count, failure_count, pending_count)
-          super(duration, example_count, failure_count, pending_count)
+        def dump_summary(summary)
           @output_hash[:summary] = {
-            :duration => duration,
-            :example_count => example_count,
-            :failure_count => failure_count,
-            :pending_count => pending_count
+            :duration => summary.duration,
+            :example_count => summary.example_count,
+            :failure_count => summary.failure_count,
+            :pending_count => summary.pending_count
           }
-          @output_hash[:summary_line] = summary_line(example_count, failure_count, pending_count)
-        end
-
-        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
+          @output_hash[:summary_line] = summary.totals_line
         end
 
-        def stop
-          super
-          @output_hash[:examples] = examples.map do |example|
-            {
-              :description => example.description,
-              :full_description => example.full_description,
-              :status => example.execution_result[:status],
-              # :example_group,
-              # :execution_result,
-              :file_path => example.metadata[:file_path],
-              :line_number  => example.metadata[:line_number],
-            }.tap do |hash|
+        def stop(notification)
+          @output_hash[:examples] = notification.examples.map do |example|
+            format_example(example).tap do |hash|
               if e=example.exception
                 hash[:exception] =  {
                   :class => e.class.name,
@@ -59,11 +43,50 @@ module RSpec
           end
         end
 
-        def close
+        def close(notification)
           output.write @output_hash.to_json
           output.close if IO === output && output != $stdout
         end
 
+        def dump_profile(profile)
+          @output_hash[:profile] = {}
+          dump_profile_slowest_examples(profile)
+          dump_profile_slowest_example_groups(profile)
+        end
+
+        # @api private
+        def dump_profile_slowest_examples(profile)
+          @output_hash[:profile] = {}
+          sorted_examples = profile.slowest_examples
+          @output_hash[:profile][:examples] = sorted_examples.map do |example|
+            format_example(example).tap do |hash|
+              hash[:run_time] = example.execution_result.run_time
+            end
+          end
+          @output_hash[:profile][:slowest] = profile.slow_duration
+          @output_hash[:profile][:total] = profile.duration
+        end
+
+        # @api private
+        def dump_profile_slowest_example_groups(profile)
+          @output_hash[:profile] ||= {}
+          @output_hash[:profile][:groups] = profile.slowest_groups.map do |loc, hash|
+            hash.update(:location => loc)
+          end
+        end
+
+      private
+
+        def format_example(example)
+          {
+            :description => example.description,
+            :full_description => example.full_description,
+            :status => example.execution_result.status.to_s,
+            :file_path => example.metadata[:file_path],
+            :line_number  => example.metadata[:line_number],
+            :run_time => example.execution_result.run_time
+          }
+        end
       end
     end
   end

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

@@ -0,0 +1,67 @@
+RSpec::Support.require_rspec_core "formatters/console_codes"
+
+module RSpec
+  module Core
+    module Formatters
+
+      # @api private
+      # Formatter for providing profile output
+      class ProfileFormatter
+        Formatters.register self, :dump_profile
+
+        def initialize(output)
+          @output = output
+        end
+
+        # @private
+        attr_reader :output
+
+        # @method dump_profile
+        # @api public
+        #
+        # This method is invoked after the dumping the summary if profiling is
+        # enabled.
+        #
+        # @param profile [ProfileNotification] containing duration, slowest_examples
+        #                                      and slowest_example_groups
+        def dump_profile(profile)
+          dump_profile_slowest_examples(profile)
+          dump_profile_slowest_example_groups(profile)
+        end
+
+      private
+
+        def dump_profile_slowest_examples(profile)
+          @output.puts "\nTop #{profile.slowest_examples.size} slowest examples (#{Helpers.format_seconds(profile.slow_duration)} seconds, #{profile.percentage}% of total time):\n"
+
+          profile.slowest_examples.each do |example|
+            @output.puts "  #{example.full_description}"
+            @output.puts "    #{bold(Helpers.format_seconds(example.execution_result.run_time))} #{bold("seconds")} #{format_caller(example.location)}"
+          end
+        end
+
+        def dump_profile_slowest_example_groups(profile)
+          return if profile.slowest_groups.empty?
+
+          @output.puts "\nTop #{profile.slowest_groups.size} slowest example groups:"
+          profile.slowest_groups.each do |loc, hash|
+            average = "#{bold(Helpers.format_seconds(hash[:average]))} #{bold("seconds")} average"
+            total   = "#{Helpers.format_seconds(hash[:total_time])} seconds"
+            count   = Helpers.pluralize(hash[:count], "example")
+            @output.puts "  #{hash[:description]}"
+            @output.puts "    #{average} (#{total} / #{count}) #{loc}"
+          end
+        end
+
+        def format_caller(caller_info)
+          RSpec.configuration.backtrace_formatter.backtrace_line(caller_info.to_s.split(':in `block').first)
+        end
+
+        def bold(text)
+          ConsoleCodes.wrap(text, :bold)
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,32 +1,28 @@
-require 'rspec/core/formatters/base_text_formatter'
+RSpec::Support.require_rspec_core "formatters/base_text_formatter"
+
 module RSpec
   module Core
     module Formatters
-
+      # @private
       class ProgressFormatter < BaseTextFormatter
+        Formatters.register self, :example_passed, :example_pending, :example_failed, :start_dump
 
-        def example_passed(example)
-          super(example)
-          output.print success_color('.')
+        def example_passed(notification)
+          output.print ConsoleCodes.wrap('.', :success)
         end
 
-        def example_pending(example)
-          super(example)
-          output.print pending_color('*')
+        def example_pending(notification)
+          output.print ConsoleCodes.wrap('*', :pending)
         end
 
-        def example_failed(example)
-          super(example)
-          output.print failure_color('F')
+        def example_failed(notification)
+          output.print ConsoleCodes.wrap('F', :failure)
         end
 
-        def start_dump
-          super()
+        def start_dump(notification)
           output.puts
         end
-
       end
-
     end
   end
 end