class Nokogiri::XML::Node

def <<(node_or_tags)
  add_child node_or_tags
  self
end

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)
  get(name.to_s)
end

def []=(name, value)
  set name.to_s, value.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_and_reparent_attrs n }
  else
    add_child_node_and_reparent_attrs node_or_tags
  end
  node_or_tags
end

def add_child_node_and_reparent_attrs(node)
  add_child_node node
  node.attribute_nodes.find_all { |a| a.name =~ /:/ }.each do |attr_node|
    attr_node.remove
    node[attr_node.name] = attr_node.value
  end
end

def add_class(names)
  kwattr_add("class", names)
end

def add_next_sibling(node_or_tags)
  raise ArgumentError.new("A document may not have multiple root nodes.") if (parent && parent.document?) && !(node_or_tags.comment? || node_or_tags.processing_instruction?)
  add_sibling :next, node_or_tags
end

def add_previous_sibling(node_or_tags)
  raise ArgumentError.new("A document may not have multiple root nodes.") if (parent && parent.document?) && !(node_or_tags.comment? || node_or_tags.processing_instruction?)
  add_sibling :previous, node_or_tags
end

def add_sibling(next_or_previous, node_or_tags)
  raise("Cannot add sibling to a node with no parent") unless parent
  impl = (next_or_previous == :next) ? :add_next_sibling_node : :add_previous_sibling_node
  iter = (next_or_previous == :next) ? :reverse_each : :each
  node_or_tags = parent.coerce(node_or_tags)
  if node_or_tags.is_a?(XML::NodeSet)
    if text?
      pivot = Nokogiri::XML::Node.new "dummy", document
      send impl, pivot
    else
      pivot = self
    end
    node_or_tags.send(iter) { |n| pivot.send impl, n }
    pivot.unlink if text?
  else
    send impl, 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
  search_results = root.search(selector)
  NodeSet.new(document, parents.find_all { |parent|
    search_results.include?(parent)
  })
end

def append_class(names)
  kwattr_append("class", names)
end

def attributes
  attribute_nodes.each_with_object({}) do |node, hash|
    hash[node.node_name] = node
  end
end

def before(node_or_tags)
  add_previous_sibling node_or_tags
  self
end

def canonicalize(mode = XML::XML_C14N_1_0, inclusive_namespaces = nil, with_comments = false)
  c14n_root = self
  document.canonicalize(mode, inclusive_namespaces, with_comments) do |node, parent|
    tn = node.is_a?(XML::Node) ? node : parent
    tn == c14n_root || tn.ancestors.include?(c14n_root)
  end
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_and_reparent_attrs n }
  else
    add_child_node_and_reparent_attrs node_or_tags
  end
  node_or_tags
end

def classes
  kwattr_values("class")
end

def coerce(data)
  case data
  when XML::NodeSet
    return data
  when XML::DocumentFragment
    return data.children
  when String
    return fragment(data).children
  when Document, XML::Attr
    # unacceptable
  when XML::Node
    return data
  end
  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

def comment?
  type == COMMENT_NODE
end

def content=(string)
  self.native_content = encode_special_chars(string.to_s)
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::HTML4::ElementDescription[name]
end

def do_xinclude(options = XML::ParseOptions::DEFAULT_XML)
  options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
  # give options to user
  yield options if block_given?
  # call c extension
  process_xincludes(options.to_i)
end

def document?
  is_a? XML::Document
end

def each
  attribute_nodes.each { |node|
    yield [node.node_name, node.value]
  }
end

def element?
  type == ELEMENT_NODE
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 initialize(name, document)
  # This is intentionally empty.
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_name)
end

def keywordify(keywords)
  case keywords
  when Enumerable
    return keywords
  when String
    return keywords.scan(/\S+/)
  else
    raise ArgumentError.new("Keyword attributes must be passed as either a String or an Enumerable, but received #{keywords.class}")
  end
end

def kwattr_add(attribute_name, keywords)
  keywords = keywordify(keywords)
  current_kws = kwattr_values(attribute_name)
  new_kws = (current_kws + (keywords - current_kws)).join(" ")
  set_attribute(attribute_name, new_kws)
  self
end

def kwattr_append(attribute_name, keywords)
  keywords = keywordify(keywords)
  current_kws = kwattr_values(attribute_name)
  new_kws = (current_kws + keywords).join(" ")
  set_attribute(attribute_name, new_kws)
  self
end

def kwattr_remove(attribute_name, keywords)
  if keywords.nil?
    remove_attribute(attribute_name)
    return self
  end
  keywords = keywordify(keywords)
  current_kws = kwattr_values(attribute_name)
  new_kws = current_kws - keywords
  if new_kws.empty?
    remove_attribute(attribute_name)
  else
    set_attribute(attribute_name, new_kws.join(" "))
  end
  self
end

def kwattr_values(attribute_name)
  keywordify(get_attribute(attribute_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
  namespace_scopes.each_with_object({}) do |ns, hash|
    prefix = ns.prefix
    key = prefix ? "xmlns:#{prefix}" : "xmlns"
    hash[key] = ns.href
  end
end

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

def parse(string_or_io, options = nil)
  ##
  # When the current node is unparented and not an element node, use the
  # document as the parsing context instead. Otherwise, the in-context
  # parser cannot find an element or a document node.
  # Document Fragments are also not usable by the in-context parser.
  if !element? && !document? && (!parent || parent.fragment?)
    return document.parse(string_or_io, options)
  end
  options ||= (document.html? ? ParseOptions::DEFAULT_HTML : ParseOptions::DEFAULT_XML)
  if Integer === 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?
  # libxml2 does not obey the `recover` option after encountering errors during `in_context`
  # parsing, and so this horrible hack is here to try to emulate recovery behavior.
  #
  # Unfortunately, this means we're no longer parsing "in context" and so namespaces that
  # would have been inherited from the context node won't be handled correctly. This hack was
  # written in 2010, and I regret it, because it's silently degrading functionality in a way
  # that's not easily prevented (or even detected).
  #
  # I think preferable behavior would be to either:
  #
  # a. add an error noting that we "fell back" and pointing the user to turning off the `recover` option
  # b. don't recover, but raise a sensible exception
  #
  # For context and background: https://github.com/sparklemotion/nokogiri/issues/313
  # FIXME bug report: https://github.com/sparklemotion/nokogiri/issues/2092
  error_count = document.errors.length
  node_set = in_context(contents, options.to_i)
  if (node_set.empty? && (document.errors.length > error_count))
    if options.recover?
      fragment = Nokogiri::HTML4::DocumentFragment.parse contents
      node_set = fragment.children
    else
      raise document.errors[error_count]
    end
  end
  node_set
end

def prepend_child(node_or_tags)
  if first = children.first
    # Mimic the error add_child would raise.
    raise RuntimeError, "Document already has a root node" if document? && !(node_or_tags.comment? || node_or_tags.processing_instruction?)
    first.__send__(:add_sibling, :previous, node_or_tags)
  else
    add_child(node_or_tags)
  end
end

def processing_instruction?
  type == PI_NODE
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)
  attr = attributes[name].remove if key? name
  clear_xpath_context if Nokogiri.jruby?
  attr
end

def remove_class(names = nil)
  kwattr_remove("class", names)
end

def replace(node_or_tags)
  raise("Cannot replace a node with no parent") unless parent
  # We cannot replace a text node directly, otherwise libxml will return
  # an internal error at parser.c:13031, I don't know exactly why
  # libxml is trying to find a parent node that is an element or document
  # so I can't tell if this is bug in libxml or not. issue #775.
  if text?
    replacee = Nokogiri::XML::Node.new "dummy", document
    add_previous_sibling_node replacee
    unlink
    return replacee.replace node_or_tags
  end
  node_or_tags = parent.coerce(node_or_tags)
  if node_or_tags.is_a?(XML::NodeSet)
    node_or_tags.each { |n| add_previous_sibling n }
    unlink
  else
    replace_node node_or_tags
  end
  node_or_tags
end

def serialize(*args, &block)
  options = args.first.is_a?(Hash) ? args.shift : {
    :encoding => args[0],
    :save_with => args[1],
  }
  encoding = options[:encoding] || document.encoding
  options[:encoding] = encoding
  outstring = String.new
  outstring.force_encoding(Encoding.find(encoding || "utf-8"))
  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_format(save_option, options)
  return dump_html if USING_LIBXML_WITH_BROKEN_SERIALIZATION
  options[:save_with] = save_option unless options[:save_with]
  serialize(options)
end

def to_html(options = {})
  to_format SaveOptions::DEFAULT_HTML, options
end

def to_s
  document.xml? ? to_xml : to_html
end

def to_xhtml(options = {})
  to_format SaveOptions::DEFAULT_XHTML, options
end

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

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

def value?(value)
  values.include? value
end

def values
  attribute_nodes.map(&:value)
end

def wrap(html)
  new_parent = document.parse(html).first
  add_next_sibling(new_parent)
  new_parent.add_child(self)
  self
end

def write_format_to(save_option, io, options)
  return (io << dump_html) if USING_LIBXML_WITH_BROKEN_SERIALIZATION
  options[:save_with] ||= save_option
  write_to io, options
end

def write_html_to(io, options = {})
  write_format_to SaveOptions::DEFAULT_HTML, io, options
end

def write_to(io, *options)
  options = options.first.is_a?(Hash) ? options.shift : {}
  encoding = options[:encoding] || options[0]
  if Nokogiri.jruby?
    save_options = options[:save_with] || options[1]
    indent_times = options[:indent] || 0
  else
    save_options = options[:save_with] || options[1] || SaveOptions::FORMAT
    indent_times = options[:indent] || 2
  end
  indent_text = options[:indent_text] || " "
  # Any string times 0 returns an empty string. Therefore, use the same
  # string instead of generating a new empty string for every node with
  # zero indentation.
  indentation = indent_times.zero? ? "" : (indent_text * indent_times)
  config = SaveOptions.new(save_options.to_i)
  yield config if block_given?
  native_write_to(io, encoding, indentation, config.options)
end

def write_xhtml_to(io, options = {})
  write_format_to SaveOptions::DEFAULT_XHTML, io, options
end

def write_xml_to(io, options = {})
  options[:save_with] ||= SaveOptions::DEFAULT_XML
  write_to io, options
end

def xml?
  type == DOCUMENT_NODE
end