rspec-core 3.8.2

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

@@ -0,0 +1,29 @@
+require 'drb/drb'
+RSpec::Support.require_rspec_core "formatters/base_bisect_formatter"
+
+module RSpec
+  module Core
+    module Formatters
+      # Used by `--bisect`. When it shells out and runs a portion of the suite, it uses
+      # this formatter as a means to have the status reported back to it, via DRb.
+      #
+      # Note that since DRb calls carry considerable overhead compared to normal
+      # method calls, we try to minimize the number of DRb calls for perf reasons,
+      # opting to communicate only at the start and the end of the run, rather than
+      # after each example.
+      # @private
+      class BisectDRbFormatter < BaseBisectFormatter
+        def initialize(_output)
+          drb_uri = "druby://localhost:#{RSpec.configuration.drb_port}"
+          @bisect_server = DRbObject.new_with_uri(drb_uri)
+          RSpec.configuration.files_or_directories_to_run = @bisect_server.files_or_directories_to_run
+          super(Set.new(@bisect_server.expected_failures))
+        end
+
+        def notify_results(results)
+          @bisect_server.latest_run_results = results
+        end
+      end
+    end
+  end
+end

data/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/lib/rspec/core/formatters/console_codes.rb

@@ -0,0 +1,68 @@
+module RSpec
+  module Core
+    module Formatters
+      # ConsoleCodes provides helpers for formatting console output
+      # with ANSI codes, e.g. color's and bold.
+      module ConsoleCodes
+        # @private
+        VT100_CODES =
+          {
+            :black   => 30,
+            :red     => 31,
+            :green   => 32,
+            :yellow  => 33,
+            :blue    => 34,
+            :magenta => 35,
+            :cyan    => 36,
+            :white   => 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 (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
+            VT100_CODES.fetch(code_or_symbol) do
+              console_code_for(:white)
+            end
+          end
+        end
+
+        # Wraps a piece of text in ANSI codes with the supplied code. Will
+        # only apply the control code if `RSpec.configuration.color_enabled?`
+        # returns true.
+        #
+        # @param text [String] the text to wrap
+        # @param code_or_symbol [Symbol, Fixnum] the desired control code
+        # @return [String] the wrapped text
+        def wrap(text, code_or_symbol)
+          if RSpec.configuration.color_enabled?
+            "\e[#{console_code_for(code_or_symbol)}m#{text}\e[0m"
+          else
+            text
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,223 @@
+RSpec::Support.require_rspec_core "formatters/helpers"
+
+module RSpec
+  module Core
+    module Formatters
+      # @private
+      class DeprecationFormatter
+        Formatters.register self, :deprecation, :deprecation_summary
+
+        attr_reader :count, :deprecation_stream, :summary_stream
+
+        def initialize(deprecation_stream, summary_stream)
+          @deprecation_stream = deprecation_stream
+          @summary_stream = summary_stream
+          @seen_deprecations = Set.new
+          @count = 0
+        end
+        alias :output :deprecation_stream
+
+        def printer
+          @printer ||= case deprecation_stream
+                       when File
+                         ImmediatePrinter.new(FileStream.new(deprecation_stream),
+                                              summary_stream, self)
+                       when RaiseErrorStream
+                         ImmediatePrinter.new(deprecation_stream, summary_stream, self)
+                       else
+                         DelayedPrinter.new(deprecation_stream, summary_stream, self)
+                       end
+        end
+
+        def deprecation(notification)
+          return if @seen_deprecations.include? notification
+
+          @count += 1
+          printer.print_deprecation_message notification
+          @seen_deprecations << notification
+        end
+
+        def deprecation_summary(_notification)
+          printer.deprecation_summary
+        end
+
+        def deprecation_message_for(data)
+          if data.message
+            SpecifiedDeprecationMessage.new(data)
+          else
+            GeneratedDeprecationMessage.new(data)
+          end
+        end
+
+        RAISE_ERROR_CONFIG_NOTICE = <<-EOS.gsub(/^\s+\|/, '')
+          |
+          |If you need more of the backtrace for any of these deprecations to
+          |identify where to make the necessary changes, you can configure
+          |`config.raise_errors_for_deprecations!`, and it will turn the
+          |deprecation warnings into errors, giving you the full backtrace.
+        EOS
+
+        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
+            super deprecation_type_for(data)
+          end
+
+          def to_s
+            output_formatted @message
+          end
+
+          def too_many_warnings_message
+            TOO_MANY_WARNINGS_NOTICE
+          end
+
+          private
+
+          def output_formatted(str)
+            return str unless str.lines.count > 1
+            separator = '-' * 80
+            "#{separator}\n#{str.chomp}\n#{separator}"
+          end
+
+          def deprecation_type_for(data)
+            data.message.gsub(/(\w+\/)+\w+\.rb:\d+/, '')
+          end
+        end
+
+        # @private
+        GeneratedDeprecationMessage = Struct.new(:type) do
+          def initialize(data)
+            @data = data
+            super data.deprecated
+          end
+
+          def to_s
+            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
+          end
+
+          def too_many_warnings_message
+            "Too many uses of deprecated '#{type}'. #{DEPRECATION_STREAM_NOTICE}"
+          end
+        end
+
+        # @private
+        class ImmediatePrinter
+          attr_reader :deprecation_stream, :summary_stream, :deprecation_formatter
+
+          def initialize(deprecation_stream, summary_stream, deprecation_formatter)
+            @deprecation_stream = deprecation_stream
+
+            @summary_stream = summary_stream
+            @deprecation_formatter = deprecation_formatter
+          end
+
+          def print_deprecation_message(data)
+            deprecation_message = deprecation_formatter.deprecation_message_for(data)
+            deprecation_stream.puts deprecation_message.to_s
+          end
+
+          def deprecation_summary
+            return if deprecation_formatter.count.zero?
+            deprecation_stream.summarize(summary_stream, deprecation_formatter.count)
+          end
+        end
+
+        # @private
+        class DelayedPrinter
+          TOO_MANY_USES_LIMIT = 4
+
+          attr_reader :deprecation_stream, :summary_stream, :deprecation_formatter
+
+          def initialize(deprecation_stream, summary_stream, deprecation_formatter)
+            @deprecation_stream = deprecation_stream
+            @summary_stream = summary_stream
+            @deprecation_formatter = deprecation_formatter
+            @seen_deprecations = Hash.new { 0 }
+            @deprecation_messages = Hash.new { |h, k| h[k] = [] }
+          end
+
+          def print_deprecation_message(data)
+            deprecation_message = deprecation_formatter.deprecation_message_for(data)
+            @seen_deprecations[deprecation_message] += 1
+
+            stash_deprecation_message(deprecation_message)
+          end
+
+          def stash_deprecation_message(deprecation_message)
+            if @seen_deprecations[deprecation_message] < TOO_MANY_USES_LIMIT
+              @deprecation_messages[deprecation_message] << deprecation_message.to_s
+            elsif @seen_deprecations[deprecation_message] == TOO_MANY_USES_LIMIT
+              @deprecation_messages[deprecation_message] << deprecation_message.too_many_warnings_message
+            end
+          end
+
+          def deprecation_summary
+            return unless @deprecation_messages.any?
+
+            print_deferred_deprecation_warnings
+            deprecation_stream.puts RAISE_ERROR_CONFIG_NOTICE
+
+            summary_stream.puts "\n#{Helpers.pluralize(deprecation_formatter.count, 'deprecation warning')} total"
+          end
+
+          def print_deferred_deprecation_warnings
+            deprecation_stream.puts "\nDeprecation Warnings:\n\n"
+            @deprecation_messages.keys.sort_by(&:type).each do |deprecation|
+              messages = @deprecation_messages[deprecation]
+              messages.each { |msg| deprecation_stream.puts msg }
+              deprecation_stream.puts
+            end
+          end
+        end
+
+        # @private
+        # Not really a stream, but is usable in place of one.
+        class RaiseErrorStream
+          def puts(message)
+            raise DeprecationError, message
+          end
+
+          def summarize(summary_stream, deprecation_count)
+            summary_stream.puts "\n#{Helpers.pluralize(deprecation_count, 'deprecation')} found."
+          end
+        end
+
+        # @private
+        # Wraps a File object and provides file-specific operations.
+        class FileStream
+          def initialize(file)
+            @file = file
+
+            # In one of my test suites, I got lots of duplicate output in the
+            # deprecation file (e.g. 200 of the same deprecation, even though
+            # the `puts` below was only called 6 times). Setting `sync = true`
+            # fixes this (but we really have no idea why!).
+            @file.sync = true
+          end
+
+          def puts(*args)
+            @file.puts(*args)
+          end
+
+          def summarize(summary_stream, deprecation_count)
+            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.
+    DeprecationError = Class.new(StandardError)
+  end
+end