class Hpricot::Elements

def self.expand(ele1, ele2, excl=false)
  ary = []
  offset = excl ? -1 : 0
  if ele1 and ele2
    # let's quickly take care of siblings
    if ele1.parent == ele2.parent
      ary = ele1.parent.children[ele1.node_position..(ele2.node_position+offset)]
    else
      # find common parent
      p, ele1_p = ele1, [ele1]
      ele1_p.unshift p while p.respond_to?(:parent) and p = p.parent
      p, ele2_p = ele2, [ele2]
      ele2_p.unshift p while p.respond_to?(:parent) and p = p.parent
      common_parent = ele1_p.zip(ele2_p).select { |p1, p2| p1 == p2 }.flatten.last
      child = nil
      if ele1 == common_parent
        child = ele2
      elsif ele2 == common_parent
        child = ele1
      end
      if child
        ary = common_parent.children[0..(child.node_position+offset)]
      end
    end
  end
  return Elements[*ary]
end

def self.filter(nodes, expr, truth = true)
    until expr.empty?
        _, *m = *expr.match(/^(?:#{ATTR_RE}|#{BRACK_RE}|#{FUNC_RE}|#{CUST_RE}|#{CATCH_RE})/)
        break unless _
        expr = $'
        m.compact!
        if m[0] == '@'
            m[0] = "@#{m.slice!(2,1)}"
        end
        if m[0] == '[' && m[1] =~ /^\d+$/
            m = [":", "nth", m[1].to_i-1]
        end
        if m[0] == ":" && m[1] == "not"
            nodes, = Elements.filter(nodes, m[2], false)
        elsif "#{m[0]}#{m[1]}" =~ /^(:even|:odd)$/
            new_nodes = []
            nodes.each_with_index {|n,i| new_nodes.push(n) if (i % 2 == (m[1] == "even" ? 0 : 1)) }
            nodes = new_nodes
        elsif "#{m[0]}#{m[1]}" =~ /^(:first|:last)$/
            nodes = [nodes.send(m[1])]
        else
            meth = "filter[#{m[0]}#{m[1]}]" unless m[0].empty?
            if meth and Traverse.method_defined? meth
                args = m[2..-1]
            else
                meth = "filter[#{m[0]}]"
                if Traverse.method_defined? meth
                    args = m[1..-1]
                end
            end
            i = -1
            nodes = Elements[*nodes.find_all do |x| 
                                  i += 1
                                  x.send(meth, *([*args] + [i])) ? truth : !truth
                              end]
        end
    end
    [nodes, expr]
end

def add_class class_name
  each do |el|
    next unless el.respond_to? :get_attribute
    classes = el.get_attribute('class').to_s.split(" ")
    el.set_attribute('class', classes.push(class_name).uniq.join(" "))
  end
  self
end

def after(str = nil, &blk)
  each { |x| x.parent.insert_after x.make(str, &blk), x }
end

def append(str = nil, &blk)
  each { |x| x.html(x.children + x.make(str, &blk)) }
end

def at(expr, &blk)
  search(expr, &blk).first
end

def attr key, value = nil, &blk
  if value or blk
    each do |el|
      el.set_attribute(key, value || blk[el])
    end
    return self      
  end    
  if key.is_a? Hash
    key.each { |k,v| self.attr(k,v) }
    return self
  else
    return self[0].get_attribute(key)
  end
end

def before(str = nil, &blk)
  each { |x| x.parent.insert_before x.make(str, &blk), x }
end

def copy_node(node, l)
    l.instance_variables.each do |iv|
        node.instance_variable_set(iv, l.instance_variable_get(iv))
    end
end

def empty
  each { |x| x.inner_html = nil }
end

def filter(expr)
    nodes, = Elements.filter(self, expr)
    nodes
end

def inner_html(*string)
  if string.empty?
    map { |x| x.inner_html }.join
  else
    x = self.inner_html = string.pop || x
  end
end

def inner_html=(string)
  each { |x| x.inner_html = string }
end

def inner_text
  map { |x| x.inner_text }.join
end

def not(expr)
    if expr.is_a? Traverse
        nodes = self - [expr]
    else
        nodes, = Elements.filter(self, expr, false)
    end
    nodes
end

def prepend(str = nil, &blk)
  each { |x| x.html(x.make(str, &blk) + x.children) }
end

def pretty_print(q)
  q.object_group(self) { super }
end

def remove
  each { |x| x.parent.children.delete(x) }
end

def remove_attr name
  each do |el|
    next unless el.respond_to? :remove_attribute
    el.remove_attribute(name)
  end
  self      
end

def remove_class name = nil
  each do |el|
    next unless el.respond_to? :get_attribute
    if name
      classes = el.get_attribute('class').to_s.split(" ")
      el.set_attribute('class', (classes - [name]).uniq.join(" "))
    else
      el.remove_attribute("class")
    end
  end
  self      
end

def search(*expr,&blk)
  Elements[*map { |x| x.search(*expr,&blk) }.flatten.uniq]
end

def to_html
  map { |x| x.output("") }.join
end

def wrap(str = nil, &blk)
  each do |x|
    wrap = x.make(str, &blk)
    nest = wrap.detect { |w| w.respond_to? :children }
    unless nest
      raise "No wrapping element found."
    end
    x.parent.replace_child(x, wrap)
    nest = nest.children.first until nest.empty?
    nest.html(nest.children + [x])
  end
end