class MiniTest::Spec

def self.after type = :each, &block
  raise "unsupported after type: #{type}" unless type == :each
  define_inheritable_method :teardown, &block
end

def self.before type = :each, &block
  raise "unsupported before type: #{type}" unless type == :each
  define_inheritable_method :setup, &block
end

def self.bench name, &block
  define_method "bench_#{name.gsub(/\W+/, '_')}", &block
end

def self.bench_performance_constant name, threshold = 0.99, &work
  bench name do
    assert_performance_constant threshold, &work
  end
end

def self.bench_performance_exponential name, threshold = 0.99, &work
  bench name do
    assert_performance_exponential threshold, &work
  end
end

def self.bench_performance_linear name, threshold = 0.99, &work
  bench name do
    assert_performance_linear threshold, &work
  end
end

def self.bench_range &block
  return super unless block
  meta = (class << self; self; end)
  meta.send :define_method, "bench_range", &block
end

def self.children
  @children ||= []
end

def self.current # :nodoc:
  @@current_spec
end

def self.define_inheritable_method name, &block # :nodoc:
  # regular super() warns
  super_method = self.superclass.instance_method name
  teardown     = name.to_s == "teardown"
  super_before = super_method && ! teardown
  super_after  = super_method && teardown
  define_method name do
    super_method.bind(self).call if super_before
    instance_eval(&block)
    super_method.bind(self).call if super_after
  end
end

def self.describe_stack # :nodoc:
  @@describe_stack
end

def self.it desc, &block
  block ||= proc { skip "(no tests defined)" }
  @specs ||= 0
  @specs += 1
  name = "test_%04d_%s" % [ @specs, desc.gsub(/\W+/, '_').downcase ]
  define_method name, &block
  self.children.each do |mod|
    mod.send :undef_method, name if mod.public_method_defined? name
  end
end

def self.nuke_test_methods! # :nodoc:
  self.public_instance_methods.grep(/^test_/).each do |name|
    self.send :undef_method, name
  end
end

def self.register_spec_type matcher, klass
  TYPES.unshift [matcher, klass]
end

def self.spec_type desc
  desc = desc.to_s
  TYPES.find { |re, klass| re === desc }.last
end

def initialize name # :nodoc:
  super
  @@current_spec = self
end