minitest-sprint 1.4.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 790ead66e6245fe36749169e3a015e45f2b2f66e47570fbfd993de93cbe94708
-  data.tar.gz: 880f3206df70fb0c7f2e2a4823148604adb74c3a58d04309f3b777461d9cf148
+  metadata.gz: 8b1b68075882de07be85d45f66148b077be1e1935c8b26164525e0b3ea009d3f
+  data.tar.gz: 47effadd6a826ff5f967cc90d9944822483e815ee1ba54d5ab1e9284cdefab8e
 SHA512:
-  metadata.gz: 85a0f778582781cb98443b46a2c8ce888611e60244e53ccb84c1d96ff1b5adc3f47070446bcc3f12771ce1db3aaa869dd8ab29876737f3f4ce099c0a1b8156b9
-  data.tar.gz: f816258ddc6450ca21b2f47fbefc1d117543ec4a8e670d5a336acfe93792e8089922641ecbf6d05692fe7224fa75460383a9ece1dc9531faf546851b2cbbc9eb
+  metadata.gz: f1a813c462dca3ec94100802a686ac7db6dd475b0512012ab7bf81e87bca09876479c50eae3a7eef9c420771939f0291ed70a8def6d365097d97c62fd0982961
+  data.tar.gz: 715a332cdcb91d0029ae00d7841468bf580842e485075380e82ed87533eacee3261da25f78c3c07dce2509827ece43f7aabda07763ff9ff57410bc4d08a9df6f

data/History.rdoc

@@ -1,3 +1,25 @@
+=== 1.5.0 / 2025-12-11
+
+* 10 minor enhancements:
+
+  * --rerun now takes a style (lines, names) and defaults to lines.
+  * Add --simplecov (and MT_COV=1) option to load before minitest.
+  * Added all the filtering options to minitest/complete.
+  * Folded BinstubReporter into SprintReporter and added line number reporting.
+  * Folded rake_reporter.rb and sprint_reporter.rb into sprint.rb
+  * Normalized namespacing inside of Minitest::Sprint
+  * Renamed --binstub to --rerun and added -r shortcut.
+  * Switched minitest/complete to prism. Should be much more solid.
+  * Vendored latest version of path_expander.
+  * Updated Minitest::VendoredPathExpander to 2.0.0 and cleaned up overrides.
+
+* 4 bug fixes:
+
+  * -I flag now prepends onto load path.
+  * Fixed minitest cmdline to use require_relative to test against current version.
+  * Made RakeReporter play better with superclass.
+  * Prepend test and lib onto load path before loading minitest.
+
 === 1.4.1 / 2025-11-18
 
 * 1 bug fix:

data/Manifest.txt

@@ -4,11 +4,8 @@ Manifest.txt
 README.rdoc
 Rakefile
 bin/minitest
-lib/minitest/binstub_reporter.rb
 lib/minitest/complete.rb
 lib/minitest/path_expander.rb
-lib/minitest/rake_reporter.rb
 lib/minitest/sprint.rb
 lib/minitest/sprint_plugin.rb
-lib/minitest/sprint_reporter.rb
 test/test_minitest_sprint.rb

data/README.rdoc

@@ -41,7 +41,7 @@ failures.
 
 Add this to your .bashrc (or .zshrc?--someone please confirm with a PR):
 
-  $ complete -o bashdefault -f -C 'ruby --disable-gems $(gem which minitest/complete)' minitest
+  $ complete -o bashdefault -f -C 'ruby $(gem which minitest/complete)' minitest
 
 Running individual minitest tests will now have tab completion for the
 method names. When running tests, just hit tab after -n. For example:

data/Rakefile

@@ -13,7 +13,6 @@ Hoe.spec "minitest-sprint" do
 
   require_ruby_version ">= 3.2"
 
-  dependency "path_expander", "~> 1.1"
   dependency "prism",         "~> 1.5"
 end
 

data/bin/minitest

@@ -1,5 +1,5 @@
 #!/usr/bin/env -S ruby
 
-require "minitest/sprint"
+require_relative "../lib/minitest/sprint"
 
 Minitest::Sprint.run

data/lib/minitest/complete.rb

@@ -1,35 +1,56 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env -S ruby
 
-# see instructions in the readme for use
+# :stopdoc:
 
-require 'optparse'
-require 'shellwords'
+require "optparse"
+require "shellwords"
 
-argv = Shellwords.split(ENV['COMP_LINE']).drop 1
-options = {}
+# complete -o bashdefault -f -C 'ruby lib/minitest/complete.rb' minitest
+# using eg:
+#    COMP_LINE="blah test/test_file.rb -n test_pattern"
+# or test directly with:
+#    ./lib/minitest/complete.rb test/test_file.rb -n test_pattern
+
+argv = Shellwords.split ENV["COMP_LINE"] || ARGV.join(" ")
+comp_re = nil
 
 begin
   OptionParser.new do |opts|
-    opts.on("-n", "--name [METHOD]", "Test method") do |m|
-      options[:method] = m
+    # part of my unofficial embedded gem "makeoptparseworkwell"
+    def opts.topdict(name)   = (name.length > 1 ? top.long : top.short)
+    def opts.alias(from, to) = (dict = topdict(from) ; dict[to] = dict[from])
+
+    opts.on "-n", "--name [METHOD]", "minitest option" do |m|
+      comp_re = Regexp.new m
     end
-  end.parse!(argv)
+
+    opts.alias "name", "include"
+    opts.alias "name", "exclude"
+    opts.alias "n",    "i"
+    opts.alias "n",    "e"
+    opts.alias "n",    "x"
+  end.parse! argv
 rescue
   retry # ignore options passed to Ruby
 end
 
-file = argv.find { |f| File.file?(f) && !File.directory?(f) }
+path = argv.find_all { |f| File.file? f }.last
 
-exit unless options.key?(:method) && file
+exit unless comp_re && path
 
-require 'ripper'
+require "prism"
 
-methods = []
-K = Class.new(Ripper) { define_method(:on_def) { |n,_,_| methods << n } }
+names, queue = [], [Prism.parse_file(path).value]
 
-begin
-  K.parse File.read(file), file, 1
-  methods = methods.grep(/^#{options[:method]}/) if options[:method]
-  puts methods.join("\n")
-rescue # give up on parse errors
+while node = queue.shift do
+  if node.type == :def_node then
+    name = node.name
+    names << name if name =~ comp_re
+  else
+    queue.concat node.compact_child_nodes # no need to process def body
+  end
 end
+
+puts names.sort
+
+# :startdoc:

data/lib/minitest/path_expander.rb

@@ -1,13 +1,228 @@
-require "path_expander"
 require "prism"
 
 module Minitest; end # :nodoc:
 
+##
+# PathExpander helps pre-process command-line arguments expanding
+# directories into their constituent files. It further helps by
+# providing additional mechanisms to make specifying subsets easier
+# with path subtraction and allowing for command-line arguments to be
+# saved in a file.
+#
+# NOTE: this is NOT an options processor. It is a path processor
+# (basically everything else besides options). It does provide a
+# mechanism for pre-filtering cmdline options, but not with the intent
+# of actually processing them in PathExpander. Use OptionParser to
+# deal with options either before or after passing ARGV through
+# PathExpander.
+
+class Minitest::VendoredPathExpander
+  # extracted version = "2.0.0"
+
+  ##
+  # The args array to process.
+
+  attr_accessor :args
+
+  ##
+  # The glob used to expand dirs to files.
+
+  attr_accessor :glob
+
+  ##
+  # The path to scan if no paths are found in the initial scan.
+
+  attr_accessor :path
+
+  ##
+  # Create a new path expander that operates on args and expands via
+  # glob as necessary. Takes an optional +path+ arg to fall back on if
+  # no paths are found on the initial scan (see #process_args).
+
+  def initialize args, glob, path = "."
+    self.args = args
+    self.glob = glob
+    self.path = path
+  end
+
+  ##
+  # Takes an array of paths and returns an array of paths where all
+  # directories are expanded to all files found via the glob provided
+  # to PathExpander.
+  #
+  # Paths are normalized to not have a leading "./".
+
+  def expand_dirs_to_files *dirs
+    dirs.flatten.map { |p|
+      if File.directory? p then
+        Dir[File.join(p, glob)].find_all { |f| File.file? f }
+      else
+        p
+      end
+    }.flatten.sort.map { |s| s.to_s.delete_prefix "./" }
+  end
+
+  ##
+  # Process a file into more arguments. Override this to add
+  # additional capabilities.
+
+  def process_file path
+    File.readlines(path).map(&:chomp)
+  end
+
+  ##
+  # Enumerate over args passed to PathExpander and return a list of
+  # files and flags to process. Arguments are processed as:
+  #
+  # @file_of_args :: Read the file and append to args.
+  # -file_path    :: Subtract path from file to be processed.
+  # -dir_path     :: Expand and subtract paths from files to be processed.
+  # -not_a_path   :: Add to flags to be processed.
+  # dir_path      :: Expand and add to files to be processed.
+  # file_path     :: Add to files to be processed.
+  # -             :: Add "-" (stdin) to files to be processed.
+  #
+  # See expand_dirs_to_files for details on how expansion occurs.
+  #
+  # Subtraction happens last, regardless of argument ordering.
+  #
+  # If no files are found (which is not the same as having an empty
+  # file list after subtraction), then fall back to expanding on the
+  # default #path given to initialize.
+
+  def process_args
+    pos_files = []
+    neg_files = []
+    flags     = []
+    clean     = true
+
+    args.each do |arg|
+      case arg
+      when /^@(.*)/ then # push back on, so they can have dirs/-/@ as well
+        clean = false
+        args.concat process_file $1
+      when "-" then
+        pos_files << arg
+      when /^-(.*)/ then
+        if File.exist? $1 then
+          clean = false
+          neg_files += expand_dirs_to_files($1)
+        else
+          flags << arg
+        end
+      else
+        root_path = File.expand_path(arg) == "/" # eg: -n /./
+        if File.exist? arg and not root_path then
+          clean = false
+          pos_files += expand_dirs_to_files(arg)
+        else
+          flags << arg
+        end
+      end
+    end
+
+    files = pos_files - neg_files
+    files += expand_dirs_to_files(self.path) if files.empty? && clean
+
+    [files, flags]
+  end
+
+  ##
+  # Process over flags and treat any special ones here. Returns an
+  # array of the flags you haven't processed.
+  #
+  # This version does nothing. Subclass and override for
+  # customization.
+
+  def process_flags flags
+    flags
+  end
+
+  ##
+  # Top-level method processes args. If no block is given, immediately
+  # returns with an Enumerator for further chaining.
+  #
+  # Otherwise, it calls +pre_process+, +process_args+ and
+  # +process_flags+, enumerates over the files, and then calls
+  # +post_process+, returning self for any further chaining.
+  #
+  # Most of the time, you're going to provide a block to process files
+  # and do nothing more with the result. Eg:
+  #
+  #     PathExpander.new(ARGV).process do |f|
+  #       puts "./#{f}"
+  #     end
+  #
+  # or:
+  #
+  #     PathExpander.new(ARGV).process # => Enumerator
+
+  def process(&b)
+    return enum_for(:process) unless block_given?
+
+    pre_process
+
+    files, flags = process_args
+
+    args.replace process_flags flags
+
+    files.uniq.each(&b)
+
+    post_process
+
+    self
+  end
+
+  def pre_process = nil
+  def post_process = nil
+
+  ##
+  # A file filter mechanism similar to, but not as extensive as,
+  # .gitignore files:
+  #
+  # + If a pattern does not contain a slash, it is treated as a shell glob.
+  # + If a pattern ends in a slash, it matches on directories (and contents).
+  # + Otherwise, it matches on relative paths.
+  #
+  # File.fnmatch is used throughout, so glob patterns work for all 3 types.
+  #
+  # Takes a list of +files+ and either an io or path of +ignore+ data
+  # and returns a list of files left after filtering.
+
+  def filter_files files, ignore
+    ignore_paths = if ignore.respond_to? :read then
+                     ignore.read
+                   elsif File.exist? ignore then
+                     File.read ignore
+                   end
+
+    if ignore_paths then
+      nonglobs, globs = ignore_paths.split("\n").partition { |p| p.include? "/" }
+      dirs, ifiles    = nonglobs.partition { |p| p.end_with? "/" }
+      dirs            = dirs.map { |s| s.chomp "/" }
+
+      dirs.map!   { |i| File.expand_path i }
+      globs.map!  { |i| File.expand_path i }
+      ifiles.map! { |i| File.expand_path i }
+
+      only_paths = File::FNM_PATHNAME
+      files = files.reject { |f|
+        f = File.expand_path(f)
+        dirs.any?     { |i| File.fnmatch?(i, File.dirname(f), only_paths) } ||
+          globs.any?  { |i| File.fnmatch?(i, f) } ||
+          ifiles.any? { |i| File.fnmatch?(i, f, only_paths) }
+      }
+    end
+
+    files
+  end
+end # VendoredPathExpander
+
 ##
 # Minitest's PathExpander to find and filter tests.
 
-class Minitest::PathExpander < PathExpander
-  attr_accessor :by_line
+class Minitest::PathExpander < Minitest::VendoredPathExpander
+  attr_accessor :by_line # :nodoc:
 
   TEST_GLOB = "**/{test_*,*_test,spec_*,*_spec}.rb" # :nodoc:
 
@@ -16,12 +231,6 @@ class Minitest::PathExpander < PathExpander
     self.by_line = {}
   end
 
-  def process(&b) # :nodoc: TODO: push up!
-    super.each(&b)
-    post_process
-    self
-  end
-
   def process_args # :nodoc:
     args.reject! { |arg|                # this is a good use of overriding
       case arg
@@ -57,7 +266,7 @@ class Minitest::PathExpander < PathExpander
     flags.reject { |flag| # all hits are truthy, so this works out well
       case flag
       when /^-I(.*)/ then
-        $LOAD_PATH.concat $1.split(/:/)
+        $LOAD_PATH.prepend(*$1.split(/:/))
       when /^-d/ then
         $DEBUG = true
       when /^-w/ then
@@ -82,6 +291,10 @@ class Minitest::PathExpander < PathExpander
     self.args << "-n" << "/#{test_res.join "|"}/"
   end
 
+  ##
+  # Find and return all known tests as a hash of klass => [TM...]
+  # pairs.
+
   def all_tests
     Minitest.seed = 42 # minor hack to deal with runnable_methods shuffling
     Minitest::Runnable.runnables
@@ -101,7 +314,10 @@ class Minitest::PathExpander < PathExpander
   def tests_by_class
     all_tests
       .transform_values { |ms|
-        ms.select { |m| bl=by_line[m.path]; not bl or bl.any? { |l| m.include? l } }
+        ms.select { |m|
+          bl = by_line[m.path]
+          not bl or bl.any? { |l| m.include? l }
+        }
       }
       .reject { |k, v| v.empty? }
   end
@@ -116,7 +332,7 @@ class Minitest::PathExpander < PathExpander
       .map { |k, ns|                              # [ "k1#(?:a|b)", "k2#c", ...]
         if ns.size > 1 then
           ns.map! { |n| Regexp.escape n }
-          "%s#\(%s\)" % [Regexp.escape(k.name), ns.join("|")]
+          "%s#\(?:%s\)" % [Regexp.escape(k.name), ns.join("|")]
         else
           "%s#%s" % [Regexp.escape(k.name), ns.first]
         end
@@ -158,6 +374,9 @@ class Minitest::PathExpander < PathExpander
     end
   end
 
+  ##
+  # Simple TestMethod (abbr TM) Data object.
+
   TM = Data.define :klass, :name, :path, :lines do
     def initialize klass:, name:
       method = klass.instance_method name

data/lib/minitest/sprint.rb

@@ -1,14 +1,98 @@
+$LOAD_PATH.unshift "test", "lib"
+
+require "simplecov" if ENV["MT_COV"] || ARGV.delete("--simplecov")
 require "minitest/autorun"
-require "minitest/path_expander"
+require_relative "path_expander"
+
+##
+# Runs (Get it? It's fast!) your tests and makes it easier to rerun individual
+# failures.
+
+module Minitest
+  class Sprint
+    VERSION = "1.5.0" # :nodoc:
+
+    ##
+    # Process and run minitest cmdline.
+
+    def self.run args = ARGV
+      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.
 
-$LOAD_PATH.unshift "test"
-$LOAD_PATH.unshift "lib"
+      attr_accessor :name
 
-class Minitest::Sprint
-  VERSION = "1.4.1"
+      def initialize name = nil # :nodoc:
+        super()
+        self.name    = name
+      end
 
-  def self.run args = ARGV
-    Minitest::PathExpander.new(args)
-      .process { |f| require "./#{f}" if File.file? f }
+      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

@@ -1,25 +1,39 @@
 require "minitest"
 
-module 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.on "--binstub", "Report how to re-run failures with minitest." do
-      options[:sprint] = :binstub
+    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
-      require "minitest/rake_reporter"
-      self.reporter << Minitest::RakeReporter.new(options[:rake_task])
-    when :binstub then
-      require "minitest/binstub_reporter"
-      self.reporter << Minitest::BinstubReporter.new
+      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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minitest-sprint
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.5.0
 platform: ruby
 authors:
 - Ryan Davis
@@ -30,20 +30,6 @@ cert_chain:
   -----END CERTIFICATE-----
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: path_expander
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: prism
   requirement: !ruby/object:Gem::Requirement
@@ -111,13 +97,10 @@ files:
 - README.rdoc
 - Rakefile
 - bin/minitest
-- lib/minitest/binstub_reporter.rb
 - lib/minitest/complete.rb
 - lib/minitest/path_expander.rb
-- lib/minitest/rake_reporter.rb
 - lib/minitest/sprint.rb
 - lib/minitest/sprint_plugin.rb
-- lib/minitest/sprint_reporter.rb
 - test/test_minitest_sprint.rb
 homepage: https://github.com/seattlerb/minitest-sprint
 licenses:

data/lib/minitest/binstub_reporter.rb

@@ -1,11 +0,0 @@
-require "minitest/sprint_reporter"
-
-module Minitest
-  class BinstubReporter < SprintReporter
-    def print_list
-      results.each do |result|
-        puts "  minitest -n #{result.class_name}##{result.name}"
-      end
-    end
-  end
-end

data/lib/minitest/rake_reporter.rb

@@ -1,18 +0,0 @@
-require "minitest/sprint_reporter"
-
-module Minitest
-  class RakeReporter < SprintReporter
-    attr_accessor :name
-
-    def initialize name = nil
-      self.results = []
-      self.name    = name
-    end
-
-    def print_list
-      results.each do |result|
-        puts ["  rake", name, "N=#{result.class_name}##{result.name}"].compact.join(" ")
-      end
-    end
-  end
-end

data/lib/minitest/sprint_reporter.rb

@@ -1,23 +0,0 @@
-module Minitest
-  class SprintReporter < AbstractReporter
-    attr_accessor :results
-
-    def initialize
-      self.results = []
-    end
-
-    def record result
-      results << result unless result.passed? or result.skipped?
-    end
-
-    def report
-      return if results.empty?
-
-      puts
-      puts "Happy Happy Sprint List:"
-      puts
-      print_list
-      puts
-    end
-  end
-end