fastxml 0.1.91

data/ext/fastxml.h

@@ -0,0 +1,61 @@
+/*
+ *  $Id$
+ */
+
+#ifndef fastxml_h
+#define fastxml_h
+
+#include <ruby.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+#include <libxslt/xslt.h>
+#include <libxslt/xsltInternals.h>
+#include <libxml/HTMLparser.h> 
+
+#ifndef XML_WITH_TREE
+	#define XML_WITH_TREE 2
+	#define XML_WITH_XPATH 16
+#endif
+
+#ifndef HTML_PARSE_RECOVER
+    #define HTML_PARSE_RECOVER 1
+#endif
+
+typedef struct {
+    xmlDocPtr doc;
+    xmlNodePtr node;
+	xmlNodePtr list;
+    xmlXPathObjectPtr xpath_obj;     
+	xsltStylesheetPtr xslt;
+	int list_len;
+} fxml_data_t;
+
+
+#ifndef fastxml_c
+RUBY_EXTERN VALUE rb_cFastXmlDoc;
+RUBY_EXTERN VALUE rb_cFastXmlNode;
+RUBY_EXTERN VALUE rb_cFastXmlAttrList;
+
+RUBY_EXTERN VALUE rb_sValidateDtd;
+RUBY_EXTERN VALUE rb_sForgivingParse;
+RUBY_EXTERN VALUE rb_sHtmlParse;
+
+RUBY_EXTERN ID s_readlines;
+RUBY_EXTERN ID s_to_s;
+
+RUBY_EXTERN VALUE fastxml_xpath_search(VALUE self, VALUE raw_xpath, VALUE blk);
+RUBY_EXTERN VALUE fastxml_raw_node_to_obj(xmlNodePtr cur);
+RUBY_EXTERN VALUE fastxml_nodeset_to_obj(xmlXPathObjectPtr xpath_obj, fxml_data_t *data);
+RUBY_EXTERN VALUE fastxml_nodelist_to_obj(xmlNodePtr root, int len);
+RUBY_EXTERN void fastxml_data_mark( fxml_data_t *data );
+RUBY_EXTERN void fastxml_data_free( fxml_data_t *data );
+#endif
+#endif /* fastxml_h */

data/ext/fastxml_attrlist.c

@@ -0,0 +1,60 @@
+/*
+ *  $Id$
+ */
+
+#include "fastxml.h"
+#include "fastxml_node.h"
+#include "fastxml_doc.h"
+#include "fastxml_nodelist.h"
+#include "fastxml_attrlist.h"
+
+/* {{{ fastml_attr_list
+*/
+
+VALUE fastxml_attrlist_initialize(VALUE self)
+{
+    return self;
+}
+
+VALUE fastxml_attrlist_indexer(VALUE self, VALUE attr_name)
+{
+	VALUE ret, dv, attr_raw_str;
+	fxml_data_t *data;
+	xmlChar *raw_ret, *name_str;
+	
+	dv = rb_iv_get( self, "@lxml_doc" );
+	Data_Get_Struct( dv, fxml_data_t, data );
+	
+	attr_raw_str = rb_funcall( attr_name, s_to_s, 0 );
+	name_str = (xmlChar*)StringValuePtr( attr_raw_str );
+	raw_ret = xmlGetProp( data->node, name_str );
+	if (raw_ret == NULL)
+		return Qnil;
+		
+	ret = rb_str_new2( (const char*)raw_ret );
+	xmlFree( raw_ret );
+	
+	return ret;
+}
+
+VALUE fastxml_attrlist_indexer_set(VALUE self, VALUE attr_name, VALUE attr_value)
+{
+	VALUE dv, attr_raw_str;
+	fxml_data_t *data;
+	xmlChar *val, *name_str;
+	
+	dv = rb_iv_get( self, "@lxml_doc" );
+	Data_Get_Struct( dv, fxml_data_t, data );
+	
+	attr_raw_str = rb_funcall( attr_name, s_to_s, 0 );
+	name_str = (xmlChar*)StringValuePtr( attr_raw_str );
+	val = (xmlChar*)StringValuePtr( attr_value );
+
+    xmlSetProp( data->node, name_str, val );
+
+	return attr_value;
+}
+
+
+/* }}} fastxml_attr_list
+*/

data/ext/fastxml_attrlist.h

@@ -0,0 +1,11 @@
+/*
+ * $Id$
+ */
+
+#ifndef fastxml_attrlist_h
+#define fastxml_attrlist_h
+
+RUBY_EXTERN VALUE fastxml_attrlist_initialize(VALUE self);
+RUBY_EXTERN VALUE fastxml_attrlist_indexer(VALUE self, VALUE idx);
+RUBY_EXTERN VALUE fastxml_attrlist_indexer_set(VALUE self, VALUE idx, VALUE val);
+#endif

data/ext/fastxml_doc.c

@@ -0,0 +1,190 @@
+/*
+ *  $Id$
+ */
+#include "fastxml.h"
+#include "fastxml_node.h"
+#include "fastxml_doc.h"
+#include "fastxml_nodelist.h"
+
+
+/* {{{ fastxml_doc 
+ */
+VALUE fastxml_doc_inspect(VALUE self)
+{
+    VALUE *argv;
+    argv = ALLOCA_N( VALUE, 3 );
+    argv[0] = rb_str_new2( "#<%s:0x%x %s>" );
+    argv[1] = CLASS_OF( self );
+    argv[2] = rb_obj_id( self );
+	argv[3] = fastxml_doc_to_s( self );
+
+    return rb_f_sprintf( 4, argv );
+}
+
+VALUE fastxml_doc_children(VALUE self)
+{
+	VALUE dv;
+    fxml_data_t *data;
+
+    dv = rb_iv_get( self, "@lxml_doc" );    
+    Data_Get_Struct( dv, fxml_data_t, data );
+
+	if (data->doc->children == NULL)
+		return Qnil;
+	
+	return fastxml_nodelist_to_obj( data->doc->children, -1 );
+}
+
+VALUE fastxml_doc_stylesheet(VALUE self)
+{
+	return rb_iv_get( self, "@lxml_style" );
+}
+
+VALUE fastxml_doc_stylesheet_set(VALUE self, VALUE style)
+{
+	VALUE dv, xslt_doc;
+	fxml_data_t *data;
+
+    xslt_doc = rb_class_new_instance(1, &style, rb_cFastXmlDoc );
+	
+    dv = rb_iv_get( xslt_doc, "@lxml_doc" );    
+    Data_Get_Struct( dv, fxml_data_t, data );
+	data->xslt = xsltParseStylesheetDoc( data->doc );
+	rb_iv_set( self, "@lxml_style", xslt_doc );
+	
+	return Qnil;	
+}
+
+VALUE fastxml_doc_transform(VALUE self, VALUE xform)
+{
+	VALUE ret, dv, xform_dv, ret_str, ret_dv;
+	fxml_data_t *my_data, *xf_data, *ret_data;
+	xmlDocPtr ret_doc;
+
+	if (xform == Qnil)
+		return Qnil;
+	
+    dv = rb_iv_get( self, "@lxml_doc" );    
+    Data_Get_Struct( dv, fxml_data_t, my_data );
+	xform_dv = rb_iv_get( xform, "@lxml_doc" );
+	Data_Get_Struct( xform_dv, fxml_data_t, xf_data );
+	
+	if (xf_data->xslt == NULL)
+		return Qnil;
+
+	ret_doc = (xmlDocPtr)xsltApplyStylesheet( xf_data->xslt, my_data->doc, NULL );
+	ret_str = rb_str_new2( "<shouldNeverBeSeen/>" );
+	ret = rb_class_new_instance( 1, &ret_str, rb_cFastXmlDoc );
+	ret_dv = rb_iv_get( ret, "@lxml_doc" );
+	Data_Get_Struct( ret_dv, fxml_data_t, ret_data );
+	xmlFree( ret_data->doc );
+	ret_data->doc = ret_doc;
+	
+	return ret;
+}
+
+VALUE fastxml_doc_search(VALUE self, VALUE raw_xpath, VALUE blk)
+{
+	return fastxml_xpath_search( self, raw_xpath, blk );
+}
+
+VALUE fastxml_doc_to_s(VALUE self)
+{
+    VALUE ret, dv;
+    xmlChar *xs;
+    fxml_data_t *data;
+    int xs_len;
+
+    dv = rb_iv_get( self, "@lxml_doc" );
+    Data_Get_Struct( dv, fxml_data_t, data );
+
+    xmlDocDumpFormatMemory( data->doc, &xs, &xs_len, 0 );
+
+    ret = rb_str_new( (const char*)xs, xs_len );
+    xmlFree( xs );
+
+    return ret; 
+}
+
+VALUE fastxml_doc_root(VALUE self)
+{
+    VALUE dv;
+    fxml_data_t *data;
+    xmlNodePtr root;
+
+    dv = rb_iv_get( self, "@lxml_doc" );
+    Data_Get_Struct( dv, fxml_data_t, data );
+
+    root = xmlDocGetRootElement( data->doc );
+
+    return fastxml_raw_node_to_obj( root );
+}
+
+VALUE fastxml_doc_initialize(int argc, VALUE* argv, VALUE self)
+{
+    VALUE data_s, dv, lines, xml_doc_str, opts, blk;
+    fxml_data_t *data;
+    int parser_opts = XML_PARSE_NOERROR | XML_PARSE_NOWARNING;
+    short html_parser = 0;
+
+    if (rb_scan_args( argc, argv, "11&", &xml_doc_str, &opts, &blk ) == 0)
+        return Qnil; // error state
+
+    if (NIL_P(xml_doc_str)) {
+        rb_raise(rb_eArgError, "nil passed as xml document");
+        return Qnil;
+    }
+
+    if (opts != Qnil) {
+        if (rb_hash_aref(opts, rb_sValidateDtd) == Qtrue) {
+            parser_opts = parser_opts | XML_PARSE_DTDLOAD | XML_PARSE_DTDATTR | XML_PARSE_DTDVALID;
+			rb_iv_set( self, "@validate_dtd", Qtrue );
+        }
+
+        if (rb_hash_aref(opts, rb_sForgivingParse) == Qtrue) {
+            parser_opts = parser_opts | XML_PARSE_RECOVER;
+			rb_iv_set( self, "@forgiving", Qtrue );
+		}
+
+        if (rb_hash_aref(opts, rb_sHtmlParse) == Qtrue) {
+            html_parser = 1;
+        }
+    }
+
+	if (rb_respond_to( xml_doc_str, s_readlines )) {
+		lines = rb_funcall( xml_doc_str, s_readlines, 0 );
+		data_s = rb_funcall( lines, s_to_s, 0 );
+	}
+	else
+    	data_s = rb_obj_as_string( xml_doc_str );
+    
+	rb_iv_set( self, "@raw_data", data_s );
+
+    data = ALLOC(fxml_data_t);
+    memset( data, (int)NULL, sizeof(fxml_data_t) );
+
+    if (html_parser == 0)
+        data->doc = xmlReadMemory( RSTRING(data_s)->ptr, RSTRING(data_s)->len, 
+                               "noname.xml", NULL, parser_opts );
+    else
+        data->doc = htmlReadMemory( RSTRING(data_s)->ptr, RSTRING(data_s)->len,
+                                    "noname.html", NULL, HTML_PARSE_RECOVER | HTML_PARSE_NOERROR | HTML_PARSE_NOWARNING );
+
+    // if we're mallformed we might want to use xmlRecoverMemcory(char*, int)
+    if (data->doc == NULL) {
+        rb_raise( rb_eRuntimeError, "Failed to parse document" );
+	    return Qnil;
+    }
+    
+    dv = Data_Wrap_Struct( rb_cObject, fastxml_data_mark, fastxml_data_free, data );
+    rb_iv_set(self, "@lxml_doc", dv );
+
+    if (blk != Qnil)
+        rb_yield( self );
+
+    return self;
+}
+
+
+/* }}} fastxml_doc 
+ */

data/ext/fastxml_doc.h

@@ -0,0 +1,16 @@
+/*
+ * $Id$
+ */
+
+#ifndef fastxml_doc_h
+#define fastxml_doc_h
+RUBY_EXTERN VALUE fastxml_doc_initialize(int argc, VALUE* argv, VALUE self);
+RUBY_EXTERN VALUE fastxml_doc_search(VALUE self, VALUE raw_xpath, VALUE blk);
+RUBY_EXTERN VALUE fastxml_doc_to_s(VALUE self);
+RUBY_EXTERN VALUE fastxml_doc_root(VALUE self);
+RUBY_EXTERN VALUE fastxml_doc_transform(VALUE self, VALUE xform);
+RUBY_EXTERN VALUE fastxml_doc_stylesheet(VALUE self);
+RUBY_EXTERN VALUE fastxml_doc_stylesheet_set(VALUE self, VALUE style);
+RUBY_EXTERN VALUE fastxml_doc_children(VALUE self);
+RUBY_EXTERN VALUE fastxml_doc_inspect(VALUE self);
+#endif

data/ext/fastxml_node.c

@@ -0,0 +1,240 @@
+/*
+ *  $Id$
+ */
+
+#include "fastxml.h"
+#include "fastxml_node.h"
+#include "fastxml_doc.h"
+#include "fastxml_nodelist.h"
+
+/* {{{ fastxml_node 
+ */
+
+VALUE fastxml_node_inspect(VALUE self)
+{
+    VALUE dv;
+    VALUE *argv;
+    fxml_data_t *data;
+
+    dv = rb_iv_get( self, "@lxml_doc" );    
+    Data_Get_Struct( dv, fxml_data_t, data );
+
+    argv = ALLOCA_N( VALUE, 4 );
+    argv[0] = rb_str_new2( "#<%s:0x%x %s>" );
+    argv[1] = CLASS_OF( self );
+    argv[2] = rb_obj_id( self );
+    argv[3] = rb_str_new2( (char*) data->node->name );
+    return rb_f_sprintf( 4, argv );
+}
+
+VALUE fastxml_node_initialize(VALUE self)
+{
+    return self;
+}
+
+VALUE fastxml_node_innerxml(VALUE self)
+{
+	VALUE dv, ret;
+    fxml_data_t *data;
+	xmlBufferPtr buf = xmlBufferCreate();
+
+    dv = rb_iv_get( self, "@lxml_doc" );    
+    Data_Get_Struct( dv, fxml_data_t, data );
+	
+	xmlNodeDump( buf, data->doc, data->node, 0, 0 );
+	ret = rb_str_new2( (char*)xmlBufferContent( buf ) );
+	xmlBufferFree( buf );	
+	
+    return ret;
+}
+
+VALUE fastxml_node_next(VALUE self)
+{
+	VALUE dv, next;
+    fxml_data_t *data;
+
+    dv = rb_iv_get( self, "@lxml_doc" );    
+    Data_Get_Struct( dv, fxml_data_t, data );
+
+	if (data->node == NULL || (data->node != NULL && data->node->next == NULL))
+		return Qnil;
+		
+	next = rb_iv_get( self, "@next" );
+	if (next == Qnil) {
+		next = fastxml_raw_node_to_obj( data->node->next );
+		rb_iv_set( self, "@next", next );
+	}
+	
+	return next;
+}
+
+VALUE fastxml_node_prev(VALUE self)
+{
+	VALUE dv, prev;
+    fxml_data_t *data;
+
+    dv = rb_iv_get( self, "@lxml_doc" );    
+    Data_Get_Struct( dv, fxml_data_t, data );
+
+	if (data->node == NULL || (data->node != NULL && data->node->prev == NULL))
+		return Qnil;
+		
+	prev = rb_iv_get( self, "@prev" );
+	if (prev == Qnil) {
+		prev = fastxml_raw_node_to_obj( data->node->prev );
+		rb_iv_set( self, "@prev", prev );
+	}		
+	
+	return prev;
+}
+
+VALUE fastxml_node_parent(VALUE self)
+{
+	VALUE dv;
+    fxml_data_t *data;
+
+    dv = rb_iv_get( self, "@lxml_doc" );    
+    Data_Get_Struct( dv, fxml_data_t, data );
+
+	if (data->node == NULL || (data->node != NULL && data->node->parent == NULL))
+		return Qnil;
+	
+	return fastxml_raw_node_to_obj( data->node->parent );
+}
+
+VALUE fastxml_node_children(VALUE self)
+{
+	VALUE dv;
+    fxml_data_t *data;
+
+    dv = rb_iv_get( self, "@lxml_doc" );    
+    Data_Get_Struct( dv, fxml_data_t, data );
+
+	if (data->node == NULL || (data->node != NULL && data->node->children == NULL))
+		return Qnil;
+	
+	return fastxml_nodelist_to_obj( data->node->children, -1 );
+}
+
+VALUE fastxml_node_name(VALUE self)
+{
+    VALUE ret, dv;
+    fxml_data_t *data;
+
+    dv = rb_iv_get( self, "@lxml_doc" );    
+    Data_Get_Struct( dv, fxml_data_t, data ); 
+
+    if (data->node == NULL || (data->node != NULL && data->node->name == NULL))
+        return Qnil;
+
+    ret = rb_str_new2( (const char*)data->node->name );
+
+    return ret;
+}
+
+
+VALUE fastxml_node_attr(VALUE self)
+{
+	VALUE self_dv, ret;
+	fxml_data_t *data;
+	xmlChar *raw_ret;
+
+	ret = rb_iv_get( self, "@attrs" );
+	if (ret == Qnil) {
+		self_dv = rb_iv_get( self, "@lxml_doc" );
+		Data_Get_Struct( self_dv, fxml_data_t, data );
+		ret = rb_class_new_instance( 0, 0, rb_cFastXmlAttrList ); 
+
+		rb_iv_set( ret, "@lxml_doc", self_dv );
+    	rb_iv_set( self, "@attrs", ret );
+	}
+
+	return ret;
+}
+
+
+VALUE fastxml_node_xpath(VALUE self)
+{
+	VALUE ret, dv;
+	fxml_data_t *data;
+	xmlChar *raw_ret;
+	
+	dv = rb_iv_get( self, "@lxml_doc" );
+	Data_Get_Struct( dv, fxml_data_t, data );
+	
+	raw_ret = xmlGetNodePath( data->node );
+	if (raw_ret == NULL)
+		return Qnil;
+	
+	ret = rb_str_new2( (const char*)raw_ret );
+	xmlFree( raw_ret );
+	
+	return ret;
+}
+
+VALUE fastxml_node_value_set(VALUE self, VALUE new_val)
+{
+    VALUE dv, val_s;
+    fxml_data_t *data;
+    xmlChar *ents, *spec;
+
+
+    val_s = rb_obj_as_string( new_val );
+    dv = rb_iv_get( self, "@lxml_doc" );    
+    Data_Get_Struct( dv, fxml_data_t, data ); 
+
+    ents = xmlEncodeEntitiesReentrant( data->doc, (const xmlChar*)StringValuePtr(val_s) );
+    spec = xmlEncodeSpecialChars( data->doc, ents );
+
+    xmlNodeSetContent( data->node, spec );
+    xmlFree( ents );
+
+    return new_val;
+}
+
+VALUE fastxml_node_value(VALUE self)
+{
+    VALUE ret, dv;
+    fxml_data_t *data;
+	xmlChar *cont;
+
+    dv = rb_iv_get( self, "@lxml_doc" );    
+    Data_Get_Struct( dv, fxml_data_t, data ); 
+	
+	cont = xmlNodeGetContent( data->node );
+
+    if (cont == NULL)
+        return Qnil;
+
+    ret = rb_str_new2( (const char*)cont );
+
+    return ret;
+}
+
+VALUE fastxml_node_to_s(VALUE self)
+{
+    VALUE ret, dv;
+    fxml_data_t *data;
+    xmlBufferPtr buf;
+
+    dv = rb_iv_get( self, "@lxml_doc" );
+    Data_Get_Struct( dv, fxml_data_t, data );
+
+    buf = xmlBufferCreate();
+    ret = Qnil;
+
+    if (xmlNodeDump(buf, data->doc, data->node, 0, 0) != -1) 
+        ret = rb_str_new( (const char*)buf->content, buf->use );
+
+    xmlBufferFree( buf );
+    return ret;
+}
+
+VALUE fastxml_node_search(VALUE self, VALUE raw_xpath, VALUE blk)
+{
+    return fastxml_xpath_search( self, raw_xpath, blk );
+}
+
+
+/* }}} fastxml_node
+ */