nokogiri 1.6.7.2-java → 1.6.8-java

data/ext/nokogiri/xml_node.c

@@ -35,13 +35,13 @@ static void relink_namespace(xmlNodePtr reparented)
   xmlNsPtr ns;
 
   if (reparented->type != XML_ATTRIBUTE_NODE &&
-      reparented->type != XML_ELEMENT_NODE) return;
+      reparented->type != XML_ELEMENT_NODE) { return; }
 
   if (reparented->ns == NULL || reparented->ns->prefix == NULL) {
     name = xmlSplitQName2(reparented->name, &prefix);
 
     if(reparented->type == XML_ATTRIBUTE_NODE) {
-      if (prefix == NULL || strcmp((char*)prefix, XMLNS_PREFIX) == 0) return;
+      if (prefix == NULL || strcmp((char*)prefix, XMLNS_PREFIX) == 0) { return; }
     }
 
     ns = xmlSearchNs(reparented->doc, reparented, prefix);
@@ -57,18 +57,19 @@ static void relink_namespace(xmlNodePtr reparented)
   }
 
   /* Avoid segv when relinking against unlinked nodes. */
-  if (reparented->type != XML_ELEMENT_NODE || !reparented->parent) return;
+  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) {
     xmlSetNs(reparented, reparented->parent->ns);
+  }
 
   /* Search our parents for an existing definition */
-  if(reparented->nsDef) {
+  if (reparented->nsDef) {
     xmlNsPtr curr = reparented->nsDef;
     xmlNsPtr prev = NULL;
 
-    while(curr) {
+    while (curr) {
       xmlNsPtr ns = xmlSearchNsByHref(
           reparented->doc,
           reparented->parent,
@@ -76,7 +77,7 @@ static void relink_namespace(xmlNodePtr reparented)
       );
       /* If we find the namespace is already declared, remove it from this
        * definition list. */
-      if(ns && ns != curr) {
+      if (ns && ns != curr && xmlStrEqual(ns->prefix, curr->prefix)) {
         if (prev) {
           prev->next = curr->next;
         } else {
@@ -92,12 +93,12 @@ static void relink_namespace(xmlNodePtr reparented)
 
   /* Only walk all children if there actually is a namespace we need to */
   /* reparent. */
-  if(NULL == reparented->ns) return;
+  if (NULL == reparented->ns) { return; }
 
   /* 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) {
+  while (NULL != child) {
     relink_namespace(child);
     child = child->next;
   }
@@ -140,6 +141,7 @@ static VALUE reparent_node_with(VALUE pivot_obj, VALUE reparentee_obj, pivot_rep
 {
   VALUE reparented_obj ;
   xmlNodePtr 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))
     rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node");
@@ -233,18 +235,38 @@ ok:
      *  uninteresting libxml2 implementation detail). as a result, we cannot
      *  reparent the actual reparentee, so we reparent a duplicate.
      */
-    nokogiri_root_node(reparentee);
-
-    xmlResetLastError();
-    xmlSetStructuredErrorFunc((void *)rb_iv_get(DOC_RUBY_OBJECT(pivot->doc), "@errors"), Nokogiri_error_array_pusher);
+    if (reparentee->type == XML_TEXT_NODE && reparentee->_private) {
+      /*
+       *  additionally, since we know this C struct isn't going to be related to
+       *  a Ruby object anymore, let's break the relationship on this end as
+       *  well.
+       *
+       *  this is not absolutely necessary unless libxml-ruby is also in effect,
+       *  in which case its global callback `rxml_node_deregisterNode` will try
+       *  to do things to our data.
+       *
+       *  for more details on this particular (and particularly nasty) edge
+       *  case, see:
+       *
+       *    https://github.com/sparklemotion/nokogiri/issues/1426
+       */
+      reparentee->_private = NULL ;
+    }
 
-    reparentee = xmlDocCopyNode(reparentee, pivot->doc, 1) ;
+    if (reparentee->ns != NULL && reparentee->ns->prefix == NULL) {
+      original_ns_prefix_is_default = 1;
+    }
 
-    xmlSetStructuredErrorFunc(NULL, NULL);
+    nokogiri_root_node(reparentee);
 
-    if (! reparentee) {
+    if (!(reparentee = xmlDocCopyNode(reparentee, pivot->doc, 1))) {
       rb_raise(rb_eRuntimeError, "Could not reparent node (xmlDocCopyNode)");
     }
+
+    if (original_ns_prefix_is_default && reparentee->ns != NULL && reparentee->ns->prefix != NULL) {
+      /* issue #391, where new node's prefix may become the string "default" */
+      reparentee->ns->prefix = NULL;
+    }
   }
 
   if (prf != xmlAddPrevSibling && prf != xmlAddNextSibling
@@ -339,7 +361,7 @@ static VALUE encode_special_chars(VALUE self, VALUE string)
   Data_Get_Struct(self, xmlNode, node);
   encoded = xmlEncodeSpecialChars(
       node->doc,
-      (const xmlChar *)StringValuePtr(string)
+      (const xmlChar *)StringValueCStr(string)
   );
 
   encoded_str = NOKOGIRI_STR_NEW2(encoded);
@@ -375,9 +397,9 @@ static VALUE create_internal_subset(VALUE self, VALUE name, VALUE external_id, V
 
   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)
+      NIL_P(name)        ? NULL : (const xmlChar *)StringValueCStr(name),
+      NIL_P(external_id) ? NULL : (const xmlChar *)StringValueCStr(external_id),
+      NIL_P(system_id)   ? NULL : (const xmlChar *)StringValueCStr(system_id)
   );
 
   if(!dtd) return Qnil;
@@ -406,9 +428,9 @@ static VALUE create_external_subset(VALUE self, VALUE name, VALUE external_id, V
 
   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)
+      NIL_P(name)        ? NULL : (const xmlChar *)StringValueCStr(name),
+      NIL_P(external_id) ? NULL : (const xmlChar *)StringValueCStr(external_id),
+      NIL_P(system_id)   ? NULL : (const xmlChar *)StringValueCStr(system_id)
   );
 
   if(!dtd) return Qnil;
@@ -481,13 +503,7 @@ static VALUE duplicate_node(int argc, VALUE *argv, VALUE self)
 
   Data_Get_Struct(self, xmlNode, node);
 
-  xmlResetLastError();
-  xmlSetStructuredErrorFunc(NULL, Nokogiri_error_silencer);
-
   dup = xmlDocCopyNode(node, node->doc, (int)NUM2INT(level));
-
-  xmlSetStructuredErrorFunc(NULL, NULL);
-
   if(dup == NULL) return Qnil;
 
   nokogiri_root_node(dup);
@@ -751,7 +767,7 @@ static VALUE key_eh(VALUE self, VALUE attribute)
 {
   xmlNodePtr node;
   Data_Get_Struct(self, xmlNode, node);
-  if(xmlHasProp(node, (xmlChar *)StringValuePtr(attribute)))
+  if(xmlHasProp(node, (xmlChar *)StringValueCStr(attribute)))
     return Qtrue;
   return Qfalse;
 }
@@ -766,8 +782,8 @@ static VALUE namespaced_key_eh(VALUE self, VALUE attribute, VALUE namespace)
 {
   xmlNodePtr node;
   Data_Get_Struct(self, xmlNode, node);
-  if(xmlHasNsProp(node, (xmlChar *)StringValuePtr(attribute),
-        NIL_P(namespace) ? NULL : (xmlChar *)StringValuePtr(namespace)))
+  if(xmlHasNsProp(node, (xmlChar *)StringValueCStr(attribute),
+        NIL_P(namespace) ? NULL : (xmlChar *)StringValueCStr(namespace)))
     return Qtrue;
   return Qfalse;
 }
@@ -778,19 +794,11 @@ static VALUE namespaced_key_eh(VALUE self, VALUE attribute, VALUE namespace)
  *
  * Set the +property+ to +value+
  */
-static VALUE set(VALUE node_rb, VALUE property_name_rb, VALUE property_value_rb)
+static VALUE set(VALUE self, VALUE property, VALUE value)
 {
   xmlNodePtr node, cur;
-  xmlChar*   property_name ;
-  xmlAttrPtr property;
-
-  Data_Get_Struct(node_rb, xmlNode, node);
-
-  if (node->type != XML_ELEMENT_NODE) {
-    return(Qnil); // TODO: would raising an exception be more appropriate?
-  }
-
-  property_name = (xmlChar *)StringValuePtr(property_name_rb);
+  xmlAttrPtr prop;
+  Data_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
@@ -798,9 +806,11 @@ static VALUE set(VALUE node_rb, VALUE property_name_rb, VALUE property_value_rb)
    *
    * We can avoid this by unlinking these nodes first.
    */
-  property = xmlHasProp(node, property_name);
-  if (property && property->children) {
-    for (cur = property->children; cur; cur = cur->next) {
+  if (node->type != XML_ELEMENT_NODE)
+    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);
         xmlUnlinkNode(cur);
@@ -808,14 +818,10 @@ static VALUE set(VALUE node_rb, VALUE property_name_rb, VALUE property_value_rb)
     }
   }
 
-  xmlResetLastError();
-  xmlSetStructuredErrorFunc(NULL, Nokogiri_error_silencer);
-
-  xmlSetProp(node, property_name, (xmlChar *)StringValuePtr(property_value_rb));
-
-  xmlSetStructuredErrorFunc(NULL, NULL);
+  xmlSetProp(node, (xmlChar *)StringValueCStr(property),
+      (xmlChar *)StringValueCStr(value));
 
-  return property_value_rb;
+  return value;
 }
 
 /*
@@ -836,7 +842,7 @@ static VALUE get(VALUE self, VALUE rattribute)
   if (NIL_P(rattribute)) return Qnil;
 
   Data_Get_Struct(self, xmlNode, node);
-  attribute = strdup(StringValuePtr(rattribute));
+  attribute = strdup(StringValueCStr(rattribute));
 
   colon = strchr(attribute, ':');
   if (colon) {
@@ -847,7 +853,7 @@ static VALUE get(VALUE self, VALUE rattribute)
     if (ns) {
       value = xmlGetNsProp(node, (xmlChar*)(attr_name), ns->href);
     } else {
-      value = xmlGetProp(node, (xmlChar*)StringValuePtr(rattribute));
+      value = xmlGetProp(node, (xmlChar*)StringValueCStr(rattribute));
     }
   } else {
     value = xmlGetNoNsProp(node, (xmlChar*)attribute);
@@ -894,7 +900,7 @@ static VALUE attr(VALUE self, VALUE name)
   xmlNodePtr node;
   xmlAttrPtr prop;
   Data_Get_Struct(self, xmlNode, node);
-  prop = xmlHasProp(node, (xmlChar *)StringValuePtr(name));
+  prop = xmlHasProp(node, (xmlChar *)StringValueCStr(name));
 
   if(! prop) return Qnil;
   return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)prop);
@@ -911,8 +917,8 @@ 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 *)StringValuePtr(name),
-      NIL_P(namespace) ? NULL : (xmlChar *)StringValuePtr(namespace));
+  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);
@@ -1049,7 +1055,7 @@ static VALUE set_native_content(VALUE self, VALUE content)
     child = next ;
   }
 
-  xmlNodeSetContent(node, (xmlChar *)StringValuePtr(content));
+  xmlNodeSetContent(node, (xmlChar *)StringValueCStr(content));
   return content;
 }
 
@@ -1087,7 +1093,7 @@ static VALUE set_lang(VALUE self_rb, VALUE lang_rb)
   xmlChar* lang ;
 
   Data_Get_Struct(self_rb, xmlNode, self);
-  lang = (xmlChar*)StringValuePtr(lang_rb);
+  lang = (xmlChar*)StringValueCStr(lang_rb);
 
   xmlNodeSetLang(self, lang);
 
@@ -1152,7 +1158,7 @@ static VALUE set_name(VALUE self, VALUE new_name)
 {
   xmlNodePtr node;
   Data_Get_Struct(self, xmlNode, node);
-  xmlNodeSetName(node, (xmlChar*)StringValuePtr(new_name));
+  xmlNodeSetName(node, (xmlChar*)StringValueCStr(new_name));
   return new_name;
 }
 
@@ -1226,13 +1232,13 @@ static VALUE native_write_to(
 
   before_indent = xmlTreeIndentString;
 
-  xmlTreeIndentString = StringValuePtr(indent_string);
+  xmlTreeIndentString = StringValueCStr(indent_string);
 
   savectx = xmlSaveToIO(
       (xmlOutputWriteCallback)io_write_callback,
       (xmlOutputCloseCallback)io_close_callback,
       (void *)io,
-      RTEST(encoding) ? StringValuePtr(encoding) : NULL,
+      RTEST(encoding) ? StringValueCStr(encoding) : NULL,
       (int)NUM2INT(options)
   );
 
@@ -1279,7 +1285,7 @@ static VALUE add_namespace_definition(VALUE self, VALUE prefix, VALUE href)
   ns = xmlSearchNs(
       node->doc,
       node,
-      (const xmlChar *)(NIL_P(prefix) ? NULL : StringValuePtr(prefix))
+      (const xmlChar *)(NIL_P(prefix) ? NULL : StringValueCStr(prefix))
   );
 
   if(!ns) {
@@ -1288,8 +1294,8 @@ static VALUE add_namespace_definition(VALUE self, VALUE prefix, VALUE href)
     }
     ns = xmlNewNs(
         namespacee,
-        (const xmlChar *)StringValuePtr(href),
-        (const xmlChar *)(NIL_P(prefix) ? NULL : StringValuePtr(prefix))
+        (const xmlChar *)StringValueCStr(href),
+        (const xmlChar *)(NIL_P(prefix) ? NULL : StringValueCStr(prefix))
     );
   }
 
@@ -1319,7 +1325,7 @@ static VALUE new(int argc, VALUE *argv, VALUE klass)
 
   Data_Get_Struct(document, xmlDoc, doc);
 
-  node = xmlNewNode(NULL, (xmlChar *)StringValuePtr(name));
+  node = xmlNewNode(NULL, (xmlChar *)StringValueCStr(name));
   node->doc = doc->doc;
   nokogiri_root_node(node);
 

data/ext/nokogiri/xml_node_set.c

@@ -1,62 +1,42 @@
 #include <xml_node_set.h>
+#include <xml_namespace.h>
 #include <libxml/xpathInternals.h>
 
 static ID decorate ;
+static void xpath_node_set_del(xmlNodeSetPtr cur, xmlNodePtr val);
 
-static int dealloc_namespace(xmlNsPtr ns)
+
+static void Check_Node_Set_Node_Type(VALUE node)
 {
-  if (ns->href)
-    xmlFree((xmlChar *)ns->href);
-  if (ns->prefix)
-    xmlFree((xmlChar *)ns->prefix);
-  xmlFree(ns);
-  return ST_CONTINUE;
+  if (!(rb_obj_is_kind_of(node, cNokogiriXmlNode) ||
+        rb_obj_is_kind_of(node, cNokogiriXmlNamespace))) {
+    rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");
+  }
 }
 
-static void deallocate(nokogiriNodeSetTuple *tuple)
+
+static void deallocate(xmlNodeSetPtr node_set)
 {
   /*
-   *  xmlXPathFreeNodeSet() contains an implicit assumption that it is being
-   *  called before any of its pointed-to nodes have been free()d. this
-   *  assumption lies in the operation where it dereferences nodeTab pointers
-   *  while searching for namespace nodes to free.
-   *
-   *  however, since Ruby's GC mechanism cannot guarantee the strict order in
-   *  which ruby objects will be GC'd, nodes may be garbage collected before a
-   *  nodeset containing pointers to those nodes. (this is true regardless of
-   *  how we declare dependencies between objects with rb_gc_mark().)
    *
-   *  as a result, xmlXPathFreeNodeSet() will perform unsafe memory operations,
-   *  and calling it would be evil.
+   *  since xpath queries return copies of the xmlNs structs,
+   *  xmlXPathFreeNodeSet() frees those xmlNs structs that are in the
+   *  NodeSet.
    *
-   *  so here, we *manually* free the set of namespace nodes that was
-   *  constructed at initialization time (see Nokogiri_wrap_xml_node_set()), as
-   *  well as the NodeSet, without using the official xmlXPathFreeNodeSet().
+   *  this is bad if someone is still trying to use the Namespace object wrapped
+   *  around the xmlNs, so we need to avoid that.
    *
-   *  there's probably a lesson in here somewhere about intermingling, within a
-   *  single array, structs with different memory-ownership semantics. or more
-   *  generally, a lesson about building an API in C/C++ that does not contain
-   *  assumptions about the strict order in which memory will be released. hey,
-   *  that sounds like a great idea for a blog post! get to it!
+   *  here we reproduce xmlXPathFreeNodeSet() without the xmlNs logic.
    *
-   *  "In Valgrind We Trust." seriously.
+   *  this doesn't cause a leak because Namespace objects that are in an XPath
+   *  query NodeSet are given their own lifecycle in
+   *  Nokogiri_wrap_xml_namespace().
    */
-  xmlNodeSetPtr node_set;
-
-  node_set = tuple->node_set;
-
-  if (!node_set)
-    return;
-
   NOKOGIRI_DEBUG_START(node_set) ;
-  st_foreach(tuple->namespaces, dealloc_namespace, 0);
-
   if (node_set->nodeTab != NULL)
     xmlFree(node_set->nodeTab);
 
   xmlFree(node_set);
-  st_free_table(tuple->namespaces);
-  free(tuple);
   NOKOGIRI_DEBUG_END(node_set) ;
 }
 
@@ -74,12 +54,12 @@ static VALUE allocate(VALUE klass)
  */
 static VALUE duplicate(VALUE self)
 {
-  nokogiriNodeSetTuple *tuple;
+  xmlNodeSetPtr node_set;
   xmlNodeSetPtr dupl;
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
+  Data_Get_Struct(self, xmlNodeSet, node_set);
 
-  dupl = xmlXPathNodeSetMerge(NULL, tuple->node_set);
+  dupl = xmlXPathNodeSetMerge(NULL, node_set);
 
   return Nokogiri_wrap_xml_node_set(dupl, rb_iv_get(self, "@document"));
 }
@@ -92,10 +72,11 @@ static VALUE duplicate(VALUE self)
  */
 static VALUE length(VALUE self)
 {
-  nokogiriNodeSetTuple *tuple;
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
+  xmlNodeSetPtr node_set;
 
-  return tuple->node_set ? INT2NUM(tuple->node_set->nodeNr) : INT2NUM(0);
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+
+  return node_set ? INT2NUM(node_set->nodeNr) : INT2NUM(0);
 }
 
 /*
@@ -106,15 +87,16 @@ static VALUE length(VALUE self)
  */
 static VALUE push(VALUE self, VALUE rb_node)
 {
-  nokogiriNodeSetTuple *tuple;
+  xmlNodeSetPtr node_set;
   xmlNodePtr node;
 
-  if(!(rb_obj_is_kind_of(rb_node, cNokogiriXmlNode) || rb_obj_is_kind_of(rb_node, cNokogiriXmlNamespace)))
-    rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");
+  Check_Node_Set_Node_Type(rb_node);
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
+  Data_Get_Struct(self, xmlNodeSet, node_set);
   Data_Get_Struct(rb_node, xmlNode, node);
-  xmlXPathNodeSetAdd(tuple->node_set, node);
+
+  xmlXPathNodeSetAdd(node_set, node);
+
   return self;
 }
 
@@ -128,29 +110,19 @@ static VALUE push(VALUE self, VALUE rb_node)
 static VALUE
 delete(VALUE self, VALUE rb_node)
 {
-    nokogiriNodeSetTuple *tuple;
-    xmlNodePtr node;
-    xmlNodeSetPtr cur;
-    int i;
-
-    if (!(rb_obj_is_kind_of(rb_node, cNokogiriXmlNode) || rb_obj_is_kind_of(rb_node, cNokogiriXmlNamespace)))
-	rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");
-
-    Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-    Data_Get_Struct(rb_node, xmlNode, node);
-    cur = tuple->node_set;
-
-    if (xmlXPathNodeSetContains(cur, node)) {
-	for (i = 0; i < cur->nodeNr; i++)
-	    if (cur->nodeTab[i] == node) break;
-
-	cur->nodeNr--;
-	for (;i < cur->nodeNr;i++)
-	    cur->nodeTab[i] = cur->nodeTab[i + 1];
-	cur->nodeTab[cur->nodeNr] = NULL;
-	return rb_node;
-    }
-    return Qnil ;
+  xmlNodeSetPtr node_set;
+  xmlNodePtr node;
+
+  Check_Node_Set_Node_Type(rb_node);
+
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(rb_node, xmlNode, node);
+
+  if (xmlXPathNodeSetContains(node_set, node)) {
+    xpath_node_set_del(node_set, node);
+    return rb_node;
+  }
+  return Qnil ;
 }
 
 
@@ -162,16 +134,16 @@ delete(VALUE self, VALUE rb_node)
  */
 static VALUE intersection(VALUE self, VALUE rb_other)
 {
-  nokogiriNodeSetTuple *tuple, *other;
+  xmlNodeSetPtr node_set, other ;
   xmlNodeSetPtr intersection;
 
   if(!rb_obj_is_kind_of(rb_other, cNokogiriXmlNodeSet))
     rb_raise(rb_eArgError, "node_set must be a Nokogiri::XML::NodeSet");
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-  Data_Get_Struct(rb_other, nokogiriNodeSetTuple, other);
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(rb_other, xmlNodeSet, other);
 
-  intersection = xmlXPathIntersection(tuple->node_set, other->node_set);
+  intersection = xmlXPathIntersection(node_set, other);
   return Nokogiri_wrap_xml_node_set(intersection, rb_iv_get(self, "@document"));
 }
 
@@ -184,16 +156,15 @@ static VALUE intersection(VALUE self, VALUE rb_other)
  */
 static VALUE include_eh(VALUE self, VALUE rb_node)
 {
-  nokogiriNodeSetTuple *tuple;
+  xmlNodeSetPtr node_set;
   xmlNodePtr node;
 
-  if(!(rb_obj_is_kind_of(rb_node, cNokogiriXmlNode) || rb_obj_is_kind_of(rb_node, cNokogiriXmlNamespace)))
-    rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");
+  Check_Node_Set_Node_Type(rb_node);
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
+  Data_Get_Struct(self, xmlNodeSet, node_set);
   Data_Get_Struct(rb_node, xmlNode, node);
 
-  return (xmlXPathNodeSetContains(tuple->node_set, node) ? Qtrue : Qfalse);
+  return (xmlXPathNodeSetContains(node_set, node) ? Qtrue : Qfalse);
 }
 
 
@@ -206,17 +177,17 @@ static VALUE include_eh(VALUE self, VALUE rb_node)
  */
 static VALUE set_union(VALUE self, VALUE rb_other)
 {
-  nokogiriNodeSetTuple *tuple, *other;
+  xmlNodeSetPtr node_set, other;
   xmlNodeSetPtr new;
 
   if(!rb_obj_is_kind_of(rb_other, cNokogiriXmlNodeSet))
     rb_raise(rb_eArgError, "node_set must be a Nokogiri::XML::NodeSet");
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-  Data_Get_Struct(rb_other, nokogiriNodeSetTuple, other);
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(rb_other, xmlNodeSet, other);
 
-  new = xmlXPathNodeSetMerge(NULL, tuple->node_set);
-  new = xmlXPathNodeSetMerge(new, other->node_set);
+  new = xmlXPathNodeSetMerge(NULL, node_set);
+  new = xmlXPathNodeSetMerge(new, other);
 
   return Nokogiri_wrap_xml_node_set(new, rb_iv_get(self, "@document"));
 }
@@ -230,19 +201,19 @@ static VALUE set_union(VALUE self, VALUE rb_other)
  */
 static VALUE minus(VALUE self, VALUE rb_other)
 {
-  nokogiriNodeSetTuple *tuple, *other;
+  xmlNodeSetPtr node_set, other;
   xmlNodeSetPtr new;
   int j ;
 
   if(!rb_obj_is_kind_of(rb_other, cNokogiriXmlNodeSet))
     rb_raise(rb_eArgError, "node_set must be a Nokogiri::XML::NodeSet");
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-  Data_Get_Struct(rb_other, nokogiriNodeSetTuple, other);
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(rb_other, xmlNodeSet, other);
 
-  new = xmlXPathNodeSetMerge(NULL, tuple->node_set);
-  for (j = 0 ; j < other->node_set->nodeNr ; ++j) {
-    xmlXPathNodeSetDel(new, other->node_set->nodeTab[j]);
+  new = xmlXPathNodeSetMerge(NULL, node_set);
+  for (j = 0 ; j < other->nodeNr ; ++j) {
+    xpath_node_set_del(new, other->nodeTab[j]);
   }
 
   return Nokogiri_wrap_xml_node_set(new, rb_iv_get(self, "@document"));
@@ -252,31 +223,25 @@ static VALUE minus(VALUE self, VALUE rb_other)
 static VALUE index_at(VALUE self, long offset)
 {
   xmlNodeSetPtr node_set;
-  nokogiriNodeSetTuple *tuple;
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-  node_set = tuple->node_set;
+  Data_Get_Struct(self, xmlNodeSet, node_set);
 
-  if (offset >= node_set->nodeNr || abs((int)offset) > node_set->nodeNr)
+  if (offset >= node_set->nodeNr || abs((int)offset) > node_set->nodeNr) {
     return Qnil;
+  }
 
-  if (offset < 0)
-    offset += node_set->nodeNr;
+  if (offset < 0) { offset += node_set->nodeNr ; }
 
-  if (XML_NAMESPACE_DECL == node_set->nodeTab[offset]->type)
-    return Nokogiri_wrap_xml_namespace2(rb_iv_get(self, "@document"), (xmlNsPtr)(node_set->nodeTab[offset]));
-  return Nokogiri_wrap_xml_node(Qnil, node_set->nodeTab[offset]);
+  return Nokogiri_wrap_xml_node_set_node(node_set->nodeTab[offset], self);
 }
 
 static VALUE subseq(VALUE self, long beg, long len)
 {
   long j;
-  nokogiriNodeSetTuple *tuple;
   xmlNodeSetPtr node_set;
   xmlNodeSetPtr new_set ;
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-  node_set = tuple->node_set;
+  Data_Get_Struct(self, xmlNodeSet, node_set);
 
   if (beg > node_set->nodeNr) return Qnil ;
   if (beg < 0 || len < 0) return Qnil ;
@@ -312,9 +277,8 @@ static VALUE slice(int argc, VALUE *argv, VALUE self)
   VALUE arg ;
   long beg, len ;
   xmlNodeSetPtr node_set;
-  nokogiriNodeSetTuple *tuple;
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-  node_set = tuple->node_set;
+
+  Data_Get_Struct(self, xmlNodeSet, node_set);
 
   if (argc == 2) {
     beg = NUM2LONG(argv[0]);
@@ -333,7 +297,7 @@ static VALUE slice(int argc, VALUE *argv, VALUE self)
   if (FIXNUM_P(arg)) {
     return index_at(self, FIX2LONG(arg));
   }
-  
+
   /* if arg is Range */
   switch (rb_range_beg_len(arg, &beg, &len, (long)node_set->nodeNr, 0)) {
   case Qfalse:
@@ -356,27 +320,18 @@ static VALUE slice(int argc, VALUE *argv, VALUE self)
  */
 static VALUE to_array(VALUE self, VALUE rb_node)
 {
-  xmlNodeSetPtr set;
-  VALUE *elts;
+  xmlNodeSetPtr node_set ;
   VALUE list;
   int i;
-  nokogiriNodeSetTuple *tuple;
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-  set = tuple->node_set;
+  Data_Get_Struct(self, xmlNodeSet, node_set);
 
-  elts = calloc((size_t)set->nodeNr, sizeof(VALUE *));
-  for(i = 0; i < set->nodeNr; i++) {
-    if (XML_NAMESPACE_DECL == set->nodeTab[i]->type)
-      elts[i] = Nokogiri_wrap_xml_namespace2(rb_iv_get(self, "@document"), (xmlNsPtr)(set->nodeTab[i]));
-    else
-      elts[i] = Nokogiri_wrap_xml_node(Qnil, set->nodeTab[i]);
+  list = rb_ary_new2(node_set->nodeNr);
+  for(i = 0; i < node_set->nodeNr; i++) {
+    VALUE elt = Nokogiri_wrap_xml_node_set_node(node_set->nodeTab[i], self);
+    rb_ary_push( list, elt );
   }
 
-  list = rb_ary_new4((long)set->nodeNr, elts);
-
-  /*free(elts); */
-
   return list;
 }
 
@@ -390,13 +345,12 @@ static VALUE unlink_nodeset(VALUE self)
 {
   xmlNodeSetPtr node_set;
   int j, nodeNr ;
-  nokogiriNodeSetTuple *tuple;
 
-  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
-  node_set = tuple->node_set;
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+
   nodeNr = node_set->nodeNr ;
   for (j = 0 ; j < nodeNr ; j++) {
-    if (XML_NAMESPACE_DECL != node_set->nodeTab[j]->type) {
+    if (! Nokogiri_namespace_eh(node_set->nodeTab[j])) {
       VALUE node ;
       xmlNodePtr node_ptr;
       node = Nokogiri_wrap_xml_node(Qnil, node_set->nodeTab[j]);
@@ -408,39 +362,103 @@ static VALUE unlink_nodeset(VALUE self)
   return self ;
 }
 
+
+static void reify_node_set_namespaces(VALUE self)
+{
+  /*
+   *  as mentioned in deallocate() above, xmlNs structs returned in an XPath
+   *  NodeSet are duplicates, and we don't clean them up at deallocate() time.
+   *
+   *  as a result, we need to make sure the Ruby manages this memory. we do this
+   *  by forcing the creation of a Ruby object wrapped around the xmlNs.
+   *
+   *  we also have to make sure that the NodeSet has a reference to the
+   *  Namespace object, otherwise GC will kick in and the Namespace won't be
+   *  marked.
+   *
+   *  we *could* do this safely with *all* the nodes in the NodeSet, but we only
+   *  *need* to do it for xmlNs structs, and so you get the code we have here.
+   */
+  int j ;
+  xmlNodeSetPtr node_set ;
+  VALUE namespace_cache ;
+
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+
+  namespace_cache = rb_iv_get(self, "@namespace_cache");
+
+  for (j = 0 ; j < node_set->nodeNr ; j++) {
+    if (Nokogiri_namespace_eh(node_set->nodeTab[j])) {
+      rb_ary_push(namespace_cache, Nokogiri_wrap_xml_node_set_node(node_set->nodeTab[j], self));
+    }
+  }
+}
+
+
 VALUE Nokogiri_wrap_xml_node_set(xmlNodeSetPtr node_set, VALUE document)
 {
   VALUE new_set ;
-  int i;
-  xmlNodePtr cur;
-  xmlNsPtr ns;
-  nokogiriNodeSetTuple *tuple;
 
-  new_set = Data_Make_Struct(cNokogiriXmlNodeSet, nokogiriNodeSetTuple, 0,
-			     deallocate, tuple);
+  if (node_set == NULL) {
+    node_set = xmlXPathNodeSetCreate(NULL);
+  }
 
-  tuple->node_set = node_set;
-  tuple->namespaces = st_init_numtable();
+  new_set = Data_Wrap_Struct(cNokogiriXmlNodeSet, 0, deallocate, node_set);
 
   if (!NIL_P(document)) {
     rb_iv_set(new_set, "@document", document);
     rb_funcall(document, decorate, 1, new_set);
   }
 
-  if (node_set && node_set->nodeTab) {
-    for (i = 0; i < node_set->nodeNr; i++) {
-      cur = node_set->nodeTab[i];
-      if (cur && cur->type == XML_NAMESPACE_DECL) {
-        ns = (xmlNsPtr)cur;
-        if (ns->next && ns->next->type != XML_NAMESPACE_DECL)
-          st_insert(tuple->namespaces, (st_data_t)cur, (st_data_t)0);
-      }
-    }
-  }
+  rb_iv_set(new_set, "@namespace_cache", rb_ary_new());
+  reify_node_set_namespaces(new_set);
 
   return new_set ;
 }
 
+VALUE Nokogiri_wrap_xml_node_set_node(xmlNodePtr node, VALUE node_set)
+{
+  xmlDocPtr document ;
+
+  if (Nokogiri_namespace_eh(node)) {
+    Data_Get_Struct(rb_iv_get(node_set, "@document"), xmlDoc, document);
+    return Nokogiri_wrap_xml_namespace(document, (xmlNsPtr)node);
+  } else {
+    return Nokogiri_wrap_xml_node(Qnil, node);
+  }
+}
+
+
+static void xpath_node_set_del(xmlNodeSetPtr cur, xmlNodePtr val)
+{
+  /*
+   * as mentioned a few times above, we do not want to free xmlNs structs
+   * outside of the Namespace lifecycle.
+   *
+   * xmlXPathNodeSetDel() frees xmlNs structs, and so here we reproduce that
+   * function with the xmlNs logic.
+   */
+  int i;
+
+  if (cur == NULL) return;
+  if (val == NULL) return;
+
+  /*
+   * find node in nodeTab
+   */
+  for (i = 0;i < cur->nodeNr;i++)
+    if (cur->nodeTab[i] == val) break;
+
+  if (i >= cur->nodeNr) {	/* not found */
+    return;
+  }
+  cur->nodeNr--;
+  for (;i < cur->nodeNr;i++)
+    cur->nodeTab[i] = cur->nodeTab[i + 1];
+  cur->nodeTab[cur->nodeNr] = NULL;
+}
+
+
 VALUE cNokogiriXmlNodeSet ;
 void init_xml_node_set(void)
 {