minitest 5.23.1 → 5.25.4

data/lib/minitest.rb

@@ -6,10 +6,11 @@ require_relative "minitest/parallel"
 require_relative "minitest/compress"
 
 ##
-# :include: README.rdoc
+# The top-level namespace for Minitest. Also the location of the main
+# runtime. See +Minitest.run+ for more information.
 
 module Minitest
-  VERSION = "5.23.1" # :nodoc:
+  VERSION = "5.25.4" # :nodoc:
 
   @@installed_at_exit ||= false
   @@after_run = []
@@ -67,9 +68,8 @@ module Minitest
   # Registers Minitest to run at process exit
 
   def self.autorun
-    if Object.const_defined?(:Warning) && Warning.respond_to?(:[]=)
-      Warning[:deprecated] = true
-    end
+    Warning[:deprecated] = true if
+      Object.const_defined?(:Warning) && Warning.respond_to?(:[]=)
 
     at_exit {
       next if $! and not ($!.kind_of? SystemExit and $!.success?)
@@ -98,20 +98,19 @@ module Minitest
     @@after_run << block
   end
 
-  def self.init_plugins options # :nodoc:
-    self.extensions.each do |name|
-      msg = "plugin_#{name}_init"
-      send msg, options if self.respond_to? msg
-    end
+  ##
+  # Register a plugin to be used. Does NOT require / load it.
+
+  def self.register_plugin name_or_mod
+    self.extensions << name_or_mod
+    nil
   end
 
   def self.load_plugins # :nodoc:
-    return unless self.extensions.empty?
+    return unless defined? Gem
 
     seen = {}
 
-    require "rubygems" unless defined? Gem
-
     Gem.find_files("minitest/*_plugin.rb").each do |plugin_path|
       name = File.basename plugin_path, "_plugin.rb"
 
@@ -123,93 +122,27 @@ module Minitest
     end
   end
 
-  ##
-  # This is the top-level run method. Everything starts from here. It
-  # tells each Runnable sub-class to run, and each of those are
-  # responsible for doing whatever they do.
-  #
-  # The overall structure of a run looks like this:
-  #
-  #   Minitest.autorun
-  #     Minitest.run(args)
-  #       Minitest.__run(reporter, options)
-  #         Runnable.runnables.each
-  #           runnable_klass.run(reporter, options)
-  #             self.runnable_methods.each
-  #               self.run_one_method(self, runnable_method, reporter)
-  #                 Minitest.run_one_method(klass, runnable_method)
-  #                   klass.new(runnable_method).run
-
-  def self.run args = []
-    self.load_plugins unless args.delete("--no-plugins") || ENV["MT_NO_PLUGINS"]
-
-    options = process_args args
-
-    Minitest.seed = options[:seed]
-    srand Minitest.seed
-
-    reporter = CompositeReporter.new
-    reporter << SummaryReporter.new(options[:io], options)
-    reporter << ProgressReporter.new(options[:io], options) unless options[:quiet]
-
-    self.reporter = reporter # this makes it available to plugins
-    self.init_plugins options
-    self.reporter = nil # runnables shouldn't depend on the reporter, ever
-
-    self.parallel_executor.start if parallel_executor.respond_to?(:start)
-    reporter.start
-    begin
-      __run reporter, options
-    rescue Interrupt
-      warn "Interrupted. Exiting..."
+  def self.init_plugins options # :nodoc:
+    self.extensions.each do |mod_or_meth|
+      case mod_or_meth
+      when Symbol, String then
+        name = mod_or_meth
+        msg = "plugin_#{name}_init"
+        next unless self.respond_to? msg
+        send msg, options
+      when Module then
+        recv = mod_or_meth
+        next unless recv.respond_to? :minitest_plugin_init
+        recv.minitest_plugin_init options
+      else
+        raise ArgumentError, "plugin is %p, but it must be a symbol, string or module" % [mod_or_meth]
+      end
     end
-    self.parallel_executor.shutdown
-
-    # might have been removed/replaced during init_plugins:
-    summary = reporter.reporters.grep(SummaryReporter).first
-
-    reporter.report
-
-    return empty_run! options if summary && summary.count == 0
-    reporter.passed?
-  end
-
-  def self.empty_run! options # :nodoc:
-    filter = options[:filter]
-    return true unless filter # no filter, but nothing ran == success
-
-    warn "Nothing ran for filter: %s" % [filter]
-
-    require "did_you_mean" # soft dependency, punt if it doesn't load
-
-    ms = Runnable.runnables.flat_map(&:runnable_methods)
-    cs = DidYouMean::SpellChecker.new(dictionary: ms).correct filter
-
-    warn DidYouMean::Formatter.message_for cs unless cs.empty?
-  rescue LoadError
-    # do nothing
-  end
-
-  ##
-  # Internal run method. Responsible for telling all Runnable
-  # sub-classes to run.
-
-  def self.__run reporter, options
-    suites = Runnable.runnables.shuffle
-    parallel, serial = suites.partition { |s| s.test_order == :parallel }
-
-    # If we run the parallel tests before the serial tests, the parallel tests
-    # could run in parallel with the serial tests. This would be bad because
-    # the serial tests won't lock around Reporter#record. Run the serial tests
-    # first, so that after they complete, the parallel tests will lock when
-    # recording results.
-    serial.map { |suite| suite.run reporter, options } +
-      parallel.map { |suite| suite.run reporter, options }
   end
 
   def self.process_args args = [] # :nodoc:
     options = {
-               :io => $stdout,
+                :io => $stdout,
               }
     orig_args = args.dup
 
@@ -253,7 +186,7 @@ module Minitest
         options[:skip] = s.chars.to_a
       end
 
-      ruby27plus = ::Warning.respond_to?(:[]=)
+      ruby27plus = ::Warning.respond_to? :[]=
 
       opts.on "-W[error]", String, "Turn Ruby warnings into errors" do |s|
         options[:Werror] = true
@@ -269,11 +202,21 @@ module Minitest
 
       unless extensions.empty?
         opts.separator ""
-        opts.separator "Known extensions: #{extensions.join(", ")}"
-
-        extensions.each do |meth|
-          msg = "plugin_#{meth}_options"
-          send msg, opts, options if self.respond_to?(msg)
+        opts.separator "Known extensions: #{extensions.join ", "}"
+
+        extensions.each do |mod_or_meth|
+          case mod_or_meth
+          when Symbol, String then
+            meth = mod_or_meth
+            msg = "plugin_#{meth}_options"
+            send msg, opts, options if respond_to? msg
+          when Module
+            recv = mod_or_meth
+            next unless recv.respond_to? :minitest_plugin_options
+            recv.minitest_plugin_options opts, options
+          else
+            raise ArgumentError, "plugin is %p, but it must be a symbol, string or module" % [mod_or_meth]
+          end
         end
       end
 
@@ -297,12 +240,99 @@ module Minitest
     end
 
     options[:args] = orig_args.map { |s|
-      s =~ /[\s|&<>$()]/ ? s.inspect : s
+      s.match?(/[\s|&<>$()]/) ? s.inspect : s
     }.join " "
 
     options
   end
 
+  ##
+  # This is the top-level run method. Everything starts from here. It
+  # tells each Runnable sub-class to run, and each of those are
+  # responsible for doing whatever they do.
+  #
+  # The overall structure of a run looks like this:
+  #
+  #   Minitest.autorun
+  #     Minitest.run(args)
+  #       Minitest.load_plugins
+  #       Minitest.process_args
+  #       Minitest.init_plugins
+  #       Minitest.__run(reporter, options)
+  #         Runnable.runnables.each
+  #           runnable_klass.run(reporter, options)
+  #             self.runnable_methods.each
+  #               self.run_one_method(self, runnable_method, reporter)
+  #                 Minitest.run_one_method(klass, runnable_method)
+  #                   klass.new(runnable_method).run
+
+  def self.run args = []
+    self.load_plugins unless args.delete("--no-plugins") || ENV["MT_NO_PLUGINS"]
+
+    options = process_args args
+
+    Minitest.seed = options[:seed]
+    srand Minitest.seed
+
+    reporter = CompositeReporter.new
+    reporter << SummaryReporter.new(options[:io], options)
+    reporter << ProgressReporter.new(options[:io], options) unless options[:quiet]
+
+    self.reporter = reporter # this makes it available to plugins
+    self.init_plugins options
+    self.reporter = nil # runnables shouldn't depend on the reporter, ever
+
+    self.parallel_executor.start if parallel_executor.respond_to? :start
+    reporter.start
+    begin
+      __run reporter, options
+    rescue Interrupt
+      warn "Interrupted. Exiting..."
+    end
+    self.parallel_executor.shutdown
+
+    # might have been removed/replaced during init_plugins:
+    summary = reporter.reporters.grep(SummaryReporter).first
+
+    reporter.report
+
+    return empty_run! options if summary && summary.count == 0
+    reporter.passed?
+  end
+
+  def self.empty_run! options # :nodoc:
+    filter = options[:filter]
+    return true unless filter # no filter, but nothing ran == success
+
+    warn "Nothing ran for filter: %s" % [filter]
+
+    require "did_you_mean" # soft dependency, punt if it doesn't load
+
+    ms = Runnable.runnables.flat_map(&:runnable_methods)
+    cs = DidYouMean::SpellChecker.new(dictionary: ms).correct filter
+
+    warn DidYouMean::Formatter.message_for cs unless cs.empty?
+  rescue LoadError
+    # do nothing
+  end
+
+  ##
+  # Internal run method. Responsible for telling all Runnable
+  # sub-classes to run.
+
+  def self.__run reporter, options
+    suites = Runnable.runnables.shuffle
+    parallel, serial = suites.partition { |s| s.test_order == :parallel }
+
+    # If we run the parallel tests before the serial tests, the parallel tests
+    # could run in parallel with the serial tests. This would be bad because
+    # the serial tests won't lock around Reporter#record. Run the serial tests
+    # first, so that after they complete, the parallel tests will lock when
+    # recording results.
+    serial.map { |suite| suite.run reporter, options } +
+      parallel.map { |suite| suite.run reporter, options }
+  end
+
   def self.filter_backtrace bt # :nodoc:
     result = backtrace_filter.filter bt
     result = bt.dup if result.empty?
@@ -376,8 +406,8 @@ module Minitest
       pos = options[:filter]
       neg = options[:exclude]
 
-      pos = Regexp.new $1 if pos.is_a?(String) && pos =~ %r%/(.*)/%
-      neg = Regexp.new $1 if neg.is_a?(String) && neg =~ %r%/(.*)/%
+      pos = Regexp.new $1 if pos.kind_of?(String) && pos =~ %r%/(.*)/%
+      neg = Regexp.new $1 if neg.kind_of?(String) && neg =~ %r%/(.*)/%
 
       filtered_methods = self.runnable_methods
         .select { |m| !pos ||  pos === m || pos === "#{self}##{m}"  }
@@ -385,8 +415,22 @@ module Minitest
 
       return if filtered_methods.empty?
 
+      t0 = name = nil
+
+      @_info_handler = lambda do
+        unless reporter.passed? then
+          warn "Current results:"
+          warn reporter.reporters.grep(SummaryReporter).first
+        end
+
+        warn "Current: %s#%s %.2fs" % [self, name, Minitest.clock_time - t0]
+      end
+
       with_info_handler reporter do
         filtered_methods.each do |method_name|
+          name = method_name
+          t0 = Minitest.clock_time
+
           run_one_method self, method_name, reporter
         end
       end
@@ -412,16 +456,7 @@ module Minitest
     end
 
     def self.with_info_handler reporter, &block # :nodoc:
-      handler = lambda do
-        unless reporter.passed? then
-          warn "Current results:"
-          warn ""
-          warn reporter.reporters.first
-          warn ""
-        end
-      end
-
-      on_signal ::Minitest.info_signal, handler, &block
+      on_signal ::Minitest.info_signal, @_info_handler, &block
     end
 
     SIGNALS = Signal.list # :nodoc:
@@ -459,7 +494,7 @@ module Minitest
     def marshal_dump # :nodoc:
       unless @@marshal_dump_warned then
         warn ["Minitest::Runnable#marshal_dump is deprecated.",
-              "You might be violating internals. From", caller.first].join " "
+              "You might be violating internals. From", caller(1..1).first].join " "
         @@marshal_dump_warned = true
       end
 
@@ -587,7 +622,7 @@ module Minitest
     # Did this run error?
 
     def error?
-      self.failures.any? { |f| UnexpectedError === f }
+      self.failures.any? UnexpectedError
     end
   end
 
@@ -690,7 +725,7 @@ module Minitest
       true
     end
 
-    def synchronize(&block) # :nodoc:
+    def synchronize &block # :nodoc:
       @mutex.synchronize(&block)
     end
   end
@@ -722,11 +757,11 @@ module Minitest
   # own.
 
   class ProgressReporter < Reporter
-    def prerecord klass, name #:nodoc:
-      if options[:verbose] then
-        io.print "%s#%s = " % [klass.name, name]
-        io.flush
-      end
+    def prerecord klass, name # :nodoc:
+      return unless options[:verbose]
+
+      io.print "%s#%s = " % [klass.name, name]
+      io.flush
     end
 
     def record result # :nodoc:
@@ -860,10 +895,8 @@ module Minitest
   # own.
 
   class SummaryReporter < StatisticsReporter
-    # :stopdoc:
-    attr_accessor :sync
-    attr_accessor :old_sync
-    # :startdoc:
+    attr_accessor :sync     # :nodoc:
+    attr_accessor :old_sync # :nodoc:
 
     def start # :nodoc:
       super
@@ -911,20 +944,22 @@ module Minitest
     end
 
     def to_s # :nodoc:
-      aggregated_results(StringIO.new(''.b)).string
+      aggregated_results(StringIO.new("".b)).string
     end
 
     def summary # :nodoc:
-      extra = ""
+      extra = []
 
-      extra = "\n\nYou have skipped tests. Run with --verbose for details." if
-        results.any?(&:skipped?) unless
-        options[:verbose] or options[:show_skips] or ENV["MT_NO_SKIP_MSG"]
+      extra << ", %d warnings" % [warnings] if options[:Werror]
 
-      extra.prepend ", %d warnings" % [warnings] if options[:Werror]
+      extra << "\n\nYou have skipped tests. Run with --verbose for details." if
+        results.any?(&:skipped?) unless
+        options[:verbose]        or
+        options[:show_skips]     or
+        ENV["MT_NO_SKIP_MSG"]
 
       "%d runs, %d assertions, %d failures, %d errors, %d skips%s" %
-        [count, assertions, failures, errors, skips, extra]
+        [count, assertions, failures, errors, skips, extra.join]
     end
   end
 
@@ -1095,7 +1130,7 @@ module Minitest
 
     def maglev? platform = defined?(RUBY_ENGINE) && RUBY_ENGINE
       where = Minitest.filter_backtrace(caller).first
-      where = where.split(/:in /, 2).first # clean up noise
+      where = where.split(":in ", 2).first # clean up noise
       warn "DEPRECATED: `maglev?` called from #{where}. This will fail in Minitest 6."
       "maglev" == platform
     end
@@ -1104,14 +1139,14 @@ module Minitest
     # Is this running on mri?
 
     def mri? platform = RUBY_DESCRIPTION
-      /^ruby/ =~ platform
+      platform.start_with? "ruby"
     end
 
     ##
     # Is this running on macOS?
 
     def osx? platform = RUBY_PLATFORM
-      /darwin/ =~ platform
+      platform.include? "darwin"
     end
 
     ##
@@ -1119,7 +1154,7 @@ module Minitest
 
     def rubinius? platform = defined?(RUBY_ENGINE) && RUBY_ENGINE
       where = Minitest.filter_backtrace(caller).first
-      where = where.split(/:in /, 2).first # clean up noise
+      where = where.split(":in ", 2).first # clean up noise
       warn "DEPRECATED: `rubinius?` called from #{where}. This will fail in Minitest 6."
       "rbx" == platform
     end
@@ -1128,7 +1163,7 @@ module Minitest
     # Is this running on windows?
 
     def windows? platform = RUBY_PLATFORM
-      /mswin|mingw/ =~ platform
+      /mswin|mingw/.match? platform
     end
   end
 
@@ -1139,11 +1174,14 @@ module Minitest
 
   class BacktraceFilter
 
-    MT_RE = %r%lib/minitest|internal:warning% #:nodoc:
+    MT_RE = %r%lib/minitest|internal:warning% # :nodoc:
+
+    ##
+    # The regular expression to use to filter backtraces. Defaults to +MT_RE+.
 
     attr_accessor :regexp
 
-    def initialize regexp = MT_RE
+    def initialize regexp = MT_RE # :nodoc:
       self.regexp = regexp
     end
 
@@ -1156,9 +1194,9 @@ module Minitest
 
       return bt.dup if $DEBUG || ENV["MT_DEBUG"]
 
-      new_bt = bt.take_while { |line| line.to_s !~ regexp }
-      new_bt = bt.select     { |line| line.to_s !~ regexp } if new_bt.empty?
-      new_bt = bt.dup                                       if new_bt.empty?
+      new_bt = bt.take_while { |line| !regexp.match? line.to_s }
+      new_bt = bt.select     { |line| !regexp.match? line.to_s } if new_bt.empty?
+      new_bt = bt.dup                                            if new_bt.empty?
 
       new_bt
     end

data/test/minitest/metametameta.rb

@@ -3,10 +3,6 @@ require "stringio"
 require "minitest/autorun"
 
 class Minitest::Test
-  def clean s
-    s.gsub(/^ {6}/, "")
-  end
-
   def with_empty_backtrace_filter
     with_backtrace_filter Minitest::BacktraceFilter.new %r%.% do
       yield
@@ -31,6 +27,7 @@ class Minitest::Test
   end
 
   def assert_deprecation re = /DEPRECATED/
+    re = // if $-w.nil? # "skip" if running `rake testW0`
     assert_output "", re do
       yield
     end
@@ -67,7 +64,7 @@ class MetaMetaMetaTestCase < Minitest::Test
   def run_tu_with_fresh_reporter flags = %w[--seed 42]
     options = Minitest.process_args flags
 
-    @output = StringIO.new("".encode(Encoding::UTF_8))
+    @output = StringIO.new(+"")
 
     self.reporter = Minitest::CompositeReporter.new
     reporter << Minitest::SummaryReporter.new(@output, options)
@@ -76,7 +73,7 @@ class MetaMetaMetaTestCase < Minitest::Test
     with_stderr @output do
       reporter.start
 
-      yield(reporter) if block_given?
+      yield reporter if block_given?
 
       @tus ||= [@tu]
       @tus.each do |tu|
@@ -94,8 +91,8 @@ class MetaMetaMetaTestCase < Minitest::Test
   end
 
   def assert_report expected, flags = %w[--seed 42], &block
-    header = clean <<-EOM
-      Run options: #{flags.map { |s| s =~ /\|/ ? s.inspect : s }.join " "}
+    header = <<~EOM
+      Run options: #{flags.map { |s| s.include?("|") ? s.inspect : s }.join " "}
 
       # Running:
 
@@ -130,7 +127,7 @@ class MetaMetaMetaTestCase < Minitest::Test
     output.gsub!(/in [`']block in (?:([^']+)[#.])?/, "in 'block in")
     output.gsub!(/in [`'](?:([^']+)[#.])?/, "in '")
 
-    output.gsub!(/( at )[^:]+:\d+/) { "#{$1}[#{file[$2]}:LINE]" } # eval?
+    output.gsub!(/( at )([^:]+):\d+/) { "#{$1}[#{file[$2]}:LINE]" } # eval?
 
     output
   end