minitest 5.23.1 → 5.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eea239479abe950b2b6ac7881a88c73088fd9efc7dcddd5f54ceb7717830e7d7
-  data.tar.gz: 645ac4943b4bb6d1a4cca710d10bfe6d6526ce78a99d5393aae1a91152a0bded
+  metadata.gz: ddd0fe4703c1bc82b9c33eb3dca089b234e123893d379dc940791e2cbd74802f
+  data.tar.gz: cfdfd1306481c0ea6ed54f03952205f4ceb9c41d2a901640f599c453eec39e39
 SHA512:
-  metadata.gz: 6eb63425f42af466e8d839fa5de4f4dc57da32bc2a6798d40421ac99cc41b9c782a3fa7e91113463de0a261d1af6e8ddf2d3316fba5a141413f15b7fd4aedf73
-  data.tar.gz: 8c60d2666e50e2c683b9f32363702ba5b529c7170b9c3d32df077fbc912430e6de76b1cc3f0fcdb72d03d0abaa75cda2b90c742ed9937115d7416008e45a45f1
+  metadata.gz: cde9b530576ab5a9fccf75e7ed171768b83ef8ad833a6de3a69384c3da219642b93ab0d6e00e2c13d5cf7a0a0ee7d85ce291523cc50ee9908c2d37454a654598
+  data.tar.gz: 5d9432e383458f01530a68e1b6d6e6531bb85ff772335e5fdb15646d8cd880429c5ed6965c9c8e879399628395d1557f67893dc39236874e2c24c2782f954fb3

data/History.rdoc

@@ -1,3 +1,14 @@
+=== 5.24.0 / 2024-06-18
+
+* 2 minor enhancements:
+
+  * Added Minitest.register_plugin.
+  * Extended plugin system to work with modules/classes for opt-out plugins.
+
+* 1 bug fix:
+
+  * Removed anacronism, but allow load_plugins to exit gracefully if --disable=gems.
+
 === 5.23.1 / 2024-05-21
 
 * 1 bug fix:

data/lib/minitest/autorun.rb

@@ -1,10 +1,3 @@
-begin
-  require "rubygems"
-  gem "minitest"
-rescue Gem::LoadError
-  # do nothing
-end
-
 require "minitest"
 require "minitest/spec"
 require "minitest/mock"

data/lib/minitest/test_task.rb

@@ -1,6 +1,12 @@
 require "shellwords"
 require "rbconfig"
-require "rake/tasklib"
+
+begin
+  require "rake/tasklib"
+rescue LoadError => e
+  warn e.message
+  return
+end
 
 module Minitest # :nodoc:
 

data/lib/minitest.rb

@@ -9,7 +9,7 @@ require_relative "minitest/compress"
 # :include: README.rdoc
 
 module Minitest
-  VERSION = "5.23.1" # :nodoc:
+  VERSION = "5.24.0" # :nodoc:
 
   @@installed_at_exit ||= false
   @@after_run = []
@@ -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,88 +122,22 @@ 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, "blahblah %p" % [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:
@@ -271,9 +204,19 @@ module Minitest
         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)
+        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, "blahblah %p" % [mod_or_meth]
+          end
         end
       end
 
@@ -303,6 +246,93 @@ module Minitest
     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?

data/test/minitest/test_minitest_assertions.rb

@@ -957,8 +957,8 @@ class TestMinitestAssertions < Minitest::Test
       @tc.assert_same 1, 2
     end
 
-    s1 = "blah"
-    s2 = "blah"
+    s1 = +"blah"
+    s2 = +"blah"
 
     assert_triggered 'Expected "blah" (oid=N) to be the same as "blah" (oid=N).' do
       @tc.assert_same s1, s2

data/test/minitest/test_minitest_test_task.rb

@@ -1,5 +1,11 @@
 require "minitest/autorun"
-require "hoe"
+
+begin
+  require "hoe"
+rescue LoadError => e
+  warn e.message
+  return
+end
 
 require "minitest/test_task"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minitest
 version: !ruby/object:Gem::Version
-  version: 5.23.1
+  version: 5.24.0
 platform: ruby
 authors:
 - Ryan Davis
@@ -29,7 +29,7 @@ cert_chain:
   S7043fq9EbQdBr2AXdj92+CDwuTfHI6/Hj5FVBDULufrJaan4xUgL70Hvc6pTTeW
   deKfBjgVAq7EYHu1AczzlUly
   -----END CERTIFICATE-----
-date: 2024-05-22 00:00:00.000000000 Z
+date: 2024-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -187,7 +187,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: minitest provides a complete suite of testing facilities supporting TDD,