XmlNode.java

package nokogiri;

import static java.lang.Math.max;
import static nokogiri.internals.NokogiriHelpers.*;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.util.*;

import org.apache.xerces.dom.CoreDocumentImpl;
import org.jruby.Ruby;
import org.jruby.RubyArray;
import org.jruby.RubyBoolean;
import org.jruby.RubyClass;
import org.jruby.RubyFixnum;
import org.jruby.RubyInteger;
import org.jruby.RubyModule;
import org.jruby.RubyObject;
import org.jruby.RubyString;
import org.jruby.anno.JRubyClass;
import org.jruby.anno.JRubyMethod;
import org.jruby.exceptions.RaiseException;
import org.jruby.runtime.Block;
import org.jruby.runtime.Helpers;
import org.jruby.runtime.ThreadContext;
import org.jruby.runtime.Visibility;
import org.jruby.runtime.builtin.IRubyObject;
import org.jruby.util.ByteList;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentFragment;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;
import org.w3c.dom.Comment;

import nokogiri.internals.HtmlDomParserContext;
import nokogiri.internals.NokogiriHelpers;
import nokogiri.internals.NokogiriNamespaceCache;
import nokogiri.internals.SaveContextVisitor;
import nokogiri.internals.XmlDomParserContext;

/**
 * Class for Nokogiri::XML::Node
 *
 * @author sergio
 * @author Patrick Mahoney <pat@polycrystal.org>
 * @author Yoko Harada <yokolet@gmail.com>
 * @author John Shahid <jvshahid@gmail.com>
 */
@JRubyClass(name = "Nokogiri::XML::Node")
public class XmlNode extends RubyObject
{
  protected static final String TEXT_WRAPPER_NAME = "nokogiri_text_wrapper";

  /** The underlying Node object. */
  protected Node node;

  /* Cached objects */
  protected IRubyObject content = null;
  private transient XmlDocument doc;
  protected transient RubyString name;

  /*
   * Taken from http://ejohn.org/blog/comparing-document-position/
   * Used for compareDocumentPosition.
   * <ironic>Thanks to both java api and w3 doc for its helpful documentation</ironic>
   */

  protected static final int IDENTICAL_ELEMENTS = 0;
  protected static final int IN_DIFFERENT_DOCUMENTS = 1;
  protected static final int SECOND_PRECEDES_FIRST = 2;
  protected static final int FIRST_PRECEDES_SECOND = 4;
  protected static final int SECOND_CONTAINS_FIRST = 8;
  protected static final int FIRST_CONTAINS_SECOND = 16;

  /**
   * Cast <code>node</code> to an XmlNode or raise a type error
   * in <code>context</code>.
   */
  protected static XmlNode
  asXmlNode(ThreadContext context, IRubyObject node)
  {
    if (!(node instanceof XmlNode)) {
      final Ruby runtime = context.runtime;
      throw runtime.newTypeError(node == null ? runtime.getNil() : node, getNokogiriClass(runtime, "Nokogiri::XML::Node"));
    }
    return (XmlNode) node;
  }

  /**
   * Cast <code>node</code> to an XmlNode, or null if RubyNil, or
   * raise a type error in <code>context</code>.
   */
  protected static XmlNode
  asXmlNodeOrNull(ThreadContext context, IRubyObject node)
  {
    if (node == null || node.isNil()) { return null; }
    return asXmlNode(context, node);
  }

  /**
   * Coalesce to adjacent TextNodes.
   * @param context
   * @param prev Previous node to cur.
   * @param cur Next node to prev.
   */
  public static void
  coalesceTextNodes(ThreadContext context, IRubyObject prev, IRubyObject cur)
  {
    XmlNode p = asXmlNode(context, prev);
    XmlNode c = asXmlNode(context, cur);

    Node pNode = p.node;
    Node cNode = c.node;

    pNode.setNodeValue(pNode.getNodeValue() + cNode.getNodeValue());
    p.content = null;       // clear cached content

    c.assimilateXmlNode(context, p);
  }

  /**
   * Coalesce text nodes around <code>anchorNode</code>.  If
   * <code>anchorNode</code> has siblings (previous or next) that
   * are text nodes, the content will be merged into
   * <code>anchorNode</code> and the redundant nodes will be removed
   * from the DOM.
   *
   * To match libxml behavior (?) the final content of
   * <code>anchorNode</code> and any removed nodes will be
   * identical.
   *
   * @param context
   * @param anchorNode
   */
  protected static void
  coalesceTextNodes(ThreadContext context,
                    IRubyObject anchorNode,
                    AdoptScheme scheme)
  {
    XmlNode xa = asXmlNode(context, anchorNode);

    XmlNode xp = asXmlNodeOrNull(context, xa.previous_sibling(context));
    XmlNode xn = asXmlNodeOrNull(context, xa.next_sibling(context));

    Node p = xp == null ? null : xp.node;
    Node a = xa.node;
    Node n = xn == null ? null : xn.node;

    Node parent = a.getParentNode();

    boolean shouldMergeP = scheme == AdoptScheme.NEXT_SIBLING || scheme == AdoptScheme.CHILD
                           || scheme == AdoptScheme.REPLACEMENT;
    boolean shouldMergeN = scheme == AdoptScheme.PREV_SIBLING || scheme == AdoptScheme.REPLACEMENT;

    // apply the merge right to left
    if (shouldMergeN && n != null && n.getNodeType() == Node.TEXT_NODE) {
      xa.setContent(a.getNodeValue() + n.getNodeValue());
      parent.removeChild(n);
      xn.assimilateXmlNode(context, xa);
    }
    if (shouldMergeP && p != null && p.getNodeType() == Node.TEXT_NODE) {
      xp.setContent(p.getNodeValue() + a.getNodeValue());
      parent.removeChild(a);
      xa.assimilateXmlNode(context, xp);
    }
  }

  /**
   * This is the allocator for XmlNode class.  It should only be
   * called from Ruby code.
   */
  public
  XmlNode(Ruby runtime, RubyClass klass)
  {
    super(runtime, klass);
  }

  /**
   * This is a constructor to create an XmlNode from an already
   * existing node.  It may be called by Java code.
   */
  public
  XmlNode(Ruby runtime, RubyClass klass, Node node)
  {
    super(runtime, klass);
    setNode(runtime, node);
  }

  protected void
  decorate(final Ruby runtime)
  {
    if (node != null) {
      resetCache();

      if (node.getNodeType() != Node.DOCUMENT_NODE) {
        setDocumentAndDecorate(runtime.getCurrentContext(), this, document(runtime));
      }
    }
  }

  /**
   * Create and return a copy of this object.
   *
   * @return a clone of this object
   */
  @Override
  public Object
  clone() throws CloneNotSupportedException
  {
    return super.clone();
  }

  protected void
  resetCache()
  {
    node.setUserData(NokogiriHelpers.CACHED_NODE, this, null);
  }

  /**
   * Allocate a new object, perform initialization, call that
   * object's initialize method, and call any block passing the
   * object as the only argument.  If <code>cls</code> is
   * Nokogiri::XML::Node, creates a new Nokogiri::XML::Element
   * instead.
   *
   * This static method seems to be inherited, strangely enough.
   * E.g. creating a new XmlAttr from Ruby code calls this method if
   * XmlAttr does not define its own 'new' method.
   *
   * Since there is some Java bookkeeping that always needs to
   * happen, we don't define the 'initialize' method in Java because
   * we'd have to count on subclasses calling 'super'.
   *
   * The main consequence of this is that every subclass needs to
   * define its own 'new' method.
   *
   * As a convenience, this method does the following:
   *
   * <ul>
   *
   * <li>allocates a new object using the allocator assigned to
   * <code>cls</code></li>
   *
   * <li>calls the Java method init(); subclasses can override this,
   * otherwise they should implement a specific 'new' method</li>
   *
   * <li>invokes the Ruby initializer</li>
   *
   * <li>if a block is given, calls the block with the new node as
   * the argument</li>
   *
   * </ul>
   *
   * -pmahoney
   */
  @JRubyMethod(name = "new", meta = true, rest = true)
  public static IRubyObject
  rbNew(ThreadContext context, IRubyObject cls,
        IRubyObject[] args, Block block)
  {
    Ruby ruby = context.runtime;
    RubyClass klazz = (RubyClass) cls;

    if ("Nokogiri::XML::Node".equals(klazz.getName())) {
      klazz = getNokogiriClass(ruby, "Nokogiri::XML::Element");
    }

    XmlNode xmlNode = (XmlNode) klazz.allocate();
    xmlNode.init(context, args);
    xmlNode.callInit(args, block);
    assert xmlNode.node != null;
    if (block.isGiven()) { block.call(context, xmlNode); }
    return xmlNode;
  }

  /**
   * Initialize the object from Ruby arguments.  Should be
   * overridden by subclasses.  Should check for a minimum number of
   * args but not for an exact number.  Any extra args will then be
   * passed to 'initialize'.  The way 'new' and this 'init' function
   * interact means that subclasses cannot arbitrarily change the
   * require aruments by defining an 'initialize' method.  This is
   * how the C libxml wrapper works also.
   *
   * As written it performs initialization for a new Element with
   * the given <code>name</code> within the document
   * <code>doc</code>.  So XmlElement need not override this.  This
   * implementation cannot be moved to XmlElement however, because
   * subclassing XmlNode must result in something that behaves much
   * like XmlElement.
   */
  protected void
  init(ThreadContext context, IRubyObject[] args)
  {
    if (args.length < 2) {
      throw context.runtime.newArgumentError(args.length, 2);
    }

    IRubyObject name = args[0];
    IRubyObject doc = args[1];

    Document document = asXmlNode(context, doc).getOwnerDocument();
    if (document == null) {
      throw context.runtime.newArgumentError("node must have owner document");
    }

    Element element;
    String node_name = rubyStringToString(name);
    String prefix = NokogiriHelpers.getPrefix(node_name);
    String namespace_uri = null;
    if (document.getDocumentElement() != null) {
      namespace_uri = document.getDocumentElement().lookupNamespaceURI(prefix);
    }
    element = document.createElementNS(namespace_uri, node_name);
    setNode(context.runtime, element);
  }

  /**
   * Set the underlying node of this node to the underlying node of
   * <code>otherNode</code>.
   *
   * FIXME: also update the cached node?
   */
  protected void
  assimilateXmlNode(ThreadContext context, IRubyObject otherNode)
  {
    XmlNode toAssimilate = asXmlNode(context, otherNode);

    this.node = toAssimilate.node;
    content = null;         // clear cache
  }

  /**
   * See org.w3.dom.Node#normalize.
   */
  public void
  normalize()
  {
    node.normalize();
  }

  public Node
  getNode()
  {
    return node;
  }

  public boolean
  isComment() { return false; }

  public boolean
  isElement()
  {
    if (node instanceof Element) { return true; } // in case of subclassing
    else { return false; }
  }

  public boolean
  isProcessingInstruction() { return false; }

  /**
   * Return the string value of the attribute <code>key</code> or
   * nil.
   *
   * Only applies where the underlying Node is an Element node, but
   * implemented here in XmlNode because not all nodes with
   * underlying Element nodes subclass XmlElement, such as the DTD
   * declarations like XmlElementDecl.
   */
  protected IRubyObject
  getAttribute(ThreadContext context, String key)
  {
    return getAttribute(context.runtime, key);
  }

  protected IRubyObject
  getAttribute(Ruby runtime, String key)
  {
    String value = getAttribute(key);
    return nonEmptyStringOrNil(runtime, value);
  }

  protected String
  getAttribute(String key)
  {
    if (node.getNodeType() != Node.ELEMENT_NODE) { return null; }

    String value = ((Element)node).getAttribute(key);
    return value.length() == 0 ? null : value;
  }

  /**
   * This method should be called after a node has been adopted in a new
   * document. This method will ensure that the node is renamed with the
   * appriopriate NS uri. First the prefix of the node is extracted, then is
   * used to lookup the namespace uri in the new document starting at the
   * current node and traversing the ancestors. If the namespace uri wasn't
   * empty (or null) all children and the node has attributes and/or children
   * then the algorithm is recursively applied to the children.
   */
  public void
  relink_namespace(ThreadContext context)
  {
    if (!(node instanceof Element)) {
      return;
    }

    Element e = (Element) node;

    // disable error checking to prevent lines like the following
    // from throwing a `NAMESPACE_ERR' exception:
    // Nokogiri::XML::DocumentFragment.parse("<o:div>a</o:div>")
    // since the `o' prefix isn't defined anywhere.
    e.getOwnerDocument().setStrictErrorChecking(false);

    String prefix = e.getPrefix();
    String nsURI = e.lookupNamespaceURI(prefix);
    this.node = NokogiriHelpers.renameNode(e, nsURI, e.getNodeName());

    if (nsURI == null || nsURI.isEmpty()) {
      RubyBoolean ns_inherit =
        (RubyBoolean)document(context.runtime).getInstanceVariable("@namespace_inheritance");
      if (ns_inherit.isTrue()) {
        set_namespace(context, ((XmlNode)parent(context)).namespace(context));
      }
      return;
    }

    String currentPrefix = e.getParentNode().lookupPrefix(nsURI);
    String currentURI = e.getParentNode().lookupNamespaceURI(prefix);
    boolean isDefault = e.getParentNode().isDefaultNamespace(nsURI);

    // add xmlns attribute if this is a new root node or if the node's
    // namespace isn't a default namespace in the new document
    if (e.getParentNode().getNodeType() == Node.DOCUMENT_NODE) {
      // this is the root node, so we must set the namespaces attributes anyway
      e.setAttribute(prefix == null ? "xmlns" : "xmlns:" + prefix, nsURI);
    } else if (prefix == null) {
      // this is a default namespace but isn't the default where this node is being added
      if (!isDefault) { e.setAttribute("xmlns", nsURI); }
    } else if (!prefix.equals(currentPrefix) || nsURI.equals(currentURI)) {
      // this is a prefixed namespace
      // but doesn't have the same prefix or the prefix is set to a different URI
      e.setAttribute("xmlns:" + prefix, nsURI);
    }

    if (e.hasAttributes()) {
      NamedNodeMap attrs = e.getAttributes();

      for (int i = 0; i < attrs.getLength(); i++) {
        Attr attr = (Attr) attrs.item(i);
        String attrPrefix = attr.getPrefix();
        if (attrPrefix == null) {
          attrPrefix = NokogiriHelpers.getPrefix(attr.getNodeName());
        }
        String nodeName = attr.getNodeName();
        String nsUri;
        if ("xml".equals(attrPrefix)) {
          nsUri = "http://www.w3.org/XML/1998/namespace";
        } else if ("xmlns".equals(attrPrefix) || nodeName.equals("xmlns")) {
          nsUri = "http://www.w3.org/2000/xmlns/";
        } else {
          nsUri = attr.lookupNamespaceURI(attrPrefix);
        }

        if (nsUri != null && nsUri.equals(e.getNamespaceURI())) {
          nsUri = null;
        }

        if (!(nsUri == null || "".equals(nsUri) || "http://www.w3.org/XML/1998/namespace".equals(nsUri))) {
          // Create a new namespace object and add it to the document namespace cache.
          // TODO: why do we need the namespace cache ?
          XmlNamespace.createFromAttr(context.runtime, attr);
        }
        NokogiriHelpers.renameNode(attr, nsUri, nodeName);
      }
    }

    if (this.node.hasChildNodes()) {
      relink_namespace(context, getChildren());
    }
  }

  static void
  relink_namespace(ThreadContext context, IRubyObject[] nodes)
  {
    for (int i = 0; i < nodes.length; i++) {
      if (nodes[i] instanceof XmlNode) {
        ((XmlNode) nodes[i]).relink_namespace(context);
      }
    }
  }

  // Users might extend XmlNode. This method works for such a case.
  public void
  accept(ThreadContext context, SaveContextVisitor visitor)
  {
    visitor.enter(node);
    acceptChildren(context, getChildren(), visitor);
    visitor.leave(node);
  }

  void
  acceptChildren(ThreadContext context, IRubyObject[] nodes, SaveContextVisitor visitor)
  {
    if (nodes.length > 0) {
      for (int i = 0; i < nodes.length; i++) {
        Object item = nodes[i];
        if (item instanceof XmlNode) {
          ((XmlNode) item).accept(context, visitor);
        } else if (item instanceof XmlNamespace) {
          ((XmlNamespace) item).accept(context, visitor);
        }
      }
    }
  }

  RubyString
  doSetName(IRubyObject name)
  {
    if (name.isNil()) { return this.name = null; }
    return this.name = name.convertToString();
  }

  public void
  setDocument(ThreadContext context, XmlDocument doc)
  {
    this.doc = doc;

    setDocumentAndDecorate(context, this, doc);
  }

  // shared logic with XmlNodeSet
  static void
  setDocumentAndDecorate(ThreadContext context, RubyObject self, XmlDocument doc)
  {
    self.setInstanceVariable("@document", doc == null ? context.nil : doc);
    if (doc != null) { Helpers.invoke(context, doc, "decorate", self); }
  }

  public void
  setNode(Ruby runtime, Node node)
  {
    this.node = node;

    decorate(runtime);

    if (this instanceof XmlAttr) {
      ((XmlAttr) this).setNamespaceIfNecessary(runtime);
    }
  }

  protected IRubyObject
  getNodeName(ThreadContext context)
  {
    if (name != null) { return name; }

    String str = null;
    if (node != null) {
      str = NokogiriHelpers.getLocalPart(node.getNodeName());
    }
    if (str == null) { str = ""; }
    if (str.startsWith("#")) { str = str.substring(1); } // eliminates '#'
    return name = context.runtime.newString(str);
  }

  /**
   * Add a namespace definition to this node.  To the underlying
   * node, add an attribute of the form
   * <code>xmlns:prefix="uri"</code>.
   */
  @JRubyMethod(name = {"add_namespace_definition", "add_namespace"})
  public IRubyObject
  add_namespace_definition(ThreadContext context, IRubyObject prefix, IRubyObject href)
  {
    String hrefStr, prefixStr = prefix.isNil() ? null : prefix.convertToString().decodeString();

    // try to search the namespace first
    if (href.isNil()) {
      hrefStr = findNamespaceHref(context, prefixStr);
      if (hrefStr == null) { return context.nil; }
      href = context.runtime.newString(hrefStr);
    } else {
      hrefStr = rubyStringToString(href.convertToString());
    }

    NokogiriNamespaceCache nsCache = NokogiriHelpers.getNamespaceCache(node);
    XmlNamespace cachedNamespace = nsCache.get(prefixStr, hrefStr);
    if (cachedNamespace != null) { return cachedNamespace; }

    Node namespaceOwner;
    if (node.getNodeType() == Node.ELEMENT_NODE) {
      namespaceOwner = node;
      Element element = (Element) node;
      // adds namespace as node's attribute
      String qName = prefix.isNil() ? "xmlns" : "xmlns:" + prefixStr;
      element.setAttributeNS("http://www.w3.org/2000/xmlns/", qName, hrefStr);
    } else if (node.getNodeType() == Node.ATTRIBUTE_NODE) { namespaceOwner = ((Attr) node).getOwnerElement(); }
    else { namespaceOwner = node.getParentNode(); }

    XmlNamespace ns = XmlNamespace.createImpl(namespaceOwner, prefix, prefixStr, href, hrefStr);

    if (node != namespaceOwner) {
      node = NokogiriHelpers.renameNode(node, ns.getHref(), ns.getPrefix() + ':' + node.getLocalName());
    }
    updateNodeNamespaceIfNecessary(ns);

    return ns;
  }

  private void
  updateNodeNamespaceIfNecessary(XmlNamespace ns)
  {
    String oldPrefix = this.node.getPrefix();

    /*
     * Update if both prefixes are null or equal
     */
    boolean update =
      (oldPrefix == null && ns.getPrefix() == null) ||
      (oldPrefix != null && oldPrefix.equals(ns.getPrefix()));

    if (update) {
      this.node = NokogiriHelpers.renameNode(this.node, ns.getHref(), this.node.getNodeName());
    }
  }

  @JRubyMethod(name = {"attribute", "attr"})
  public IRubyObject
  attribute(ThreadContext context, IRubyObject name)
  {
    NamedNodeMap attrs = this.node.getAttributes();
    Node attr = attrs.getNamedItem(rubyStringToString(name));
    if (attr == null) { return context.nil; }
    return getCachedNodeOrCreate(context.runtime, attr);
  }

  @JRubyMethod
  public IRubyObject
  attribute_nodes(ThreadContext context)
  {
    final Ruby runtime = context.runtime;

    NamedNodeMap nodeMap = this.node.getAttributes();

    if (nodeMap == null) { return runtime.newEmptyArray(); }
    RubyArray attr = runtime.newArray(nodeMap.getLength());

    final XmlDocument doc = document(context.runtime);
    for (int i = 0; i < nodeMap.getLength(); i++) {
      if ((doc instanceof Html4Document) || !NokogiriHelpers.isNamespace(nodeMap.item(i))) {
        attr.append(getCachedNodeOrCreate(runtime, nodeMap.item(i)));
      }
    }

    return attr;
  }

  @JRubyMethod
  public IRubyObject
  attribute_with_ns(ThreadContext context, IRubyObject name, IRubyObject namespace)
  {
    String namej = rubyStringToString(name);
    String nsj = (namespace.isNil()) ? null : rubyStringToString(namespace);

    Node el = this.node.getAttributes().getNamedItemNS(nsj, namej);

    if (el == null) { return context.nil; }

    return NokogiriHelpers.getCachedNodeOrCreate(context.runtime, el);
  }

  @JRubyMethod(name = "blank?")
  public IRubyObject
  blank_p(ThreadContext context)
  {
    // according to libxml doc,
    // a node is blank if if it is a Text or CDATA node consisting of whitespace only
    if (node.getNodeType() == Node.TEXT_NODE || node.getNodeType() == Node.CDATA_SECTION_NODE) {
      String data = node.getTextContent();
      return context.runtime.newBoolean(data == null || isBlank(data));
    }
    return context.runtime.getFalse();
  }

  @JRubyMethod
  public IRubyObject
  child(ThreadContext context)
  {
    return getCachedNodeOrCreate(context.getRuntime(), node.getFirstChild());
  }

  @JRubyMethod
  public IRubyObject
  children(ThreadContext context)
  {
    final IRubyObject[] nodes = getChildren();
    if (nodes.length == 0) {
      return XmlNodeSet.newEmptyNodeSet(context, this);
    }
    return XmlNodeSet.newNodeSet(context.runtime, nodes);
  }

  IRubyObject[]
  getChildren()
  {
    NodeList nodeList = node.getChildNodes();
    if (nodeList.getLength() > 0) {
      return nodeListToRubyArray(getRuntime(), nodeList);
    }
    return IRubyObject.NULL_ARRAY;
  }

  @JRubyMethod
  public IRubyObject
  first_element_child(ThreadContext context)
  {
    List<Node> elementNodes = getElements(node, true);
    if (elementNodes.size() == 0) { return context.nil; }
    return getCachedNodeOrCreate(context.runtime, elementNodes.get(0));
  }

  @JRubyMethod
  public IRubyObject
  last_element_child(ThreadContext context)
  {
    List<Node> elementNodes = getElements(node, false);
    if (elementNodes.size() == 0) { return context.nil; }
    return getCachedNodeOrCreate(context.runtime, elementNodes.get(elementNodes.size() - 1));
  }

  @JRubyMethod(name = {"element_children", "elements"})
  public IRubyObject
  element_children(ThreadContext context)
  {
    List<Node> elementNodes = getElements(node, false);
    IRubyObject[] array = NokogiriHelpers.nodeListToArray(context.runtime, elementNodes);
    return XmlNodeSet.newNodeSet(context.runtime, array, this);
  }

  private static List<Node>
  getElements(Node node, final boolean firstOnly)
  {
    NodeList children = node.getChildNodes();
    if (children.getLength() == 0) {
      return Collections.emptyList();
    }
    ArrayList<Node> elements = firstOnly ? null : new ArrayList<Node>(children.getLength());
    for (int i = 0; i < children.getLength(); i++) {
      Node child = children.item(i);
      if (child.getNodeType() == Node.ELEMENT_NODE) {
        if (firstOnly) {
          return Collections.singletonList(child);
        }
        elements.add(child);
      }
    }
    return elements;
  }

  /**
   * call-seq:
   *  compare(other)
   *
   * Compare this Node to +other+ with respect to their Document
   */
  @JRubyMethod(visibility = Visibility.PRIVATE)
  public IRubyObject
  compare(ThreadContext context, IRubyObject other)
  {
    if (!(other instanceof XmlNode)) {
      return context.runtime.newFixnum(-2);
    }

    Node otherNode = asXmlNode(context, other).node;

    // Do not touch this if, if it's not for a good reason.
    if (node.getNodeType() == Node.DOCUMENT_NODE ||
        otherNode.getNodeType() == Node.DOCUMENT_NODE) {
      return context.runtime.newFixnum(1);
    }

    try {
      int res = node.compareDocumentPosition(otherNode);
      if ((res & FIRST_PRECEDES_SECOND) == FIRST_PRECEDES_SECOND) {
        return context.runtime.newFixnum(-1);
      } else if ((res & SECOND_PRECEDES_FIRST) == SECOND_PRECEDES_FIRST) {
        return context.runtime.newFixnum(1);
      } else if (res == IDENTICAL_ELEMENTS) {
        return context.runtime.newFixnum(0);
      }

      return context.runtime.newFixnum(-2);
    } catch (Exception ex) {
      return context.runtime.newFixnum(-2);
    }
  }

  /**
   * TODO: this is a stub implementation.  It's not clear what
   * 'in_context' is supposed to do.  Also should take
   * <code>options</code> into account.
   */
  @JRubyMethod(required = 2, visibility = Visibility.PRIVATE)
  public IRubyObject
  in_context(ThreadContext context, IRubyObject str, IRubyObject options)
  {
    RubyClass klass;
    XmlDomParserContext ctx;
    InputStream istream;

    final Ruby runtime = context.runtime;

    XmlDocument document = document(runtime);
    if (document == null) { return context.nil; }

    if (document instanceof Html4Document) {
      klass = getNokogiriClass(runtime, "Nokogiri::HTML4::Document");
      ctx = new HtmlDomParserContext(runtime, options);
      ((HtmlDomParserContext) ctx).enableDocumentFragment();
      ctx.setStringInputSource(context, str, context.nil);
    } else {
      klass = getNokogiriClass(runtime, "Nokogiri::XML::Document");
      ctx = new XmlDomParserContext(runtime, options);
      ctx.setStringInputSource(context, str, context.nil);
    }

    // TODO: for some reason, document.getEncoding() can be null or nil (don't know why)
    // run `test_parse_with_unparented_html_text_context_node' few times to see this happen
    if (document instanceof Html4Document && !(document.getEncoding() == null || document.getEncoding().isNil())) {
      HtmlDomParserContext htmlCtx = (HtmlDomParserContext) ctx;
      htmlCtx.setEncoding(document.getEncoding().asJavaString());
    }

    XmlDocument doc = ctx.parse(context, klass, context.nil);

    RubyArray documentErrors = getErrors(document);
    RubyArray docErrors = getErrors(doc);
    if (checkNewErrors(documentErrors, docErrors)) {
      for (int i = 0; i < docErrors.getLength(); i++) {
        documentErrors.append(docErrors.entry(i));
      }
      document.setInstanceVariable("@errors", documentErrors);
      return XmlNodeSet.newNodeSet(context.runtime, IRubyObject.NULL_ARRAY, this);
    }

    // The first child might be document type node (dtd declaration).
    // XmlNodeSet to be return should not have dtd decl in its list.
    Node first;
    if (doc.node.getFirstChild().getNodeType() == Node.DOCUMENT_TYPE_NODE) {
      first = doc.node.getFirstChild().getNextSibling();
    } else {
      first = doc.node.getFirstChild();
    }

    IRubyObject[] nodes = new IRubyObject[] { NokogiriHelpers.getCachedNodeOrCreate(runtime, first) };
    return XmlNodeSet.newNodeSet(context.runtime, nodes, this);
  }

  private static RubyArray
  getErrors(XmlDocument document)
  {
    IRubyObject obj = document.getInstanceVariable("@errors");
    if (obj instanceof RubyArray) { return (RubyArray) obj; }
    return RubyArray.newEmptyArray(document.getRuntime());
  }

  private static boolean
  checkNewErrors(RubyArray baseErrors, RubyArray newErrors)
  {
    int length = ((RubyArray) newErrors.op_diff(baseErrors)).size();
    return length > 0;
  }

  @JRubyMethod(name = {"content", "text", "inner_text"})
  public IRubyObject
  content(ThreadContext context)
  {
    return stringOrNil(context.runtime, getContentImpl());
  }

  public CharSequence
  getContentImpl()
  {
    if (!node.hasChildNodes() && node.getNodeValue() == null &&
        (node.getNodeType() == Node.TEXT_NODE || node.getNodeType() == Node.CDATA_SECTION_NODE)) {
      return null;
    }
    CharSequence textContent;
    if (this instanceof XmlDocument) {
      Node node = ((Document) this.node).getDocumentElement();
      if (node == null) {
        textContent = "";
      } else {
        Node documentElement = ((Document) this.node).getDocumentElement();
        textContent = getTextContentRecursively(new StringBuilder(), documentElement);
      }
    } else {
      textContent = getTextContentRecursively(new StringBuilder(), node);
    }
    // textContent = NokogiriHelpers.convertEncodingByNKFIfNecessary(context, (XmlDocument) document(context), textContent);
    return textContent;
  }

  private static StringBuilder
  getTextContentRecursively(StringBuilder buffer, Node currentNode)
  {
    CharSequence textContent = currentNode.getNodeValue();
    if (textContent != null && NokogiriHelpers.shouldDecode(currentNode)) {
      textContent = NokogiriHelpers.decodeJavaString(textContent);
    }
    if (textContent != null) { buffer.append(textContent); }
    NodeList children = currentNode.getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
      Node child = children.item(i);
      if (hasTextContent(child)) { getTextContentRecursively(buffer, child); }
    }
    return buffer;
  }

  private static boolean
  hasTextContent(Node child)
  {
    return child.getNodeType() != Node.COMMENT_NODE && child.getNodeType() != Node.PROCESSING_INSTRUCTION_NODE;
  }

  @JRubyMethod
  public final IRubyObject
  document(ThreadContext context)
  {
    return document(context.runtime);
  }

  XmlDocument
  document(final Ruby runtime)
  {
    return document(runtime, true);
  }

  XmlDocument
  document(final Ruby runtime, boolean create)
  {
    if (doc == null) {
      doc = (XmlDocument) node.getOwnerDocument().getUserData(NokogiriHelpers.CACHED_NODE);
      if (doc == null && create) {
        doc = (XmlDocument) getCachedNodeOrCreate(runtime, node.getOwnerDocument());
        node.getOwnerDocument().setUserData(NokogiriHelpers.CACHED_NODE, doc, null);
      }
    }
    return doc;
  }

  public IRubyObject
  dup()
  {
    return dup_implementation(getMetaClass().getClassRuntime(), true);
  }

  @JRubyMethod
  public IRubyObject
  dup(ThreadContext context)
  {
    return dup_implementation(context, true);
  }

  @JRubyMethod
  public IRubyObject
  dup(ThreadContext context, IRubyObject depth)
  {
    boolean deep = depth instanceof RubyInteger && RubyFixnum.fix2int(depth) != 0;
    return dup_implementation(context, deep);
  }

  protected final IRubyObject
  dup_implementation(ThreadContext context, boolean deep)
  {
    return dup_implementation(context.runtime, deep);
  }

  protected IRubyObject
  dup_implementation(Ruby runtime, boolean deep)
  {
    XmlNode clone;
    try {
      clone = (XmlNode) clone();
    } catch (CloneNotSupportedException e) {
      throw runtime.newRuntimeError(e.toString());
    }
    Node newNode = node.cloneNode(deep);
    clone.node = newNode;
    return clone;
  }

  public static RubyString
  encode_special_chars(ThreadContext context, IRubyObject string)
  {
    CharSequence str = NokogiriHelpers.encodeJavaString(rubyStringToString(string));
    return RubyString.newString(context.runtime, str);
  }

  /**
   * Instance method version of the above static method.
   */
  @JRubyMethod(name = "encode_special_chars")
  public IRubyObject
  i_encode_special_chars(ThreadContext context, IRubyObject string)
  {
    return encode_special_chars(context, string);
  }

  /**
   * Get the attribute at the given key, <code>key</code>.
   * Assumes that this node has attributes (i.e. that key? returned
   * true).
   */
  @JRubyMethod(visibility = Visibility.PRIVATE)
  public IRubyObject
  get(ThreadContext context, IRubyObject rbkey)
  {
    if (node instanceof Element) {
      if (rbkey == null || rbkey.isNil()) { return context.nil; }
      String key = rubyStringToString(rbkey);
      Element element = (Element) node;
      if (!element.hasAttribute(key)) { return context.nil; }
      String value = element.getAttribute(key);
      return stringOrNil(context.runtime, value);
    }
    return context.nil;
  }

  /**
   * Returns the owner document, checking if this node is the
   * document, or returns null if there is no owner.
   */
  protected Document
  getOwnerDocument()
  {
    if (node.getNodeType() == Node.DOCUMENT_NODE) {
      return (Document) node;
    } else {
      return node.getOwnerDocument();
    }
  }

  @JRubyMethod
  public IRubyObject
  internal_subset(ThreadContext context)
  {
    Document document = getOwnerDocument();

    if (document == null) {
      return context.getRuntime().getNil();
    }

    XmlDocument xdoc =
      (XmlDocument) getCachedNodeOrCreate(context.getRuntime(), document);
    IRubyObject xdtd = xdoc.getInternalSubset(context);
    return xdtd;
  }

  @JRubyMethod
  public IRubyObject
  create_internal_subset(ThreadContext context,
                         IRubyObject name,
                         IRubyObject external_id,
                         IRubyObject system_id)
  {
    IRubyObject subset = internal_subset(context);
    if (!subset.isNil()) {
      throw context.runtime.newRuntimeError("Document already has internal subset");
    }

    Document document = getOwnerDocument();
    if (document == null) {
      return context.getRuntime().getNil();
    }

    XmlDocument xdoc =
      (XmlDocument) getCachedNodeOrCreate(context.getRuntime(), document);
    IRubyObject xdtd = xdoc.createInternalSubset(context, name,
                       external_id, system_id);
    return xdtd;
  }

  @JRubyMethod
  public IRubyObject
  external_subset(ThreadContext context)
  {
    Document document = getOwnerDocument();

    if (document == null) {
      return context.getRuntime().getNil();
    }

    XmlDocument xdoc =
      (XmlDocument) getCachedNodeOrCreate(context.getRuntime(), document);
    IRubyObject xdtd = xdoc.getExternalSubset(context);
    return xdtd;
  }

  @JRubyMethod
  public IRubyObject
  create_external_subset(ThreadContext context,
                         IRubyObject name,
                         IRubyObject external_id,
                         IRubyObject system_id)
  {
    IRubyObject subset = external_subset(context);
    if (!subset.isNil()) {
      throw context.runtime.newRuntimeError("Document already has external subset");
    }

    Document document = getOwnerDocument();
    if (document == null) {
      return context.getRuntime().getNil();
    }
    XmlDocument xdoc = (XmlDocument) getCachedNodeOrCreate(context.getRuntime(), document);
    IRubyObject xdtd = xdoc.createExternalSubset(context, name, external_id, system_id);
    return xdtd;
  }

  /**
   * Test if this node has an attribute named <code>rbkey</code>.
   * Overridden in XmlElement.
   */
  @JRubyMethod(name = {"key?", "has_attribute?"})
  public IRubyObject
  key_p(ThreadContext context, IRubyObject rbkey)
  {
    if (node instanceof Element) {
      String key = rubyStringToString(rbkey);
      Element element = (Element) node;
      if (element.hasAttribute(key)) {
        return context.runtime.getTrue();
      } else {
        NamedNodeMap namedNodeMap = element.getAttributes();
        for (int i = 0; i < namedNodeMap.getLength(); i++) {
          Node n = namedNodeMap.item(i);
          if (key.equals(n.getLocalName())) {
            return context.runtime.getTrue();
          }
        }
      }
      return context.runtime.getFalse();
    }
    return context.nil;
  }

  @JRubyMethod
  public IRubyObject
  namespace(ThreadContext context)
  {
    final XmlDocument doc = document(context.runtime);
    if (doc instanceof Html4Document) { return context.nil; }

    String namespaceURI = node.getNamespaceURI();
    if (namespaceURI == null || namespaceURI.isEmpty()) {
      return context.nil;
    }

    String prefix = node.getPrefix();
    NokogiriNamespaceCache nsCache = NokogiriHelpers.getNamespaceCache(node);
    XmlNamespace namespace = nsCache.get(prefix, namespaceURI);

    if (namespace == null || namespace.isEmpty()) {
      // if it's not in the cache, create an unowned, uncached namespace and
      // return that. XmlReader can't insert namespaces into the cache, so
      // this is necessary for XmlReader to work correctly.
      namespace = new XmlNamespace(context.runtime, null, prefix, namespaceURI, doc);
    }

    return namespace;
  }

  /**
   * Return an array of XmlNamespace nodes based on the attributes
   * of this node.
   */
  @JRubyMethod
  public IRubyObject
  namespace_definitions(ThreadContext context)
  {
    // don't use namespace_definitions cache anymore since
    // namespaces might be deleted. Reflecting the result of
    // namespace removals is complicated, so the cache might not be
    // updated.
    final XmlDocument doc = document(context.runtime);
    if (doc == null) { return context.runtime.newEmptyArray(); }
    if (doc instanceof Html4Document) { return context.runtime.newEmptyArray(); }

    List<XmlNamespace> namespaces = doc.getNamespaceCache().get(node);
    return context.runtime.newArray((List) namespaces);
  }

  /**
   * Return an array of XmlNamespace nodes defined on this node and
   * on any ancestor node.
   */
  @JRubyMethod
  public RubyArray
  namespace_scopes(ThreadContext context)
  {
    final XmlDocument doc = document(context.runtime);
    if (doc == null) { return context.runtime.newEmptyArray(); }
    if (doc instanceof Html4Document) { return context.runtime.newEmptyArray(); }

    Node previousNode;
    if (node.getNodeType() == Node.ELEMENT_NODE) {
      previousNode = node;
    } else if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
      previousNode = ((Attr)node).getOwnerElement();
    } else {
      previousNode = findPreviousElement(node);
    }
    if (previousNode == null) { return context.runtime.newEmptyArray(); }

    final RubyArray scoped_namespaces = context.runtime.newArray();
    final HashSet<String> prefixes_in_scope = new HashSet<String>(8);
    NokogiriNamespaceCache nsCache = NokogiriHelpers.getNamespaceCache(previousNode);
    for (Node previous = previousNode; previous != null;) {
      List<XmlNamespace> namespaces = nsCache.get(previous);
      for (XmlNamespace namespace : namespaces) {
        if (prefixes_in_scope.contains(namespace.getPrefix())) { continue; }
        scoped_namespaces.append(namespace);
        prefixes_in_scope.add(namespace.getPrefix());
      }
      previous = findPreviousElement(previous);
    }
    return scoped_namespaces;
  }

  private Node
  findPreviousElement(Node n)
  {
    Node previous = n.getPreviousSibling() == null ? n.getParentNode() : n.getPreviousSibling();
    if (previous == null || previous.getNodeType() == Node.DOCUMENT_NODE) { return null; }
    if (previous.getNodeType() == Node.ELEMENT_NODE) {
      return previous;
    } else {
      return findPreviousElement(previous);
    }
  }

  @JRubyMethod(name = "namespaced_key?")
  public IRubyObject
  namespaced_key_p(ThreadContext context, IRubyObject elementLName, IRubyObject namespaceUri)
  {
    return this.attribute_with_ns(context, elementLName, namespaceUri).isNil() ?
           context.runtime.getFalse() : context.runtime.getTrue();
  }

  protected void
  setContent(IRubyObject content)
  {
    String javaContent = rubyStringToString(content);
    node.setTextContent(javaContent);
    if (javaContent == null || javaContent.length() == 0) { return; }
    if (node.getNodeType() == Node.TEXT_NODE || node.getNodeType() == Node.CDATA_SECTION_NODE) { return; }
    if (node.getFirstChild() != null) {
      node.getFirstChild().setUserData(NokogiriHelpers.ENCODED_STRING, true, null);
    }
  }

  private void
  setContent(String content)
  {
    node.setTextContent(content);
    this.content = null;    // clear cache
  }

  @JRubyMethod(name = "native_content=")
  public IRubyObject
  native_content_set(ThreadContext context, IRubyObject content)
  {
    setContent(content);
    return content;
  }

  @JRubyMethod
  public IRubyObject
  lang(ThreadContext context)
  {
    IRubyObject currentObj = this ;
    while (!currentObj.isNil()) {
      XmlNode currentNode = asXmlNode(context, currentObj);
      IRubyObject lang = currentNode.getAttribute(context.runtime, "xml:lang");
      if (!lang.isNil()) { return lang ; }

      currentObj = currentNode.parent(context);
    }
    return context.nil;
  }

  @JRubyMethod(name = "lang=")
  public IRubyObject
  set_lang(ThreadContext context, IRubyObject lang)
  {
    setAttribute(context, "xml:lang", rubyStringToString(lang));
    return context.nil ;
  }

  /**
   * @param args {IRubyObject io,
   *              IRubyObject encoding,
   *              IRubyObject indentString,
   *              IRubyObject options}
   */
  @JRubyMethod(required = 4, visibility = Visibility.PRIVATE)
  public IRubyObject
  native_write_to(ThreadContext context, IRubyObject[] args)
  {

    IRubyObject io = args[0];
    IRubyObject encoding = args[1];
    IRubyObject indentString = args[2];
    IRubyObject options = args[3];

    String encString = rubyStringToString(encoding);

    SaveContextVisitor visitor =
      new SaveContextVisitor(RubyFixnum.fix2int(options), rubyStringToString(indentString), encString, isHtmlDoc(context),
                             isFragment(), 0);
    accept(context, visitor);

    final IRubyObject rubyString;
    if (NokogiriHelpers.isUTF8(encString)) {
      rubyString = convertString(context.runtime, visitor.getInternalBuffer());
    } else {
      ByteBuffer bytes = convertEncoding(Charset.forName(encString), visitor.getInternalBuffer());
      ByteList str = new ByteList(bytes.array(), bytes.arrayOffset(), bytes.remaining());
      rubyString = RubyString.newString(context.runtime, str);
    }
    Helpers.invoke(context, io, "write", rubyString);

    return io;
  }

  private boolean
  isHtmlDoc(ThreadContext context)
  {
    return document(context).getMetaClass().isKindOfModule(getNokogiriClass(context.runtime, "Nokogiri::HTML4::Document"));
  }

  private boolean
  isFragment()
  {
    if (node instanceof DocumentFragment) { return true; }
    if (node.getParentNode() != null && node.getParentNode() instanceof DocumentFragment) { return true; }
    return false;
  }

  @JRubyMethod(name = {"next_sibling", "next"})
  public IRubyObject
  next_sibling(ThreadContext context)
  {
    return getCachedNodeOrCreate(context.getRuntime(), node.getNextSibling());
  }

  @JRubyMethod(name = {"previous_sibling", "previous"})
  public IRubyObject
  previous_sibling(ThreadContext context)
  {
    return getCachedNodeOrCreate(context.getRuntime(), node.getPreviousSibling());
  }

  @JRubyMethod(name = {"node_name", "name"})
  public IRubyObject
  node_name(ThreadContext context)
  {
    return getNodeName(context);
  }

  @JRubyMethod(name = {"node_name=", "name="})
  public IRubyObject
  node_name_set(ThreadContext context, IRubyObject nodeName)
  {
    nodeName = doSetName(nodeName);
    String newName = nodeName == null ? null : rubyStringToString((RubyString) nodeName);
    this.node = NokogiriHelpers.renameNode(node, null, newName);
    return this;
  }

  @JRubyMethod(visibility = Visibility.PRIVATE)
  public IRubyObject
  set(ThreadContext context, IRubyObject rbkey, IRubyObject rbval)
  {
    if (node instanceof Element) {
      setAttribute(context, rubyStringToString(rbkey), rubyStringToString(rbval));
      return this;
    } else {
      return rbval;
    }
  }

  private void
  setAttribute(ThreadContext context, String key, String val)
  {
    Element element = (Element) node;

    String uri = null;
    int colonIndex = key.indexOf(":");
    if (colonIndex > 0) {
      String prefix = key.substring(0, colonIndex);
      if (prefix.equals("xml")) {
        uri = "http://www.w3.org/XML/1998/namespace";
      } else if (prefix.equals("xmlns")) {
        uri = "http://www.w3.org/2000/xmlns/";
      } else {
        uri = node.lookupNamespaceURI(prefix);
      }
    }

    if (uri != null) {
      element.setAttributeNS(uri, key, val);
    } else {
      element.setAttribute(key, val);
    }
    clearXpathContext(node);
  }

  private String
  findNamespaceHref(ThreadContext context, String prefix)
  {
    XmlNode currentNode = this;
    final XmlDocument doc = document(context.runtime);
    while (currentNode != doc) {
      RubyArray namespaces = currentNode.namespace_scopes(context);
      for (int i = 0; i < namespaces.size(); i++) {
        XmlNamespace namespace = (XmlNamespace) namespaces.eltInternal(i);
        if (namespace.hasPrefix(prefix)) { return namespace.getHref(); }
      }
      IRubyObject parent = currentNode.parent(context);
      if (parent == context.nil) { break; }
      currentNode = (XmlNode) parent;
    }
    return null;
  }

  @JRubyMethod
  public IRubyObject
  parent(ThreadContext context)
  {
    /*
     * Check if this node is the root node of the document.
     * If so, parent is the document.
     */
    if (node.getOwnerDocument() != null &&
        node.getOwnerDocument().getDocumentElement() == node) {
      return document(context);
    }
    return getCachedNodeOrCreate(context.runtime, node.getParentNode());
  }

  @JRubyMethod
  public IRubyObject
  path(ThreadContext context)
  {
    return RubyString.newString(context.runtime, NokogiriHelpers.getNodeCompletePath(this.node));
  }

  @JRubyMethod
  public IRubyObject
  pointer_id(ThreadContext context)
  {
    return RubyFixnum.newFixnum(context.runtime, this.node.hashCode());
  }

  @JRubyMethod(visibility = Visibility.PRIVATE)
  public IRubyObject
  set_namespace(ThreadContext context, IRubyObject namespace)
  {
    if (namespace.isNil()) {
      XmlDocument doc = document(context.runtime);
      if (doc != null) {
        Node node = this.node;
        doc.getNamespaceCache().remove(node);
        this.node = NokogiriHelpers.renameNode(node, null, NokogiriHelpers.getLocalPart(node.getNodeName()));
      }
    } else {
      XmlNamespace ns = (XmlNamespace) namespace;

      // Assigning node = ...renameNode() or not seems to make no
      // difference.  Why not? -pmahoney

      // It actually makes a great deal of difference. renameNode()
      // will operate in place if it can, but sometimes it can't.
      // The node you passed in *might* come back as you expect, but
      // it might not. It's much safer to throw away the original
      // and keep the return value. -mbklein
      String new_name = NokogiriHelpers.newQName(ns.getPrefix(), node);
      this.node = NokogiriHelpers.renameNode(node, ns.getHref(), new_name);
    }

    clearXpathContext(getNode());

    return this;
  }

  @JRubyMethod(name = {"unlink", "remove"})
  public IRubyObject
  unlink(ThreadContext context)
  {
    final Node parent = node.getParentNode();
    if (parent != null) {
      parent.removeChild(node);
      clearXpathContext(parent);
    }
    return this;
  }

  /**
   * The C-library simply returns libxml2 magic numbers.  Here we
   * convert Java Xml nodes to the appropriate constant defined in
   * xml/node.rb.
   */
  @JRubyMethod(name = {"node_type", "type"})
  public IRubyObject
  node_type(ThreadContext context)
  {
    String type;
    switch (node.getNodeType()) {
      case Node.ELEMENT_NODE:
        if (this instanceof XmlElementDecl) {
          type = "ELEMENT_DECL";
        } else if (this instanceof XmlAttributeDecl) {
          type = "ATTRIBUTE_DECL";
        } else if (this instanceof XmlEntityDecl) {
          type = "ENTITY_DECL";
        } else {
          type = "ELEMENT_NODE";
        }
        break;
      case Node.ATTRIBUTE_NODE:
        type = "ATTRIBUTE_NODE";
        break;
      case Node.TEXT_NODE:
        type = "TEXT_NODE";
        break;
      case Node.CDATA_SECTION_NODE:
        type = "CDATA_SECTION_NODE";
        break;
      case Node.ENTITY_REFERENCE_NODE:
        type = "ENTITY_REF_NODE";
        break;
      case Node.ENTITY_NODE:
        type = "ENTITY_NODE";
        break;
      case Node.PROCESSING_INSTRUCTION_NODE:
        type = "PI_NODE";
        break;
      case Node.COMMENT_NODE:
        type = "COMMENT_NODE";
        break;
      case Node.DOCUMENT_NODE:
        if (this instanceof Html4Document) {
          type = "HTML_DOCUMENT_NODE";
        } else {
          type = "DOCUMENT_NODE";
        }
        break;
      case Node.DOCUMENT_TYPE_NODE:
        type = "DOCUMENT_TYPE_NODE";
        break;
      case Node.DOCUMENT_FRAGMENT_NODE:
        type = "DOCUMENT_FRAG_NODE";
        break;
      case Node.NOTATION_NODE:
        type = "NOTATION_NODE";
        break;
      default:
        return context.runtime.newFixnum(0);
    }

    return getNokogiriClass(context.runtime, "Nokogiri::XML::Node").getConstant(type);
  }

  /*
   * NOTE that the behavior of this function is very difference from the CRuby implementation, see
   * the docstring in ext/nokogiri/xml_node.c for details.
   */
  @JRubyMethod
  public IRubyObject
  line(ThreadContext context)
  {
    Node root = getOwnerDocument();
    int[] counter = new int[1];
    count(root, counter);
    // offset of 2:
    // - one because humans start counting at 1 not zero
    // - one to account for the XML declaration present in the output
    return RubyFixnum.newFixnum(context.runtime, counter[0] + 2);
  }

  private boolean
  count(Node node, int[] counter)
  {
    if (node == this.node) {
      return true;
    }

    NodeList list = node.getChildNodes();
    for (int jchild = 0; jchild < list.getLength(); jchild++) {
      Node child = list.item(jchild);
      String text = null;

      if (child instanceof Text) {
        text = ((Text)child).getData();
      } else if (child instanceof Comment) {
        text = ((Comment)child).getData();
      }
      if (text != null) {
        int textLength = text.length();
        for (int jchar = 0; jchar < textLength; jchar++) {
          if (text.charAt(jchar) == '\n') {
            counter[0] += 1;
          }
        }
      }

      if (count(child, counter)) { return true; }
    }
    return false;
  }

  @JRubyMethod
  public IRubyObject
  next_element(ThreadContext context)
  {
    Node nextNode = node.getNextSibling();
    if (nextNode == null) { return context.nil; }
    if (nextNode instanceof Element) {
      return getCachedNodeOrCreate(context.runtime, nextNode);
    }
    Node deeper = nextNode.getNextSibling();
    if (deeper == null) { return context.nil; }
    return getCachedNodeOrCreate(context.runtime, deeper);
  }

  @JRubyMethod
  public IRubyObject
  previous_element(ThreadContext context)
  {
    Node prevNode = node.getPreviousSibling();
    if (prevNode == null) { return context.nil; }
    if (prevNode instanceof Element) {
      return getCachedNodeOrCreate(context.runtime, prevNode);
    }
    Node shallower = prevNode.getPreviousSibling();
    if (shallower == null) { return context.nil; }
    return getCachedNodeOrCreate(context.runtime, shallower);
  }

  protected enum AdoptScheme {
    CHILD, PREV_SIBLING, NEXT_SIBLING, REPLACEMENT
  }

  /**
   * Adopt XmlNode <code>other</code> into the document of
   * <code>this</code> using the specified scheme.
   */
  protected IRubyObject
  adoptAs(ThreadContext context, AdoptScheme scheme, IRubyObject other_)
  {
    final XmlNode other = asXmlNode(context, other_);
    // this.doc might be null since this node can be empty node.
    if (doc != null) { other.setDocument(context, doc); }

    IRubyObject nodeOrTags = other;
    Node thisNode = node;
    Node otherNode = other.node;

    try {
      Document prev = otherNode.getOwnerDocument();
      Document doc = thisNode.getOwnerDocument();
      if (doc == null && thisNode instanceof Document) {
        // we are adding the new node to a new empty document
        doc = (Document) thisNode;
      }
      clearXpathContext(prev);
      clearXpathContext(doc);
      if (doc != null && doc != otherNode.getOwnerDocument()) {
        Node ret = doc.adoptNode(otherNode);
        if (ret == null) {
          throw context.runtime.newRuntimeError("Failed to take ownership of node");
        }
        // FIXME: this is really a hack, see documentation of fixUserData() for more details.
        fixUserData(prev, ret);
        otherNode = ret;
      }

      Node parent = thisNode.getParentNode();

      switch (scheme) {
        case CHILD:
          Node[] children = adoptAsChild(thisNode, otherNode);
          if (children.length == 1 && otherNode == children[0]) {
            break;
          } else {
            nodeOrTags = nodeArrayToRubyArray(context.runtime, children);
          }
          break;
        case PREV_SIBLING:
          adoptAsPrevSibling(context, parent, thisNode, otherNode);
          break;
        case NEXT_SIBLING:
          adoptAsNextSibling(context, parent, thisNode, otherNode);
          break;
        case REPLACEMENT:
          adoptAsReplacement(context, parent, thisNode, otherNode);
          break;
      }
    } catch (Exception e) {
      throw context.runtime.newRuntimeError(e.toString());
    }

    if (otherNode.getNodeType() == Node.TEXT_NODE) {
      coalesceTextNodes(context, other, scheme);
    }

    if (this instanceof XmlDocument) {
      ((XmlDocument) this).resetNamespaceCache(context);
    }

    other.relink_namespace(context);

    return nodeOrTags;
  }

  /**
   * This is a hack to fix #839. We should submit a patch to Xerces.
   * It looks like CoreDocumentImpl.adoptNode() doesn't copy
   * the user data associated with child nodes (recursively).
   */
  private static void
  fixUserData(Document previous, Node ret)
  {
    final String key = NokogiriHelpers.ENCODED_STRING;
    for (Node child = ret.getFirstChild(); child != null; child = child.getNextSibling()) {
      CoreDocumentImpl previousDocument = (CoreDocumentImpl) previous;
      child.setUserData(key, previousDocument.getUserData(child, key), null);
      fixUserData(previous, child);
    }
  }

  private Node[]
  adoptAsChild(final Node parent, Node otherNode)
  {
    /*
     * This is a bit of a hack.  C-Nokogiri allows adding a bare text node as the root element.
     * Java (and XML spec?) does not.  So we wrap the text node in an element.
     */
    if (parent.getNodeType() == Node.DOCUMENT_NODE && otherNode.getNodeType() == Node.TEXT_NODE) {
      Element e = (Element) parent.getFirstChild();
      if (e == null || !e.getNodeName().equals(TEXT_WRAPPER_NAME)) {
        e = ((Document) parent).createElement(TEXT_WRAPPER_NAME);
        adoptAsChild(parent, e);
      }
      e.appendChild(otherNode);
      otherNode = e;
    } else {
      parent.appendChild(otherNode);
    }
    return new Node[] { otherNode };
  }

  protected void
  adoptAsPrevSibling(ThreadContext context,
                     Node parent,
                     Node thisNode, Node otherNode)
  {
    if (parent == null) {
      /* I'm not sure what do do here...  A node with no
       * parent can't exactly have a 'sibling', so we make
       * otherNode parentless also. */
      if (otherNode.getParentNode() != null) {
        otherNode.getParentNode().removeChild(otherNode);
      }
      return;
    }

    parent.insertBefore(otherNode, thisNode);
  }

  protected void
  adoptAsNextSibling(ThreadContext context,
                     Node parent,
                     Node thisNode, Node otherNode)
  {
    if (parent == null) {
      /* I'm not sure what do do here...  A node with no
       * parent can't exactly have a 'sibling', so we make
       * otherNode parentless also. */
      if (otherNode.getParentNode() != null) {
        otherNode.getParentNode().removeChild(otherNode);
      }

      return;
    }

    Node nextSib = thisNode.getNextSibling();

    if (nextSib != null) {
      parent.insertBefore(otherNode, nextSib);
    } else {
      parent.appendChild(otherNode);
    }
  }

  protected void
  adoptAsReplacement(ThreadContext context,
                     Node parentNode,
                     Node thisNode, Node otherNode)
  {
    if (parentNode == null) {
      /* nothing to replace? */
      return;
    }

    try {
      parentNode.replaceChild(otherNode, thisNode);
    } catch (Exception e) {
      String prefix = "could not replace child: ";
      throw context.runtime.newRuntimeError(prefix + e.toString());
    }
  }

  /**
   * Add <code>other</code> as a child of <code>this</code>.
   */
  @JRubyMethod(visibility = Visibility.PRIVATE)
  public IRubyObject
  add_child_node(ThreadContext context, IRubyObject other)
  {
    return adoptAs(context, AdoptScheme.CHILD, other);
  }

  /**
   * Replace <code>this</code> with <code>other</code>.
   */
  @JRubyMethod(visibility = Visibility.PRIVATE)
  public IRubyObject
  replace_node(ThreadContext context, IRubyObject other)
  {
    return adoptAs(context, AdoptScheme.REPLACEMENT, other);
  }

  /**
   * Add <code>other</code> as a sibling before <code>this</code>.
   */
  @JRubyMethod(visibility = Visibility.PRIVATE)
  public IRubyObject
  add_previous_sibling_node(ThreadContext context, IRubyObject other)
  {
    return adoptAs(context, AdoptScheme.PREV_SIBLING, other);
  }

  /**
   * Add <code>other</code> as a sibling after <code>this</code>.
   */
  @JRubyMethod(visibility = Visibility.PRIVATE)
  public IRubyObject
  add_next_sibling_node(ThreadContext context, IRubyObject other)
  {
    return adoptAs(context, AdoptScheme.NEXT_SIBLING, other);
  }

  /**
   * call-seq:
   *   process_xincludes(options)
   *
   * Loads and substitutes all xinclude elements below the node. The
   * parser context will be initialized with +options+.
   *
   */
  @JRubyMethod(visibility = Visibility.PRIVATE)
  public IRubyObject
  process_xincludes(ThreadContext context, IRubyObject options)
  {
    XmlDocument xmlDocument = (XmlDocument)document(context);
    RubyArray errors = (RubyArray)xmlDocument.getInstanceVariable("@errors");
    while (errors.getLength() > 0) {
      XmlSyntaxError error = (XmlSyntaxError)errors.shift(context);
      if (error.toString().contains("Include operation failed")) {
        throw error.toThrowable();
      }
    }
    return this;
  }

  @JRubyMethod(visibility = Visibility.PRIVATE)
  public IRubyObject
  clear_xpath_context(ThreadContext context)
  {
    clearXpathContext(getNode());
    return context.nil ;
  }

  @SuppressWarnings("unchecked")
  @Override
  public Object
  toJava(final Class target)
  {
    if (target == Object.class || Node.class.isAssignableFrom(target)) {
      return getNode();
    }
    return super.toJava(target);
  }

}