minitest 5.26.0 → 6.0.1

data/lib/minitest/sprint.rb

@@ -0,0 +1,104 @@
+$LOAD_PATH.unshift "test", "lib"
+
+require "simplecov" if ENV["MT_COV"] || ARGV.delete("--simplecov")
+require_relative "autorun"
+require_relative "path_expander"
+
+##
+# Runs (Get it? It's fast!) your tests and makes it easier to rerun individual
+# failures.
+
+module Minitest
+  class Sprint
+    # extracted version = "1.5.0"
+
+    ##
+    # Process and run minitest cmdline.
+
+    def self.run args = ARGV
+      if ARGV.delete("--bisect") or ARGV.delete("-b") then
+        require_relative "bisect"
+
+        return Minitest::Bisect.run ARGV
+      end
+
+      Minitest::PathExpander.new(args).process { |f|
+        require "./#{f}" if File.file? f
+      }
+    end
+
+    ##
+    # An extra minitest reporter to output how to rerun failures in
+    # various styles.
+
+    class SprintReporter < AbstractReporter
+      ##
+      # The style to report, either lines or regexp. Defaults to lines.
+      attr_accessor :style
+      attr_accessor :results # :nodoc:
+
+      def initialize style = :regexp # :nodoc:
+        self.results = []
+        self.style = style
+      end
+
+      def record result # :nodoc:
+        results << result unless result.passed? or result.skipped?
+      end
+
+      def report # :nodoc:
+        return if results.empty?
+
+        puts
+        puts "Happy Happy Sprint List:"
+        puts
+        print_list
+        puts
+      end
+
+      def print_list # :nodoc:
+        case style
+        when :regexp
+          results.each do |result|
+            puts "  minitest -n #{result.class_name}##{result.name}"
+          end
+        when :lines
+          files = Hash.new { |h,k| h[k] = [] }
+          results.each do |result|
+            path, line = result.source_location
+            path = path.delete_prefix "#{Dir.pwd}/"
+            files[path] << line
+          end
+
+          files.sort.each do |path, lines|
+            puts "  minitest %s:%s" % [path, lines.sort.join(",")]
+          end
+        else
+          raise "unsupported style: %p" % [style]
+        end
+      end
+    end
+
+    ##
+    # An extra minitest reporter to output how to rerun failures using
+    # rake.
+
+    class RakeReporter < SprintReporter
+      ##
+      # The name of the rake task to rerun. Defaults to nil.
+
+      attr_accessor :name
+
+      def initialize name = nil # :nodoc:
+        super()
+        self.name    = name
+      end
+
+      def print_list # :nodoc:
+        results.each do |result|
+          puts ["  rake", name, "N=#{result.class_name}##{result.name}"].compact.join(" ")
+        end
+      end
+    end
+  end
+end

data/lib/minitest/sprint_plugin.rb

@@ -0,0 +1,39 @@
+require_relative "../minitest"
+
+# :stopdoc:
+class OptionParser # unofficial embedded gem "makeoptparseworkwell"
+  def hidden(...)         = define(...).tap { |sw| def sw.summarize(*) = nil }
+  def deprecate(from, to) = hidden(from) { abort "#{from} is deprecated. Use #{to}." }
+  def topdict(name)       = name.length > 1 ? top.long : top.short
+  def alias(from, to)     = (dict = topdict(from) and dict[to] = dict[from])
+end unless OptionParser.method_defined? :hidden
+# :startdoc:
+
+module Minitest # :nodoc:
+  def self.plugin_sprint_options opts, options # :nodoc:
+    opts.on "--rake [TASK]", "Report how to re-run failures with rake." do |task|
+      options[:sprint] = :rake
+      options[:rake_task] = task
+    end
+
+    opts.deprecate "--binstub", "--rerun"
+
+    sprint_styles = %w[rake lines names binstub]
+
+    opts.on "-r", "--rerun [STYLE]", sprint_styles, "Report how to re-run failures using STYLE (names, lines)." do |style|
+      options[:sprint] = (style || :lines).to_sym
+    end
+  end
+
+  def self.plugin_sprint_init options
+    require_relative "sprint"
+    case options[:sprint]
+    when :rake then
+      self.reporter << Minitest::Sprint::RakeReporter.new(options[:rake_task])
+    when :binstub, :names then
+      self.reporter << Minitest::Sprint::SprintReporter.new
+    when :lines then
+      self.reporter << Minitest::Sprint::SprintReporter.new(:lines)
+    end
+  end
+end

data/lib/minitest/test.rb

@@ -1,4 +1,4 @@
-require "minitest" unless defined? Minitest::Runnable
+require_relative "../minitest" unless defined? Minitest::Runnable
 
 module Minitest
   ##
@@ -8,14 +8,10 @@ module Minitest
   # See Minitest::Assertions
 
   class Test < Runnable
-    require "minitest/assertions"
+    require_relative "assertions"
     include Minitest::Reportable
     include Minitest::Assertions
 
-    def class_name # :nodoc:
-      self.class.name # for Minitest::Reportable
-    end
-
     PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException, SystemExit] # :nodoc:
 
     SETUP_METHODS = %w[ before_setup setup after_setup ] # :nodoc:
@@ -34,8 +30,8 @@ module Minitest
 
     def self.i_suck_and_my_tests_are_order_dependent!
       class << self
-        undef_method :test_order if method_defined? :test_order
-        define_method :test_order do :alpha end
+        undef_method :run_order if method_defined? :run_order
+        define_method :run_order do :alpha end
       end
     end
 
@@ -65,20 +61,20 @@ module Minitest
 
     ##
     # Returns all instance methods starting with "test_". Based on
-    # #test_order, the methods are either sorted, randomized
+    # #run_order, the methods are either sorted, randomized
     # (default), or run in parallel.
 
     def self.runnable_methods
       methods = methods_matching(/^test_/)
 
-      case self.test_order
+      case self.run_order
       when :random, :parallel then
         srand Minitest.seed
         methods.sort.shuffle
       when :alpha, :sorted then
         methods.sort
       else
-        raise "Unknown test_order: #{self.test_order.inspect}"
+        raise "Unknown_order: %p" % [self.run_order]
       end
     end
 
@@ -234,5 +230,3 @@ module Minitest
     extend Guard
   end # Test
 end
-
-require "minitest/unit" if ENV["MT_COMPAT"] # compatibility layer only

data/lib/minitest/test_task.rb

@@ -168,20 +168,18 @@ module Minitest # :nodoc:
         ENV["TESTOPTS"]
       warn "FILTER is deprecated in Minitest::TestTask. Use A instead" if
         ENV["FILTER"]
-      warn "N is deprecated in Minitest::TestTask. Use MT_CPU instead" if
-        ENV["N"] && ENV["N"].to_i > 0
 
       lib_extras = (ENV["MT_LIB_EXTRAS"] || "").split File::PATH_SEPARATOR
       self.libs[0, 0] = lib_extras
 
-      extra_args << "-n" << ENV["N"]                      if ENV["N"]
-      extra_args << "-e" << ENV["X"]                      if ENV["X"]
+      extra_args << "-i" << ENV["N"]                      if ENV["N"]
+      extra_args << "-i" << ENV["I"]                      if ENV["I"]
+      extra_args << "-x" << ENV["X"]                      if ENV["X"]
+      extra_args << "-x" << ENV["E"]                      if ENV["E"]
       extra_args.concat Shellwords.split(ENV["TESTOPTS"]) if ENV["TESTOPTS"]
       extra_args.concat Shellwords.split(ENV["FILTER"])   if ENV["FILTER"]
       extra_args.concat Shellwords.split(ENV["A"])        if ENV["A"]
 
-      ENV.delete "N" if ENV["N"]
-
       # TODO? RUBY_DEBUG = ENV["RUBY_DEBUG"]
       # TODO? ENV["RUBY_FLAGS"]
 
@@ -189,11 +187,16 @@ module Minitest # :nodoc:
     end
 
     def define # :nodoc:
-      desc "Run the test suite. Use N, X, A, and TESTOPTS to add flags/args."
+      desc "Run the test suite. Use I, X, and A to add flags/args."
       task name do
         ruby make_test_cmd, verbose: verbose
       end
 
+      desc "Run the test suite, filtering for 'FU' in name (focused units?)."
+      task "#{name}:fu" do
+        ruby make_test_cmd(include:"/FU/"), verbose: verbose
+      end
+
       desc "Print out the test command. Good for profiling and other tools."
       task "#{name}:cmd" do
         puts "ruby #{make_test_cmd}"
@@ -212,7 +215,7 @@ module Minitest # :nodoc:
 
         n.threads_do tests.sort do |path|
           t0 = Time.now
-          output = `#{Gem.ruby} #{make_test_cmd path} 2>&1`
+          output = `#{Gem.ruby} #{make_test_cmd path:path} 2>&1`
           t1 = Time.now - t0
 
           times[path] = t1
@@ -278,7 +281,9 @@ module Minitest # :nodoc:
     ##
     # Generate the test command-line.
 
-    def make_test_cmd globs = test_globs
+    def make_test_cmd **option
+      globs = option[:path] || test_globs
+
       tests = []
       tests.concat Dir[*globs].sort.shuffle # TODO: SEED -> srand first?
       tests.map! { |f| %(require "#{f}") }
@@ -289,6 +294,8 @@ module Minitest # :nodoc:
       runner.concat tests
       runner = runner.join "; "
 
+      extra_args << "-i" << option[:include] if option[:include]
+
       args  = []
       args << "-I#{libs.join File::PATH_SEPARATOR}" unless libs.empty?
       args << "-w" if warning
@@ -303,13 +310,8 @@ module Minitest # :nodoc:
 end
 
 class Work < Queue # :nodoc:
-  def initialize jobs = [] # :nodoc:
-    super()
-
-    jobs.each do |job|
-      self << job
-    end
-
+  def initialize jobs # :nodoc:
+    super
     close
   end
 end