libxml-ruby 0.9.7 → 0.9.8

data/ext/libxml/ruby_xml_sax_parser.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_sax_parser.c 684 2008-12-13 00:34:28Z cfis $ */
+/* $Id: ruby_xml_sax_parser.c 740 2009-01-23 04:03:11Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -12,7 +12,7 @@
  * in contrast to XML::Parser's tree based API and XML::Reader's stream
  * based API.
  *
- * Note that the XML::SaxParser API is fairly complex, not well standardized,
+ * The XML::SaxParser API is fairly complex, not well standardized,
  * and does not directly support validation making entity, namespace and
  * base processing relatively hard.
  *
@@ -30,49 +30,22 @@
  *     end
  *   end
  *
- *   parser = XML::SaxParser.new
+ *   parser = XML::SaxParser.string(my_string)
  *   parser.callbacks = MyCallbacks.new
  *   parser.parse
+ *
+ * You can also parse strings (see XML::SaxParser.string) and
+ * io objects (see XML::SaxParser.io).
  */
 
 VALUE cXMLSaxParser;
-
-static ID INPUT_ATTR;
 static ID CALLBACKS_ATTR;
+static ID CONTEXT_ATTR;
 
 
 /* ======  Parser  =========== */
-/*
- * call-seq:
- *    sax_parser.initialize -> sax_parser
- *
- * Initiliazes instance of parser.
- */
-static VALUE rxml_sax_parser_initialize(VALUE self)
-{
-  VALUE input = rb_class_new_instance(0, NULL, cXMLInput);
-  rb_iv_set(self, "@input", input);
-  return self;
-}
-
-/* Parsing data sources */
-static int rxml_sax_parser_parse_file(VALUE self, VALUE input)
-{
-  VALUE handler = rb_ivar_get(self, CALLBACKS_ATTR);
-  VALUE file = rb_ivar_get(input, FILE_ATTR);
-  return xmlSAXUserParseFile((xmlSAXHandlerPtr) &rxml_sax_handler,
-      (void *) handler, StringValuePtr(file));
-}
-
-static int rxml_sax_parser_parse_string(VALUE self, VALUE input)
-{
-  VALUE handler = rb_ivar_get(self, CALLBACKS_ATTR);
-  VALUE str = rb_ivar_get(input, STRING_ATTR);
-  return xmlSAXUserParseMemory((xmlSAXHandlerPtr) &rxml_sax_handler,
-      (void *) handler, StringValuePtr(str), RSTRING_LEN(str));
-}
 
-static int rxml_sax_parser_parse_io(VALUE self, VALUE input)
+/*static int rxml_sax_parser_parse_io(VALUE self, VALUE input)
 {
   VALUE handler = rb_ivar_get(self, CALLBACKS_ATTR);
   VALUE io = rb_ivar_get(input, IO_ATTR);
@@ -83,6 +56,30 @@ static int rxml_sax_parser_parse_io(VALUE self, VALUE input)
           (void *) handler, (xmlInputReadCallback) rxml_read_callback, NULL,
           (void *) io, xmlEncoding);
   return xmlParseDocument(ctxt);
+}*/
+
+
+/*
+ * call-seq:
+ *    parser.initialize(context) -> XML::Parser
+ *
+ * Creates a new XML::Parser from the specified 
+ * XML::Parser::Context.
+ */
+static VALUE rxml_sax_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::SaxParser.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;
 }
 
 /*
@@ -95,26 +92,33 @@ static int rxml_sax_parser_parse_io(VALUE self, VALUE input)
 static VALUE rxml_sax_parser_parse(VALUE self)
 {
   int status;
-  VALUE input = rb_ivar_get(self, INPUT_ATTR);
-
-  if (rb_ivar_get(input, FILE_ATTR) != Qnil)
-    status = rxml_sax_parser_parse_file(self, input);
-  else if (rb_ivar_get(input, STRING_ATTR) != Qnil)
-    status = rxml_sax_parser_parse_string(self, input);
-  else if (rb_ivar_get(input, IO_ATTR) != Qnil)
-    status = rxml_sax_parser_parse_io(self, input);
-  else
-    rb_raise(rb_eArgError, "You must specify a parser data source");
-
-  if (status)
+  VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(context, xmlParserCtxt, ctxt);
+
+  ctxt->sax2 = 1;
+	ctxt->userData = (void*)rb_ivar_get(self, CALLBACKS_ATTR);
+
+  if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
+    xmlFree(ctxt->sax);
+    
+  ctxt->sax = (xmlSAXHandlerPtr)&rxml_sax_handler;
+    
+  status = xmlParseDocument(ctxt);
+
+  /* IMPORTANT - null the handle to our sax handler
+     so libxml doesn't try to free it.*/
+  ctxt->sax = NULL;
+  
+  /* Now check the parsing result*/
+  if (status == -1 || !ctxt->wellFormed)
   {
-    rxml_raise(&xmlLastError);
-    return Qfalse;
-  }
-  else
-  {
-    return (Qtrue);
+    if (ctxt->myDoc)
+      xmlFreeDoc(ctxt->myDoc);
+
+    rxml_raise(&ctxt->lastError);
   }
+  return Qtrue;
 }
 
 // Rdoc needs to know
@@ -130,11 +134,10 @@ void ruby_init_xml_sax_parser(void)
 
   /* Atributes */
   CALLBACKS_ATTR = rb_intern("@callbacks");
-  INPUT_ATTR = rb_intern("@input");
+  CONTEXT_ATTR = rb_intern("@context");
   rb_define_attr(cXMLSaxParser, "callbacks", 1, 1);
-  rb_define_attr(cXMLSaxParser, "input", 1, 0);
 
   /* Instance Methods */
-  rb_define_method(cXMLSaxParser, "initialize", rxml_sax_parser_initialize, 0);
+  rb_define_method(cXMLSaxParser, "initialize", rxml_sax_parser_initialize, -1);
   rb_define_method(cXMLSaxParser, "parse", rxml_sax_parser_parse, 0);
-}
+}

data/ext/libxml/ruby_xml_xpath_context.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_xpath_context.c 673 2008-12-08 06:33:23Z cfis $ */
+/* $Id: ruby_xml_xpath_context.c 739 2009-01-23 03:42:09Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -23,6 +23,8 @@
 
 VALUE cXMLXPathContext;
 
+static ID DOC_ATTRIBUTE;
+
 static void rxml_xpath_context_free(xmlXPathContextPtr ctxt)
 {
   xmlXPathFreeContext(ctxt);
@@ -68,7 +70,7 @@ static VALUE rxml_xpath_context_initialize(VALUE self, VALUE node)
   DATA_PTR(self) = xmlXPathNewContext(xdoc);
 
   /* Save the doc as an attribute, this will expose it to Ruby's GC. */
-  rb_iv_set(self, "@doc", document);
+  rb_ivar_set(self, DOC_ATTRIBUTE, document);
 
   return self;
 }
@@ -245,9 +247,11 @@ static VALUE rxml_xpath_context_node_set(VALUE self, VALUE node)
 
 /*
  * call-seq:
- *    context.find("xpath") -> XML::XPath::Object
+ *    context.find("xpath") -> true|false|number|string|XML::XPath::Object
  *
- * Find nodes matching the specified XPath expression
+ * Executes the provided xpath function.  The result depends on the execution
+ * of the xpath statement.  It may be true, false, a number, a string or 
+ * a node set.
  */
 static VALUE rxml_xpath_context_find(VALUE self, VALUE xpath_expr)
 {
@@ -283,12 +287,31 @@ static VALUE rxml_xpath_context_find(VALUE self, VALUE xpath_expr)
     rxml_raise(xerror);
   }
 
-  result = rxml_xpath_object_wrap(xobject);
-  rb_iv_set(result, "@context", self);
+  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 = rb_str_new2((const char*)xobject->stringval);
+    xmlXPathFreeObject(xobject);
+    break;
+  default:
+    result = Qnil;
+    xmlXPathFreeObject(xobject);
+  }
   return result;
 }
 
-
+#if LIBXML_VERSION >= 20626
 /*
  * call-seq:
  *    context.enable_cache(size = nil)
@@ -327,7 +350,8 @@ rxml_xpath_context_enable_cache(int argc,  VALUE *argv, VALUE self)
  * Disables an XPath::Context's built-in cache.
  */
 static VALUE
-rxml_xpath_context_disable_cache(VALUE self) {
+rxml_xpath_context_disable_cache(VALUE self)
+{
   xmlXPathContextPtr xctxt;
   Data_Get_Struct(self, xmlXPathContext, xctxt);
 
@@ -336,10 +360,19 @@ rxml_xpath_context_disable_cache(VALUE self) {
 
   return self;
 }
+#endif
+
 
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mLibXML = rb_define_module("LibXML");
+  mXPath = rb_define_module_under(mLibXML, "XPath");
+#endif
 
 void ruby_init_xml_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);
@@ -349,6 +382,8 @@ void ruby_init_xml_xpath_context(void)
   rb_define_method(cXMLXPathContext, "register_namespace", rxml_xpath_context_register_namespace, 2);
   rb_define_method(cXMLXPathContext, "node=", rxml_xpath_context_node_set, 1);
   rb_define_method(cXMLXPathContext, "find", rxml_xpath_context_find, 1);
+#if LIBXML_VERSION >= 20626
   rb_define_method(cXMLXPathContext, "enable_cache", rxml_xpath_context_enable_cache, -1);
   rb_define_method(cXMLXPathContext, "disable_cache", rxml_xpath_context_disable_cache, 0);
+#endif
 }

data/ext/libxml/ruby_xml_xpath_expression.c

@@ -58,6 +58,12 @@ static VALUE rxml_xpath_expression_initialize(VALUE self, VALUE expression)
   return self;
 }
 
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mLibXML = rb_define_module("LibXML");
+  mXPath = rb_define_module_under(mLibXML, "XPath");
+#endif
+
 void ruby_init_xml_xpath_expression(void)
 {
   cXMLXPathExpression = rb_define_class_under(mXPath, "Expression", rb_cObject);

data/ext/libxml/ruby_xml_xpath_object.c

@@ -7,91 +7,90 @@
  *
  * A collection of nodes returned from the evaluation of an XML::XPath
  * or XML::XPointer expression.
- *
  */
-VALUE cXMLXPathObject;
-
-static xmlDocPtr rxml_xpath_object_doc(xmlXPathObjectPtr xpop)
-{
-  xmlDocPtr result = NULL;
-  xmlNodePtr *nodes = NULL;
 
-  if (xpop->type != XPATH_NODESET)
-    return result;
+VALUE cXMLXPathObject;
 
-  if (!xpop->nodesetval || !xpop->nodesetval->nodeTab)
-    return result;
 
-  nodes = xpop->nodesetval->nodeTab;
+/* Memory management of xpath results is tricky.  If a nodeset is
+   returned, it generally consists of pointers to nodes in the 
+   original document.  However, namespace nodes are handled differently - 
+   libxml creates copies of them instead.  Thus, when an xmlXPathObjectPtr
+   is freed, libxml iterates over the results to find the copied namespace 
+   nodes to free them.
 
-  if (!(*nodes))
-    return result;
+   This causes problems for the bindings because the underlying document
+   may be freed before the xmlXPathObjectPtr instance.  This might seem
+   counterintuitive since the xmlXPathObjectPtr marks the document.
+   However, once both objects go out of scope, the order of their 
+   destruction is random.
 
-  return (*nodes)->doc;
-}
+   To deal with this, the wrapper code searches for the namespace nodes
+   and wraps them in Ruby objects.  When the Ruby objects go out of scope
+   then the namespace nodes are freed. */
 
-static void rxml_xpath_object_mark(xmlXPathObjectPtr xpop)
+static void rxml_xpath_object_free(rxml_xpath_object *rxpop)
 {
-  int i;
-
-  if (xpop->type == XPATH_NODESET && xpop->nodesetval != NULL)
+  /* We positively, absolutely cannot let libxml iterate over
+     the nodeTab since if the underlying document has been
+     freed the majority of entries are invalid, resulting in
+     segmentation faults.*/
+  if (rxpop->xpop->nodesetval && rxpop->xpop->nodesetval->nodeTab)
   {
-    xmlDocPtr xdoc = rxml_xpath_object_doc(xpop);
-    if (xdoc && xdoc->_private)
-      rb_gc_mark((VALUE) xdoc->_private);
-
-    for (i = 0; i < xpop->nodesetval->nodeNr; i++)
-    {
-      if (xpop->nodesetval->nodeTab[i]->_private)
-        rb_gc_mark((VALUE) xpop->nodesetval->nodeTab[i]->_private);
-    }
+    xmlFree(rxpop->xpop->nodesetval->nodeTab);
+    rxpop->xpop->nodesetval->nodeTab = NULL;
   }
+  xmlXPathFreeObject(rxpop->xpop);
+  xfree(rxpop);
 }
 
-static void rxml_xpath_object_free(xmlXPathObjectPtr xpop)
+/* Custom free function for copied namespace nodes */
+static void rxml_namespace_xpath_free(xmlNsPtr xns)
 {
-  /* Now free the xpath result but not underlying nodes
-   since those belong to the document. */
-  xmlXPathFreeNodeSetList(xpop);
+  xns->_private = NULL;
+  xmlFreeNs(xns);
 }
 
-VALUE rxml_xpath_object_wrap(xmlXPathObjectPtr xpop)
+static void rxml_xpath_object_mark(rxml_xpath_object *rxpop)
 {
-  VALUE rval;
+  rb_gc_mark(rxpop->nsnodes);
+  if (rxpop->xdoc->_private)
+    rb_gc_mark((VALUE)rxpop->xdoc->_private);
+}
 
-  if (xpop == NULL)
-    return Qnil;
+VALUE rxml_xpath_object_wrap(xmlDocPtr xdoc, xmlXPathObjectPtr xpop)
+{
+  int i;
+  rxml_xpath_object *rxpop = ALLOC(rxml_xpath_object);
+  rxpop->xdoc =xdoc;
+  rxpop->xpop = xpop;
+  rxpop->nsnodes = rb_ary_new();
 
-  switch (xpop->type)
+  /* Find all the extra namespace nodes and wrap them. */
+  if (xpop->nodesetval && xpop->nodesetval->nodeNr)
   {
-  case XPATH_NODESET:
-    rval = Data_Wrap_Struct(cXMLXPathObject, rxml_xpath_object_mark,
-        rxml_xpath_object_free, xpop);
-
-    break;
-  case XPATH_BOOLEAN:
-    if (xpop->boolval != 0)
-      rval = Qtrue;
-    else
-      rval = Qfalse;
-
-    xmlXPathFreeObject(xpop);
-    break;
-  case XPATH_NUMBER:
-    rval = rb_float_new(xpop->floatval);
-
-    xmlXPathFreeObject(xpop);
-    break;
-  case XPATH_STRING:
-    rval = rb_str_new2((const char*)xpop->stringval);
-
-    xmlXPathFreeObject(xpop);
-    break;
-  default:
-    xmlXPathFreeObject(xpop);
-    rval = Qnil;
+    for (i = 0;i < xpop->nodesetval->nodeNr; i++)
+    {
+      xmlNodePtr xnode = xpop->nodesetval->nodeTab[i];
+      if (xnode!= NULL && xnode->type == XML_NAMESPACE_DECL)
+      {
+        VALUE ns = Qnil;
+        xmlNsPtr xns = (xmlNsPtr)xnode;
+
+        /* Get rid of libxml's -> next hack.  The issue here is
+           the rxml_namespace code assumes that ns->next refers
+           to another namespace. */
+        xns->next = NULL;
+
+        /* 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);
+        rb_ary_push(rxpop->nsnodes, ns);
+      }
+    }
   }
-  return rval;
+
+  return Data_Wrap_Struct(cXMLXPathObject, rxml_xpath_object_mark, rxml_xpath_object_free, rxpop);
 }
 
 static VALUE rxml_xpath_object_tabref(xmlXPathObjectPtr xpop, int apos)
@@ -108,8 +107,11 @@ static VALUE rxml_xpath_object_tabref(xmlXPathObjectPtr xpop, int apos)
   case XML_ATTRIBUTE_NODE:
     return rxml_attr_wrap((xmlAttrPtr) xpop->nodesetval->nodeTab[apos]);
     break;
+  case XML_NAMESPACE_DECL:
+    return rxml_namespace_wrap((xmlNsPtr)xpop->nodesetval->nodeTab[apos], NULL);
+    break;
   default:
-    return rxml_node_wrap(cXMLNode, xpop->nodesetval->nodeTab[apos]);
+    return rxml_node_wrap(xpop->nodesetval->nodeTab[apos]);
   }
 }
 
@@ -122,12 +124,15 @@ static VALUE rxml_xpath_object_tabref(xmlXPathObjectPtr xpop, int apos)
 static VALUE rxml_xpath_object_to_a(VALUE self)
 {
   VALUE set_ary, nodeobj;
+  rxml_xpath_object *rxpop;
   xmlXPathObjectPtr xpop;
   int i;
 
-  Data_Get_Struct(self, xmlXPathObject, xpop);
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  xpop = rxpop->xpop;
 
   set_ary = rb_ary_new();
+
   if (!((xpop->nodesetval == NULL) || (xpop->nodesetval->nodeNr == 0)))
   {
     for (i = 0; i < xpop->nodesetval->nodeNr; i++)
@@ -148,14 +153,13 @@ static VALUE rxml_xpath_object_to_a(VALUE self)
  */
 static VALUE rxml_xpath_object_empty_q(VALUE self)
 {
-  xmlXPathObjectPtr xpop;
+  rxml_xpath_object *rxpop;
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
 
-  Data_Get_Struct(self, xmlXPathObject, xpop);
-
-  if (xpop->type != XPATH_NODESET)
+  if (rxpop->xpop->type != XPATH_NODESET)
     return Qnil;
 
-  return (xpop->nodesetval == NULL || xpop->nodesetval->nodeNr <= 0) ? Qtrue
+  return (rxpop->xpop->nodesetval == NULL || rxpop->xpop->nodesetval->nodeNr <= 0) ? Qtrue
       : Qfalse;
 }
 
@@ -167,17 +171,17 @@ static VALUE rxml_xpath_object_empty_q(VALUE self)
  */
 static VALUE rxml_xpath_object_each(VALUE self)
 {
-  xmlXPathObjectPtr xpop;
+  rxml_xpath_object *rxpop;
   int i;
 
   if (rxml_xpath_object_empty_q(self) == Qtrue)
     return Qnil;
 
-  Data_Get_Struct(self, xmlXPathObject, xpop);
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
 
-  for (i = 0; i < xpop->nodesetval->nodeNr; i++)
+  for (i = 0; i < rxpop->xpop->nodesetval->nodeNr; i++)
   {
-    rb_yield(rxml_xpath_object_tabref(xpop, i));
+    rb_yield(rxml_xpath_object_tabref(rxpop->xpop, i));
   }
   return (self);
 }
@@ -190,10 +194,13 @@ static VALUE rxml_xpath_object_each(VALUE self)
  */
 static VALUE rxml_xpath_object_first(VALUE self)
 {
+  rxml_xpath_object *rxpop;
+
   if (rxml_xpath_object_empty_q(self) == Qtrue)
     return Qnil;
 
-  return rxml_xpath_object_tabref((xmlXPathObjectPtr) DATA_PTR(self), 0);
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  return rxml_xpath_object_tabref(rxpop->xpop, 0);
 }
 
 /*
@@ -204,11 +211,13 @@ static VALUE rxml_xpath_object_first(VALUE self)
  */
 static VALUE rxml_xpath_object_aref(VALUE self, VALUE aref)
 {
+  rxml_xpath_object *rxpop;
+
   if (rxml_xpath_object_empty_q(self) == Qtrue)
     return Qnil;
 
-  return rxml_xpath_object_tabref((xmlXPathObjectPtr) DATA_PTR(self), NUM2INT(
-      aref));
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  return rxml_xpath_object_tabref(rxpop->xpop, NUM2INT(aref));
 }
 
 /*
@@ -219,14 +228,13 @@ static VALUE rxml_xpath_object_aref(VALUE self, VALUE aref)
  */
 static VALUE rxml_xpath_object_length(VALUE self)
 {
-  xmlXPathObjectPtr xpop;
+  rxml_xpath_object *rxpop;
 
   if (rxml_xpath_object_empty_q(self) == Qtrue)
     return INT2FIX(0);
 
-  Data_Get_Struct(self, xmlXPathObject, xpop);
-
-  return INT2NUM(xpop->nodesetval->nodeNr);
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  return INT2NUM(rxpop->xpop->nodesetval->nodeNr);
 }
 
 /*
@@ -250,11 +258,9 @@ static VALUE rxml_xpath_object_length(VALUE self)
  */
 static VALUE rxml_xpath_object_get_type(VALUE self)
 {
-  xmlXPathObjectPtr xpop;
-
-  Data_Get_Struct(self, xmlXPathObject, xpop);
-
-  return INT2FIX(xpop->type);
+  rxml_xpath_object *rxpop;
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  return INT2FIX(rxpop->xpop->type);
 }
 
 /*
@@ -265,14 +271,14 @@ static VALUE rxml_xpath_object_get_type(VALUE self)
  */
 static VALUE rxml_xpath_object_string(VALUE self)
 {
-  xmlXPathObjectPtr xpop;
+  rxml_xpath_object *rxpop;
 
-  Data_Get_Struct(self, xmlXPathObject, xpop);
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
 
-  if (xpop->stringval == NULL)
+  if (rxpop->xpop->stringval == NULL)
     return Qnil;
 
-  return rb_str_new2((const char*) xpop->stringval);
+  return rb_str_new2((const char*) rxpop->xpop->stringval);
 }
 
 /*
@@ -285,9 +291,9 @@ static VALUE rxml_xpath_object_string(VALUE self)
 static VALUE rxml_xpath_object_debug(VALUE self)
 {
 #ifdef LIBXML_DEBUG_ENABLED
-  xmlXPathObjectPtr xpop;
-  Data_Get_Struct(self, xmlXPathObject, xpop);
-  xmlXPathDebugDumpObject(stdout, xpop, 0);
+  rxml_xpath_object *rxpop;
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  xmlXPathDebugDumpObject(stdout, rxpop->xpop, 0);
   return Qtrue;
 #else
   rb_warn("libxml was compiled without debugging support.")
@@ -295,6 +301,12 @@ static VALUE rxml_xpath_object_debug(VALUE self)
 #endif
 }
 
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mLibXML = rb_define_module("LibXML");
+  mXPath = rb_define_module_under(mLibXML, "XPath");
+#endif
+
 void ruby_init_xml_xpath_object(void)
 {
   cXMLXPathObject = rb_define_class_under(mXPath, "Object", rb_cObject);