nokogiri 1.5.0 → 1.5.1.rc1

data/ext/nokogiri/xml_node_set.c

@@ -3,6 +3,69 @@
 
 static ID decorate ;
 
+static int dealloc_namespace(xmlNsPtr ns)
+{
+  if (ns->href)
+    xmlFree((xmlChar *)ns->href);
+  if (ns->prefix)
+    xmlFree((xmlChar *)ns->prefix);
+  xmlFree(ns);
+  return ST_CONTINUE;
+}
+
+static void deallocate(nokogiriNodeSetTuple *tuple)
+{
+  /*
+   *  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.
+   *
+   *  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().
+   *
+   *  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!
+   *
+   *  "In Valgrind We Trust." seriously.
+   */
+  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) ;
+}
+
+static VALUE allocate(VALUE klass)
+{
+  return Nokogiri_wrap_xml_node_set(xmlXPathNodeSetCreate(NULL), Qnil);
+}
+
+
 /*
  * call-seq:
  *  dup
@@ -11,12 +74,12 @@ static ID decorate ;
  */
 static VALUE duplicate(VALUE self)
 {
-  xmlNodeSetPtr node_set;
+  nokogiriNodeSetTuple *tuple;
   xmlNodeSetPtr dupl;
 
-  Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
 
-  dupl = xmlXPathNodeSetMerge(NULL, node_set);
+  dupl = xmlXPathNodeSetMerge(NULL, tuple->node_set);
 
   return Nokogiri_wrap_xml_node_set(dupl, rb_iv_get(self, "@document"));
 }
@@ -29,13 +92,10 @@ static VALUE duplicate(VALUE self)
  */
 static VALUE length(VALUE self)
 {
-  xmlNodeSetPtr node_set;
-  Data_Get_Struct(self, xmlNodeSet, node_set);
+  nokogiriNodeSetTuple *tuple;
+  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
 
-  if(node_set)
-    return INT2NUM(node_set->nodeNr);
-
-  return INT2NUM(0);
+  return tuple->node_set ? INT2NUM(tuple->node_set->nodeNr) : INT2NUM(0);
 }
 
 /*
@@ -46,15 +106,15 @@ static VALUE length(VALUE self)
  */
 static VALUE push(VALUE self, VALUE rb_node)
 {
-  xmlNodeSetPtr node_set;
+  nokogiriNodeSetTuple *tuple;
   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");
 
-  Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
   Data_Get_Struct(rb_node, xmlNode, node);
-  xmlXPathNodeSetAdd(node_set, node);
+  xmlXPathNodeSetAdd(tuple->node_set, node);
   return self;
 }
 
@@ -65,23 +125,32 @@ static VALUE push(VALUE self, VALUE rb_node)
  *  Delete +node+ from the Nodeset, if it is a member. Returns the deleted node
  *  if found, otherwise returns nil.
  */
-static VALUE delete(VALUE self, VALUE rb_node)
+static VALUE
+delete(VALUE self, VALUE rb_node)
 {
-  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");
-
-  Data_Get_Struct(self, xmlNodeSet, node_set);
-  Data_Get_Struct(rb_node, xmlNode, node);
-
-  if (xmlXPathNodeSetContains(node_set, node)) {
-    xmlXPathNodeSetDel(node_set, node);
-    return rb_node ;
-  }
-
-  return Qnil ;
+    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 ;
 }
 
 
@@ -93,16 +162,17 @@ static VALUE delete(VALUE self, VALUE rb_node)
  */
 static VALUE intersection(VALUE self, VALUE rb_other)
 {
-  xmlNodeSetPtr node_set;
-  xmlNodeSetPtr other;
+  nokogiriNodeSetTuple *tuple, *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, xmlNodeSet, node_set);
-  Data_Get_Struct(rb_other, xmlNodeSet, other);
+  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
+  Data_Get_Struct(rb_other, nokogiriNodeSetTuple, other);
 
-  return Nokogiri_wrap_xml_node_set(xmlXPathIntersection(node_set, other), rb_iv_get(self, "@document"));
+  intersection = xmlXPathIntersection(tuple->node_set, other->node_set);
+  return Nokogiri_wrap_xml_node_set(intersection, rb_iv_get(self, "@document"));
 }
 
 
@@ -114,16 +184,16 @@ static VALUE intersection(VALUE self, VALUE rb_other)
  */
 static VALUE include_eh(VALUE self, VALUE rb_node)
 {
-  xmlNodeSetPtr node_set;
+  nokogiriNodeSetTuple *tuple;
   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");
 
-  Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
   Data_Get_Struct(rb_node, xmlNode, node);
 
-  return (xmlXPathNodeSetContains(node_set, node) ? Qtrue : Qfalse);
+  return (xmlXPathNodeSetContains(tuple->node_set, node) ? Qtrue : Qfalse);
 }
 
 
@@ -136,18 +206,17 @@ static VALUE include_eh(VALUE self, VALUE rb_node)
  */
 static VALUE set_union(VALUE self, VALUE rb_other)
 {
-  xmlNodeSetPtr node_set;
-  xmlNodeSetPtr other;
+  nokogiriNodeSetTuple *tuple, *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, xmlNodeSet, node_set);
-  Data_Get_Struct(rb_other, xmlNodeSet, other);
+  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
+  Data_Get_Struct(rb_other, nokogiriNodeSetTuple, other);
 
-  new = xmlXPathNodeSetMerge(NULL, node_set);
-  new = xmlXPathNodeSetMerge(new, other);
+  new = xmlXPathNodeSetMerge(NULL, tuple->node_set);
+  new = xmlXPathNodeSetMerge(new, other->node_set);
 
   return Nokogiri_wrap_xml_node_set(new, rb_iv_get(self, "@document"));
 }
@@ -161,20 +230,19 @@ static VALUE set_union(VALUE self, VALUE rb_other)
  */
 static VALUE minus(VALUE self, VALUE rb_other)
 {
-  xmlNodeSetPtr node_set;
-  xmlNodeSetPtr other;
+  nokogiriNodeSetTuple *tuple, *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, xmlNodeSet, node_set);
-  Data_Get_Struct(rb_other, xmlNodeSet, other);
+  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
+  Data_Get_Struct(rb_other, nokogiriNodeSetTuple, other);
 
-  new = xmlXPathNodeSetMerge(NULL, node_set);
-  for (j = 0 ; j < other->nodeNr ; ++j) {
-    xmlXPathNodeSetDel(new, other->nodeTab[j]);
+  new = xmlXPathNodeSetMerge(NULL, tuple->node_set);
+  for (j = 0 ; j < other->node_set->nodeNr ; ++j) {
+    xmlXPathNodeSetDel(new, other->node_set->nodeTab[j]);
   }
 
   return Nokogiri_wrap_xml_node_set(new, rb_iv_get(self, "@document"));
@@ -184,10 +252,16 @@ static VALUE minus(VALUE self, VALUE rb_other)
 static VALUE index_at(VALUE self, long offset)
 {
   xmlNodeSetPtr node_set;
-  Data_Get_Struct(self, xmlNodeSet, node_set);
+  nokogiriNodeSetTuple *tuple;
+
+  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
+  node_set = tuple->node_set;
+
+  if (offset >= node_set->nodeNr || abs((int)offset) > node_set->nodeNr)
+    return Qnil;
 
-  if(offset >= node_set->nodeNr || abs((int)offset) > node_set->nodeNr) return Qnil;
-  if(offset < 0) offset = 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]));
@@ -197,10 +271,12 @@ static VALUE index_at(VALUE self, long offset)
 static VALUE subseq(VALUE self, long beg, long len)
 {
   long j;
+  nokogiriNodeSetTuple *tuple;
   xmlNodeSetPtr node_set;
   xmlNodeSetPtr new_set ;
 
-  Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
+  node_set = tuple->node_set;
 
   if (beg > node_set->nodeNr) return Qnil ;
   if (beg < 0 || len < 0) return Qnil ;
@@ -236,7 +312,9 @@ static VALUE slice(int argc, VALUE *argv, VALUE self)
   VALUE arg ;
   long beg, len ;
   xmlNodeSetPtr node_set;
-  Data_Get_Struct(self, xmlNodeSet, node_set);
+  nokogiriNodeSetTuple *tuple;
+  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
+  node_set = tuple->node_set;
 
   if (argc == 2) {
     beg = NUM2LONG(argv[0]);
@@ -282,25 +360,17 @@ static VALUE to_array(VALUE self, VALUE rb_node)
   VALUE *elts;
   VALUE list;
   int i;
+  nokogiriNodeSetTuple *tuple;
 
-  Data_Get_Struct(self, xmlNodeSet, set);
+  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
+  set = tuple->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) {
+    if (XML_NAMESPACE_DECL == set->nodeTab[i]->type)
       elts[i] = Nokogiri_wrap_xml_namespace2(rb_iv_get(self, "@document"), (xmlNsPtr)(set->nodeTab[i]));
-    } else {
-      xmlNodePtr node = set->nodeTab[i];
-
-      if(node->_private) {
-        if(node->type == XML_DOCUMENT_NODE || node->type == XML_HTML_DOCUMENT_NODE)
-          elts[i] = DOC_RUBY_OBJECT(node->doc);
-        else
-          elts[i] = (VALUE)node->_private;
-      } else {
-        elts[i] = Nokogiri_wrap_xml_node(Qnil, node);
-      }
-    }
+    else
+      elts[i] = Nokogiri_wrap_xml_node(Qnil, set->nodeTab[i]);
   }
 
   list = rb_ary_new4((long)set->nodeNr, elts);
@@ -320,8 +390,10 @@ static VALUE unlink_nodeset(VALUE self)
 {
   xmlNodeSetPtr node_set;
   int j, nodeNr ;
+  nokogiriNodeSetTuple *tuple;
 
-  Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(self, nokogiriNodeSetTuple, tuple);
+  node_set = tuple->node_set;
   nodeNr = node_set->nodeNr ;
   for (j = 0 ; j < nodeNr ; j++) {
     if (XML_NAMESPACE_DECL != node_set->nodeTab[j]->type) {
@@ -336,68 +408,45 @@ static VALUE unlink_nodeset(VALUE self)
   return self ;
 }
 
-
-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.
-   *
-   *  on the bright side, though, Nokogiri's API currently does not cause
-   *  namespace nodes to be included in node sets, ever.
-   *
-   *  armed with that fact, we examined xmlXPathFreeNodeSet() and related libxml
-   *  code and determined that, within the Nokogiri abstraction, we will not
-   *  leak memory if we simply free the node set's memory directly. that's only
-   *  quasi-evil!
-   *
-   *  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!
-   *
-   *  "In Valgrind We Trust." seriously.
-   */
-  NOKOGIRI_DEBUG_START(node_set) ;
-  if (node_set->nodeTab != NULL)
-    xmlFree(node_set->nodeTab);
-  xmlFree(node_set);
-  NOKOGIRI_DEBUG_END(node_set) ;
-}
-
-static VALUE allocate(VALUE klass)
-{
-  return Nokogiri_wrap_xml_node_set(xmlXPathNodeSetCreate(NULL), Qnil);
-}
-
 VALUE Nokogiri_wrap_xml_node_set(xmlNodeSetPtr node_set, VALUE document)
 {
   VALUE new_set ;
-  new_set = Data_Wrap_Struct(cNokogiriXmlNodeSet, 0, deallocate, node_set);
-  if (document != Qnil) {
+  int i;
+  xmlNodePtr cur;
+  xmlNsPtr ns;
+  nokogiriNodeSetTuple *tuple;
+
+  new_set = Data_Make_Struct(cNokogiriXmlNodeSet, nokogiriNodeSetTuple, 0,
+			     deallocate, tuple);
+
+  tuple->node_set = node_set;
+  tuple->namespaces = st_init_numtable();
+
+  if (!NIL_P(document)) {
     rb_iv_set(new_set, "@document", document);
     rb_funcall(document, decorate, 1, new_set);
   }
+
+  if (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);
+      }
+    }
+  }
+
   return new_set ;
 }
 
 VALUE cNokogiriXmlNodeSet ;
 void init_xml_node_set(void)
 {
-  VALUE nokogiri  = rb_define_module("Nokogiri");
-  VALUE xml       = rb_define_module_under(nokogiri, "XML");
-  VALUE klass     = rb_define_class_under(xml, "NodeSet", rb_cObject);
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml      = rb_define_module_under(nokogiri, "XML");
+  VALUE klass    = rb_define_class_under(xml, "NodeSet", rb_cObject);
   cNokogiriXmlNodeSet = klass;
 
   rb_define_alloc_func(klass, allocate);
@@ -414,5 +463,5 @@ void init_xml_node_set(void)
   rb_define_method(klass, "&", intersection, 1);
   rb_define_method(klass, "include?", include_eh, 1);
 
-  decorate      = rb_intern("decorate");
+  decorate = rb_intern("decorate");
 }

data/ext/nokogiri/xml_node_set.h

@@ -6,4 +6,9 @@ void init_xml_node_set();
 
 extern VALUE cNokogiriXmlNodeSet ;
 VALUE Nokogiri_wrap_xml_node_set(xmlNodeSetPtr node_set, VALUE document) ;
+
+typedef struct _nokogiriNodeSetTuple {
+  xmlNodeSetPtr node_set;
+  st_table     *namespaces;
+} nokogiriNodeSetTuple;
 #endif