libxml-ruby 0.5.1.0 → 0.5.2.0

data/ext/xml/ruby_xml_xpath.h

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_xpath.h 39 2006-02-21 20:40:16Z roscopeco $ */
+/* $Id: ruby_xml_xpath.h 190 2007-09-28 17:13:52Z danj $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -15,10 +15,9 @@ typedef struct ruby_xml_xpath {
 } ruby_xml_xpath;
 
 void ruby_xml_xpath_free(ruby_xml_xpath *rxxp);
-VALUE ruby_xml_xpath_find(int argc, VALUE *argv, VALUE class);
-VALUE ruby_xml_xpath_find2(int argc, VALUE *argv);
-VALUE ruby_xml_xpath_new(VALUE class, VALUE xd, VALUE xxpc,
-			 xmlXPathObjectPtr xpop);
+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

data/ext/xml/ruby_xml_xpath_context.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_xpath_context.c 138 2007-08-29 18:00:35Z danj $ */
+/* $Id: ruby_xml_xpath_context.c 188 2007-09-24 01:43:21Z danj $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -15,76 +15,68 @@ VALUE cXMLXPathContext;
  */
 VALUE
 ruby_xml_xpath_context_doc_get(VALUE self) {
-  ruby_xml_xpath_context *rxxpc;
-  Data_Get_Struct(self, ruby_xml_xpath_context, rxxpc);
+  xmlXPathContextPtr ctxt;
+  Data_Get_Struct(self, xmlXPathContext, ctxt);
 
-  return(rxxpc->xd);
+  return ruby_xml_document_wrap2(ctxt->doc);
 }
 
 
 void
-ruby_xml_xpath_context_free(ruby_xml_xpath_context *rxxpc) {
-  if (rxxpc->ctxt != NULL) {
-    xmlXPathFreeContext(rxxpc->ctxt);
-    rxxpc->ctxt = NULL;
+ruby_xml_xpath_context_free(xmlXPathContextPtr ctxt) {
+  if (ctxt != NULL) {
+    xmlXPathFreeContext(ctxt);
+    ctxt = NULL;
   }
-
-  free(rxxpc);
 }
 
 
 void
-ruby_xml_xpath_context_mark(ruby_xml_xpath_context *rxxpc) {
-  if (rxxpc == NULL) return;
-  if (!NIL_P(rxxpc->xd)) rb_gc_mark(rxxpc->xd);
-}
-
-
-VALUE
-ruby_xml_xpath_context_new(VALUE class, VALUE xd,
-				 xmlXPathContextPtr xxpc) {
-  ruby_xml_xpath_context *rxxpc;
-
-  rxxpc = ALLOC(ruby_xml_xpath_context);
-  rxxpc->ctxt = xxpc;
-  rxxpc->xd = xd;
-  return(Data_Wrap_Struct(class, ruby_xml_xpath_context_mark,
-			  ruby_xml_xpath_context_free, rxxpc));
+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);
 }
 
 
 VALUE
-ruby_xml_xpath_context_new2(VALUE xd, xmlXPathContextPtr xxpc) {
-  return(ruby_xml_xpath_context_new(cXMLXPathContext, xd, xxpc));
+ruby_xml_xpath_context_wrap(xmlXPathContextPtr ctxt) {
+  return Data_Wrap_Struct(cXMLXPathContext,
+			  ruby_xml_xpath_context_mark,
+			  ruby_xml_xpath_context_free,
+			  ctxt);
 }
 
 
 VALUE
-ruby_xml_xpath_context_new3(VALUE xd) {
+ruby_xml_xpath_context_new(VALUE anode) {
   ruby_xml_document_t *rxd;
+  ruby_xml_node *node;
   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);
 
-  Data_Get_Struct(xd, ruby_xml_document_t, rxd);
-  if (rxd->doc == NULL)
-    return(Qnil);
+    ctxt = xmlXPathNewContext(rxd->doc);
+    if (ctxt == NULL) return(Qnil);
 
-  ctxt = xmlXPathNewContext(rxd->doc);
-  if (ctxt == NULL)
-    return(Qnil);
+  } else if (rb_obj_is_kind_of(anode,cXMLNode) == Qtrue ) {
+    Data_Get_Struct(anode, ruby_xml_node, node);
+    if (node->node->doc == NULL)
+      rb_raise(rb_eTypeError,"Supplied node must be part of a document");
 
-  return(ruby_xml_xpath_context_new2(xd, ctxt));
-}
+    ctxt = xmlXPathNewContext(node->node->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));
+  }
 
-VALUE
-ruby_xml_xpath_context_new4(VALUE rnode) {
-  ruby_xml_node *node;
-
-  Data_Get_Struct(rnode, ruby_xml_node, node);
-  return ruby_xml_xpath_context_new3(ruby_xml_document_wrap(cXMLDocument,node->node->doc));
+  return ruby_xml_xpath_context_wrap(ctxt);
 }
 
-
 /*
  * call-seq:
  *    context.register_namespace(prefix, uri) => (true|false)
@@ -94,16 +86,17 @@ ruby_xml_xpath_context_new4(VALUE rnode) {
  */
 VALUE
 ruby_xml_xpath_context_register_namespace(VALUE self, VALUE prefix, VALUE uri) {
-  ruby_xml_xpath_context *rxxpc;
+  xmlXPathContextPtr ctxt;
 
-  Data_Get_Struct(self, ruby_xml_xpath_context, rxxpc);
-  if (xmlXPathRegisterNs(rxxpc->ctxt, 
+  Data_Get_Struct(self, xmlXPathContext, ctxt);
+  if (xmlXPathRegisterNs(ctxt, 
                          (xmlChar*)StringValuePtr(prefix), 
-                         (xmlChar*)StringValuePtr(uri)) 
-                         == 0) {
+                         (xmlChar*)StringValuePtr(uri))
+      == 0) {
     return(Qtrue);
   } else {
-    /* Should raise an exception, IMHO */
+    /* Should raise an exception, IMHO (whose?, why shouldnt it? -danj)*/
+    rb_warning("register namespace failed");
     return(Qfalse);
   }
 }

data/ext/xml/ruby_xml_xpath_context.h

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_xpath_context.h 41 2006-02-27 12:55:32Z roscopeco $ */
+/* $Id: ruby_xml_xpath_context.h 188 2007-09-24 01:43:21Z danj $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -12,12 +12,8 @@ typedef struct ruby_xml_xpath_context {
   xmlXPathContextPtr ctxt;
 } ruby_xml_xpath_context;
 
-void ruby_xml_xpath_context_free(ruby_xml_xpath_context *rxxpc);
-VALUE ruby_xml_xpath_context_new(VALUE class, VALUE xd,
-				 xmlXPathContextPtr ctxt);
-VALUE ruby_xml_xpath_context_new2(VALUE xd, xmlXPathContextPtr ctxt);
-VALUE ruby_xml_xpath_context_new3(VALUE xd);
-VALUE ruby_xml_xpath_context_new4(VALUE rnode);
+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);
 

data/ext/xml/ruby_xml_xpath_object.c

@@ -0,0 +1,246 @@
+/* $Id: $ */
+
+#include "libxml.h"
+
+/*
+ * Document-class: 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.
+ *
+ */
+VALUE cXMLXPathObject;
+
+void
+ruby_xml_xpath_object_mark(xmlXPathObjectPtr xpop)
+{
+  void * xnp;
+  int i;
+
+  if ( xpop->type == XPATH_NODESET ) {
+    for (i=0; i<xpop->nodesetval->nodeNr; i++) {
+      xnp=xpop->nodesetval->nodeTab[i]->_private;
+      if (xnp != NULL)
+	rb_gc_mark((VALUE)xnp);
+    }
+  }
+}
+
+void
+ruby_xml_xpath_object_free(xmlXPathObjectPtr xpop)
+{
+  xmlXPathFreeObject(xpop);
+}
+
+VALUE
+ruby_xml_xpath_object_wrap(xmlXPathObjectPtr xpop)
+{
+  if ( xpop==NULL )
+    return Qnil;
+
+  return Data_Wrap_Struct(cXMLXPathObject,
+			  ruby_xml_xpath_object_mark,
+			  ruby_xml_xpath_object_free,
+			  xpop);
+}
+
+/*
+ * call-seq:
+ *    xpath_object.to_a => [node, ..., node]
+ * 
+ * Obtain an array of the nodes in this set.
+ */
+VALUE
+ruby_xml_xpath_object_to_a(VALUE self)
+{
+  VALUE set_ary, nodeobj;
+  xmlXPathObjectPtr xpop;
+  int i;
+  
+  Data_Get_Struct(self,xmlXPathObject,xpop);
+
+  set_ary = rb_ary_new();
+  if (!((xpop->nodesetval == NULL) || (xpop->nodesetval->nodeNr == 0))) {
+    for (i = 0; i < xpop->nodesetval->nodeNr; i++) {
+      nodeobj = ruby_xml_node2_wrap(cXMLNode, xpop->nodesetval->nodeTab[i]);
+      rb_ary_push(set_ary, nodeobj);
+    }
+  }
+  
+  return(set_ary);
+}
+
+/*
+ * call-seq:
+ *    xpath_object.set => Node::Set
+ * 
+ * Obtain the previous type object which is really
+ * just a proxy back to this object. Unless the
+ * type is not a NODESET, in which case it is nil.
+ */
+VALUE
+ruby_xml_xpath_object_set(VALUE self)
+{
+  xmlXPathObjectPtr xpop;
+  VALUE r;
+
+  Data_Get_Struct(self,xmlXPathObject,xpop);
+  r=Qnil;
+
+  if (xpop->type == XPATH_NODESET)
+    r=ruby_xml_node_set_new2(self);
+
+  return r;
+}
+
+/*
+ * call-seq:
+ *    xpath_object.empty? => (true|false)
+ *
+ * Determine whether this nodeset is empty (contains no nodes).
+ */
+VALUE
+ruby_xml_xpath_object_empty_q(VALUE self) {
+  xmlXPathObjectPtr xpop;
+
+  Data_Get_Struct(self,xmlXPathObject,xpop);
+
+  if (xpop->type != XPATH_NODESET)
+    return Qnil;
+  
+  return ( xpop->nodesetval == NULL || xpop->nodesetval->nodeNr <= 0 ) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *    xpath_object.each { |node| ... } => self
+ * 
+ * Call the supplied block for each node in this set.
+ */
+VALUE
+ruby_xml_xpath_object_each(VALUE self)
+{
+  xmlXPathObjectPtr xpop;
+  int i;
+  VALUE nodeobj;
+
+  if ( ruby_xml_xpath_object_empty_q(self) == Qtrue )
+    return Qnil;
+
+  Data_Get_Struct(self,xmlXPathObject,xpop);
+
+  for (i = 0; i < xpop->nodesetval->nodeNr; i++) {
+    switch(xpop->nodesetval->nodeTab[i]->type) {
+    case XML_ATTRIBUTE_NODE:
+      nodeobj = ruby_xml_attr_wrap(cXMLAttr,
+				   (xmlAttrPtr)xpop->nodesetval->nodeTab[i]);
+      break;
+    default:
+      nodeobj = ruby_xml_node2_wrap(cXMLNode, xpop->nodesetval->nodeTab[i]);
+    }
+
+    rb_yield(nodeobj);
+  }
+  return(self);
+}
+
+/*
+ * call-seq:
+ *    xpath_object.first => node
+ *
+ * Returns the first node in this node set, or nil if none exist.
+ */
+VALUE
+ruby_xml_xpath_object_first(VALUE self) {
+  VALUE nodeobj;
+
+  xmlXPathObjectPtr xpop;
+
+  if ( ruby_xml_xpath_object_empty_q(self) == Qtrue )
+    return Qnil;
+
+  Data_Get_Struct(self,xmlXPathObject,xpop);
+  
+  switch(xpop->nodesetval->nodeTab[0]->type) {
+  case XML_ATTRIBUTE_NODE:
+    nodeobj = ruby_xml_attr_wrap(cXMLAttr,
+				 (xmlAttrPtr)xpop->nodesetval->nodeTab[0]);
+    break;
+  default:
+    nodeobj = ruby_xml_node2_wrap(cXMLNode,
+				  xpop->nodesetval->nodeTab[0]);
+  }
+  
+  return(nodeobj);
+}
+
+/*
+ * call-seq:
+ *    xpath_object.length => num
+ * 
+ * Obtain the length of the nodesetval node list.
+ */
+VALUE
+ruby_xml_xpath_object_length(VALUE self) {
+  xmlXPathObjectPtr xpop;
+
+  if ( ruby_xml_xpath_object_empty_q(self) == Qtrue )
+    return INT2FIX(0);
+
+  Data_Get_Struct(self,xmlXPathObject,xpop);
+
+  return INT2NUM(xpop->nodesetval->nodeNr);
+}
+
+VALUE
+ruby_xml_xpath_object_set_type(VALUE self)
+{
+  xmlXPathObjectPtr xpop;
+
+  Data_Get_Struct(self,xmlXPathObject,xpop);
+
+  return INT2FIX(xpop->type);
+}
+
+VALUE
+ruby_xml_xpath_object_string(VALUE self)
+{
+  xmlXPathObjectPtr xpop;
+
+  Data_Get_Struct(self,xmlXPathObject,xpop);
+
+  if (xpop->stringval == NULL)
+    return Qnil;
+
+  return rb_str_new2((const char*) xpop->stringval);
+}
+
+// Rdoc needs to know
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+  cXMLXPath = rb_define_class_under(mXML, "XPath", rb_cObject);
+#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")));
+
+  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, "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, "string", ruby_xml_xpath_object_string, 0);
+
+  rb_include_module(cXMLNodeSet, rb_const_get(rb_cObject, rb_intern("Enumerable")));
+
+  /* Give the NodeSet type, but it is pointless */
+  rb_define_method(cXMLXPathObject, "set", ruby_xml_xpath_object_set, 0);
+  
+}

data/ext/xml/ruby_xml_xpath_object.h

@@ -0,0 +1,29 @@
+/* $Id $ */
+
+#ifndef __RUBY_XML_XPATH_OBJECT__
+#define __RUBY_XML_XPATH_OBJECT__
+
+extern VALUE cXMLXPathObject;
+
+typedef struct ruby_xml_xpath_object_s {
+  xmlXPathObjectPtr xpop;
+} ruby_xml_xpath_object;
+
+VALUE ruby_xml_xpath_object_wrap(xmlXPathObjectPtr xpop);
+
+VALUE ruby_xml_xpath_object_to_a(VALUE self);
+VALUE ruby_xml_xpath_object_first(VALUE self);
+VALUE ruby_xml_xpath_object_set(VALUE self);
+VALUE ruby_xml_xpath_object_empty_q(VALUE self);
+VALUE ruby_xml_xpath_object_each(VALUE self);
+VALUE ruby_xml_xpath_object_first(VALUE self);
+VALUE ruby_xml_xpath_object_length(VALUE self);
+VALUE ruby_xml_xpath_object_set_type(VALUE self);
+VALUE ruby_xml_xpath_object_string(VALUE self);
+
+void ruby_xml_xpath_object_mark(xmlXPathObjectPtr xpop);
+void ruby_xml_xpath_object_free(xmlXPathObjectPtr xpop);
+
+void ruby_init_xml_xpath_object(void);
+
+#endif