libxml-ruby 2.0.2-x86-mingw32 → 2.0.3-x86-mingw32

data/HISTORY

@@ -1,6 +1,57 @@
 = Release History
 
-== 2.0.1 / 2011-04-17 Charlie Savage
+== 2.0.3 / 2011-05-01 Charlie Savage
+
+* The biggest change in this release is supporting the use of libxml-ruby in
+  native background Ruby threads.  Previously, the use of libxml-ruby in
+  background threads in Ruby 1.9.x and higher would often cause
+  segmentation faults.  This has now been fixed (Charlie Savage).
+
+* Update Reader#expand so that returned node correctly remembers its
+  encoding in Ruby 1.9.x (zerebubuth).
+
+* Add check to verify a node has not been deleted.  This can happen when
+  a ruby variable holds a reference to a child node that gets freed
+  when its parent gets freed.  Previously when this happened a
+  segmentation fault would occur, now an exception is raised (Charlie Savage, fixes
+  RubyForge #26839.
+
+* Do not unlink nodes before internal validations have run - avoids
+  segmentation faults caused by freeing a node twice (Charlie Savage).
+
+* Add support for Document#canonicalization (Victor Lin).
+
+* Fix memory leak in Reader#lookup_namespace (Charlie Savage).
+
+* Fix memory leak in Reader#[] (Nathan Kriege).
+
+* Fix usage of @io instance variable (Jeffrey Taylor)
+
+* Removed old sax error handling code that has been fixed in newer
+  versions of libxml (Charlie Savage).
+
+* Code cleanup - remove unused variables and commented out code (Charlie Savage)
+
+* Minor text changes and documentation fixes (Charlie Savage).
+
+* Fix documentation error (fixes RubyForge #26888).
+
+* Update documentation for Document#validation* methods (fixes RubyForge #24833).
+
+* Update documentation and test (fixes Ruby Forge Issue #28770).
+
+* Updated documentation in README (Anurag Priyam):
+1. rake doc does not work; use rake rdoc.
+2. gem mislav-hanna does not exist; use hanna.
+3. rake rdoc 'depends' on hanna; no need of RDOCOPTS
+4. Point to the github issue tracker instead of Ruby Forge
+5. Point to the github (gh-pages) site for docs
+
+* Add tc_error to test suite (Charlie Savage).
+
+* Add sax test (Stanislav O.Pogrebnyak).
+
+== 2.0.2 / 2011-04-17 Charlie Savage
 
 * Added binaries for windows (Charlie Savage).
 

data/README.rdoc

@@ -75,9 +75,9 @@ then install the libxslt gem which is available at
 http://rubyforge.org/projects/libxsl/.
 
 == Usage
-For information about using libxml-ruby please refer
-to its documentation at http://libxml.rubyforge.org/rdoc/index.html.
-Some tutorials are also available at https://github.com/xml4r/libxml-ruby/wiki.
+For information about using libxml-ruby please refer to its documentation at
+http://xml4r.github.com/libxml-ruby/rdoc/index.html Some tutorials are also
+available at https://github.com/xml4r/libxml-ruby/wiki.
 
 All libxml classes are in the LibXML::XML module. The easiest
 way to use libxml is to require 'xml'.  This will mixin
@@ -111,6 +111,34 @@ For example:
 
 For simplicity's sake, the documentation uses the xml module in its examples.
 
+== Memory Management
+libxml-ruby automatically manages memory associated with the
+underlying libxml2 library.  There is however one corner case that
+your code must handle.  If a node is imported into a document, but not
+added to the document, a segmentation fault may occur on program termination.
+
+  # Do NOT do this
+  require 'xml'
+  doc1 = XML::Document.string("test1")
+  doc2 = XML::Document.string("test2")
+  node = doc2.import(doc1.root)
+
+If doc2 is freed before node2 a segmentatin fault will occur since
+node2 references the document.  To avoid this, simply make sure to add the
+node to the document:
+
+  # DO this instead
+  doc1 = XML::Document.string("test1")
+  doc2 = XML::Document.string("test2")
+  doc2.root << doc2.import(doc1.root)
+
+Alternatively, you can call node2.remove! to disassociate node2 from doc2.
+
+== Threading
+libxml-ruby fully supports native, background Ruby threads.  This of course
+only applies to Ruby 1.9.x and higher since earlier versions of Ruby do not
+support native threads.
+
 == Performance
 In addition to being feature rich and conformation, the main reason
 people use libxml-ruby is for performance.  Here are the results 
@@ -134,12 +162,14 @@ From https://svn.concord.org/svn/projects/trunk/common/ruby/xml_benchmarks/
 
 
 == Documentation
-Documentation is available via rdoc.  To generate the documentation,
-run the the command 'rake doc'.  libxml-ruby's online documentation
-is generated using Hanna.  To use hanna:
+Documentation is available via rdoc, and is installed automatically with the
+gem.
+
+libxml-ruby's online documentation is generated using Hanna.  To generate
+documentation from source:
 
-  gem install mislav-hanna
-  rake rdoc RDOCOPT="-S -T hanna"
+  gem install hanna
+  rake rdoc
 
 Note that older versions of Rdoc, which ship with Ruby 1.8.x, will report
 a number of errors.  To avoid them, install Rdoc 2.1 or higher from
@@ -152,8 +182,8 @@ ruby/lib/ruby/1.8/rdoc_old.
 
 If you have any questions about using libxml-ruby, please send them to
 libxml-devel@rubyforge.org.  If you have found any bugs in libxml-devel,
-or have developed new patches, please submit them to Ruby Forge at
-http://rubyforge.org/tracker/?group_id=494.
+or have developed new patches, please submit them to Git Hub at
+https://github.com/xml4r/libxml-ruby/issues.
 
 == License
 See LICENSE for license information.

data/ext/libxml/ruby_libxml.h

@@ -14,6 +14,7 @@
 #include <libxml/catalog.h>
 #include <libxml/HTMLparser.h>
 #include <libxml/xmlreader.h>
+#include <libxml/c14n.h>
 
 /* Needed for Ruby 1.8.5 */
 #ifndef RARRAY_LEN

data/ext/libxml/ruby_xml_attr.c

@@ -186,7 +186,7 @@ static VALUE rxml_attr_name_get(VALUE self)
   if (xattr->name == NULL)
     return Qnil;
   else
-    return rxml_str_new2((const char*) xattr->name, xattr->doc->encoding);
+    return rxml_str_new2((const char*) xattr->name, (xattr->doc ? xattr->doc->encoding : NULL));
 }
 
 /*
@@ -302,7 +302,7 @@ VALUE rxml_attr_value_get(VALUE self)
 
   if (value != NULL)
   {
-    result = rxml_str_new2((const char*) value, xattr->doc->encoding);
+    result = rxml_str_new2((const char*) value, (xattr->doc ? xattr->doc->encoding : NULL));
     xmlFree(value);
   }
   return result;

data/ext/libxml/ruby_xml_document.c

@@ -20,7 +20,7 @@
  *  doc = XML::Document.new()
  *  doc.root = XML::Node.new('root_node')
  *  doc.root << XML::Node.new('elem1')
- *  doc.save(filename, :indent => true, :encoding => 'UTF-8')
+ *  doc.save(filename, :indent => true, :encoding => XML::Encoding::UTF_8)
  *
  * To write a document to a file:
  *
@@ -45,7 +45,7 @@
  *
  *  elem3['attr'] = 'baz'
  *
- *  doc.save(filename, :indent => true, :encoding => 'UTF-8')
+ *  doc.save(filename, :indent => true, :encoding => XML::Encoding::UTF_8)
  */
 
 #include <stdarg.h>
@@ -123,6 +123,40 @@ static VALUE rxml_document_initialize(int argc, VALUE *argv, VALUE self)
   return self;
 }
 
+  /*
+   * call-seq:
+  *    document.canonicalize(comments) -> String 
+   *
+   * 	Returns a string containing the canonicalized form of the document.
+   *
+   *  :comments - Specifies if comments should be output.  This is an optional
+   *              parameter whose default value is false.
+   */
+static VALUE rxml_document_canonicalize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE result = Qnil;
+  VALUE comments = Qnil ;
+  xmlDocPtr xdoc;
+  xmlChar *buffer = NULL;
+  int length;
+
+  rb_scan_args(argc, argv, "01", &comments);
+  
+  Data_Get_Struct(self, xmlDoc, xdoc);
+  length = xmlC14NDocDumpMemory(xdoc, NULL, XML_C14N_1_1, NULL, 
+                                (comments == Qtrue ? 1 : 0),
+                                &buffer);
+
+  if (buffer)
+  {
+    result = rxml_str_new2((const char*) buffer, (const char*)xdoc->encoding);
+    xmlFree(buffer);
+  }
+
+  return result;
+}
+  
+ 
 /*
  * call-seq:
  *    document.compression -> num
@@ -285,16 +319,17 @@ static VALUE rxml_document_encoding_get(VALUE self)
  * Returns the Ruby encoding specified by this document
  * (available on Ruby 1.9.x and higher).
  */
+#ifdef HAVE_RUBY_ENCODING_H
 static VALUE rxml_document_rb_encoding_get(VALUE self)
 {
   xmlDocPtr xdoc;
   const char *xencoding;
-  VALUE encoding;
   Data_Get_Struct(self, xmlDoc, xdoc);
 
   xencoding = (const char*)xdoc->encoding;
   return rxml_xml_encoding_to_rb_encoding(mXMLEncoding, xmlParseCharEncoding(xencoding));
 }
+#endif 
 
 /*
  * call-seq:
@@ -322,6 +357,11 @@ static VALUE rxml_document_encoding_set(VALUE self, VALUE encoding)
  *
  * Creates a copy of the node that can be inserted into the
  * current document.
+ *
+ * IMPORTANT - The returned node MUST be inserted into the document.
+ * This is because the returned node refereces internal LibXML data
+ * structures owned by the document.  Therefore, if the document is
+ * is freed before the the node is freed a segmentation fault will occur.
  */
 static VALUE rxml_document_import(VALUE self, VALUE node)
 {
@@ -534,6 +574,9 @@ static VALUE rxml_document_root_set(VALUE self, VALUE node)
   Data_Get_Struct(self, xmlDoc, xdoc);
   Data_Get_Struct(node, xmlNode, xnode);
 
+  if (xnode->doc != NULL && xnode->doc != xdoc)
+    rb_raise(eXMLError, "Nodes belong to different documents.  You must first import the node by calling XML::Document.import");
+
   xroot = xmlDocSetRootElement(xdoc, xnode);
   return node;
 }
@@ -541,7 +584,7 @@ static VALUE rxml_document_root_set(VALUE self, VALUE node)
 /*
  * call-seq:
  *    document.save(filename) -> int
- *    document.save(filename, :indent => true, :encoding => 'UTF-8') -> int
+ *    document.save(filename, :indent => true, :encoding => XML::Encoding::UTF_8) -> int
  *
  * Saves a document to a file.  You may provide an optional hash table
  * to control how the string is generated.  Valid options are:
@@ -619,7 +662,7 @@ static VALUE rxml_document_standalone_q(VALUE self)
 /*
  * call-seq:
  *    document.to_s -> "string"
- *    document.to_s(:indent => true, :encoding => 'UTF-8') -> "string"
+ *    document.to_s(:indent => true, :encoding => XML::Encoding::UTF_8) -> "string"
  *
  * Converts a document, and all of its children, to a string representation.
  * You may provide an optional hash table to control how the string is 
@@ -771,9 +814,11 @@ static VALUE rxml_document_order_elements(VALUE self)
 
 /*
  * call-seq:
- *    document.validate_schema(schema) -> (true|false)
+ *    document.validate_schema(schema) 
  *
  * Validate this document against the specified XML::Schema.
+ * If the document is valid the method returns true.  Otherwise an
+ * exception is raised with validation information.
  */
 static VALUE rxml_document_validate_schema(VALUE self, VALUE schema)
 {
@@ -802,9 +847,11 @@ static VALUE rxml_document_validate_schema(VALUE self, VALUE schema)
 
 /*
  * call-seq:
- *    document.validate_schema(relaxng) -> (true|false)
+ *    document.validate_relaxng(relaxng) 
  *
  * Validate this document against the specified XML::RelaxNG.
+ * If the document is valid the method returns true.  Otherwise an
+ * exception is raised with validation information.
  */
 static VALUE rxml_document_validate_relaxng(VALUE self, VALUE relaxng)
 {
@@ -836,6 +883,8 @@ static VALUE rxml_document_validate_relaxng(VALUE self, VALUE relaxng)
  *    document.validate(dtd) -> (true|false)
  *
  * Validate this document against the specified XML::DTD.
+ * If the document is valid the method returns true.  Otherwise an
+ * exception is raised with validation information.
  */
 static VALUE rxml_document_validate_dtd(VALUE self, VALUE dtd)
 {
@@ -871,6 +920,7 @@ void rxml_init_document(void)
   rb_define_alloc_func(cXMLDocument, rxml_document_alloc);
 
   rb_define_method(cXMLDocument, "initialize", rxml_document_initialize, -1);
+  rb_define_method(cXMLDocument, "canonicalize", rxml_document_canonicalize, -1);
   rb_define_method(cXMLDocument, "child", rxml_document_child_get, 0);
   rb_define_method(cXMLDocument, "child?", rxml_document_child_q, 0);
   rb_define_method(cXMLDocument, "compression", rxml_document_compression_get, 0);

data/ext/libxml/ruby_xml_error.c

@@ -131,18 +131,6 @@ static void structuredErrorFunc(void *userData, xmlErrorPtr xerror)
   /* Wrap error up as Ruby object and send it off to ruby */
   VALUE block = rb_cvar_get(eXMLError, ERROR_HANDLER_ID);
 
-  /* This next bit of code is a total hack to get around a bug
-     in libxml which causes error handlers on sax handlers to
-     be ignored in favor of the global handler.  In addition,
-     the correct context is also not passed in.  So try to 
-     dig it out. */
-  if (!userData && xerror->ctxt)
-  {
-    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) xerror->ctxt;
-    if (ctxt != ctxt->userData)
-      userData = ctxt->userData;
-  }
-
   /* Now call global handler */
   if (block != Qnil)
   {

data/ext/libxml/ruby_xml_node.c

@@ -33,11 +33,11 @@ VALUE cXMLNode;
  * a libxml document.  When a Ruby node is freed, the _private
  * field is set back to null.  
  *
- * In the sweep phase in Ruby 1.9.1, the document is freed before
- * the nodes.  To support that, the bindingds 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 situtation.
+ * 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.
  */
 
 static void rxml_node_deregisterNode(xmlNodePtr xnode)
@@ -50,6 +50,8 @@ static void rxml_node_deregisterNode(xmlNodePtr xnode)
       try to free the node a second time. */
     VALUE node = (VALUE) xnode->_private;
     RDATA(node)->data = NULL;
+    RDATA(node)->dfree = NULL;
+    RDATA(node)->dmark = NULL;
   }
 }
 
@@ -64,40 +66,46 @@ static void rxml_node_free(xmlNodePtr xnode)
   /* The ruby object wrapping the xml object no longer exists. */
   xnode->_private = NULL;
 
-  /* Ruby is responsible for freeing this node since it
-     has no parent. */
+  /* 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. */
   if (xnode->parent == NULL)
+  {
     xmlFreeNode(xnode);
+  }
 }
 
  void rxml_node_mark(xmlNodePtr xnode)
 {
-  /* Either the node has been created yet in initialize
+  /* 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;
 
-  if (xnode->doc != NULL)
+  if (xnode->doc && xnode->doc->_private)
     rb_gc_mark((VALUE) xnode->doc->_private);
   
-  if (xnode->parent != NULL)
+  if (xnode->parent && xnode->parent->_private)
     rb_gc_mark((VALUE) xnode->_private);
 }
 
 VALUE rxml_node_wrap(xmlNodePtr xnode)
 {
+  VALUE result;
+
   /* Is the node already wrapped? */
   if (xnode->_private != NULL)
   {
-    return (VALUE) xnode->_private;
+    result = (VALUE) xnode->_private;
   }
   else
   {
-    VALUE node = Data_Wrap_Struct(cXMLNode, rxml_node_mark, rxml_node_free, xnode);
-    xnode->_private = (void*) node;
-    return node;
+    result = Data_Wrap_Struct(cXMLNode, rxml_node_mark, rxml_node_free, xnode);
+    xnode->_private = (void*) result;
   }
+  return result;
 }
 
 static VALUE rxml_node_alloc(VALUE klass)
@@ -107,6 +115,17 @@ static VALUE rxml_node_alloc(VALUE klass)
   return Data_Wrap_Struct(klass, rxml_node_mark, rxml_node_free, NULL);
 }
 
+static xmlNodePtr rxml_get_xnode(VALUE node)
+{
+   xmlNodePtr result;
+   Data_Get_Struct(node, xmlNode, result);
+
+   if (!result)
+    rb_raise(rb_eRuntimeError, "This node has already been freed.");
+
+   return result;
+}
+
 /*
  * call-seq:
  *    XML::Node.new_cdata(content = nil) -> XML::Node
@@ -237,11 +256,13 @@ static VALUE rxml_node_modify_dom(VALUE self, VALUE target,
   if (rb_obj_is_kind_of(target, cXMLNode) == Qfalse)
     rb_raise(rb_eTypeError, "Must pass an XML::Node object");
 
-  Data_Get_Struct(self, xmlNode, xnode);
-  Data_Get_Struct(target, xmlNode, xtarget);
+  xnode = rxml_get_xnode(self);
+  xtarget = rxml_get_xnode(target);
 
   if (xtarget->doc != NULL && xtarget->doc != xnode->doc)
-    rb_raise(eXMLError, "Nodes belong to different documents.  You must first import the by calling XML::Document.import");
+    rb_raise(eXMLError, "Nodes belong to different documents.  You must first import the node by calling XML::Document.import");
+
+  xmlUnlinkNode(xtarget);
 
   /* This target node could be freed here. */  
   xresult = xmlFunc(xnode, xtarget);
@@ -271,7 +292,7 @@ static VALUE rxml_node_base_uri_get(VALUE self)
   xmlChar* base_uri;
   VALUE result = Qnil;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
 
   if (xnode->doc == NULL)
     return (result);
@@ -299,7 +320,7 @@ static VALUE rxml_node_base_uri_set(VALUE self, VALUE uri)
   xmlNodePtr xnode;
 
   Check_Type(uri, T_STRING);
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
   if (xnode->doc == NULL)
     return (Qnil);
 
@@ -319,7 +340,7 @@ static VALUE rxml_node_content_get(VALUE self)
   xmlChar *content;
   VALUE result = Qnil;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
   content = xmlNodeGetContent(xnode);
   if (content)
   {
@@ -341,7 +362,7 @@ static VALUE rxml_node_content_set(VALUE self, VALUE content)
   xmlNodePtr xnode;
 
   Check_Type(content, T_STRING);
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
   // XXX docs indicate need for escaping entites, need to be done? danj
   xmlNodeSetContent(xnode, (xmlChar*) StringValuePtr(content));
   return (Qtrue);
@@ -362,7 +383,7 @@ static VALUE rxml_node_content_stripped_get(VALUE self)
   xmlChar* content;
   VALUE result = Qnil;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
 
   if (!xnode->content)
     return result;
@@ -387,7 +408,7 @@ static VALUE rxml_node_debug(VALUE self)
 {
 #ifdef LIBXML_DEBUG_ENABLED
   xmlNodePtr xnode;
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
   xmlDebugDumpNode(NULL, xnode, 2);
   return Qtrue;
 #else
@@ -406,7 +427,7 @@ static VALUE rxml_node_first_get(VALUE self)
 {
   xmlNodePtr xnode;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
 
   if (xnode->children)
     return (rxml_node_wrap(xnode->children));
@@ -434,16 +455,14 @@ static VALUE rxml_node_content_add(VALUE self, VALUE obj)
   xmlNodePtr xnode;
   VALUE str;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
+
   /* XXX This should only be legal for a CDATA type node, I think,
    * resulting in a merge of content, as if a string were passed
    * danj 070827
    */
   if (rb_obj_is_kind_of(obj, cXMLNode))
   { 
-    xmlNodePtr xtarget;
-    Data_Get_Struct(obj, xmlNode, xtarget);
-    xmlUnlinkNode(xtarget);
     rxml_node_modify_dom(self, obj, xmlAddChild);
   }
   else
@@ -465,41 +484,32 @@ static VALUE rxml_node_content_add(VALUE self, VALUE obj)
  */
 static VALUE rxml_node_doc(VALUE self)
 {
-  xmlNodePtr xnode;
-  xmlDocPtr doc = NULL;
-
-  Data_Get_Struct(self, xmlNode, xnode);
+  xmlDocPtr xdoc = NULL;
+  xmlNodePtr xnode = rxml_get_xnode(self);
 
   switch (xnode->type)
   {
   case XML_DOCUMENT_NODE:
 #ifdef LIBXML_DOCB_ENABLED
-    case XML_DOCB_DOCUMENT_NODE:
+  case XML_DOCB_DOCUMENT_NODE:
 #endif
   case XML_HTML_DOCUMENT_NODE:
-    doc = NULL;
+  case XML_NAMESPACE_DECL:
     break;
   case XML_ATTRIBUTE_NODE:
-  {
-    xmlAttrPtr attr = (xmlAttrPtr) xnode;
-    doc = attr->doc;
-    break;
-  }
-  case XML_NAMESPACE_DECL:
-    doc = NULL;
+    xdoc = (xmlDocPtr)((xmlAttrPtr) xnode->doc);
     break;
   default:
-    doc = xnode->doc;
-    break;
+    xdoc = xnode->doc;
   }
 
-  if (doc == NULL)
+  if (xdoc == NULL)
     return (Qnil);
-
-  if (doc->_private == NULL)
-    rb_raise(rb_eRuntimeError, "existing document object has no ruby-instance");
-
-  return (VALUE) doc->_private;
+  else if (xdoc->_private)
+    return (VALUE) xdoc->_private;
+  else
+    /* This can happen by calling Reader#expand.doc */
+    rb_raise(eXMLError, "Document is not accessible to Ruby (hint - did you call Reader#expand?)");
 }
 
 /*
@@ -567,7 +577,8 @@ static VALUE rxml_node_to_s(int argc, VALUE *argv, VALUE self)
   encodingHandler = xmlFindCharEncodingHandler(xencoding);
   output = xmlAllocOutputBuffer(encodingHandler);
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
+
   xmlNodeDumpOutput(output, xnode->doc, xnode, level, indent, xencoding);
   xmlOutputBufferFlush(output);
 
@@ -597,7 +608,7 @@ static VALUE rxml_node_each(VALUE self)
 {
   xmlNodePtr xnode;
   xmlNodePtr xcurrent;
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
 
   xcurrent = xnode->children;
 
@@ -617,12 +628,12 @@ static VALUE rxml_node_each(VALUE self)
  * call-seq:
  *    node.empty? -> (true|false)
  *
- * Determine whether this node is empty.
+ * Determine whether this node is an empty or whitespace only text-node.
  */
 static VALUE rxml_node_empty_q(VALUE self)
 {
   xmlNodePtr xnode;
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
   if (xnode == NULL)
     return (Qnil);
 
@@ -638,26 +649,26 @@ static VALUE rxml_node_empty_q(VALUE self)
  * if they are the same node or have the same XML representation.*/
 static VALUE rxml_node_eql_q(VALUE self, VALUE other)
 {
-if(self == other)
-{
-  return Qtrue;
-}
-else if (NIL_P(other))
-{
-  return Qfalse;
-}
-else
-{
-  VALUE self_xml;
-  VALUE other_xml;
+  if(self == other)
+  {
+    return Qtrue;
+  }
+  else if (NIL_P(other))
+  {
+    return Qfalse;
+  }
+  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");
+    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));
-}
+    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));
+  }
 }
 
 /*
@@ -673,7 +684,7 @@ static VALUE rxml_node_lang_get(VALUE self)
   xmlChar *lang;
   VALUE result = Qnil;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
   lang = xmlNodeGetLang(xnode);
 
   if (lang)
@@ -699,7 +710,7 @@ static VALUE rxml_node_lang_set(VALUE self, VALUE lang)
   xmlNodePtr xnode;
 
   Check_Type(lang, T_STRING);
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
   xmlNodeSetLang(xnode, (xmlChar*) StringValuePtr(lang));
 
   return (Qtrue);
@@ -715,7 +726,7 @@ static VALUE rxml_node_last_get(VALUE self)
 {
   xmlNodePtr xnode;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
 
   if (xnode->last)
     return (rxml_node_wrap(xnode->last));
@@ -735,7 +746,7 @@ static VALUE rxml_node_line_num(VALUE self)
 {
   xmlNodePtr xnode;
   long line_num;
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
 
   if (!xmlLineNumbersDefaultValue)
     rb_warn(
@@ -759,7 +770,7 @@ static VALUE rxml_node_xlink_q(VALUE self)
   xmlNodePtr xnode;
   xlinkType xlt;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
   xlt = xlinkIsLink(xnode->doc, xnode);
 
   if (xlt == XLINK_TYPE_NONE)
@@ -781,7 +792,7 @@ static VALUE rxml_node_xlink_type(VALUE self)
   xmlNodePtr xnode;
   xlinkType xlt;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
   xlt = xlinkIsLink(xnode->doc, xnode);
 
   if (xlt == XLINK_TYPE_NONE)
@@ -803,7 +814,7 @@ static VALUE rxml_node_xlink_type_name(VALUE self)
   xmlNodePtr xnode;
   xlinkType xlt;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
   xlt = xlinkIsLink(xnode->doc, xnode);
 
   switch (xlt)
@@ -832,7 +843,7 @@ static VALUE rxml_node_name_get(VALUE self)
   xmlNodePtr xnode;
   const xmlChar *name;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
 
   switch (xnode->type)
   {
@@ -881,7 +892,7 @@ static VALUE rxml_node_name_set(VALUE self, VALUE name)
   const xmlChar *xname;
 
   Check_Type(name, T_STRING);
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
   xname = (const xmlChar*)StringValuePtr(name);
 
 	/* Note: calling xmlNodeSetName() for a text node is ignored by libXML. */
@@ -900,7 +911,7 @@ static VALUE rxml_node_next_get(VALUE self)
 {
   xmlNodePtr xnode;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
 
   if (xnode->next)
     return (rxml_node_wrap(xnode->next));
@@ -933,7 +944,7 @@ static VALUE rxml_node_parent_get(VALUE self)
 {
   xmlNodePtr xnode;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
 
   if (xnode->parent)
     return (rxml_node_wrap(xnode->parent));
@@ -952,7 +963,7 @@ static VALUE rxml_node_path(VALUE self)
   xmlNodePtr xnode;
   xmlChar *path;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
   path = xmlGetNodePath(xnode);
 
   if (path == NULL)
@@ -982,7 +993,7 @@ static VALUE rxml_node_prev_get(VALUE self)
 {
   xmlNodePtr xnode;
   xmlNodePtr node;
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
 
   switch (xnode->type)
   {
@@ -1036,7 +1047,7 @@ static VALUE rxml_node_attributes_get(VALUE self)
 {
   xmlNodePtr xnode;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
   return rxml_attributes_new(xnode);
 }
 
@@ -1077,7 +1088,7 @@ static VALUE rxml_node_property_set(VALUE self, VALUE name, VALUE value)
 static VALUE rxml_node_remove_ex(VALUE self)
 {
   xmlNodePtr xnode, xresult;
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
 
   /* First unlink the node from its parent. */
   xmlUnlinkNode(xnode);
@@ -1137,7 +1148,7 @@ static VALUE rxml_node_sibling_set(VALUE self, VALUE sibling)
 static VALUE rxml_node_output_escaping_q(VALUE self)
 {
   xmlNodePtr xnode;
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
 
   switch (xnode->type) {
   case XML_TEXT_NODE:
@@ -1184,7 +1195,7 @@ static VALUE rxml_node_output_escaping_q(VALUE self)
 static VALUE rxml_node_output_escaping_set(VALUE self, VALUE bool)
 {
   xmlNodePtr xnode;
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
 
   switch (xnode->type) {
   case XML_TEXT_NODE:
@@ -1217,7 +1228,7 @@ static VALUE rxml_node_space_preserve_get(VALUE self)
 {
   xmlNodePtr xnode;
 
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
   return (INT2NUM(xmlNodeGetSpacePreserve(xnode)));
 }
 
@@ -1230,7 +1241,7 @@ static VALUE rxml_node_space_preserve_get(VALUE self)
 static VALUE rxml_node_space_preserve_set(VALUE self, VALUE bool)
 {
   xmlNodePtr xnode;
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
 
   if (TYPE(bool) == T_FALSE)
     xmlNodeSetSpacePreserve(xnode, 0);
@@ -1249,7 +1260,7 @@ static VALUE rxml_node_space_preserve_set(VALUE self, VALUE bool)
 static VALUE rxml_node_type(VALUE self)
 {
   xmlNodePtr xnode;
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
   return (INT2NUM(xnode->type));
 }
 
@@ -1268,7 +1279,7 @@ static VALUE rxml_node_copy(VALUE self, VALUE deep)
   xmlNodePtr xnode;
   xmlNodePtr xcopy;
   int recursive = (deep == Qnil || deep == Qfalse) ? 0 : 1;
-  Data_Get_Struct(self, xmlNode, xnode);
+  xnode = rxml_get_xnode(self);
 
   xcopy = xmlCopyNode(xnode, recursive);
 
@@ -1280,8 +1291,12 @@ 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));