nokogiri 1.4.3.1 → 1.4.4

data/ext/nokogiri/extconf.rb

@@ -91,14 +91,12 @@ def asplode(lib)
   abort "-----\n#{lib} is missing.  please visit http://nokogiri.org/tutorials/installing_nokogiri.html for help with installing dependencies.\n-----"
 end
 
-# Use this with cross compiling
-# PKG_CONFIG_PATH=/Users/apatterson/git/nokogiri/tmp/cross/lib/pkgconfig/ \
-#   rake cross compile RUBY_CC_VERSION=1.9.1
 pkg_config('libxslt') if RUBY_PLATFORM =~ /mingw/
 
 asplode "libxml2"  unless find_header('libxml/parser.h')
 asplode "libxslt"  unless find_header('libxslt/xslt.h')
 asplode "libexslt" unless find_header('libexslt/exslt.h')
+asplode "libiconv" unless have_func('iconv_open', 'iconv.h') or have_library('iconv', 'iconv_open', 'iconv.h')
 asplode "libxml2"  unless find_library("#{lib_prefix}xml2", 'xmlParseDoc')
 asplode "libxslt"  unless find_library("#{lib_prefix}xslt", 'xsltParseStylesheetDoc')
 asplode "libexslt" unless find_library("#{lib_prefix}exslt", 'exsltFuncRegister')

data/ext/nokogiri/nokogiri.c

@@ -30,12 +30,14 @@ int is_2_6_16(void)
 
 void Init_nokogiri()
 {
+#ifndef __MACRUBY__
   xmlMemSetup(
       (xmlFreeFunc)ruby_xfree,
       (xmlMallocFunc)ruby_xmalloc,
       (xmlReallocFunc)ruby_xrealloc,
       strdup
   );
+#endif
 
   mNokogiri         = rb_define_module("Nokogiri");
   mNokogiriXml      = rb_define_module_under(mNokogiri, "XML");

data/ext/nokogiri/nokogiri.h

@@ -27,6 +27,7 @@ int vasprintf (char **strp, const char *fmt, va_list ap);
 #include <libxml/HTMLparser.h>
 #include <libxml/HTMLtree.h>
 #include <libxml/relaxng.h>
+#include <libxslt/extensions.h>
 #include <ruby.h>
 
 #ifdef HAVE_RUBY_ENCODING_H
@@ -134,6 +135,8 @@ extern VALUE mNokogiriXslt ;
 #define NOKOGIRI_DEBUG_START(p)
 #define NOKOGIRI_DEBUG_END(p)
 
+#endif
+
 #ifndef RSTRING_PTR
 #define RSTRING_PTR(s) (RSTRING(s)->ptr)
 #endif
@@ -150,6 +153,10 @@ extern VALUE mNokogiriXslt ;
 #define RARRAY_LEN(a) RARRAY(a)->len
 #endif
 
+#ifndef __builtin_expect
+# if defined(__GNUC__)
+#  define __builtin_expect(expr, c) __builtin_expect((long)(expr), (long)(c))
+# endif
 #endif
 
 #endif

data/ext/nokogiri/xml_dtd.c

@@ -84,10 +84,10 @@ static VALUE attributes(VALUE self)
 
   Data_Get_Struct(self, xmlDtd, dtd);
 
-  if(!dtd->attributes) return Qnil;
-
   hash = rb_hash_new();
 
+  if(!dtd->attributes) return hash;
+
   xmlHashScan((xmlHashTablePtr)dtd->attributes, element_copier, (void *)hash);
 
   return hash;

data/ext/nokogiri/xml_io.c

@@ -8,14 +8,14 @@ int io_read_callback(void * ctx, char * buffer, int len) {
 
   if(NIL_P(string)) return 0;
 
-  memcpy(buffer, StringValuePtr(string), (unsigned int)RSTRING_LEN(string));
+  memcpy(buffer, StringValuePtr(string), (size_t)RSTRING_LEN(string));
 
   return (int)RSTRING_LEN(string);
 }
 
 int io_write_callback(void * ctx, char * buffer, int len) {
   VALUE io = (VALUE)ctx;
-  VALUE string = rb_str_new(buffer, len);
+  VALUE string = rb_str_new(buffer, (long)len);
 
   rb_funcall(io, id_write, 1, string);
   return len;

data/ext/nokogiri/xml_node.c

@@ -251,7 +251,13 @@ static VALUE encode_special_chars(VALUE self, VALUE string)
  * call-seq:
  *  create_internal_subset(name, external_id, system_id)
  *
- * Create an internal subset
+ * Create the internal subset of a document.
+ *
+ *   doc.create_internal_subset("chapter", "-//OASIS//DTD DocBook XML//EN", "chapter.dtd")
+ *   # => <!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML//EN" "chapter.dtd">
+ *
+ *   doc.create_internal_subset("chapter", nil, "chapter.dtd")
+ *   # => <!DOCTYPE chapter SYSTEM "chapter.dtd">
  */
 static VALUE create_internal_subset(VALUE self, VALUE name, VALUE external_id, VALUE system_id)
 {
@@ -377,6 +383,8 @@ static VALUE duplicate_node(int argc, VALUE *argv, VALUE self)
   dup = xmlDocCopyNode(node, node->doc, (int)NUM2INT(level));
   if(dup == NULL) return Qnil;
 
+  NOKOGIRI_ROOT_NODE(dup);
+
   return Nokogiri_wrap_xml_node(rb_obj_class(self), dup);
 }
 
@@ -774,7 +782,8 @@ static VALUE attribute_nodes(VALUE self)
  *  call-seq:
  *    namespace()
  *
- *  returns the Nokogiri::XML::Namespace for the node, if one exists.
+ *  returns the default namespace set on this node (as with an "xmlns="
+ *  attribute), as a Namespace object.
  */
 static VALUE namespace(VALUE self)
 {
@@ -791,7 +800,7 @@ static VALUE namespace(VALUE self)
  *  call-seq:
  *    namespace_definitions()
  *
- *  returns a list of Namespace nodes defined on _self_
+ *  returns namespaces defined on self element directly, as an array of Namespace objects. Includes both a default namespace (as in"xmlns="), and prefixed namespaces (as in "xmlns:prefix=").
  */
 static VALUE namespace_definitions(VALUE self)
 {
@@ -820,8 +829,10 @@ static VALUE namespace_definitions(VALUE self)
  *  call-seq:
  *    namespace_scopes()
  *
- *  returns a list of Namespace nodes in scope for _self_. this is all
- *  namespaces defined in the node, or in any ancestor node.
+ * returns namespaces in scope for self -- those defined on self element
+ * directly or any ancestor node -- as an array of Namespace objects.  Default
+ * namespaces ("xmlns=" style) for self are included in this array; Default
+ * namespaces for  ancestors, however, are not. See also #namespaces
  */
 static VALUE namespace_scopes(VALUE self)
 {
@@ -1045,7 +1056,12 @@ static VALUE line(VALUE self)
  * call-seq:
  *  add_namespace_definition(prefix, href)
  *
- * Adds a namespace definition with +prefix+ using +href+
+ * Adds a namespace definition with +prefix+ using +href+ value. The result is
+ * as if parsed XML for this node had included an attribute
+ * 'xmlns:prefix=value'.  A default namespace for this node ("xmlns=") can be
+ * added by passing 'nil' for prefix. Namespaces added this way will not
+ * show up in #attributes, but they will be included as an xmlns attribute
+ * when the node is serialized to XML.
  */
 static VALUE add_namespace_definition(VALUE self, VALUE prefix, VALUE href)
 {
@@ -1155,6 +1171,7 @@ static VALUE in_context(VALUE self, VALUE _str, VALUE _options)
 {
   xmlNodePtr node;
   xmlNodePtr list;
+  xmlNodePtr child_iter;
   xmlNodeSetPtr set;
   xmlParserErrors error;
   VALUE doc, err;
@@ -1180,6 +1197,14 @@ static VALUE in_context(VALUE self, VALUE _str, VALUE _options)
       (int)NUM2INT(_options),
       &list);
 
+  /* make sure parent/child pointers are coherent so an unlink will work properly (#331) */
+  child_iter = node->doc->children ;
+  while (child_iter) {
+    if (child_iter->parent != (xmlNodePtr)node->doc)
+      child_iter->parent = (xmlNodePtr)node->doc ;
+    child_iter = child_iter->next ;
+  }
+
 #ifndef HTML_PARSE_NOIMPLIED
   htmlHandleOmittedElem(1);
 #endif

data/ext/nokogiri/xml_node_set.c

@@ -257,7 +257,7 @@ static VALUE slice(int argc, VALUE *argv, VALUE self)
   }
   
   /* if arg is Range */
-  switch (rb_range_beg_len(arg, &beg, &len, node_set->nodeNr, 0)) {
+  switch (rb_range_beg_len(arg, &beg, &len, (long)node_set->nodeNr, 0)) {
   case Qfalse:
     break;
   case Qnil:

data/ext/nokogiri/xml_sax_parser.c

@@ -238,7 +238,7 @@ static void deallocate(xmlSAXHandlerPtr handler)
 
 static VALUE allocate(VALUE klass)
 {
-  xmlSAXHandlerPtr handler = calloc(1, sizeof(xmlSAXHandler));
+  xmlSAXHandlerPtr handler = calloc((size_t)1, sizeof(xmlSAXHandler));
 
   xmlSetStructuredErrorFunc(NULL, NULL);
 

data/ext/nokogiri/xml_sax_parser_context.c

@@ -140,6 +140,44 @@ static VALUE get_replace_entities(VALUE self)
     return Qtrue;
 }
 
+/*
+ * call-seq: line
+ *
+ * Get the current line the parser context is processing.
+ */
+static VALUE line(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  xmlParserInputPtr io;
+
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  io = ctxt->input;
+  if(io)
+    return INT2NUM(io->line);
+
+  return Qnil;
+}
+
+/*
+ * call-seq: column
+ *
+ * Get the current column the parser context is processing.
+ */
+static VALUE column(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  xmlParserInputPtr io;
+
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  io = ctxt->input;
+  if(io)
+    return INT2NUM(io->col);
+
+  return Qnil;
+}
+
 void init_xml_sax_parser_context()
 {
   VALUE nokogiri  = rb_define_module("Nokogiri");
@@ -156,4 +194,6 @@ void init_xml_sax_parser_context()
   rb_define_method(klass, "parse_with", parse_with, 1);
   rb_define_method(klass, "replace_entities=", set_replace_entities, 1);
   rb_define_method(klass, "replace_entities", get_replace_entities, 0);
+  rb_define_method(klass, "line", line, 0);
+  rb_define_method(klass, "column", column, 0);
 }

data/ext/nokogiri/xml_xpath_context.c

@@ -27,6 +27,28 @@ static VALUE register_ns(VALUE self, VALUE prefix, VALUE uri)
   return self;
 }
 
+/*
+ * call-seq:
+ *  register_variable(name, value)
+ *
+ * Register the variable +name+ with +value+.
+ */
+static VALUE register_variable(VALUE self, VALUE name, VALUE value)
+{
+   xmlXPathContextPtr ctx;
+   xmlXPathObjectPtr xmlValue;
+   Data_Get_Struct(self, xmlXPathContext, ctx);
+
+   xmlValue = xmlXPathNewCString(StringValuePtr(value));
+
+   xmlXPathRegisterVariable( ctx,
+      (const xmlChar *)StringValuePtr(name),
+      xmlValue
+   );
+
+   return self;
+}
+
 static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
 {
   VALUE xpath_handler = Qnil;
@@ -46,7 +68,11 @@ static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
 
   xpath_handler = (VALUE)(ctx->context->userData);
 
-  argv = (VALUE *)calloc((unsigned int)nargs, sizeof(VALUE));
+  argv = (VALUE *)calloc((size_t)nargs, sizeof(VALUE));
+  for (i = 0 ; i < nargs ; ++i) {
+    rb_gc_register_address(&argv[i]);
+  }
+
   doc = DOC_RUBY_OBJECT(ctx->context->doc);
 
   i = nargs - 1;
@@ -77,6 +103,10 @@ static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
       nargs,
       argv
   );
+
+  for (i = 0 ; i < nargs ; ++i) {
+    rb_gc_unregister_address(&argv[i]);
+  }
   free(argv);
 
   switch(TYPE(result)) {
@@ -156,7 +186,7 @@ static void xpath_generic_exception_handler(void * ctx, const char *msg, ...)
 
 /*
  * call-seq:
- *  evaluate(search_path)
+ *  evaluate(search_path, handler = nil)
  *
  * Evaluate the +search_path+ returning an XML::XPath object.
  */
@@ -274,5 +304,6 @@ void init_xml_xpath_context(void)
 
   rb_define_singleton_method(klass, "new", new, 1);
   rb_define_method(klass, "evaluate", evaluate, -1);
+  rb_define_method(klass, "register_variable", register_variable, 2);
   rb_define_method(klass, "register_ns", register_ns, 2);
 }

data/ext/nokogiri/xslt_stylesheet.c

@@ -5,6 +5,8 @@
 #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)
@@ -24,7 +26,7 @@ static void xslt_generic_error_handler(void * ctx, const char *msg, ...)
   vasprintf(&message, msg, args);
   va_end(args);
 
-  rb_raise(rb_eRuntimeError, message);
+  rb_exc_raise(rb_exc_new2(rb_eRuntimeError, message));
 }
 
 /*
@@ -97,7 +99,7 @@ static VALUE transform(int argc, VALUE* argv, VALUE self)
     long param_len, j ;
 
     rb_scan_args(argc, argv, "11", &xmldoc, &paramobj);
-    if (NIL_P(paramobj)) { paramobj = rb_ary_new2(0) ; }
+    if (NIL_P(paramobj)) { paramobj = rb_ary_new2(0L) ; }
 
     /* handle hashes as arguments. */
     if(T_HASH == TYPE(paramobj)) {
@@ -124,19 +126,129 @@ static VALUE transform(int argc, VALUE* argv, VALUE self)
 
     if (!result) rb_raise(rb_eRuntimeError, "could not perform xslt transform on document");
 
-    return Nokogiri_wrap_xml_document(0, result) ;
+    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;
+
+    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;
+    }
+    VALUE 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:
+ *    register(uri, custom_handler_class)
+ *
+ *  Register a class that implements custom XLST 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 *)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");
+  xslt = rb_define_module_under(nokogiri, "XSLT");
   VALUE 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, "transform", transform, -1);
 }