tenderlove-nokogiri 0.0.0.20081001111445

data/ext/nokogiri/xml_reader.h

@@ -0,0 +1,10 @@
+#ifndef NOKOGIRI_XML_READER
+#define NOKOGIRI_XML_READER
+
+#include <native.h>
+
+void init_xml_reader();
+
+extern VALUE cNokogiriXmlReader;
+
+#endif

data/ext/nokogiri/xml_sax_parser.c

@@ -0,0 +1,161 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <xml_sax_parser.h>
+
+/*
+ * call-seq:
+ *  parse_memory(data)
+ *
+ * Parse the document stored in +data+
+ */
+static VALUE parse_memory(VALUE self, VALUE data)
+{
+  xmlSAXHandlerPtr handler;
+  Data_Get_Struct(self, xmlSAXHandler, handler);
+  xmlSAXUserParseMemory(  handler,
+                          (void *)self,
+                          StringValuePtr(data),
+                          NUM2INT(rb_funcall(data, rb_intern("length"), 0))
+  );
+  return data;
+}
+
+static VALUE native_parse_file(VALUE self, VALUE data)
+{
+  xmlSAXHandlerPtr handler;
+  Data_Get_Struct(self, xmlSAXHandler, handler);
+  xmlSAXUserParseFile(  handler,
+                        (void *)self,
+                        StringValuePtr(data)
+  );
+  return data;
+}
+
+static void start_document(void * ctx)
+{
+  VALUE self = (VALUE)ctx;
+  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
+  rb_funcall(doc, rb_intern("start_document"), 0);
+}
+
+static void end_document(void * ctx)
+{
+  VALUE self = (VALUE)ctx;
+  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
+  rb_funcall(doc, rb_intern("end_document"), 0);
+}
+
+static void start_element(void * ctx, const xmlChar *name, const xmlChar **atts)
+{
+  VALUE self = (VALUE)ctx;
+  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
+  VALUE attributes = rb_ary_new();
+  const xmlChar * attr;
+  int i = 0;
+  if(atts) {
+    while((attr = atts[i]) != NULL) {
+      rb_funcall(attributes, rb_intern("<<"), 1, rb_str_new2((const char *)attr));
+      i++;
+    }
+  }
+
+  rb_funcall( doc,
+              rb_intern("start_element"),
+              2,
+              rb_str_new2((const char *)name),
+              attributes
+  );
+}
+
+static void end_element(void * ctx, const xmlChar *name)
+{
+  VALUE self = (VALUE)ctx;
+  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
+  rb_funcall(doc, rb_intern("end_element"), 1, rb_str_new2((const char *)name));
+}
+
+static void characters_func(void * ctx, const xmlChar * ch, int len)
+{
+  VALUE self = (VALUE)ctx;
+  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
+  VALUE str = rb_str_new((const char *)ch, (long)len);
+  rb_funcall(doc, rb_intern("characters"), 1, str);
+}
+
+static void comment_func(void * ctx, const xmlChar * value)
+{
+  VALUE self = (VALUE)ctx;
+  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
+  VALUE str = rb_str_new2((const char *)value);
+  rb_funcall(doc, rb_intern("comment"), 1, str);
+}
+
+static void warning_func(void * ctx, const char *msg, ...)
+{
+  VALUE self = (VALUE)ctx;
+  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
+  char * message;
+
+  va_list args;
+  va_start(args, msg);
+  vasprintf(&message, msg, args);
+  va_end(args);
+
+  rb_funcall(doc, rb_intern("warning"), 1, rb_str_new2(message));
+  free(message);
+}
+
+static void error_func(void * ctx, const char *msg, ...)
+{
+  VALUE self = (VALUE)ctx;
+  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
+  char * message;
+
+  va_list args;
+  va_start(args, msg);
+  vasprintf(&message, msg, args);
+  va_end(args);
+
+  rb_funcall(doc, rb_intern("error"), 1, rb_str_new2(message));
+  free(message);
+}
+
+static void cdata_block(void * ctx, const xmlChar * value, int len)
+{
+  VALUE self = (VALUE)ctx;
+  VALUE doc = rb_funcall(self, rb_intern("document"), 0);
+  VALUE string = rb_str_new((const char *)value, (long)len);
+  rb_funcall(doc, rb_intern("cdata_block"), 1, string);
+}
+
+static void deallocate(xmlSAXHandlerPtr handler)
+{
+  free(handler);
+}
+
+static VALUE allocate(VALUE klass)
+{
+  xmlSAXHandlerPtr handler = calloc(1, sizeof(xmlSAXHandler));
+
+  handler->startDocument = start_document;
+  handler->endDocument = end_document;
+  handler->startElement = start_element;
+  handler->endElement = end_element;
+  handler->characters = characters_func;
+  handler->comment = comment_func;
+  handler->warning = warning_func;
+  handler->error = error_func;
+  handler->cdataBlock = cdata_block;
+
+  return Data_Wrap_Struct(klass, NULL, deallocate, handler);
+}
+
+VALUE cNokogiriXmlSaxParser ;
+void init_xml_sax_parser()
+{
+  VALUE klass = cNokogiriXmlSaxParser =
+    rb_const_get(mNokogiriXmlSax, rb_intern("Parser"));
+  rb_define_alloc_func(klass, allocate);
+  rb_define_method(klass, "parse_memory", parse_memory, 1);
+  rb_define_private_method(klass, "native_parse_file", native_parse_file, 1);
+}

data/ext/nokogiri/xml_sax_parser.h

@@ -0,0 +1,10 @@
+#ifndef NOKOGIRI_XML_SAX_PARSER
+#define NOKOGIRI_XML_SAX_PARSER
+
+#include <native.h>
+
+void init_xml_sax_parser();
+
+extern VALUE cNokogiriXmlSaxParser ;
+#endif
+

data/ext/nokogiri/xml_text.c

@@ -0,0 +1,25 @@
+#include <xml_text.h>
+
+static void dealloc(xmlNodePtr node)
+{
+  if(node->doc == NULL) xmlFreeNode(node);
+}
+
+static VALUE new(VALUE klass, VALUE string)
+{
+  xmlNodePtr node = xmlNewText((xmlChar *)StringValuePtr(string));
+  VALUE rb_node = Data_Wrap_Struct(klass, NULL, dealloc, node);
+  node->_private = (void *)rb_node;
+
+  if(rb_block_given_p()) rb_yield(rb_node);
+
+  return rb_node;
+}
+
+VALUE cNokogiriXmlText ;
+void init_xml_text()
+{
+  VALUE klass = cNokogiriXmlText = rb_const_get(mNokogiriXml, rb_intern("Text"));
+
+  rb_define_singleton_method(klass, "new", new, 1);
+}

data/ext/nokogiri/xml_text.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_TEXT
+#define NOKOGIRI_XML_TEXT
+
+#include <native.h>
+
+void init_xml_text();
+
+extern VALUE cNokogiriXmlText ;
+#endif

data/ext/nokogiri/xml_xpath.c

@@ -0,0 +1,39 @@
+#include <xml_xpath.h>
+
+static void deallocate(xmlXPathObjectPtr xpath)
+{
+  xmlXPathFreeNodeSetList(xpath); // despite the name, this frees the xpath but not the contained node set
+}
+
+VALUE Nokogiri_wrap_xml_xpath(xmlXPathObjectPtr xpath)
+{
+  return Data_Wrap_Struct(cNokogiriXmlXpath, 0, deallocate, xpath);
+}
+
+/*
+ * call-seq:
+ *  node_set
+ *
+ * Fetch the node set associated with this xpath context.
+ */
+static VALUE node_set(VALUE self)
+{
+  xmlXPathObjectPtr xpath;
+  Data_Get_Struct(self, xmlXPathObject, xpath);
+
+  if (xpath->nodesetval)
+    return Nokogiri_wrap_xml_node_set(xpath->nodesetval);
+
+  return Nokogiri_wrap_xml_node_set(xmlXPathNodeSetCreate(NULL));
+}
+
+VALUE cNokogiriXmlXpath;
+void init_xml_xpath(void)
+{
+  VALUE module = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(module, "XML");
+  VALUE klass = rb_define_class_under(xml, "XPath", rb_cObject);
+
+  cNokogiriXmlXpath = klass;
+  rb_define_method(klass, "node_set", node_set, 0);
+}

data/ext/nokogiri/xml_xpath.h

@@ -0,0 +1,11 @@
+#ifndef NOKOGIRI_XML_XPATH
+#define NOKOGIRI_XML_XPATH
+
+#include <native.h>
+
+void init_xml_xpath();
+VALUE Nokogiri_wrap_xml_xpath(xmlXPathObjectPtr xpath);
+
+extern VALUE cNokogiriXmlXpath;
+#endif
+

data/ext/nokogiri/xml_xpath_context.c

@@ -0,0 +1,69 @@
+#include <xml_xpath_context.h>
+
+static void deallocate(xmlXPathContextPtr ctx)
+{
+  xmlXPathFreeContext(ctx);
+}
+
+/*
+ * call-seq:
+ *  register_ns(prefix, uri)
+ *
+ * Register the namespace with +prefix+ and +uri+.
+ */
+static VALUE register_ns(VALUE self, VALUE prefix, VALUE uri)
+{
+  xmlXPathContextPtr ctx;
+  Data_Get_Struct(self, xmlXPathContext, ctx);
+
+  xmlXPathRegisterNs( ctx,
+                      (const xmlChar *)StringValuePtr(prefix),
+                      (const xmlChar *)StringValuePtr(uri)
+  );
+  return self;
+}
+
+/*
+ * call-seq:
+ *  evaluate(search_path)
+ *
+ * Evaluate the +search_path+ returning an XML::XPath object.
+ */
+static VALUE evaluate(VALUE self, VALUE search_path)
+{
+  xmlXPathContextPtr ctx;
+  Data_Get_Struct(self, xmlXPathContext, ctx);
+
+  xmlChar* query = (xmlChar *)StringValuePtr(search_path);
+  xmlXPathObjectPtr xpath = xmlXPathEvalExpression(query, ctx);
+  if(xpath == NULL) {
+    rb_raise(rb_eRuntimeError, "Couldn't evaluate expression '%s'", query);
+  }
+  return Nokogiri_wrap_xml_xpath(xpath);
+}
+
+static VALUE new(VALUE klass, VALUE nodeobj)
+{
+  xmlXPathInit();
+
+  xmlNodePtr node ;
+  Data_Get_Struct(nodeobj, xmlNode, node);
+
+  xmlXPathContextPtr ctx = xmlXPathNewContext(node->doc);
+  ctx->node = node ;
+  return Data_Wrap_Struct(klass, 0, deallocate, ctx);
+}
+
+VALUE cNokogiriXmlXpathContext;
+void init_xml_xpath_context(void)
+{
+  VALUE module = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(module, "XML");
+  VALUE klass = rb_define_class_under(xml, "XPathContext", rb_cObject);
+
+  cNokogiriXmlXpathContext = klass;
+
+  rb_define_singleton_method(klass, "new", new, 1);
+  rb_define_method(klass, "evaluate", evaluate, 1);
+  rb_define_method(klass, "register_ns", register_ns, 2);
+}

data/ext/nokogiri/xml_xpath_context.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_XPATH_CONTEXT
+#define NOKOGIRI_XML_XPATH_CONTEXT
+
+#include <native.h>
+
+void init_xml_xpath_context();
+
+extern VALUE cNokogiriXmlXpathContext;
+#endif

data/ext/nokogiri/xslt_stylesheet.c

@@ -0,0 +1,83 @@
+#include <xslt_stylesheet.h>
+
+#include "libxslt/xsltInternals.h"
+#include "libxslt/xsltutils.h"
+#include "libxslt/transform.h"
+
+static void dealloc(xsltStylesheetPtr doc)
+{
+    xsltFreeStylesheet(doc); // commented out for now.
+}
+
+static VALUE parse_stylesheet_doc(VALUE klass, VALUE xmldocobj)
+{
+    xmlDocPtr xml ;
+    xsltStylesheetPtr ss ;
+    Data_Get_Struct(xmldocobj, xmlDoc, xml);
+    ss = xsltParseStylesheetDoc(xmlCopyDoc(xml, 1)); /* 1 => recursive */
+    return Data_Wrap_Struct(klass, NULL, dealloc, ss);
+}
+
+
+static VALUE serialize(VALUE self, VALUE xmlobj)
+{
+    xmlDocPtr xml ;
+    xsltStylesheetPtr ss ;
+    xmlChar* doc_ptr ;
+    int doc_len ;
+    VALUE rval ;
+
+    Data_Get_Struct(xmlobj, xmlDoc, xml);
+    Data_Get_Struct(self, xsltStylesheet, ss);
+    xsltSaveResultToString(&doc_ptr, &doc_len, xml, ss);
+    rval = rb_str_new((char*)doc_ptr, doc_len);
+    free(doc_ptr);
+    return rval ;
+}
+
+
+/*
+ *  call-seq:
+ *    apply_to(Nokogiri::XML::Document, params)
+ *
+ *  Apply an XSLT stylesheet to an XML document.
+ *  +params+ is an array of strings.
+ */
+static VALUE apply_to(int argc, VALUE* argv, VALUE self)
+{
+    VALUE xmldoc, paramobj ;
+    xmlDocPtr xml ;
+    xmlDocPtr result ;
+    xsltStylesheetPtr ss ;
+    const char** params ;
+    int param_len, j ;
+    VALUE resultobj ;
+
+    rb_scan_args(argc, argv, "11", &xmldoc, &paramobj);
+    if (paramobj == Qnil) { paramobj = rb_ary_new2(0) ; }
+
+    Data_Get_Struct(xmldoc, xmlDoc, xml);
+    Data_Get_Struct(self, xsltStylesheet, ss);
+
+    param_len = RARRAY_LEN(paramobj);
+    params = calloc((size_t)param_len+1, sizeof(char*));
+    for (j = 0 ; j < param_len ; j++) {
+        params[j] = RSTRING(rb_ary_entry(paramobj, j))->ptr ;
+    }
+    params[param_len] = 0 ;
+
+    result = xsltApplyStylesheet(ss, xml, params);
+    free(params);
+    resultobj = Nokogiri_wrap_xml_document(0, result) ;
+    return rb_funcall(self, rb_intern("serialize"), 1, resultobj);
+}
+
+VALUE cNokogiriXsltStylesheet ;
+void init_xslt_stylesheet()
+{
+  VALUE klass = cNokogiriXsltStylesheet = rb_const_get(mNokogiriXslt, rb_intern("Stylesheet"));
+    
+  rb_define_singleton_method(klass, "parse_stylesheet_doc", parse_stylesheet_doc, 1);
+  rb_define_method(klass, "serialize", serialize, 1);
+  rb_define_method(klass, "apply_to", apply_to, -1);
+}

data/ext/nokogiri/xslt_stylesheet.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XSLT_STYLESHEET
+#define NOKOGIRI_XSLT_STYLESHEET
+
+#include <native.h>
+
+void init_xslt_stylesheet();
+
+extern VALUE cNokogiriXsltStylesheet ;
+#endif