module Hpricot::Container::Trav

def classes
  get_attribute('class').to_s.strip.split(/\s+/)
end

def containers
  children.grep(Container::Trav)
end

def each_child(&block) # :yields: child_node
  children.each(&block)
  nil
end

def each_child_with_index(&block) # :yields: child_node, index
  children.each_with_index(&block)
  nil
end

def each_hyperlink # :yields: text
  links = []
  each_hyperlink_attribute {|elem, attr, hyperlink|
    yield hyperlink
  }
end

def each_hyperlink_attribute
  traverse_element(
      '{http://www.w3.org/1999/xhtml}a',
      '{http://www.w3.org/1999/xhtml}area',
      '{http://www.w3.org/1999/xhtml}link',
      '{http://www.w3.org/1999/xhtml}img',
      '{http://www.w3.org/1999/xhtml}object',
      '{http://www.w3.org/1999/xhtml}q',
      '{http://www.w3.org/1999/xhtml}blockquote',
      '{http://www.w3.org/1999/xhtml}ins',
      '{http://www.w3.org/1999/xhtml}del',
      '{http://www.w3.org/1999/xhtml}form',
      '{http://www.w3.org/1999/xhtml}input',
      '{http://www.w3.org/1999/xhtml}head',
      '{http://www.w3.org/1999/xhtml}base',
      '{http://www.w3.org/1999/xhtml}script') {|elem|
    case elem.name
    when %r{\{http://www.w3.org/1999/xhtml\}(?:base|a|area|link)\z}i
      attrs = ['href']
    when %r{\{http://www.w3.org/1999/xhtml\}(?:img)\z}i
      attrs = ['src', 'longdesc', 'usemap']
    when %r{\{http://www.w3.org/1999/xhtml\}(?:object)\z}i
      attrs = ['classid', 'codebase', 'data', 'usemap']
    when %r{\{http://www.w3.org/1999/xhtml\}(?:q|blockquote|ins|del)\z}i
      attrs = ['cite']
    when %r{\{http://www.w3.org/1999/xhtml\}(?:form)\z}i
      attrs = ['action']
    when %r{\{http://www.w3.org/1999/xhtml\}(?:input)\z}i
      attrs = ['src', 'usemap']
    when %r{\{http://www.w3.org/1999/xhtml\}(?:head)\z}i
      attrs = ['profile']
    when %r{\{http://www.w3.org/1999/xhtml\}(?:script)\z}i
      attrs = ['src', 'for']
    end
    attrs.each {|attr|
      if hyperlink = elem.get_attribute(attr)
        yield elem, attr, hyperlink
      end
    }
  }
end

def each_hyperlink_uri(base_uri=nil) # :yields: hyperlink, uri
  base_uri = URI.parse(base_uri) if String === base_uri
  links = []
  each_hyperlink_attribute {|elem, attr, hyperlink|
    if %r{\{http://www.w3.org/1999/xhtml\}(?:base)\z}i =~ elem.name
      base_uri = URI.parse(hyperlink.to_s)
    else
      links << hyperlink
    end
  }
  if base_uri
    links.each {|hyperlink| yield hyperlink, base_uri + hyperlink.to_s }
  else
    links.each {|hyperlink| yield hyperlink, URI.parse(hyperlink.to_s) }
  end
end

def each_uri(base_uri=nil) # :yields: URI
  each_hyperlink_uri(base_uri) {|hyperlink, uri| yield uri }
end

def filter(&block)
  subst = {}
  each_child_with_index {|descendant, i|
    if yield descendant
      if descendant.elem?
        subst[i] = descendant.filter(&block)
      else
        subst[i] = descendant
      end
    else
      subst[i] = nil
    end
  }
  to_node.subst_subnode(subst)
end

def find_element(*names)
  traverse_element(*names) {|e| return e }
  nil
end

def following_siblings() 
  sibs = parent.containers 
  si = sibs.index(self) + 1 
  return Elements[*sibs[si...sibs.length]] 
end 

def get_element_by_id(id)
  traverse_all_element do |ele|
      if ele.elem? and eid = ele.get_attribute('id')
          return ele if eid.to_s == id
      end
  end
  nil
end

def get_elements_by_tag_name(*a)
  list = Elements[]
  a.delete("*")
  traverse_element(*a.map { |tag| [tag, "{http://www.w3.org/1999/xhtml}#{tag}"] }.flatten) do |e|
    list << e if e.elem?
  end
  list
end

def insert_after(nodes, ele)
  case nodes
  when Array
    nodes.reverse_each { |n| insert_after(n, ele) }
  else
    reparent nodes
    idx = children.index(ele)
    children[idx ? idx + 1 : children.length, 0] = nodes
  end
end

def insert_before(nodes, ele)
  case nodes
  when Array
    nodes.each { |n| insert_before(n, ele) }
  else
    reparent nodes
    children[children.index(ele) || 0, 0] = nodes
  end
end

def next_sibling
  sib = parent.containers
  sib[sib.index(self) + 1] if parent
end

def preceding_siblings() 
  sibs = parent.containers 
  si = sibs.index(self) 
  return Elements[*sibs[0...si]] 
end 

def previous_sibling
  sib = parent.containers
  x = sib.index(self) - 1
  sib[x] if sib and x >= 0
end

def replace_child(old, new)
  reparent new
  children[children.index(old), 1] = [*new]
end

def siblings_at(*pos)
  sib = parent.containers
  i, si = 0, sib.index(self)
  Elements[*
    sib.select do |x|
      sel = case i - si when *pos
              true
            end
      i += 1
      sel
    end
  ]
end

def traverse_text_internal(&block)
  each_child {|c| c.traverse_text_internal(&block) }
end