libxml-ruby 2.8.0 → 3.2.1

data/ext/libxml/ruby_xml_xpath_context.h

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

data/ext/libxml/ruby_xml_xpath_expression.c

@@ -1,81 +1,81 @@
-/* Please see the LICENSE file for copyright and distribution information */
-
-#include "ruby_libxml.h"
-#include "ruby_xml_xpath.h"
-#include "ruby_xml_xpath_expression.h"
-
-/*
- * Document-class: LibXML::XML::XPath::Expression
- *
- * The XML::XPath::Expression class is used to compile
- * XPath expressions so they can be parsed only once
- * but reused multiple times.
- *
- *  doc = XML::Document.string(IO.read('some xml file'))
- *  expr = XPath::Expression.new('//first')
- *  doc.root.each do |node|
- *   result = node.find(expr) # many, many, many times
- *   # ...
- *  end
- */
-
-VALUE cXMLXPathExpression;
-
-static void rxml_xpath_expression_free(xmlXPathCompExprPtr expr)
-{
-  xmlXPathFreeCompExpr(expr);
-}
-
-static VALUE rxml_xpath_expression_alloc(VALUE klass)
-{
-  return Data_Wrap_Struct(cXMLXPathExpression, NULL,
-      rxml_xpath_expression_free, NULL);
-}
-
-/* call-seq:
- *    XPath::Expression.compile(expression) -> XPath::Expression
- *
- * Compiles an XPatch expression. This improves performance
- * when an XPath expression is called multiple times.
- *
- *  doc = XML::Document.string('<header><first>hi</first></header>')
- *  expr = XPath::Expression.new('//first')
- *  nodes = doc.find(expr)
- */
-static VALUE rxml_xpath_expression_compile(VALUE klass, VALUE expression)
-{
-  VALUE args[] = {expression};
-  return rb_class_new_instance(1, args, cXMLXPathExpression);
-}
-
-/* call-seq:
- *    XPath::Expression.new(expression) -> XPath::Expression
- *
- * Compiles an XPatch expression. This improves performance
- * when an XPath expression is called multiple times.
- *
- *  doc = XML::Document.string('<header><first>hi</first></header>')
- *  expr = XPath::Expression.new('//first')
- *  nodes = doc.find(expr)
- */
-static VALUE rxml_xpath_expression_initialize(VALUE self, VALUE expression)
-{
-  xmlXPathCompExprPtr compexpr = xmlXPathCompile((const xmlChar*)StringValueCStr(expression));
-
-  if (compexpr == NULL)
-  {
-    xmlErrorPtr xerror = xmlGetLastError();
-    rxml_raise(xerror);
-  }
-
-  DATA_PTR( self) = compexpr;
-  return self;
-}
-
-void rxml_init_xpath_expression(void)
-{
-  cXMLXPathExpression = rb_define_class_under(mXPath, "Expression", rb_cObject);
-  rb_define_alloc_func(cXMLXPathExpression, rxml_xpath_expression_alloc);
-  rb_define_singleton_method(cXMLXPathExpression, "compile", rxml_xpath_expression_compile, 1);
-  rb_define_method(cXMLXPathExpression, "initialize", rxml_xpath_expression_initialize, 1);
-}
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_xpath.h"
+#include "ruby_xml_xpath_expression.h"
+
+/*
+ * Document-class: LibXML::XML::XPath::Expression
+ *
+ * The XML::XPath::Expression class is used to compile
+ * XPath expressions so they can be parsed only once
+ * but reused multiple times.
+ *
+ *  doc = XML::Document.string(IO.read('some xml file'))
+ *  expr = XPath::Expression.new('//first')
+ *  doc.root.each do |node|
+ *   result = node.find(expr) # many, many, many times
+ *   # ...
+ *  end
+ */
+
+VALUE cXMLXPathExpression;
+
+static void rxml_xpath_expression_free(xmlXPathCompExprPtr expr)
+{
+  xmlXPathFreeCompExpr(expr);
+}
+
+static VALUE rxml_xpath_expression_alloc(VALUE klass)
+{
+  return Data_Wrap_Struct(cXMLXPathExpression, NULL,
+      rxml_xpath_expression_free, NULL);
+}
+
+/* call-seq:
+ *    XPath::Expression.compile(expression) -> XPath::Expression
+ *
+ * Compiles an XPatch expression. This improves performance
+ * when an XPath expression is called multiple times.
+ *
+ *  doc = XML::Document.string('<header><first>hi</first></header>')
+ *  expr = XPath::Expression.new('//first')
+ *  nodes = doc.find(expr)
+ */
+static VALUE rxml_xpath_expression_compile(VALUE klass, VALUE expression)
+{
+  VALUE args[] = {expression};
+  return rb_class_new_instance(1, args, cXMLXPathExpression);
+}
+
+/* call-seq:
+ *    XPath::Expression.new(expression) -> XPath::Expression
+ *
+ * Compiles an XPatch expression. This improves performance
+ * when an XPath expression is called multiple times.
+ *
+ *  doc = XML::Document.string('<header><first>hi</first></header>')
+ *  expr = XPath::Expression.new('//first')
+ *  nodes = doc.find(expr)
+ */
+static VALUE rxml_xpath_expression_initialize(VALUE self, VALUE expression)
+{
+  xmlXPathCompExprPtr compexpr = xmlXPathCompile((const xmlChar*)StringValueCStr(expression));
+
+  if (compexpr == NULL)
+  {
+    xmlErrorPtr xerror = xmlGetLastError();
+    rxml_raise(xerror);
+  }
+
+  DATA_PTR( self) = compexpr;
+  return self;
+}
+
+void rxml_init_xpath_expression(void)
+{
+  cXMLXPathExpression = rb_define_class_under(mXPath, "Expression", rb_cObject);
+  rb_define_alloc_func(cXMLXPathExpression, rxml_xpath_expression_alloc);
+  rb_define_singleton_method(cXMLXPathExpression, "compile", rxml_xpath_expression_compile, 1);
+  rb_define_method(cXMLXPathExpression, "initialize", rxml_xpath_expression_initialize, 1);
+}

data/ext/libxml/ruby_xml_xpath_expression.h

@@ -1,10 +1,10 @@
-/* Please see the LICENSE file for copyright and distribution information */
-
-#ifndef __RXML_XPATH_EXPRESSION__
-#define __RXML_XPATH_EXPRESSION__
-
-extern VALUE cXMLXPathExpression;
-
-void rxml_init_xpath_expression(void);
-
-#endif
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_XPATH_EXPRESSION__
+#define __RXML_XPATH_EXPRESSION__
+
+extern VALUE cXMLXPathExpression;
+
+void rxml_init_xpath_expression(void);
+
+#endif

data/ext/libxml/ruby_xml_xpath_object.c

@@ -1,335 +1,338 @@
-#include "ruby_libxml.h"
-
-/*
- * Document-class: LibXML::XML::XPath::Object
- *
- * A collection of nodes returned from the evaluation of an XML::XPath
- * or XML::XPointer expression.
- */
-
-VALUE cXMLXPathObject;
-
-
-/* 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.
-
-   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.
-
-   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_free(rxml_xpath_object *rxpop)
-{
-  /* 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)
-  {
-    xmlFree(rxpop->xpop->nodesetval->nodeTab);
-    rxpop->xpop->nodesetval->nodeTab = NULL;
-  }
-  xmlXPathFreeObject(rxpop->xpop);
-  xfree(rxpop);
-}
-
-/* Custom free function for copied namespace nodes */
-static void rxml_xpath_namespace_free(xmlNsPtr xns)
-{
-  xmlFreeNs(xns);
-}
-
-static void rxml_xpath_object_mark(rxml_xpath_object *rxpop)
-{
-  rb_gc_mark(rxpop->nsnodes);
-  if (rxpop->xdoc->_private)
-    rb_gc_mark((VALUE)rxpop->xdoc->_private);
-}
-
-VALUE rxml_xpath_object_wrap(xmlDocPtr xdoc, xmlXPathObjectPtr xpop)
-{
-  int i;
-  rxml_xpath_object *rxpop = ALLOC(rxml_xpath_object);
-  /* Make sure Ruby's GC can find the array in the stack */
-  VALUE nsnodes = rb_ary_new();
-  rxpop->xdoc =xdoc;
-  rxpop->xpop = xpop;
-
-  /* Find all the extra namespace nodes and wrap them. */
-  if (xpop->nodesetval && xpop->nodesetval->nodeNr)
-  {
-    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);
-        RDATA(ns)->dfree = (RUBY_DATA_FUNC)rxml_xpath_namespace_free;
-        rb_ary_push(nsnodes, ns);
-      }
-    }
-  }
-
-  rxpop->nsnodes = nsnodes;
-  return Data_Wrap_Struct(cXMLXPathObject, rxml_xpath_object_mark, rxml_xpath_object_free, rxpop);
-}
-
-static VALUE rxml_xpath_object_tabref(xmlXPathObjectPtr xpop, int index)
-{
-  if (index < 0)
-    index = xpop->nodesetval->nodeNr + index;
-
-  if (index < 0 || index + 1 > xpop->nodesetval->nodeNr)
-    return Qnil;
-
-  switch (xpop->nodesetval->nodeTab[index]->type)
-  {
-  case XML_ATTRIBUTE_NODE:
-    return rxml_attr_wrap((xmlAttrPtr) xpop->nodesetval->nodeTab[index]);
-    break;
-  case XML_NAMESPACE_DECL:
-    return rxml_namespace_wrap((xmlNsPtr)xpop->nodesetval->nodeTab[index]);
-    break;
-  default:
-    return rxml_node_wrap(xpop->nodesetval->nodeTab[index]);
-  }
-}
-
-/*
- * call-seq:
- *    xpath_object.to_a -> [node, ..., node]
- *
- * Obtain an array of the nodes in this set.
- */
-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, 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++)
-    {
-      nodeobj = rxml_xpath_object_tabref(xpop, i);
-      rb_ary_push(set_ary, nodeobj);
-    }
-  }
-
-  return (set_ary);
-}
-
-/*
- * call-seq:
- *    xpath_object.empty? -> (true|false)
- *
- * Determine whether this nodeset is empty (contains no nodes).
- */
-static VALUE rxml_xpath_object_empty_q(VALUE self)
-{
-  rxml_xpath_object *rxpop;
-  Data_Get_Struct(self, rxml_xpath_object, rxpop);
-
-  if (rxpop->xpop->type != XPATH_NODESET)
-    return Qnil;
-
-  return (rxpop->xpop->nodesetval == NULL || rxpop->xpop->nodesetval->nodeNr <= 0) ? Qtrue
-      : Qfalse;
-}
-
-/*
- * call-seq:
- *    xpath_object.each { |node| ... } -> self
- *
- * Call the supplied block for each node in this set.
- */
-static VALUE rxml_xpath_object_each(VALUE self)
-{
-  rxml_xpath_object *rxpop;
-  int i;
-
-  if (rxml_xpath_object_empty_q(self) == Qtrue)
-    return Qnil;
-
-  Data_Get_Struct(self, rxml_xpath_object, rxpop);
-
-  for (i = 0; i < rxpop->xpop->nodesetval->nodeNr; i++)
-  {
-    rb_yield(rxml_xpath_object_tabref(rxpop->xpop, i));
-  }
-  return (self);
-}
-
-/*
- * call-seq:
- *    xpath_object.first -> node
- *
- * Returns the first node in this node set, or nil if none exist.
- */
-static VALUE rxml_xpath_object_first(VALUE self)
-{
-  rxml_xpath_object *rxpop;
-
-  if (rxml_xpath_object_empty_q(self) == Qtrue)
-    return Qnil;
-
-  Data_Get_Struct(self, rxml_xpath_object, rxpop);
-  return rxml_xpath_object_tabref(rxpop->xpop, 0);
-}
-
-/*
- * call-seq:
- *    xpath_object.last -> node
- *
- * Returns the last node in this node set, or nil if none exist.
- */
-static VALUE rxml_xpath_object_last(VALUE self)
-{
-  rxml_xpath_object *rxpop;
-
-  if (rxml_xpath_object_empty_q(self) == Qtrue)
-    return Qnil;
-
-  Data_Get_Struct(self, rxml_xpath_object, rxpop);
-  return rxml_xpath_object_tabref(rxpop->xpop, -1);
-}
-
-/*
- * call-seq:
- * xpath_object[i] -> node
- *
- * array index into set of nodes
- */
-static VALUE rxml_xpath_object_aref(VALUE self, VALUE aref)
-{
-  rxml_xpath_object *rxpop;
-
-  if (rxml_xpath_object_empty_q(self) == Qtrue)
-    return Qnil;
-
-  Data_Get_Struct(self, rxml_xpath_object, rxpop);
-  return rxml_xpath_object_tabref(rxpop->xpop, NUM2INT(aref));
-}
-
-/*
- * call-seq:
- *    xpath_object.length -> num
- *
- * Obtain the length of the nodesetval node list.
- */
-static VALUE rxml_xpath_object_length(VALUE self)
-{
-  rxml_xpath_object *rxpop;
-
-  if (rxml_xpath_object_empty_q(self) == Qtrue)
-    return INT2FIX(0);
-
-  Data_Get_Struct(self, rxml_xpath_object, rxpop);
-  return INT2NUM(rxpop->xpop->nodesetval->nodeNr);
-}
-
-/*
- * call-seq:
- *    xpath_object.xpath_type -> int
- *
- * Returns the XPath type of the result object.
- * Possible values are defined as constants
- * on the XML::XPath class and include:
- *
- * * XML::XPath::UNDEFINED
- * * XML::XPath::NODESET
- * * XML::XPath::BOOLEAN
- * * XML::XPath::NUMBER
- * * XML::XPath::STRING
- * * XML::XPath::POINT
- * * XML::XPath::RANGE
- * * XML::XPath::LOCATIONSET
- * * XML::XPath::USERS
- * * XML::XPath::XSLT_TREE
- */
-static VALUE rxml_xpath_object_get_type(VALUE self)
-{
-  rxml_xpath_object *rxpop;
-  Data_Get_Struct(self, rxml_xpath_object, rxpop);
-  return INT2FIX(rxpop->xpop->type);
-}
-
-/*
- * call-seq:
- *    xpath_object.string -> String
- *
- * Returns the original XPath expression as a string.
- */
-static VALUE rxml_xpath_object_string(VALUE self)
-{
-  rxml_xpath_object *rxpop;
-
-  Data_Get_Struct(self, rxml_xpath_object, rxpop);
-
-  if (rxpop->xpop->stringval == NULL)
-    return Qnil;
-
-  return rxml_new_cstr((const char*) rxpop->xpop->stringval, rxpop->xdoc->encoding);
-}
-
-/*
- * call-seq:
- *    nodes.debug -> (true|false)
- *
- * Dump libxml debugging information to stdout.
- * Requires Libxml be compiled with debugging enabled.
- */
-static VALUE rxml_xpath_object_debug(VALUE self)
-{
-#ifdef LIBXML_DEBUG_ENABLED
-  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.");
-  return Qfalse;
-#endif
-}
-
-void rxml_init_xpath_object(void)
-{
-  cXMLXPathObject = rb_define_class_under(mXPath, "Object", rb_cObject);
-  rb_include_module(cXMLXPathObject, rb_mEnumerable);
-  rb_define_attr(cXMLXPathObject, "context", 1, 0);
-  rb_define_method(cXMLXPathObject, "each", rxml_xpath_object_each, 0);
-  rb_define_method(cXMLXPathObject, "xpath_type", rxml_xpath_object_get_type, 0);
-  rb_define_method(cXMLXPathObject, "empty?", rxml_xpath_object_empty_q, 0);
-  rb_define_method(cXMLXPathObject, "first", rxml_xpath_object_first, 0);
-  rb_define_method(cXMLXPathObject, "last", rxml_xpath_object_last, 0);
-  rb_define_method(cXMLXPathObject, "length", rxml_xpath_object_length, 0);
-  rb_define_method(cXMLXPathObject, "to_a", rxml_xpath_object_to_a, 0);
-  rb_define_method(cXMLXPathObject, "[]", rxml_xpath_object_aref, 1);
-  rb_define_method(cXMLXPathObject, "string", rxml_xpath_object_string, 0);
-  rb_define_method(cXMLXPathObject, "debug", rxml_xpath_object_debug, 0);
-}
+#include "ruby_libxml.h"
+
+/*
+ * Document-class: LibXML::XML::XPath::Object
+ *
+ * A collection of nodes returned from the evaluation of an XML::XPath
+ * or XML::XPointer expression.
+ */
+
+VALUE cXMLXPathObject;
+
+
+/* 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.
+
+   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.
+
+   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_free(rxml_xpath_object *rxpop)
+{
+  /* 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)
+  {
+    xmlFree(rxpop->xpop->nodesetval->nodeTab);
+    rxpop->xpop->nodesetval->nodeTab = NULL;
+  }
+  xmlXPathFreeObject(rxpop->xpop);
+  xfree(rxpop);
+}
+
+/* Custom free function for copied namespace nodes */
+static void rxml_xpath_namespace_free(xmlNsPtr xns)
+{
+  xmlFreeNs(xns);
+}
+
+static void rxml_xpath_object_mark(rxml_xpath_object *rxpop)
+{
+  VALUE doc = (VALUE)rxpop->xdoc->_private;
+  rb_gc_mark(doc);
+  rb_gc_mark(rxpop->nsnodes);
+}
+
+VALUE rxml_xpath_object_wrap(xmlDocPtr xdoc, xmlXPathObjectPtr xpop)
+{
+  int i;
+  rxml_xpath_object *rxpop = ALLOC(rxml_xpath_object);
+
+  /* Make sure Ruby's GC can find the array in the stack */
+  VALUE nsnodes = rb_ary_new();
+  rxpop->xdoc =xdoc;
+  rxpop->xpop = xpop;
+
+  /* Find all the extra namespace nodes and wrap them. */
+  if (xpop->nodesetval && xpop->nodesetval->nodeNr)
+  {
+    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);
+        RDATA(ns)->dfree = (RUBY_DATA_FUNC)rxml_xpath_namespace_free;
+        rb_ary_push(nsnodes, ns);
+      }
+    }
+  }
+
+  rxpop->nsnodes = nsnodes;
+  return Data_Wrap_Struct(cXMLXPathObject, rxml_xpath_object_mark, rxml_xpath_object_free, rxpop);
+}
+
+static VALUE rxml_xpath_object_tabref(xmlXPathObjectPtr xpop, int index)
+{
+  if (index < 0)
+    index = xpop->nodesetval->nodeNr + index;
+
+  if (index < 0 || index + 1 > xpop->nodesetval->nodeNr)
+    return Qnil;
+
+  switch (xpop->nodesetval->nodeTab[index]->type)
+  {
+  case XML_ATTRIBUTE_NODE:
+    return rxml_attr_wrap((xmlAttrPtr) xpop->nodesetval->nodeTab[index]);
+    break;
+  case XML_NAMESPACE_DECL:
+    return rxml_namespace_wrap((xmlNsPtr)xpop->nodesetval->nodeTab[index]);
+    break;
+  default:
+    return rxml_node_wrap(xpop->nodesetval->nodeTab[index]);
+  }
+}
+
+/*
+ * call-seq:
+ *    xpath_object.to_a -> [node, ..., node]
+ *
+ * Obtain an array of the nodes in this set.
+ */
+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, 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++)
+    {
+      nodeobj = rxml_xpath_object_tabref(xpop, i);
+      rb_ary_push(set_ary, nodeobj);
+    }
+  }
+
+  return (set_ary);
+}
+
+/*
+ * call-seq:
+ *    xpath_object.empty? -> (true|false)
+ *
+ * Determine whether this nodeset is empty (contains no nodes).
+ */
+static VALUE rxml_xpath_object_empty_q(VALUE self)
+{
+  rxml_xpath_object *rxpop;
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+
+  if (rxpop->xpop->type != XPATH_NODESET)
+    return Qnil;
+
+  return (rxpop->xpop->nodesetval == NULL || rxpop->xpop->nodesetval->nodeNr <= 0) ? Qtrue
+      : Qfalse;
+}
+
+/*
+ * call-seq:
+ *    xpath_object.each { |node| ... } -> self
+ *
+ * Call the supplied block for each node in this set.
+ */
+static VALUE rxml_xpath_object_each(VALUE self)
+{
+  rxml_xpath_object *rxpop;
+  int i;
+
+  if (rxml_xpath_object_empty_q(self) == Qtrue)
+    return Qnil;
+
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+
+  for (i = 0; i < rxpop->xpop->nodesetval->nodeNr; i++)
+  {
+    rb_yield(rxml_xpath_object_tabref(rxpop->xpop, i));
+  }
+  return (self);
+}
+
+/*
+ * call-seq:
+ *    xpath_object.first -> node
+ *
+ * Returns the first node in this node set, or nil if none exist.
+ */
+static VALUE rxml_xpath_object_first(VALUE self)
+{
+  rxml_xpath_object *rxpop;
+
+  if (rxml_xpath_object_empty_q(self) == Qtrue)
+    return Qnil;
+
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  return rxml_xpath_object_tabref(rxpop->xpop, 0);
+}
+
+/*
+ * call-seq:
+ *    xpath_object.last -> node
+ *
+ * Returns the last node in this node set, or nil if none exist.
+ */
+static VALUE rxml_xpath_object_last(VALUE self)
+{
+  rxml_xpath_object *rxpop;
+
+  if (rxml_xpath_object_empty_q(self) == Qtrue)
+    return Qnil;
+
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  return rxml_xpath_object_tabref(rxpop->xpop, -1);
+}
+
+/*
+ * call-seq:
+ * xpath_object[i] -> node
+ *
+ * array index into set of nodes
+ */
+static VALUE rxml_xpath_object_aref(VALUE self, VALUE aref)
+{
+  rxml_xpath_object *rxpop;
+
+  if (rxml_xpath_object_empty_q(self) == Qtrue)
+    return Qnil;
+
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  return rxml_xpath_object_tabref(rxpop->xpop, NUM2INT(aref));
+}
+
+/*
+ * call-seq:
+ *    xpath_object.length -> num
+ *
+ * Obtain the length of the nodesetval node list.
+ */
+static VALUE rxml_xpath_object_length(VALUE self)
+{
+  rxml_xpath_object *rxpop;
+
+  if (rxml_xpath_object_empty_q(self) == Qtrue)
+    return INT2FIX(0);
+
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  return INT2NUM(rxpop->xpop->nodesetval->nodeNr);
+}
+
+/*
+ * call-seq:
+ *    xpath_object.xpath_type -> int
+ *
+ * Returns the XPath type of the result object.
+ * Possible values are defined as constants
+ * on the XML::XPath class and include:
+ *
+ * * XML::XPath::UNDEFINED
+ * * XML::XPath::NODESET
+ * * XML::XPath::BOOLEAN
+ * * XML::XPath::NUMBER
+ * * XML::XPath::STRING
+ * * XML::XPath::POINT
+ * * XML::XPath::RANGE
+ * * XML::XPath::LOCATIONSET
+ * * XML::XPath::USERS
+ * * XML::XPath::XSLT_TREE
+ */
+static VALUE rxml_xpath_object_get_type(VALUE self)
+{
+  rxml_xpath_object *rxpop;
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+  return INT2FIX(rxpop->xpop->type);
+}
+
+/*
+ * call-seq:
+ *    xpath_object.string -> String
+ *
+ * Returns the original XPath expression as a string.
+ */
+static VALUE rxml_xpath_object_string(VALUE self)
+{
+  rxml_xpath_object *rxpop;
+
+  Data_Get_Struct(self, rxml_xpath_object, rxpop);
+
+  if (rxpop->xpop->stringval == NULL)
+    return Qnil;
+
+  return rxml_new_cstr( rxpop->xpop->stringval, rxpop->xdoc->encoding);
+}
+
+/*
+ * call-seq:
+ *    nodes.debug -> (true|false)
+ *
+ * Dump libxml debugging information to stdout.
+ * Requires Libxml be compiled with debugging enabled.
+ */
+static VALUE rxml_xpath_object_debug(VALUE self)
+{
+#ifdef LIBXML_DEBUG_ENABLED
+  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.");
+  return Qfalse;
+#endif
+}
+
+void rxml_init_xpath_object(void)
+{
+  cXMLXPathObject = rb_define_class_under(mXPath, "Object", rb_cObject);
+  rb_include_module(cXMLXPathObject, rb_mEnumerable);
+  rb_define_attr(cXMLXPathObject, "context", 1, 0);
+  rb_define_method(cXMLXPathObject, "each", rxml_xpath_object_each, 0);
+  rb_define_method(cXMLXPathObject, "xpath_type", rxml_xpath_object_get_type, 0);
+  rb_define_method(cXMLXPathObject, "empty?", rxml_xpath_object_empty_q, 0);
+  rb_define_method(cXMLXPathObject, "first", rxml_xpath_object_first, 0);
+  rb_define_method(cXMLXPathObject, "last", rxml_xpath_object_last, 0);
+  rb_define_method(cXMLXPathObject, "length", rxml_xpath_object_length, 0);
+  rb_define_method(cXMLXPathObject, "to_a", rxml_xpath_object_to_a, 0);
+  rb_define_method(cXMLXPathObject, "[]", rxml_xpath_object_aref, 1);
+  rb_define_method(cXMLXPathObject, "string", rxml_xpath_object_string, 0);
+  rb_define_method(cXMLXPathObject, "debug", rxml_xpath_object_debug, 0);
+  rb_define_alias(cXMLXPathObject, "size", "length");
+
+}