opal-rspec 0.8.0 → 1.0.0.alpha1

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

@@ -0,0 +1,157 @@
+RSpec::Support.require_rspec_core "formatters/base_text_formatter"
+
+module RSpec
+  module Core
+    module Formatters
+      # @private
+      # Produces progress output while bisecting.
+      class BisectProgressFormatter < BaseTextFormatter
+        def initialize(output, bisect_runner)
+          super(output)
+          @bisect_runner = bisect_runner
+        end
+
+        def bisect_starting(notification)
+          @round_count = 0
+          output.puts bisect_started_message(notification)
+          output.print "Running suite to find failures..."
+        end
+
+        def bisect_original_run_complete(notification)
+          failures     = Helpers.pluralize(notification.failed_example_ids.size, "failing example")
+          non_failures = Helpers.pluralize(notification.non_failing_example_ids.size, "non-failing example")
+
+          output.puts " (#{Helpers.format_duration(notification.duration)})"
+          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(s) do not require any non-failures to run first"
+
+          if @bisect_runner == :fork
+            output.puts
+            output.puts "=" * 80
+            output.puts "NOTE: this bisect run used `config.bisect_runner = :fork`, which generally"
+            output.puts "provides significantly faster bisection runs than the old shell-based runner,"
+            output.puts "but may inaccurately report that no non-failures are required. If this result"
+            output.puts "is unexpected, consider setting `config.bisect_runner = :shell` and trying again."
+            output.puts "=" * 80
+          end
+        end
+
+        def bisect_round_started(notification, include_trailing_space=true)
+          @round_count += 1
+          range_desc = notification.candidate_range.description
+
+          output.print "\nRound #{@round_count}: bisecting over non-failing #{range_desc}"
+          output.print " " if include_trailing_space
+        end
+
+        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
+
+        def bisect_individual_run_complete(_)
+          output.print '.'
+        end
+
+        def bisect_complete(notification)
+          output.puts "\nBisect complete! Reduced necessary non-failing examples " \
+                      "from #{notification.original_non_failing_count} to " \
+                      "#{notification.remaining_count} in " \
+                      "#{Helpers.format_duration(notification.duration)}."
+        end
+
+        def bisect_repro_command(notification)
+          output.puts "\nThe minimal reproduction command is:\n  #{notification.repro}"
+        end
+
+        def bisect_failed(notification)
+          output.puts "\nBisect failed! #{notification.failure_explanation}"
+        end
+
+        def bisect_aborted(notification)
+          output.puts "\n\nBisect aborted!"
+          output.puts "\nThe most minimal reproduction command discovered so far is:\n  #{notification.repro}"
+        end
+
+      private
+
+        def bisect_started_message(notification)
+          options = notification.original_cli_args.join(' ')
+          "Bisect started using options: #{options.inspect}"
+        end
+      end
+
+      # @private
+      # Produces detailed debug output while bisecting. Used when bisect is
+      # performed with `--bisect=verbose`. Designed to provide details for
+      # us when we need to troubleshoot bisect bugs.
+      class BisectDebugFormatter < BisectProgressFormatter
+        def bisect_original_run_complete(notification)
+          output.puts " (#{Helpers.format_duration(notification.duration)})"
+
+          output.puts " - #{describe_ids 'Failing examples', notification.failed_example_ids}"
+          output.puts " - #{describe_ids 'Non-failing examples', notification.non_failing_example_ids}"
+        end
+
+        def bisect_individual_run_start(notification)
+          output.print "\n - Running: #{notification.command}"
+        end
+
+        def bisect_individual_run_complete(notification)
+          output.print " (#{Helpers.format_duration(notification.duration)})"
+        end
+
+        def bisect_dependency_check_passed(_notification)
+          output.print "\n - Failure appears to be order-dependent"
+        end
+
+        def bisect_dependency_check_failed(_notification)
+          output.print "\n - Failure is not order-dependent"
+        end
+
+        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)
+          organized_ids = Formatters::Helpers.organize_ids(ids)
+          formatted_ids = organized_ids.map { |id| "    - #{id}" }.join("\n")
+          "#{description} (#{ids.size}):\n#{formatted_ids}"
+        end
+
+        def bisect_started_message(notification)
+          "#{super} and bisect runner: #{notification.bisect_runner.inspect}"
+        end
+      end
+    end
+  end
+end

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

@@ -7,29 +7,46 @@ module RSpec
         # @private
         VT100_CODES =
           {
-            :black   => 30,
-            :red     => 31,
-            :green   => 32,
-            :yellow  => 33,
-            :blue    => 34,
-            :magenta => 35,
-            :cyan    => 36,
-            :white   => 37,
-            :bold    => 1,
+            :black         => 30,
+            :red           => 31,
+            :green         => 32,
+            :yellow        => 33,
+            :blue          => 34,
+            :magenta       => 35,
+            :cyan          => 36,
+            :white         => 37,
+            :bold_black   => '1;30',
+            :bold_red     => '1;31',
+            :bold_green   => '1;32',
+            :bold_yellow  => '1;33',
+            :bold_blue    => '1;34',
+            :bold_magenta => '1;35',
+            :bold_cyan    => '1;36',
+            :bold_white   => '1;37',
+            :bold          => 1,
           }
         # @private
         VT100_CODE_VALUES = VT100_CODES.invert
 
         module_function
 
+        # @private
+        def config_colors_to_methods
+          @config_colors_to_methods ||=
+            Configuration.instance_methods.grep(/_color\z/).inject({}) do |hash, method|
+              hash[method.to_s.sub(/_color\z/, '').to_sym] = method
+              hash
+            end
+        end
+
         # Fetches the correct code for the supplied symbol, or checks
         # that a code is valid. Defaults to white (37).
         #
         # @param code_or_symbol [Symbol, Fixnum] Symbol or code to check
         # @return [Fixnum] a console code
         def console_code_for(code_or_symbol)
-          if RSpec.configuration.respond_to?(:"#{code_or_symbol}_color")
-            console_code_for configuration_color(code_or_symbol)
+          if (config_method = config_colors_to_methods[code_or_symbol])
+            console_code_for RSpec.configuration.__send__(config_method)
           elsif VT100_CODE_VALUES.key?(code_or_symbol)
             code_or_symbol
           else
@@ -53,11 +70,6 @@ module RSpec
             text
           end
         end
-
-        # @private
-        def configuration_color(code)
-          RSpec.configuration.__send__(:"#{code}_color")
-        end
       end
     end
   end

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

@@ -1,5 +1,4 @@
 RSpec::Support.require_rspec_core "formatters/helpers"
-require 'set'
 
 module RSpec
   module Core
@@ -21,7 +20,8 @@ module RSpec
         def printer
           @printer ||= case deprecation_stream
                        when File
-                         ImmediatePrinter.new(FileStream.new(deprecation_stream), summary_stream, self)
+                         ImmediatePrinter.new(FileStream.new(deprecation_stream),
+                                              summary_stream, self)
                        when RaiseErrorStream
                          ImmediatePrinter.new(deprecation_stream, summary_stream, self)
                        else
@@ -59,7 +59,10 @@ module RSpec
 
         DEPRECATION_STREAM_NOTICE = "Pass `--deprecation-out` or set " \
           "`config.deprecation_stream` to a file for full output."
+        TOO_MANY_WARNINGS_NOTICE  = "Too many similar deprecation messages " \
+          "reported, disregarding further reports. #{DEPRECATION_STREAM_NOTICE}"
 
+        # @private
         SpecifiedDeprecationMessage = Struct.new(:type) do
           def initialize(data)
             @message = data.message
@@ -71,16 +74,14 @@ module RSpec
           end
 
           def too_many_warnings_message
-            msg = "Too many similar deprecation messages reported, disregarding further reports. "
-            msg << DEPRECATION_STREAM_NOTICE
-            msg
+            TOO_MANY_WARNINGS_NOTICE
           end
 
           private
 
           def output_formatted(str)
             return str unless str.lines.count > 1
-            separator = "#{'-' * 80}"
+            separator = '-' * 80
             "#{separator}\n#{str.chomp}\n#{separator}"
           end
 
@@ -89,6 +90,7 @@ module RSpec
           end
         end
 
+        # @private
         GeneratedDeprecationMessage = Struct.new(:type) do
           def initialize(data)
             @data = data
@@ -96,16 +98,14 @@ module RSpec
           end
 
           def to_s
-            msg =  "#{@data.deprecated} is deprecated."
+            msg = String.new("#{@data.deprecated} is deprecated.")
             msg << " Use #{@data.replacement} instead." if @data.replacement
-            msg << " Called from #{@data.call_site}." if @data.call_site
+            msg << " Called from #{@data.call_site}."   if @data.call_site
             msg
           end
 
           def too_many_warnings_message
-            msg = "Too many uses of deprecated '#{type}'. "
-            msg << DEPRECATION_STREAM_NOTICE
-            msg
+            "Too many uses of deprecated '#{type}'. #{DEPRECATION_STREAM_NOTICE}"
           end
         end
 
@@ -209,14 +209,15 @@ module RSpec
           end
 
           def summarize(summary_stream, deprecation_count)
-            summary_stream.puts "\n#{Helpers.pluralize(deprecation_count, 'deprecation')} logged to #{@file.path}"
+            path = @file.respond_to?(:path) ? @file.path : @file.inspect
+            summary_stream.puts "\n#{Helpers.pluralize(deprecation_count, 'deprecation')} logged to #{path}"
             puts RAISE_ERROR_CONFIG_NOTICE
           end
         end
       end
     end
 
-    # Deprecation Error
+    # Deprecation Error.
     DeprecationError = Class.new(StandardError)
   end
 end

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

@@ -1,16 +1,24 @@
 RSpec::Support.require_rspec_core "formatters/base_text_formatter"
+RSpec::Support.require_rspec_core "formatters/console_codes"
 
 module RSpec
   module Core
     module Formatters
       # @private
       class DocumentationFormatter < BaseTextFormatter
-        Formatters.register self, :example_group_started, :example_group_finished,
+        Formatters.register self, :example_started, :example_group_started, :example_group_finished,
                             :example_passed, :example_pending, :example_failed
 
         def initialize(output)
           super
           @group_level = 0
+
+          @example_running = false
+          @messages = []
+        end
+
+        def example_started(_notification)
+          @example_running = true
         end
 
         def example_group_started(notification)
@@ -21,33 +29,63 @@ module RSpec
         end
 
         def example_group_finished(_notification)
-          @group_level -= 1
+          @group_level -= 1 if @group_level > 0
         end
 
         def example_passed(passed)
           output.puts passed_output(passed.example)
+
+          flush_messages
+          @example_running = false
         end
 
         def example_pending(pending)
-          output.puts pending_output(pending.example, pending.example.execution_result.pending_message)
+          output.puts pending_output(pending.example,
+                                     pending.example.execution_result.pending_message)
+
+          flush_messages
+          @example_running = false
         end
 
         def example_failed(failure)
-          output.puts failure_output(failure.example, failure.example.execution_result.exception)
+          output.puts failure_output(failure.example)
+
+          flush_messages
+          @example_running = false
+        end
+
+        def message(notification)
+          if @example_running
+            @messages << notification.message
+          else
+            output.puts "#{current_indentation}#{notification.message}"
+          end
         end
 
       private
 
+        def flush_messages
+          @messages.each do |message|
+            output.puts "#{current_indentation(1)}#{message}"
+          end
+
+          @messages.clear
+        end
+
         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)
+          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)
+        def failure_output(example)
+          ConsoleCodes.wrap("#{current_indentation}#{example.description.strip} " \
+                            "(FAILED - #{next_failure_index})",
+                            :failure)
         end
 
         def next_failure_index
@@ -55,12 +93,8 @@ module RSpec
           @next_failure_index += 1
         end
 
-        def current_indentation
-          '  ' * @group_level
-        end
-
-        def example_group_chain
-          example_group.parent_groups.reverse
+        def current_indentation(offset=0)
+          '  ' * (@group_level + offset)
         end
       end
     end