module RSpec::Core::Hooks

def after(*args, &block)
  register_hook :prepend, :after, *args, &block
end

def after_all_hooks_for(group)
  GroupHookCollection.new(hooks[:after][:all]).for(group)
end

def after_each_hooks_for(example)
  HookCollection.new(parent_groups.map {|a| a.hooks[:after][:each]}.flatten).for(example)
end

def append_after(*args, &block)
  register_hook :append, :after, *args, &block
end

def around(*args, &block)
  register_hook :prepend, :around, *args, &block
end

def around_each_hooks_for(example, initial_procsy=nil)
  AroundHookCollection.new(parent_groups.map {|a| a.hooks[:around][:each]}.flatten).for(example, initial_procsy)
end

def before(*args, &block)
  register_hook :append, :before, *args, &block
end

def before_all_hooks_for(group)
  GroupHookCollection.new(hooks[:before][:all]).for(group)
end

def before_each_hooks_for(example)
  HookCollection.new(parent_groups.reverse.map {|a| a.hooks[:before][:each]}.flatten).for(example)
end

def extract_scope_from(args)
  if SCOPES.include?(args.first)
    args.shift
  elsif args.any? { |a| a.is_a?(Symbol) }
    raise ArgumentError.new("You must explicitly give a scope (:each, :all, or :suite) when using symbols as metadata for a hook.")
  else
    :each
  end
end

def find_hook(hook, scope, example_or_group, initial_procsy)
  case [hook, scope]
  when [:before, :all]
    before_all_hooks_for(example_or_group)
  when [:after, :all]
    after_all_hooks_for(example_or_group)
  when [:around, :each]
    around_each_hooks_for(example_or_group, initial_procsy)
  when [:before, :each]
    before_each_hooks_for(example_or_group)
  when [:after, :each]
    after_each_hooks_for(example_or_group)
  when [:before, :suite], [:after, :suite]
    hooks[hook][:suite].with(example_or_group)
  end
end

def hooks
  @hooks ||= {
    :around => { :each => AroundHookCollection.new },
    :before => { :each => HookCollection.new, :all => HookCollection.new, :suite => HookCollection.new },
    :after =>  { :each => HookCollection.new, :all => HookCollection.new, :suite => HookCollection.new }
  }.extend(RegistersGlobals)
end

def prepend_before(*args, &block)
  register_hook :prepend, :before, *args, &block
end

def register_hook prepend_or_append, hook, *args, &block
  scope, options = scope_and_options_from(*args)
  hooks[hook][scope].send(prepend_or_append, HOOK_TYPES[hook].new(block, options))
end

def run_hook(hook, scope, example_or_group=ExampleGroup.new, initial_procsy=nil)
  find_hook(hook, scope, example_or_group, initial_procsy).run
end

def scope_and_options_from(*args)
  return extract_scope_from(args), build_metadata_hash_from(args)
end