nokogiri 1.2.3-x86-mswin32-60 → 1.4.5-x86-mswin32-60

data/ext/nokogiri/xml_xpath_context.h

@@ -1,7 +1,7 @@
 #ifndef NOKOGIRI_XML_XPATH_CONTEXT
 #define NOKOGIRI_XML_XPATH_CONTEXT
 
-#include <native.h>
+#include <nokogiri.h>
 
 void init_xml_xpath_context();
 

data/ext/nokogiri/xslt_stylesheet.c

@@ -5,13 +5,30 @@
 #include <libxslt/transform.h>
 #include <libexslt/exslt.h>
 
+VALUE xslt;
+
+int vasprintf (char **strp, const char *fmt, va_list ap);
+
 static void dealloc(xsltStylesheetPtr doc)
 {
     NOKOGIRI_DEBUG_START(doc);
-    xsltFreeStylesheet(doc); // commented out for now.
+    xsltFreeStylesheet(doc); /* commented out for now. */
     NOKOGIRI_DEBUG_END(doc);
 }
 
+NORETURN(static void xslt_generic_error_handler(void * ctx, const char *msg, ...));
+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_exc_raise(rb_exc_new2(rb_eRuntimeError, message));
+}
+
 /*
  * call-seq:
  *   parse_stylesheet_doc(document)
@@ -24,7 +41,13 @@ static VALUE parse_stylesheet_doc(VALUE klass, VALUE xmldocobj)
     xsltStylesheetPtr ss ;
     Data_Get_Struct(xmldocobj, xmlDoc, xml);
     exsltRegisterAll();
+
+    xsltSetGenericErrorFunc(NULL, xslt_generic_error_handler);
+
     ss = xsltParseStylesheetDoc(xmlCopyDoc(xml, 1)); /* 1 => recursive */
+
+    xsltSetGenericErrorFunc(NULL, NULL);
+
     return Data_Wrap_Struct(klass, NULL, dealloc, ss);
 }
 
@@ -46,17 +69,25 @@ static VALUE serialize(VALUE self, VALUE xmlobj)
     Data_Get_Struct(xmlobj, xmlDoc, xml);
     Data_Get_Struct(self, xsltStylesheet, ss);
     xsltSaveResultToString(&doc_ptr, &doc_len, xml, ss);
-    rval = NOKOGIRI_STR_NEW(doc_ptr, doc_len, xml->encoding);
+    rval = NOKOGIRI_STR_NEW(doc_ptr, doc_len);
     xmlFree(doc_ptr);
     return rval ;
 }
+
 /*
  *  call-seq:
- *    transform(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 transform(int argc, VALUE* argv, VALUE self)
 {
@@ -65,15 +96,25 @@ static VALUE transform(int argc, VALUE* argv, VALUE self)
     xmlDocPtr result ;
     xsltStylesheetPtr ss ;
     const char** params ;
-    int param_len, j ;
+    long param_len, j ;
 
     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);
 
-    param_len = NUM2INT(rb_funcall(paramobj, rb_intern("length"), 0));
+    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);
@@ -85,34 +126,135 @@ static VALUE transform(int argc, VALUE* argv, VALUE self)
     result = xsltApplyStylesheet(ss, xml, params);
     free(params);
 
-    return Nokogiri_wrap_xml_document(0, result) ;
+    if (!result) rb_raise(rb_eRuntimeError, "could not perform xslt transform on document");
+
+    return Nokogiri_wrap_xml_document((VALUE)0, result) ;
+}
+
+static void method_caller(xmlXPathParserContextPtr ctxt, int nargs)
+{
+    const xmlChar * function;
+    const xmlChar * functionURI;
+    size_t i, count;
+
+    xsltTransformContextPtr transform;
+    xmlXPathObjectPtr xpath;
+    VALUE obj;
+    VALUE *args;
+    VALUE result;
+
+    transform = xsltXPathGetTransformContext(ctxt);
+
+    function = ctxt->context->function;
+    functionURI = ctxt->context->functionURI;
+    obj = (VALUE)xsltGetExtData(transform, functionURI);
+
+    count = (size_t)ctxt->valueNr;
+    args = calloc(count, sizeof(VALUE *));
+
+    for(i = 0; i < count; i++) {
+	VALUE thing;
+
+	xpath = valuePop(ctxt);
+	switch(xpath->type) {
+	    case XPATH_STRING:
+		thing = NOKOGIRI_STR_NEW2(xpath->stringval);
+		break;
+	    case XPATH_NODESET:
+		if(NULL == xpath->nodesetval) {
+		    thing = Nokogiri_wrap_xml_node_set(
+			    xmlXPathNodeSetCreate(NULL),
+			    DOC_RUBY_OBJECT(ctxt->context->doc));
+		} else {
+		    thing = Nokogiri_wrap_xml_node_set(xpath->nodesetval,
+			    DOC_RUBY_OBJECT(ctxt->context->doc));
+		}
+		break;
+	    default:
+		rb_raise(rb_eRuntimeError, "do not handle type: %d", xpath->type);
+	}
+	args[i] = thing;
+    }
+    result = rb_funcall3(obj, rb_intern((const char *)function), (int)count, args);
+    switch(TYPE(result)) {
+	case T_FLOAT:
+	case T_BIGNUM:
+	case T_FIXNUM:
+	    xmlXPathReturnNumber(ctxt, NUM2DBL(result));
+	    break;
+	case T_STRING:
+	    xmlXPathReturnString(
+		    ctxt,
+		    xmlStrdup((xmlChar *)StringValuePtr(result))
+		    );
+	    break;
+	case T_TRUE:
+	    xmlXPathReturnTrue(ctxt);
+	    break;
+	case T_FALSE:
+	    xmlXPathReturnFalse(ctxt);
+	    break;
+	case T_NIL:
+	    break;
+	default:
+	    rb_raise(rb_eRuntimeError, "Invalid return type");
+    }
+}
+
+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);
+    int i;
+
+    for(i = 0; i < RARRAY_LEN(methods); i++) {
+	VALUE method_name = rb_obj_as_string(RARRAY_PTR(methods)[i]);
+	xsltRegisterExtFunction(ctxt,
+          (unsigned char *)StringValuePtr(method_name), uri, method_caller);
+    }
+
+    return (void *)rb_class_new_instance(0, NULL, obj);
+}
+
+static void shutdownFunc(xsltTransformContextPtr ctxt,
+	const xmlChar *uri, void *data)
+{
 }
 
 /*
  *  call-seq:
- *    apply_to(document, params)
+ *    register(uri, custom_handler_class)
  *
- *  Apply an XSLT stylesheet to an XML::Document.
- *  +params+ is an array of strings used as XSLT parameters.
- *  returns serialized document
+ *  Register a class that implements custom XLST transformation functions.
  */
-static VALUE apply_to(int argc, VALUE* argv, VALUE self)
+static VALUE registr(VALUE self, VALUE uri, VALUE obj)
 {
-  return rb_funcall(self, rb_intern("serialize"), 1, 
-                    transform(argc, argv, self));
+    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 *)StringValuePtr(uri), initFunc, shutdownFunc);
+    return self;
 }
 
 VALUE cNokogiriXsltStylesheet ;
 void init_xslt_stylesheet()
 {
-  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 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,7 +1,7 @@
 #ifndef NOKOGIRI_XSLT_STYLESHEET
 #define NOKOGIRI_XSLT_STYLESHEET
 
-#include <native.h>
+#include <nokogiri.h>
 
 void init_xslt_stylesheet();
 

data/lib/nokogiri.rb

@@ -1,19 +1,44 @@
+# -*- coding: utf-8 -*-
 # Modify the PATH on windows so that the external DLLs will get loaded.
+
+require 'rbconfig'
 ENV['PATH'] = [File.expand_path(
   File.join(File.dirname(__FILE__), "..", "ext", "nokogiri")
-), ENV['PATH']].compact.join(';') if RUBY_PLATFORM =~ /mswin/i
+), ENV['PATH']].compact.join(';') if RbConfig::CONFIG['host_os'] =~ /(mswin|mingw)/i
+
+if ENV['NOKOGIRI_FFI'] || RUBY_PLATFORM =~ /java/
+  require 'ffi'
+  require 'nokogiri/ffi/libxml'
+else
+  require 'nokogiri/nokogiri'
+end
+
+warn(<<-eowarn) if '1.8.6' == RUBY_VERSION && $VERBOSE
+!!! DEPRECATION WARNING !!!
+Hey Champ!  I see you're using Ruby 1.8.6!  While I applaud you for sticking to
+your guns and using The One True Ruby, I have to let you know that we're going
+to stop supporting 1.8.6.  I know, it's sad.  But, we just don't have time to
+support every version of Ruby out there.  Whether we like it or not, time moves
+forward and so does our software.
+
+On August 1, 2010, we will no longer support Ruby 1.8.6.  If nokogiri happens to
+work on 1.8.6 after that date, then great!  We will hownever, no longer test,
+use, or endorse 1.8.6 as a supported platform.
 
-require 'nokogiri/native' unless RUBY_PLATFORM =~ /java/
+Thanks,
+
+  Team Nokogiri
+eowarn
 
 require 'nokogiri/version'
+require 'nokogiri/version_warning'
 require 'nokogiri/syntax_error'
 require 'nokogiri/xml'
 require 'nokogiri/xslt'
 require 'nokogiri/html'
-require 'nokogiri/decorators'
+require 'nokogiri/decorators/slop'
 require 'nokogiri/css'
 require 'nokogiri/html/builder'
-require 'nokogiri/hpricot'
 
 # Nokogiri parses and searches XML/HTML very quickly, and also has
 # correctly implemented CSS3 selector support as well as XPath support.
@@ -46,15 +71,23 @@ module Nokogiri
     # Parse an HTML or XML document.  +string+ contains the document.
     def parse string, url = nil, encoding = nil, options = nil
       doc =
-        if string =~ /^\s*<[^Hh>]*html/i # Probably html
-          Nokogiri::HTML.parse(string, url, encoding, options || 2145)
+        if string.respond_to?(:read) ||
+          string =~ /^\s*<[^Hh>]*html/i # Probably html
+          Nokogiri::HTML(
+            string,
+            url,
+            encoding, options || XML::ParseOptions::DEFAULT_HTML
+          )
         else
-          Nokogiri::XML.parse(string, url, encoding, options || 2159)
+          Nokogiri::XML(string, url, encoding,
+                        options || XML::ParseOptions::DEFAULT_XML)
         end
       yield doc if block_given?
       doc
     end
 
+    ###
+    # Create a new Nokogiri::XML::DocumentFragment
     def make input = nil, opts = {}, &blk
       if input
         Nokogiri::HTML.fragment(input).children.first
@@ -62,7 +95,7 @@ module Nokogiri
         Nokogiri(&blk)
       end
     end
-    
+
     ###
     # Parse a document and add the Slop decorator.  The Slop decorator
     # implements method_missing such that methods may be used instead of CSS
@@ -84,6 +117,12 @@ module Nokogiri
   end
 end
 
+###
+# Parser a document contained in +args+.  Nokogiri will try to guess what
+# type of document you are attempting to parse.  For more information, see
+# Nokogiri.parse
+#
+# To specify the type of document, use Nokogiri.XML or Nokogiri.HTML.
 def Nokogiri(*args, &block)
   if block_given?
     builder = Nokogiri::HTML::Builder.new(&block)

data/lib/nokogiri/css.rb

@@ -1,9 +1,12 @@
 require 'nokogiri/css/node'
 require 'nokogiri/css/xpath_visitor'
-require 'nokogiri/css/generated_parser'
-require 'nokogiri/css/generated_tokenizer'
-require 'nokogiri/css/tokenizer'
+
+x = $-w
+$-w = false
 require 'nokogiri/css/parser'
+$-w = x
+
+require 'nokogiri/css/tokenizer'
 require 'nokogiri/css/syntax_error'
 
 module Nokogiri

data/lib/nokogiri/css/node.rb

@@ -1,12 +1,18 @@
 module Nokogiri
   module CSS
     class Node
-      attr_accessor :type, :value
+      # 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
@@ -18,6 +24,7 @@ module Nokogiri
         prefix + visitor.accept(self)
       end
 
+      # Preprocess this node tree
       def preprocess!
         ### Deal with nth-child
         matches = find_by_type(
@@ -29,15 +36,7 @@ module Nokogiri
           ]
         )
         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/
+          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, [
@@ -67,14 +66,15 @@ module Nokogiri
             match.value[1] = Node.new(:COMBINATOR, [
               Node.new(:FUNCTION, ["#{match.value[1].value.first}("]),
               Node.new(:FUNCTION, ['self(', tag_name])
-            ])                                        
+            ])
           end
         end
 
         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|
@@ -83,12 +83,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