class Test::Unit::Collector::XML::Listener

def _ns(ns, prefix)
  ns.fetch(prefix, "")
end

def current_path
  locals = @tag_stack.collect do |uri, local|
    local
  end
  ["", *locals].join("/")
end

def initialize
  @ns_stack = [{"xml" => :xml}]
  @tag_stack = [["", :root]]
  @text_stack = ['']
  @state_stack = [:root]
  @values = {}
  @test_suites = []
end

def next_state(current_state, uri, local)
  local = normalize_local(local)
  valid_elements = STATE_TABLE[current_state]
  if valid_elements.nil?
    raise "unexpected element: #{current_path}"
  end
  next_state = local.to_sym
  unless valid_elements.include?(next_state)
    raise "unexpected element: #{current_path}"
  end
  next_state
end

def normalize_local(local)
  local.gsub(/-/, "_")
end

def parent_tag
  @tag_stack.last[1]
end

def split_name(name)
  name =~ NAME_SPLIT
  [$1 || '', $2]
end

def tag_end(name)
  state = @state_stack.pop
  text = @text_stack.pop
  uri, local = @tag_stack.pop
  no_action_states = [:root, :stream]
  case state
  when *no_action_states
    # do nothing
  when :test_suite
    test_suite_end
  when :complete_test_case
    @test_suites.last << @test_case.suite
  when :test_case
    test_case_end
  when :result
    @result = @values
  when :test
    test_end
  when :pass_assertion
    @n_pass_assertions += 1
  when :backtrace
    @values = @values_backup
    @values["backtrace"] = @backtrace
  when :entry
    file = @values['file']
    line = @values['line']
    info = @values['info']
    @backtrace << "#{file}:#{line}: #{info}"
    @values = {}
  else
    local = normalize_local(local)
    @values[local] = text
  end
  @ns_stack.pop
end

def tag_start(name, attributes)
  @text_stack.push('')
  ns = @ns_stack.last.dup
  attrs = {}
  attributes.each do |n, v|
    if /\Axmlns(?:\z|:)/ =~ n
      ns[$POSTMATCH] = v
    else
      attrs[n] = v
    end
  end
  @ns_stack.push(ns)
  _parent_tag = parent_tag
  prefix, local = split_name(name)
  uri = _ns(ns, prefix)
  @tag_stack.push([uri, local])
  state = next_state(@state_stack.last, uri, local)
  @state_stack.push(state)
  @values = {}
  case state
  when :test_suite, :test_case
    # do nothing
  when :test
    @n_pass_assertions = 0 if _parent_tag == "start-test"
  when :backtrace
    @backtrace = []
    @values_backup = @values
  end
end

def test_case_end
  return unless parent_tag == "start-test-case"
  name = @values["name"]
  @test_case = Class.new(TestCase) do
    define_method(:name) do
      name
    end
  end
end

def test_end
  return unless parent_tag == "complete-test"
  name = @values["name"]
  n_pass_assertions = @n_pass_assertions
  result = @result
  @test_case.module_eval do
    test
    define_method(name) do
      n_pass_assertions.times do
        add_assertion
      end
      case result["status"]
      when "omission"
        add_omission(Omission.new(name,
                                  result["backtrace"],
                                  result["detail"]))
      end
    end
  end
end

def test_suite_end
  return unless parent_tag == "start-test-suite"
  suite = TestSuite.new
  ["start_time", "elapsed_time", "n_tests"].each do |key|
    if @values.has_key?(key)
      suite.instance_variable_set("@#{key}", @values[key])
    end
  end
  @test_suites << suite
end

def text(data)
  @text_stack.last << data
end