class Minitest::Runnable

def self.inherited klass # :nodoc:
  self.runnables << klass
  super
end

def self.methods_matching re
  public_instance_methods(true).grep(re).map(&:to_s)
end

def self.on_signal name, action # :nodoc:
  supported = Signal.list[name]
  old_trap = trap name do
    old_trap.call if old_trap.respond_to? :call
    action.call
  end if supported
  yield
ensure
  trap name, old_trap if supported
end

def self.reset # :nodoc:
  @@runnables = []
end

def self.run reporter, options = {}
  filter = options[:filter] || '/./'
  filter = Regexp.new $1 if filter =~ /\/(.*)\//
  filtered_methods = self.runnable_methods.find_all { |m|
    filter === m || filter === "#{self}##{m}"
  }
  with_info_handler reporter do
    filtered_methods.each do |method_name|
      run_one_method self, method_name, reporter
    end
  end
end

def self.run_one_method klass, method_name, reporter
  reporter.record Minitest.run_one_method(klass, method_name)
end

def self.runnable_methods
  raise NotImplementedError, "subclass responsibility"
end

def self.runnables
  @@runnables
end

def self.with_info_handler reporter, &block # :nodoc:
  handler = lambda do
    unless reporter.passed? then
      warn "Current results:"
      warn ""
      warn reporter.reporters.first
      warn ""
    end
  end
  on_signal "INFO", handler, &block
end

def failure # :nodoc:
  self.failures.first
end

def initialize name # :nodoc:
  self.name       = name
  self.failures   = []
  self.assertions = 0
end

def marshal_dump # :nodoc:
  [self.name, self.failures, self.assertions]
end

def marshal_load ary # :nodoc:
  self.name, self.failures, self.assertions = ary
end

def name
  @NAME
end

def name= o
  @NAME = o
end

def passed?
  raise NotImplementedError, "subclass responsibility"
end

def result_code
  raise NotImplementedError, "subclass responsibility"
end

def run
  raise NotImplementedError, "subclass responsibility"
end

def skipped?
  raise NotImplementedError, "subclass responsibility"
end