nokogiri 1.14.3-x64-mingw-ucrt → 1.15.0-x64-mingw-ucrt

data/ext/nokogiri/include/libxslt/xsltlocale.h

@@ -14,63 +14,23 @@
 #include <libxml/xmlstring.h>
 #include "xsltexports.h"
 
-#ifdef HAVE_STRXFRM_L
-
-/*
- * XSLT_LOCALE_POSIX:
- * Macro indicating to use POSIX locale extensions
- */
-#define XSLT_LOCALE_POSIX
-
-#ifdef HAVE_LOCALE_H
-#include <locale.h>
-#endif
-#ifdef HAVE_XLOCALE_H
-#include <xlocale.h>
-#endif
-
-typedef locale_t xsltLocale;
-typedef xmlChar xsltLocaleChar;
-
-#elif defined(_WIN32)
-
-/*
- * XSLT_LOCALE_WINAPI:
- * Macro indicating to use WinAPI for extended locale support
- */
-#define XSLT_LOCALE_WINAPI
-
-#include <windows.h>
-#include <winnls.h>
-
-typedef LCID xsltLocale;
-typedef wchar_t xsltLocaleChar;
-
-#else
-
-/*
- * XSLT_LOCALE_NONE:
- * Macro indicating that there's no extended locale support
- */
-#define XSLT_LOCALE_NONE
-
-typedef void *xsltLocale;
-typedef xmlChar xsltLocaleChar;
-
-#endif
-
-XSLTPUBFUN xsltLocale XSLTCALL
-	xsltNewLocale			(const xmlChar *langName);
+XSLTPUBFUN void * XSLTCALL
+	xsltNewLocale			(const xmlChar *langName,
+					 int lowerFirst);
 XSLTPUBFUN void XSLTCALL
-	xsltFreeLocale			(xsltLocale locale);
-XSLTPUBFUN xsltLocaleChar * XSLTCALL
-	xsltStrxfrm			(xsltLocale locale,
+	xsltFreeLocale			(void *locale);
+XSLTPUBFUN xmlChar * XSLTCALL
+	xsltStrxfrm			(void *locale,
 					 const xmlChar *string);
-XSLTPUBFUN int XSLTCALL
-	xsltLocaleStrcmp		(xsltLocale locale,
-					 const xsltLocaleChar *str1,
-					 const xsltLocaleChar *str2);
 XSLTPUBFUN void XSLTCALL
 	xsltFreeLocales			(void);
 
+/* Backward compatibility */
+typedef void *xsltLocale;
+typedef xmlChar xsltLocaleChar;
+XSLTPUBFUN int XSLTCALL
+	xsltLocaleStrcmp		(void *locale,
+					 const xmlChar *str1,
+					 const xmlChar *str2);
+
 #endif /* __XML_XSLTLOCALE_H__ */

data/ext/nokogiri/include/libxslt/xsltutils.h

@@ -91,6 +91,13 @@ XSLTPUBFUN const xmlChar * XSLTCALL
 XSLTPUBFUN int XSLTCALL
 		xsltGetUTF8Char	(const unsigned char *utf,
 				 int *len);
+#ifdef IN_LIBXSLT
+/** DOC_DISABLE */
+XSLTPUBFUN int XSLTCALL
+		xsltGetUTF8CharZ (const unsigned char *utf,
+				  int *len);
+/** DOC_ENABLE */
+#endif
 
 /*
  * XSLT Debug Tracing Tracing Types
@@ -178,6 +185,11 @@ XSLTPUBFUN void XSLTCALL
 XSLTPUBFUN void XSLTCALL
 		xsltSetCtxtSortFunc		(xsltTransformContextPtr ctxt,
 						 xsltSortFunc handler);
+XSLTPUBFUN void XSLTCALL
+		xsltSetCtxtLocaleHandlers	(xsltTransformContextPtr ctxt,
+						 xsltNewLocaleFunc newLocale,
+						 xsltFreeLocaleFunc freeLocale,
+						 xsltGenSortKeyFunc genSortKey);
 XSLTPUBFUN void XSLTCALL
 		xsltDefaultSortFunction		(xsltTransformContextPtr ctxt,
 						 xmlNodePtr *sorts,
@@ -244,6 +256,24 @@ XSLTPUBFUN xmlXPathCompExprPtr XSLTCALL
 						 const xmlChar *str,
 						 int flags);
 
+#ifdef IN_LIBXSLT
+/** DOC_DISABLE */
+#define XSLT_SOURCE_NODE_MASK       15u
+#define XSLT_SOURCE_NODE_HAS_KEY    1u
+#define XSLT_SOURCE_NODE_HAS_ID     2u
+int
+xsltGetSourceNodeFlags(xmlNodePtr node);
+int
+xsltSetSourceNodeFlags(xsltTransformContextPtr ctxt, xmlNodePtr node,
+                       int flags);
+int
+xsltClearSourceNodeFlags(xmlNodePtr node, int flags);
+void **
+xsltGetPSVIPtr(xmlNodePtr cur);
+/** DOC_ENABLE */
+#endif
+
+#ifdef WITH_PROFILER
 /*
  * Profiling.
  */
@@ -257,6 +287,7 @@ XSLTPUBFUN long XSLTCALL
 		xsltTimestamp			(void);
 XSLTPUBFUN void XSLTCALL
 		xsltCalibrateAdjust		(long delta);
+#endif
 
 /**
  * XSLT_TIMESTAMP_TICS_PER_SEC:
@@ -289,10 +320,11 @@ typedef void (*xsltHandleDebuggerCallback) (xmlNodePtr cur, xmlNodePtr node,
 typedef int (*xsltAddCallCallback) (xsltTemplatePtr templ, xmlNodePtr source);
 typedef void (*xsltDropCallCallback) (void);
 
-XSLTPUBFUN void XSLTCALL
-		xsltSetDebuggerStatus		(int value);
 XSLTPUBFUN int XSLTCALL
 		xsltGetDebuggerStatus		(void);
+#ifdef WITH_DEBUGGER
+XSLTPUBFUN void XSLTCALL
+		xsltSetDebuggerStatus		(int value);
 XSLTPUBFUN int XSLTCALL
 		xsltSetDebuggerCallbacks	(int no, void *block);
 XSLTPUBFUN int XSLTCALL
@@ -300,6 +332,7 @@ XSLTPUBFUN int XSLTCALL
 						 xmlNodePtr source);
 XSLTPUBFUN void XSLTCALL
 		xslDropCall			(void);
+#endif
 
 #ifdef __cplusplus
 }

data/ext/nokogiri/nokogiri.c

@@ -137,6 +137,48 @@ noko_io_close(void *io)
 }
 
 
+#if defined(_WIN32) && !defined(NOKOGIRI_PACKAGED_LIBRARIES)
+#  define NOKOGIRI_WINDOWS_DLLS 1
+#else
+#  define NOKOGIRI_WINDOWS_DLLS 0
+#endif
+
+//
+//   |      dlls || true    | false   |
+//   | nlmm      ||         |         |
+//   |-----------++---------+---------|
+//   | NULL      || default | ruby    |
+//   | "random"  || default | ruby    |
+//   | "ruby"    || ruby    | ruby    |
+//   | "default" || default | default |
+//
+//   We choose *not* to use Ruby's memory management functions with windows DLLs because of this
+//   issue: https://github.com/sparklemotion/nokogiri/issues/2241
+//
+static void
+set_libxml_memory_management(void)
+{
+  const char *nlmm = getenv("NOKOGIRI_LIBXML_MEMORY_MANAGEMENT");
+  if (nlmm) {
+    if (strcmp(nlmm, "default") == 0) {
+      goto libxml_uses_default_memory_management;
+    } else if (strcmp(nlmm, "ruby") == 0) {
+      goto libxml_uses_ruby_memory_management;
+    }
+  }
+  if (NOKOGIRI_WINDOWS_DLLS) {
+libxml_uses_default_memory_management:
+    rb_const_set(mNokogiri, rb_intern("LIBXML_MEMORY_MANAGEMENT"), NOKOGIRI_STR_NEW2("default"));
+    return;
+  } else {
+libxml_uses_ruby_memory_management:
+    rb_const_set(mNokogiri, rb_intern("LIBXML_MEMORY_MANAGEMENT"), NOKOGIRI_STR_NEW2("ruby"));
+    xmlMemSetup((xmlFreeFunc)ruby_xfree, (xmlMallocFunc)ruby_xmalloc, (xmlReallocFunc)ruby_xrealloc, ruby_strdup);
+    return;
+  }
+}
+
+
 void
 Init_nokogiri(void)
 {
@@ -150,6 +192,10 @@ Init_nokogiri(void)
   mNokogiriXmlXpath = rb_define_module_under(mNokogiriXml, "XPath");
   mNokogiriXslt     = rb_define_module_under(mNokogiri, "XSLT");
 
+  set_libxml_memory_management(); /* must be before any function calls that might invoke xmlInitParser() */
+  xmlInitParser();
+  exsltRegisterAll();
+
   rb_const_set(mNokogiri, rb_intern("LIBXML_COMPILED_VERSION"), NOKOGIRI_STR_NEW2(LIBXML_DOTTED_VERSION));
   rb_const_set(mNokogiri, rb_intern("LIBXML_LOADED_VERSION"), NOKOGIRI_STR_NEW2(xmlParserVersion));
 
@@ -182,30 +228,6 @@ Init_nokogiri(void)
   rb_const_set(mNokogiri, rb_intern("OTHER_LIBRARY_VERSIONS"), NOKOGIRI_STR_NEW2(NOKOGIRI_OTHER_LIBRARY_VERSIONS));
 #endif
 
-#if defined(_WIN32) && !defined(NOKOGIRI_PACKAGED_LIBRARIES)
-  /*
-   *  We choose *not* to do use Ruby's memory management functions with windows DLLs because of this
-   *  issue in libxml 2.9.12:
-   *
-   *    https://github.com/sparklemotion/nokogiri/issues/2241
-   *
-   *  If the atexit() issue gets fixed in a future version of libxml2, then we may be able to skip
-   *  this config only for the specific libxml2 versions 2.9.12.
-   *
-   *  Alternatively, now that Ruby has a generational GC, it might be OK to let libxml2 use its
-   *  default memory management functions (recall that this config was introduced to reduce memory
-   *  bloat and allow Ruby to GC more often); but we should *really* test with production workloads
-   *  before making that kind of a potentially-invasive change.
-   */
-  rb_const_set(mNokogiri, rb_intern("LIBXML_MEMORY_MANAGEMENT"), NOKOGIRI_STR_NEW2("default"));
-#else
-  rb_const_set(mNokogiri, rb_intern("LIBXML_MEMORY_MANAGEMENT"), NOKOGIRI_STR_NEW2("ruby"));
-  xmlMemSetup((xmlFreeFunc)ruby_xfree, (xmlMallocFunc)ruby_xmalloc, (xmlReallocFunc)ruby_xrealloc, ruby_strdup);
-#endif
-
-  xmlInitParser();
-  exsltRegisterAll();
-
   if (xsltExtModuleFunctionLookup((const xmlChar *)"date-time", EXSLT_DATE_NAMESPACE)) {
     rb_const_set(mNokogiri, rb_intern("LIBXSLT_DATETIME_ENABLED"), Qtrue);
   } else {

data/ext/nokogiri/nokogiri.h

@@ -51,6 +51,7 @@
 #include <libxslt/xsltconfig.h>
 #include <libxslt/xsltutils.h>
 #include <libxslt/transform.h>
+#include <libxslt/imports.h>
 #include <libxslt/xsltInternals.h>
 
 #include <libexslt/exslt.h>
@@ -168,6 +169,7 @@ typedef struct _nokogiriXsltStylesheetTuple {
 
 void noko_xml_document_pin_node(xmlNodePtr);
 void noko_xml_document_pin_namespace(xmlNsPtr, xmlDocPtr);
+int noko_xml_document_has_wrapped_blank_nodes_p(xmlDocPtr c_document);
 
 int noko_io_read(void *ctx, char *buffer, int len);
 int noko_io_write(void *ctx, char *buffer, int len);
@@ -186,12 +188,21 @@ VALUE noko_xml_namespace_wrap_xpath_copy(xmlNsPtr node);
 VALUE noko_xml_element_content_wrap(VALUE doc, xmlElementContentPtr element);
 
 VALUE noko_xml_node_set_wrap(xmlNodeSetPtr node_set, VALUE document) ;
+xmlNodeSetPtr noko_xml_node_set_unwrap(VALUE rb_node_set) ;
 
 VALUE noko_xml_document_wrap_with_init_args(VALUE klass, xmlDocPtr doc, int argc, VALUE *argv);
 VALUE noko_xml_document_wrap(VALUE klass, xmlDocPtr doc);
+xmlDocPtr noko_xml_document_unwrap(VALUE rb_document);
 NOKOPUBFUN VALUE Nokogiri_wrap_xml_document(VALUE klass,
     xmlDocPtr doc); /* deprecated. use noko_xml_document_wrap() instead. */
 
+xmlSAXHandlerPtr noko_sax_handler_unwrap(VALUE rb_sax_handler);
+
+xmlParserCtxtPtr noko_xml_sax_push_parser_unwrap(VALUE rb_parser);
+
+VALUE noko_xml_sax_parser_context_wrap(VALUE klass, xmlParserCtxtPtr c_context);
+xmlParserCtxtPtr noko_xml_sax_parser_context_unwrap(VALUE rb_context);
+
 #define DOC_RUBY_OBJECT_TEST(x) ((nokogiriTuplePtr)(x->_private))
 #define DOC_RUBY_OBJECT(x) (((nokogiriTuplePtr)(x->_private))->doc)
 #define DOC_UNLINKED_NODE_HASH(x) (((nokogiriTuplePtr)(x->_private))->unlinkedNodes)
@@ -207,9 +218,9 @@ NOKOPUBFUN VALUE Nokogiri_wrap_xml_document(VALUE klass,
 #define DISCARD_CONST_QUAL_XMLCHAR(v) DISCARD_CONST_QUAL(xmlChar *, v)
 
 #if HAVE_RB_CATEGORY_WARNING
-#  define NOKO_WARN_DEPRECATION(message) rb_category_warning(RB_WARN_CATEGORY_DEPRECATED, message)
+#  define NOKO_WARN_DEPRECATION(message...) rb_category_warning(RB_WARN_CATEGORY_DEPRECATED, message)
 #else
-#  define NOKO_WARN_DEPRECATION(message) rb_warning(message)
+#  define NOKO_WARN_DEPRECATION(message...) rb_warning(message)
 #endif
 
 void Nokogiri_structured_error_func_save(libxmlStructuredErrorHandlerState *handler_state);

data/ext/nokogiri/xml_attr.c

@@ -68,7 +68,7 @@ new (int argc, VALUE *argv, VALUE klass)
     rb_raise(rb_eArgError, "parameter must be a Nokogiri::XML::Document");
   }
 
-  Noko_Node_Get_Struct(document, xmlDoc, xml_doc);
+  xml_doc = noko_xml_document_unwrap(document);
 
   node = xmlNewDocProp(
            xml_doc,

data/ext/nokogiri/xml_cdata.c

@@ -25,14 +25,22 @@ new (int argc, VALUE *argv, VALUE klass)
 
   rb_scan_args(argc, argv, "2*", &doc, &content, &rest);
 
-  Noko_Node_Get_Struct(doc, xmlDoc, xml_doc);
+  if (rb_obj_is_kind_of(doc, cNokogiriXmlDocument)) {
+    xml_doc = noko_xml_document_unwrap(doc);
+  } else {
+    xmlNodePtr deprecated_node_type_arg;
+    // TODO: deprecate allowing Node
+    NOKO_WARN_DEPRECATION("Passing a Node as the first parameter to CDATA.new is deprecated. Please pass a Document instead. This will become an error in a future release of Nokogiri.");
+    Noko_Node_Get_Struct(doc, xmlNode, deprecated_node_type_arg);
+    xml_doc = deprecated_node_type_arg->doc;
+  }
 
   if (!NIL_P(content)) {
     content_str = (xmlChar *)StringValuePtr(content);
     content_str_len = RSTRING_LENINT(content);
   }
 
-  node = xmlNewCDataBlock(xml_doc->doc, content_str, content_str_len);
+  node = xmlNewCDataBlock(xml_doc, content_str, content_str_len);
 
   noko_xml_document_pin_node(node);
 

data/ext/nokogiri/xml_comment.c

@@ -30,7 +30,7 @@ new (int argc, VALUE *argv, VALUE klass)
     rb_raise(rb_eArgError, "first argument must be a XML::Document or XML::Node");
   }
 
-  Data_Get_Struct(document, xmlDoc, xml_doc);
+  xml_doc = noko_xml_document_unwrap(document);
 
   node = xmlNewDocComment(
            xml_doc,

data/ext/nokogiri/xml_document.c

@@ -51,8 +51,9 @@ remove_private(xmlNodePtr node)
 }
 
 static void
-mark(xmlDocPtr doc)
+mark(void *data)
 {
+  xmlDocPtr doc = (xmlDocPtr)data;
   nokogiriTuplePtr tuple = (nokogiriTuplePtr)doc->_private;
   if (tuple) {
     rb_gc_mark(tuple->doc);
@@ -61,8 +62,9 @@ mark(xmlDocPtr doc)
 }
 
 static void
-dealloc(xmlDocPtr doc)
+dealloc(void *data)
 {
+  xmlDocPtr doc = (xmlDocPtr)data;
   st_table *node_hash;
 
   node_hash  = DOC_UNLINKED_NODE_HASH(doc);
@@ -72,18 +74,67 @@ dealloc(xmlDocPtr doc)
 
   ruby_xfree(doc->_private);
 
-  /* When both Nokogiri and libxml-ruby are loaded, make sure that all nodes
-   * have their _private pointers cleared. This is to avoid libxml-ruby's
-   * xmlDeregisterNode callback from accessing VALUE pointers from ruby's GC
-   * free context, which can result in segfaults.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations" // xmlDeregisterNodeDefault is deprecated as of libxml2 2.11.0
+  /*
+   * libxml-ruby < 3.0.0 uses xmlDeregisterNodeDefault. If the user is using one of those older
+   * versions, the registered callback from libxml-ruby will access the _private pointers set by
+   * nokogiri, which will result in segfaults.
+   *
+   * To avoid this, we need to clear the _private pointers from all nodes in this document tree
+   * before that callback gets invoked.
+   *
+   * libxml-ruby 3.0.0 was released in 2017-02, so at some point we can probably safely remove this
+   * safeguard (though probably pairing with a runtime check on the libxml-ruby version).
    */
   if (xmlDeregisterNodeDefaultValue) {
     remove_private((xmlNodePtr)doc);
   }
+#pragma GCC diagnostic pop
 
   xmlFreeDoc(doc);
 }
 
+static size_t
+memsize_node(const xmlNodePtr node)
+{
+  /* note we don't count namespace definitions, just going for a good-enough number here */
+  xmlNodePtr child;
+  size_t memsize = 0;
+
+  memsize += xmlStrlen(node->name);
+  for (child = (xmlNodePtr)node->properties; child; child = child->next) {
+    memsize += sizeof(xmlAttr) + memsize_node(child);
+  }
+  if (node->type == XML_TEXT_NODE) {
+    memsize += xmlStrlen(node->content);
+  }
+  for (child = node->children; child; child = child->next) {
+    memsize += sizeof(xmlNode) + memsize_node(child);
+  }
+  return memsize;
+}
+
+static size_t
+memsize(const void *data)
+{
+  xmlDocPtr doc = (const xmlDocPtr)data;
+  size_t memsize = sizeof(xmlDoc);
+  /* This may not account for all memory use */
+  memsize += memsize_node((xmlNodePtr)doc);
+  return memsize;
+}
+
+static const rb_data_type_t noko_xml_document_data_type = {
+  .wrap_struct_name = "Nokogiri::XML::Document",
+  .function = {
+    .dmark = mark,
+    .dfree = dealloc,
+    .dsize = memsize,
+  },
+  // .flags = RUBY_TYPED_FREE_IMMEDIATELY, // TODO see https://github.com/sparklemotion/nokogiri/issues/2822
+};
+
 static void
 recursively_remove_namespaces_from_node(xmlNodePtr node)
 {
@@ -126,8 +177,7 @@ recursively_remove_namespaces_from_node(xmlNodePtr node)
 static VALUE
 url(VALUE self)
 {
-  xmlDocPtr doc;
-  Data_Get_Struct(self, xmlDoc, doc);
+  xmlDocPtr doc = noko_xml_document_unwrap(self);
 
   if (doc->URL) { return NOKOGIRI_STR_NEW2(doc->URL); }
 
@@ -146,7 +196,7 @@ rb_xml_document_root_set(VALUE self, VALUE rb_new_root)
   xmlDocPtr c_document;
   xmlNodePtr c_new_root = NULL, c_current_root;
 
-  Data_Get_Struct(self, xmlDoc, c_document);
+  c_document = noko_xml_document_unwrap(self);
 
   c_current_root = xmlDocGetRootElement(c_document);
   if (c_current_root) {
@@ -190,7 +240,7 @@ rb_xml_document_root(VALUE self)
   xmlDocPtr c_document;
   xmlNodePtr c_root;
 
-  Data_Get_Struct(self, xmlDoc, c_document);
+  c_document = noko_xml_document_unwrap(self);
 
   c_root = xmlDocGetRootElement(c_document);
   if (!c_root) {
@@ -209,8 +259,7 @@ rb_xml_document_root(VALUE self)
 static VALUE
 set_encoding(VALUE self, VALUE encoding)
 {
-  xmlDocPtr doc;
-  Data_Get_Struct(self, xmlDoc, doc);
+  xmlDocPtr doc = noko_xml_document_unwrap(self);
 
   if (doc->encoding) {
     xmlFree(DISCARD_CONST_QUAL_XMLCHAR(doc->encoding));
@@ -230,8 +279,7 @@ set_encoding(VALUE self, VALUE encoding)
 static VALUE
 encoding(VALUE self)
 {
-  xmlDocPtr doc;
-  Data_Get_Struct(self, xmlDoc, doc);
+  xmlDocPtr doc = noko_xml_document_unwrap(self);
 
   if (!doc->encoding) { return Qnil; }
   return NOKOGIRI_STR_NEW2(doc->encoding);
@@ -246,8 +294,7 @@ encoding(VALUE self)
 static VALUE
 version(VALUE self)
 {
-  xmlDocPtr doc;
-  Data_Get_Struct(self, xmlDoc, doc);
+  xmlDocPtr doc = noko_xml_document_unwrap(self);
 
   if (!doc->version) { return Qnil; }
   return NOKOGIRI_STR_NEW2(doc->version);
@@ -369,7 +416,7 @@ duplicate_document(int argc, VALUE *argv, VALUE self)
     level = INT2NUM((long)1);
   }
 
-  Data_Get_Struct(self, xmlDoc, doc);
+  doc = noko_xml_document_unwrap(self);
 
   dup = xmlCopyDoc(doc, (int)NUM2INT(level));
 
@@ -442,8 +489,7 @@ new (int argc, VALUE *argv, VALUE klass)
 static VALUE
 remove_namespaces_bang(VALUE self)
 {
-  xmlDocPtr doc ;
-  Data_Get_Struct(self, xmlDoc, doc);
+  xmlDocPtr doc = noko_xml_document_unwrap(self);
 
   recursively_remove_namespaces_from_node((xmlNodePtr)doc);
   return self;
@@ -471,7 +517,7 @@ create_entity(int argc, VALUE *argv, VALUE self)
   xmlEntityPtr ptr;
   xmlDocPtr doc ;
 
-  Data_Get_Struct(self, xmlDoc, doc);
+  doc = noko_xml_document_unwrap(self);
 
   rb_scan_args(argc, argv, "14", &name, &type, &external_id, &system_id,
                &content);
@@ -559,7 +605,7 @@ rb_xml_document_canonicalize(int argc, VALUE *argv, VALUE self)
     }
   }
 
-  Data_Get_Struct(self, xmlDoc, c_doc);
+  c_doc = noko_xml_document_unwrap(self);
 
   rb_cStringIO = rb_const_get_at(rb_cObject, rb_intern("StringIO"));
   rb_io = rb_class_new_instance(0, 0, rb_cStringIO);
@@ -607,7 +653,7 @@ noko_xml_document_wrap_with_init_args(VALUE klass, xmlDocPtr c_document, int arg
     klass = cNokogiriXmlDocument;
   }
 
-  rb_document = Data_Wrap_Struct(klass, mark, dealloc, c_document);
+  rb_document = TypedData_Wrap_Struct(klass, &noko_xml_document_data_type, c_document);
 
   tuple = (nokogiriTuplePtr)ruby_xmalloc(sizeof(nokogiriTuple));
   tuple->doc = rb_document;
@@ -640,6 +686,40 @@ noko_xml_document_wrap(VALUE klass, xmlDocPtr doc)
   return noko_xml_document_wrap_with_init_args(klass, doc, 0, NULL);
 }
 
+xmlDocPtr
+noko_xml_document_unwrap(VALUE rb_document)
+{
+  xmlDocPtr c_document;
+  TypedData_Get_Struct(rb_document, xmlDoc, &noko_xml_document_data_type, c_document);
+  return c_document;
+}
+
+/* Schema creation will remove and deallocate "blank" nodes.
+ * If those blank nodes have been exposed to Ruby, they could get freed
+ * out from under the VALUE pointer.  This function checks to see if any of
+ * those nodes have been exposed to Ruby, and if so we should raise an exception.
+ */
+int
+noko_xml_document_has_wrapped_blank_nodes_p(xmlDocPtr c_document)
+{
+  VALUE cache = DOC_NODE_CACHE(c_document);
+
+  if (NIL_P(cache)) {
+    return 0;
+  }
+
+  for (long jnode = 0; jnode < RARRAY_LEN(cache); jnode++) {
+    xmlNodePtr node;
+    VALUE element = rb_ary_entry(cache, jnode);
+
+    Noko_Node_Get_Struct(element, xmlNode, node);
+    if (xmlIsBlankNode(node)) {
+      return 1;
+    }
+  }
+
+  return 0;
+}
 
 void
 noko_xml_document_pin_node(xmlNodePtr node)

data/ext/nokogiri/xml_document_fragment.c

@@ -19,7 +19,7 @@ new (int argc, VALUE *argv, VALUE klass)
 
   rb_scan_args(argc, argv, "1*", &document, &rest);
 
-  Data_Get_Struct(document, xmlDoc, xml_doc);
+  xml_doc = noko_xml_document_unwrap(document);
 
   node = xmlNewDocFragment(xml_doc->doc);
 

data/ext/nokogiri/xml_dtd.c

@@ -139,7 +139,7 @@ validate(VALUE self, VALUE document)
   VALUE error_list;
 
   Noko_Node_Get_Struct(self, xmlDtd, dtd);
-  Noko_Node_Get_Struct(document, xmlDoc, doc);
+  doc = noko_xml_document_unwrap(document);
   error_list = rb_ary_new();
 
   ctxt = xmlNewValidCtxt();