nokogiri 1.9.1 → 1.15.3

data/ext/nokogiri/xml_node.c

@@ -1,36 +1,61 @@
-#include <xml_node.h>
+#include <nokogiri.h>
 
-static ID decorate, decorate_bang;
+#include <stdbool.h>
 
-#ifdef DEBUG
-static void debug_node_dealloc(xmlNodePtr x)
-{
-  NOKOGIRI_DEBUG_START(x)
-  NOKOGIRI_DEBUG_END(x)
-}
-#else
-#  define debug_node_dealloc 0
-#endif
+// :stopdoc:
 
-static void mark(xmlNodePtr node)
+VALUE cNokogiriXmlNode ;
+static ID id_decorate, id_decorate_bang;
+
+typedef xmlNodePtr(*pivot_reparentee_func)(xmlNodePtr, xmlNodePtr);
+
+static void
+_xml_node_mark(void *ptr)
 {
+  xmlNodePtr node = ptr;
+
+  if (!DOC_RUBY_OBJECT_TEST(node->doc)) {
+    return;
+  }
+
   xmlDocPtr doc = node->doc;
-  if(doc->type == XML_DOCUMENT_NODE || doc->type == XML_HTML_DOCUMENT_NODE) {
-    if(DOC_RUBY_OBJECT_TEST(doc)) {
+  if (doc->type == XML_DOCUMENT_NODE || doc->type == XML_HTML_DOCUMENT_NODE) {
+    if (DOC_RUBY_OBJECT_TEST(doc)) {
       rb_gc_mark(DOC_RUBY_OBJECT(doc));
     }
-  } else if(node->doc->_private) {
+  } else if (node->doc->_private) {
     rb_gc_mark((VALUE)doc->_private);
   }
 }
 
-/* :nodoc: */
-typedef xmlNodePtr (*pivot_reparentee_func)(xmlNodePtr, xmlNodePtr);
+#ifdef HAVE_RB_GC_LOCATION
+static void
+_xml_node_update_references(void *ptr)
+{
+  xmlNodePtr node = ptr;
 
-/* :nodoc: */
-static void relink_namespace(xmlNodePtr reparented)
+  if (node->_private) {
+    node->_private = (void *)rb_gc_location((VALUE)node->_private);
+  }
+}
+#else
+#  define _xml_node_update_references 0
+#endif
+
+static const rb_data_type_t nokogiri_node_type = {
+  .wrap_struct_name = "Nokogiri::XML::Node",
+  .function = {
+    .dmark = _xml_node_mark,
+    .dcompact = _xml_node_update_references,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static void
+relink_namespace(xmlNodePtr reparented)
 {
   xmlNodePtr child;
+  xmlAttrPtr attr;
 
   if (reparented->type != XML_ATTRIBUTE_NODE &&
       reparented->type != XML_ELEMENT_NODE) { return; }
@@ -42,7 +67,7 @@ static void relink_namespace(xmlNodePtr reparented)
     name = xmlSplitQName2(reparented->name, &prefix);
 
     if (reparented->type == XML_ATTRIBUTE_NODE) {
-      if (prefix == NULL || strcmp((char*)prefix, XMLNS_PREFIX) == 0) {
+      if (prefix == NULL || strcmp((char *)prefix, XMLNS_PREFIX) == 0) {
         xmlFree(name);
         xmlFree(prefix);
         return;
@@ -51,10 +76,6 @@ static void relink_namespace(xmlNodePtr reparented)
 
     ns = xmlSearchNs(reparented->doc, reparented, prefix);
 
-    if (ns == NULL && reparented->parent) {
-      ns = xmlSearchNs(reparented->doc, reparented->parent, prefix);
-    }
-
     if (ns != NULL) {
       xmlNodeSetName(reparented, name);
       xmlSetNs(reparented, ns);
@@ -68,7 +89,9 @@ static void relink_namespace(xmlNodePtr reparented)
   if (reparented->type != XML_ELEMENT_NODE || !reparented->parent) { return; }
 
   /* Make sure that our reparented node has the correct namespaces */
-  if (!reparented->ns && reparented->doc != (xmlDocPtr)reparented->parent) {
+  if (!reparented->ns &&
+      (reparented->doc != (xmlDocPtr)reparented->parent) &&
+      (rb_iv_get(DOC_RUBY_OBJECT(reparented->doc), "@namespace_inheritance") == Qtrue)) {
     xmlSetNs(reparented, reparented->parent->ns);
   }
 
@@ -91,7 +114,7 @@ static void relink_namespace(xmlNodePtr reparented)
         } else {
           reparented->nsDef = curr->next;
         }
-        nokogiri_root_nsdef(curr, reparented->doc);
+        noko_xml_document_pin_namespace(curr, reparented->doc);
       } else {
         prev = curr;
       }
@@ -131,16 +154,19 @@ static void relink_namespace(xmlNodePtr reparented)
   }
 
   if (reparented->type == XML_ELEMENT_NODE) {
-    child = (xmlNodePtr)((xmlElementPtr)reparented)->attributes;
-    while(NULL != child) {
-      relink_namespace(child);
-      child = child->next;
+    attr = reparented->properties;
+    while (NULL != attr) {
+      relink_namespace((xmlNodePtr)attr);
+      attr = attr->next;
     }
   }
 }
 
-/* :nodoc: */
-static xmlNodePtr xmlReplaceNodeWrapper(xmlNodePtr pivot, xmlNodePtr new_node)
+
+/* internal function meant to wrap xmlReplaceNode
+   and fix some issues we have with libxml2 merging nodes */
+static xmlNodePtr
+xmlReplaceNodeWrapper(xmlNodePtr pivot, xmlNodePtr new_node)
 {
   xmlNodePtr retval ;
 
@@ -163,22 +189,34 @@ static xmlNodePtr xmlReplaceNodeWrapper(xmlNodePtr pivot, xmlNodePtr new_node)
   return retval ;
 }
 
-/* :nodoc: */
-static VALUE reparent_node_with(VALUE pivot_obj, VALUE reparentee_obj, pivot_reparentee_func prf)
+
+static void
+raise_if_ancestor_of_self(xmlNodePtr self)
+{
+  for (xmlNodePtr ancestor = self->parent ; ancestor ; ancestor = ancestor->parent) {
+    if (self == ancestor) {
+      rb_raise(rb_eRuntimeError, "cycle detected: node '%s' is an ancestor of itself", self->name);
+    }
+  }
+}
+
+
+static VALUE
+reparent_node_with(VALUE pivot_obj, VALUE reparentee_obj, pivot_reparentee_func prf)
 {
   VALUE reparented_obj ;
-  xmlNodePtr reparentee, pivot, reparented, next_text, new_next_text, parent ;
+  xmlNodePtr reparentee, original_reparentee, pivot, reparented, next_text, new_next_text, parent ;
   int original_ns_prefix_is_default = 0 ;
 
-  if(!rb_obj_is_kind_of(reparentee_obj, cNokogiriXmlNode)) {
+  if (!rb_obj_is_kind_of(reparentee_obj, cNokogiriXmlNode)) {
     rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node");
   }
-  if(rb_obj_is_kind_of(reparentee_obj, cNokogiriXmlDocument)) {
+  if (rb_obj_is_kind_of(reparentee_obj, cNokogiriXmlDocument)) {
     rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node");
   }
 
-  Data_Get_Struct(reparentee_obj, xmlNode, reparentee);
-  Data_Get_Struct(pivot_obj, xmlNode, pivot);
+  Noko_Node_Get_Struct(reparentee_obj, xmlNode, reparentee);
+  Noko_Node_Get_Struct(pivot_obj, xmlNode, pivot);
 
   /*
    * Check if nodes given are appropriate to have a parent-child
@@ -194,66 +232,66 @@ static VALUE reparent_node_with(VALUE pivot_obj, VALUE reparentee_obj, pivot_rep
 
   if (parent) {
     switch (parent->type) {
-    case XML_DOCUMENT_NODE:
-    case XML_HTML_DOCUMENT_NODE:
-      switch (reparentee->type) {
-      case XML_ELEMENT_NODE:
-      case XML_PI_NODE:
-      case XML_COMMENT_NODE:
-      case XML_DOCUMENT_TYPE_NODE:
-      /*
-       * The DOM specification says no to adding text-like nodes
-       * directly to a document, but we allow it for compatibility.
-       */
-      case XML_TEXT_NODE:
-      case XML_CDATA_SECTION_NODE:
-      case XML_ENTITY_REF_NODE:
-        goto ok;
-      default:
+      case XML_DOCUMENT_NODE:
+      case XML_HTML_DOCUMENT_NODE:
+        switch (reparentee->type) {
+          case XML_ELEMENT_NODE:
+          case XML_PI_NODE:
+          case XML_COMMENT_NODE:
+          case XML_DOCUMENT_TYPE_NODE:
+          /*
+           * The DOM specification says no to adding text-like nodes
+           * directly to a document, but we allow it for compatibility.
+           */
+          case XML_TEXT_NODE:
+          case XML_CDATA_SECTION_NODE:
+          case XML_ENTITY_REF_NODE:
+            goto ok;
+          default:
+            break;
+        }
         break;
-      }
-      break;
-    case XML_DOCUMENT_FRAG_NODE:
-    case XML_ENTITY_REF_NODE:
-    case XML_ELEMENT_NODE:
-      switch (reparentee->type) {
-      case XML_ELEMENT_NODE:
-      case XML_PI_NODE:
-      case XML_COMMENT_NODE:
-      case XML_TEXT_NODE:
-      case XML_CDATA_SECTION_NODE:
+      case XML_DOCUMENT_FRAG_NODE:
       case XML_ENTITY_REF_NODE:
-        goto ok;
-      default:
+      case XML_ELEMENT_NODE:
+        switch (reparentee->type) {
+          case XML_ELEMENT_NODE:
+          case XML_PI_NODE:
+          case XML_COMMENT_NODE:
+          case XML_TEXT_NODE:
+          case XML_CDATA_SECTION_NODE:
+          case XML_ENTITY_REF_NODE:
+            goto ok;
+          default:
+            break;
+        }
+        break;
+      case XML_ATTRIBUTE_NODE:
+        switch (reparentee->type) {
+          case XML_TEXT_NODE:
+          case XML_ENTITY_REF_NODE:
+            goto ok;
+          default:
+            break;
+        }
         break;
-      }
-      break;
-    case XML_ATTRIBUTE_NODE:
-      switch (reparentee->type) {
       case XML_TEXT_NODE:
-      case XML_ENTITY_REF_NODE:
-        goto ok;
+        /*
+         * xmlAddChild() breaks the DOM specification in that it allows
+         * adding a text node to another, in which case text nodes are
+         * coalesced, but since our JRuby version does not support such
+         * operation, we should inhibit it.
+         */
+        break;
       default:
         break;
-      }
-      break;
-    case XML_TEXT_NODE:
-      /*
-       * xmlAddChild() breaks the DOM specification in that it allows
-       * adding a text node to another, in which case text nodes are
-       * coalesced, but since our JRuby version does not support such
-       * operation, we should inhibit it.
-       */
-      break;
-    default:
-      break;
     }
 
     rb_raise(rb_eArgError, "cannot reparent %s there", rb_obj_classname(reparentee_obj));
   }
 
 ok:
-  xmlUnlinkNode(reparentee);
+  original_reparentee = reparentee;
 
   if (reparentee->doc != pivot->doc || reparentee->type == XML_TEXT_NODE) {
     /*
@@ -294,7 +332,7 @@ ok:
       original_ns_prefix_is_default = 1;
     }
 
-    nokogiri_root_node(reparentee);
+    noko_xml_document_pin_node(reparentee);
 
     if (!(reparentee = xmlDocCopyNode(reparentee, pivot->doc, 1))) {
       rb_raise(rb_eRuntimeError, "Could not reparent node (xmlDocCopyNode)");
@@ -305,12 +343,14 @@ ok:
        *  issue #391, where new node's prefix may become the string "default"
        *  see libxml2 tree.c xmlNewReconciliedNs which implements this behavior.
        */
-      xmlFree(reparentee->ns->prefix);
+      xmlFree(DISCARD_CONST_QUAL_XMLCHAR(reparentee->ns->prefix));
       reparentee->ns->prefix = NULL;
     }
   }
 
-  if (prf != xmlAddPrevSibling && prf != xmlAddNextSibling
+  xmlUnlinkNode(original_reparentee);
+
+  if (prf != xmlAddPrevSibling && prf != xmlAddNextSibling && prf != xmlAddChild
       && reparentee->type == XML_TEXT_NODE && pivot->next && pivot->next->type == XML_TEXT_NODE) {
     /*
      *  libxml merges text nodes in a right-to-left fashion, meaning that if
@@ -334,12 +374,12 @@ ok:
     new_next_text = xmlDocCopyNode(next_text, pivot->doc, 1) ;
 
     xmlUnlinkNode(next_text);
-    nokogiri_root_node(next_text);
+    noko_xml_document_pin_node(next_text);
 
     xmlAddNextSibling(pivot, new_next_text);
   }
 
-  if(!(reparented = (*prf)(pivot, reparentee))) {
+  if (!(reparented = (*prf)(pivot, reparentee))) {
     rb_raise(rb_eRuntimeError, "Could not reparent node");
   }
 
@@ -349,57 +389,432 @@ ok:
    *  adjacent text nodes.
    */
   DATA_PTR(reparentee_obj) = reparented ;
+  reparented_obj = noko_xml_node_wrap(Qnil, reparented);
 
-  relink_namespace(reparented);
+  rb_funcall(reparented_obj, id_decorate_bang, 0);
 
-  reparented_obj = Nokogiri_wrap_xml_node(Qnil, reparented);
+  /* if we've created a cycle, raise an exception */
+  raise_if_ancestor_of_self(reparented);
 
-  rb_funcall(reparented_obj, decorate_bang, 0);
+  relink_namespace(reparented);
 
   return reparented_obj ;
 }
 
+// :startdoc:
 
 /*
- * call-seq:
- *  document
+ * :call-seq:
+ *   add_namespace_definition(prefix, href) → Nokogiri::XML::Namespace
+ *   add_namespace(prefix, href) → Nokogiri::XML::Namespace
+ *
+ * :category: Manipulating Document Structure
+ *
+ * Adds a namespace definition to this node with +prefix+ using +href+ value, as if this node had
+ * included an attribute "xmlns:prefix=href".
+ *
+ * A default namespace definition for this node can be added by passing +nil+ for +prefix+.
+ *
+ * [Parameters]
+ * - +prefix+ (String, +nil+) An {XML Name}[https://www.w3.org/TR/xml-names/#ns-decl]
+ * - +href+ (String) The {URI reference}[https://www.w3.org/TR/xml-names/#sec-namespaces]
+ *
+ * [Returns] The new Nokogiri::XML::Namespace
+ *
+ * *Example:* adding a non-default namespace definition
+ *
+ *   doc = Nokogiri::XML("<store><inventory></inventory></store>")
+ *   inventory = doc.at_css("inventory")
+ *   inventory.add_namespace_definition("automobile", "http://alices-autos.com/")
+ *   inventory.add_namespace_definition("bicycle", "http://bobs-bikes.com/")
+ *   inventory.add_child("<automobile:tire>Michelin model XGV, size 75R</automobile:tire>")
+ *   doc.to_xml
+ *   # => "<?xml version=\"1.0\"?>\n" +
+ *   #    "<store>\n" +
+ *   #    "  <inventory xmlns:automobile=\"http://alices-autos.com/\" xmlns:bicycle=\"http://bobs-bikes.com/\">\n" +
+ *   #    "    <automobile:tire>Michelin model XGV, size 75R</automobile:tire>\n" +
+ *   #    "  </inventory>\n" +
+ *   #    "</store>\n"
+ *
+ * *Example:* adding a default namespace definition
+ *
+ *   doc = Nokogiri::XML("<store><inventory><tire>Michelin model XGV, size 75R</tire></inventory></store>")
+ *   doc.at_css("tire").add_namespace_definition(nil, "http://bobs-bikes.com/")
+ *   doc.to_xml
+ *   # => "<?xml version=\"1.0\"?>\n" +
+ *   #    "<store>\n" +
+ *   #    "  <inventory>\n" +
+ *   #    "    <tire xmlns=\"http://bobs-bikes.com/\">Michelin model XGV, size 75R</tire>\n" +
+ *   #    "  </inventory>\n" +
+ *   #    "</store>\n"
+ *
+ */
+static VALUE
+rb_xml_node_add_namespace_definition(VALUE rb_node, VALUE rb_prefix, VALUE rb_href)
+{
+  xmlNodePtr c_node, element;
+  xmlNsPtr c_namespace;
+  const xmlChar *c_prefix = (const xmlChar *)(NIL_P(rb_prefix) ? NULL : StringValueCStr(rb_prefix));
+
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
+  element = c_node ;
+
+  c_namespace = xmlSearchNs(c_node->doc, c_node, c_prefix);
+
+  if (!c_namespace) {
+    if (c_node->type != XML_ELEMENT_NODE) {
+      element = c_node->parent;
+    }
+    c_namespace = xmlNewNs(element, (const xmlChar *)StringValueCStr(rb_href), c_prefix);
+  }
+
+  if (!c_namespace) {
+    return Qnil ;
+  }
+
+  if (NIL_P(rb_prefix) || c_node != element) {
+    xmlSetNs(c_node, c_namespace);
+  }
+
+  return noko_xml_namespace_wrap(c_namespace, c_node->doc);
+}
+
+
+/*
+ * :call-seq: attribute(name) → Nokogiri::XML::Attr
+ *
+ * :category: Working With Node Attributes
+ *
+ * [Returns] Attribute (Nokogiri::XML::Attr) belonging to this node with name +name+.
+ *
+ * ⚠ Note that attribute namespaces are ignored and only the simple (non-namespace-prefixed) name is
+ * used to find a matching attribute. In case of a simple name collision, only one of the matching
+ * attributes will be returned. In this case, you will need to use #attribute_with_ns.
+ *
+ * *Example:*
+ *
+ *   doc = Nokogiri::XML("<root><child size='large' class='big wide tall'/></root>")
+ *   child = doc.at_css("child")
+ *   child.attribute("size") # => #<Nokogiri::XML::Attr:0x550 name="size" value="large">
+ *   child.attribute("class") # => #<Nokogiri::XML::Attr:0x564 name="class" value="big wide tall">
+ *
+ * *Example* showing that namespaced attributes will not be returned:
+ *
+ * ⚠ Note that only one of the two matching attributes is returned.
+ *
+ *   doc = Nokogiri::XML(<<~EOF)
+ *     <root xmlns:width='http://example.com/widths'
+ *           xmlns:height='http://example.com/heights'>
+ *       <child width:size='broad' height:size='tall'/>
+ *     </root>
+ *   EOF
+ *   doc.at_css("child").attribute("size")
+ *   # => #(Attr:0x550 {
+ *   #      name = "size",
+ *   #      namespace = #(Namespace:0x564 {
+ *   #        prefix = "width",
+ *   #        href = "http://example.com/widths"
+ *   #        }),
+ *   #      value = "broad"
+ *   #      })
+ */
+static VALUE
+rb_xml_node_attribute(VALUE self, VALUE name)
+{
+  xmlNodePtr node;
+  xmlAttrPtr prop;
+  Noko_Node_Get_Struct(self, xmlNode, node);
+  prop = xmlHasProp(node, (xmlChar *)StringValueCStr(name));
+
+  if (! prop) { return Qnil; }
+  return noko_xml_node_wrap(Qnil, (xmlNodePtr)prop);
+}
+
+
+/*
+ * :call-seq: attribute_nodes() → Array<Nokogiri::XML::Attr>
+ *
+ * :category: Working With Node Attributes
+ *
+ * [Returns] Attributes (an Array of Nokogiri::XML::Attr) belonging to this node.
+ *
+ * Note that this is the preferred alternative to #attributes when the simple
+ * (non-namespace-prefixed) attribute names may collide.
+ *
+ * *Example:*
+ *
+ * Contrast this with the colliding-name example from #attributes.
+ *
+ *   doc = Nokogiri::XML(<<~EOF)
+ *     <root xmlns:width='http://example.com/widths'
+ *           xmlns:height='http://example.com/heights'>
+ *       <child width:size='broad' height:size='tall'/>
+ *     </root>
+ *   EOF
+ *   doc.at_css("child").attribute_nodes
+ *   # => [#(Attr:0x550 {
+ *   #       name = "size",
+ *   #       namespace = #(Namespace:0x564 {
+ *   #         prefix = "width",
+ *   #         href = "http://example.com/widths"
+ *   #         }),
+ *   #       value = "broad"
+ *   #       }),
+ *   #     #(Attr:0x578 {
+ *   #       name = "size",
+ *   #       namespace = #(Namespace:0x58c {
+ *   #         prefix = "height",
+ *   #         href = "http://example.com/heights"
+ *   #         }),
+ *   #       value = "tall"
+ *   #       })]
+ */
+static VALUE
+rb_xml_node_attribute_nodes(VALUE rb_node)
+{
+  xmlNodePtr c_node;
+
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
+
+  return noko_xml_node_attrs(c_node);
+}
+
+
+/*
+ * :call-seq: attribute_with_ns(name, namespace) → Nokogiri::XML::Attr
+ *
+ * :category: Working With Node Attributes
+ *
+ * [Returns]
+ *   Attribute (Nokogiri::XML::Attr) belonging to this node with matching +name+ and +namespace+.
+ *
+ * [Parameters]
+ * - +name+ (String): the simple (non-namespace-prefixed) name of the attribute
+ * - +namespace+ (String): the URI of the attribute's namespace
+ *
+ * See related: #attribute
+ *
+ * *Example:*
+ *
+ *   doc = Nokogiri::XML(<<~EOF)
+ *     <root xmlns:width='http://example.com/widths'
+ *           xmlns:height='http://example.com/heights'>
+ *       <child width:size='broad' height:size='tall'/>
+ *     </root>
+ *   EOF
+ *   doc.at_css("child").attribute_with_ns("size", "http://example.com/widths")
+ *   # => #(Attr:0x550 {
+ *   #      name = "size",
+ *   #      namespace = #(Namespace:0x564 {
+ *   #        prefix = "width",
+ *   #        href = "http://example.com/widths"
+ *   #        }),
+ *   #      value = "broad"
+ *   #      })
+ *   doc.at_css("child").attribute_with_ns("size", "http://example.com/heights")
+ *   # => #(Attr:0x578 {
+ *   #      name = "size",
+ *   #      namespace = #(Namespace:0x58c {
+ *   #        prefix = "height",
+ *   #        href = "http://example.com/heights"
+ *   #        }),
+ *   #      value = "tall"
+ *   #      })
+ */
+static VALUE
+rb_xml_node_attribute_with_ns(VALUE self, VALUE name, VALUE namespace)
+{
+  xmlNodePtr node;
+  xmlAttrPtr prop;
+  Noko_Node_Get_Struct(self, xmlNode, node);
+  prop = xmlHasNsProp(node, (xmlChar *)StringValueCStr(name),
+                      NIL_P(namespace) ? NULL : (xmlChar *)StringValueCStr(namespace));
+
+  if (! prop) { return Qnil; }
+  return noko_xml_node_wrap(Qnil, (xmlNodePtr)prop);
+}
+
+
+
+/*
+ * call-seq: blank? → Boolean
+ *
+ * [Returns] +true+ if the node is an empty or whitespace-only text or cdata node, else +false+.
+ *
+ * *Example:*
+ *
+ *     Nokogiri("<root><child/></root>").root.child.blank? # => false
+ *     Nokogiri("<root>\t \n</root>").root.child.blank? # => true
+ *     Nokogiri("<root><![CDATA[\t \n]]></root>").root.child.blank? # => true
+ *     Nokogiri("<root>not-blank</root>").root.child
+ *       .tap { |n| n.content = "" }.blank # => true
+ */
+static VALUE
+rb_xml_node_blank_eh(VALUE self)
+{
+  xmlNodePtr node;
+  Noko_Node_Get_Struct(self, xmlNode, node);
+  return (1 == xmlIsBlankNode(node)) ? Qtrue : Qfalse ;
+}
+
+
+/*
+ * :call-seq: child() → Nokogiri::XML::Node
+ *
+ * :category: Traversing Document Structure
+ *
+ * [Returns] First of this node's children, or +nil+ if there are no children
+ *
+ * This is a convenience method and is equivalent to:
+ *
+ *   node.children.first
+ *
+ * See related: #children
+ */
+static VALUE
+rb_xml_node_child(VALUE self)
+{
+  xmlNodePtr node, child;
+  Noko_Node_Get_Struct(self, xmlNode, node);
+
+  child = node->children;
+  if (!child) { return Qnil; }
+
+  return noko_xml_node_wrap(Qnil, child);
+}
+
+
+/*
+ * :call-seq: children() → Nokogiri::XML::NodeSet
+ *
+ * :category: Traversing Document Structure
+ *
+ * [Returns] Nokogiri::XML::NodeSet containing this node's children.
+ */
+static VALUE
+rb_xml_node_children(VALUE self)
+{
+  xmlNodePtr node;
+  xmlNodePtr child;
+  xmlNodeSetPtr set;
+  VALUE document;
+  VALUE node_set;
+
+  Noko_Node_Get_Struct(self, xmlNode, node);
+
+  child = node->children;
+  set = xmlXPathNodeSetCreate(child);
+
+  document = DOC_RUBY_OBJECT(node->doc);
+
+  if (!child) { return noko_xml_node_set_wrap(set, document); }
+
+  child = child->next;
+  while (NULL != child) {
+    xmlXPathNodeSetAddUnique(set, child);
+    child = child->next;
+  }
+
+  node_set = noko_xml_node_set_wrap(set, document);
+
+  return node_set;
+}
+
+
+/*
+ * :call-seq:
+ *   content() → String
+ *   inner_text() → String
+ *   text() → String
+ *   to_str() → String
+ *
+ * [Returns]
+ *   Contents of all the text nodes in this node's subtree, concatenated together into a single
+ *   String.
+ *
+ * ⚠ Note that entities will _always_ be expanded in the returned String.
+ *
+ * See related: #inner_html
+ *
+ * *Example* of how entities are handled:
+ *
+ * Note that <tt>&lt;</tt> becomes <tt><</tt> in the returned String.
+ *
+ *   doc = Nokogiri::XML.fragment("<child>a &lt; b</child>")
+ *   doc.at_css("child").content
+ *   # => "a < b"
+ *
+ * *Example* of how a subtree is handled:
+ *
+ * Note that the <tt><span></tt> tags are omitted and only the text node contents are returned,
+ * concatenated into a single string.
+ *
+ *   doc = Nokogiri::XML.fragment("<child><span>first</span> <span>second</span></child>")
+ *   doc.at_css("child").content
+ *   # => "first second"
+ */
+static VALUE
+rb_xml_node_content(VALUE self)
+{
+  xmlNodePtr node;
+  xmlChar *content;
+
+  Noko_Node_Get_Struct(self, xmlNode, node);
+
+  content = xmlNodeGetContent(node);
+  if (content) {
+    VALUE rval = NOKOGIRI_STR_NEW2(content);
+    xmlFree(content);
+    return rval;
+  }
+  return Qnil;
+}
+
+
+/*
+ * :call-seq: document() → Nokogiri::XML::Document
+ *
+ * :category: Traversing Document Structure
  *
- * Get the document for this Node
+ * [Returns] Parent Nokogiri::XML::Document for this node
  */
-static VALUE document(VALUE self)
+static VALUE
+rb_xml_node_document(VALUE self)
 {
   xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
   return DOC_RUBY_OBJECT(node->doc);
 }
 
 /*
- * call-seq:
- *  pointer_id
+ * :call-seq: pointer_id() → Integer
  *
- * Get the internal pointer number
+ * [Returns]
+ *   A unique id for this node based on the internal memory structures. This method is used by #==
+ *   to determine node identity.
  */
-static VALUE pointer_id(VALUE self)
+static VALUE
+rb_xml_node_pointer_id(VALUE self)
 {
   xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
-  return INT2NUM((long)(node));
+  return rb_uint2inum((uintptr_t)(node));
 }
 
 /*
- * call-seq:
- *  encode_special_chars(string)
+ * :call-seq: encode_special_chars(string) → String
  *
  * Encode any special characters in +string+
  */
-static VALUE encode_special_chars(VALUE self, VALUE string)
+static VALUE
+encode_special_chars(VALUE self, VALUE string)
 {
   xmlNodePtr node;
   xmlChar *encoded;
   VALUE encoded_str;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
   encoded = xmlEncodeSpecialChars(
               node->doc,
               (const xmlChar *)StringValueCStr(string)
@@ -412,8 +827,8 @@ static VALUE encode_special_chars(VALUE self, VALUE string)
 }
 
 /*
- * call-seq:
- *  create_internal_subset(name, external_id, system_id)
+ * :call-seq:
+ *   create_internal_subset(name, external_id, system_id)
  *
  * Create the internal subset of a document.
  *
@@ -423,17 +838,18 @@ static VALUE encode_special_chars(VALUE self, VALUE string)
  *   doc.create_internal_subset("chapter", nil, "chapter.dtd")
  *   # => <!DOCTYPE chapter SYSTEM "chapter.dtd">
  */
-static VALUE create_internal_subset(VALUE self, VALUE name, VALUE external_id, VALUE system_id)
+static VALUE
+create_internal_subset(VALUE self, VALUE name, VALUE external_id, VALUE system_id)
 {
   xmlNodePtr node;
   xmlDocPtr doc;
   xmlDtdPtr dtd;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   doc = node->doc;
 
-  if(xmlGetIntSubset(doc)) {
+  if (xmlGetIntSubset(doc)) {
     rb_raise(rb_eRuntimeError, "Document already has an internal subset");
   }
 
@@ -444,28 +860,29 @@ static VALUE create_internal_subset(VALUE self, VALUE name, VALUE external_id, V
           NIL_P(system_id)   ? NULL : (const xmlChar *)StringValueCStr(system_id)
         );
 
-  if(!dtd) { return Qnil; }
+  if (!dtd) { return Qnil; }
 
-  return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)dtd);
+  return noko_xml_node_wrap(Qnil, (xmlNodePtr)dtd);
 }
 
 /*
- * call-seq:
- *  create_external_subset(name, external_id, system_id)
+ * :call-seq:
+ *   create_external_subset(name, external_id, system_id)
  *
  * Create an external subset
  */
-static VALUE create_external_subset(VALUE self, VALUE name, VALUE external_id, VALUE system_id)
+static VALUE
+create_external_subset(VALUE self, VALUE name, VALUE external_id, VALUE system_id)
 {
   xmlNodePtr node;
   xmlDocPtr doc;
   xmlDtdPtr dtd;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   doc = node->doc;
 
-  if(doc->extSubset) {
+  if (doc->extSubset) {
     rb_raise(rb_eRuntimeError, "Document already has an external subset");
   }
 
@@ -476,72 +893,78 @@ static VALUE create_external_subset(VALUE self, VALUE name, VALUE external_id, V
           NIL_P(system_id)   ? NULL : (const xmlChar *)StringValueCStr(system_id)
         );
 
-  if(!dtd) { return Qnil; }
+  if (!dtd) { return Qnil; }
 
-  return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)dtd);
+  return noko_xml_node_wrap(Qnil, (xmlNodePtr)dtd);
 }
 
 /*
- * call-seq:
- *  external_subset
+ * :call-seq:
+ *   external_subset()
  *
  * Get the external subset
  */
-static VALUE external_subset(VALUE self)
+static VALUE
+external_subset(VALUE self)
 {
   xmlNodePtr node;
   xmlDocPtr doc;
   xmlDtdPtr dtd;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
-  if(!node->doc) { return Qnil; }
+  if (!node->doc) { return Qnil; }
 
   doc = node->doc;
   dtd = doc->extSubset;
 
-  if(!dtd) { return Qnil; }
+  if (!dtd) { return Qnil; }
 
-  return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)dtd);
+  return noko_xml_node_wrap(Qnil, (xmlNodePtr)dtd);
 }
 
 /*
- * call-seq:
- *  internal_subset
+ * :call-seq:
+ *   internal_subset()
  *
  * Get the internal subset
  */
-static VALUE internal_subset(VALUE self)
+static VALUE
+internal_subset(VALUE self)
 {
   xmlNodePtr node;
   xmlDocPtr doc;
   xmlDtdPtr dtd;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
-  if(!node->doc) { return Qnil; }
+  if (!node->doc) { return Qnil; }
 
   doc = node->doc;
   dtd = xmlGetIntSubset(doc);
 
-  if(!dtd) { return Qnil; }
+  if (!dtd) { return Qnil; }
 
-  return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)dtd);
+  return noko_xml_node_wrap(Qnil, (xmlNodePtr)dtd);
 }
 
 /*
- * call-seq:
- *  dup
- *  dup(depth)
- *  dup(depth, new_parent_doc)
+ * :call-seq:
+ *   dup → Nokogiri::XML::Node
+ *   dup(depth) → Nokogiri::XML::Node
+ *   dup(depth, new_parent_doc) → Nokogiri::XML::Node
  *
  * Copy this node.
- * An optional depth may be passed in. 0 is a shallow copy, 1 (the default) is a deep copy.
- * An optional new_parent_doc may also be passed in, which will be the new
- * node's parent document. Defaults to the current node's document.
- * current document.
+ *
+ * [Parameters]
+ * - +depth+ 0 is a shallow copy, 1 (the default) is a deep copy.
+ * - +new_parent_doc+
+ *   The new node's parent Document. Defaults to the this node's document.
+ *
+ * [Returns] The new Nokgiri::XML::Node
  */
-static VALUE duplicate_node(int argc, VALUE *argv, VALUE self)
+static VALUE
+duplicate_node(int argc, VALUE *argv, VALUE self)
 {
   VALUE r_level, r_new_parent_doc;
   int level;
@@ -549,7 +972,7 @@ static VALUE duplicate_node(int argc, VALUE *argv, VALUE self)
   xmlDocPtr new_parent_doc;
   xmlNodePtr node, dup;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   n_args = rb_scan_args(argc, argv, "02", &r_level, &r_new_parent_doc);
 
@@ -561,44 +984,33 @@ static VALUE duplicate_node(int argc, VALUE *argv, VALUE self)
   if (n_args < 2) {
     new_parent_doc = node->doc;
   } else {
-    Data_Get_Struct(r_new_parent_doc, xmlDoc, new_parent_doc);
+    new_parent_doc = noko_xml_document_unwrap(r_new_parent_doc);
   }
 
   dup = xmlDocCopyNode(node, new_parent_doc, level);
-  if(dup == NULL) { return Qnil; }
+  if (dup == NULL) { return Qnil; }
 
-  nokogiri_root_node(dup);
+  noko_xml_document_pin_node(dup);
 
-  return Nokogiri_wrap_xml_node(rb_obj_class(self), dup);
+  return noko_xml_node_wrap(rb_obj_class(self), dup);
 }
 
 /*
- * call-seq:
- *  unlink
+ * :call-seq:
+ *   unlink() → self
  *
  * Unlink this node from its current context.
  */
-static VALUE unlink_node(VALUE self)
+static VALUE
+unlink_node(VALUE self)
 {
   xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
   xmlUnlinkNode(node);
-  nokogiri_root_node(node);
+  noko_xml_document_pin_node(node);
   return self;
 }
 
-/*
- * call-seq:
- *  blank?
- *
- * Is this node blank?
- */
-static VALUE blank_eh(VALUE self)
-{
-  xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
-  return (1 == xmlIsBlankNode(node)) ? Qtrue : Qfalse ;
-}
 
 /*
  * call-seq:
@@ -606,15 +1018,16 @@ static VALUE blank_eh(VALUE self)
  *
  * Returns the next sibling node
  */
-static VALUE next_sibling(VALUE self)
+static VALUE
+next_sibling(VALUE self)
 {
   xmlNodePtr node, sibling;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   sibling = node->next;
-  if(!sibling) { return Qnil; }
+  if (!sibling) { return Qnil; }
 
-  return Nokogiri_wrap_xml_node(Qnil, sibling) ;
+  return noko_xml_node_wrap(Qnil, sibling) ;
 }
 
 /*
@@ -623,15 +1036,16 @@ static VALUE next_sibling(VALUE self)
  *
  * Returns the previous sibling node
  */
-static VALUE previous_sibling(VALUE self)
+static VALUE
+previous_sibling(VALUE self)
 {
   xmlNodePtr node, sibling;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   sibling = node->prev;
-  if(!sibling) { return Qnil; }
+  if (!sibling) { return Qnil; }
 
-  return Nokogiri_wrap_xml_node(Qnil, sibling);
+  return noko_xml_node_wrap(Qnil, sibling);
 }
 
 /*
@@ -640,15 +1054,16 @@ static VALUE previous_sibling(VALUE self)
  *
  * Returns the next Nokogiri::XML::Element type sibling node.
  */
-static VALUE next_element(VALUE self)
+static VALUE
+next_element(VALUE self)
 {
   xmlNodePtr node, sibling;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   sibling = xmlNextElementSibling(node);
-  if(!sibling) { return Qnil; }
+  if (!sibling) { return Qnil; }
 
-  return Nokogiri_wrap_xml_node(Qnil, sibling);
+  return noko_xml_node_wrap(Qnil, sibling);
 }
 
 /*
@@ -657,82 +1072,60 @@ static VALUE next_element(VALUE self)
  *
  * Returns the previous Nokogiri::XML::Element type sibling node.
  */
-static VALUE previous_element(VALUE self)
+static VALUE
+previous_element(VALUE self)
 {
   xmlNodePtr node, sibling;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   /*
    *  note that we don't use xmlPreviousElementSibling here because it's buggy pre-2.7.7.
    */
   sibling = node->prev;
-  if(!sibling) { return Qnil; }
+  if (!sibling) { return Qnil; }
 
-  while(sibling && sibling->type != XML_ELEMENT_NODE) {
+  while (sibling && sibling->type != XML_ELEMENT_NODE) {
     sibling = sibling->prev;
   }
 
-  return sibling ? Nokogiri_wrap_xml_node(Qnil, sibling) : Qnil ;
+  return sibling ? noko_xml_node_wrap(Qnil, sibling) : Qnil ;
 }
 
 /* :nodoc: */
-static VALUE replace(VALUE self, VALUE new_node)
+static VALUE
+replace(VALUE self, VALUE new_node)
 {
   VALUE reparent = reparent_node_with(self, new_node, xmlReplaceNodeWrapper);
 
   xmlNodePtr pivot;
-  Data_Get_Struct(self, xmlNode, pivot);
-  nokogiri_root_node(pivot);
+  Noko_Node_Get_Struct(self, xmlNode, pivot);
+  noko_xml_document_pin_node(pivot);
 
   return reparent;
 }
 
 /*
- * call-seq:
- *  children
+ * :call-seq:
+ *   element_children() → NodeSet
+ *   elements() → NodeSet
  *
- * Get the list of children for this node as a NodeSet
- */
-static VALUE children(VALUE self)
-{
-  xmlNodePtr node;
-  xmlNodePtr child;
-  xmlNodeSetPtr set;
-  VALUE document;
-  VALUE node_set;
-
-  Data_Get_Struct(self, xmlNode, node);
-
-  child = node->children;
-  set = xmlXPathNodeSetCreate(child);
-
-  document = DOC_RUBY_OBJECT(node->doc);
-
-  if(!child) { return Nokogiri_wrap_xml_node_set(set, document); }
-
-  child = child->next;
-  while(NULL != child) {
-    xmlXPathNodeSetAddUnique(set, child);
-    child = child->next;
-  }
-
-  node_set = Nokogiri_wrap_xml_node_set(set, document);
-
-  return node_set;
-}
-
-/*
- * call-seq:
- *  element_children
+ * [Returns]
+ *   The node's child elements as a NodeSet. Only children that are elements will be returned, which
+ *   notably excludes Text nodes.
  *
- * Get the list of children for this node as a NodeSet.  All nodes will be
- * element nodes.
+ * *Example:*
  *
- * Example:
+ * Note that #children returns the Text node "hello" while #element_children does not.
  *
- *   @doc.root.element_children.all? { |x| x.element? } # => true
+ *   div = Nokogiri::HTML5("<div>hello<span>world</span>").at_css("div")
+ *   div.element_children
+ *   # => [#<Nokogiri::XML::Element:0x50 name="span" children=[#<Nokogiri::XML::Text:0x3c "world">]>]
+ *   div.children
+ *   # => [#<Nokogiri::XML::Text:0x64 "hello">,
+ *   #     #<Nokogiri::XML::Element:0x50 name="span" children=[#<Nokogiri::XML::Text:0x3c "world">]>]
  */
-static VALUE element_children(VALUE self)
+static VALUE
+rb_xml_node_element_children(VALUE self)
 {
   xmlNodePtr node;
   xmlNodePtr child;
@@ -740,83 +1133,78 @@ static VALUE element_children(VALUE self)
   VALUE document;
   VALUE node_set;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   child = xmlFirstElementChild(node);
   set = xmlXPathNodeSetCreate(child);
 
   document = DOC_RUBY_OBJECT(node->doc);
 
-  if(!child) { return Nokogiri_wrap_xml_node_set(set, document); }
-
-  child = xmlNextElementSibling(child);
-  while(NULL != child) {
-    xmlXPathNodeSetAddUnique(set, child);
-    child = xmlNextElementSibling(child);
-  }
-
-  node_set = Nokogiri_wrap_xml_node_set(set, document);
+  if (!child) { return noko_xml_node_set_wrap(set, document); }
 
-  return node_set;
-}
-
-/*
- * call-seq:
- *  child
- *
- * Returns the child node
- */
-static VALUE child(VALUE self)
-{
-  xmlNodePtr node, child;
-  Data_Get_Struct(self, xmlNode, node);
+  child = xmlNextElementSibling(child);
+  while (NULL != child) {
+    xmlXPathNodeSetAddUnique(set, child);
+    child = xmlNextElementSibling(child);
+  }
 
-  child = node->children;
-  if(!child) { return Qnil; }
+  node_set = noko_xml_node_set_wrap(set, document);
 
-  return Nokogiri_wrap_xml_node(Qnil, child);
+  return node_set;
 }
 
 /*
- * call-seq:
- *  first_element_child
+ * :call-seq:
+ *   first_element_child() → Node
  *
- * Returns the first child node of this node that is an element.
+ * [Returns] The first child Node that is an element.
  *
- * Example:
+ * *Example:*
  *
- *   @doc.root.first_element_child.element? # => true
+ * Note that the "hello" child, which is a Text node, is skipped and the <tt><span></tt> element is
+ * returned.
+ *
+ *   div = Nokogiri::HTML5("<div>hello<span>world</span>").at_css("div")
+ *   div.first_element_child
+ *   # => #(Element:0x3c { name = "span", children = [ #(Text "world")] })
  */
-static VALUE first_element_child(VALUE self)
+static VALUE
+rb_xml_node_first_element_child(VALUE self)
 {
   xmlNodePtr node, child;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   child = xmlFirstElementChild(node);
-  if(!child) { return Qnil; }
+  if (!child) { return Qnil; }
 
-  return Nokogiri_wrap_xml_node(Qnil, child);
+  return noko_xml_node_wrap(Qnil, child);
 }
 
 /*
- * call-seq:
- *  last_element_child
+ * :call-seq:
+ *   last_element_child() → Node
  *
- * Returns the last child node of this node that is an element.
+ * [Returns] The last child Node that is an element.
  *
- * Example:
+ * *Example:*
  *
- *   @doc.root.last_element_child.element? # => true
+ * Note that the "hello" child, which is a Text node, is skipped and the <tt><span>yes</span></tt>
+ * element is returned.
+ *
+ *   div = Nokogiri::HTML5("<div><span>no</span><span>yes</span>skip</div>").at_css("div")
+ *   div.last_element_child
+ *   # => #(Element:0x3c { name = "span", children = [ #(Text "yes")] })
  */
-static VALUE last_element_child(VALUE self)
+static VALUE
+rb_xml_node_last_element_child(VALUE self)
 {
   xmlNodePtr node, child;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   child = xmlLastElementChild(node);
-  if(!child) { return Qnil; }
+  if (!child) { return Qnil; }
 
-  return Nokogiri_wrap_xml_node(Qnil, child);
+  return noko_xml_node_wrap(Qnil, child);
 }
 
 /*
@@ -825,11 +1213,12 @@ static VALUE last_element_child(VALUE self)
  *
  * Returns true if +attribute+ is set
  */
-static VALUE key_eh(VALUE self, VALUE attribute)
+static VALUE
+key_eh(VALUE self, VALUE attribute)
 {
   xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
-  if(xmlHasProp(node, (xmlChar *)StringValueCStr(attribute))) {
+  Noko_Node_Get_Struct(self, xmlNode, node);
+  if (xmlHasProp(node, (xmlChar *)StringValueCStr(attribute))) {
     return Qtrue;
   }
   return Qfalse;
@@ -841,12 +1230,13 @@ static VALUE key_eh(VALUE self, VALUE attribute)
  *
  * Returns true if +attribute+ is set with +namespace+
  */
-static VALUE namespaced_key_eh(VALUE self, VALUE attribute, VALUE namespace)
+static VALUE
+namespaced_key_eh(VALUE self, VALUE attribute, VALUE namespace)
 {
   xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
-  if(xmlHasNsProp(node, (xmlChar *)StringValueCStr(attribute),
-                  NIL_P(namespace) ? NULL : (xmlChar *)StringValueCStr(namespace))) {
+  Noko_Node_Get_Struct(self, xmlNode, node);
+  if (xmlHasNsProp(node, (xmlChar *)StringValueCStr(attribute),
+                   NIL_P(namespace) ? NULL : (xmlChar *)StringValueCStr(namespace))) {
     return Qtrue;
   }
   return Qfalse;
@@ -858,11 +1248,12 @@ static VALUE namespaced_key_eh(VALUE self, VALUE attribute, VALUE namespace)
  *
  * Set the +property+ to +value+
  */
-static VALUE set(VALUE self, VALUE property, VALUE value)
+static VALUE
+set(VALUE self, VALUE property, VALUE value)
 {
   xmlNodePtr node, cur;
   xmlAttrPtr prop;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   /* If a matching attribute node already exists, then xmlSetProp will destroy
    * the existing node's children. However, if Nokogiri has a node object
@@ -871,13 +1262,13 @@ static VALUE set(VALUE self, VALUE property, VALUE value)
    * We can avoid this by unlinking these nodes first.
    */
   if (node->type != XML_ELEMENT_NODE) {
-    return(Qnil);
+    return (Qnil);
   }
   prop = xmlHasProp(node, (xmlChar *)StringValueCStr(property));
   if (prop && prop->children) {
     for (cur = prop->children; cur; cur = cur->next) {
       if (cur->_private) {
-        nokogiri_root_node(cur);
+        noko_xml_document_pin_node(cur);
         xmlUnlinkNode(cur);
       }
     }
@@ -895,7 +1286,8 @@ static VALUE set(VALUE self, VALUE property, VALUE value)
  *
  * Get the value for +attribute+
  */
-static VALUE get(VALUE self, VALUE rattribute)
+static VALUE
+get(VALUE self, VALUE rattribute)
 {
   xmlNodePtr node;
   xmlChar *value = 0;
@@ -906,10 +1298,10 @@ static VALUE get(VALUE self, VALUE rattribute)
 
   if (NIL_P(rattribute)) { return Qnil; }
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
   attribute = xmlCharStrdup(StringValueCStr(rattribute));
 
-  colon = (xmlChar *)(uintptr_t)xmlStrchr(attribute, (const xmlChar)':');
+  colon = DISCARD_CONST_QUAL_XMLCHAR(xmlStrchr(attribute, (const xmlChar)':'));
   if (colon) {
     /* split the attribute string into separate prefix and name by
      * null-terminating the prefix at the colon */
@@ -921,7 +1313,7 @@ static VALUE get(VALUE self, VALUE rattribute)
     if (ns) {
       value = xmlGetNsProp(node, attr_name, ns->href);
     } else {
-      value = xmlGetProp(node, (xmlChar*)StringValueCStr(rattribute));
+      value = xmlGetProp(node, (xmlChar *)StringValueCStr(rattribute));
     }
   } else {
     value = xmlGetNoNsProp(node, attribute);
@@ -942,15 +1334,16 @@ static VALUE get(VALUE self, VALUE rattribute)
  *
  * Set the namespace to +namespace+
  */
-static VALUE set_namespace(VALUE self, VALUE namespace)
+static VALUE
+set_namespace(VALUE self, VALUE namespace)
 {
   xmlNodePtr node;
   xmlNsPtr ns = NULL;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
-  if(!NIL_P(namespace)) {
-    Data_Get_Struct(namespace, xmlNs, ns);
+  if (!NIL_P(namespace)) {
+    Noko_Namespace_Get_Struct(namespace, xmlNs, ns);
   }
 
   xmlSetNs(node, ns);
@@ -959,138 +1352,140 @@ static VALUE set_namespace(VALUE self, VALUE namespace)
 }
 
 /*
- * call-seq:
- *   attribute(name)
+ * :call-seq:
+ *   namespace() → Namespace
  *
- * Get the attribute node with +name+
- */
-static VALUE attr(VALUE self, VALUE name)
-{
-  xmlNodePtr node;
-  xmlAttrPtr prop;
-  Data_Get_Struct(self, xmlNode, node);
-  prop = xmlHasProp(node, (xmlChar *)StringValueCStr(name));
-
-  if(! prop) { return Qnil; }
-  return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)prop);
-}
-
-/*
- * call-seq:
- *   attribute_with_ns(name, namespace)
+ * [Returns] The Namespace of the element or attribute node, or +nil+ if there is no namespace.
  *
- * Get the attribute node with +name+ and +namespace+
- */
-static VALUE attribute_with_ns(VALUE self, VALUE name, VALUE namespace)
-{
-  xmlNodePtr node;
-  xmlAttrPtr prop;
-  Data_Get_Struct(self, xmlNode, node);
-  prop = xmlHasNsProp(node, (xmlChar *)StringValueCStr(name),
-                      NIL_P(namespace) ? NULL : (xmlChar *)StringValueCStr(namespace));
-
-  if(! prop) { return Qnil; }
-  return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)prop);
-}
-
-/*
- *  call-seq:
- *    attribute_nodes()
+ * *Example:*
  *
- *  returns a list containing the Node attributes.
+ *   doc = Nokogiri::XML(<<~EOF)
+ *     <root>
+ *       <first/>
+ *       <second xmlns="http://example.com/child"/>
+ *       <foo:third xmlns:foo="http://example.com/foo"/>
+ *     </root>
+ *   EOF
+ *   doc.at_xpath("//first").namespace
+ *   # => nil
+ *   doc.at_xpath("//xmlns:second", "xmlns" => "http://example.com/child").namespace
+ *   # => #(Namespace:0x3c { href = "http://example.com/child" })
+ *   doc.at_xpath("//foo:third", "foo" => "http://example.com/foo").namespace
+ *   # => #(Namespace:0x50 { prefix = "foo", href = "http://example.com/foo" })
  */
-static VALUE attribute_nodes(VALUE self)
+static VALUE
+rb_xml_node_namespace(VALUE rb_node)
 {
-  /* this code in the mode of xmlHasProp() */
-  xmlNodePtr node;
-  VALUE attr;
+  xmlNodePtr c_node ;
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
 
-  Data_Get_Struct(self, xmlNode, node);
-
-  attr = rb_ary_new();
-  Nokogiri_xml_node_properties(node, attr);
+  if (c_node->ns) {
+    return noko_xml_namespace_wrap(c_node->ns, c_node->doc);
+  }
 
-  return attr ;
+  return Qnil ;
 }
 
-
 /*
- *  call-seq:
- *    namespace()
+ * :call-seq:
+ *   namespace_definitions() → Array<Nokogiri::XML::Namespace>
  *
- *  returns the namespace of the element or attribute node as a Namespace
- *  object, or nil if there is no namespace for the element or attribute.
- */
-static VALUE namespace(VALUE self)
-{
-xmlNodePtr node ;
-Data_Get_Struct(self, xmlNode, node);
-
-if (node->ns) {
-  return Nokogiri_wrap_xml_namespace(node->doc, node->ns);
-}
-
-return Qnil ;
-}
-
-/*
- *  call-seq:
- *    namespace_definitions()
+ * [Returns]
+ *   Namespaces that are defined directly on this node, as an Array of Namespace objects. The array
+ *   will be empty if no namespaces are defined on this node.
  *
- *  returns namespaces defined on self element directly, as an array of Namespace objects. Includes both a default namespace (as in"xmlns="), and prefixed namespaces (as in "xmlns:prefix=").
+ * *Example:*
+ *
+ *   doc = Nokogiri::XML(<<~EOF)
+ *     <root xmlns="http://example.com/root">
+ *       <first/>
+ *       <second xmlns="http://example.com/child" xmlns:unused="http://example.com/unused"/>
+ *       <foo:third xmlns:foo="http://example.com/foo"/>
+ *     </root>
+ *   EOF
+ *   doc.at_xpath("//root:first", "root" => "http://example.com/root").namespace_definitions
+ *   # => []
+ *   doc.at_xpath("//xmlns:second", "xmlns" => "http://example.com/child").namespace_definitions
+ *   # => [#(Namespace:0x3c { href = "http://example.com/child" }),
+ *   #     #(Namespace:0x50 {
+ *   #       prefix = "unused",
+ *   #       href = "http://example.com/unused"
+ *   #       })]
+ *   doc.at_xpath("//foo:third", "foo" => "http://example.com/foo").namespace_definitions
+ *   # => [#(Namespace:0x64 { prefix = "foo", href = "http://example.com/foo" })]
  */
-static VALUE namespace_definitions(VALUE self)
+static VALUE
+namespace_definitions(VALUE rb_node)
 {
   /* this code in the mode of xmlHasProp() */
-  xmlNodePtr node ;
-  VALUE list;
-  xmlNsPtr ns;
-
-  Data_Get_Struct(self, xmlNode, node);
+  xmlNodePtr c_node ;
+  xmlNsPtr c_namespace;
+  VALUE definitions = rb_ary_new();
 
-  list = rb_ary_new();
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
 
-  ns = node->nsDef;
-
-  if(!ns) { return list; }
+  c_namespace = c_node->nsDef;
+  if (!c_namespace) {
+    return definitions;
+  }
 
-  while(NULL != ns) {
-    rb_ary_push(list, Nokogiri_wrap_xml_namespace(node->doc, ns));
-    ns = ns->next;
+  while (c_namespace != NULL) {
+    rb_ary_push(definitions, noko_xml_namespace_wrap(c_namespace, c_node->doc));
+    c_namespace = c_namespace->next;
   }
 
-  return list;
+  return definitions;
 }
 
 /*
- *  call-seq:
- *    namespace_scopes()
+ * :call-seq:
+ *   namespace_scopes() → Array<Nokogiri::XML::Namespace>
  *
- * returns namespaces in scope for self -- those defined on self element
- * directly or any ancestor node -- as an array of Namespace objects.  Default
- * namespaces ("xmlns=" style) for self are included in this array; Default
- * namespaces for  ancestors, however, are not. See also #namespaces
+ * [Returns] Array of all the Namespaces on this node and its ancestors.
+ *
+ * See also #namespaces
+ *
+ * *Example:*
+ *
+ *   doc = Nokogiri::XML(<<~EOF)
+ *     <root xmlns="http://example.com/root" xmlns:bar="http://example.com/bar">
+ *       <first/>
+ *       <second xmlns="http://example.com/child"/>
+ *       <third xmlns:foo="http://example.com/foo"/>
+ *     </root>
+ *   EOF
+ *   doc.at_xpath("//root:first", "root" => "http://example.com/root").namespace_scopes
+ *   # => [#(Namespace:0x3c { href = "http://example.com/root" }),
+ *   #     #(Namespace:0x50 { prefix = "bar", href = "http://example.com/bar" })]
+ *   doc.at_xpath("//child:second", "child" => "http://example.com/child").namespace_scopes
+ *   # => [#(Namespace:0x64 { href = "http://example.com/child" }),
+ *   #     #(Namespace:0x50 { prefix = "bar", href = "http://example.com/bar" })]
+ *   doc.at_xpath("//root:third", "root" => "http://example.com/root").namespace_scopes
+ *   # => [#(Namespace:0x78 { prefix = "foo", href = "http://example.com/foo" }),
+ *   #     #(Namespace:0x3c { href = "http://example.com/root" }),
+ *   #     #(Namespace:0x50 { prefix = "bar", href = "http://example.com/bar" })]
  */
-static VALUE namespace_scopes(VALUE self)
+static VALUE
+rb_xml_node_namespace_scopes(VALUE rb_node)
 {
-  xmlNodePtr node ;
-  VALUE list;
-  xmlNsPtr *ns_list;
+  xmlNodePtr c_node ;
+  xmlNsPtr *namespaces;
+  VALUE scopes = rb_ary_new();
   int j;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
 
-  list = rb_ary_new();
-  ns_list = xmlGetNsList(node->doc, node);
-
-  if(!ns_list) { return list; }
+  namespaces = xmlGetNsList(c_node->doc, c_node);
+  if (!namespaces) {
+    return scopes;
+  }
 
-  for (j = 0 ; ns_list[j] != NULL ; ++j) {
-    rb_ary_push(list, Nokogiri_wrap_xml_namespace(node->doc, ns_list[j]));
+  for (j = 0 ; namespaces[j] != NULL ; ++j) {
+    rb_ary_push(scopes, noko_xml_namespace_wrap(namespaces[j], c_node->doc));
   }
 
-  xmlFree(ns_list);
-  return list;
+  xmlFree(namespaces);
+  return scopes;
 }
 
 /*
@@ -1099,11 +1494,12 @@ static VALUE namespace_scopes(VALUE self)
  *
  * Get the type for this Node
  */
-static VALUE node_type(VALUE self)
+static VALUE
+node_type(VALUE self)
 {
   xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
-  return INT2NUM((long)node->type);
+  Noko_Node_Get_Struct(self, xmlNode, node);
+  return INT2NUM(node->type);
 }
 
 /*
@@ -1112,16 +1508,17 @@ static VALUE node_type(VALUE self)
  *
  * Set the content for this Node
  */
-static VALUE set_native_content(VALUE self, VALUE content)
+static VALUE
+set_native_content(VALUE self, VALUE content)
 {
   xmlNodePtr node, child, next ;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   child = node->children;
   while (NULL != child) {
     next = child->next ;
     xmlUnlinkNode(child) ;
-    nokogiri_root_node(child);
+    noko_xml_document_pin_node(child);
     child = next ;
   }
 
@@ -1129,41 +1526,20 @@ static VALUE set_native_content(VALUE self, VALUE content)
   return content;
 }
 
-/*
- * call-seq:
- *  content
- *
- * Returns the content for this Node
- */
-static VALUE get_native_content(VALUE self)
-{
-  xmlNodePtr node;
-  xmlChar * content;
-
-  Data_Get_Struct(self, xmlNode, node);
-
-  content = xmlNodeGetContent(node);
-  if(content) {
-    VALUE rval = NOKOGIRI_STR_NEW2(content);
-    xmlFree(content);
-    return rval;
-  }
-  return Qnil;
-}
-
 /*
  * call-seq:
  *  lang=
  *
  * Set the language of a node, i.e. the values of the xml:lang attribute.
  */
-static VALUE set_lang(VALUE self_rb, VALUE lang_rb)
+static VALUE
+set_lang(VALUE self_rb, VALUE lang_rb)
 {
   xmlNodePtr self ;
-  xmlChar* lang ;
+  xmlChar *lang ;
 
-  Data_Get_Struct(self_rb, xmlNode, self);
-  lang = (xmlChar*)StringValueCStr(lang_rb);
+  Noko_Node_Get_Struct(self_rb, xmlNode, self);
+  lang = (xmlChar *)StringValueCStr(lang_rb);
 
   xmlNodeSetLang(self, lang);
 
@@ -1177,13 +1553,14 @@ static VALUE set_lang(VALUE self_rb, VALUE lang_rb)
  * Searches the language of a node, i.e. the values of the xml:lang attribute or
  * the one carried by the nearest ancestor.
  */
-static VALUE get_lang(VALUE self_rb)
+static VALUE
+get_lang(VALUE self_rb)
 {
   xmlNodePtr self ;
-  xmlChar* lang ;
+  xmlChar *lang ;
   VALUE lang_rb ;
 
-  Data_Get_Struct(self_rb, xmlNode, self);
+  Noko_Node_Get_Struct(self_rb, xmlNode, self);
 
   lang = xmlNodeGetLang(self);
   if (lang) {
@@ -1196,7 +1573,8 @@ static VALUE get_lang(VALUE self_rb)
 }
 
 /* :nodoc: */
-static VALUE add_child(VALUE self, VALUE new_child)
+static VALUE
+add_child(VALUE self, VALUE new_child)
 {
   return reparent_node_with(self, new_child, xmlAddChild);
 }
@@ -1207,15 +1585,16 @@ static VALUE add_child(VALUE self, VALUE new_child)
  *
  * Get the parent Node for this Node
  */
-static VALUE get_parent(VALUE self)
+static VALUE
+get_parent(VALUE self)
 {
   xmlNodePtr node, parent;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   parent = node->parent;
-  if(!parent) { return Qnil; }
+  if (!parent) { return Qnil; }
 
-  return Nokogiri_wrap_xml_node(Qnil, parent) ;
+  return noko_xml_node_wrap(Qnil, parent) ;
 }
 
 /*
@@ -1224,11 +1603,12 @@ static VALUE get_parent(VALUE self)
  *
  * Set the name for this Node
  */
-static VALUE set_name(VALUE self, VALUE new_name)
+static VALUE
+set_name(VALUE self, VALUE new_name)
 {
   xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
-  xmlNodeSetName(node, (xmlChar*)StringValueCStr(new_name));
+  Noko_Node_Get_Struct(self, xmlNode, node);
+  xmlNodeSetName(node, (xmlChar *)StringValueCStr(new_name));
   return new_name;
 }
 
@@ -1238,11 +1618,12 @@ static VALUE set_name(VALUE self, VALUE new_name)
  *
  * Returns the name for this Node
  */
-static VALUE get_name(VALUE self)
+static VALUE
+get_name(VALUE self)
 {
   xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
-  if(node->name) {
+  Noko_Node_Get_Struct(self, xmlNode, node);
+  if (node->name) {
     return NOKOGIRI_STR_NEW2(node->name);
   }
   return Qnil;
@@ -1254,28 +1635,39 @@ static VALUE get_name(VALUE self)
  *
  * Returns the path associated with this Node
  */
-static VALUE path(VALUE self)
+static VALUE
+rb_xml_node_path(VALUE rb_node)
 {
-  xmlNodePtr node;
-  xmlChar *path ;
+  xmlNodePtr c_node;
+  xmlChar *c_path ;
   VALUE rval;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
+
+  c_path = xmlGetNodePath(c_node);
+  if (c_path == NULL) {
+    // see https://github.com/sparklemotion/nokogiri/issues/2250
+    // this behavior is clearly undesirable, but is what libxml <= 2.9.10 returned, and so we
+    // do this for now to preserve the behavior across libxml2 versions.
+    rval = NOKOGIRI_STR_NEW2("?");
+  } else {
+    rval = NOKOGIRI_STR_NEW2(c_path);
+    xmlFree(c_path);
+  }
 
-  path = xmlGetNodePath(node);
-  rval = NOKOGIRI_STR_NEW2(path);
-  xmlFree(path);
   return rval ;
 }
 
 /* :nodoc: */
-static VALUE add_next_sibling(VALUE self, VALUE new_sibling)
+static VALUE
+add_next_sibling(VALUE self, VALUE new_sibling)
 {
   return reparent_node_with(self, new_sibling, xmlAddNextSibling) ;
 }
 
 /* :nodoc: */
-static VALUE add_previous_sibling(VALUE self, VALUE new_sibling)
+static VALUE
+add_previous_sibling(VALUE self, VALUE new_sibling)
 {
   return reparent_node_with(self, new_sibling, xmlAddPrevSibling) ;
 }
@@ -1286,7 +1678,8 @@ static VALUE add_previous_sibling(VALUE self, VALUE new_sibling)
  *
  * Write this Node to +io+ with +encoding+ and +options+
  */
-static VALUE native_write_to(
+static VALUE
+native_write_to(
   VALUE self,
   VALUE io,
   VALUE encoding,
@@ -1295,10 +1688,10 @@ static VALUE native_write_to(
 )
 {
   xmlNodePtr node;
-  const char * before_indent;
+  const char *before_indent;
   xmlSaveCtxtPtr savectx;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   xmlIndentTreeOutput = 1;
 
@@ -1307,8 +1700,8 @@ static VALUE native_write_to(
   xmlTreeIndentString = StringValueCStr(indent_string);
 
   savectx = xmlSaveToIO(
-              (xmlOutputWriteCallback)io_write_callback,
-              (xmlOutputCloseCallback)io_close_callback,
+              (xmlOutputWriteCallback)noko_io_write,
+              (xmlOutputCloseCallback)noko_io_close,
               (void *)io,
               RTEST(encoding) ? StringValueCStr(encoding) : NULL,
               (int)NUM2INT(options)
@@ -1321,93 +1714,366 @@ static VALUE native_write_to(
   return io;
 }
 
-/*
- * call-seq:
- *  line
- *
- * Returns the line for this Node
- */
-static VALUE line(VALUE self)
+
+static inline void
+output_partial_string(VALUE out, char const *str, size_t length)
 {
-  xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
+  if (length) {
+    rb_enc_str_buf_cat(out, str, (long)length, rb_utf8_encoding());
+  }
+}
 
-  return INT2NUM(xmlGetLineNo(node));
+static inline void
+output_char(VALUE out, char ch)
+{
+  output_partial_string(out, &ch, 1);
 }
 
-/*
- * call-seq:
- *  add_namespace_definition(prefix, href)
- *
- * Adds a namespace definition with +prefix+ using +href+ value. The result is
- * as if parsed XML for this node had included an attribute
- * 'xmlns:prefix=value'.  A default namespace for this node ("xmlns=") can be
- * added by passing 'nil' for prefix. Namespaces added this way will not
- * show up in #attributes, but they will be included as an xmlns attribute
- * when the node is serialized to XML.
- */
-static VALUE add_namespace_definition(VALUE self, VALUE prefix, VALUE href)
+static inline void
+output_string(VALUE out, char const *str)
 {
-  xmlNodePtr node, namespace;
-  xmlNsPtr ns;
+  output_partial_string(out, str, strlen(str));
+}
+
+static inline void
+output_tagname(VALUE out, xmlNodePtr elem)
+{
+  // Elements in the HTML, MathML, and SVG namespaces do not use a namespace
+  // prefix in the HTML syntax.
+  char const *name = (char const *)elem->name;
+  xmlNsPtr ns = elem->ns;
+  if (ns && ns->href && ns->prefix
+      && strcmp((char const *)ns->href, "http://www.w3.org/1999/xhtml")
+      && strcmp((char const *)ns->href, "http://www.w3.org/1998/Math/MathML")
+      && strcmp((char const *)ns->href, "http://www.w3.org/2000/svg")) {
+    output_string(out, (char const *)elem->ns->prefix);
+    output_char(out, ':');
+    char const *colon = strchr(name, ':');
+    if (colon) {
+      name = colon + 1;
+    }
+  }
+  output_string(out, name);
+}
+
+static inline void
+output_attr_name(VALUE out, xmlAttrPtr attr)
+{
+  xmlNsPtr ns = attr->ns;
+  char const *name = (char const *)attr->name;
+  if (ns && ns->href) {
+    char const *uri = (char const *)ns->href;
+    char const *localname = strchr(name, ':');
+    if (localname) {
+      ++localname;
+    } else {
+      localname = name;
+    }
+
+    if (!strcmp(uri, "http://www.w3.org/XML/1998/namespace")) {
+      output_string(out, "xml:");
+      name = localname;
+    } else if (!strcmp(uri, "http://www.w3.org/2000/xmlns/")) {
+      // xmlns:xmlns -> xmlns
+      // xmlns:foo -> xmlns:foo
+      if (strcmp(localname, "xmlns")) {
+        output_string(out, "xmlns:");
+      }
+      name = localname;
+    } else if (!strcmp(uri, "http://www.w3.org/1999/xlink")) {
+      output_string(out, "xlink:");
+      name = localname;
+    } else if (ns->prefix) {
+      output_string(out, (char const *)ns->prefix);
+      output_char(out, ':');
+      name = localname;
+    }
+  }
+  output_string(out, name);
+}
+
+static void
+output_escaped_string(VALUE out, xmlChar const *start, bool attr)
+{
+  xmlChar const *next = start;
+  int ch;
+
+  while ((ch = *next) != 0) {
+    char const *replacement = NULL;
+    size_t replaced_bytes = 1;
+    if (ch == '&') {
+      replacement = "&amp;";
+    } else if (ch == 0xC2 && next[1] == 0xA0) {
+      // U+00A0 NO-BREAK SPACE has the UTF-8 encoding C2 A0.
+      replacement = "&nbsp;";
+      replaced_bytes = 2;
+    } else if (attr && ch == '"') {
+      replacement = "&quot;";
+    } else if (!attr && ch == '<') {
+      replacement = "&lt;";
+    } else if (!attr && ch == '>') {
+      replacement = "&gt;";
+    } else {
+      ++next;
+      continue;
+    }
+    output_partial_string(out, (char const *)start, next - start);
+    output_string(out, replacement);
+    next += replaced_bytes;
+    start = next;
+  }
+  output_partial_string(out, (char const *)start, next - start);
+}
 
-  Data_Get_Struct(self, xmlNode, node);
-  namespace = node ;
+static bool
+should_prepend_newline(xmlNodePtr node)
+{
+  char const *name = (char const *)node->name;
+  xmlNodePtr child = node->children;
+
+  if (!name || !child || (strcmp(name, "pre") && strcmp(name, "textarea") && strcmp(name, "listing"))) {
+    return false;
+  }
+
+  return child->type == XML_TEXT_NODE && child->content && child->content[0] == '\n';
+}
 
-  ns = xmlSearchNs(
-         node->doc,
-         node,
-         (const xmlChar *)(NIL_P(prefix) ? NULL : StringValueCStr(prefix))
-       );
+static VALUE
+rb_prepend_newline(VALUE self)
+{
+  xmlNodePtr node;
+  Noko_Node_Get_Struct(self, xmlNode, node);
+  return should_prepend_newline(node) ? Qtrue : Qfalse;
+}
 
-  if(!ns) {
-    if (node->type != XML_ELEMENT_NODE) {
-      namespace = node->parent;
+static bool
+is_one_of(xmlNodePtr node, char const *const *tagnames, size_t num_tagnames)
+{
+  char const *name = (char const *)node->name;
+  if (name == NULL) { // fragments don't have a name
+    return false;
+  }
+  for (size_t idx = 0; idx < num_tagnames; ++idx) {
+    if (!strcmp(name, tagnames[idx])) {
+      return true;
     }
-    ns = xmlNewNs(
-           namespace,
-           (const xmlChar *)StringValueCStr(href),
-           (const xmlChar *)(NIL_P(prefix) ? NULL : StringValueCStr(prefix))
-         );
   }
+  return false;
+
+}
+
+static void
+output_node(
+  VALUE out,
+  xmlNodePtr node,
+  bool preserve_newline
+)
+{
+  static char const *const VOID_ELEMENTS[] = {
+    "area", "base", "basefont", "bgsound", "br", "col", "embed", "frame", "hr",
+    "img", "input", "keygen", "link", "meta", "param", "source", "track", "wbr",
+  };
+
+  static char const *const UNESCAPED_TEXT_ELEMENTS[] = {
+    "style", "script", "xmp", "iframe", "noembed", "noframes", "plaintext", "noscript",
+  };
+
+  switch (node->type) {
+    case XML_ELEMENT_NODE:
+      // Serialize the start tag.
+      output_char(out, '<');
+      output_tagname(out, node);
+
+      // Add attributes.
+      for (xmlAttrPtr attr = node->properties; attr; attr = attr->next) {
+        output_char(out, ' ');
+        output_attr_name(out, attr);
+        if (attr->children) {
+          output_string(out, "=\"");
+          xmlChar *value = xmlNodeListGetString(attr->doc, attr->children, 1);
+          output_escaped_string(out, value, true);
+          xmlFree(value);
+          output_char(out, '"');
+        } else {
+          // Output name=""
+          output_string(out, "=\"\"");
+        }
+      }
+      output_char(out, '>');
+
+      // Add children and end tag if element is not void.
+      if (!is_one_of(node, VOID_ELEMENTS, sizeof VOID_ELEMENTS / sizeof VOID_ELEMENTS[0])) {
+        if (preserve_newline && should_prepend_newline(node)) {
+          output_char(out, '\n');
+        }
+        for (xmlNodePtr child = node->children; child; child = child->next) {
+          output_node(out, child, preserve_newline);
+        }
+        output_string(out, "</");
+        output_tagname(out, node);
+        output_char(out, '>');
+      }
+      break;
+
+    case XML_TEXT_NODE:
+      if (node->parent
+          && is_one_of(node->parent, UNESCAPED_TEXT_ELEMENTS,
+                       sizeof UNESCAPED_TEXT_ELEMENTS / sizeof UNESCAPED_TEXT_ELEMENTS[0])) {
+        output_string(out, (char const *)node->content);
+      } else {
+        output_escaped_string(out, node->content, false);
+      }
+      break;
+
+    case XML_CDATA_SECTION_NODE:
+      output_string(out, "<![CDATA[");
+      output_string(out, (char const *)node->content);
+      output_string(out, "]]>");
+      break;
+
+    case XML_COMMENT_NODE:
+      output_string(out, "<!--");
+      output_string(out, (char const *)node->content);
+      output_string(out, "-->");
+      break;
+
+    case XML_PI_NODE:
+      output_string(out, "<?");
+      output_string(out, (char const *)node->content);
+      output_char(out, '>');
+      break;
+
+    case XML_DOCUMENT_TYPE_NODE:
+    case XML_DTD_NODE:
+      output_string(out, "<!DOCTYPE ");
+      output_string(out, (char const *)node->name);
+      output_string(out, ">");
+      break;
+
+    case XML_DOCUMENT_NODE:
+    case XML_DOCUMENT_FRAG_NODE:
+    case XML_HTML_DOCUMENT_NODE:
+      for (xmlNodePtr child = node->children; child; child = child->next) {
+        output_node(out, child, preserve_newline);
+      }
+      break;
+
+    default:
+      rb_raise(rb_eRuntimeError, "Unsupported document node (%d); this is a bug in Nokogiri", node->type);
+      break;
+  }
+}
 
-  if (!ns) { return Qnil ; }
+static VALUE
+html_standard_serialize(
+  VALUE self,
+  VALUE preserve_newline
+)
+{
+  xmlNodePtr node;
+  Noko_Node_Get_Struct(self, xmlNode, node);
+  VALUE output = rb_str_buf_new(4096);
+  output_node(output, node, RTEST(preserve_newline));
+  return output;
+}
 
-  if(NIL_P(prefix) || node != namespace) { xmlSetNs(node, ns); }
+/*
+ * :call-seq:
+ *   line() → Integer
+ *
+ * [Returns] The line number of this Node.
+ *
+ * ---
+ *
+ * <b> ⚠ The CRuby and JRuby implementations differ in important ways! </b>
+ *
+ * Semantic differences:
+ * - The CRuby method reflects the node's line number <i>in the parsed string</i>
+ * - The JRuby method reflects the node's line number <i>in the final DOM structure</i> after
+ *   corrections have been applied
+ *
+ * Performance differences:
+ * - The CRuby method is {O(1)}[https://en.wikipedia.org/wiki/Time_complexity#Constant_time]
+ *   (constant time)
+ * - The JRuby method is {O(n)}[https://en.wikipedia.org/wiki/Time_complexity#Linear_time] (linear
+ *   time, where n is the number of nodes before/above the element in the DOM)
+ *
+ * If you'd like to help improve the JRuby implementation, please review these issues and reach out
+ * to the maintainers:
+ * - https://github.com/sparklemotion/nokogiri/issues/1223
+ * - https://github.com/sparklemotion/nokogiri/pull/2177
+ * - https://github.com/sparklemotion/nokogiri/issues/2380
+ */
+static VALUE
+rb_xml_node_line(VALUE rb_node)
+{
+  xmlNodePtr c_node;
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
 
-  return Nokogiri_wrap_xml_namespace(node->doc, ns);
+  return LONG2NUM(xmlGetLineNo(c_node));
 }
 
 /*
  * call-seq:
- *   new(name, document)
+ *  line=(num)
  *
- * Create a new node with +name+ sharing GC lifecycle with +document+
+ * Sets the line for this Node. num must be less than 65535.
  */
-static VALUE new(int argc, VALUE *argv, VALUE klass)
+static VALUE
+rb_xml_node_line_set(VALUE rb_node, VALUE rb_line_number)
 {
-  xmlDocPtr doc;
-  xmlNodePtr node;
-  VALUE name;
-  VALUE document;
+  xmlNodePtr c_node;
+  int line_number = NUM2INT(rb_line_number);
+
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
+
+  // libxml2 optionally uses xmlNode.psvi to store longer line numbers, but only for text nodes.
+  // search for "psvi" in SAX2.c and tree.c to learn more.
+  if (line_number < 65535) {
+    c_node->line = (short) line_number;
+  } else {
+    c_node->line = 65535;
+    if (c_node->type == XML_TEXT_NODE) {
+      c_node->psvi = (void *)(ptrdiff_t) line_number;
+    }
+  }
+
+  return rb_line_number;
+}
+
+/* :nodoc: documented in lib/nokogiri/xml/node.rb */
+static VALUE
+rb_xml_node_new(int argc, VALUE *argv, VALUE klass)
+{
+  xmlNodePtr c_document_node;
+  xmlNodePtr c_node;
+  VALUE rb_name;
+  VALUE rb_document_node;
   VALUE rest;
   VALUE rb_node;
 
-  rb_scan_args(argc, argv, "2*", &name, &document, &rest);
+  rb_scan_args(argc, argv, "2*", &rb_name, &rb_document_node, &rest);
 
-  Data_Get_Struct(document, xmlDoc, doc);
+  if (!rb_obj_is_kind_of(rb_document_node, cNokogiriXmlNode)) {
+    rb_raise(rb_eArgError, "document must be a Nokogiri::XML::Node");
+  }
+  if (!rb_obj_is_kind_of(rb_document_node, cNokogiriXmlDocument)) {
+    // TODO: deprecate allowing Node
+    NOKO_WARN_DEPRECATION("Passing a Node as the second parameter to Node.new is deprecated. Please pass a Document instead, or prefer an alternative constructor like Node#add_child. This will become an error in a future release of Nokogiri.");
+  }
+  Noko_Node_Get_Struct(rb_document_node, xmlNode, c_document_node);
 
-  node = xmlNewNode(NULL, (xmlChar *)StringValueCStr(name));
-  node->doc = doc->doc;
-  nokogiri_root_node(node);
+  c_node = xmlNewNode(NULL, (xmlChar *)StringValueCStr(rb_name));
+  c_node->doc = c_document_node->doc;
+  noko_xml_document_pin_node(c_node);
 
-  rb_node = Nokogiri_wrap_xml_node(
+  rb_node = noko_xml_node_wrap(
               klass == cNokogiriXmlNode ? (VALUE)NULL : klass,
-              node
+              c_node
             );
   rb_obj_call_init(rb_node, argc, argv);
 
-  if(rb_block_given_p()) { rb_yield(rb_node); }
+  if (rb_block_given_p()) { rb_yield(rb_node); }
 
   return rb_node;
 }
@@ -1418,13 +2084,14 @@ static VALUE new(int argc, VALUE *argv, VALUE klass)
  *
  * Returns the Node as html.
  */
-static VALUE dump_html(VALUE self)
+static VALUE
+dump_html(VALUE self)
 {
   xmlBufferPtr buf ;
   xmlNodePtr node ;
   VALUE html;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   buf = xmlBufferCreate() ;
   htmlNodeDump(buf, node->doc, node);
@@ -1439,13 +2106,14 @@ static VALUE dump_html(VALUE self)
  *
  * Compare this Node to +other+ with respect to their Document
  */
-static VALUE compare(VALUE self, VALUE _other)
+static VALUE
+compare(VALUE self, VALUE _other)
 {
   xmlNodePtr node, other;
-  Data_Get_Struct(self, xmlNode, node);
-  Data_Get_Struct(_other, xmlNode, other);
+  Noko_Node_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(_other, xmlNode, other);
 
-  return INT2NUM((long)xmlXPathCmpNodes(other, node));
+  return INT2NUM(xmlXPathCmpNodes(other, node));
 }
 
 
@@ -1456,13 +2124,14 @@ static VALUE compare(VALUE self, VALUE _other)
  * Loads and substitutes all xinclude elements below the node. The
  * parser context will be initialized with +options+.
  */
-static VALUE process_xincludes(VALUE self, VALUE options)
+static VALUE
+process_xincludes(VALUE self, VALUE options)
 {
   int rcode ;
   xmlNodePtr node;
   VALUE error_list = rb_ary_new();
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
   rcode = xmlXIncludeProcessTreeFlags(node, (int)NUM2INT(options));
@@ -1472,7 +2141,7 @@ static VALUE process_xincludes(VALUE self, VALUE options)
     xmlErrorPtr error;
 
     error = xmlGetLastError();
-    if(error) {
+    if (error) {
       rb_exc_raise(Nokogiri_wrap_xml_syntax_error(error));
     } else {
       rb_raise(rb_eRuntimeError, "Could not perform xinclude substitution");
@@ -1484,7 +2153,8 @@ static VALUE process_xincludes(VALUE self, VALUE options)
 
 
 /* TODO: DOCUMENT ME */
-static VALUE in_context(VALUE self, VALUE _str, VALUE _options)
+static VALUE
+in_context(VALUE self, VALUE _str, VALUE _options)
 {
   xmlNodePtr node, list = 0, tmp, child_iter, node_children, doc_children;
   xmlNodeSetPtr set;
@@ -1492,7 +2162,7 @@ static VALUE in_context(VALUE self, VALUE _str, VALUE _options)
   VALUE doc, err;
   int doc_is_empty;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   doc = DOC_RUBY_OBJECT(node->doc);
   err = rb_iv_get(doc, "@errors");
@@ -1533,9 +2203,7 @@ static VALUE in_context(VALUE self, VALUE _str, VALUE _options)
    */
   child_iter = node->doc->children ;
   while (child_iter) {
-    if (child_iter->parent != (xmlNodePtr)node->doc) {
-      child_iter->parent = (xmlNodePtr)node->doc;
-    }
+    child_iter->parent = (xmlNodePtr)node->doc;
     child_iter = child_iter->next;
   }
 
@@ -1545,12 +2213,17 @@ static VALUE in_context(VALUE self, VALUE _str, VALUE _options)
 
   xmlSetStructuredErrorFunc(NULL, NULL);
 
-  /* Workaround for a libxml2 bug where a parsing error may leave a broken
+  /*
+   * Workaround for a libxml2 bug where a parsing error may leave a broken
    * node reference in node->doc->children.
+   *
+   * https://bugzilla.gnome.org/show_bug.cgi?id=668155
+   *
    * This workaround is limited to when a parse error occurs, the document
    * went from having no children to having children, and the context node is
    * part of a document fragment.
-   * https://bugzilla.gnome.org/show_bug.cgi?id=668155
+   *
+   * TODO: This was fixed in libxml 2.8.0 by 71a243d
    */
   if (error != XML_ERR_OK && doc_is_empty && node->doc->children != NULL) {
     child_iter = node;
@@ -1565,12 +2238,12 @@ static VALUE in_context(VALUE self, VALUE _str, VALUE _options)
 
   /* FIXME: This probably needs to handle more constants... */
   switch (error) {
-  case XML_ERR_INTERNAL_ERROR:
-  case XML_ERR_NO_MEMORY:
-    rb_raise(rb_eRuntimeError, "error parsing fragment (%d)", error);
-    break;
-  default:
-    break;
+    case XML_ERR_INTERNAL_ERROR:
+    case XML_ERR_NO_MEMORY:
+      rb_raise(rb_eRuntimeError, "error parsing fragment (%d)", error);
+      break;
+    default:
+      break;
   }
 
   set = xmlXPathNodeSetCreate(NULL);
@@ -1579,178 +2252,174 @@ static VALUE in_context(VALUE self, VALUE _str, VALUE _options)
     tmp = list->next;
     list->next = NULL;
     xmlXPathNodeSetAddUnique(set, list);
-    nokogiri_root_node(list);
+    noko_xml_document_pin_node(list);
     list = tmp;
   }
 
-  return Nokogiri_wrap_xml_node_set(set, doc);
+  return noko_xml_node_set_wrap(set, doc);
 }
 
-
-VALUE Nokogiri_wrap_xml_node(VALUE klass, xmlNodePtr node)
+VALUE
+noko_xml_node_wrap(VALUE rb_class, xmlNodePtr c_node)
 {
-  VALUE document = Qnil ;
-  VALUE node_cache = Qnil ;
-  VALUE rb_node = Qnil ;
+  VALUE rb_document, rb_node_cache, rb_node;
   nokogiriTuplePtr node_has_a_document;
-  xmlDocPtr doc;
-  void (*mark_method)(xmlNodePtr) = NULL ;
+  xmlDocPtr c_doc;
 
-  assert(node);
+  assert(c_node);
 
-  if(node->type == XML_DOCUMENT_NODE || node->type == XML_HTML_DOCUMENT_NODE) {
-    return DOC_RUBY_OBJECT(node->doc);
+  if (c_node->type == XML_DOCUMENT_NODE || c_node->type == XML_HTML_DOCUMENT_NODE) {
+    return DOC_RUBY_OBJECT(c_node->doc);
   }
 
-  /* It's OK if the node doesn't have a fully-realized document (as in XML::Reader). */
-  /* see https://github.com/sparklemotion/nokogiri/issues/95 */
-  /* and https://github.com/sparklemotion/nokogiri/issues/439 */
-  doc = node->doc;
-  if (doc->type == XML_DOCUMENT_FRAG_NODE) { doc = doc->doc; }
-  node_has_a_document = DOC_RUBY_OBJECT_TEST(doc);
+  c_doc = c_node->doc;
+
+  // Nodes yielded from XML::Reader don't have a fully-realized Document
+  node_has_a_document = DOC_RUBY_OBJECT_TEST(c_doc);
 
-  if(node->_private && node_has_a_document) {
-    return (VALUE)node->_private;
+  if (c_node->_private && node_has_a_document) {
+    return (VALUE)c_node->_private;
   }
 
-  if(!RTEST(klass)) {
-    switch(node->type) {
-    case XML_ELEMENT_NODE:
-      klass = cNokogiriXmlElement;
-      break;
-    case XML_TEXT_NODE:
-      klass = cNokogiriXmlText;
-      break;
-    case XML_ATTRIBUTE_NODE:
-      klass = cNokogiriXmlAttr;
-      break;
-    case XML_ENTITY_REF_NODE:
-      klass = cNokogiriXmlEntityReference;
-      break;
-    case XML_COMMENT_NODE:
-      klass = cNokogiriXmlComment;
-      break;
-    case XML_DOCUMENT_FRAG_NODE:
-      klass = cNokogiriXmlDocumentFragment;
-      break;
-    case XML_PI_NODE:
-      klass = cNokogiriXmlProcessingInstruction;
-      break;
-    case XML_ENTITY_DECL:
-      klass = cNokogiriXmlEntityDecl;
-      break;
-    case XML_CDATA_SECTION_NODE:
-      klass = cNokogiriXmlCData;
-      break;
-    case XML_DTD_NODE:
-      klass = cNokogiriXmlDtd;
-      break;
-    case XML_ATTRIBUTE_DECL:
-      klass = cNokogiriXmlAttributeDecl;
-      break;
-    case XML_ELEMENT_DECL:
-      klass = cNokogiriXmlElementDecl;
-      break;
-    default:
-      klass = cNokogiriXmlNode;
+  if (!RTEST(rb_class)) {
+    switch (c_node->type) {
+      case XML_ELEMENT_NODE:
+        rb_class = cNokogiriXmlElement;
+        break;
+      case XML_TEXT_NODE:
+        rb_class = cNokogiriXmlText;
+        break;
+      case XML_ATTRIBUTE_NODE:
+        rb_class = cNokogiriXmlAttr;
+        break;
+      case XML_ENTITY_REF_NODE:
+        rb_class = cNokogiriXmlEntityReference;
+        break;
+      case XML_COMMENT_NODE:
+        rb_class = cNokogiriXmlComment;
+        break;
+      case XML_DOCUMENT_FRAG_NODE:
+        rb_class = cNokogiriXmlDocumentFragment;
+        break;
+      case XML_PI_NODE:
+        rb_class = cNokogiriXmlProcessingInstruction;
+        break;
+      case XML_ENTITY_DECL:
+        rb_class = cNokogiriXmlEntityDecl;
+        break;
+      case XML_CDATA_SECTION_NODE:
+        rb_class = cNokogiriXmlCData;
+        break;
+      case XML_DTD_NODE:
+        rb_class = cNokogiriXmlDtd;
+        break;
+      case XML_ATTRIBUTE_DECL:
+        rb_class = cNokogiriXmlAttributeDecl;
+        break;
+      case XML_ELEMENT_DECL:
+        rb_class = cNokogiriXmlElementDecl;
+        break;
+      default:
+        rb_class = cNokogiriXmlNode;
     }
   }
 
-  mark_method = node_has_a_document ? mark : NULL ;
-
-  rb_node = Data_Wrap_Struct(klass, mark_method, debug_node_dealloc, node) ;
-  node->_private = (void *)rb_node;
+  rb_node = TypedData_Wrap_Struct(rb_class, &nokogiri_node_type, c_node) ;
+  c_node->_private = (void *)rb_node;
 
   if (node_has_a_document) {
-    document = DOC_RUBY_OBJECT(doc);
-    node_cache = DOC_NODE_CACHE(doc);
-    rb_ary_push(node_cache, rb_node);
-    rb_funcall(document, decorate, 1, rb_node);
+    rb_document = DOC_RUBY_OBJECT(c_doc);
+    rb_node_cache = DOC_NODE_CACHE(c_doc);
+    rb_ary_push(rb_node_cache, rb_node);
+    rb_funcall(rb_document, id_decorate, 1, rb_node);
   }
 
   return rb_node ;
 }
 
 
-void Nokogiri_xml_node_properties(xmlNodePtr node, VALUE attr_list)
+/*
+ *  return Array<Nokogiri::XML::Attr> containing the node's attributes
+ */
+VALUE
+noko_xml_node_attrs(xmlNodePtr c_node)
 {
-  xmlAttrPtr prop;
-  prop = node->properties ;
-  while (prop != NULL) {
-    rb_ary_push(attr_list, Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)prop));
-    prop = prop->next ;
+  VALUE rb_properties = rb_ary_new();
+  xmlAttrPtr c_property;
+
+  c_property = c_node->properties ;
+  while (c_property != NULL) {
+    rb_ary_push(rb_properties, noko_xml_node_wrap(Qnil, (xmlNodePtr)c_property));
+    c_property = c_property->next ;
   }
+
+  return rb_properties;
 }
 
-VALUE cNokogiriXmlNode ;
-VALUE cNokogiriXmlElement ;
-
-void init_xml_node()
-{
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE xml = rb_define_module_under(nokogiri, "XML");
-  VALUE klass = rb_define_class_under(xml, "Node", rb_cObject);
-
-  cNokogiriXmlNode = klass;
-
-  cNokogiriXmlElement = rb_define_class_under(xml, "Element", klass);
-
-  rb_define_singleton_method(klass, "new", new, -1);
-
-  rb_define_method(klass, "add_namespace_definition", add_namespace_definition, 2);
-  rb_define_method(klass, "node_name", get_name, 0);
-  rb_define_method(klass, "document", document, 0);
-  rb_define_method(klass, "node_name=", set_name, 1);
-  rb_define_method(klass, "parent", get_parent, 0);
-  rb_define_method(klass, "child", child, 0);
-  rb_define_method(klass, "first_element_child", first_element_child, 0);
-  rb_define_method(klass, "last_element_child", last_element_child, 0);
-  rb_define_method(klass, "children", children, 0);
-  rb_define_method(klass, "element_children", element_children, 0);
-  rb_define_method(klass, "next_sibling", next_sibling, 0);
-  rb_define_method(klass, "previous_sibling", previous_sibling, 0);
-  rb_define_method(klass, "next_element", next_element, 0);
-  rb_define_method(klass, "previous_element", previous_element, 0);
-  rb_define_method(klass, "node_type", node_type, 0);
-  rb_define_method(klass, "path", path, 0);
-  rb_define_method(klass, "key?", key_eh, 1);
-  rb_define_method(klass, "namespaced_key?", namespaced_key_eh, 2);
-  rb_define_method(klass, "blank?", blank_eh, 0);
-  rb_define_method(klass, "attribute_nodes", attribute_nodes, 0);
-  rb_define_method(klass, "attribute", attr, 1);
-  rb_define_method(klass, "attribute_with_ns", attribute_with_ns, 2);
-  rb_define_method(klass, "namespace", namespace, 0);
-  rb_define_method(klass, "namespace_definitions", namespace_definitions, 0);
-  rb_define_method(klass, "namespace_scopes", namespace_scopes, 0);
-  rb_define_method(klass, "encode_special_chars", encode_special_chars, 1);
-  rb_define_method(klass, "dup", duplicate_node, -1);
-  rb_define_method(klass, "unlink", unlink_node, 0);
-  rb_define_method(klass, "internal_subset", internal_subset, 0);
-  rb_define_method(klass, "external_subset", external_subset, 0);
-  rb_define_method(klass, "create_internal_subset", create_internal_subset, 3);
-  rb_define_method(klass, "create_external_subset", create_external_subset, 3);
-  rb_define_method(klass, "pointer_id", pointer_id, 0);
-  rb_define_method(klass, "line", line, 0);
-  rb_define_method(klass, "content", get_native_content, 0);
-  rb_define_method(klass, "native_content=", set_native_content, 1);
-  rb_define_method(klass, "lang", get_lang, 0);
-  rb_define_method(klass, "lang=", set_lang, 1);
-
-  rb_define_private_method(klass, "process_xincludes", process_xincludes, 1);
-  rb_define_private_method(klass, "in_context", in_context, 2);
-  rb_define_private_method(klass, "add_child_node", add_child, 1);
-  rb_define_private_method(klass, "add_previous_sibling_node", add_previous_sibling, 1);
-  rb_define_private_method(klass, "add_next_sibling_node", add_next_sibling, 1);
-  rb_define_private_method(klass, "replace_node", replace, 1);
-  rb_define_private_method(klass, "dump_html", dump_html, 0);
-  rb_define_private_method(klass, "native_write_to", native_write_to, 4);
-  rb_define_private_method(klass, "get", get, 1);
-  rb_define_private_method(klass, "set", set, 2);
-  rb_define_private_method(klass, "set_namespace", set_namespace, 1);
-  rb_define_private_method(klass, "compare", compare, 1);
-
-  decorate      = rb_intern("decorate");
-  decorate_bang = rb_intern("decorate!");
-}
-
-/* vim: set noet sw=4 sws=4 */
+void
+noko_init_xml_node(void)
+{
+  cNokogiriXmlNode = rb_define_class_under(mNokogiriXml, "Node", rb_cObject);
+
+  rb_undef_alloc_func(cNokogiriXmlNode);
+
+  rb_define_singleton_method(cNokogiriXmlNode, "new", rb_xml_node_new, -1);
+
+  rb_define_method(cNokogiriXmlNode, "add_namespace_definition", rb_xml_node_add_namespace_definition, 2);
+  rb_define_method(cNokogiriXmlNode, "attribute", rb_xml_node_attribute, 1);
+  rb_define_method(cNokogiriXmlNode, "attribute_nodes", rb_xml_node_attribute_nodes, 0);
+  rb_define_method(cNokogiriXmlNode, "attribute_with_ns", rb_xml_node_attribute_with_ns, 2);
+  rb_define_method(cNokogiriXmlNode, "blank?", rb_xml_node_blank_eh, 0);
+  rb_define_method(cNokogiriXmlNode, "child", rb_xml_node_child, 0);
+  rb_define_method(cNokogiriXmlNode, "children", rb_xml_node_children, 0);
+  rb_define_method(cNokogiriXmlNode, "content", rb_xml_node_content, 0);
+  rb_define_method(cNokogiriXmlNode, "create_external_subset", create_external_subset, 3);
+  rb_define_method(cNokogiriXmlNode, "create_internal_subset", create_internal_subset, 3);
+  rb_define_method(cNokogiriXmlNode, "document", rb_xml_node_document, 0);
+  rb_define_method(cNokogiriXmlNode, "dup", duplicate_node, -1);
+  rb_define_method(cNokogiriXmlNode, "element_children", rb_xml_node_element_children, 0);
+  rb_define_method(cNokogiriXmlNode, "encode_special_chars", encode_special_chars, 1);
+  rb_define_method(cNokogiriXmlNode, "external_subset", external_subset, 0);
+  rb_define_method(cNokogiriXmlNode, "first_element_child", rb_xml_node_first_element_child, 0);
+  rb_define_method(cNokogiriXmlNode, "internal_subset", internal_subset, 0);
+  rb_define_method(cNokogiriXmlNode, "key?", key_eh, 1);
+  rb_define_method(cNokogiriXmlNode, "lang", get_lang, 0);
+  rb_define_method(cNokogiriXmlNode, "lang=", set_lang, 1);
+  rb_define_method(cNokogiriXmlNode, "last_element_child", rb_xml_node_last_element_child, 0);
+  rb_define_method(cNokogiriXmlNode, "line", rb_xml_node_line, 0);
+  rb_define_method(cNokogiriXmlNode, "line=", rb_xml_node_line_set, 1);
+  rb_define_method(cNokogiriXmlNode, "namespace", rb_xml_node_namespace, 0);
+  rb_define_method(cNokogiriXmlNode, "namespace_definitions", namespace_definitions, 0);
+  rb_define_method(cNokogiriXmlNode, "namespace_scopes", rb_xml_node_namespace_scopes, 0);
+  rb_define_method(cNokogiriXmlNode, "namespaced_key?", namespaced_key_eh, 2);
+  rb_define_method(cNokogiriXmlNode, "native_content=", set_native_content, 1);
+  rb_define_method(cNokogiriXmlNode, "next_element", next_element, 0);
+  rb_define_method(cNokogiriXmlNode, "next_sibling", next_sibling, 0);
+  rb_define_method(cNokogiriXmlNode, "node_name", get_name, 0);
+  rb_define_method(cNokogiriXmlNode, "node_name=", set_name, 1);
+  rb_define_method(cNokogiriXmlNode, "node_type", node_type, 0);
+  rb_define_method(cNokogiriXmlNode, "parent", get_parent, 0);
+  rb_define_method(cNokogiriXmlNode, "path", rb_xml_node_path, 0);
+  rb_define_method(cNokogiriXmlNode, "pointer_id", rb_xml_node_pointer_id, 0);
+  rb_define_method(cNokogiriXmlNode, "previous_element", previous_element, 0);
+  rb_define_method(cNokogiriXmlNode, "previous_sibling", previous_sibling, 0);
+  rb_define_method(cNokogiriXmlNode, "unlink", unlink_node, 0);
+
+  rb_define_private_method(cNokogiriXmlNode, "add_child_node", add_child, 1);
+  rb_define_private_method(cNokogiriXmlNode, "add_next_sibling_node", add_next_sibling, 1);
+  rb_define_private_method(cNokogiriXmlNode, "add_previous_sibling_node", add_previous_sibling, 1);
+  rb_define_private_method(cNokogiriXmlNode, "compare", compare, 1);
+  rb_define_private_method(cNokogiriXmlNode, "dump_html", dump_html, 0);
+  rb_define_private_method(cNokogiriXmlNode, "get", get, 1);
+  rb_define_private_method(cNokogiriXmlNode, "in_context", in_context, 2);
+  rb_define_private_method(cNokogiriXmlNode, "native_write_to", native_write_to, 4);
+  rb_define_private_method(cNokogiriXmlNode, "prepend_newline?", rb_prepend_newline, 0);
+  rb_define_private_method(cNokogiriXmlNode, "html_standard_serialize", html_standard_serialize, 1);
+  rb_define_private_method(cNokogiriXmlNode, "process_xincludes", process_xincludes, 1);
+  rb_define_private_method(cNokogiriXmlNode, "replace_node", replace, 1);
+  rb_define_private_method(cNokogiriXmlNode, "set", set, 2);
+  rb_define_private_method(cNokogiriXmlNode, "set_namespace", set_namespace, 1);
+
+  id_decorate      = rb_intern("decorate");
+  id_decorate_bang = rb_intern("decorate!");
+}