class Nokogiri::XML::Node

def <=> other
  return nil unless other.is_a?(Nokogiri::XML::Node)
  return nil unless document == other.document
  compare other
end

def == other
  return false unless other
  return false unless other.respond_to?(:pointer_id)
  pointer_id == other.pointer_id
end

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

def [] name
  return nil unless key?(name.to_s)
  get(name.to_s)
end

def accept visitor
  visitor.visit(self)
end

def add_child node_or_tags
  node_or_tags = coerce(node_or_tags)
  if node_or_tags.is_a?(XML::NodeSet)
    node_or_tags.each { |n| add_child_node n }
  else
    add_child_node node_or_tags
  end
  node_or_tags
end

def add_next_sibling node_or_tags
  node_or_tags = coerce(node_or_tags)
  if node_or_tags.is_a?(XML::NodeSet)
    if text?
      pivot = Nokogiri::XML::Node.new 'dummy', document
      add_next_sibling_node pivot
    else
      pivot = self
    end
    node_or_tags.reverse.each { |n| pivot.send :add_next_sibling_node, n }
    pivot.unlink if text?
  else
    add_next_sibling_node node_or_tags
  end
  node_or_tags
end

def add_previous_sibling node_or_tags
  node_or_tags = coerce(node_or_tags)
  if node_or_tags.is_a?(XML::NodeSet)
    if text?
      pivot = Nokogiri::XML::Node.new 'dummy', document
      add_previous_sibling_node pivot
    else
      pivot = self
    end
    node_or_tags.each { |n| pivot.send :add_previous_sibling_node, n }
    pivot.unlink if text?
  else
    add_previous_sibling_node node_or_tags
  end
  node_or_tags
end

def after node_or_tags
  add_next_sibling node_or_tags
  self
end

def ancestors selector = nil
  return NodeSet.new(document) unless respond_to?(:parent)
  return NodeSet.new(document) unless parent
  parents = [parent]
  while parents.last.respond_to?(:parent)
    break unless ctx_parent = parents.last.parent
    parents << ctx_parent
  end
  return NodeSet.new(document, parents) unless selector
  root = parents.last
  NodeSet.new(document, parents.find_all { |parent|
    root.search(selector).include?(parent)
  })
end

def at path, ns = document.root ? document.root.namespaces : {}
  search(path, ns).first
end

def at_css *rules
  css(*rules).first
end

def at_xpath *paths
  xpath(*paths).first
end

def attributes
  Hash[*(attribute_nodes.map { |node|
    [node.node_name, node]
  }.flatten)]
end

def before node_or_tags
  add_previous_sibling node_or_tags
  self
end

def cdata?
  type == CDATA_SECTION_NODE
end

def children= node_or_tags
  node_or_tags = coerce(node_or_tags)
  children.unlink
  if node_or_tags.is_a?(XML::NodeSet)
    node_or_tags.each { |n| add_child_node n }
  else
    add_child_node node_or_tags
  end
  node_or_tags
end

def coerce data # :nodoc:
  return data                    if data.is_a?(XML::NodeSet)
  return data.children           if data.is_a?(XML::DocumentFragment)
  return fragment(data).children if data.is_a?(String)
  if data.is_a?(Document) || !data.is_a?(XML::Node)
    raise ArgumentError, <<-EOERR
es a Node, NodeSet or String argument, and cannot accept a #{data.class}.
robably want to select a node from the Document with at() or search(), or create a new Node via Node.new().)
    EOERR
  end
  data
end

def comment?
  type == COMMENT_NODE
end

def content= string
  self.native_content = encode_special_chars(string.to_s)
end

def css *rules
  rules, handler, ns, binds = extract_params(rules)
  prefix = "#{implied_xpath_context}/"
  rules = rules.map { |rule|
    CSS.xpath_for(rule, :prefix => prefix, :ns => ns)
  }.flatten.uniq + [ns, handler, binds].compact
  xpath(*rules)
end

def css_path
  path.split(/\//).map { |part|
    part.length == 0 ? nil : part.gsub(/\[(\d+)\]/, ':nth-of-type(\1)')
  }.compact.join(' > ')
end

def decorate!
  document.decorate(self)
end

def default_namespace= url
  add_namespace_definition(nil, url)
end

def description
  return nil if document.xml?
  Nokogiri::HTML::ElementDescription[name]
end

def each &block
  attribute_nodes.each { |node|
    block.call([node.node_name, node.value])
  }
end

def element?
  type == ELEMENT_NODE
end

def extract_params params # :nodoc:
  # Pop off our custom function handler if it exists
  handler = params.find { |param|
    ![Hash, String, Symbol].include?(param.class)
  }
  params -= [handler] if handler
  hashes = []
  hashes << params.pop while Hash === params.last || params.last.nil?
  ns, binds = hashes.reverse
  ns ||= document.root ? document.root.namespaces : {}
  [params, handler, ns, binds]
end

def fragment tags
  type = document.html? ? Nokogiri::HTML : Nokogiri::XML
  type::DocumentFragment.new(document, tags, self)
end

def fragment?
  type == DOCUMENT_FRAG_NODE
end

def html?
  type == HTML_DOCUMENT_NODE
end

def implied_xpath_context
  "./"
end

def initialize name, document # :nodoc:
  # ... Ya.  This is empty on purpose.
end

def inner_html *args
  children.map { |x| x.to_html(*args) }.join
end

def inner_html= node_or_tags
  self.children = node_or_tags
  self
end

def inspect_attributes
  [:name, :namespace, :attribute_nodes, :children]
end

def keys
  attribute_nodes.map { |node| node.node_name }
end

def matches? selector
  ancestors.last.search(selector).include?(self)
end

def namespace= ns
  return set_namespace(ns) unless ns
  unless Nokogiri::XML::Namespace === ns
    raise TypeError, "#{ns.class} can't be coerced into Nokogiri::XML::Namespace"
  end
  if ns.document != document
    raise ArgumentError, 'namespace must be declared on the same document'
  end
  set_namespace ns
end

def namespaces
  Hash[*namespace_scopes.map { |nd|
    key = ['xmlns', nd.prefix].compact.join(':')
    if RUBY_VERSION >= '1.9' && document.encoding
      begin
        key.force_encoding document.encoding
      rescue ArgumentError
      end
    end
    [key, nd.href]
  }.flatten]
end

def parent= parent_node
  parent_node.add_child(self)
  parent_node
end

def parse string_or_io, options = nil
  options ||= (document.html? ? ParseOptions::DEFAULT_HTML : ParseOptions::DEFAULT_XML)
  if Fixnum === options
    options = Nokogiri::XML::ParseOptions.new(options)
  end
  # Give the options to the user
  yield options if block_given?
  contents = string_or_io.respond_to?(:read) ?
    string_or_io.read :
    string_or_io
  return Nokogiri::XML::NodeSet.new(document) if contents.empty?
  ##
  # This is a horrible hack, but I don't care. See #313 for background.
  error_count = document.errors.length
  node_set = in_context(contents, options.to_i)
  if node_set.empty? and document.errors.length > error_count and options.recover?
    fragment = Nokogiri::HTML::DocumentFragment.parse contents
    node_set = fragment.children
  end
  node_set
end

def read_only?
  # According to gdome2, these are read-only node types
  [NOTATION_NODE, ENTITY_NODE, ENTITY_DECL].include?(type)
end

def remove_attribute name
  attributes[name].remove if key? name
end

def replace node_or_tags
  node_or_tags = coerce(node_or_tags)
  if node_or_tags.is_a?(XML::NodeSet)
    if text?
      replacee = Nokogiri::XML::Node.new 'dummy', document
      add_previous_sibling_node replacee
      unlink
    else
      replacee = self
    end
    node_or_tags.each { |n| replacee.add_previous_sibling n }
    replacee.unlink
  else
    replace_node node_or_tags
  end
  node_or_tags
end

def search *paths
  # TODO use         paths, handler, ns, binds = extract_params(paths)
  ns = paths.last.is_a?(Hash) ? paths.pop :
    (document.root ? document.root.namespaces : {})
  prefix = "#{implied_xpath_context}/"
  xpath(*(paths.map { |path|
    path = path.to_s
    path =~ /^(\.\/|\/)/ ? path : CSS.xpath_for(
      path,
      :prefix => prefix,
      :ns     => ns
    )
  }.flatten.uniq) + [ns])
end

def serialize *args, &block
  options = args.first.is_a?(Hash) ? args.shift : {
    :encoding   => args[0],
    :save_with  => args[1] || SaveOptions::FORMAT
  }
  encoding = options[:encoding] || document.encoding
  outstring = ""
  if encoding && outstring.respond_to?(:force_encoding)
    outstring.force_encoding(Encoding.find(encoding))
  end
  io = StringIO.new(outstring)
  write_to io, options, &block
  io.string
end

def swap node_or_tags
  replace node_or_tags
  self
end

def text?
  type == TEXT_NODE
end

def to_html options = {}
  # FIXME: this is a hack around broken libxml versions
  return dump_html if Nokogiri.uses_libxml? && %w[2 6] === LIBXML_VERSION.split('.')[0..1]
  options[:save_with] ||= SaveOptions::FORMAT |
                          SaveOptions::NO_DECLARATION |
                          SaveOptions::NO_EMPTY_TAGS |
                          SaveOptions::AS_HTML
  serialize(options)
end

def to_s
  document.xml? ? to_xml : to_html
end

def to_xhtml options = {}
  # FIXME: this is a hack around broken libxml versions
  return dump_html if Nokogiri.uses_libxml? && %w[2 6] === LIBXML_VERSION.split('.')[0..1]
  options[:save_with] ||= SaveOptions::FORMAT |
                          SaveOptions::NO_DECLARATION |
                          SaveOptions::NO_EMPTY_TAGS |
                          SaveOptions::AS_XHTML
  serialize(options)
end

def to_xml options = {}
  options[:save_with] ||= SaveOptions::FORMAT | SaveOptions::AS_XML
  serialize(options)
end

def traverse &block
  children.each{|j| j.traverse(&block) }
  block.call(self)
end

def values
  attribute_nodes.map { |node| node.value }
end

def write_html_to io, options = {}
  # FIXME: this is a hack around broken libxml versions
  return (io << dump_html) if Nokogiri.uses_libxml? && %w[2 6] === LIBXML_VERSION.split('.')[0..1]
  options[:save_with] ||= SaveOptions::FORMAT |
    SaveOptions::NO_DECLARATION |
    SaveOptions::NO_EMPTY_TAGS |
    SaveOptions::AS_HTML
  write_to io, options
end

def write_to io, *options
  options       = options.first.is_a?(Hash) ? options.shift : {}
  encoding      = options[:encoding] || options[0]
  save_options  = options[:save_with] || options[1] || SaveOptions::FORMAT
  indent_text   = options[:indent_text] || ' '
  indent_times  = options[:indent] || 2
  config = SaveOptions.new(save_options)
  yield config if block_given?
  native_write_to(io, encoding, indent_text * indent_times, config.options)
end

def write_xhtml_to io, options = {}
  # FIXME: this is a hack around broken libxml versions
  return (io << dump_html) if Nokogiri.uses_libxml? && %w[2 6] === LIBXML_VERSION.split('.')[0..1]
  options[:save_with] ||= SaveOptions::FORMAT |
    SaveOptions::NO_DECLARATION |
    SaveOptions::NO_EMPTY_TAGS |
    SaveOptions::AS_XHTML
  write_to io, options
end

def write_xml_to io, options = {}
  options[:save_with] ||= SaveOptions::FORMAT | SaveOptions::AS_XML
  write_to io, options
end

def xml?
  type == DOCUMENT_NODE
end

def xpath *paths
  return NodeSet.new(document) unless document
  paths, handler, ns, binds = extract_params(paths)
  sets = paths.map { |path|
    ctx = XPathContext.new(self)
    ctx.register_namespaces(ns)
    path = path.gsub(/\/xmlns:/,'/:') unless Nokogiri.uses_libxml?
    binds.each do |key,value|
      ctx.register_variable key.to_s, value
    end if binds
    ctx.evaluate(path, handler)
  }
  return sets.first if sets.length == 1
  NodeSet.new(document) do |combined|
    sets.each do |set|
      set.each do |node|
        combined << node
      end
    end
  end
end