nokogiri 1.2.1 → 1.2.2

data/ext/nokogiri/xml_document.h

@@ -3,8 +3,19 @@
 
 #include <native.h>
 
+struct _nokogiriTuple {
+  xmlDocPtr     doc;
+  xmlNodeSetPtr unlinkedNodes;
+};
+typedef struct _nokogiriTuple nokogiriTuple;
+typedef nokogiriTuple * nokogiriTuplePtr;
+
 void init_xml_document();
 VALUE Nokogiri_wrap_xml_document(VALUE klass, xmlDocPtr doc);
 
+#define DOC_RUBY_OBJECT_TEST(x) ((nokogiriTuplePtr)(x->_private))
+#define DOC_RUBY_OBJECT(x) ((VALUE)((nokogiriTuplePtr)(x->_private))->doc)
+#define DOC_UNLINKED_NODE_SET(x) ((xmlNodeSetPtr)((nokogiriTuplePtr)(x->_private))->unlinkedNodes)
+
 extern VALUE cNokogiriXmlDocument ;
 #endif

data/ext/nokogiri/xml_document_fragment.c

@@ -11,7 +11,7 @@ static VALUE new(VALUE klass, VALUE doc)
   xmlDocPtr xml_doc;
   Data_Get_Struct(doc, xmlDoc, xml_doc);
 
-  xmlNodePtr node = xmlNewDocFragment(xml_doc);
+  xmlNodePtr node = xmlNewDocFragment(xml_doc->doc);
 
   VALUE rb_node = Nokogiri_wrap_xml_node(node);
 

data/ext/nokogiri/xml_node.c

@@ -10,6 +10,55 @@ static void debug_node_dealloc(xmlNodePtr x)
 #  define debug_node_dealloc 0
 #endif
 
+/* :nodoc: */
+typedef xmlNodePtr (*node_other_func)(xmlNodePtr, xmlNodePtr);
+
+/* :nodoc: */
+static VALUE reparent_node_with(VALUE node_obj, VALUE other_obj, node_other_func func)
+{
+  VALUE reparented_obj ;
+  xmlNodePtr node, other, reparented ;
+
+  Data_Get_Struct(node_obj, xmlNode, node);
+  Data_Get_Struct(other_obj, xmlNode, other);
+
+  if (node->doc == other->doc) {
+    xmlUnlinkNode(node) ;
+    if(!(reparented = (*func)(other, node))) {
+      rb_raise(rb_eRuntimeError, "Could not reparent node (1)");
+    }
+
+  } else {
+    xmlNodePtr duped_node ;
+    // recursively copy to the new document
+    if (!(duped_node = xmlDocCopyNode(node, other->doc, 1))) {
+      rb_raise(rb_eRuntimeError, "Could not reparent node (xmlDocCopyNode)");
+    }
+    if(!(reparented = (*func)(other, duped_node))) {
+      rb_raise(rb_eRuntimeError, "Could not reparent node (2)");
+    }
+    xmlUnlinkNode(node);
+    NOKOGIRI_ROOT_NODE(node);
+  }
+
+  // the child was a text node that was coalesced. we need to have the object
+  // point at SOMETHING, or we'll totally bomb out.
+  if (reparented != node) {
+    DATA_PTR(node_obj) = reparented ;
+  }
+
+  // Make sure that our reparented node has the correct namespaces
+  if(reparented->doc != reparented->parent)
+    reparented->ns = reparented->parent->ns;
+
+  reparented_obj = Nokogiri_wrap_xml_node(reparented);
+
+  rb_funcall(reparented_obj, rb_intern("decorate!"), 0);
+
+  return reparented_obj ;
+}
+
+
 /*
  * call-seq:
  *  pointer_id
@@ -101,6 +150,7 @@ static VALUE unlink_node(VALUE self)
   xmlNodePtr node;
   Data_Get_Struct(self, xmlNode, node);
   xmlUnlinkNode(node);
+  NOKOGIRI_ROOT_NODE(node);
   return self;
 }
 
@@ -208,12 +258,9 @@ static VALUE set(VALUE self, VALUE property, VALUE value)
   xmlNodePtr node;
   Data_Get_Struct(self, xmlNode, node);
 
-  xmlChar *buffer = xmlEncodeEntitiesReentrant(node->doc,
+  xmlSetProp(node, (xmlChar *)StringValuePtr(property),
       (xmlChar *)StringValuePtr(value));
 
-  xmlSetProp(node, (xmlChar *)StringValuePtr(property), buffer);
-  xmlFree(buffer);
-
   return value;
 }
 
@@ -371,21 +418,7 @@ static VALUE get_content(VALUE self)
  */
 static VALUE add_child(VALUE self, VALUE child)
 {
-  xmlNodePtr node, parent, new_child;
-  Data_Get_Struct(child, xmlNode, node);
-  Data_Get_Struct(self, xmlNode, parent);
-
-  xmlUnlinkNode(node) ;
-
-  if(!(new_child = xmlAddChild(parent, node)))
-    rb_raise(rb_eRuntimeError, "Could not add new child");
-
-  // the child was a text node that was coalesced. we need to have the object
-  // point at SOMETHING, or we'll totally bomb out.
-  if (new_child != node)
-    DATA_PTR(child) = new_child ;
-
-  return Nokogiri_wrap_xml_node(new_child);
+  return reparent_node_with(child, self, xmlAddChild);
 }
 
 /*
@@ -460,20 +493,7 @@ static VALUE path(VALUE self)
  */
 static VALUE add_next_sibling(VALUE self, VALUE rb_node)
 {
-  xmlNodePtr node, _new_sibling, new_sibling;
-  Data_Get_Struct(self, xmlNode, node);
-  Data_Get_Struct(rb_node, xmlNode, _new_sibling);
-
-  if(!(new_sibling = xmlAddNextSibling(node, _new_sibling)))
-    rb_raise(rb_eRuntimeError, "Could not add next sibling");
-
-  // the sibling was a text node that was coalesced. we need to have the object
-  // point at SOMETHING, or we'll totally bomb out.
-  if(new_sibling != _new_sibling) DATA_PTR(rb_node) = new_sibling;
-
-  rb_funcall(rb_node, rb_intern("decorate!"), 0);
-
-  return rb_node;
+  return reparent_node_with(rb_node, self, xmlAddNextSibling) ;
 }
 
 /*
@@ -484,22 +504,7 @@ static VALUE add_next_sibling(VALUE self, VALUE rb_node)
  */
 static VALUE add_previous_sibling(VALUE self, VALUE rb_node)
 {
-  xmlNodePtr node, sibling, new_sibling;
-  Check_Type(rb_node, T_DATA);
-
-  Data_Get_Struct(self, xmlNode, node);
-  Data_Get_Struct(rb_node, xmlNode, sibling);
-
-  if(!(new_sibling = xmlAddPrevSibling(node, sibling)))
-    rb_raise(rb_eRuntimeError, "Could not add previous sibling");
-
-  // the sibling was a text node that was coalesced. we need to have the object
-  // point at SOMETHING, or we'll totally bomb out.
-  if(sibling != new_sibling) DATA_PTR(rb_node) = new_sibling;
-
-  rb_funcall(rb_node, rb_intern("decorate!"), 0);
-
-  return rb_node;
+  return reparent_node_with(rb_node, self, xmlAddPrevSibling) ;
 }
 
 /*
@@ -560,12 +565,14 @@ static VALUE add_namespace(VALUE self, VALUE prefix, VALUE href)
 
   if(NULL == ns) return self;
 
+  /*
   xmlNewNsProp(
       node,
       ns,
       (const xmlChar *)StringValuePtr(href),
       (const xmlChar *)StringValuePtr(prefix)
   );
+  */
 
   return self;
 }
@@ -617,16 +624,18 @@ static VALUE dump_html(VALUE self)
 VALUE Nokogiri_wrap_xml_node(xmlNodePtr node)
 {
   assert(node);
-  assert(node->doc);
-  assert(node->doc->_private);
 
   VALUE index = INT2NUM((int)node);
-  VALUE document = (VALUE)node->doc->_private;
-
-  VALUE node_cache = rb_funcall(document, rb_intern("node_cache"), 0);
-  VALUE rb_node = rb_hash_aref(node_cache, index);
-
-  if(rb_node != Qnil) return rb_node;
+  VALUE document = Qnil ;
+  VALUE node_cache = Qnil ;
+  VALUE rb_node = Qnil ;
+
+  if (DOC_RUBY_OBJECT_TEST(node->doc) && DOC_RUBY_OBJECT(node->doc)) {
+    document = DOC_RUBY_OBJECT(node->doc);
+    node_cache = rb_funcall(document, rb_intern("node_cache"), 0);
+    rb_node = rb_hash_aref(node_cache, index);
+    if(rb_node != Qnil) return rb_node;
+  }
 
   switch(node->type)
   {
@@ -672,11 +681,15 @@ VALUE Nokogiri_wrap_xml_node(xmlNodePtr node)
       klass = rb_const_get(mNokogiriXml, rb_intern("DTD"));
       rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
       break;
+    case XML_DOCUMENT_NODE:
+      return DOC_RUBY_OBJECT(node->doc);
+    case XML_HTML_DOCUMENT_NODE:
+      return DOC_RUBY_OBJECT(node->doc);
     default:
       rb_node = Data_Wrap_Struct(cNokogiriXmlNode, 0, debug_node_dealloc, node) ;
   }
 
-  rb_hash_aset(node_cache, index, rb_node);
+  if (node_cache != Qnil) rb_hash_aset(node_cache, index, rb_node);
   rb_iv_set(rb_node, "@document", document);
   rb_funcall(rb_node, rb_intern("decorate!"), 0);
   return rb_node ;

data/ext/nokogiri/xml_node_set.c

@@ -58,6 +58,31 @@ static VALUE index_at(VALUE self, VALUE number)
   return Nokogiri_wrap_xml_node(node_set->nodeTab[i]);
 }
 
+/*
+ *  call-seq:
+ *    unlink
+ *
+ * Unlink this NodeSet and all Node objects it contains from their current context.
+ */
+static VALUE unlink_nodeset(VALUE self)
+{
+  xmlNodeSetPtr node_set;
+  int j, nodeNr ;
+
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+  nodeNr = node_set->nodeNr ;
+  for (j = 0 ; j < nodeNr ; j++) {
+    VALUE node ;
+    xmlNodePtr node_ptr;
+    node = Nokogiri_wrap_xml_node(node_set->nodeTab[j]);
+    rb_funcall(node, rb_intern("unlink"), 0); /* modifies the C struct out from under the object */
+    Data_Get_Struct(node, xmlNode, node_ptr);
+    node_set->nodeTab[j] = node_ptr ;
+  }
+  return self ;
+}
+
+
 static void deallocate(xmlNodeSetPtr node_set)
 {
   /*
@@ -119,4 +144,5 @@ void init_xml_node_set(void)
   rb_define_method(klass, "length", length, 0);
   rb_define_method(klass, "[]", index_at, 1);
   rb_define_method(klass, "push", push, 1);
+  rb_define_method(klass, "unlink", unlink_nodeset, 0);
 }

data/ext/nokogiri/xml_reader.c

@@ -126,10 +126,12 @@ static VALUE attribute_nodes(VALUE self)
   // FIXME I'm not sure if this is correct.....  I don't really like pointing
   // at this document, but I have to because of the assertions in
   // the node wrapping code.
-  if(!ptr->doc->_private) {
+  if(! DOC_RUBY_OBJECT_TEST(ptr->doc)) {
     VALUE rb_doc = Data_Wrap_Struct(cNokogiriXmlDocument, 0, 0, ptr->doc);
+    ptr->doc->_private = malloc(sizeof(nokogiriTuple));
     rb_iv_set(rb_doc, "@decorators", Qnil);
-    ptr->doc->_private = (void *)rb_doc;
+    ((nokogiriTuplePtr)(ptr->doc->_private))->doc = (void *)rb_doc;
+    ((nokogiriTuplePtr)(ptr->doc->_private))->unlinkedNodes = xmlXPathNodeSetCreate(NULL);
   }
   VALUE enc = rb_iv_get(self, "@encoding");
 

data/ext/nokogiri/xml_sax_parser.c

@@ -129,43 +129,6 @@ static void comment_func(void * ctx, const xmlChar * value)
   rb_funcall(doc, rb_intern("comment"), 1, str);
 }
 
-#ifdef XP_WIN
-/*
- * I srsly hate windows.  it doesn't have vasprintf.
- * This is stolen from here:
- *   http://eleves.ec-lille.fr/~couprieg/index.php?2008/06/17/39-first-issues-when-porting-an-application-on-windows-ce
- * and slightly modified
- */
-static inline int vasprintf(char **strp, const char *fmt, va_list ap) {
-  int n;
-  size_t size = 4096;
-  char *res, *np;
-
-  if ( (res = (char *) malloc(size)) == NULL )
-    return -1;
-
-  while (1) {
-    n = vsnprintf (res, size, fmt, ap);
-    /* If that worked, return the string. */
-    if (n > -1 && n < size) {
-      *strp = res;
-      return n;
-    }
-
-    /* Else try again with more space. */
-    if (n == -1)
-      size *= 2; /* twice the old size */
-
-    if ( (np = (char *) realloc(res, size)) == NULL ) {
-      free(res);
-      return -1;
-    } else {
-      res = np;
-    }
-  }
-}
-#endif
-
 static void warning_func(void * ctx, const char *msg, ...)
 {
   VALUE self = (VALUE)ctx;

data/ext/nokogiri/xml_sax_push_parser.c

@@ -2,9 +2,9 @@
 
 static void deallocate(xmlParserCtxtPtr ctx)
 {
-  NOKOGIRI_DEBUG_START(handler);
+  NOKOGIRI_DEBUG_START(ctx);
   if(ctx != NULL) xmlFreeParserCtxt(ctx);
-  NOKOGIRI_DEBUG_END(handler);
+  NOKOGIRI_DEBUG_END(ctx);
 }
 
 static VALUE allocate(VALUE klass)

data/ext/nokogiri/xml_xpath_context.c

@@ -34,12 +34,12 @@ static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
   assert(ctx->context);
   assert(ctx->context->userData);
   assert(ctx->context->doc);
-  assert(ctx->context->doc->_private);
+  assert(DOC_RUBY_OBJECT_TEST(ctx->context->doc));
 
   xpath_handler = (VALUE)(ctx->context->userData);
 
   VALUE * argv = (VALUE *)calloc((unsigned int)nargs, sizeof(VALUE));
-  VALUE doc = (VALUE)ctx->context->doc->_private;
+  VALUE doc = DOC_RUBY_OBJECT(ctx->context->doc);
 
   int i = nargs - 1;
   do {
@@ -130,6 +130,28 @@ static xmlXPathFunction lookup( void *ctx,
   return NULL;
 }
 
+static void xpath_exception_handler(void * ctx, xmlErrorPtr error)
+{
+  VALUE xpath = rb_const_get(mNokogiriXml, rb_intern("XPath"));
+  VALUE klass = rb_const_get(xpath, rb_intern("SyntaxError"));
+
+  rb_funcall(rb_mKernel, rb_intern("raise"), 1,
+    Nokogiri_wrap_xml_syntax_error(klass, error)
+  );
+}
+
+static void xpath_generic_exception_handler(void * ctx, const char *msg, ...)
+{
+  char * message;
+
+  va_list args;
+  va_start(args, msg);
+  vasprintf(&message, msg, args);
+  va_end(args);
+
+  rb_raise(rb_eRuntimeError, message);
+}
+
 /*
  * call-seq:
  *  evaluate(search_path)
@@ -141,7 +163,6 @@ static VALUE evaluate(int argc, VALUE *argv, VALUE self)
   VALUE search_path, xpath_handler;
   xmlXPathContextPtr ctx;
   Data_Get_Struct(self, xmlXPathContext, ctx);
-  VALUE error_list      = rb_ary_new();
 
   if(rb_scan_args(argc, argv, "11", &search_path, &xpath_handler) == 1)
     xpath_handler = Qnil;
@@ -155,9 +176,15 @@ static VALUE evaluate(int argc, VALUE *argv, VALUE self)
   }
 
   xmlResetLastError();
-  xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
+  xmlSetStructuredErrorFunc(NULL, xpath_exception_handler);
+
+  // For some reason, xmlXPathEvalExpression will blow up with a generic error
+  // when there is a non existent function.
+  xmlSetGenericErrorFunc(NULL, xpath_generic_exception_handler);
+
   xmlXPathObjectPtr xpath = xmlXPathEvalExpression(query, ctx);
   xmlSetStructuredErrorFunc(NULL, NULL);
+  xmlSetGenericErrorFunc(NULL, NULL);
 
   if(xpath == NULL) {
     VALUE xpath = rb_const_get(mNokogiriXml, rb_intern("XPath"));
@@ -172,13 +199,13 @@ static VALUE evaluate(int argc, VALUE *argv, VALUE self)
   VALUE xpath_object = Nokogiri_wrap_xml_xpath(xpath);
 
   assert(ctx->doc);
-  assert(ctx->doc->_private);
+  assert(DOC_RUBY_OBJECT_TEST(ctx->doc));
 
   rb_funcall( xpath_object,
               rb_intern("document="),
               1,
-              (VALUE)ctx->doc->_private
-    );
+              DOC_RUBY_OBJECT(ctx->doc)
+   );
   return xpath_object;
 }
 

data/lib/nokogiri.rb

@@ -15,6 +15,31 @@ 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.
+#
+# Parsing a document returns either a Nokogiri::XML::Document, or a
+# Nokogiri::HTML::Document depending on the kind of document you parse.
+#
+# Here is an example:
+#
+#   require 'nokogiri'
+#   require 'open-uri'
+#
+#   # Get a Nokogiri::HTML:Document for the page we’re interested in...
+#
+#   doc = Nokogiri::HTML(open('http://www.google.com/search?q=tenderlove'))
+#
+#   # Do funky things with it using Nokogiri::XML::Node methods...
+#
+#   ####
+#   # Search for nodes by css
+#   doc.css('h3.r a.l').each do |link|
+#     puts link.content
+#   end
+#
+# See Nokogiri::XML::Node#css for more information about CSS searching.
+# See Nokogiri::XML::Node#xpath for more information about XPath searching.
 module Nokogiri
   class << self
     ###