libxml-ruby 0.7.0-x86-mswin32-60 → 0.8.0-x86-mswin32-60

data/ext/libxml/ruby_xml_xpath.h

@@ -1,23 +1,22 @@
-/* $Id: ruby_xml_xpath.h 207 2007-11-14 07:51:46Z danj $ */
-
-/* Please see the LICENSE file for copyright and distribution information */
-
-#ifndef __RUBY_XML_XPATH__
-#define __RUBY_XML_XPATH__
-
-extern VALUE cXMLXPath;
-extern VALUE eXMLXPathInvalidPath;
-
-typedef struct ruby_xml_xpath {
-  VALUE xd;
-  VALUE ctxt;
-  xmlXPathObjectPtr xpop;
-} ruby_xml_xpath;
-
-void ruby_xml_xpath_free(ruby_xml_xpath *rxxp);
-VALUE ruby_xml_xpath_find(VALUE class, VALUE anode, VALUE xpath_expr, VALUE nslist);
-VALUE ruby_xml_xpath_find2(VALUE anode, VALUE xpath_expr, VALUE nslist);
-
-void ruby_init_xml_xpath(void);
-
-#endif
+/* $Id: ruby_xml_xpath.h 418 2008-07-14 16:44:59Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_XPATH__
+#define __RUBY_XML_XPATH__
+
+extern VALUE mXPath;
+extern VALUE eXMLXPathInvalidPath;
+
+typedef struct ruby_xml_xpath {
+  VALUE xd;
+  VALUE ctxt;
+  xmlXPathObjectPtr xpop;
+} ruby_xml_xpath;
+
+void ruby_xml_xpath_free(ruby_xml_xpath *rxxp);
+VALUE ruby_xml_xpath_find(VALUE class, VALUE anode, VALUE xpath_expr, VALUE nslist);
+
+void ruby_init_xml_xpath(void);
+
+#endif

data/ext/libxml/ruby_xml_xpath_context.c

@@ -1,92 +1,94 @@
-/* $Id: ruby_xml_xpath_context.c 351 2008-07-09 19:55:21Z cfis $ */
+/* $Id: ruby_xml_xpath_context.c 461 2008-07-15 21:35:56Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
 #include "ruby_libxml.h"
 #include "ruby_xml_xpath_context.h"
+#include <st.h>
 
-VALUE cXMLXPathContext;
 
 /*
- * call-seq:
- *    context.doc -> document
+ * Document-class: LibXML::XML::XPath::Context
  * 
- * Obtain the XML::Document associated with this XPath.
+ * The XML::XPath::Context class is used to evaluate XPath
+ * expressions.  Generally, you should not directly use this class,
+ * but instead use the XML::Document#find and XML::Node#find methods.
+ *
+ *  doc = XML::Document.string('<header>content</header>')
+ *  context = XPath::Context.new(doc)
+ *  context.node = doc.root  
+ *  context.register_namespaces_from_node(doc.root)
+ *  nodes = context.find('/header')
  */
-VALUE
-ruby_xml_xpath_context_doc_get(VALUE self) {
-  xmlXPathContextPtr ctxt;
-  Data_Get_Struct(self, xmlXPathContext, ctxt);
-
-  return ruby_xml_document_wrap(ctxt->doc);
-}
 
+VALUE cXMLXPathContext;
 
 void
 ruby_xml_xpath_context_free(xmlXPathContextPtr ctxt) {
-  if (ctxt != NULL) {
-    if (ctxt->namespaces != NULL) {
-      xmlFree(ctxt->namespaces);
-      ctxt->namespaces = NULL;
-    }  
-    xmlXPathFreeContext(ctxt);
-    ctxt = NULL;
-  }
-}
-
-
-void
-ruby_xml_xpath_context_mark(xmlXPathContextPtr ctxt) {
-  if (ctxt == NULL ) return;
-  if (ctxt->doc != NULL && ctxt->doc->_private != NULL)
-    rb_gc_mark((VALUE)ctxt->doc->_private);
+  xmlXPathFreeContext(ctxt);
 }
 
 
 VALUE
-ruby_xml_xpath_context_wrap(xmlXPathContextPtr ctxt) {
+ruby_xml_xpath_context_alloc(VALUE klass) {
   return Data_Wrap_Struct(cXMLXPathContext,
-			  ruby_xml_xpath_context_mark,
+			  NULL,
 			  ruby_xml_xpath_context_free,
-			  ctxt);
+			  NULL);
 }
 
-
+/* call-seq:
+ *    XPath::Context.new(node) -> XPath::Context
+ * 
+ * Creates a new XPath context for the specified document.  The
+ * context can then be used to evaluate an XPath expression.
+ *
+ *  doc = XML::Document.string('<header><first>hi</first></header>')
+ *  context = XPath::Context.new(doc)
+ *  nodes = XPath::Object.new('//first', context)
+ *  nodes.length == 1
+ */
 VALUE
-ruby_xml_xpath_context_new(VALUE anode) {
+ruby_xml_xpath_context_initialize(VALUE self, VALUE node) {
   ruby_xml_document_t *rxd;
-  xmlNodePtr xnode;
-  xmlXPathContextPtr ctxt;
-  
-  if (rb_obj_is_kind_of(anode,cXMLDocument) == Qtrue ) {
-    Data_Get_Struct(anode,ruby_xml_document_t,rxd);
-    if (rxd->doc == NULL) return(Qnil);
+  VALUE document;
+  #ifndef LIBXML_XPATH_ENABLED
+  rb_raise(rb_eTypeError, "libxml was not compiled with XPath support.");
+  #endif
 
-    ctxt = xmlXPathNewContext(rxd->doc);
-    if (ctxt == NULL) return(Qnil);
-
-  } else if (rb_obj_is_kind_of(anode,cXMLNode) == Qtrue ) {
-    Data_Get_Struct(anode, xmlNode, xnode);
-    if (xnode->doc == NULL)
-      rb_raise(rb_eTypeError,"Supplied node must be part of a document");
-
-    ctxt = xmlXPathNewContext(xnode->doc);
-    if (ctxt == NULL) return(Qnil);
-
-  } else {
-    rb_raise(rb_eTypeError,"create context requires a document or node. Supplied a %s?",
-	     rb_obj_as_string(anode));
+  if (rb_obj_is_kind_of(node, cXMLNode) == Qtrue)
+  {
+    document = rb_funcall(node, rb_intern("doc"), 0);
+    if NIL_P(document)
+     rb_raise(rb_eTypeError, "Supplied node must belong to a document.");
+  }
+  else if (rb_obj_is_kind_of(node, cXMLDocument) == Qtrue)
+  {
+    document = node;
   }
+  else
+  {
+    rb_raise(rb_eTypeError, "Supplied argument must be a document or node.");
+  }
+  
+  Data_Get_Struct(document, ruby_xml_document_t, rxd);
+  DATA_PTR(self) = xmlXPathNewContext(rxd->doc);
+  
+  /* Save the doc as an attribute, this will expose it to Ruby's GC. */
+  rb_iv_set(self, "@doc", document);    
 
-  return ruby_xml_xpath_context_wrap(ctxt);
+  return self;
 }
 
+
 /*
  * call-seq:
  *    context.register_namespace(prefix, uri) -> (true|false)
  * 
  * Register the specified namespace URI with the specified prefix
  * in this context.
+ 
+ *   context.register_namespace('xi', 'http://www.w3.org/2001/XInclude')
  */
 VALUE
 ruby_xml_xpath_context_register_namespace(VALUE self, VALUE prefix, VALUE uri) {
@@ -105,18 +107,177 @@ ruby_xml_xpath_context_register_namespace(VALUE self, VALUE prefix, VALUE uri) {
   }
 }
 
+/* call-seq:
+ *    context.register_namespaces_from_node(node) -> self
+ * 
+ * Helper method to read in namespaces defined on a node.
+ *
+ *  doc = XML::Document.string('<header><first>hi</first></header>')
+ *  context = XPath::Context.new(doc)
+ *  context.register_namespaces_from_node(doc.root)
+ */
+VALUE
+ruby_xml_xpath_context_register_namespaces_from_node(VALUE self, VALUE node) {
+  xmlXPathContextPtr xctxt;
+  xmlNodePtr xnode;
+  xmlNsPtr *xnsArr;
+
+  Data_Get_Struct(self, xmlXPathContext, xctxt);
+  
+  if (rb_obj_is_kind_of(node, cXMLDocument) == Qtrue)
+  {
+    ruby_xml_document_t *rdoc;
+    Data_Get_Struct(node, ruby_xml_document_t, rdoc);
+    xnode = xmlDocGetRootElement(rdoc->doc);
+  }
+  else if (rb_obj_is_kind_of(node, cXMLNode) == Qtrue)
+  {
+    Data_Get_Struct(node, xmlNode, xnode);
+  }
+  else
+  {
+    rb_raise(rb_eTypeError, "The first argument must be a document or node.");
+  } 
+  
+  xnsArr = xmlGetNsList(xnode->doc, xnode);
+  
+  if (xnsArr)
+  {
+    xmlNsPtr xns = *xnsArr;
+    
+    while (xns) {
+      /* If there is no prefix, then this is the default namespace.
+         Skip it for now. */
+      if (xns->prefix)
+      {
+        VALUE prefix = rb_str_new2(xns->prefix);
+        VALUE uri = rb_str_new2(xns->href);
+        ruby_xml_xpath_context_register_namespace(self, prefix, uri);
+      }
+      xns = xns->next;
+    }
+    xmlFree(xnsArr);
+  }
+    
+  return self;
+}
+
+static int
+iterate_ns_hash(st_data_t prefix, st_data_t uri, st_data_t self)
+{
+  ruby_xml_xpath_context_register_namespace(self, prefix, uri);
+  return ST_CONTINUE;
+}
+
+
+/*
+ * call-seq:
+ *    context.register_namespaces(["prefix:uri"]) -> self
+ * 
+ * Register the specified namespaces in this context.
+ *
+ *   context.register_namespaces('xi:http://www.w3.org/2001/XInclude')
+ *   context.register_namespaces(['xlink:http://www.w3.org/1999/xlink',
+ *                                'xi:http://www.w3.org/2001/XInclude')
+ *   context.register_namespaces('xlink' => 'http://www.w3.org/1999/xlink',
+ *                                  'xi' => 'http://www.w3.org/2001/XInclude')
+ */
+VALUE
+ruby_xml_xpath_context_register_namespaces(VALUE self, VALUE nslist) {
+  char *cp;
+  long i;
+  VALUE rprefix, ruri;
+
+  /* Need to loop through the 2nd argument and iterate through the
+   * list of namespaces that we want to allow */
+  switch (TYPE(nslist)) {
+  case T_STRING:
+    cp = strchr(StringValuePtr(nslist), (int)':');
+    if (cp == NULL) {
+      rprefix = nslist;
+      ruri = Qnil;
+    } else {
+      rprefix = rb_str_new(StringValuePtr(nslist), (int)((long)cp - (long)StringValuePtr(nslist)));
+      ruri = rb_str_new2(&cp[1]);
+    }
+    /* Should test the results of this */
+    ruby_xml_xpath_context_register_namespace(self, rprefix, ruri);
+    break;
+  case T_ARRAY:
+    for (i = 0; i < RARRAY(nslist)->len; i++) {
+      ruby_xml_xpath_context_register_namespaces(self, RARRAY(nslist)->ptr[i]);
+    }
+    break;
+  case T_HASH:
+    st_foreach(RHASH(nslist)->tbl, iterate_ns_hash, self);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Invalid argument type, only accept string, array of strings, or an array of arrays");
+  }
+  return self;
+}
+
+/*
+ * call-seq:
+ *    context.node = node
+ * 
+ * Set the current node used by the XPath engine
+ 
+ *  doc = XML::Document.string('<header><first>hi</first></header>')
+ *  context.node = doc.root.first
+ */
+VALUE
+ruby_xml_xpath_context_node_set(VALUE self, VALUE node) {
+  xmlXPathContextPtr xctxt;
+  xmlNodePtr xnode;
+  
+  Data_Get_Struct(self, xmlXPathContext, xctxt);
+  Data_Get_Struct(node, xmlNode, xnode);
+  xctxt->node = xnode;
+  return node;
+}
+
+/*
+ * call-seq:
+ *    context.find("xpath") -> XML::XPath::Object
+ * 
+ * Find nodes matching the specified XPath expression
+ */
+VALUE
+ruby_xml_xpath_context_find(VALUE self, VALUE xpath_expr) {
+  xmlXPathContextPtr xctxt;
+  xmlXPathObjectPtr xobject;
+  VALUE result;
+
+  Data_Get_Struct(self, xmlXPathContext, xctxt);
+  xobject = xmlXPathEval((xmlChar*)StringValuePtr(xpath_expr), xctxt);
+  
+  if (xobject == NULL)
+    rb_raise(eXMLXPathInvalidPath,
+	     "Invalid XPath expression (expr could not be evaluated)");
+
+  result = ruby_xml_xpath_object_wrap(xobject);
+  rb_iv_set(result, "@context", self);
+  return result;  
+}
+
+
 // Rdoc needs to know 
 #ifdef RDOC_NEVER_DEFINED
-  mXML = rb_define_module("XML");
-  cXMLXPath = rb_define_class_under(mXML, "XPath", rb_cObject);
+  mLibXML = rb_define_module("LibXML");
+  mXML = rb_define_module_under(mLibXML, "XML");
+  mXPath = rb_define_module_under(mXML, "XPath");
 #endif
 
 void
 ruby_init_xml_xpath_context(void) {
-  cXMLXPathContext = rb_define_class_under(cXMLXPath, "Context", rb_cObject);
-
-  rb_define_method(cXMLXPathContext, "register_namespace",
-		   ruby_xml_xpath_context_register_namespace, 2);
-  rb_define_method(cXMLXPathContext, "doc",
-		   ruby_xml_xpath_context_doc_get, 0);
+  cXMLXPathContext = rb_define_class_under(mXPath, "Context", rb_cObject);
+  rb_define_alloc_func(cXMLXPathContext, ruby_xml_xpath_context_alloc);
+  rb_define_method(cXMLXPathContext, "initialize", ruby_xml_xpath_context_initialize, 1);
+  rb_define_method(cXMLXPathContext, "register_namespaces", ruby_xml_xpath_context_register_namespaces, 1);
+  rb_define_method(cXMLXPathContext, "register_namespaces_from_node", ruby_xml_xpath_context_register_namespaces_from_node, 1);
+  rb_define_method(cXMLXPathContext, "register_namespace", ruby_xml_xpath_context_register_namespace, 2);
+  rb_define_method(cXMLXPathContext, "node=", ruby_xml_xpath_context_node_set, 1);
+  rb_define_method(cXMLXPathContext, "find", ruby_xml_xpath_context_find, 1);
+  rb_define_attr(cXMLXPathContext, "doc", 1, 0);
 }

data/ext/libxml/ruby_xml_xpath_context.h

@@ -1,20 +1,15 @@
-/* $Id: ruby_xml_xpath_context.h 207 2007-11-14 07:51:46Z danj $ */
-
-/* Please see the LICENSE file for copyright and distribution information */
-
-#ifndef __RUBY_XML_XPATH_CONTEXT__
-#define __RUBY_XML_XPATH_CONTEXT__
-
-extern VALUE cXMLXPathContext;
-
-typedef struct ruby_xml_xpath_context {
-  VALUE xd;
-  xmlXPathContextPtr ctxt;
-} ruby_xml_xpath_context;
-
-VALUE ruby_xml_xpath_context_wrap(xmlXPathContextPtr ctxt);
-VALUE ruby_xml_xpath_context_new(VALUE anode);
-VALUE ruby_xml_xpath_context_register_namespace(VALUE self, VALUE prefix, VALUE uri);
-void ruby_init_xml_xpath_context(void);
-
-#endif
+/* $Id: ruby_xml_xpath_context.h 412 2008-07-14 08:02:47Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_XPATH_CONTEXT__
+#define __RUBY_XML_XPATH_CONTEXT__
+
+extern VALUE cXMLXPathContext;
+void ruby_init_xml_xpath_context(void);
+
+VALUE ruby_xml_xpath_context_register_namespaces(VALUE self, VALUE nslist);
+VALUE ruby_xml_xpath_context_register_namespaces_from_node(VALUE self, VALUE node);
+VALUE ruby_xml_xpath_context_find(VALUE self, VALUE xpath_expr);
+
+#endif

data/ext/libxml/ruby_xml_xpath_object.c

@@ -3,11 +3,10 @@
 #include "ruby_libxml.h"
 
 /*
- * Document-class: XML::XPath::Object
+ * Document-class: LibXML::XML::XPath::Object
  *
- * All XPath and XPointer evals result in this type.
- * nodeset should become entirely virtual and refer back to
- * this class/data structure.
+ * A collection of nodes returned from the evaluation of an XML::XPath
+ * or XML::XPointer expression. 
  *
  */
 VALUE cXMLXPathObject;
@@ -24,7 +23,7 @@ ruby_xml_xpath_object_tabref(xmlXPathObjectPtr xpop, int apos) {
 
   switch(xpop->nodesetval->nodeTab[apos]->type) {
   case XML_ATTRIBUTE_NODE:
-    return Qnil;//ruby_xml_attr_wrap((xmlAttrPtr)xpop->nodesetval->nodeTab[apos]);
+    return ruby_xml_attr_wrap((xmlAttrPtr)xpop->nodesetval->nodeTab[apos]);
     break;
   default:
     return ruby_xml_node2_wrap(cXMLNode,
@@ -232,8 +231,27 @@ ruby_xml_xpath_object_length(VALUE self) {
   return INT2NUM(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 
+ */
 VALUE
-ruby_xml_xpath_object_set_type(VALUE self)
+ruby_xml_xpath_object_get_type(VALUE self)
 {
   xmlXPathObjectPtr xpop;
 
@@ -242,6 +260,13 @@ ruby_xml_xpath_object_set_type(VALUE self)
   return INT2FIX(xpop->type);
 }
 
+
+/*
+ * call-seq:
+ *    xpath_object.string -> String
+ * 
+ * Returns the original XPath expression as a string.
+ */
 VALUE
 ruby_xml_xpath_object_string(VALUE self)
 {
@@ -255,32 +280,51 @@ ruby_xml_xpath_object_string(VALUE self)
   return rb_str_new2((const char*) xpop->stringval);
 }
 
+/* 
+ * call-seq:
+ *    nodes.debug -> (true|false)
+ * 
+ * Dump libxml debugging information to stdout.
+ * Requires Libxml be compiled with debugging enabled.
+ */
+VALUE
+ruby_xml_xpath_object_debug(VALUE self) {
+  xmlXPathObjectPtr xpop;
+  
+  #ifndef LIBXML_DEBUG_ENABLED
+  rb_raise(rb_eTypeError, "libxml was not compiled with debug support.");
+  #endif
+
+  Data_Get_Struct(self, xmlXPathObject, xpop);
+  xmlXPathDebugDumpObject(stdout, xpop, 0);
+  return Qnil;
+}
+
+
 // Rdoc needs to know
-#ifdef RDOC_NEVER_DEFINED
-  mXML = rb_define_module("XML");
-  cXMLXPath = rb_define_class_under(mXML, "XPath", rb_cObject);
-#endif
+#ifdef RDOC_NEVER_DEFINED
+  mLibXML = rb_define_module("LibXML");
+  mXML = rb_define_module_under(mLibXML, "XML");
+  mXPath = rb_define_module_under(mXML, "XPath");
+#endif
 
 void
 ruby_init_xml_xpath_object(void) {
-  cXMLXPathObject = rb_define_class_under(cXMLXPath, "Object", rb_cObject);
-
-  rb_include_module(cXMLXPathObject, rb_const_get(rb_cObject, rb_intern("Enumerable")));
+  cXMLXPathObject = rb_define_class_under(mXPath, "Object", rb_cObject);
+  rb_include_module(cXMLXPathObject, rb_mEnumerable);
 
   rb_define_method(cXMLXPathObject, "each", ruby_xml_xpath_object_each, 0);
-  rb_define_method(cXMLXPathObject, "set_type", ruby_xml_xpath_object_set_type, 0);
+  rb_define_method(cXMLXPathObject, "xpath_type", ruby_xml_xpath_object_get_type, 0);
   rb_define_method(cXMLXPathObject, "empty?", ruby_xml_xpath_object_empty_q, 0);
   rb_define_method(cXMLXPathObject, "first", ruby_xml_xpath_object_first, 0);
   rb_define_method(cXMLXPathObject, "length", ruby_xml_xpath_object_length, 0);
   rb_define_method(cXMLXPathObject, "size", ruby_xml_xpath_object_length, 0);
   rb_define_method(cXMLXPathObject, "to_a", ruby_xml_xpath_object_to_a, 0);
   rb_define_method(cXMLXPathObject, "[]", ruby_xml_xpath_object_aref, 1);
-
   rb_define_method(cXMLXPathObject, "string", ruby_xml_xpath_object_string, 0);
-
-  rb_include_module(cXMLNodeSet, rb_const_get(rb_cObject, rb_intern("Enumerable")));
-
+  rb_define_attr(cXMLXPathObject, "context", 1, 0);
+  rb_define_method(cXMLXPathObject, "debug", ruby_xml_xpath_object_debug, 0);
+  
   /* Give the NodeSet type, but it is pointless */
   rb_define_method(cXMLXPathObject, "set", ruby_xml_xpath_object_set, 0);
-  
 }