nokogiri 1.4.1 → 1.4.2

data/ext/nokogiri/xml_node.c

@@ -14,42 +14,61 @@ static void debug_node_dealloc(xmlNodePtr x)
 
 static void mark(xmlNodePtr node)
 {
-  // it's OK if the document isn't fully realized (as in XML::Reader).
-  // see http://github.com/tenderlove/nokogiri/issues/closed/#issue/95
+  /* it's OK if the document isn't fully realized (as in XML::Reader). */
+  /* see http://github.com/tenderlove/nokogiri/issues/closed/#issue/95 */
   if (DOC_RUBY_OBJECT_TEST(node->doc) && DOC_RUBY_OBJECT(node->doc))
     rb_gc_mark(DOC_RUBY_OBJECT(node->doc));
 }
 
 /* :nodoc: */
-typedef xmlNodePtr (*node_other_func)(xmlNodePtr, xmlNodePtr);
+typedef xmlNodePtr (*pivot_reparentee_func)(xmlNodePtr, xmlNodePtr);
 
 /* :nodoc: */
 static void relink_namespace(xmlNodePtr reparented)
 {
-  // Avoid segv when relinking against unlinked nodes.
+  xmlNodePtr child;
+
+  /* Avoid segv when relinking against unlinked nodes. */
   if(!reparented->parent) return;
 
-  // Make sure that our reparented node has the correct namespaces
+  /* Make sure that our reparented node has the correct namespaces */
   if(!reparented->ns && reparented->doc != (xmlDocPtr)reparented->parent)
     xmlSetNs(reparented, reparented->parent->ns);
 
-  // Search our parents for an existing definition
+  /* Search our parents for an existing definition */
   if(reparented->nsDef) {
-    xmlNsPtr ns = xmlSearchNsByHref(
-        reparented->doc,
-        reparented->parent,
-        reparented->nsDef->href
-    );
-    if(ns && ns != reparented->nsDef) reparented->nsDef = NULL;
+    xmlNsPtr curr = reparented->nsDef;
+    xmlNsPtr prev = NULL;
+
+    while(curr) {
+      xmlNsPtr ns = xmlSearchNsByHref(
+          reparented->doc,
+          reparented->parent,
+          curr->href
+      );
+      /* If we find the namespace is already declared, remove it from this
+       * definition list. */
+      if(ns && ns != curr) {
+        if (prev) {
+          prev->next = curr->next;
+        } else {
+          reparented->nsDef = curr->next;
+        }
+        NOKOGIRI_ROOT_NSDEF(curr, reparented->doc);
+      } else {
+        prev = curr;
+      }
+      curr = curr->next;
+    }
   }
 
-  // Only walk all children if there actually is a namespace we need to
-  // reparent.
+  /* Only walk all children if there actually is a namespace we need to */
+  /* reparent. */
   if(NULL == reparented->ns) return;
 
-  // When a node gets reparented, walk it's children to make sure that
-  // their namespaces are reparented as well.
-  xmlNodePtr child = reparented->children;
+  /* When a node gets reparented, walk it's children to make sure that */
+  /* their namespaces are reparented as well. */
+  child = reparented->children;
   while(NULL != child) {
     relink_namespace(child);
     child = child->next;
@@ -57,72 +76,88 @@ static void relink_namespace(xmlNodePtr reparented)
 }
 
 /* :nodoc: */
-static xmlNodePtr xmlReplaceNodeWrapper(xmlNodePtr old, xmlNodePtr cur)
+static xmlNodePtr xmlReplaceNodeWrapper(xmlNodePtr pivot, xmlNodePtr new_node)
 {
   xmlNodePtr retval ;
-  retval = xmlReplaceNode(old, cur) ;
-  if (retval == old) {
-    return cur ; // return semantics for reparent_node_with
+
+  retval = xmlReplaceNode(pivot, new_node) ;
+
+  if (retval == pivot) {
+    retval = new_node ; /* return semantics for reparent_node_with */
   }
+
+  /* work around libxml2 issue: https://bugzilla.gnome.org/show_bug.cgi?id=615612 */
+  if (retval->type == XML_TEXT_NODE) {
+    if (retval->prev && retval->prev->type == XML_TEXT_NODE) {
+      retval = xmlTextMerge(retval->prev, retval);
+    }
+    if (retval->next && retval->next->type == XML_TEXT_NODE) {
+      retval = xmlTextMerge(retval, retval->next);
+    }
+  }
+
   return retval ;
 }
 
 /* :nodoc: */
-static VALUE reparent_node_with(VALUE node_obj, VALUE other_obj, node_other_func func)
+static VALUE reparent_node_with(VALUE pivot_obj, VALUE reparentee_obj, pivot_reparentee_func prf)
 {
   VALUE reparented_obj ;
-  xmlNodePtr node, other, reparented ;
+  xmlNodePtr reparentee, pivot, reparented ;
 
-  if(!rb_obj_is_kind_of(node_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))
     rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node");
 
-  Data_Get_Struct(node_obj, xmlNode, node);
-  Data_Get_Struct(other_obj, xmlNode, other);
+  Data_Get_Struct(reparentee_obj, xmlNode, reparentee);
+  Data_Get_Struct(pivot_obj, xmlNode, pivot);
 
-  if(XML_DOCUMENT_NODE == node->type || XML_HTML_DOCUMENT_NODE == node->type)
+  if(XML_DOCUMENT_NODE == reparentee->type || XML_HTML_DOCUMENT_NODE == reparentee->type)
     rb_raise(rb_eArgError, "cannot reparent a document node");
 
-  if(node->type == XML_TEXT_NODE) {
-    NOKOGIRI_ROOT_NODE(node);
-    node = xmlDocCopyNode(node, other->doc, 1);
-  }
-
-  if (node->doc == other->doc) {
-    xmlUnlinkNode(node) ;
-
-    // TODO: I really want to remove this.  We shouldn't support 2.6.16 anymore
-    if ( node->type == XML_TEXT_NODE
-         && other->type == XML_TEXT_NODE
-         && is_2_6_16() ) {
-
-      // we'd rather leak than segfault.
-      other->content = xmlStrdup(other->content);
-
-    }
-
-    if(!(reparented = (*func)(other, node))) {
-      rb_raise(rb_eRuntimeError, "Could not reparent node (1)");
-    }
-  } else {
-    xmlNodePtr duped_node ;
-    // recursively copy to the new document
-    if (!(duped_node = xmlDocCopyNode(node, other->doc, 1))) {
+  xmlUnlinkNode(reparentee);
+
+  if (reparentee->doc != pivot->doc || reparentee->type == XML_TEXT_NODE) {
+    /*
+     *  if the reparentee is a text node, there's a very good chance it will be
+     *  merged with an adjacent text node after being reparented, and in that case
+     *  libxml will free the underlying C struct.
+     *
+     *  since we clearly have a ruby object which references the underlying
+     *  memory, we can't let the C struct get freed. let's pickle the original
+     *  reparentee by rooting it; and then we'll reparent a duplicate of the
+     *  node that we don't care about preserving.
+     *
+     *  alternatively, if the reparentee is from a different document than the
+     *  pivot node, libxml2 is going to get confused about which document's
+     *  "dictionary" the node's strings belong to (this is an otherwise
+     *  uninteresting libxml2 implementation detail). as a result, we cannot
+     *  reparent the actual reparentee, so we reparent a duplicate.
+     */
+    NOKOGIRI_ROOT_NODE(reparentee);
+    if (!(reparentee = xmlDocCopyNode(reparentee, pivot->doc, 1))) {
       rb_raise(rb_eRuntimeError, "Could not reparent node (xmlDocCopyNode)");
     }
-    if(!(reparented = (*func)(other, duped_node))) {
-      rb_raise(rb_eRuntimeError, "Could not reparent node (2)");
-    }
-    xmlUnlinkNode(node);
-    NOKOGIRI_ROOT_NODE(node);
   }
 
-  // the child was a text node that was coalesced. we need to have the object
-  // point at SOMETHING, or we'll totally bomb out.
-  if (reparented != node) {
-    DATA_PTR(node_obj) = reparented ;
+  /* TODO: I really want to remove this.  We shouldn't support 2.6.16 anymore */
+  if ( reparentee->type == XML_TEXT_NODE && pivot->type == XML_TEXT_NODE && is_2_6_16() ) {
+    /* work around a string-handling bug in libxml 2.6.16. we'd rather leak than segfault. */
+    pivot->content = xmlStrdup(pivot->content);
+  }
+
+  if(!(reparented = (*prf)(pivot, reparentee))) {
+    rb_raise(rb_eRuntimeError, "Could not reparent node");
   }
 
-  // Appropriately link in namespaces
+  /*
+   *  make sure the ruby object is pointed at the just-reparented node, which
+   *  might be a duplicate (see above) or might be the result of merging
+   *  adjacent text nodes.
+   */
+  DATA_PTR(reparentee_obj) = reparented ;
+
   relink_namespace(reparented);
 
   reparented_obj = Nokogiri_wrap_xml_node(Qnil, reparented);
@@ -169,13 +204,16 @@ static VALUE pointer_id(VALUE self)
 static VALUE encode_special_chars(VALUE self, VALUE string)
 {
   xmlNodePtr node;
+  xmlChar *encoded;
+  VALUE encoded_str;
+
   Data_Get_Struct(self, xmlNode, node);
-  xmlChar * encoded = xmlEncodeSpecialChars(
+  encoded = xmlEncodeSpecialChars(
       node->doc,
       (const xmlChar *)StringValuePtr(string)
   );
 
-  VALUE encoded_str = NOKOGIRI_STR_NEW2(encoded);
+  encoded_str = NOKOGIRI_STR_NEW2(encoded);
   xmlFree(encoded);
 
   return encoded_str;
@@ -191,6 +229,8 @@ static VALUE create_internal_subset(VALUE self, VALUE name, VALUE external_id, V
 {
   xmlNodePtr node;
   xmlDocPtr doc;
+  xmlDtdPtr dtd;
+
   Data_Get_Struct(self, xmlNode, node);
 
   doc = node->doc;
@@ -198,8 +238,8 @@ static VALUE create_internal_subset(VALUE self, VALUE name, VALUE external_id, V
   if(xmlGetIntSubset(doc))
     rb_raise(rb_eRuntimeError, "Document already has an internal subset");
 
-  xmlDtdPtr dtd = xmlCreateIntSubset(
-      doc, 
+  dtd = xmlCreateIntSubset(
+      doc,
       NIL_P(name)        ? NULL : (const xmlChar *)StringValuePtr(name),
       NIL_P(external_id) ? NULL : (const xmlChar *)StringValuePtr(external_id),
       NIL_P(system_id)   ? NULL : (const xmlChar *)StringValuePtr(system_id)
@@ -220,6 +260,8 @@ static VALUE create_external_subset(VALUE self, VALUE name, VALUE external_id, V
 {
   xmlNodePtr node;
   xmlDocPtr doc;
+  xmlDtdPtr dtd;
+
   Data_Get_Struct(self, xmlNode, node);
 
   doc = node->doc;
@@ -227,8 +269,8 @@ static VALUE create_external_subset(VALUE self, VALUE name, VALUE external_id, V
   if(doc->extSubset)
     rb_raise(rb_eRuntimeError, "Document already has an external subset");
 
-  xmlDtdPtr dtd = xmlNewDtd(
-      doc, 
+  dtd = xmlNewDtd(
+      doc,
       NIL_P(name)        ? NULL : (const xmlChar *)StringValuePtr(name),
       NIL_P(external_id) ? NULL : (const xmlChar *)StringValuePtr(external_id),
       NIL_P(system_id)   ? NULL : (const xmlChar *)StringValuePtr(system_id)
@@ -249,12 +291,14 @@ static VALUE external_subset(VALUE self)
 {
   xmlNodePtr node;
   xmlDocPtr doc;
+  xmlDtdPtr dtd;
+
   Data_Get_Struct(self, xmlNode, node);
 
   if(!node->doc) return Qnil;
 
   doc = node->doc;
-  xmlDtdPtr dtd = doc->extSubset;
+  dtd = doc->extSubset;
 
   if(!dtd) return Qnil;
 
@@ -271,12 +315,14 @@ static VALUE internal_subset(VALUE self)
 {
   xmlNodePtr node;
   xmlDocPtr doc;
+  xmlDtdPtr dtd;
+
   Data_Get_Struct(self, xmlNode, node);
 
   if(!node->doc) return Qnil;
 
   doc = node->doc;
-  xmlDtdPtr dtd = xmlGetIntSubset(doc);
+  dtd = xmlGetIntSubset(doc);
 
   if(!dtd) return Qnil;
 
@@ -293,11 +339,11 @@ static VALUE internal_subset(VALUE self)
 static VALUE duplicate_node(int argc, VALUE *argv, VALUE self)
 {
   VALUE level;
+  xmlNodePtr node, dup;
 
   if(rb_scan_args(argc, argv, "01", &level) == 0)
     level = INT2NUM((long)1);
 
-  xmlNodePtr node, dup;
   Data_Get_Struct(self, xmlNode, node);
 
   dup = xmlDocCopyNode(node, node->doc, (int)NUM2INT(level));
@@ -331,9 +377,7 @@ static VALUE blank_eh(VALUE self)
 {
   xmlNodePtr node;
   Data_Get_Struct(self, xmlNode, node);
-  if(1 == xmlIsBlankNode(node))
-    return Qtrue;
-  return Qfalse;
+  return (1 == xmlIsBlankNode(node)) ? Qtrue : Qfalse ;
 }
 
 /*
@@ -381,13 +425,10 @@ static VALUE next_element(VALUE self)
   xmlNodePtr node, sibling;
   Data_Get_Struct(self, xmlNode, node);
 
-  sibling = node->next;
+  sibling = xmlNextElementSibling(node);
   if(!sibling) return Qnil;
 
-  while(sibling && sibling->type != XML_ELEMENT_NODE)
-    sibling = sibling->next;
-
-  return sibling ? Nokogiri_wrap_xml_node(Qnil, sibling) : Qnil ;
+  return Nokogiri_wrap_xml_node(Qnil, sibling);
 }
 
 /*
@@ -401,6 +442,9 @@ static VALUE previous_element(VALUE self)
   xmlNodePtr node, sibling;
   Data_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;
 
@@ -411,10 +455,9 @@ static VALUE previous_element(VALUE self)
 }
 
 /* :nodoc: */
-static VALUE replace(VALUE self, VALUE _new_node)
+static VALUE replace(VALUE self, VALUE new_node)
 {
-  reparent_node_with(_new_node, self, xmlReplaceNodeWrapper) ;
-  return self ;
+  return reparent_node_with(self, new_node, xmlReplaceNodeWrapper) ;
 }
 
 /*
@@ -426,21 +469,66 @@ static VALUE replace(VALUE self, VALUE _new_node)
 static VALUE children(VALUE self)
 {
   xmlNodePtr node;
+  xmlNodePtr child;
+  xmlNodeSetPtr set;
+  VALUE document;
+  VALUE node_set;
+
   Data_Get_Struct(self, xmlNode, node);
 
-  xmlNodePtr child = node->children;
-  xmlNodeSetPtr set = xmlXPathNodeSetCreate(child);
+  child = node->children;
+  set = xmlXPathNodeSetCreate(child);
+
+  document = DOC_RUBY_OBJECT(node->doc);
 
-  if(!child) return Nokogiri_wrap_xml_node_set(set);
+  if(!child) return Nokogiri_wrap_xml_node_set(set, document);
 
   child = child->next;
   while(NULL != child) {
-    xmlXPathNodeSetAdd(set, child);
+    xmlXPathNodeSetAddUnique(set, child);
     child = child->next;
   }
 
-  VALUE node_set = Nokogiri_wrap_xml_node_set(set);
-  rb_iv_set(node_set, "@document", DOC_RUBY_OBJECT(node->doc));
+  node_set = Nokogiri_wrap_xml_node_set(set, document);
+
+  return node_set;
+}
+
+/*
+ * call-seq:
+ *  element_children
+ *
+ * Get the list of children for this node as a NodeSet.  All nodes will be
+ * element nodes.
+ *
+ * Example:
+ *
+ *   @doc.root.element_children.all? { |x| x.element? } # => true
+ */
+static VALUE element_children(VALUE self)
+{
+  xmlNodePtr node;
+  xmlNodePtr child;
+  xmlNodeSetPtr set;
+  VALUE document;
+  VALUE node_set;
+
+  Data_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);
 
   return node_set;
 }
@@ -462,6 +550,48 @@ static VALUE child(VALUE self)
   return Nokogiri_wrap_xml_node(Qnil, child);
 }
 
+/*
+ * call-seq:
+ *  first_element_child
+ *
+ * Returns the first child node of this node that is an element.
+ *
+ * Example:
+ *
+ *   @doc.root.first_element_child.element? # => true
+ */
+static VALUE first_element_child(VALUE self)
+{
+  xmlNodePtr node, child;
+  Data_Get_Struct(self, xmlNode, node);
+
+  child = xmlFirstElementChild(node);
+  if(!child) return Qnil;
+
+  return Nokogiri_wrap_xml_node(Qnil, child);
+}
+
+/*
+ * call-seq:
+ *  last_element_child
+ *
+ * Returns the last child node of this node that is an element.
+ *
+ * Example:
+ *
+ *   @doc.root.last_element_child.element? # => true
+ */
+static VALUE last_element_child(VALUE self)
+{
+  xmlNodePtr node, child;
+  Data_Get_Struct(self, xmlNode, node);
+
+  child = xmlLastElementChild(node);
+  if(!child) return Qnil;
+
+  return Nokogiri_wrap_xml_node(Qnil, child);
+}
+
 /*
  * call-seq:
  *  key?(attribute)
@@ -544,10 +674,12 @@ static VALUE get(VALUE self, VALUE attribute)
 static VALUE set_namespace(VALUE self, VALUE namespace)
 {
   xmlNodePtr node;
-  xmlNsPtr ns;
+  xmlNsPtr ns = NULL;
 
   Data_Get_Struct(self, xmlNode, node);
-  Data_Get_Struct(namespace, xmlNs, ns);
+
+  if(!NIL_P(namespace))
+    Data_Get_Struct(namespace, xmlNs, ns);
 
   xmlSetNs(node, ns);
 
@@ -599,10 +731,11 @@ static VALUE attribute_nodes(VALUE self)
 {
     /* this code in the mode of xmlHasProp() */
     xmlNodePtr node;
+    VALUE attr;
 
     Data_Get_Struct(self, xmlNode, node);
 
-    VALUE attr = rb_ary_new();
+    attr = rb_ary_new();
     Nokogiri_xml_node_properties(node, attr);
 
     return attr ;
@@ -636,12 +769,14 @@ static VALUE namespace_definitions(VALUE self)
 {
   /* this code in the mode of xmlHasProp() */
   xmlNodePtr node ;
+  VALUE list;
+  xmlNsPtr ns;
 
   Data_Get_Struct(self, xmlNode, node);
 
-  VALUE list = rb_ary_new();
+  list = rb_ary_new();
 
-  xmlNsPtr ns = node->nsDef;
+  ns = node->nsDef;
 
   if(!ns) return list;
 
@@ -653,6 +788,35 @@ static VALUE namespace_definitions(VALUE self)
   return list;
 }
 
+/*
+ *  call-seq:
+ *    namespace_scopes()
+ *
+ *  returns a list of Namespace nodes in scope for _self_. this is all
+ *  namespaces defined in the node, or in any ancestor node.
+ */
+static VALUE namespace_scopes(VALUE self)
+{
+  xmlNodePtr node ;
+  VALUE list;
+  xmlNsPtr *ns_list;
+  int j;
+
+  Data_Get_Struct(self, xmlNode, node);
+
+  list = rb_ary_new();
+  ns_list = xmlGetNsList(node->doc, node);
+
+  if(!ns_list) return list;
+
+  for (j = 0 ; ns_list[j] != NULL ; ++j) {
+    rb_ary_push(list, Nokogiri_wrap_xml_namespace(node->doc, ns_list[j]));
+  }
+
+  xmlFree(ns_list);
+  return list;
+}
+
 /*
  * call-seq:
  *  node_type
@@ -674,8 +838,17 @@ static VALUE node_type(VALUE self)
  */
 static VALUE set_content(VALUE self, VALUE content)
 {
-  xmlNodePtr node;
+  xmlNodePtr node, child, next ;
   Data_Get_Struct(self, xmlNode, node);
+
+  child = node->children;
+  while (NULL != child) {
+    next = child->next ;
+    xmlUnlinkNode(child) ;
+    NOKOGIRI_ROOT_NODE(child) ;
+    child = next ;
+  }
+
   xmlNodeSetContent(node, (xmlChar *)StringValuePtr(content));
   return content;
 }
@@ -689,9 +862,11 @@ static VALUE set_content(VALUE self, VALUE content)
 static VALUE get_content(VALUE self)
 {
   xmlNodePtr node;
+  xmlChar * content;
+
   Data_Get_Struct(self, xmlNode, node);
 
-  xmlChar * content = xmlNodeGetContent(node);
+  content = xmlNodeGetContent(node);
   if(content) {
     VALUE rval = NOKOGIRI_STR_NEW2(content);
     xmlFree(content);
@@ -701,9 +876,9 @@ static VALUE get_content(VALUE self)
 }
 
 /* :nodoc: */
-static VALUE add_child(VALUE self, VALUE child)
+static VALUE add_child(VALUE self, VALUE new_child)
 {
-  return reparent_node_with(child, self, xmlAddChild);
+  return reparent_node_with(self, new_child, xmlAddChild);
 }
 
 /*
@@ -762,24 +937,26 @@ static VALUE path(VALUE self)
 {
   xmlNodePtr node;
   xmlChar *path ;
+  VALUE rval;
+
   Data_Get_Struct(self, xmlNode, node);
-  
+
   path = xmlGetNodePath(node);
-  VALUE rval = NOKOGIRI_STR_NEW2(path);
+  rval = NOKOGIRI_STR_NEW2(path);
   xmlFree(path);
   return rval ;
 }
 
 /* :nodoc: */
-static VALUE add_next_sibling(VALUE self, VALUE rb_node)
+static VALUE add_next_sibling(VALUE self, VALUE new_sibling)
 {
-  return reparent_node_with(rb_node, self, xmlAddNextSibling) ;
+  return reparent_node_with(self, new_sibling, xmlAddNextSibling) ;
 }
 
 /* :nodoc: */
-static VALUE add_previous_sibling(VALUE self, VALUE rb_node)
+static VALUE add_previous_sibling(VALUE self, VALUE new_sibling)
 {
-  return reparent_node_with(rb_node, self, xmlAddPrevSibling) ;
+  return reparent_node_with(self, new_sibling, xmlAddPrevSibling) ;
 }
 
 /*
@@ -796,16 +973,18 @@ static VALUE native_write_to(
     VALUE options
 ) {
   xmlNodePtr node;
+  const char * before_indent;
+  xmlSaveCtxtPtr savectx;
 
   Data_Get_Struct(self, xmlNode, node);
 
   xmlIndentTreeOutput = 1;
 
-  const char * before_indent = xmlTreeIndentString;
+  before_indent = xmlTreeIndentString;
 
   xmlTreeIndentString = StringValuePtr(indent_string);
 
-  xmlSaveCtxtPtr savectx = xmlSaveToIO(
+  savectx = xmlSaveToIO(
       (xmlOutputWriteCallback)io_write_callback,
       (xmlOutputCloseCallback)io_close_callback,
       (void *)io,
@@ -843,10 +1022,11 @@ static VALUE line(VALUE self)
 static VALUE add_namespace_definition(VALUE self, VALUE prefix, VALUE href)
 {
   xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, node);
+  xmlNsPtr ns;
 
+  Data_Get_Struct(self, xmlNode, node);
 
-  xmlNsPtr ns = xmlNewNs(
+  ns = xmlNewNs(
       node,
       (const xmlChar *)StringValuePtr(href),
       (const xmlChar *)(NIL_P(prefix) ? NULL : StringValuePtr(prefix))
@@ -874,19 +1054,21 @@ static VALUE add_namespace_definition(VALUE self, VALUE prefix, VALUE href)
 static VALUE new(int argc, VALUE *argv, VALUE klass)
 {
   xmlDocPtr doc;
+  xmlNodePtr node;
   VALUE name;
   VALUE document;
   VALUE rest;
+  VALUE rb_node;
 
   rb_scan_args(argc, argv, "2*", &name, &document, &rest);
 
   Data_Get_Struct(document, xmlDoc, doc);
 
-  xmlNodePtr node = xmlNewNode(NULL, (xmlChar *)StringValuePtr(name));
+  node = xmlNewNode(NULL, (xmlChar *)StringValuePtr(name));
   node->doc = doc->doc;
   NOKOGIRI_ROOT_NODE(node);
 
-  VALUE rb_node = Nokogiri_wrap_xml_node(
+  rb_node = Nokogiri_wrap_xml_node(
       klass == cNokogiriXmlNode ? (VALUE)NULL : klass,
       node
   );
@@ -907,11 +1089,13 @@ static VALUE dump_html(VALUE self)
 {
   xmlBufferPtr buf ;
   xmlNodePtr node ;
+  VALUE html;
+
   Data_Get_Struct(self, xmlNode, node);
 
   buf = xmlBufferCreate() ;
   htmlNodeDump(buf, node->doc, node);
-  VALUE html = NOKOGIRI_STR_NEW2(buf->content);
+  html = NOKOGIRI_STR_NEW2(buf->content);
   xmlBufferFree(buf);
   return html ;
 }
@@ -931,14 +1115,64 @@ static VALUE compare(VALUE self, VALUE _other)
   return INT2NUM((long)xmlXPathCmpNodes(other, node));
 }
 
-VALUE Nokogiri_wrap_xml_node(VALUE klass, xmlNodePtr node)
+
+/* TODO: DOCUMENT ME */
+static VALUE in_context(VALUE self, VALUE _str, VALUE _options)
 {
-  assert(node);
+  xmlNodePtr node;
+  xmlNodePtr list;
+  xmlNodeSetPtr set;
+  VALUE doc, err;
+
+  Data_Get_Struct(self, xmlNode, node);
+
+  if(!node->parent)
+    rb_raise(rb_eRuntimeError, "no contextual parsing on unlinked nodes");
+
+  doc = DOC_RUBY_OBJECT(node->doc);
+  err = rb_iv_get(doc, "@errors");
 
+  xmlSetStructuredErrorFunc((void *)err, Nokogiri_error_array_pusher);
+
+  /* Twiddle global variable because of a bug in libxml2.
+   * http://git.gnome.org/browse/libxml2/commit/?id=e20fb5a72c83cbfc8e4a8aa3943c6be8febadab7
+   */
+#ifndef HTML_PARSE_NOIMPLIED
+  htmlHandleOmittedElem(0);
+#endif
+
+  xmlParseInNodeContext(
+      node,
+      StringValuePtr(_str),
+      (int)RSTRING_LEN(_str),
+      (int)NUM2INT(_options),
+      &list);
+
+#ifndef HTML_PARSE_NOIMPLIED
+  htmlHandleOmittedElem(1);
+#endif
+
+  xmlSetStructuredErrorFunc(NULL, NULL);
+
+  set = xmlXPathNodeSetCreate(NULL);
+
+  while(list) {
+    xmlXPathNodeSetAddUnique(set, list);
+    list = list->next;
+  }
+
+  return Nokogiri_wrap_xml_node_set(set, doc);
+}
+
+
+VALUE Nokogiri_wrap_xml_node(VALUE klass, xmlNodePtr node)
+{
   VALUE document = Qnil ;
   VALUE node_cache = Qnil ;
   VALUE rb_node = Qnil ;
 
+  assert(node);
+
   if(node->type == XML_DOCUMENT_NODE || node->type == XML_HTML_DOCUMENT_NODE)
       return DOC_RUBY_OBJECT(node->doc);
 
@@ -994,8 +1228,8 @@ VALUE Nokogiri_wrap_xml_node(VALUE klass, xmlNodePtr node)
   node->_private = (void *)rb_node;
 
   if (DOC_RUBY_OBJECT_TEST(node->doc) && DOC_RUBY_OBJECT(node->doc)) {
-    // it's OK if the document isn't fully realized (as in XML::Reader).
-    // see http://github.com/tenderlove/nokogiri/issues/closed/#issue/95
+    /* it's OK if the document isn't fully realized (as in XML::Reader). */
+    /* see http://github.com/tenderlove/nokogiri/issues/closed/#issue/95 */
     document = DOC_RUBY_OBJECT(node->doc);
     node_cache = DOC_NODE_CACHE(node->doc);
     rb_ary_push(node_cache, rb_node);
@@ -1037,7 +1271,10 @@ void init_xml_node()
   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);
@@ -1054,6 +1291,7 @@ void init_xml_node()
   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);
@@ -1064,6 +1302,7 @@ void init_xml_node()
   rb_define_method(klass, "pointer_id", pointer_id, 0);
   rb_define_method(klass, "line", line, 0);
 
+  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);