opal-rspec 0.4.3 → 0.5.0.beta1

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

@@ -0,0 +1,68 @@
+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
+          @group_level = 0
+        end
+
+        def example_group_started(notification)
+          output.puts if @group_level == 0
+          output.puts "#{current_indentation}#{notification.group.description.strip}"
+
+          @group_level += 1
+        end
+
+        def example_group_finished(_notification)
+          @group_level -= 1
+        end
+
+        def example_passed(passed)
+          output.puts passed_output(passed.example)
+        end
+
+        def example_pending(pending)
+          output.puts pending_output(pending.example, pending.example.execution_result.pending_message)
+        end
+
+        def example_failed(failure)
+          output.puts failure_output(failure.example, failure.example.execution_result.exception)
+        end
+
+      private
+
+        def passed_output(example)
+          ConsoleCodes.wrap("#{current_indentation}#{example.description.strip}", :success)
+        end
+
+        def pending_output(example, message)
+          ConsoleCodes.wrap("#{current_indentation}#{example.description.strip} (PENDING: #{message})", :pending)
+        end
+
+        def failure_output(example, _exception)
+          ConsoleCodes.wrap("#{current_indentation}#{example.description.strip} (FAILED - #{next_failure_index})", :failure)
+        end
+
+        def next_failure_index
+          @next_failure_index ||= 0
+          @next_failure_index += 1
+        end
+
+        def current_indentation
+          '  ' * @group_level
+        end
+
+        def example_group_chain
+          example_group.parent_groups.reverse
+        end
+      end
+    end
+  end
+end

data/{vendor_lib → rspec-core/lib}/rspec/core/formatters/helpers.rb

@@ -1,25 +1,29 @@
 module RSpec
   module Core
     module Formatters
+      # Formatters helpers
       module Helpers
+        # @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
-                      when duration < 300;  1
+                      when duration < 1 then    SUB_SECOND_PRECISION
+                      when duration < 120 then  DEFAULT_PRECISION
+                      when duration < 300 then  1
                       else                  0
                       end
 
@@ -38,7 +42,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
@@ -49,9 +53,9 @@ 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)
+          formatted = "%.#{precision}f" % float
           strip_trailing_zeroes(formatted)
         end
 
@@ -59,21 +63,22 @@ 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

data/{vendor_lib → rspec-core/lib}/rspec/core/formatters/html_formatter.rb

@@ -1,75 +1,57 @@
-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_end unless example_group_number == 1
+          @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 +64,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")
-            }
-          else
-            false
-          end
-          extra = extra_failure_content(exception)
+                                {
+                                  :message => exception.message,
+                                  :backtrace => failure.formatted_backtrace.join("\n")
+                                }
+                              else
+                                false
+                              end
+          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,25 +89,41 @@ 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| configuration.backtrace_formatter.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
+
+        # If these methods are declared with attr_reader Ruby will issue a warning because they are private
+        # rubocop:disable Style/TrivialAccessors
+
+        # 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
+        # rubocop:enable Style/TrivialAccessors
 
         def percent_done
           result = 100.0
@@ -133,21 +133,15 @@ module RSpec
           result
         end
 
-        def dump_failures
-        end
-
-        def dump_pending
-        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
+        # 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
       end
     end

data/{vendor_lib → rspec-core/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,19 +20,21 @@ 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 )
-          formatted_run_time = sprintf("%.5f", run_time)
+        def print_example_passed(description, run_time)
+          formatted_run_time = "%.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 )
-          formatted_run_time = sprintf("%.5f", run_time)
+        # rubocop:disable Style/ParameterLists
+        def print_example_failed(pending_fixed, description, run_time, failure_id, exception, extra_content, escape_backtrace=false)
+          # rubocop:enable Style/ParameterLists
+          formatted_run_time = "%.5f" % run_time
 
           @output.puts "    <dd class=\"example #{pending_fixed ? 'pending_fixed' : 'failed'}\">"
           @output.puts "      <span class=\"failed_spec_name\">#{h(description)}</span>"
@@ -50,21 +53,16 @@ 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)
+          formatted_duration = "%.5f" % duration
 
           @output.puts "<script type=\"text/javascript\">document.getElementById('duration').innerHTML = \"Finished in <strong>#{formatted_duration} seconds</strong>\";</script>"
           @output.puts "<script type=\"text/javascript\">document.getElementById('totals').innerHTML = \"#{totals}\";</script>"
@@ -78,7 +76,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 +99,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">
 
@@ -401,7 +397,6 @@ EOF
 </head>
 <body>
 EOF
-
       end
     end
   end

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

@@ -0,0 +1,94 @@
+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
+
+        def initialize(output)
+          super
+          @output_hash = {}
+        end
+
+        def message(notification)
+          (@output_hash[:messages] ||= []) << notification.message
+        end
+
+        def dump_summary(summary)
+          @output_hash[:summary] = {
+            :duration => summary.duration,
+            :example_count => summary.example_count,
+            :failure_count => summary.failure_count,
+            :pending_count => summary.pending_count
+          }
+          @output_hash[:summary_line] = summary.totals_line
+        end
+
+        def stop(notification)
+          @output_hash[:examples] = notification.examples.map do |example|
+            format_example(example).tap do |hash|
+              e = example.exception
+              if e
+                hash[:exception] =  {
+                  :class => e.class.name,
+                  :message => e.message,
+                  :backtrace => e.backtrace,
+                }
+              end
+            end
+          end
+        end
+
+        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
+end

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

@@ -0,0 +1,65 @@
+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/rspec-core/lib/rspec/core/formatters/progress_formatter.rb

@@ -0,0 +1,28 @@
+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(_notification)
+          output.print ConsoleCodes.wrap('.', :success)
+        end
+
+        def example_pending(_notification)
+          output.print ConsoleCodes.wrap('*', :pending)
+        end
+
+        def example_failed(_notification)
+          output.print ConsoleCodes.wrap('F', :failure)
+        end
+
+        def start_dump(_notification)
+          output.puts
+        end
+      end
+    end
+  end
+end