minitest 5.16.2 → 6.0.5

data/lib/minitest/path_expander.rb

@@ -0,0 +1,432 @@
+require "prism"
+require "pathname" # for ruby 3
+
+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| _normalize s }
+  end
+
+  def _normalize(f) = Pathname.new(f).cleanpath.to_s # :nodoc:
+
+  ##
+  # 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
+
+    root_dir = File.expand_path "/" # needed for windows paths
+
+    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) == root_dir # 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
+
+  ##
+  # Hook to run before process
+
+  def pre_process = nil
+
+  ##
+  # Hook to run after process
+
+  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 < Minitest::VendoredPathExpander
+  attr_accessor :by_line # :nodoc:
+
+  TEST_GLOB = "**/{test_*,*_test,spec_*,*_spec}.rb" # :nodoc:
+
+  def initialize args = ARGV # :nodoc:
+    super args, TEST_GLOB, "test"
+    self.by_line = {}
+  end
+
+  def process_args # :nodoc:
+    args.reject! { |arg|                # this is a good use of overriding
+      case arg
+      when /^(.*):([\d,-]+)$/ then
+        f, ls = $1, $2
+        ls = ls
+          .split(/,/)
+          .map { |l|
+            case l
+            when /^\d+$/ then
+              l.to_i
+            when /^(\d+)-(\d+)$/ then
+              $1.to_i..$2.to_i
+            else
+              raise "unhandled argument format: %p" % [l]
+            end
+          }
+        next unless File.exist? f
+        f = _normalize f
+        args << f                       # push path on lest it run whole dir
+        by_line[f] = ls                 # implies rejection
+      end
+    }
+
+    super
+  end
+
+  ##
+  # Overrides PathExpander#process_flags to filter out ruby flags
+  # from minitest flags. Only supports -I<paths>, -d, and -w for
+  # ruby.
+
+  def process_flags flags
+    flags.reject { |flag| # all hits are truthy, so this works out well
+      case flag
+      when /^-I(.*)/ then
+        $LOAD_PATH.prepend(*$1.split(/:/))
+      when /^-d/ then
+        $DEBUG = true
+      when /^-w/ then
+        $VERBOSE = true
+      else
+        false
+      end
+    }
+  end
+
+  ##
+  # Add additional arguments to args to handle path:line argument filtering
+
+  def post_process
+    return if by_line.empty?
+
+    tests = tests_by_class
+
+    exit! 1 if handle_missing_tests? tests
+
+    test_res = tests_to_regexp tests
+    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
+      .to_h { |k|
+        ms = k.runnable_methods
+          .sort
+          .map { |m| TM.new k, m.to_sym }
+          .sort_by { |t| [t.path, t.line_s] }
+        [k, ms]
+      }
+      .reject { |k, v| v.empty? }
+  end
+
+  ##
+  # Returns a hash mapping Minitest runnable classes to TMs
+
+  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 }
+        }
+      }
+      .reject { |k, v| v.empty? }
+  end
+
+  ##
+  # Converts +tests+ to an array of "klass#(methods+)" regexps to be
+  # used for test selection.
+
+  def tests_to_regexp tests
+    tests                                         # { k1 => [Test(a), ...}
+      .transform_values { |tms| tms.map(&:name) } # { k1 => %w[a, b], ...}
+      .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("|")]
+        else
+          "%s#%s" % [Regexp.escape(k.name), ns.first]
+        end
+      }
+  end
+
+  ##
+  # Handle the case where a line number doesn't match any known tests.
+  # Returns true to signal that running should stop.
+
+  def handle_missing_tests? tests
+    _tests = tests.values.flatten
+    not_found = by_line
+      .flat_map { |f, ls| ls.map { |l| [f, l] } }
+      .reject { |f, l|
+        _tests.any? { |t| t.path == f and t.include? l }
+      }
+
+    unless not_found.empty? then
+      by_path = all_tests.values.flatten.group_by(&:path)
+
+      puts
+      puts "ERROR: test(s) not found at:"
+      not_found.each do |f, l|
+        puts "  %s:%s" % [f, l]
+        puts
+        puts "Did you mean?"
+        puts
+        l = l.begin if l.is_a? Range
+        by_path[f] and
+          by_path[f]
+          .sort_by { |m| (m.line_s - l).abs }
+          .first(2)
+          .each do |m|
+            puts "  %-30s (dist=%+d) (%s)" % [m, m.line_s - l, m.name]
+          end
+        puts
+      end
+      $stdout.flush
+      $stderr.flush
+      true
+    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
+      path, line_s = method.source_location
+
+      path = path.delete_prefix "#{Dir.pwd}/"
+
+      line_e = line_s + TM.source_for(method).lines.size - 1
+
+      lines = line_s..line_e
+
+      super klass:, name:, path:, lines:
+    end
+
+    def self.source_for method
+      path, line = method.source_location
+      file = cache[path] ||= File.readlines(path)
+
+      ruby = +""
+
+      file[line-1..].each do |l|
+        ruby << l
+        return ruby if Prism.parse_success? ruby
+      end
+
+      nil
+    end
+
+    def self.cache = @cache ||= {}
+
+    def include?(o) = o.is_a?(Integer) ? lines.include?(o) : lines.overlap?(o)
+
+    def to_s = "%s:%d-%d" % [path, lines.begin, lines.end]
+
+    def line_s = lines.begin
+  end
+end

data/lib/minitest/pride.rb

@@ -1,4 +1,4 @@
-require "minitest"
+require_relative "../minitest"
 
-Minitest.load_plugins
+Minitest.load :pride
 Minitest::PrideIO.pride!

data/lib/minitest/pride_plugin.rb

@@ -1,4 +1,4 @@
-require "minitest"
+require_relative "../minitest"
 
 module Minitest
   def self.plugin_pride_options opts, _options # :nodoc:
@@ -8,13 +8,13 @@ module Minitest
   end
 
   def self.plugin_pride_init options # :nodoc:
-    if PrideIO.pride? then
-      klass = ENV["TERM"] =~ /^xterm|-256color$/ ? PrideLOL : PrideIO
-      io    = klass.new options[:io]
+    return unless PrideIO.pride?
 
-      self.reporter.reporters.grep(Minitest::Reporter).each do |rep|
-        rep.io = io if rep.io.tty?
-      end
+    klass = ENV["TERM"] =~ /^xterm|-(?:256color|direct)$/ ? PrideLOL : PrideIO
+    io    = klass.new options[:io]
+
+    self.reporter.reporters.grep(Minitest::Reporter).each do |rep|
+      rep.io = io if rep.io.tty?
     end
   end
 
@@ -59,12 +59,10 @@ module Minitest
 
     def print o
       case o
-      when "." then
+      when ".", "S" then
         io.print pride o
       when "E", "F" then
         io.print "#{ESC}41m#{ESC}37m#{o}#{NND}"
-      when "S" then
-        io.print pride o
       else
         io.print o
       end
@@ -72,11 +70,9 @@ module Minitest
 
     def puts *o # :nodoc:
       o.map! { |s|
-        s.to_s.sub(/Finished/) {
+        s.to_s.sub("Finished") {
           @index = 0
-          "Fabulous run".split(//).map { |c|
-            pride(c)
-          }.join
+          "Fabulous run".chars.map { |c| pride(c) }.join
         }
       }
 
@@ -113,19 +109,16 @@ module Minitest
       #
       #   plot (3*sin(x)+3), (3*sin(x+2*pi/3)+3), (3*sin(x+4*pi/3)+3)
 
-      # 6 has wide pretty gradients. 3 == lolcat, about half the width
-      @colors = (0...(6 * 7)).map { |n|
-        n *= 1.0 / 6
+      @colors = Array.new(6 * 7) { |n|
+        n *= 1.0 / 3
         r  = (3 * Math.sin(n           ) + 3).to_i
-        g  = (3 * Math.sin(n + 2 * PI_3) + 3).to_i
-        b  = (3 * Math.sin(n + 4 * PI_3) + 3).to_i
-
-        # Then we take rgb and encode them in a single number using base 6.
-        # For some mysterious reason, we add 16... to clear the bottom 4 bits?
-        # Yes... they're ugly.
+        g  = (3 * Math.sin(n + 4 * PI_3) + 3).to_i
+        b  = (3 * Math.sin(n + 2 * PI_3) + 3).to_i
 
+        # Then we take rgb and encode them in a single number using
+        # base 6, shifted by 16 for the base 16 ansi colors.
         36 * r + 6 * g + b + 16
-      }
+      }.rotate(4) # puts "red" first
 
       super
     end

data/lib/minitest/server.rb

@@ -0,0 +1,49 @@
+require "drb"
+require "tmpdir"
+require_relative "../minitest"
+
+# :stopdoc:
+
+class Minitest::Server
+  # extracted version = "1.0.10"
+
+  TOPDIR = Dir.pwd + "/"
+
+  def self.path pid = $$
+    "drbunix:#{Dir.tmpdir}/minitest.#{pid}"
+  end
+
+  def self.run client
+    DRb.start_service path, new(client)
+  end
+
+  def self.stop
+    DRb.stop_service
+  end
+
+  attr_accessor :client
+
+  def initialize client
+    self.client = client
+  end
+
+  def quit
+    self.class.stop
+  end
+
+  def start
+    client.minitest_start
+  end
+
+  def result file, klass, method, fails, assertions, time
+    file = file.sub(/^#{TOPDIR}/, "")
+
+    client.minitest_result file, klass, method, fails, assertions, time
+  end
+
+  def report
+    # do nothing
+  end
+end
+
+# :startdoc:

data/lib/minitest/server_plugin.rb

@@ -0,0 +1,88 @@
+require_relative "../minitest" unless defined? Minitest
+
+# :stopdoc:
+
+module Minitest
+  @server = false
+
+  def self.plugin_server_options opts, options # :nodoc:
+    opts.on "--server=pid", Integer, "Connect to minitest server w/ pid." do |s|
+      @server = s
+    end
+  end
+
+  def self.plugin_server_init options
+    if @server then
+      require_relative "server"
+      self.reporter << Minitest::ServerReporter.new(@server)
+    end
+  end
+end
+
+class Minitest::ServerReporter < Minitest::AbstractReporter
+  def initialize pid
+    uri = Minitest::Server.path(pid)
+    @mt_server = DRbObject.new_with_uri uri
+    super()
+  end
+
+  def start
+    @mt_server.start
+  end
+
+  def record result
+    r = result
+    c = r.class
+
+    case r
+    when Minitest::Result then
+      file, = r.source_location
+      cn = r.klass
+    else
+      # TODO: remove? when is this used?
+      file, = r.method(r.name).source_location
+      cn = c.name
+    end
+
+    sanitize r.failures
+
+    @mt_server.result file, cn, r.name, r.failures, r.assertions, r.time
+  end
+
+  def sanitize failures
+    failures.map! { |e|
+      case e
+      when Minitest::UnexpectedError then
+        # embedded exception might not be able to be marshaled.
+        bt = e.error.backtrace
+
+        ex = RuntimeError.new(e.error.message)
+        e.error = ex
+        ex.set_backtrace bt
+
+        e = Minitest::UnexpectedError.new ex # ugh. some rails plugin. ugh.
+
+        if ex.instance_variables.include? :@bindings then # web-console is Evil
+          ex.instance_variable_set :@bindings, nil
+          e.instance_variable_set  :@bindings, nil
+        end
+      when Minitest::Skip then
+        # do nothing
+      when Minitest::Assertion then
+        bt = e.backtrace
+        e = e.class.new(e.message)
+        e.set_backtrace bt
+      else
+        warn "Unhandled exception type: #{e.class}\n\n#{e.inspect}"
+      end
+
+      e
+    }
+  end
+
+  def report
+    @mt_server.report
+  end
+end
+
+# :startdoc: