nokogiri 1.11.3 → 1.13.8

data/ext/nokogiri/xml_node.c

@@ -1,23 +1,30 @@
 #include <nokogiri.h>
 
-VALUE cNokogiriXmlNode ;
+// :stopdoc:
 
+VALUE cNokogiriXmlNode ;
 static ID id_decorate, id_decorate_bang;
 
+typedef xmlNodePtr(*pivot_reparentee_func)(xmlNodePtr, xmlNodePtr);
+
 #ifdef DEBUG
 static void
-debug_node_dealloc(xmlNodePtr x)
+_xml_node_dealloc(xmlNodePtr x)
 {
   NOKOGIRI_DEBUG_START(x)
   NOKOGIRI_DEBUG_END(x)
 }
 #else
-#  define debug_node_dealloc 0
+#  define _xml_node_dealloc 0
 #endif
 
 static void
-mark(xmlNodePtr node)
+_xml_node_mark(xmlNodePtr node)
 {
+  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)) {
@@ -28,14 +35,37 @@ mark(xmlNodePtr node)
   }
 }
 
-/* :nodoc: */
-typedef xmlNodePtr(*pivot_reparentee_func)(xmlNodePtr, xmlNodePtr);
+#ifdef HAVE_RB_GC_LOCATION
+static void
+_xml_node_update_references(xmlNodePtr node)
+{
+  if (node->_private) {
+    node->_private = (void *)rb_gc_location((VALUE)node->_private);
+  }
+}
+#endif
+
+typedef void (*gc_callback_t)(void *);
+
+static const rb_data_type_t nokogiri_node_type = {
+  "Nokogiri/XMLNode",
+  {
+    (gc_callback_t)_xml_node_mark, (gc_callback_t)_xml_node_dealloc, 0,
+#ifdef HAVE_RB_GC_LOCATION
+    (gc_callback_t)_xml_node_update_references
+#endif
+  },
+  0, 0,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+  RUBY_TYPED_FREE_IMMEDIATELY,
+#endif
+};
 
-/* :nodoc: */
 static void
 relink_namespace(xmlNodePtr reparented)
 {
   xmlNodePtr child;
+  xmlAttrPtr attr;
 
   if (reparented->type != XML_ATTRIBUTE_NODE &&
       reparented->type != XML_ELEMENT_NODE) { return; }
@@ -69,7 +99,9 @@ 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);
   }
 
@@ -132,15 +164,17 @@ 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: */
+
+/* internal function meant to wrap xmlReplaceNode
+   and fix some issues we have with libxml2 merging nodes */
 static xmlNodePtr
 xmlReplaceNodeWrapper(xmlNodePtr pivot, xmlNodePtr new_node)
 {
@@ -165,12 +199,23 @@ xmlReplaceNodeWrapper(xmlNodePtr pivot, xmlNodePtr new_node)
   return retval ;
 }
 
-/* :nodoc: */
+
+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)) {
@@ -180,8 +225,8 @@ reparent_node_with(VALUE pivot_obj, VALUE reparentee_obj, pivot_reparentee_func
     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
@@ -197,66 +242,66 @@ reparent_node_with(VALUE pivot_obj, VALUE reparentee_obj, pivot_reparentee_func
 
   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) {
     /*
@@ -308,11 +353,13 @@ ok:
        *  issue #391, where new node's prefix may become the string "default"
        *  see libxml2 tree.c xmlNewReconciliedNs which implements this behavior.
        */
-      xmlFree((xmlChar *)reparentee->ns->prefix);
+      xmlFree(DISCARD_CONST_QUAL_XMLCHAR(reparentee->ns->prefix));
       reparentee->ns->prefix = NULL;
     }
   }
 
+  xmlUnlinkNode(original_reparentee);
+
   if (prf != xmlAddPrevSibling && prf != xmlAddNextSibling
       && reparentee->type == XML_TEXT_NODE && pivot->next && pivot->next->type == XML_TEXT_NODE) {
     /*
@@ -352,49 +399,421 @@ ok:
    *  adjacent text nodes.
    */
   DATA_PTR(reparentee_obj) = reparented ;
-
-  relink_namespace(reparented);
-
   reparented_obj = noko_xml_node_wrap(Qnil, reparented);
 
   rb_funcall(reparented_obj, id_decorate_bang, 0);
 
+  /* if we've created a cycle, raise an exception */
+  raise_if_ancestor_of_self(reparented);
+
+  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"
  *
- * Get the document for this Node
  */
 static VALUE
-document(VALUE self)
+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;
-  Data_Get_Struct(self, xmlNode, 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
+ *
+ * [Returns] Parent Nokogiri::XML::Document for this node
+ */
+static VALUE
+rb_xml_node_document(VALUE self)
+{
+  xmlNodePtr 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)
+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));
 }
 
 /*
- * call-seq:
- *  encode_special_chars(string)
+ * :call-seq: encode_special_chars(string) → String
  *
  * Encode any special characters in +string+
  */
@@ -405,7 +824,7 @@ encode_special_chars(VALUE self, VALUE string)
   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)
@@ -418,8 +837,8 @@ 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.
  *
@@ -436,7 +855,7 @@ create_internal_subset(VALUE self, VALUE name, VALUE external_id, VALUE system_i
   xmlDocPtr doc;
   xmlDtdPtr dtd;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   doc = node->doc;
 
@@ -457,8 +876,8 @@ create_internal_subset(VALUE self, VALUE name, VALUE external_id, VALUE system_i
 }
 
 /*
- * call-seq:
- *  create_external_subset(name, external_id, system_id)
+ * :call-seq:
+ *   create_external_subset(name, external_id, system_id)
  *
  * Create an external subset
  */
@@ -469,7 +888,7 @@ create_external_subset(VALUE self, VALUE name, VALUE external_id, VALUE system_i
   xmlDocPtr doc;
   xmlDtdPtr dtd;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   doc = node->doc;
 
@@ -490,8 +909,8 @@ create_external_subset(VALUE self, VALUE name, VALUE external_id, VALUE system_i
 }
 
 /*
- * call-seq:
- *  external_subset
+ * :call-seq:
+ *   external_subset()
  *
  * Get the external subset
  */
@@ -502,7 +921,7 @@ external_subset(VALUE self)
   xmlDocPtr doc;
   xmlDtdPtr dtd;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   if (!node->doc) { return Qnil; }
 
@@ -515,8 +934,8 @@ external_subset(VALUE self)
 }
 
 /*
- * call-seq:
- *  internal_subset
+ * :call-seq:
+ *   internal_subset()
  *
  * Get the internal subset
  */
@@ -527,7 +946,7 @@ internal_subset(VALUE self)
   xmlDocPtr doc;
   xmlDtdPtr dtd;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   if (!node->doc) { return Qnil; }
 
@@ -540,16 +959,19 @@ internal_subset(VALUE self)
 }
 
 /*
- * 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)
@@ -560,7 +982,7 @@ 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);
 
@@ -584,35 +1006,22 @@ duplicate_node(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * call-seq:
- *  unlink
- *
- * Unlink this node from its current context.
- */
-static VALUE
-unlink_node(VALUE self)
-{
-  xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
-  xmlUnlinkNode(node);
-  noko_xml_document_pin_node(node);
-  return self;
-}
-
-/*
- * call-seq:
- *  blank?
+ * :call-seq:
+ *   unlink() → self
  *
- * Is this node blank?
+ * Unlink this node from its current context.
  */
 static VALUE
-blank_eh(VALUE self)
+unlink_node(VALUE self)
 {
   xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
-  return (1 == xmlIsBlankNode(node)) ? Qtrue : Qfalse ;
+  Noko_Node_Get_Struct(self, xmlNode, node);
+  xmlUnlinkNode(node);
+  noko_xml_document_pin_node(node);
+  return self;
 }
 
+
 /*
  * call-seq:
  *  next_sibling
@@ -623,7 +1032,7 @@ 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; }
@@ -641,7 +1050,7 @@ 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; }
@@ -659,7 +1068,7 @@ 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; }
@@ -677,7 +1086,7 @@ 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.
@@ -699,60 +1108,34 @@ replace(VALUE self, VALUE new_node)
   VALUE reparent = reparent_node_with(self, new_node, xmlReplaceNodeWrapper);
 
   xmlNodePtr pivot;
-  Data_Get_Struct(self, xmlNode, 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 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:
- *  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)
+rb_xml_node_element_children(VALUE self)
 {
   xmlNodePtr node;
   xmlNodePtr child;
@@ -760,7 +1143,7 @@ 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);
@@ -781,38 +1164,25 @@ element_children(VALUE self)
 }
 
 /*
- * call-seq:
- *  child
+ * :call-seq:
+ *   first_element_child() → Node
  *
- * Returns the child node
- */
-static VALUE
-child(VALUE self)
-{
-  xmlNodePtr node, child;
-  Data_Get_Struct(self, xmlNode, node);
-
-  child = node->children;
-  if (!child) { return Qnil; }
-
-  return noko_xml_node_wrap(Qnil, child);
-}
-
-/*
- * call-seq:
- *  first_element_child
+ * [Returns] The first child Node that is an element.
  *
- * Returns the first child node of this node that is an element.
+ * *Example:*
  *
- * Example:
+ * Note that the "hello" child, which is a Text node, is skipped and the <tt><span></tt> element is
+ * returned.
  *
- *   @doc.root.first_element_child.element? # => true
+ *   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)
+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; }
@@ -821,20 +1191,25 @@ first_element_child(VALUE self)
 }
 
 /*
- * 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)
+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; }
@@ -852,7 +1227,7 @@ static VALUE
 key_eh(VALUE self, VALUE attribute)
 {
   xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
   if (xmlHasProp(node, (xmlChar *)StringValueCStr(attribute))) {
     return Qtrue;
   }
@@ -869,7 +1244,7 @@ static VALUE
 namespaced_key_eh(VALUE self, VALUE attribute, VALUE namespace)
 {
   xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
   if (xmlHasNsProp(node, (xmlChar *)StringValueCStr(attribute),
                    NIL_P(namespace) ? NULL : (xmlChar *)StringValueCStr(namespace))) {
     return Qtrue;
@@ -888,7 +1263,7 @@ 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
@@ -933,10 +1308,10 @@ 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 */
@@ -975,7 +1350,7 @@ 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);
@@ -987,70 +1362,32 @@ 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 noko_xml_node_wrap(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 noko_xml_node_wrap(Qnil, (xmlNodePtr)prop);
-}
-
-/*
- * @overload attribute_nodes()
- *   Get the attributes for a Node
- *   @return [Array<Nokogiri::XML::Attr>] containing the Node's attributes.
- */
-static VALUE
-attribute_nodes(VALUE rb_node)
-{
-  xmlNodePtr c_node;
-
-  Data_Get_Struct(rb_node, xmlNode, c_node);
-
-  return noko_xml_node_attrs(c_node);
-}
-
-
-/*
- *  call-seq:
- *    namespace()
+ * *Example:*
  *
- *  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.
+ *   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
-noko_xml_node_namespace(VALUE rb_node)
+rb_xml_node_namespace(VALUE rb_node)
 {
   xmlNodePtr c_node ;
-  Data_Get_Struct(rb_node, xmlNode, c_node);
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
 
   if (c_node->ns) {
     return noko_xml_namespace_wrap(c_node->ns, c_node->doc);
@@ -1060,10 +1397,32 @@ noko_xml_node_namespace(VALUE rb_node)
 }
 
 /*
- *  call-seq:
- *    namespace_definitions()
+ * :call-seq:
+ *   namespace_definitions() → Array<Nokogiri::XML::Namespace>
+ *
+ * [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 rb_node)
@@ -1073,7 +1432,7 @@ namespace_definitions(VALUE rb_node)
   xmlNsPtr c_namespace;
   VALUE definitions = rb_ary_new();
 
-  Data_Get_Struct(rb_node, xmlNode, c_node);
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
 
   c_namespace = c_node->nsDef;
   if (!c_namespace) {
@@ -1089,23 +1448,42 @@ namespace_definitions(VALUE rb_node)
 }
 
 /*
- *  call-seq:
- *    namespace_scopes()
+ * :call-seq:
+ *   namespace_scopes() → Array<Nokogiri::XML::Namespace>
+ *
+ * [Returns] Array of all the Namespaces on this node and its ancestors.
  *
- * 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
+ * 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 rb_node)
+rb_xml_node_namespace_scopes(VALUE rb_node)
 {
   xmlNodePtr c_node ;
   xmlNsPtr *namespaces;
   VALUE scopes = rb_ary_new();
   int j;
 
-  Data_Get_Struct(rb_node, xmlNode, c_node);
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
 
   namespaces = xmlGetNsList(c_node->doc, c_node);
   if (!namespaces) {
@@ -1130,7 +1508,7 @@ static VALUE
 node_type(VALUE self)
 {
   xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
   return INT2NUM((long)node->type);
 }
 
@@ -1144,7 +1522,7 @@ 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) {
@@ -1158,30 +1536,6 @@ set_native_content(VALUE self, VALUE content)
   return content;
 }
 
-/*
- * call-seq:
- *  content
- *
- * Returns the plaintext content for this Node. Note that entities will always
- * be expanded in the returned string.
- */
-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=
@@ -1194,7 +1548,7 @@ set_lang(VALUE self_rb, VALUE lang_rb)
   xmlNodePtr self ;
   xmlChar *lang ;
 
-  Data_Get_Struct(self_rb, xmlNode, self);
+  Noko_Node_Get_Struct(self_rb, xmlNode, self);
   lang = (xmlChar *)StringValueCStr(lang_rb);
 
   xmlNodeSetLang(self, lang);
@@ -1216,7 +1570,7 @@ get_lang(VALUE self_rb)
   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) {
@@ -1245,7 +1599,7 @@ 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; }
@@ -1263,7 +1617,7 @@ static VALUE
 set_name(VALUE self, VALUE new_name)
 {
   xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
   xmlNodeSetName(node, (xmlChar *)StringValueCStr(new_name));
   return new_name;
 }
@@ -1278,7 +1632,7 @@ static VALUE
 get_name(VALUE self)
 {
   xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
   if (node->name) {
     return NOKOGIRI_STR_NEW2(node->name);
   }
@@ -1292,17 +1646,25 @@ get_name(VALUE self)
  * Returns the path associated with this Node
  */
 static VALUE
-path(VALUE self)
+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 ;
 }
 
@@ -1339,7 +1701,7 @@ native_write_to(
   const char *before_indent;
   xmlSaveCtxtPtr savectx;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   xmlIndentTreeOutput = 1;
 
@@ -1363,18 +1725,39 @@ native_write_to(
 }
 
 /*
- * call-seq:
- *  line
+ * :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)
  *
- * Returns the line for this Node
+ * 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
-line(VALUE self)
+rb_xml_node_line(VALUE rb_node)
 {
-  xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
+  xmlNodePtr c_node;
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
 
-  return INT2NUM(xmlGetLineNo(node));
+  return INT2NUM(xmlGetLineNo(c_node));
 }
 
 /*
@@ -1384,90 +1767,56 @@ line(VALUE self)
  * Sets the line for this Node. num must be less than 65535.
  */
 static VALUE
-set_line(VALUE self, VALUE num)
-{
-  xmlNodePtr node;
-  int value = NUM2INT(num);
-
-  Data_Get_Struct(self, xmlNode, node);
-  if (value < 65535) {
-    node->line = value;
-  }
-
-  return num;
-}
-
-/*
- * 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 rb_node, VALUE rb_prefix, VALUE rb_href)
+rb_xml_node_line_set(VALUE rb_node, VALUE rb_line_number)
 {
-  xmlNodePtr c_node, element;
-  xmlNsPtr c_namespace;
-  const xmlChar *c_prefix = (const xmlChar *)(NIL_P(rb_prefix) ? NULL : StringValueCStr(rb_prefix));
-
-  Data_Get_Struct(rb_node, xmlNode, c_node);
-  element = c_node ;
+  xmlNodePtr c_node;
+  int line_number = NUM2INT(rb_line_number);
 
-  c_namespace = xmlSearchNs(c_node->doc, c_node, c_prefix);
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
 
-  if (!c_namespace) {
-    if (c_node->type != XML_ELEMENT_NODE) {
-      element = c_node->parent;
+  // 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;
     }
-    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);
+  return rb_line_number;
 }
 
-/*
- * @overload new(name, document)
- *   Create a new node with +name+ sharing GC lifecycle with +document+.
- *   @param name [String]
- *   @param document [Nokogiri::XML::Document]
- *   @yieldparam node [Nokogiri::XML::Node]
- *   @return [Nokogiri::XML::Node]
- *   @see Nokogiri::XML::Node#initialize
- */
+/* :nodoc: documented in lib/nokogiri/xml/node.rb */
 static VALUE
 rb_xml_node_new(int argc, VALUE *argv, VALUE klass)
 {
-  xmlDocPtr doc;
-  xmlNodePtr node;
-  VALUE name;
-  VALUE document;
+  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;
-  noko_xml_document_pin_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 = noko_xml_node_wrap(
               klass == cNokogiriXmlNode ? (VALUE)NULL : klass,
-              node
+              c_node
             );
   rb_obj_call_init(rb_node, argc, argv);
 
@@ -1489,7 +1838,7 @@ dump_html(VALUE self)
   xmlNodePtr node ;
   VALUE html;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(self, xmlNode, node);
 
   buf = xmlBufferCreate() ;
   htmlNodeDump(buf, node->doc, node);
@@ -1508,8 +1857,8 @@ 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));
 }
@@ -1529,7 +1878,7 @@ process_xincludes(VALUE self, VALUE options)
   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));
@@ -1560,7 +1909,7 @@ 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");
@@ -1601,9 +1950,7 @@ 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;
   }
 
@@ -1633,12 +1980,12 @@ 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);
@@ -1654,14 +2001,12 @@ in_context(VALUE self, VALUE _str, VALUE _options)
   return noko_xml_node_set_wrap(set, doc);
 }
 
-
 VALUE
 noko_xml_node_wrap(VALUE rb_class, xmlNodePtr c_node)
 {
   VALUE rb_document, rb_node_cache, rb_node;
   nokogiriTuplePtr node_has_a_document;
   xmlDocPtr c_doc;
-  void (*mark_method)(xmlNodePtr) = NULL ;
 
   assert(c_node);
 
@@ -1669,11 +2014,9 @@ noko_xml_node_wrap(VALUE rb_class, xmlNodePtr c_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 */
   c_doc = c_node->doc;
-  if (c_doc->type == XML_DOCUMENT_FRAG_NODE) { c_doc = c_doc->doc; }
+
+  // Nodes yielded from XML::Reader don't have a fully-realized Document
   node_has_a_document = DOC_RUBY_OBJECT_TEST(c_doc);
 
   if (c_node->_private && node_has_a_document) {
@@ -1682,50 +2025,48 @@ noko_xml_node_wrap(VALUE rb_class, xmlNodePtr c_node)
 
   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;
+      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(rb_class, mark_method, debug_node_dealloc, c_node) ;
+  rb_node = TypedData_Wrap_Struct(rb_class, &nokogiri_node_type, c_node) ;
   c_node->_private = (void *)rb_node;
 
   if (node_has_a_document) {
@@ -1762,63 +2103,63 @@ noko_init_xml_node()
 {
   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", add_namespace_definition, 2);
+  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, "document", document, 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, "child", child, 0);
-  rb_define_method(cNokogiriXmlNode, "first_element_child", first_element_child, 0);
-  rb_define_method(cNokogiriXmlNode, "last_element_child", last_element_child, 0);
-  rb_define_method(cNokogiriXmlNode, "children", children, 0);
-  rb_define_method(cNokogiriXmlNode, "element_children", element_children, 0);
-  rb_define_method(cNokogiriXmlNode, "next_sibling", next_sibling, 0);
-  rb_define_method(cNokogiriXmlNode, "previous_sibling", previous_sibling, 0);
-  rb_define_method(cNokogiriXmlNode, "next_element", next_element, 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, "node_type", node_type, 0);
-  rb_define_method(cNokogiriXmlNode, "path", path, 0);
-  rb_define_method(cNokogiriXmlNode, "key?", key_eh, 1);
-  rb_define_method(cNokogiriXmlNode, "namespaced_key?", namespaced_key_eh, 2);
-  rb_define_method(cNokogiriXmlNode, "blank?", blank_eh, 0);
-  rb_define_method(cNokogiriXmlNode, "attribute_nodes", attribute_nodes, 0);
-  rb_define_method(cNokogiriXmlNode, "attribute", attr, 1);
-  rb_define_method(cNokogiriXmlNode, "attribute_with_ns", attribute_with_ns, 2);
-  rb_define_method(cNokogiriXmlNode, "namespace", noko_xml_node_namespace, 0);
-  rb_define_method(cNokogiriXmlNode, "namespace_definitions", namespace_definitions, 0);
-  rb_define_method(cNokogiriXmlNode, "namespace_scopes", namespace_scopes, 0);
-  rb_define_method(cNokogiriXmlNode, "encode_special_chars", encode_special_chars, 1);
-  rb_define_method(cNokogiriXmlNode, "dup", duplicate_node, -1);
+  rb_define_method(cNokogiriXmlNode, "previous_sibling", previous_sibling, 0);
   rb_define_method(cNokogiriXmlNode, "unlink", unlink_node, 0);
-  rb_define_method(cNokogiriXmlNode, "internal_subset", internal_subset, 0);
-  rb_define_method(cNokogiriXmlNode, "external_subset", external_subset, 0);
-  rb_define_method(cNokogiriXmlNode, "create_internal_subset", create_internal_subset, 3);
-  rb_define_method(cNokogiriXmlNode, "create_external_subset", create_external_subset, 3);
-  rb_define_method(cNokogiriXmlNode, "pointer_id", pointer_id, 0);
-  rb_define_method(cNokogiriXmlNode, "line", line, 0);
-  rb_define_method(cNokogiriXmlNode, "line=", set_line, 1);
-  rb_define_method(cNokogiriXmlNode, "content", get_native_content, 0);
-  rb_define_method(cNokogiriXmlNode, "native_content=", set_native_content, 1);
-  rb_define_method(cNokogiriXmlNode, "lang", get_lang, 0);
-  rb_define_method(cNokogiriXmlNode, "lang=", set_lang, 1);
 
-  rb_define_private_method(cNokogiriXmlNode, "process_xincludes", process_xincludes, 1);
-  rb_define_private_method(cNokogiriXmlNode, "in_context", in_context, 2);
   rb_define_private_method(cNokogiriXmlNode, "add_child_node", add_child, 1);
-  rb_define_private_method(cNokogiriXmlNode, "add_previous_sibling_node", add_previous_sibling, 1);
   rb_define_private_method(cNokogiriXmlNode, "add_next_sibling_node", add_next_sibling, 1);
-  rb_define_private_method(cNokogiriXmlNode, "replace_node", replace, 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, "native_write_to", native_write_to, 4);
   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, "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);
-  rb_define_private_method(cNokogiriXmlNode, "compare", compare, 1);
 
   id_decorate      = rb_intern("decorate");
   id_decorate_bang = rb_intern("decorate!");
 }
-
-/* vim: set noet sw=4 sws=4 */