nokogiri 1.0.0 → 1.6.8.1

data/ext/nokogiri/xslt_stylesheet.c

@@ -3,12 +3,56 @@
 #include <libxslt/xsltInternals.h>
 #include <libxslt/xsltutils.h>
 #include <libxslt/transform.h>
+#include <libexslt/exslt.h>
 
-static void dealloc(xsltStylesheetPtr doc)
+VALUE xslt;
+
+int vasprintf (char **strp, const char *fmt, va_list ap);
+void vasprintf_free (void *p);
+
+static void mark(nokogiriXsltStylesheetTuple *wrapper)
+{
+  rb_gc_mark(wrapper->func_instances);
+}
+
+static void dealloc(nokogiriXsltStylesheetTuple *wrapper)
 {
+    xsltStylesheetPtr doc = wrapper->ss;
+
     NOKOGIRI_DEBUG_START(doc);
-    xsltFreeStylesheet(doc); // commented out for now.
+    xsltFreeStylesheet(doc); /* commented out for now. */
     NOKOGIRI_DEBUG_END(doc);
+
+    free(wrapper);
+}
+
+static void xslt_generic_error_handler(void * ctx, const char *msg, ...)
+{
+  char * message;
+
+  va_list args;
+  va_start(args, msg);
+  vasprintf(&message, msg, args);
+  va_end(args);
+
+  rb_str_cat2((VALUE)ctx, message);
+
+  vasprintf_free(message);
+}
+
+VALUE Nokogiri_wrap_xslt_stylesheet(xsltStylesheetPtr ss)
+{
+  VALUE self;
+  nokogiriXsltStylesheetTuple *wrapper;
+
+  self = Data_Make_Struct(cNokogiriXsltStylesheet, nokogiriXsltStylesheetTuple,
+                          mark, dealloc, wrapper);
+
+  ss->_private = (void *)self;
+  wrapper->ss = ss;
+  wrapper->func_instances = rb_ary_new();
+
+  return self;
 }
 
 /*
@@ -19,11 +63,27 @@ static void dealloc(xsltStylesheetPtr doc)
  */
 static VALUE parse_stylesheet_doc(VALUE klass, VALUE xmldocobj)
 {
-    xmlDocPtr xml ;
+    xmlDocPtr xml, xml_cpy;
+    VALUE errstr, exception;
     xsltStylesheetPtr ss ;
     Data_Get_Struct(xmldocobj, xmlDoc, xml);
-    ss = xsltParseStylesheetDoc(xmlCopyDoc(xml, 1)); /* 1 => recursive */
-    return Data_Wrap_Struct(klass, NULL, dealloc, ss);
+    exsltRegisterAll();
+
+    errstr = rb_str_new(0, 0);
+    xsltSetGenericErrorFunc((void *)errstr, xslt_generic_error_handler);
+
+    xml_cpy = xmlCopyDoc(xml, 1); /* 1 => recursive */
+    ss = xsltParseStylesheetDoc(xml_cpy);
+
+    xsltSetGenericErrorFunc(NULL, NULL);
+
+    if (!ss) {
+	xmlFreeDoc(xml_cpy);
+	exception = rb_exc_new3(rb_eRuntimeError, errstr);
+	rb_exc_raise(exception);
+    }
+
+    return Nokogiri_wrap_xslt_stylesheet(ss);
 }
 
 
@@ -36,73 +96,175 @@ static VALUE parse_stylesheet_doc(VALUE klass, VALUE xmldocobj)
 static VALUE serialize(VALUE self, VALUE xmlobj)
 {
     xmlDocPtr xml ;
-    xsltStylesheetPtr ss ;
+    nokogiriXsltStylesheetTuple *wrapper;
     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);
+    Data_Get_Struct(self, nokogiriXsltStylesheetTuple, wrapper);
+    xsltSaveResultToString(&doc_ptr, &doc_len, xml, wrapper->ss);
+    rval = NOKOGIRI_STR_NEW(doc_ptr, doc_len);
+    xmlFree(doc_ptr);
     return rval ;
 }
 
+static void swallow_superfluous_xml_errors(void * userdata, xmlErrorPtr error, ...)
+{
+}
 
 /*
  *  call-seq:
- *    apply_to(document, params)
+ *    transform(document, params = [])
  *
  *  Apply an XSLT stylesheet to an XML::Document.
  *  +params+ is an array of strings used as XSLT parameters.
+ *  returns Nokogiri::XML::Document
+ *
+ *  Example:
+ *
+ *    doc   = Nokogiri::XML(File.read(ARGV[0]))
+ *    xslt  = Nokogiri::XSLT(File.read(ARGV[1]))
+ *    puts xslt.transform(doc, ['key', 'value'])
+ *
  */
-static VALUE apply_to(int argc, VALUE* argv, VALUE self)
+static VALUE transform(int argc, VALUE* argv, VALUE self)
 {
-    VALUE xmldoc, paramobj ;
+    VALUE xmldoc, paramobj, errstr, exception ;
     xmlDocPtr xml ;
     xmlDocPtr result ;
-    xsltStylesheetPtr ss ;
+    nokogiriXsltStylesheetTuple *wrapper;
     const char** params ;
-    int param_len, j ;
-    VALUE resultobj ;
+    long param_len, j ;
+    int parse_error_occurred ;
 
     rb_scan_args(argc, argv, "11", &xmldoc, &paramobj);
-    if (paramobj == Qnil) { paramobj = rb_ary_new2(0) ; }
+    if (NIL_P(paramobj)) { paramobj = rb_ary_new2(0L) ; }
+    if (!rb_obj_is_kind_of(xmldoc, cNokogiriXmlDocument))
+      rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::Document");
+
+    /* handle hashes as arguments. */
+    if(T_HASH == TYPE(paramobj)) {
+      paramobj = rb_funcall(paramobj, rb_intern("to_a"), 0);
+      paramobj = rb_funcall(paramobj, rb_intern("flatten"), 0);
+    }
+
+    Check_Type(paramobj, T_ARRAY);
 
     Data_Get_Struct(xmldoc, xmlDoc, xml);
-    Data_Get_Struct(self, xsltStylesheet, ss);
+    Data_Get_Struct(self, nokogiriXsltStylesheetTuple, wrapper);
 
     param_len = RARRAY_LEN(paramobj);
     params = calloc((size_t)param_len+1, sizeof(char*));
     for (j = 0 ; j < param_len ; j++) {
       VALUE entry = rb_ary_entry(paramobj, j);
-      const char * ptr = StringValuePtr(entry);
+      const char * ptr = StringValueCStr(entry);
       params[j] = ptr;
     }
     params[param_len] = 0 ;
 
-    result = xsltApplyStylesheet(ss, xml, params);
+    errstr = rb_str_new(0, 0);
+    xsltSetGenericErrorFunc((void *)errstr, xslt_generic_error_handler);
+    xmlSetGenericErrorFunc(NULL, (xmlGenericErrorFunc)&swallow_superfluous_xml_errors);
+
+    result = xsltApplyStylesheet(wrapper->ss, xml, params);
     free(params);
-    resultobj = Nokogiri_wrap_xml_document(0, result) ;
-    return rb_funcall(self, rb_intern("serialize"), 1, resultobj);
+
+    xsltSetGenericErrorFunc(NULL, NULL);
+    xmlSetGenericErrorFunc(NULL, NULL);
+
+    parse_error_occurred = (Qfalse == rb_funcall(errstr, rb_intern("empty?"), 0));
+
+    if (parse_error_occurred) {
+      exception = rb_exc_new3(rb_eRuntimeError, errstr);
+      rb_exc_raise(exception);
+    }
+
+    return Nokogiri_wrap_xml_document((VALUE)0, result) ;
+}
+
+static void method_caller(xmlXPathParserContextPtr ctxt, int nargs)
+{
+    VALUE handler;
+    const char *function_name;
+    xsltTransformContextPtr transform;
+    const xmlChar *functionURI;
+
+    transform = xsltXPathGetTransformContext(ctxt);
+    functionURI = ctxt->context->functionURI;
+    handler = (VALUE)xsltGetExtData(transform, functionURI);
+    function_name = (const char*)(ctxt->context->function);
+
+    Nokogiri_marshal_xpath_funcall_and_return_values(ctxt, nargs, handler, (const char*)function_name);
+}
+
+static void * initFunc(xsltTransformContextPtr ctxt, const xmlChar *uri)
+{
+    VALUE modules = rb_iv_get(xslt, "@modules");
+    VALUE obj = rb_hash_aref(modules, rb_str_new2((const char *)uri));
+    VALUE args = { Qfalse };
+    VALUE methods = rb_funcall(obj, rb_intern("instance_methods"), 1, args);
+    VALUE inst;
+    nokogiriXsltStylesheetTuple *wrapper;
+    int i;
+
+    for(i = 0; i < RARRAY_LEN(methods); i++) {
+	VALUE method_name = rb_obj_as_string(rb_ary_entry(methods, i));
+	xsltRegisterExtFunction(ctxt,
+          (unsigned char *)StringValueCStr(method_name), uri, method_caller);
+    }
+
+    Data_Get_Struct(ctxt->style->_private, nokogiriXsltStylesheetTuple,
+                    wrapper);
+    inst = rb_class_new_instance(0, NULL, obj);
+    rb_ary_push(wrapper->func_instances, inst);
+
+    return (void *)inst;
+}
+
+static void shutdownFunc(xsltTransformContextPtr ctxt,
+	const xmlChar *uri, void *data)
+{
+    nokogiriXsltStylesheetTuple *wrapper;
+
+    Data_Get_Struct(ctxt->style->_private, nokogiriXsltStylesheetTuple,
+                    wrapper);
+
+    rb_ary_clear(wrapper->func_instances);
+}
+
+/*
+ *  call-seq:
+ *    register(uri, custom_handler_class)
+ *
+ *  Register a class that implements custom XSLT transformation functions.
+ */
+static VALUE registr(VALUE self, VALUE uri, VALUE obj)
+{
+    VALUE modules = rb_iv_get(self, "@modules");
+    if(NIL_P(modules)) rb_raise(rb_eRuntimeError, "wtf! @modules isn't set");
+
+    rb_hash_aset(modules, uri, obj);
+    xsltRegisterExtModule((unsigned char *)StringValueCStr(uri), initFunc, shutdownFunc);
+    return self;
 }
 
 VALUE cNokogiriXsltStylesheet ;
 void init_xslt_stylesheet()
 {
-  /*
-   * HACK.  This is so that rdoc will work with this C file.
-   */
-  /*
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE xslt = rb_define_module_under(nokogiri, "XSLT");
-  VALUE klass = rb_define_class_under(xslt, "Stylesheet", rb_cObject);
-  */
-
-  VALUE klass = cNokogiriXsltStylesheet = rb_const_get(mNokogiriXslt, rb_intern("Stylesheet"));
-    
+  VALUE nokogiri;
+  VALUE klass;
+
+  nokogiri = rb_define_module("Nokogiri");
+  xslt = rb_define_module_under(nokogiri, "XSLT");
+  klass = rb_define_class_under(xslt, "Stylesheet", rb_cObject);
+
+  rb_iv_set(xslt, "@modules", rb_hash_new());
+
+  cNokogiriXsltStylesheet = klass;
+
   rb_define_singleton_method(klass, "parse_stylesheet_doc", parse_stylesheet_doc, 1);
+  rb_define_singleton_method(xslt, "register", registr, 2);
   rb_define_method(klass, "serialize", serialize, 1);
-  rb_define_method(klass, "apply_to", apply_to, -1);
+  rb_define_method(klass, "transform", transform, -1);
 }

data/ext/nokogiri/xslt_stylesheet.h

@@ -1,9 +1,14 @@
 #ifndef NOKOGIRI_XSLT_STYLESHEET
 #define NOKOGIRI_XSLT_STYLESHEET
 
-#include <native.h>
+#include <nokogiri.h>
 
 void init_xslt_stylesheet();
 
 extern VALUE cNokogiriXsltStylesheet ;
+
+typedef struct _nokogiriXsltStylesheetTuple {
+  xsltStylesheetPtr ss;
+  VALUE func_instances;
+} nokogiriXsltStylesheetTuple;
 #endif

data/lib/nokogiri/css/node.rb

@@ -1,78 +1,33 @@
 module Nokogiri
   module CSS
     class Node
-      attr_accessor :type, :value
+      ALLOW_COMBINATOR_ON_SELF = [:DIRECT_ADJACENT_SELECTOR, :FOLLOWING_SELECTOR, :CHILD_SELECTOR]
+
+      # Get the type of this node
+      attr_accessor :type
+      # Get the value of this node
+      attr_accessor :value
+
+      # Create a new Node with +type+ and +value+
       def initialize type, value
         @type = type
         @value = value
       end
 
+      # Accept +visitor+
       def accept visitor
         visitor.send(:"visit_#{type.to_s.downcase}", self)
       end
 
-      def to_xpath prefix = '//', preprocess = true
-        self.preprocess! if preprocess
-        prefix + XPathVisitor.new.accept(self)
-      end
-
-      def preprocess!
-        ### Deal with nth-child
-        matches = find_by_type(
-          [:CONDITIONAL_SELECTOR,
-            [:ELEMENT_NAME],
-            [:PSEUDO_CLASS,
-              [:FUNCTION]
-            ]
-          ]
-        )
-        matches.each do |match|
-          if match.value[1].value[0].value[0] =~ /^nth-child/
-            tag_name = match.value[0].value.first
-            match.value[0].value = ['*']
-            match.value[1] = Node.new(:COMBINATOR, [
-              match.value[1].value[0],
-              Node.new(:FUNCTION, ['self(', tag_name])
-            ])
-          end
-          if match.value[1].value[0].value[0] =~ /^nth-last-child/
-            tag_name = match.value[0].value.first
-            match.value[0].value = ['*']
-            match.value[1] = Node.new(:COMBINATOR, [
-              match.value[1].value[0],
-              Node.new(:FUNCTION, ['self(', tag_name])
-            ])
-          end
-        end
-
-        ### Deal with first-child, last-child
-        matches = find_by_type(
-          [:CONDITIONAL_SELECTOR,
-            [:ELEMENT_NAME], [:PSEUDO_CLASS]
-        ])
-        matches.each do |match|
-          if ['first-child', 'last-child'].include?(match.value[1].value.first)
-            which = match.value[1].value.first.gsub(/-\w*$/, '')
-            tag_name = match.value[0].value.first
-            match.value[0].value = ['*']
-            match.value[1] = Node.new(:COMBINATOR, [
-              Node.new(:FUNCTION, ["#{which}("]),
-              Node.new(:FUNCTION, ['self(', tag_name])
-            ])
-          elsif 'only-child' == match.value[1].value.first
-            tag_name = match.value[0].value.first
-            match.value[0].value = ['*']
-            match.value[1] = Node.new(:COMBINATOR, [
-              Node.new(:FUNCTION, ["#{match.value[1].value.first}("]),
-              Node.new(:FUNCTION, ['self(', tag_name])
-            ])                                        
-          end
-        end
-
-        self
+      ###
+      # Convert this CSS node to xpath with +prefix+ using +visitor+
+      def to_xpath prefix = '//', visitor = XPathVisitor.new
+        prefix = '.' if ALLOW_COMBINATOR_ON_SELF.include?(type) && value.first.nil?
+        prefix + visitor.accept(self)
       end
 
-      def find_by_type(types)
+      # Find a node by type using +types+
+      def find_by_type types
         matches = []
         matches << self if to_type == types
         @value.each do |v|
@@ -81,12 +36,14 @@ module Nokogiri
         matches
       end
 
+      # Convert to_type
       def to_type
         [@type] + @value.map { |n|
           n.to_type if n.respond_to?(:to_type)
         }.compact
       end
 
+      # Convert to array
       def to_a
         [@type] + @value.map { |n| n.respond_to?(:to_a) ? n.to_a : [n] }
       end