libxml-ruby 2.9.0 → 3.0.0

data/ext/libxml/ruby_xml_namespaces.h

@@ -1,9 +1,9 @@
-/* Please see the LICENSE file for copyright and distribution information */
-
-#ifndef __RXML_NAMESPACES__
-#define __RXML_NAMESPACES__
-
-extern VALUE cXMLNamespaces;
-
-void rxml_init_namespaces(void);
-#endif
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_NAMESPACES__
+#define __RXML_NAMESPACES__
+
+extern VALUE cXMLNamespaces;
+
+void rxml_init_namespaces(void);
+#endif

data/ext/libxml/ruby_xml_node.c

@@ -17,89 +17,103 @@ VALUE cXMLNode;
 
 /* Memory management:
  *
- * The bindings create a one-to-one mapping between libxml nodes
- * and Ruby nodes.  If a libxml node is wrapped, the mapping is stored in the
- * private_pointers hashtable.
- *
- * When a libxml document or top level node is freed, it will free
- * all its children.  Thus Ruby is responsible for:
- *
- *  * Using the mark function to keep alive any documents Ruby is
- *    referencing via the document or child nodes.
- *  * Using the mark function to keep alive any top level, free
- *    standing nodes Ruby is referencing via the node or its children.
- *
- * In general use, this will cause Ruby nodes to be freed before
- * a libxml document.  When a Ruby node is freed, the hashtable entry is
- * removed.
- *
- * In the sweep phase in Ruby 1.9.*, the document tends to be
- * freed before the nodes.  To support this, the bindings register
- * a callback function with libxml that is called each time a node
- * is freed.  In that case, the data_ptr is set to null, so the bindings
- * can recognize the situation.
+ * The bindings create a one-to-one mapping between ruby objects and
+ * libxml documents and libxml parent nodes (ie, nodes that do not
+ * have a parent and do not belong to a document). In these cases,
+ * the bindings manage the memory.  They do this by installing a free
+ * function and storing a back pointer to the Ruby object from the xmlnode
+ * using the _private member on libxml structures.  When the Ruby object
+ * goes out of scope, the underlying libxml structure is freed.  Libxml
+ * itself then frees all child node (recursively).
+ *
+ * For all other nodes (the vast majority), the bindings create temporary
+ * Ruby objects that get freed once they go out of scope. Thus there can be
+ * more than one ruby object pointing to the same xml node.  To mostly hide
+ * this from programmers on the ruby side, the #eql? and #== methods are 
+ * overriden to check if two ruby objects wrap the same xmlnode.  If they do,
+ * then the methods return true.  During the mark phase, each of these temporary
+ * objects marks its owning document, thereby keeping the Ruby document object
+ * alive and thus the xmldoc tree.
+ *
+ * In the sweep phase of the garbage collector, or when a program ends, 
+ * there is no order to how Ruby objects are freed. In fact, the ruby document
+ * object is almost always freed before any ruby objects that wrap child nodes.
+ * However, this is ok because those ruby objects do not have a free function
+ * and are no longer in scope (since if they were the document would not be freed).
  */
 
-static void rxml_node_deregisterNode(xmlNodePtr xnode)
-{
-  /* Has the node been wrapped and exposed to Ruby? */
-  VALUE node = rxml_lookup_node(xnode);
-  if (node == Qnil)
-      return;
-
-  /* Node was wrapped. Disassociate the ruby object from the xml node
-     and turn off the free function so Ruby will not call it when the
-     wrapping object is itself freed. Note we still MUST include 
-     the mark function.  Unsetting it breaks the Ruby GC. */
-   RDATA(node)->dfree = NULL;
-   RDATA(node)->data = NULL;
-
-  // Remove the hashtable entry
-  rxml_unregister_node(xnode);
-}
-
 static void rxml_node_free(xmlNodePtr xnode)
 {
-  /* The ruby object wrapping the xml object no longer exists. */
-  rxml_unregister_node(xnode);
-
-  /* Ruby is responsible for freeing this node if it does not
-     have a parent and is not owned by a document.  Note a corner
-     case here - calling node2 = doc.import(node1) will cause node2
-     to not have a parent but to have a document. */
+  /* The ruby object wrapping the xml object no longer exists and this
+     is a standalone node without a document or parent so ruby is 
+     responsible for freeing the underlying node.*/
   if (xnode->doc == NULL && xnode->parent == NULL)
   {
+    // Remove the back linkage from libxml to Ruby
+    xnode->_private = NULL;
     xmlFreeNode(xnode);
   }
 }
 
- void rxml_node_mark(xmlNodePtr xnode)
+void rxml_node_manage(xmlNodePtr xnode, VALUE node)
 {
-   VALUE doc = Qnil;
-   VALUE parent = Qnil;
+  RDATA(node)->dfree = rxml_node_free;
+  xnode->_private = (void*)node;
+}
 
-   /* Either the node has not been created yet in initialize
-     or it has been freed by libxml already in Ruby's 
-     mark phase. */
-  if (xnode == NULL)
-    return;
+void rxml_node_unmanage(xmlNodePtr xnode, VALUE node)
+{
+  RDATA(node)->dfree = NULL;
+  xnode->_private = NULL;
+}
 
-  doc = rxml_lookup_doc(xnode->doc);
-  if (doc != Qnil)
-    rb_gc_mark(doc);
+xmlNodePtr rxml_node_root(xmlNodePtr xnode)
+{
+  xmlNodePtr current = xnode;
 
-  parent = rxml_lookup_node(xnode->parent);
-  if (parent != Qnil)
-     rb_gc_mark(parent);
+  while (current->parent)
+  {
+    current = current->parent;
+  }
+
+  return current;
+}
+
+void rxml_node_mark(xmlNodePtr xnode)
+{
+   if (xnode->doc)
+   {
+     VALUE doc = (VALUE)xnode->doc->_private;
+     rb_gc_mark(doc);
+   }
+   else if (xnode->parent)
+   {
+     xmlNodePtr root = rxml_node_root(xnode);
+     if (root->_private)
+     {
+       VALUE node = (VALUE)root->_private;
+       rb_gc_mark(node);
+     }
+   }
 }
 
 VALUE rxml_node_wrap(xmlNodePtr xnode)
 {
-  VALUE result = rxml_lookup_node(xnode);
+  VALUE result = Qnil;
+
+  // Is this node already wrapped?
+  if (xnode->_private)
+  {
+    result = (VALUE)xnode->_private;
+  }
+  else
+  {
+    result = Data_Wrap_Struct(cXMLNode, rxml_node_mark, NULL, xnode);
+  }
 
-  if (result == Qnil) {
-    result = Data_Wrap_Struct(cXMLNode, rxml_node_mark, rxml_node_free, xnode);
-    rxml_register_node(xnode, result);
+  if (!xnode->doc && !xnode->parent)
+  {
+    rxml_node_manage(xnode, result);
   }
   return result;
 }
@@ -270,9 +284,11 @@ static VALUE rxml_node_initialize(int argc, VALUE *argv, VALUE self)
   if (xnode == NULL)
     rxml_raise(&xmlLastError);
 
-  /* Link the Ruby object to the libxml object and vice-versa. */
-  rxml_register_node(xnode, self);
-  DATA_PTR(self) = xnode;
+  // Link the ruby wrapper to the underlying libxml node
+  RDATA(self)->data = xnode;
+
+  // Ruby is in charge of managing this node's memory
+  rxml_node_manage(xnode, self);
 
   if (!NIL_P(content))
     rxml_node_content_set(self, content);
@@ -306,9 +322,12 @@ static VALUE rxml_node_modify_dom(VALUE self, VALUE target,
   if (xresult != xtarget)
   {
     RDATA(target)->data = xresult;
-    rxml_register_node(xresult, target);
   }
 
+  // Target now has a parent so ruby should no longer manage its memory
+  rxml_node_unmanage(xresult, target);
+  xtarget->_private = NULL;
+
   return target;
 }
 
@@ -402,35 +421,6 @@ static VALUE rxml_node_content_set(VALUE self, VALUE content)
   return (Qtrue);
 }
 
-/*
- * call-seq:
- *    node.content_stripped -> "string"
- *
- * Obtain this node's stripped content.
- *
- * *Deprecated*: Stripped content can be obtained via the
- * +content+ method.
- */
-static VALUE rxml_node_content_stripped_get(VALUE self)
-{
-  xmlNodePtr xnode;
-  xmlChar* content;
-  VALUE result = Qnil;
-
-  xnode = rxml_get_xnode(self);
-
-  if (!xnode->content)
-    return result;
-
-  content = xmlNodeGetContent(xnode);
-  if (content)
-  {
-    result = rxml_new_cstr( content, NULL);
-    xmlFree(content);
-  }
-  return (result);
-}
-
 /*
  * call-seq:
  *    node.debug -> true|false
@@ -540,7 +530,7 @@ static VALUE rxml_node_doc(VALUE self)
   if (xdoc == NULL)
     return (Qnil);
 
-  return rxml_lookup_doc(xdoc);
+  return (VALUE)xdoc->_private;
 }
 
 /*
@@ -684,10 +674,10 @@ static VALUE rxml_node_empty_q(VALUE self)
  *    node.eql?(other_node) => (true|false)
  *
  * Test equality between the two nodes. Two nodes are equal
- * if they are the same node or have the same XML representation.*/
+ * if they are the same node.*/
 static VALUE rxml_node_eql_q(VALUE self, VALUE other)
 {
-  if(self == other)
+  if (self == other)
   {
     return Qtrue;
   }
@@ -697,15 +687,9 @@ static VALUE rxml_node_eql_q(VALUE self, VALUE other)
   }
   else
   {
-    VALUE self_xml;
-    VALUE other_xml;
-
-    if (rb_obj_is_kind_of(other, cXMLNode) == Qfalse)
-      rb_raise(rb_eTypeError, "Nodes can only be compared against other nodes");
-
-    self_xml = rxml_node_to_s(0, NULL, self);
-    other_xml = rxml_node_to_s(0, NULL, other);
-    return(rb_funcall(self_xml, rb_intern("=="), 1, other_xml));
+    xmlNodePtr xnode = rxml_get_xnode(self);
+    xmlNodePtr xnode_other = rxml_get_xnode(other);
+    return xnode == xnode_other ? Qtrue : Qfalse;
   }
 }
 
@@ -1125,35 +1109,15 @@ static VALUE rxml_node_property_set(VALUE self, VALUE name, VALUE value)
 
 static VALUE rxml_node_remove_ex(VALUE self)
 {
-  xmlNodePtr xnode, xresult;
-  xnode = rxml_get_xnode(self);
-
-  /* First unlink the node from its parent. */
+  xmlNodePtr xnode = rxml_get_xnode(self);
+ 
+  // Now unlink the node from its parent
   xmlUnlinkNode(xnode);
 
-  /* Now copy the node we want to remove and make the
-     current Ruby object point to it.  We do this because
-     a node has a number of dependencies on its parent
-     document - its name (if using a dictionary), entities,
-     namespaces, etc.  For a node to live on its own, it
-     needs to get its own copies of this information.*/
-  xresult = xmlDocCopyNode(xnode, NULL, 1);
-
-  /* This ruby node object no longer points at the node.*/
-  rxml_unregister_node(xnode);
-  RDATA(self)->data = NULL;
-
-  /* Now free the original node.  This will call the deregister node
-    callback which would reset the mark and free function except for
-	the fact we already removed it from the private hashtable above */
-  xmlFreeNode(xnode);
-
-  /* Now wrap the new node */
-  RDATA(self)->data = xresult;
-  rxml_register_node(xresult, self);
-
-  /* Now return the removed node so the user can
-     do something with it.*/
+  // Ruby now manages this node
+  rxml_node_manage(xnode, self);
+
+  // Now return the removed node so the user can do something with it
   return self;
 }
 
@@ -1335,12 +1299,6 @@ static VALUE rxml_node_copy(VALUE self, VALUE deep)
 
 void rxml_init_node(void)
 {
-  /* Register callback for main thread */
-  xmlDeregisterNodeDefault(rxml_node_deregisterNode);
-
-  /* Register callback for all other threads */
-  xmlThrDefDeregisterNodeDefault(rxml_node_deregisterNode);
-
   cXMLNode = rb_define_class_under(mXML, "Node", rb_cObject);
 
   rb_define_const(cXMLNode, "SPACE_DEFAULT", INT2NUM(0));
@@ -1419,7 +1377,6 @@ void rxml_init_node(void)
   rb_define_method(cXMLNode, "copy", rxml_node_copy, 1);
   rb_define_method(cXMLNode, "content", rxml_node_content_get, 0);
   rb_define_method(cXMLNode, "content=", rxml_node_content_set, 1);
-  rb_define_method(cXMLNode, "content_stripped", rxml_node_content_stripped_get, 0);
   rb_define_method(cXMLNode, "debug", rxml_node_debug, 0);
   rb_define_method(cXMLNode, "doc", rxml_node_doc, 0);
   rb_define_method(cXMLNode, "empty?", rxml_node_empty_q, 0);

data/ext/libxml/ruby_xml_node.h

@@ -1,11 +1,13 @@
-/* Please see the LICENSE file for copyright and distribution information */
-
-#ifndef __RXML_NODE__
-#define __RXML_NODE__
-
-extern VALUE cXMLNode;
-
-void rxml_init_node(void);
-void rxml_node_mark(xmlNodePtr xnode);
-VALUE rxml_node_wrap(xmlNodePtr xnode);
-#endif
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_NODE__
+#define __RXML_NODE__
+
+extern VALUE cXMLNode;
+
+void rxml_init_node(void);
+void rxml_node_mark(xmlNodePtr xnode);
+VALUE rxml_node_wrap(xmlNodePtr xnode);
+void rxml_node_manage(xmlNodePtr xnode, VALUE node);
+void rxml_node_unmanage(xmlNodePtr xnode, VALUE node);
+#endif

data/ext/libxml/ruby_xml_parser.c

@@ -1,94 +1,91 @@
-/* Please see the LICENSE file for copyright and distribution information */
-
-#include <stdarg.h>
-#include "ruby_libxml.h"
-
-/*
- * Document-class: LibXML::XML::Parser
- *
- * The XML::Parser provides a tree based API for processing
- * xml documents, in contract to XML::Reader's stream
- * based api and XML::SaxParser callback based API.
- *
- * As a result, parsing a document creates an in-memory document object
- * that consist of any number of XML::Node instances.  This is simple
- * and powerful model, but has the major limitation that the size of
- * the document that can be processed is limited by the amount of
- * memory available.  In such cases, it is better to use the XML::Reader.
- *
- * Using the parser is simple:
- *
- *   parser = XML::Parser.file('my_file')
- *   doc = parser.parse
- *
- * You can also parse documents (see XML::Parser.document), 
- * strings (see XML::Parser.string) and io objects (see
- * XML::Parser.io).
- */
-
-VALUE cXMLParser;
-static ID CONTEXT_ATTR;
-
-/*
- * call-seq:
- *    parser.initialize(context) -> XML::Parser
- *
- * Creates a new XML::Parser from the specified 
- * XML::Parser::Context.
- */
-static VALUE rxml_parser_initialize(int argc, VALUE *argv, VALUE self)
-{
-  VALUE context = Qnil;
-
-  rb_scan_args(argc, argv, "01", &context);
-
-  if (context == Qnil)
-  {
-    rb_warn("Passing no parameters to XML::Parser.new is deprecated.  Pass an instance of XML::Parser::Context instead.");
-    context = rb_class_new_instance(0, NULL, cXMLParserContext);
-  }
-
-  rb_ivar_set(self, CONTEXT_ATTR, context);
-  return self;
-}
-
-/*
- * call-seq:
- *    parser.parse -> XML::Document
- *
- * Parse the input XML and create an XML::Document with
- * it's content. If an error occurs, XML::Parser::ParseError
- * is thrown.
- */
-static VALUE rxml_parser_parse(VALUE self)
-{
-  xmlParserCtxtPtr ctxt;
-  VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
-  
-  Data_Get_Struct(context, xmlParserCtxt, ctxt);
-
-  if ((xmlParseDocument(ctxt) == -1 || !ctxt->wellFormed) && ! ctxt->recovery)
-  {
-    if (ctxt->myDoc)
-      xmlFreeDoc(ctxt->myDoc);
-    rxml_raise(&ctxt->lastError);
-  }
-
-  rb_funcall(context, rb_intern("close"), 0);
-
-  return rxml_document_wrap(ctxt->myDoc);
-}
-
-void rxml_init_parser(void)
-{
-  cXMLParser = rb_define_class_under(mXML, "Parser", rb_cObject);
-
-  /* Atributes */
-  CONTEXT_ATTR = rb_intern("@context");
-  rb_define_attr(cXMLParser, "input", 1, 0);
-  rb_define_attr(cXMLParser, "context", 1, 0);
-
-  /* Instance Methods */
-  rb_define_method(cXMLParser, "initialize", rxml_parser_initialize, -1);
-  rb_define_method(cXMLParser, "parse", rxml_parser_parse, 0);
-}
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include <stdarg.h>
+#include "ruby_libxml.h"
+
+/*
+ * Document-class: LibXML::XML::Parser
+ *
+ * The XML::Parser provides a tree based API for processing
+ * xml documents, in contract to XML::Reader's stream
+ * based api and XML::SaxParser callback based API.
+ *
+ * As a result, parsing a document creates an in-memory document object
+ * that consist of any number of XML::Node instances.  This is simple
+ * and powerful model, but has the major limitation that the size of
+ * the document that can be processed is limited by the amount of
+ * memory available.  In such cases, it is better to use the XML::Reader.
+ *
+ * Using the parser is simple:
+ *
+ *   parser = XML::Parser.file('my_file')
+ *   doc = parser.parse
+ *
+ * You can also parse documents (see XML::Parser.document), 
+ * strings (see XML::Parser.string) and io objects (see
+ * XML::Parser.io).
+ */
+
+VALUE cXMLParser;
+static ID CONTEXT_ATTR;
+
+/*
+ * call-seq:
+ *    parser.initialize(context) -> XML::Parser
+ *
+ * Creates a new XML::Parser from the specified 
+ * XML::Parser::Context.
+ */
+static VALUE rxml_parser_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE context = Qnil;
+
+  rb_scan_args(argc, argv, "01", &context);
+
+  if (context == Qnil)
+  {
+    rb_raise(rb_eArgError, "An instance of a XML::Parser::Context must be passed to XML::Parser.new");
+  }
+
+  rb_ivar_set(self, CONTEXT_ATTR, context);
+  return self;
+}
+
+/*
+ * call-seq:
+ *    parser.parse -> XML::Document
+ *
+ * Parse the input XML and create an XML::Document with
+ * it's content. If an error occurs, XML::Parser::ParseError
+ * is thrown.
+ */
+static VALUE rxml_parser_parse(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
+  
+  Data_Get_Struct(context, xmlParserCtxt, ctxt);
+
+  if ((xmlParseDocument(ctxt) == -1 || !ctxt->wellFormed) && ! ctxt->recovery)
+  {
+    rxml_raise(&ctxt->lastError);
+  }
+
+  rb_funcall(context, rb_intern("close"), 0);
+
+  return rxml_document_wrap(ctxt->myDoc);
+}
+
+void rxml_init_parser(void)
+{
+  cXMLParser = rb_define_class_under(mXML, "Parser", rb_cObject);
+
+  /* Atributes */
+  CONTEXT_ATTR = rb_intern("@context");
+  rb_define_attr(cXMLParser, "input", 1, 0);
+  rb_define_attr(cXMLParser, "context", 1, 0);
+
+  /* Instance Methods */
+  rb_define_method(cXMLParser, "initialize", rxml_parser_initialize, -1);
+  rb_define_method(cXMLParser, "parse", rxml_parser_parse, 0);
+}