libxml-ruby 0.6.0-x86-mswin32-60

data/ext/libxml/ruby_xml_xpath.h

@@ -0,0 +1,23 @@
+/* $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

data/ext/libxml/ruby_xml_xpath_context.c

@@ -0,0 +1,118 @@
+/* $Id: ruby_xml_xpath_context.c 300 2008-07-01 19:14:15Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_xpath_context.h"
+
+VALUE cXMLXPathContext;
+
+/*
+ * call-seq:
+ *    context.doc => document
+ * 
+ * Obtain the XML::Document associated with this XPath.
+ */
+VALUE
+ruby_xml_xpath_context_doc_get(VALUE self) {
+  xmlXPathContextPtr ctxt;
+  Data_Get_Struct(self, xmlXPathContext, ctxt);
+
+  return ruby_xml_document_wrap(ctxt->doc);
+}
+
+
+void
+ruby_xml_xpath_context_free(xmlXPathContextPtr ctxt) {
+  if (ctxt != 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);
+}
+
+
+VALUE
+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_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);
+
+    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");
+
+    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));
+  }
+
+  return ruby_xml_xpath_context_wrap(ctxt);
+}
+
+/*
+ * call-seq:
+ *    context.register_namespace(prefix, uri) => (true|false)
+ * 
+ * Register the specified namespace URI with the specified prefix
+ * in this context.
+ */
+VALUE
+ruby_xml_xpath_context_register_namespace(VALUE self, VALUE prefix, VALUE uri) {
+  xmlXPathContextPtr ctxt;
+
+  Data_Get_Struct(self, xmlXPathContext, ctxt);
+  if (xmlXPathRegisterNs(ctxt, 
+                         (xmlChar*)StringValuePtr(prefix), 
+                         (xmlChar*)StringValuePtr(uri))
+      == 0) {
+    return(Qtrue);
+  } else {
+    /* Should raise an exception, IMHO (whose?, why shouldnt it? -danj)*/
+    rb_warning("register namespace failed");
+    return(Qfalse);
+  }
+}
+
+// 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_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);
+}

data/ext/libxml/ruby_xml_xpath_context.h

@@ -0,0 +1,20 @@
+/* $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

data/ext/libxml/ruby_xml_xpath_object.c

@@ -0,0 +1,293 @@
+/* $Id: $ */
+
+#include "ruby_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;
+
+
+static VALUE
+ruby_xml_xpath_object_tabref(xmlXPathObjectPtr xpop, int apos) {
+
+  if (apos < 0 )
+    apos=xpop->nodesetval->nodeNr+apos;
+
+  if (apos < 0 || apos+1 > xpop->nodesetval->nodeNr )
+    return Qnil;
+
+  switch(xpop->nodesetval->nodeTab[apos]->type) {
+  case XML_ATTRIBUTE_NODE:
+    return ruby_xml_attr_wrap(cXMLAttr,
+			      (xmlAttrPtr)xpop->nodesetval->nodeTab[apos]);
+    break;
+  default:
+    return ruby_xml_node2_wrap(cXMLNode,
+			       xpop->nodesetval->nodeTab[apos]);
+  }
+}
+
+void
+ruby_xml_xpath_object_mark(xmlXPathObjectPtr xpop)
+{
+  void * xnp;
+  int i;
+
+  if ( xpop->type == XPATH_NODESET && xpop->nodesetval != NULL ) {
+    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)
+{
+  VALUE rval;
+
+  if ( xpop==NULL )
+    return Qnil;
+
+  switch(xpop->type) {
+  case XPATH_NODESET:
+    rval = Data_Wrap_Struct(cXMLXPathObject,
+                            ruby_xml_xpath_object_mark,
+                            ruby_xml_xpath_object_free,
+                            xpop);
+  
+    if (xpop->type == XPATH_NODESET && !((xpop->nodesetval == NULL) || (xpop->nodesetval->nodeNr == 0))) {
+      int i;
+      for (i = 0; i < xpop->nodesetval->nodeNr; i++) {
+        ruby_xml_xpath_object_tabref(xpop, i);
+      }
+    }
+    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(xpop->stringval);
+ 
+    xmlXPathFreeObject(xpop);
+    break;
+  default:
+    xmlXPathFreeObject(xpop);
+    rval=Qnil;
+  }
+  return rval;
+}
+
+
+/*
+ * 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_xpath_object_tabref(xpop, 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;
+
+  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++) {
+    rb_yield(ruby_xml_xpath_object_tabref(xpop,i));
+  }
+  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) {
+  if ( ruby_xml_xpath_object_empty_q(self) == Qtrue )
+    return Qnil;
+  
+  return ruby_xml_xpath_object_tabref((xmlXPathObjectPtr)DATA_PTR(self),0);
+}
+
+/*
+ * call-seq:
+ * xpath_object[i] => node
+ *
+ * array index into set of nodes
+ */
+VALUE
+ruby_xml_xpath_object_aref(VALUE self, VALUE aref) {
+  if ( ruby_xml_xpath_object_empty_q(self) == Qtrue )
+    return Qnil;
+
+  return ruby_xml_xpath_object_tabref((xmlXPathObjectPtr)DATA_PTR(self),
+				      NUM2INT(aref));
+}
+
+/*
+ * 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, "[]", 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")));
+
+  /* Give the NodeSet type, but it is pointless */
+  rb_define_method(cXMLXPathObject, "set", ruby_xml_xpath_object_set, 0);
+  
+}