nokogiri 1.4.3.1-java → 1.5.0-java

data/ext/nokogiri/xml_node.c

@@ -14,10 +14,7 @@ static void debug_node_dealloc(xmlNodePtr x)
 
 static void mark(xmlNodePtr node)
 {
-  /* it's OK if the document isn't fully realized (as in XML::Reader). */
-  /* see http://github.com/tenderlove/nokogiri/issues/closed/#issue/95 */
-  if (DOC_RUBY_OBJECT_TEST(node->doc) && DOC_RUBY_OBJECT(node->doc))
-    rb_gc_mark(DOC_RUBY_OBJECT(node->doc));
+  rb_gc_mark(DOC_RUBY_OBJECT(node->doc));
 }
 
 /* :nodoc: */
@@ -169,12 +166,6 @@ static VALUE reparent_node_with(VALUE pivot_obj, VALUE reparentee_obj, pivot_rep
     xmlAddNextSibling(pivot, new_next_text);
   }
 
-  /* TODO: I really want to remove this.  We shouldn't support 2.6.16 anymore */
-  if ( reparentee->type == XML_TEXT_NODE && pivot->type == XML_TEXT_NODE && is_2_6_16() ) {
-    /* work around a string-handling bug in libxml 2.6.16. we'd rather leak than segfault. */
-    pivot->content = xmlStrdup(pivot->content);
-  }
-
   if(!(reparented = (*prf)(pivot, reparentee))) {
     rb_raise(rb_eRuntimeError, "Could not reparent node");
   }
@@ -251,7 +242,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 +374,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 +773,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 +791,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 +820,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 +1047,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 +1162,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 +1188,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
@@ -1216,6 +1232,8 @@ VALUE Nokogiri_wrap_xml_node(VALUE klass, xmlNodePtr node)
   VALUE document = Qnil ;
   VALUE node_cache = Qnil ;
   VALUE rb_node = Qnil ;
+  int node_has_a_document = 0 ;
+  void (*mark_method)(xmlNodePtr) = NULL ;
 
   assert(node);
 
@@ -1224,11 +1242,9 @@ VALUE Nokogiri_wrap_xml_node(VALUE klass, xmlNodePtr node)
 
   if(NULL != node->_private) return (VALUE)node->_private;
 
-  if(RTEST(klass))
-    rb_node = Data_Wrap_Struct(klass, mark, debug_node_dealloc, node) ;
-
-  else switch(node->type)
-  {
+  if(!RTEST(klass)) {
+    switch(node->type)
+    {
     case XML_ELEMENT_NODE:
       klass = cNokogiriXmlElement;
       break;
@@ -1267,15 +1283,19 @@ VALUE Nokogiri_wrap_xml_node(VALUE klass, xmlNodePtr node)
       break;
     default:
       klass = cNokogiriXmlNode;
+    }
   }
 
-  rb_node = Data_Wrap_Struct(klass, mark, debug_node_dealloc, node) ;
+  /* It's OK if the node doesn't have a fully-realized document (as in XML::Reader). */
+  /* see https://github.com/tenderlove/nokogiri/issues/95 */
+  /* and https://github.com/tenderlove/nokogiri/issues/439 */
+  node_has_a_document = (DOC_RUBY_OBJECT_TEST(node->doc) && DOC_RUBY_OBJECT(node->doc)) ? 1 : 0 ;
+  mark_method = node_has_a_document ? mark : NULL ;
 
+  rb_node = Data_Wrap_Struct(klass, mark_method, debug_node_dealloc, node) ;
   node->_private = (void *)rb_node;
 
-  if (DOC_RUBY_OBJECT_TEST(node->doc) && DOC_RUBY_OBJECT(node->doc)) {
-    /* it's OK if the document isn't fully realized (as in XML::Reader). */
-    /* see http://github.com/tenderlove/nokogiri/issues/closed/#issue/95 */
+  if (node_has_a_document) {
     document = DOC_RUBY_OBJECT(node->doc);
     node_cache = DOC_NODE_CACHE(node->doc);
     rb_ary_push(node_cache, rb_node);

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_relax_ng.c

@@ -129,9 +129,6 @@ static VALUE from_document(VALUE klass, VALUE document)
   schema = xmlRelaxNGParse(ctx);
 
   xmlSetStructuredErrorFunc(NULL, NULL);
-  if (! is_2_6_16()) {
-    xmlRelaxNGFreeParserCtxt(ctx);
-  }
 
   if(NULL == schema) {
     xmlErrorPtr error = xmlGetLastError();
@@ -143,10 +140,6 @@ static VALUE from_document(VALUE klass, VALUE document)
     return Qnil;
   }
 
-  if (is_2_6_16()) {
-    xmlRelaxNGFreeParserCtxt(ctx);
-  }
-
   rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
   rb_iv_set(rb_schema, "@errors", errors);
 

data/ext/nokogiri/xml_sax_parser.c

@@ -1,6 +1,7 @@
 #include <xml_sax_parser.h>
 
 int vasprintf (char **strp, const char *fmt, va_list ap);
+void vasprintf_free (void *p);
 
 static ID id_start_document, id_end_document, id_start_element, id_end_element;
 static ID id_start_element_namespace, id_end_element_namespace;
@@ -62,8 +63,10 @@ static void start_element(void * ctx, const xmlChar *name, const xmlChar **atts)
   int i = 0;
   if(atts) {
     while((attr = atts[i]) != NULL) {
-      rb_ary_push(attributes, NOKOGIRI_STR_NEW2(attr));
-      i++;
+      const xmlChar * val = atts[i+1];
+      VALUE value = val != NULL ? NOKOGIRI_STR_NEW2(val) : Qnil;
+      rb_ary_push(attributes, rb_ary_new3(2, NOKOGIRI_STR_NEW2(attr), value));
+      i+=2;
     }
   }
 
@@ -196,14 +199,16 @@ static void warning_func(void * ctx, const char *msg, ...)
   VALUE self = NOKOGIRI_SAX_SELF(ctx);
   VALUE doc = rb_iv_get(self, "@document");
   char * message;
+  VALUE ruby_message;
 
   va_list args;
   va_start(args, msg);
   vasprintf(&message, msg, args);
   va_end(args);
 
-  rb_funcall(doc, id_warning, 1, NOKOGIRI_STR_NEW2(message));
-  free(message);
+  ruby_message = NOKOGIRI_STR_NEW2(message);
+  vasprintf_free(message);
+  rb_funcall(doc, id_warning, 1, ruby_message);
 }
 
 static void error_func(void * ctx, const char *msg, ...)
@@ -211,14 +216,16 @@ static void error_func(void * ctx, const char *msg, ...)
   VALUE self = NOKOGIRI_SAX_SELF(ctx);
   VALUE doc = rb_iv_get(self, "@document");
   char * message;
+  VALUE ruby_message;
 
   va_list args;
   va_start(args, msg);
   vasprintf(&message, msg, args);
   va_end(args);
 
-  rb_funcall(doc, id_error, 1, NOKOGIRI_STR_NEW2(message));
-  free(message);
+  ruby_message = NOKOGIRI_STR_NEW2(message);
+  vasprintf_free(message);
+  rb_funcall(doc, id_error, 1, ruby_message);
 }
 
 static void cdata_block(void * ctx, const xmlChar * value, int len)
@@ -238,7 +245,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,7 +5,10 @@
 #include <libxslt/transform.h>
 #include <libexslt/exslt.h>
 
+VALUE xslt;
+
 int vasprintf (char **strp, const char *fmt, va_list ap);
+void vasprintf_free (void *p);
 
 static void dealloc(xsltStylesheetPtr doc)
 {
@@ -18,13 +21,16 @@ 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;
+  VALUE exception;
 
   va_list args;
   va_start(args, msg);
   vasprintf(&message, msg, args);
   va_end(args);
 
-  rb_raise(rb_eRuntimeError, message);
+  exception = rb_exc_new2(rb_eRuntimeError, message);
+  vasprintf_free(message);
+  rb_exc_raise(exception);
 }
 
 /*
@@ -97,7 +103,9 @@ 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) ; }
+    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)) {
@@ -124,19 +132,133 @@ 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;
+    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:
+ *    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");
-  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, "transform", transform, -1);
 }