nokogiri-maglev- 1.5.0.1 → 1.5.2

data/ext/nokogiri/html_sax_parser_context.c

@@ -13,31 +13,35 @@ static void deallocate(xmlParserCtxtPtr ctxt)
   NOKOGIRI_DEBUG_END(handler);
 }
 
-static VALUE parse_memory(VALUE klass, VALUE data, VALUE encoding)
+static VALUE
+parse_memory(VALUE klass, VALUE data, VALUE encoding)
 {
-  htmlParserCtxtPtr ctxt;
-
-  if(NIL_P(data)) rb_raise(rb_eArgError, "data cannot be nil");
-  if(!(int)RSTRING_LEN(data))
-    rb_raise(rb_eRuntimeError, "data cannot be empty");
-
-  ctxt = htmlCreateMemoryParserCtxt(
-      StringValuePtr(data),
-      (int)RSTRING_LEN(data)
-  );
+    htmlParserCtxtPtr ctxt;
+
+    if (NIL_P(data))
+	rb_raise(rb_eArgError, "data cannot be nil");
+    if (!(int)RSTRING_LEN(data))
+	rb_raise(rb_eRuntimeError, "data cannot be empty");
+
+    ctxt = htmlCreateMemoryParserCtxt(StringValuePtr(data),
+				      (int)RSTRING_LEN(data));
+    if (ctxt->sax) {
+	xmlFree(ctxt->sax);
+	ctxt->sax = NULL;
+    }
 
-  if(RTEST(encoding)) {
-    xmlCharEncodingHandlerPtr enc = xmlFindCharEncodingHandler(StringValuePtr(encoding));
-    if(enc != NULL) {
-      xmlSwitchToEncoding(ctxt, enc);
-      if(ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
-        rb_raise(rb_eRuntimeError, "Unsupported encoding %s",
-            StringValuePtr(encoding));
-      }
+    if (RTEST(encoding)) {
+	xmlCharEncodingHandlerPtr enc = xmlFindCharEncodingHandler(StringValuePtr(encoding));
+	if (enc != NULL) {
+	    xmlSwitchToEncoding(ctxt, enc);
+	    if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
+		rb_raise(rb_eRuntimeError, "Unsupported encoding %s",
+			 StringValuePtr(encoding));
+	    }
+	}
     }
-  }
 
-  return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+    return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
 }
 
 static VALUE parse_file(VALUE klass, VALUE filename, VALUE encoding)
@@ -49,30 +53,48 @@ static VALUE parse_file(VALUE klass, VALUE filename, VALUE encoding)
   return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
 }
 
-static VALUE parse_with(VALUE self, VALUE sax_handler)
+static VALUE
+parse_doc(VALUE ctxt_val)
+{
+    htmlParserCtxtPtr ctxt = (htmlParserCtxtPtr)ctxt_val;
+    htmlParseDocument(ctxt);
+    return Qnil;
+}
+
+static VALUE
+parse_doc_finalize(VALUE ctxt_val)
 {
-  htmlParserCtxtPtr ctxt;
-  htmlSAXHandlerPtr sax;
+    htmlParserCtxtPtr ctxt = (htmlParserCtxtPtr)ctxt_val;
+
+    if (ctxt->myDoc)
+	xmlFreeDoc(ctxt->myDoc);
 
-  if(!rb_obj_is_kind_of_(sax_handler, cNokogiriXmlSaxParser))
-    rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::SAX::Parser");
+    NOKOGIRI_SAX_TUPLE_DESTROY(ctxt->userData);
+    return Qnil;
+}
+
+static VALUE
+parse_with(VALUE self, VALUE sax_handler)
+{
+    htmlParserCtxtPtr ctxt;
+    htmlSAXHandlerPtr sax;
 
-  Data_Get_Struct(self, htmlParserCtxt, ctxt);
-  Data_Get_Struct(sax_handler, htmlSAXHandler, sax);
+    if (!RTEST(rb_obj_is_kind_of(sax_handler, cNokogiriXmlSaxParser)))
+	rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::SAX::Parser");
 
-  /* Free the sax handler since we'll assign our own */
-  if(ctxt->sax && ctxt->sax != (xmlSAXHandlerPtr)&xmlDefaultSAXHandler)
-    xmlFree(ctxt->sax);
+    Data_Get_Struct(self, htmlParserCtxt, ctxt);
+    Data_Get_Struct(sax_handler, htmlSAXHandler, sax);
 
-  ctxt->sax = sax;
-  ctxt->userData = (void *)NOKOGIRI_SAX_TUPLE_NEW(ctxt, sax_handler);
+    /* Free the sax handler since we'll assign our own */
+    if (ctxt->sax && ctxt->sax != (xmlSAXHandlerPtr)&xmlDefaultSAXHandler)
+	xmlFree(ctxt->sax);
 
-  htmlParseDocument(ctxt);
+    ctxt->sax = sax;
+    ctxt->userData = (void *)NOKOGIRI_SAX_TUPLE_NEW(ctxt, sax_handler);
 
-  if(NULL != ctxt->myDoc) xmlFreeDoc(ctxt->myDoc);
+    rb_ensure(parse_doc, (VALUE)ctxt, parse_doc_finalize, (VALUE)ctxt);
 
-  NOKOGIRI_SAX_TUPLE_DESTROY(ctxt->userData);
-  return self;
+    return self;
 }
 
 void init_html_sax_parser_context()

data/ext/nokogiri/html_sax_push_parser.c

@@ -0,0 +1,87 @@
+#include <html_sax_push_parser.h>
+
+/*
+ * call-seq:
+ *  native_write(chunk, last_chunk)
+ *
+ * Write +chunk+ to PushParser. +last_chunk+ triggers the end_document handle
+ */
+static VALUE native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
+{
+  xmlParserCtxtPtr ctx;
+  const char * chunk  = NULL;
+  int size            = 0;
+
+
+  Data_Get_Struct(self, xmlParserCtxt, ctx);
+
+  if(Qnil != _chunk) {
+    chunk = StringValuePtr(_chunk);
+    size = (int)RSTRING_LEN(_chunk);
+  }
+
+  if(htmlParseChunk(ctx, chunk, size, Qtrue == _last_chunk ? 1 : 0)) {
+    if (!(ctx->options & XML_PARSE_RECOVER)) {
+      xmlErrorPtr e = xmlCtxtGetLastError(ctx);
+      Nokogiri_error_raise(NULL, e);
+    }
+  }
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *  initialize_native(xml_sax, filename)
+ *
+ * Initialize the push parser with +xml_sax+ using +filename+
+ */
+static VALUE initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename,
+			       VALUE encoding)
+{
+  htmlSAXHandlerPtr sax;
+  const char * filename = NULL;
+  htmlParserCtxtPtr ctx;
+  xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
+
+  Data_Get_Struct(_xml_sax, xmlSAXHandler, sax);
+
+  if(_filename != Qnil) filename = StringValuePtr(_filename);
+
+  if (!NIL_P(encoding)) {
+    enc = xmlParseCharEncoding(StringValuePtr(encoding));
+    if (enc == XML_CHAR_ENCODING_ERROR)
+      rb_raise(rb_eArgError, "Unsupported Encoding");
+  }
+
+  ctx = htmlCreatePushParserCtxt(
+      sax,
+      NULL,
+      NULL,
+      0,
+      filename,
+      enc
+  );
+  if(ctx == NULL)
+    rb_raise(rb_eRuntimeError, "Could not create a parser context");
+
+  ctx->userData = NOKOGIRI_SAX_TUPLE_NEW(ctx, self);
+
+  ctx->sax2 = 1;
+  rb_rdata_store(self, ctx); // DATA_PTR(self) = ctx;
+  return self;
+}
+
+VALUE cNokogiriHtmlSaxPushParser;
+void init_html_sax_push_parser()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE html = rb_define_module_under(nokogiri, "HTML");
+  VALUE sax = rb_define_module_under(html, "SAX");
+  VALUE klass = rb_define_class_under(sax, "PushParser", cNokogiriXmlSaxPushParser);
+
+  cNokogiriHtmlSaxPushParser = klass;
+
+  rb_define_private_method(klass, "initialize_native", initialize_native, 3);
+  rb_define_private_method(klass, "native_write", native_write, 2);
+}

data/ext/nokogiri/html_sax_push_parser.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_HTML_SAX_PUSH_PARSER
+#define NOKOGIRI_HTML_SAX_PUSH_PARSER
+
+#include <nokogiri.h>
+
+void init_html_sax_push_parser();
+
+extern VALUE cNokogiriHtmlSaxPushParser ;
+#endif

data/ext/nokogiri/nokogiri.c

@@ -35,20 +35,17 @@ void vasprintf_free (void *p)
 }
 #endif
 
+#ifdef HAVE_RUBY_UTIL_H
+#include "ruby/util.h"
+#else
 #ifndef __MACRUBY__
-/* Allocate strdupped strings with the same memory allocator Ruby uses. */
-static char *ruby_strdup(const char *s)
-{
-  size_t len = strlen(s);
-  char *result = ruby_xmalloc((ssize_t) (len + 1));
-  memcpy(result, s, len + 1);
-  return result;
-}
+#include "util.h"
+#endif
 #endif
 
 void Init_nokogiri()
 {
-#ifndef __MACRUBY__
+#if !(defined __MACRUBY__) && !(defined MAGLEV)
   xmlMemSetup(
       (xmlFreeFunc)ruby_xfree,
       (xmlMallocFunc)ruby_xmalloc,
@@ -104,6 +101,7 @@ void Init_nokogiri()
   init_xml_entity_decl();
   init_xml_namespace();
   init_html_sax_parser_context();
+  init_html_sax_push_parser();
   init_xslt_stylesheet();
   init_xml_syntax_error();
   init_html_entity_lookup();

data/ext/nokogiri/nokogiri.h

@@ -27,7 +27,9 @@ int vasprintf (char **strp, const char *fmt, va_list ap);
 #include <libxml/HTMLparser.h>
 #include <libxml/HTMLtree.h>
 #include <libxml/relaxng.h>
+#include <libxml/xinclude.h>
 #include <libxslt/extensions.h>
+#include <libxml/c14n.h>
 #include <ruby.h>
 
 #ifdef HAVE_RUBY_ENCODING_H
@@ -102,6 +104,7 @@ int vasprintf (char **strp, const char *fmt, va_list ap);
 #include <xml_sax_push_parser.h>
 #include <xml_reader.h>
 #include <html_sax_parser_context.h>
+#include <html_sax_push_parser.h>
 #include <xslt_stylesheet.h>
 #include <xml_syntax_error.h>
 #include <xml_schema.h>

data/ext/nokogiri/xml_document.c

@@ -48,12 +48,15 @@ static void recursively_remove_namespaces_from_node(xmlNodePtr node)
   for (child = node->children ; child ; child = child->next)
     recursively_remove_namespaces_from_node(child);
 
-  if (node->nsDef) {
+  if (((node->type == XML_ELEMENT_NODE) ||
+       (node->type == XML_XINCLUDE_START) ||
+       (node->type == XML_XINCLUDE_END)) &&
+      node->nsDef) {
     xmlFreeNsList(node->nsDef);
     node->nsDef = NULL;
   }
 
-  if (node->properties != NULL) {
+  if (node->type == XML_ELEMENT_NODE && node->properties != NULL) {
     property = node->properties ;
     while (property != NULL) {
       if (property->ns) property->ns = NULL ;
@@ -152,6 +155,9 @@ static VALUE set_encoding(VALUE self, VALUE encoding)
   xmlDocPtr doc;
   Data_Get_Struct(self, xmlDoc, doc);
 
+  if (doc->encoding)
+      free((char *) doc->encoding); // this may produce a gcc cast warning
+
   doc->encoding = xmlStrdup((xmlChar *)StringValuePtr(encoding));
 
   return encoding;
@@ -421,6 +427,97 @@ static VALUE create_entity(int argc, VALUE *argv, VALUE self)
   return Nokogiri_wrap_xml_node(cNokogiriXmlEntityDecl, (xmlNodePtr)ptr);
 }
 
+static int block_caller(void * ctx, xmlNodePtr _node, xmlNodePtr _parent)
+{
+  VALUE block;
+  VALUE node;
+  VALUE parent;
+  VALUE ret;
+
+  if(_node->type == XML_NAMESPACE_DECL){
+    node = Nokogiri_wrap_xml_namespace(_parent->doc, (xmlNsPtr) _node);
+  }
+  else{
+    node   = Nokogiri_wrap_xml_node(Qnil, _node);
+  }
+  parent = _parent ? Nokogiri_wrap_xml_node(Qnil, _parent) : Qnil;
+  block  = (VALUE)ctx;
+
+  ret = rb_funcall(block, rb_intern("call"), 2, node, parent);
+
+  if(Qfalse == ret || Qnil == ret) return 0;
+
+  return 1;
+}
+
+/* call-seq:
+ *  doc.canonicalize(mode=XML_C14N_1_0,inclusive_namespaces=nil,with_comments=false)
+ *  doc.canonicalize { |obj, parent| ... }
+ *
+ * Canonicalize a document and return the results.  Takes an optional block
+ * that takes two parameters: the +obj+ and that node's +parent+.  
+ * The  +obj+ will be either a Nokogiri::XML::Node, or a Nokogiri::XML::Namespace
+ * The block must return a non-nil, non-false value if the +obj+ passed in 
+ * should be included in the canonicalized document.
+ */
+static VALUE canonicalize(int argc, VALUE* argv, VALUE self)
+{
+  VALUE mode;
+  VALUE incl_ns;
+  VALUE with_comments;
+  xmlChar **ns;
+  long ns_len, i;
+
+  xmlDocPtr doc;
+  xmlOutputBufferPtr buf;
+  xmlC14NIsVisibleCallback cb = NULL;
+  void * ctx = NULL;
+
+  VALUE rb_cStringIO;
+  VALUE io;
+
+  rb_scan_args(argc, argv, "03", &mode, &incl_ns, &with_comments);
+
+  Data_Get_Struct(self, xmlDoc, doc);
+
+  rb_cStringIO = rb_const_get_at(rb_cObject, rb_intern("StringIO"));
+  io           = rb_class_new_instance(0, 0, rb_cStringIO);
+  buf          = xmlAllocOutputBuffer(NULL);
+
+  buf->writecallback = (xmlOutputWriteCallback)io_write_callback;
+  buf->closecallback = (xmlOutputCloseCallback)io_close_callback;
+  buf->context       = (void *)io;
+
+  if(rb_block_given_p()) {
+    cb = block_caller;
+    ctx = (void *)rb_block_proc();
+  }
+
+  if(NIL_P(incl_ns)){
+    ns = NULL;
+  }
+  else{
+    ns_len = RARRAY_LEN(incl_ns);
+    ns = calloc((size_t)ns_len+1, sizeof(xmlChar *));
+    for (i = 0 ; i < ns_len ; i++) {
+      VALUE entry = rb_ary_entry(incl_ns, i);
+      const char * ptr = StringValuePtr(entry);
+      ns[i] = (xmlChar*) ptr;
+    }
+  }
+
+
+  xmlC14NExecute(doc, cb, ctx, 
+    (int)      (NIL_P(mode)        ? 0 : NUM2INT(mode)), 
+    ns,
+    (int)      (NIL_P(with_comments)        ? 0 : 1),
+    buf);
+
+  xmlOutputBufferClose(buf);
+
+  return rb_funcall(io, rb_intern("string"), 0);
+}
+
 VALUE cNokogiriXmlDocument ;
 void init_xml_document()
 {
@@ -444,6 +541,7 @@ void init_xml_document()
   rb_define_method(klass, "encoding", encoding, 0);
   rb_define_method(klass, "encoding=", set_encoding, 1);
   rb_define_method(klass, "version", version, 0);
+  rb_define_method(klass, "canonicalize", canonicalize, -1);
   rb_define_method(klass, "dup", duplicate_node, -1);
   rb_define_method(klass, "url", url, 0);
   rb_define_method(klass, "create_entity", create_entity, -1);
@@ -467,7 +565,7 @@ VALUE Nokogiri_wrap_xml_document(VALUE klass, xmlDocPtr doc)
   rb_iv_set(rb_doc, "@decorators", Qnil);
   rb_iv_set(rb_doc, "@node_cache", cache);
 
-  tuple->doc = (void *)rb_doc;
+  tuple->doc = rb_doc;
   tuple->unlinkedNodes = st_init_numtable_with_size(128);
   tuple->node_cache = cache;
   doc->_private = tuple ;

data/ext/nokogiri/xml_document.h

@@ -4,7 +4,7 @@
 #include <nokogiri.h>
 
 struct _nokogiriTuple {
-  xmlDocPtr     doc;
+  VALUE         doc;
   st_table     *unlinkedNodes;
   VALUE         node_cache;
 };
@@ -15,9 +15,9 @@ 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_RUBY_OBJECT(x) (((nokogiriTuplePtr)(x->_private))->doc)
 #define DOC_UNLINKED_NODE_HASH(x) (((nokogiriTuplePtr)(x->_private))->unlinkedNodes)
-#define DOC_NODE_CACHE(x) ((VALUE)((nokogiriTuplePtr)(x->_private))->node_cache)
+#define DOC_NODE_CACHE(x) (((nokogiriTuplePtr)(x->_private))->node_cache)
 
 extern VALUE cNokogiriXmlDocument ;
 #endif

data/ext/nokogiri/xml_node.c

@@ -138,7 +138,8 @@ static VALUE reparent_node_with(VALUE pivot_obj, VALUE reparentee_obj, pivot_rep
     }
   }
 
-  if (reparentee->type == XML_TEXT_NODE && pivot->next && pivot->next->type == XML_TEXT_NODE) {
+  if (prf != xmlAddPrevSibling && prf != xmlAddNextSibling
+      && reparentee->type == XML_TEXT_NODE && pivot->next && pivot->next->type == XML_TEXT_NODE) {
     /*
      *  libxml merges text nodes in a right-to-left fashion, meaning that if
      *  there are two text nodes who would be adjacent, the right (or following,
@@ -484,7 +485,13 @@ static VALUE previous_element(VALUE self)
 /* :nodoc: */
 static VALUE replace(VALUE self, VALUE new_node)
 {
-  return reparent_node_with(self, new_node, xmlReplaceNodeWrapper) ;
+    VALUE reparent = reparent_node_with(self, new_node, xmlReplaceNodeWrapper);
+
+    xmlNodePtr pivot;
+    Data_Get_Struct(self, xmlNode, pivot);
+    NOKOGIRI_ROOT_NODE(pivot);
+
+    return reparent;
 }
 
 /*
@@ -658,9 +665,28 @@ static VALUE namespaced_key_eh(VALUE self, VALUE attribute, VALUE namespace)
  */
 static VALUE set(VALUE self, VALUE property, VALUE value)
 {
-  xmlNodePtr node;
+  xmlNodePtr node, cur;
+  xmlAttrPtr prop;
   Data_Get_Struct(self, xmlNode, node);
 
+  /* If a matching attribute node already exists, then xmlSetProp will destroy
+   * the existing node's children. However, if Nokogiri has a node object
+   * pointing to one of those children, we are left with a broken reference.
+   *
+   * We can avoid this by unlinking these nodes first.
+   */
+  if (node->type != XML_ELEMENT_NODE)
+    return(Qnil);
+  prop = xmlHasProp(node, (xmlChar *)StringValuePtr(property));
+  if (prop && prop->children) {
+    for (cur = prop->children; cur; cur = cur->next) {
+      if (cur->_private) {
+        NOKOGIRI_ROOT_NODE(cur);
+        xmlUnlinkNode(cur);
+      }
+    }
+  }
+
   xmlSetProp(node, (xmlChar *)StringValuePtr(property),
       (xmlChar *)StringValuePtr(value));
 
@@ -1157,73 +1183,134 @@ static VALUE compare(VALUE self, VALUE _other)
 }
 
 
-/* TODO: DOCUMENT ME */
-static VALUE in_context(VALUE self, VALUE _str, VALUE _options)
+/*
+ * call-seq:
+ *   process_xincludes(options)
+ *
+ * Loads and substitutes all xinclude elements below the node. The
+ * parser context will be initialized with +options+.
+ */
+static VALUE process_xincludes(VALUE self, VALUE options)
 {
+  int rcode ;
   xmlNodePtr node;
-  xmlNodePtr list;
-  xmlNodePtr child_iter;
-  xmlNodeSetPtr set;
-  xmlParserErrors error;
-  VALUE doc, err;
+  VALUE error_list = rb_ary_new();
 
   Data_Get_Struct(self, xmlNode, node);
 
-  doc = DOC_RUBY_OBJECT(node->doc);
-  err = rb_iv_get(doc, "@errors");
+  xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
+  rcode = xmlXIncludeProcessTreeFlags(node, (int)NUM2INT(options));
+  xmlSetStructuredErrorFunc(NULL, NULL);
 
-  xmlSetStructuredErrorFunc((void *)err, Nokogiri_error_array_pusher);
+  if (rcode < 0) {
+    xmlErrorPtr error;
 
-  /* Twiddle global variable because of a bug in libxml2.
-   * http://git.gnome.org/browse/libxml2/commit/?id=e20fb5a72c83cbfc8e4a8aa3943c6be8febadab7
-   */
+    error = xmlGetLastError();
+    if(error)
+      rb_exc_raise(Nokogiri_wrap_xml_syntax_error((VALUE)NULL, error));
+    else
+      rb_raise(rb_eRuntimeError, "Could not perform xinclude substitution");
+  }
+
+  return self;
+}
+
+
+/* TODO: DOCUMENT ME */
+static VALUE in_context(VALUE self, VALUE _str, VALUE _options)
+{
+    xmlNodePtr node, list, child_iter, tmp, node_children, doc_children;
+    xmlNodeSetPtr set;
+    xmlParserErrors error;
+    VALUE doc, err;
+    int doc_is_empty;
+
+    Data_Get_Struct(self, xmlNode, node);
+
+    doc = DOC_RUBY_OBJECT(node->doc);
+    err = rb_iv_get(doc, "@errors");
+    doc_is_empty = (node->doc->children == NULL) ? 1 : 0;
+    node_children = node->children;
+    doc_children  = node->doc->children;
+
+    xmlSetStructuredErrorFunc((void *)err, Nokogiri_error_array_pusher);
+
+    /* Twiddle global variable because of a bug in libxml2.
+     * http://git.gnome.org/browse/libxml2/commit/?id=e20fb5a72c83cbfc8e4a8aa3943c6be8febadab7
+     */
 #ifndef HTML_PARSE_NOIMPLIED
-  htmlHandleOmittedElem(0);
+    htmlHandleOmittedElem(0);
 #endif
 
-  error = xmlParseInNodeContext(
-      node,
-      StringValuePtr(_str),
-      (int)RSTRING_LEN(_str),
-      (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 ;
-  }
+    /* This function adds a fake node to the child of +node+.  If the parser
+     * does not exit cleanly with XML_ERR_OK, the list is freed.  This can
+     * leave the child pointers in a bad state if they were originally empty.
+     *
+     * http://git.gnome.org/browse/libxml2/tree/parser.c#n13177
+     * */
+    error = xmlParseInNodeContext(node, StringValuePtr(_str),
+				  (int)RSTRING_LEN(_str),
+				  (int)NUM2INT(_options), &list);
+
+    /* xmlParseInNodeContext should not mutate the original document or node,
+     * so reassigning these pointers should be OK.  The reason we're reassigning
+     * is because if there were errors, it's possible for the child pointers
+     * to be manipulated. */
+    if (error != XML_ERR_OK) {
+	node->doc->children = doc_children;
+	node->children = node_children;
+    }
+
+    /* 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);
+    htmlHandleOmittedElem(1);
 #endif
 
-  xmlSetStructuredErrorFunc(NULL, NULL);
+    xmlSetStructuredErrorFunc(NULL, NULL);
 
-  /* FIXME: This probably needs to handle more constants... */
-  switch(error) {
-    case XML_ERR_OK:
-      break;
-
-    case XML_ERR_INTERNAL_ERROR:
-    case XML_ERR_NO_MEMORY:
-      rb_raise(rb_eRuntimeError, "error parsing fragment (%d)", error);
-      break;
+    /* Workaround for a libxml2 bug where a parsing error may leave a broken
+     * node reference in node->doc->children.
+     * This workaround is limited to when a parse error occurs, the document
+     * went from having no children to having children, and the context node is
+     * part of a document fragment.
+     * https://bugzilla.gnome.org/show_bug.cgi?id=668155
+     */
+    if (error != XML_ERR_OK && doc_is_empty && node->doc->children != NULL) {
+	tmp = node;
+	while (tmp->parent)
+	    tmp = tmp->parent;
+	
+	if (tmp->type == XML_DOCUMENT_FRAG_NODE)
+	    node->doc->children = NULL;
+    }
 
-    default:
-      break;
-  }
+    /* FIXME: This probably needs to handle more constants... */
+    switch (error) {
+      case XML_ERR_INTERNAL_ERROR:
+      case XML_ERR_NO_MEMORY:
+	rb_raise(rb_eRuntimeError, "error parsing fragment (%d)", error);
+	break;
+      default:
+	break;
+    }
 
-  set = xmlXPathNodeSetCreate(NULL);
+    set = xmlXPathNodeSetCreate(NULL);
 
-  while(list) {
-    xmlXPathNodeSetAddUnique(set, list);
-    list = list->next;
-  }
+    while (list) {
+      xmlXPathNodeSetAddUnique(set, list);
+      list = list->next;
+    }
 
-  return Nokogiri_wrap_xml_node_set(set, doc);
+    return Nokogiri_wrap_xml_node_set(set, doc);
 }
 
 static VALUE sym_iv_doc = Qnil;
@@ -1234,7 +1321,7 @@ 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 ;
+  nokogiriTuplePtr node_has_a_document;
   void (*mark_method)(xmlNodePtr) = NULL ;
 
   assert(node);
@@ -1242,7 +1329,13 @@ VALUE Nokogiri_wrap_xml_node(VALUE klass, xmlNodePtr node)
   if(node->type == XML_DOCUMENT_NODE || node->type == XML_HTML_DOCUMENT_NODE)
       return DOC_RUBY_OBJECT(node->doc);
 
-  if(NULL != node->_private) return (VALUE)node->_private;
+  /* 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);
+
+  if(node->_private && node_has_a_document)
+    return (VALUE)node->_private;
 
   if (!RTEST(klass)) {
     switch(node->type) {
@@ -1288,10 +1381,7 @@ VALUE Nokogiri_wrap_xml_node(VALUE klass, xmlNodePtr 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 ;
 
   if (DOC_RUBY_OBJECT_TEST(node->doc)) {  // maglev workaround , no gc mark
     VALUE ref = DOC_RUBY_OBJECT(node->doc);
@@ -1363,7 +1453,6 @@ void init_xml_node()
   rb_define_method(klass, "key?", key_eh, 1);
   rb_define_method(klass, "namespaced_key?", namespaced_key_eh, 2);
   rb_define_method(klass, "blank?", blank_eh, 0);
-  rb_define_method(klass, "[]=", set, 2);
   rb_define_method(klass, "attribute_nodes", attribute_nodes, 0);
   rb_define_method(klass, "attribute", attr, 1);
   rb_define_method(klass, "attribute_with_ns", attribute_with_ns, 2);
@@ -1380,6 +1469,7 @@ void init_xml_node()
   rb_define_method(klass, "pointer_id", pointer_id, 0);
   rb_define_method(klass, "line", line, 0);
 
+  rb_define_private_method(klass, "process_xincludes", process_xincludes, 1);
   rb_define_private_method(klass, "in_context", in_context, 2);
   rb_define_private_method(klass, "add_child_node", add_child, 1);
   rb_define_private_method(klass, "add_previous_sibling_node", add_previous_sibling, 1);
@@ -1389,9 +1479,12 @@ void init_xml_node()
   rb_define_private_method(klass, "native_write_to", native_write_to, 4);
   rb_define_private_method(klass, "native_content=", set_content, 1);
   rb_define_private_method(klass, "get", get, 1);
+  rb_define_private_method(klass, "set", set, 2);
   rb_define_private_method(klass, "set_namespace", set_namespace, 1);
   rb_define_private_method(klass, "compare", compare, 1);
 
   decorate      = rb_intern("decorate");
   decorate_bang = rb_intern("decorate!");
 }
+
+/* vim: set noet sw=4 sws=4 */