libxml-ruby 2.0.9-x86-mingw32 → 2.1.0-x86-mingw32

data/HISTORY

@@ -1,5 +1,30 @@
 = Release History
 
+== 2.1.0 / 2011-07-31 Charlie Savage
+
+* Ruby 1.9.3 compatability (Charlie Savage).
+
+* Added XPath expression <-> Ruby value conversion methods (Jens Wille).
+
+* Extracted rxml_xpath_to_value from rxml_xpath_context_find (Jens Wille).
+
+* Adapted rxml_xpath_from_value from Gregoire Lejeune's ruby-xslt
+  library, see https://github.com/glejeune/ruby-xslt (Jens Wille).
+
+* Allow calling #find on nodes returned from Reader (Charlie Savage).
+
+* Change document handling in XPath::Context to address segmentation fault on
+  Ruby Enterprise Edition (Charlie Savage).
+
+* Update gemspec file to work directly with bundler thereby allowing git
+  repository to be used as gem (Charlie Savage).
+
+* Support gem buld (Charlie Savage).
+
+* Simplify memory management of attributes namespaces to fix
+  segmentation faults that occurred when using Ruby 1.9.3 (Charlie Savage).
+
+
 == 2.0.8 / 2011-06-23 Charlie Savage
 
 * Add in 2 new HTML Parser constants - NODEFDTD and NOIMPLIED.

data/Rakefile

@@ -4,7 +4,6 @@ require "rubygems"
 require "rake/extensiontask"
 require "rake/testtask"
 require "rubygems/package_task"
-##require 'hanna/rdoctask'
 require "rdoc/task"
 require "grancher/task"
 require "yaml"
@@ -40,6 +39,7 @@ if RUBY_PLATFORM.match(/win32|mingw32/)
   win_spec = spec.clone
   win_spec.platform = Gem::Platform::CURRENT
   win_spec.files += binaries.to_a
+  win_spec.instance_variable_set(:@cache_file, nil)
 
   # Unset extensions
   win_spec.extensions = nil

data/ext/libxml/ruby_libxml.h

@@ -16,37 +16,11 @@
 #include <libxml/xmlreader.h>
 #include <libxml/c14n.h>
 
-/* Needed for Ruby 1.8.5 */
-#ifndef RARRAY_LEN
-#define RARRAY_LEN(s) (RARRAY(s)->len)
-#endif
-
-/* Needed for Ruby 1.8.5 */
-#ifndef RARRAY_PTR
-#define RARRAY_PTR(s) (RARRAY(s)->ptr)
-#endif
-
-/* Needed for Ruby 1.8.5 */
-#ifndef RSTRING_LEN
-#define RSTRING_LEN(s) (RSTRING(s)->len)
-#endif
-
-/* Needed for Ruby 1.8.5 */
-#ifndef RSTRING_PTR
-#define RSTRING_PTR(s) (RSTRING(s)->ptr)
-#endif
-
 /* Needed prior to Ruby 1.9.1 */
 #ifndef RHASH_TBL
 #define RHASH_TBL(s) (RHASH(s)->tbl)
 #endif
 
-// Not in Ruby 1.9
-#ifndef GetWriteFile
-#define GetWriteFile(fp) rb_io_stdio_file(fp)
-#define OpenFile rb_io_t
-#endif
-
 // Encoding support added in Ruby 1.9.*
 #ifdef HAVE_RUBY_ENCODING_H
 #include <ruby/encoding.h>

data/ext/libxml/ruby_xml_attr.c

@@ -16,57 +16,38 @@
  *  attribute.remove!
  */
 
+/* Attributes are owned and freed by their nodes.  Thus, its easier for the
+   ruby bindings to not manage attribute memory management.  This does mean
+   that accessing a particular attribute multiple times will return multiple
+   different ruby objects.  Since we are not using free or xnode->_private
+   this works out fine.  Previous versions of the bindings had a one to
+   one mapping between ruby object and xml attribute, but that could 
+   result in segfaults because the ruby object could be gc'ed.  In theory
+   the mark method on the parent node could prevent that, but if an 
+   attribute is returned using an xpath statement then the node would
+   never by surfaced to ruby and the mark method never called. */
+
 #include "ruby_libxml.h"
 #include "ruby_xml_attr.h"
 
 VALUE cXMLAttr;
 
-void rxml_attr_free(xmlAttrPtr xattr)
-{
-  if (!xattr)
-    return;
-
-  xattr->_private = NULL;
-
-  if (xattr->parent == NULL && xattr->doc == NULL)
-  {
-    xmlFreeProp(xattr);
-  }
-}
-
 void rxml_attr_mark(xmlAttrPtr xattr)
 {
   /* This can happen if Ruby does a GC run after creating the
      new attribute but before initializing it. */
-  if (xattr == NULL)
-    return;
-
-  if (xattr->_private == NULL)
-  {
-    rb_warning("XmlAttr is not bound! (%s:%d)", __FILE__, __LINE__);
-    return;
-  }
-
-  rxml_node_mark((xmlNodePtr) xattr);
+  if (xattr != NULL)
+    rxml_node_mark((xmlNodePtr) xattr);
 }
 
 VALUE rxml_attr_wrap(xmlAttrPtr xattr)
 {
-  VALUE result;
-
-  /* Check if the node is already wrapped. */
-  if (xattr->_private != NULL)
-    return (VALUE) xattr->_private;
-
-  result = Data_Wrap_Struct(cXMLAttr, rxml_attr_mark, rxml_attr_free, xattr);
-  xattr->_private = (void*) result;
-  
-  return result;
+  return Data_Wrap_Struct(cXMLAttr, rxml_attr_mark, NULL, xattr);
 }
 
 static VALUE rxml_attr_alloc(VALUE klass)
 {
-  return Data_Wrap_Struct(klass, rxml_attr_mark, rxml_attr_free, NULL);
+  return Data_Wrap_Struct(klass, rxml_attr_mark, NULL, NULL);
 }
 
 /*
@@ -116,7 +97,6 @@ static VALUE rxml_attr_initialize(int argc, VALUE *argv, VALUE self)
   if (!xattr)
     rb_raise(rb_eRuntimeError, "Could not create attribute.");
 
-  xattr->_private = (void *) self;
   DATA_PTR( self) = xattr;
   return self;
 }
@@ -231,7 +211,7 @@ static VALUE rxml_attr_ns_get(VALUE self)
   if (xattr->ns == NULL)
     return Qnil;
   else
-    return rxml_namespace_wrap(xattr->ns, NULL);
+    return rxml_namespace_wrap(xattr->ns);
 }
 
 /*
@@ -268,21 +248,24 @@ static VALUE rxml_attr_prev_get(VALUE self)
 
 /*
  * call-seq:
- *     node.remove! -> nil
+ *     attr.remove! -> nil
  *
- * Removes this attribute from it's parent.
+ * Removes this attribute from it's parent.  Note
+ * the attribute and its content is freed and can
+ * no longer be used.  If you try to use it you 
+ * will get a segmentation fault.
  */
 static VALUE rxml_attr_remove_ex(VALUE self)
 {
   xmlAttrPtr xattr;
   Data_Get_Struct(self, xmlAttr, xattr);
+  xmlRemoveProp(xattr);
 
-  if (xattr->_private == NULL)
-    xmlRemoveProp(xattr);
-  else
-    xmlUnlinkNode((xmlNodePtr) xattr);
+  RDATA(self)->data = NULL;
+  RDATA(self)->dfree = NULL;
+  RDATA(self)->dmark = NULL;
 
-  return Qnil;;
+  return Qnil;
 }
 
 /*

data/ext/libxml/ruby_xml_attr_decl.c

@@ -15,28 +15,12 @@ VALUE cXMLAttrDecl;
 
 void rxml_attr_decl_mark(xmlAttributePtr xattr)
 {
-  if (xattr->_private == NULL)
-  {
-    rb_warning("AttrDecl is not bound! (%s:%d)", __FILE__, __LINE__);
-    return;
-  }
-
   rxml_node_mark((xmlNodePtr) xattr);
 }
 
 VALUE rxml_attr_decl_wrap(xmlAttributePtr xattr)
 {
-  VALUE result;
-
-  // This node is already wrapped
-  if (xattr->_private != NULL)
-    return (VALUE) xattr->_private;
-
-  result = Data_Wrap_Struct(cXMLAttrDecl, rxml_attr_decl_mark, NULL, xattr);
-
-  xattr->_private = (void*) result;
-
-  return result;
+  return Data_Wrap_Struct(cXMLAttrDecl, rxml_attr_decl_mark, NULL, xattr);
 }
 
 /*

data/ext/libxml/ruby_xml_namespace.c

@@ -21,32 +21,17 @@ VALUE cXMLNamespace;
  *   assert_nil(node.namespaces.namespace)
  */
 
-static void rxml_namespace_free(xmlNsPtr xns)
-{
-  xns->_private = NULL;
-}
+/* Namespaces are owned and freed by their nodes.  Thus, its easier for the
+   ruby bindings to not manage attribute memory management. */
 
 static VALUE rxml_namespace_alloc(VALUE klass)
 {
-  return Data_Wrap_Struct(klass, NULL, rxml_namespace_free, NULL);
+  return Data_Wrap_Struct(klass, NULL, NULL, NULL);
 }
 
-VALUE rxml_namespace_wrap(xmlNsPtr xns, RUBY_DATA_FUNC freeFunc)
+VALUE rxml_namespace_wrap(xmlNsPtr xns)
 {
-  if (xns->_private)
-  {
-    return (VALUE)xns->_private;
-  }
-  else
-  {
-    VALUE ns;
-    if (freeFunc == NULL)
-      freeFunc = (RUBY_DATA_FUNC)rxml_namespace_free;
-
-    ns = Data_Wrap_Struct(cXMLNamespace, NULL, freeFunc, xns);
-    xns->_private = (void*)ns;
-    return ns;
-  }
+  return Data_Wrap_Struct(cXMLNamespace, NULL, NULL, xns);
 }
 
 static VALUE rxml_namespace_string(xmlNsPtr xns, const char* buffer)
@@ -84,7 +69,6 @@ static VALUE rxml_namespace_initialize(VALUE self, VALUE node, VALUE prefix,
   if (!xns)
     rxml_raise(&xmlLastError);
 
-  xns->_private = (void*)self;
   DATA_PTR(self) = xns;
   return self;
 }
@@ -163,7 +147,7 @@ static VALUE rxml_namespace_next(VALUE self)
   if (xns == NULL || xns->next == NULL)
     return (Qnil);
   else
-    return (rxml_namespace_wrap(xns->next, NULL));
+    return rxml_namespace_wrap(xns->next);
 }
 
 void rxml_init_namespace(void)

data/ext/libxml/ruby_xml_namespace.h

@@ -6,5 +6,5 @@
 extern VALUE cXMLNamespace;
 
 void rxml_init_namespace(void);
-VALUE rxml_namespace_wrap(xmlNsPtr xns, RUBY_DATA_FUNC freeFunc);
+VALUE rxml_namespace_wrap(xmlNsPtr xns);
 #endif

data/ext/libxml/ruby_xml_namespaces.c

@@ -90,7 +90,7 @@ static VALUE rxml_namespaces_definitions(VALUE self)
 
   while (xns)
   {
-    VALUE anamespace = rxml_namespace_wrap(xns, NULL);
+    VALUE anamespace = rxml_namespace_wrap(xns);
     rb_ary_push(arr, anamespace);
     xns = xns->next;
   }
@@ -126,7 +126,7 @@ static VALUE rxml_namespaces_each(VALUE self)
 
   for (xns = nsList; *xns != NULL; xns++)
   {
-    VALUE ns = rxml_namespace_wrap(*xns, NULL);
+    VALUE ns = rxml_namespace_wrap(*xns);
     rb_yield(ns);
   }
   xmlFree(nsList);
@@ -161,7 +161,7 @@ static VALUE rxml_namespaces_find_by_href(VALUE self, VALUE href)
 
   xns = xmlSearchNsByHref(xnode->doc, xnode, (xmlChar*) StringValuePtr(href));
   if (xns)
-    return rxml_namespace_wrap(xns, NULL);
+    return rxml_namespace_wrap(xns);
   else
     return Qnil;
 }
@@ -200,7 +200,7 @@ static VALUE rxml_namespaces_find_by_prefix(VALUE self, VALUE prefix)
   
   xns = xmlSearchNs(xnode->doc, xnode, xprefix);
   if (xns)
-    return rxml_namespace_wrap(xns, NULL);
+    return rxml_namespace_wrap(xns);
   else
     return Qnil;
 }
@@ -224,7 +224,7 @@ static VALUE rxml_namespaces_namespace_get(VALUE self)
   Data_Get_Struct(self, xmlNode, xnode);
 
   if (xnode->ns)
-    return rxml_namespace_wrap(xnode->ns, NULL);
+    return rxml_namespace_wrap(xnode->ns);
   else
     return Qnil;
 }

data/ext/libxml/ruby_xml_node.c

@@ -508,8 +508,7 @@ static VALUE rxml_node_doc(VALUE self)
   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?)");
+    return (Qnil);
 }
 
 /*

data/ext/libxml/ruby_xml_parser_context.c

@@ -350,7 +350,7 @@ static VALUE rxml_parser_context_encoding_set(VALUE self, VALUE encoding)
   xmlCharEncodingHandlerPtr hdlr = xmlFindCharEncodingHandler(xencoding);
   
   if (!hdlr)
-    rb_raise(rb_eRuntimeError, "Unknown encoding: %s", encoding);
+    rb_raise(rb_eArgError, "Unknown encoding: %i", NUM2INT(encoding));
 
   Data_Get_Struct(self, xmlParserCtxt, ctxt);
   result = xmlSwitchToEncoding(ctxt, hdlr);

data/ext/libxml/ruby_xml_reader.c

@@ -42,6 +42,11 @@
  *
  * For a more in depth tutorial, albeit in C, see http://xmlsoft.org/xmlreader.html.*/
 
+
+  /* NOTE - We need to wrap the readers document to support Reader.read.node.find('/').
+     To do this we need to use xmlTextReaderCurrentDoc which means we have to free the
+     document ourselves. Annoying... */
+
 VALUE cXMLReader;
 
 static ID BASE_URI_SYMBOL;
@@ -54,11 +59,20 @@ static void rxml_reader_free(xmlTextReaderPtr xreader)
   xmlFreeTextReader(xreader);
 }
 
+static void rxml_reader_mark(xmlTextReaderPtr xreader)
+{
+  xmlDocPtr xdoc = xmlTextReaderCurrentDoc(xreader);
+
+  if (xdoc && xdoc->_private)
+    rb_gc_mark((VALUE) xdoc->_private);
+}
+
 static VALUE rxml_reader_wrap(xmlTextReaderPtr xreader)
 {
   return Data_Wrap_Struct(cXMLReader, NULL, rxml_reader_free, xreader);
 }
 
+
 static xmlTextReaderPtr rxml_text_reader_get(VALUE obj)
 {
   xmlTextReaderPtr xreader;
@@ -414,7 +428,7 @@ static VALUE rxml_reader_normalization(VALUE self)
 
 /*
  * call-seq:
- *    reader.read -> code
+ *    reader.read -> nil|true|false
  *
  * Causes the reader to move to the next node in the stream, exposing its properties.
  *
@@ -873,7 +887,15 @@ static VALUE rxml_reader_lookup_namespace(VALUE self, VALUE prefix)
 static VALUE rxml_reader_expand(VALUE self)
 {
   xmlTextReaderPtr xreader = rxml_text_reader_get(self);
-  xmlNodePtr xnode = xmlTextReaderExpand(xreader);
+  xmlNodePtr xnode = NULL;
+
+  /* At this point we need to wrap the reader's document as explained above. */
+  rxml_document_wrap(xmlTextReaderCurrentDoc(xreader));
+
+  /* And now hook in a mark function */
+  RDATA(self)->dmark = (RUBY_DATA_FUNC)rxml_reader_mark;
+
+  xnode = xmlTextReaderExpand(xreader);
   
   if (!xnode)
   {

data/ext/libxml/ruby_xml_version.h

@@ -1,9 +1,9 @@
 /* Don't nuke this block!  It is used for automatically updating the
  * versions below. VERSION = string formatting, VERNUM = numbered
  * version for inline testing: increment both or none at all.*/
-#define RUBY_LIBXML_VERSION  "2.0.9"
-#define RUBY_LIBXML_VERNUM   209
+#define RUBY_LIBXML_VERSION  "2.1.0"
+#define RUBY_LIBXML_VERNUM   210
 #define RUBY_LIBXML_VER_MAJ   2
-#define RUBY_LIBXML_VER_MIN   0
-#define RUBY_LIBXML_VER_MIC   9
+#define RUBY_LIBXML_VER_MIN   1
+#define RUBY_LIBXML_VER_MIC   0
 #define RUBY_LIBXML_VER_PATCH 0

data/ext/libxml/ruby_xml_xpath.c

@@ -78,6 +78,88 @@
 
 VALUE mXPath;
 
+VALUE
+rxml_xpath_to_value(xmlXPathContextPtr xctxt, xmlXPathObjectPtr xobject) {
+  VALUE result;
+  int type;
+
+  if (xobject == NULL) {
+    /* xmlLastError is different than xctxt->lastError.  Use
+     xmlLastError since it has the message set while xctxt->lastError
+     does not. */
+    xmlErrorPtr xerror = xmlGetLastError();
+    rxml_raise(xerror);
+  }
+
+  switch (type = xobject->type) {
+    case XPATH_NODESET:
+      result = rxml_xpath_object_wrap(xctxt->doc, xobject);
+      break;
+    case XPATH_BOOLEAN:
+      result = (xobject->boolval != 0) ? Qtrue : Qfalse;
+      xmlXPathFreeObject(xobject);
+      break;
+    case XPATH_NUMBER:
+      result = rb_float_new(xobject->floatval);
+      xmlXPathFreeObject(xobject);
+      break;
+    case XPATH_STRING:
+      result = rxml_str_new2((const char*)xobject->stringval, xctxt->doc->encoding);
+      xmlXPathFreeObject(xobject);
+      break;
+    default:
+      xmlXPathFreeObject(xobject);
+      rb_raise(rb_eTypeError,
+        "can't convert XPath object of type %d to Ruby value", type
+      );
+  }
+
+  return result;
+}
+
+xmlXPathObjectPtr
+rxml_xpath_from_value(VALUE value) {
+  xmlXPathObjectPtr result = NULL;
+
+  switch (TYPE(value)) {
+    case T_TRUE:
+    case T_FALSE:
+      result = xmlXPathNewBoolean(RTEST(value));
+      break;
+    case T_FIXNUM:
+    case T_FLOAT:
+      result = xmlXPathNewFloat(NUM2DBL(value));
+      break;
+    case T_STRING:
+      result = xmlXPathWrapString(xmlStrdup((const xmlChar *)StringValuePtr(value)));
+      break;
+    case T_NIL:
+      result = xmlXPathNewNodeSet(NULL);
+      break;
+    case T_ARRAY: {
+      int i, j;
+      result = xmlXPathNewNodeSet(NULL);
+
+      for (i = RARRAY_LEN(value); i > 0; i--) {
+        xmlXPathObjectPtr obj = rxml_xpath_from_value(rb_ary_shift(value));
+
+        if ((obj->nodesetval != NULL) && (obj->nodesetval->nodeNr != 0)) {
+          for (j = 0; j < obj->nodesetval->nodeNr; j++) {
+            xmlXPathNodeSetAdd(result->nodesetval, obj->nodesetval->nodeTab[j]);
+          }
+        }
+      }
+      break;
+    }
+    default:
+      rb_raise(rb_eTypeError,
+        "can't convert object of type %s to XPath object", rb_obj_classname(value)
+      );
+  }
+
+  return result;
+}
+
 void rxml_init_xpath(void)
 {
   mXPath = rb_define_module_under(mXML, "XPath");

data/ext/libxml/ruby_xml_xpath.h

@@ -5,6 +5,9 @@
 
 extern VALUE mXPath;
 
+extern VALUE rxml_xpath_to_value(xmlXPathContextPtr, xmlXPathObjectPtr);
+extern xmlXPathObjectPtr rxml_xpath_from_value(VALUE);
+
 void rxml_init_xpath(void);
 
 #endif

data/ext/libxml/ruby_xml_xpath_context.c

@@ -26,16 +26,20 @@
 
 VALUE cXMLXPathContext;
 
-static ID DOC_ATTRIBUTE;
-
 static void rxml_xpath_context_free(xmlXPathContextPtr ctxt)
 {
   xmlXPathFreeContext(ctxt);
 }
 
+static void rxml_xpath_context_mark(xmlXPathContextPtr ctxt)
+{
+  if (ctxt->doc->_private)
+    rb_gc_mark((VALUE) ctxt->doc->_private);
+}
+
 static VALUE rxml_xpath_context_alloc(VALUE klass)
 {
-  return Data_Wrap_Struct(cXMLXPathContext, NULL, rxml_xpath_context_free, NULL);
+  return Data_Wrap_Struct(cXMLXPathContext, rxml_xpath_context_mark, rxml_xpath_context_free, NULL);
 }
 
 /* call-seq:
@@ -72,12 +76,25 @@ static VALUE rxml_xpath_context_initialize(VALUE self, VALUE node)
   Data_Get_Struct(document, xmlDoc, xdoc);
   DATA_PTR(self) = xmlXPathNewContext(xdoc);
 
-  /* Save the doc as an attribute, this will expose it to Ruby's GC. */
-  rb_ivar_set(self, DOC_ATTRIBUTE, document);
-
   return self;
 }
 
+/*
+ * call-seq:
+ *    context.doc -> document
+ *
+ * Obtain the XML::Document this node belongs to.
+ */
+static VALUE rxml_xpath_context_doc(VALUE self)
+{
+  xmlDocPtr xdoc = NULL;
+  xmlXPathContextPtr ctxt;
+  Data_Get_Struct(self, xmlXPathContext, ctxt);
+  
+  xdoc = ctxt->doc;
+  return rxml_document_wrap(xdoc);
+}
+
 /*
  * call-seq:
  *    context.register_namespace(prefix, uri) -> (true|false)
@@ -264,7 +281,6 @@ static VALUE rxml_xpath_context_find(VALUE self, VALUE xpath_expr)
   xmlXPathContextPtr xctxt;
   xmlXPathObjectPtr xobject;
   xmlXPathCompExprPtr xcompexpr;
-  VALUE result;
 
   Data_Get_Struct(self, xmlXPathContext, xctxt);
 
@@ -284,37 +300,7 @@ static VALUE rxml_xpath_context_find(VALUE self, VALUE xpath_expr)
         "Argument should be an intance of a String or XPath::Expression");
   }
 
-  if (xobject == NULL)
-  {
-    /* xmlLastError is different than xctxt->lastError.  Use
-     xmlLastError since it has the message set while xctxt->lastError
-     does not. */
-    xmlErrorPtr xerror = xmlGetLastError();
-    rxml_raise(xerror);
-  }
-
-  switch (xobject->type)
-  {
-  case XPATH_NODESET:
-    result = rxml_xpath_object_wrap(xctxt->doc, xobject);
-    break;
-  case XPATH_BOOLEAN:
-    result = (xobject->boolval != 0) ? Qtrue : Qfalse;
-    xmlXPathFreeObject(xobject);
-    break;
-  case XPATH_NUMBER:
-    result = rb_float_new(xobject->floatval);
-    xmlXPathFreeObject(xobject);
-    break;
-  case XPATH_STRING:
-    result = rxml_str_new2((const char*)xobject->stringval, xctxt->doc->encoding);
-    xmlXPathFreeObject(xobject);
-    break;
-  default:
-    result = Qnil;
-    xmlXPathFreeObject(xobject);
-  }
-  return result;
+  return rxml_xpath_to_value(xctxt, xobject);
 }
 
 #if LIBXML_VERSION >= 20626
@@ -370,11 +356,9 @@ rxml_xpath_context_disable_cache(VALUE self)
 
 void rxml_init_xpath_context(void)
 {
-  DOC_ATTRIBUTE = rb_intern("@doc");
-
   cXMLXPathContext = rb_define_class_under(mXPath, "Context", rb_cObject);
   rb_define_alloc_func(cXMLXPathContext, rxml_xpath_context_alloc);
-  rb_define_attr(cXMLXPathContext, "doc", 1, 0);
+  rb_define_method(cXMLXPathContext, "doc", rxml_xpath_context_doc, 0);
   rb_define_method(cXMLXPathContext, "initialize", rxml_xpath_context_initialize, 1);
   rb_define_method(cXMLXPathContext, "register_namespaces", rxml_xpath_context_register_namespaces, 1);
   rb_define_method(cXMLXPathContext, "register_namespaces_from_node", rxml_xpath_context_register_namespaces_from_node, 1);

data/ext/libxml/ruby_xml_xpath_object.c

@@ -45,7 +45,6 @@ static void rxml_xpath_object_free(rxml_xpath_object *rxpop)
 /* Custom free function for copied namespace nodes */
 static void rxml_namespace_xpath_free(xmlNsPtr xns)
 {
-  xns->_private = NULL;
   xmlFreeNs(xns);
 }
 
@@ -82,7 +81,8 @@ VALUE rxml_xpath_object_wrap(xmlDocPtr xdoc, xmlXPathObjectPtr xpop)
 
         /* Specify a custom free function here since by default
            namespace nodes will not be freed */
-        ns = rxml_namespace_wrap((xmlNsPtr)xnode, (RUBY_DATA_FUNC)rxml_namespace_xpath_free);
+        ns = rxml_namespace_wrap((xmlNsPtr)xnode);
+        RDATA(ns)->dfree = (RUBY_DATA_FUNC)rxml_namespace_xpath_free;
         rb_ary_push(rxpop->nsnodes, ns);
       }
     }
@@ -93,7 +93,6 @@ VALUE rxml_xpath_object_wrap(xmlDocPtr xdoc, xmlXPathObjectPtr xpop)
 
 static VALUE rxml_xpath_object_tabref(xmlXPathObjectPtr xpop, int apos)
 {
-
   if (apos < 0)
     apos = xpop->nodesetval->nodeNr + apos;
 
@@ -106,7 +105,7 @@ static VALUE rxml_xpath_object_tabref(xmlXPathObjectPtr xpop, int apos)
     return rxml_attr_wrap((xmlAttrPtr) xpop->nodesetval->nodeTab[apos]);
     break;
   case XML_NAMESPACE_DECL:
-    return rxml_namespace_wrap((xmlNsPtr)xpop->nodesetval->nodeTab[apos], NULL);
+    return rxml_namespace_wrap((xmlNsPtr)xpop->nodesetval->nodeTab[apos]);
     break;
   default:
     return rxml_node_wrap(xpop->nodesetval->nodeTab[apos]);

data/libxml-ruby.gemspec

@@ -1,4 +1,5 @@
 # encoding: utf-8
+require 'rake'
 
 # Determine the current version of the software
 version = File.read('ext/libxml/ruby_xml_version.h').match(/\s*RUBY_LIBXML_VERSION\s*['"](\d.+)['"]/)[1]

data/test/tc_attr.rb

@@ -27,6 +27,7 @@ class AttrNodeTest < Test::Unit::TestCase
   
   def teardown
     @doc = nil
+    GC.start
   end
   
   def city_member
@@ -37,117 +38,118 @@ class AttrNodeTest < Test::Unit::TestCase
     assert_not_nil(@doc)
     assert_equal(XML::Encoding::NONE, @doc.encoding)
   end
-  
+
   def test_types
     attribute = city_member.attributes.get_attribute('name')
     assert_instance_of(XML::Attr, attribute)
     assert_equal('attribute', attribute.node_type_name)
   end
-  
+
   def test_name
     attribute = city_member.attributes.get_attribute('name')
     assert_equal('name', attribute.name)
     assert_equal(Encoding::ASCII_8BIT, attribute.name.encoding) if defined?(Encoding)
-    
+
     attribute = city_member.attributes.get_attribute('href')
     assert_equal('href', attribute.name)
     assert_equal('xlink', attribute.ns.prefix)
     assert_equal('http://www.w3.org/1999/xlink', attribute.ns.href)
-    
+
     attribute = city_member.attributes.get_attribute_ns('http://www.w3.org/1999/xlink', 'href')
     assert_equal('href', attribute.name)
     assert_equal('xlink', attribute.ns.prefix)
     assert_equal('http://www.w3.org/1999/xlink', attribute.ns.href)
   end
-  
+
   def test_value
     attribute = city_member.attributes.get_attribute('name')
     assert_equal('Cambridge', attribute.value)
     assert_equal(Encoding::ASCII_8BIT, attribute.value.encoding) if defined?(Encoding)
-    
+
     attribute = city_member.attributes.get_attribute('href')
     assert_equal('http://www.foo.net/cgi-bin/wfs?FeatureID=C10239', attribute.value)
   end
-  
+
   def test_set_value
     attribute = city_member.attributes.get_attribute('name')
     attribute.value = 'London'
     assert_equal('London', attribute.value)
     assert_equal(Encoding::ASCII_8BIT, attribute.value.encoding) if defined?(Encoding)
-    
+
     attribute = city_member.attributes.get_attribute('href')
     attribute.value = 'http://i.have.changed'
     assert_equal('http://i.have.changed', attribute.value)
     assert_equal(Encoding::ASCII_8BIT, attribute.value.encoding) if defined?(Encoding)
   end
-  
+
   def test_set_nil
     attribute = city_member.attributes.get_attribute('name')
     assert_raise(TypeError) do
       attribute.value = nil
     end
   end
-  
+
   def test_create
     attributes = city_member.attributes
     assert_equal(5, attributes.length)
-    
+
     attr = XML::Attr.new(city_member, 'size', '50,000')
     assert_instance_of(XML::Attr, attr)
-    
+
     attributes = city_member.attributes
     assert_equal(6, attributes.length)
-    
+
     assert_equal(attributes['size'], '50,000')
   end
-  
+
   def test_create_on_node
     attributes = city_member.attributes
     assert_equal(5, attributes.length)
-    
+
     attributes['country'] = 'England'
-    
+
     attributes = city_member.attributes
     assert_equal(6, attributes.length)
-    
+
     assert_equal(attributes['country'], 'England')
   end
-  
+
   def test_create_ns
     assert_equal(5, city_member.attributes.length)
-    
+
     ns = XML::Namespace.new(city_member, 'my_namepace', 'http://www.mynamespace.com')
     attr = XML::Attr.new(city_member, 'rating', 'rocks', ns)
     assert_instance_of(XML::Attr, attr)
     assert_equal('rating', attr.name)
     assert_equal('rocks', attr.value)
-    
+
     attributes = city_member.attributes
     assert_equal(6, attributes.length)
-    
+
     assert_equal('rocks', city_member['rating'])
   end
 
   def test_remove
     attributes = city_member.attributes
     assert_equal(5, attributes.length)
-    
+
     attribute = attributes.get_attribute('name')
     assert_not_nil(attribute.parent)
     assert(attribute.parent?)
-    
+
     attribute.remove!
     assert_equal(4, attributes.length)
-    assert_nil(attribute.parent)
-    assert(!attribute.parent?)
+
+    attribute = attributes.get_attribute('name')
+    assert_nil(attribute)
   end
-  
+
   def test_first
     attribute = city_member.attributes.first
     assert_instance_of(XML::Attr, attribute)
     assert_equal('name', attribute.name)
     assert_equal('Cambridge', attribute.value)
-    
+
     attribute = attribute.next
     assert_instance_of(XML::Attr, attribute)
     assert_equal('type', attribute.name)
@@ -157,7 +159,7 @@ class AttrNodeTest < Test::Unit::TestCase
     assert_instance_of(XML::Attr, attribute)
     assert_equal('title', attribute.name)
     assert_equal('Trinity Lane', attribute.value)
-    
+
     attribute = attribute.next
     assert_instance_of(XML::Attr, attribute)
     assert_equal('href', attribute.name)
@@ -167,7 +169,7 @@ class AttrNodeTest < Test::Unit::TestCase
     assert_instance_of(XML::Attr, attribute)
     assert_equal('remoteSchema', attribute.name)
     assert_equal("city.xsd#xpointer(//complexType[@name='RoadType'])", attribute.value)
-    
+
     attribute = attribute.next
     assert_nil(attribute)
   end

data/test/tc_attributes.rb

@@ -6,7 +6,7 @@ require 'test/unit'
 class AttributesTest < Test::Unit::TestCase
   def setup
     xp = XML::Parser.string(<<-EOS)
-    <CityModel
+    <CityModel name="value"
       xmlns="http://www.opengis.net/examples"
       xmlns:city="http://www.opengis.net/examples"
       xmlns:gml="http://www.opengis.net/gml"
@@ -90,6 +90,14 @@ class AttributesTest < Test::Unit::TestCase
     assert_equal('http://www.foo.net/cgi-bin/wfs?FeatureID=C10239', attributes[:href])
   end
 
+  def test_get_values_gc
+    # There used to be a bug caused by accessing an
+    # attribute over and over and over again.
+    20000.times do
+      @doc.root.attributes["key"]
+    end
+  end
+
   def test_set_values
     city_member[:name] = 'London'
     assert_equal('London', city_member[:name])

data/test/tc_parser_context.rb

@@ -34,6 +34,22 @@ class TestParserContext < Test::Unit::TestCase
     assert_equal(XML::Encoding::ISO_8859_1, context.encoding)
   end
 
+  def test_invalid_encoding
+    # UTF8
+    xml = <<-EOS
+      <bands>
+        <metal>m\303\266tley_cr\303\274e</metal>
+      </bands>
+    EOS
+
+    context = XML::Parser::Context.string(xml)
+
+    error = assert_raise(ArgumentError) do
+      context.encoding = -999
+    end
+    assert_equal("Unknown encoding: -999", error.to_s)
+  end
+
   def test_base_uri
     # UTF8
     xml = <<-EOS
@@ -51,7 +67,7 @@ class TestParserContext < Test::Unit::TestCase
 
   def test_string_empty
     error = assert_raise(TypeError) do
-      parser = XML::Parser::Context.string(nil)
+      XML::Parser::Context.string(nil)
     end
     assert_equal("wrong argument type nil (expected String)", error.to_s)
 

data/test/tc_reader.rb

@@ -171,12 +171,33 @@ class TestReader < Test::Unit::TestCase
     node = reader.expand
     assert_equal('feed', node.name)
     assert_equal(::Encoding::UTF_8, node.name.encoding) if defined?(::Encoding)
+  end
+
+  def test_expand_doc
+    reader = XML::Reader.file(XML_FILE)
+    reader.read.to_s
+    reader.read
+
+    # Read a node
+    node = reader.expand
 
     # Try to access the document
-    error = assert_raise(XML::Error) do
-      assert_not_nil(node.doc)
-    end
-    assert_equal(" Document is not accessible to Ruby (hint - did you call Reader#expand?).", error.to_s)
+    assert_not_nil(node.doc)
+  end
+
+  def test_expand_find
+    reader = XML::Reader.file(XML_FILE)
+    reader.read.to_s
+    reader.read
+
+    # Read first node which
+    node = reader.expand
+    assert_equal('feed', node.name)
+
+    # Search for entries
+    entries = node.find('atom:entry', 'atom:http://www.w3.org/2005/Atom')
+
+    assert_equal(1, entries.length)
   end
 
   def test_mode

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: libxml-ruby
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 11
   prerelease: 
   segments: 
   - 2
+  - 1
   - 0
-  - 9
-  version: 2.0.9
+  version: 2.1.0
 platform: x86-mingw32
 authors: 
 - Ross Bamform
@@ -20,7 +20,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-25 00:00:00 Z
+date: 2011-07-31 00:00:00 Z
 dependencies: []
 
 description: "    The Libxml-Ruby project provides Ruby language bindings for the GNOME\n    Libxml2 XML toolkit. It is free software, released under the MIT License.\n    Libxml-ruby's primary advantage over REXML is performance - if speed\n    is your need, these are good libraries to consider, as demonstrated\n    by the informal benchmark below.\n"
@@ -227,7 +227,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.7.2
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Ruby Bindings for LibXML2