Module: Minitest

# File 'lib/minitest.rb', line 97

def self.after_run &block
  @@after_run << block
end

# File 'lib/minitest.rb', line 70

def self.autorun
  Warning[:deprecated] = true if
    Object.const_defined?(:Warning) && Warning.respond_to?(:[]=)

  at_exit {
    next if $! and not ($!.kind_of? SystemExit and $!.success?)

    exit_code = nil

    pid = Process.pid
    at_exit {
      next if !Minitest.allow_fork && Process.pid != pid
      @@after_run.reverse_each(&:call)
      exit exit_code || false
    }

    exit_code = Minitest.run ARGV
  } unless @@installed_at_exit
  @@installed_at_exit = true
end

# File 'lib/minitest.rb', line 19

def self.cattr_accessor name # :nodoc:
  (class << self; self; end).attr_accessor name
end

# File 'lib/minitest.rb', line 1220

def self.clock_time
  Process.clock_gettime Process::CLOCK_MONOTONIC
end

# File 'lib/minitest.rb', line 303

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

# File 'lib/minitest.rb', line 336

def self.filter_backtrace bt # :nodoc:
  result = backtrace_filter.filter bt
  result = bt.dup if result.empty?
  result
end

# File 'lib/minitest.rb', line 125

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
end

# File 'lib/minitest/manual_plugins.rb', line 9

def self.load *names
  names.each do |name|
    require "minitest/#{name}_plugin"

    self.extensions << name.to_s
  end
end

# File 'lib/minitest.rb', line 109

def self.load_plugins # :nodoc:
  return unless defined? Gem

  seen = {}

  Gem.find_files("minitest/*_plugin.rb").each do |plugin_path|
    name = File.basename plugin_path, "_plugin.rb"

    next if seen[name]
    seen[name] = true

    require plugin_path
    self.extensions << name
  end
end

# File 'lib/minitest/pride_plugin.rb', line 10

def self.plugin_pride_init options # :nodoc:
  return unless PrideIO.pride?

  klass = ENV["TERM"] =~ /^xterm|-256color$/ ? 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

# File 'lib/minitest/pride_plugin.rb', line 4

def self.plugin_pride_options opts, _options # :nodoc:
  opts.on "-p", "--pride", "Pride. Show your testing pride!" do
    PrideIO.pride!
  end
end

# File 'lib/minitest.rb', line 143

def self.process_args args = [] # :nodoc:
  options = {
              :io => $stdout,
            }
  orig_args = args.dup

  OptionParser.new do |opts|
    opts.banner  = "minitest options:"
    opts.version = Minitest::VERSION

    opts.on "-h", "--help", "Display this help." do
      puts opts
      exit
    end

    opts.on "--no-plugins", "Bypass minitest plugin auto-loading (or set $MT_NO_PLUGINS)."

    desc = "Sets random seed. Also via env. Eg: SEED=n rake"
    opts.on "-s", "--seed SEED", Integer, desc do |m|
      options[:seed] = m.to_i
    end

    opts.on "-v", "--verbose", "Verbose. Show progress processing files." do
      options[:verbose] = true
    end

    opts.on "-q", "--quiet", "Quiet. Show no progress processing files." do
      options[:quiet] = true
    end

    opts.on "--show-skips", "Show skipped at the end of run." do
      options[:show_skips] = true
    end

    opts.on "-n", "--name PATTERN", "Filter run on /regexp/ or string." do |a|
      options[:filter] = a
    end

    opts.on "-e", "--exclude PATTERN", "Exclude /regexp/ or string from run." do |a|
      options[:exclude] = a
    end

    opts.on "-S", "--skip CODES", String, "Skip reporting of certain types of results (eg E)." do |s|
      options[:skip] = s.chars.to_a
    end

    ruby27plus = ::Warning.respond_to? :[]=

    opts.on "-W[error]", String, "Turn Ruby warnings into errors" do |s|
      options[:Werror] = true
      case s
      when "error", "all", nil then
        require "minitest/error_on_warning"
        $VERBOSE = true
        ::Warning[:deprecated] = true if ruby27plus
      else
        ::Warning[s.to_sym] = true if ruby27plus # check validity of category
      end
    end

    unless extensions.empty?
      opts.separator ""
      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

    begin
      opts.parse! args
    rescue OptionParser::InvalidOption => e
      puts
      puts e
      puts
      puts opts
      exit 1
    end

    orig_args -= args
  end

  unless options[:seed] then
    srand
    options[:seed] = (ENV["SEED"] || srand).to_i % 0xFFFF
    orig_args << "--seed" << options[:seed].to_s
  end

  options[:args] = orig_args.map { |s|
    s.match?(/[\s|&<>$()]/) ? s.inspect : s
  }.join " "

  options
end

# File 'lib/minitest.rb', line 104

def self.register_plugin name_or_mod
  self.extensions << name_or_mod
  nil
end

# File 'lib/minitest.rb', line 269

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

# File 'lib/minitest.rb', line 1207

def self.run_one_method klass, method_name # :nodoc:
  result = klass.new(method_name).run
  raise "#{klass}#run _must_ return a Result" unless Result === result
  result
end

# File 'lib/minitest.rb', line 56

cattr_accessor :extensions

# File 'lib/minitest.rb', line 61

cattr_accessor :info_signal

# File 'lib/minitest.rb', line 34

cattr_accessor :parallel_executor

# File 'lib/minitest.rb', line 51

cattr_accessor :reporter

# File 'lib/minitest.rb', line 29

cattr_accessor :seed