class Nokogiri::XML::NodeSet

def == other
  return false unless other.is_a?(Nokogiri::XML::NodeSet)
  return false unless length == other.length
  each_with_index do |node, i|
    return false unless node == other[i]
  end
  true
end

def > selector
  ns = document.root.namespaces
  xpath CSS.xpath_for(selector, :prefix => "./", :ns => ns).first
end

def add_class name
  each do |el|
    classes = el['class'].to_s.split(/\s+/)
    el['class'] = classes.push(name).uniq.join " "
  end
  self
end

def after datum
  last.after datum
end

def at *args
  if args.length == 1 && args.first.is_a?(Numeric)
    return self[args.first]
  end
  super(*args)
end

def attr key, value = nil, &blk
  unless Hash === key || key && (value || blk)
    return first.attribute(key)
  end
  hash = key.is_a?(Hash) ? key : { key => value }
  hash.each { |k,v| each { |el| el[k] = v || blk[el] } }
  self
end

def before datum
  first.before datum
end

def children
  inject(NodeSet.new(document)) { |set, node| set += node.children }
end

def css *args
  rules, handler, ns, _ = extract_params(args)
  inject(NodeSet.new(document)) do |set, node|
    set += css_internal node, rules, handler, ns
  end
end

def each(&block)
  0.upto(length - 1) do |x|
    yield self[x]
  end
end

def empty?
  length == 0
end

def filter expr
  find_all { |node| node.matches?(expr) }
end

def first n = nil
  return self[0] unless n
  list = []
  n.times { |i| list << self[i] }
  list
end

def implied_xpath_contexts # :nodoc:
  [".//", "self::"]
end

def index(node)
  each_with_index { |member, j| return j if member == node }
  nil
end

def initialize document, list = []
  @document = document
  document.decorate(self)
  list.each { |x| self << x }
  yield self if block_given?
end

def inner_html *args
  collect{|j| j.inner_html(*args) }.join('')
end

def inner_text
  collect(&:inner_text).join('')
end

def inspect
  "[#{map(&:inspect).join ', '}]"
end

def last
  self[-1]
end

def pop
  return nil if length == 0
  delete last
end

def remove_attr name
  each { |el| el.delete name }
  self
end

def remove_class name = nil
  each do |el|
    if name
      classes = el['class'].to_s.split(/\s+/)
      if classes.empty?
        el.delete 'class'
      else
        el['class'] = (classes - [name]).uniq.join " "
      end
    else
      el.delete "class"
    end
  end
  self
end

def reverse
  node_set = NodeSet.new(document)
  (length - 1).downto(0) do |x|
    node_set.push self[x]
  end
  node_set
end

def shift
  return nil if length == 0
  delete first
end

def to_html *args
  if Nokogiri.jruby?
    options = args.first.is_a?(Hash) ? args.shift : {}
    if !options[:save_with]
      options[:save_with] = Node::SaveOptions::NO_DECLARATION | Node::SaveOptions::NO_EMPTY_TAGS | Node::SaveOptions::AS_HTML
    end
    args.insert(0, options)
  end
  map { |x| x.to_html(*args) }.join
end

def to_s
  map(&:to_s).join
end

def to_xhtml *args
  map { |x| x.to_xhtml(*args) }.join
end

def to_xml *args
  map { |x| x.to_xml(*args) }.join
end

def wrap(html, &blk)
  each do |j|
    new_parent = document.parse(html).first
    j.add_next_sibling(new_parent)
    new_parent.add_child(j)
  end
  self
end

def xpath *args
  paths, handler, ns, binds = extract_params(args)
  inject(NodeSet.new(document)) do |set, node|
    set += node.xpath(*(paths + [ns, handler, binds].compact))
  end
end