nokogiri 1.14.5-java → 1.15.0-java

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/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();

data/ext/nokogiri/xml_element_content.c

@@ -2,17 +2,22 @@
 
 VALUE cNokogiriXmlElementContent;
 
+static const rb_data_type_t element_content_data_type = {
+  .wrap_struct_name = "Nokogiri::XML::ElementContent",
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
 /*
  * call-seq:
- *  name
+ *   name → String
  *
- * Get the require element +name+
+ * [Returns] The content element's +name+
  */
 static VALUE
 get_name(VALUE self)
 {
   xmlElementContentPtr elem;
-  Data_Get_Struct(self, xmlElementContent, elem);
+  TypedData_Get_Struct(self, xmlElementContent, &element_content_data_type, elem);
 
   if (!elem->name) { return Qnil; }
   return NOKOGIRI_STR_NEW2(elem->name);
@@ -20,47 +25,40 @@ get_name(VALUE self)
 
 /*
  * call-seq:
- *  type
+ *   type → Integer
  *
- * Get the element content +type+.  Possible values are PCDATA, ELEMENT, SEQ,
- * or OR.
+ * [Returns] The content element's +type+. Possible values are +PCDATA+, +ELEMENT+, +SEQ+, or +OR+.
  */
 static VALUE
 get_type(VALUE self)
 {
   xmlElementContentPtr elem;
-  Data_Get_Struct(self, xmlElementContent, elem);
+  TypedData_Get_Struct(self, xmlElementContent, &element_content_data_type, elem);
 
   return INT2NUM(elem->type);
 }
 
 /*
- * call-seq:
- *  c1
- *
  * Get the first child.
  */
 static VALUE
 get_c1(VALUE self)
 {
   xmlElementContentPtr elem;
-  Data_Get_Struct(self, xmlElementContent, elem);
+  TypedData_Get_Struct(self, xmlElementContent, &element_content_data_type, elem);
 
   if (!elem->c1) { return Qnil; }
   return noko_xml_element_content_wrap(rb_iv_get(self, "@document"), elem->c1);
 }
 
 /*
- * call-seq:
- *  c2
- *
- * Get the first child.
+ * Get the second child.
  */
 static VALUE
 get_c2(VALUE self)
 {
   xmlElementContentPtr elem;
-  Data_Get_Struct(self, xmlElementContent, elem);
+  TypedData_Get_Struct(self, xmlElementContent, &element_content_data_type, elem);
 
   if (!elem->c2) { return Qnil; }
   return noko_xml_element_content_wrap(rb_iv_get(self, "@document"), elem->c2);
@@ -68,45 +66,50 @@ get_c2(VALUE self)
 
 /*
  * call-seq:
- *  occur
+ *   occur → Integer
  *
- * Get the element content +occur+ flag.  Possible values are ONCE, OPT, MULT
- * or PLUS.
+ * [Returns] The content element's +occur+ flag. Possible values are +ONCE+, +OPT+, +MULT+ or +PLUS+.
  */
 static VALUE
 get_occur(VALUE self)
 {
   xmlElementContentPtr elem;
-  Data_Get_Struct(self, xmlElementContent, elem);
+  TypedData_Get_Struct(self, xmlElementContent, &element_content_data_type, elem);
 
   return INT2NUM(elem->ocur);
 }
 
 /*
  * call-seq:
- *  prefix
+ *   prefix → String
  *
- * Get the element content namespace +prefix+.
+ * [Returns] The content element's namespace +prefix+.
  */
 static VALUE
 get_prefix(VALUE self)
 {
   xmlElementContentPtr elem;
-  Data_Get_Struct(self, xmlElementContent, elem);
+  TypedData_Get_Struct(self, xmlElementContent, &element_content_data_type, elem);
 
   if (!elem->prefix) { return Qnil; }
 
   return NOKOGIRI_STR_NEW2(elem->prefix);
 }
 
+/*
+ *  create a Nokogiri::XML::ElementContent object around an +element+.
+ */
 VALUE
-noko_xml_element_content_wrap(VALUE doc, xmlElementContentPtr element)
+noko_xml_element_content_wrap(VALUE rb_document, xmlElementContentPtr c_element_content)
 {
-  VALUE elem = Data_Wrap_Struct(cNokogiriXmlElementContent, 0, 0, element);
-
-  /* Setting the document is necessary so that this does not get GC'd until */
-  /* the document is GC'd */
-  rb_iv_set(elem, "@document", doc);
+  VALUE elem = TypedData_Wrap_Struct(
+                 cNokogiriXmlElementContent,
+                 &element_content_data_type,
+                 c_element_content
+               );
+
+  /* keep a handle on the document for GC marking */
+  rb_iv_set(elem, "@document", rb_document);
 
   return elem;
 }

data/ext/nokogiri/xml_element_decl.c

@@ -6,7 +6,7 @@ static ID id_document;
 
 /*
  * call-seq:
- *  element_type
+ *   element_type → Integer
  *
  * The element_type
  */
@@ -20,9 +20,9 @@ element_type(VALUE self)
 
 /*
  * call-seq:
- *  content
+ *   content → Nokogiri::XML::ElementContent
  *
- * The allowed content for this ElementDecl
+ * [Returns] The root of this element declaration's content tree.
  */
 static VALUE
 content(VALUE self)
@@ -40,9 +40,9 @@ content(VALUE self)
 
 /*
  * call-seq:
- *  prefix
+ *   prefix → String
  *
- * The namespace prefix for this ElementDecl
+ * [Returns] The namespace +prefix+ for this element declaration.
  */
 static VALUE
 prefix(VALUE self)

data/ext/nokogiri/xml_encoding_handler.c

@@ -2,14 +2,22 @@
 
 VALUE cNokogiriEncodingHandler;
 
-
 static void
-_xml_encoding_handler_dealloc(xmlCharEncodingHandlerPtr c_handler)
+xml_encoding_handler_dealloc(void *data)
 {
   /* make sure iconv handlers are cleaned up and freed */
+  xmlCharEncodingHandlerPtr c_handler = data;
   xmlCharEncCloseFunc(c_handler);
 }
 
+static const rb_data_type_t xml_encoding_handler_type = {
+  .wrap_struct_name = "Nokogiri::EncodingHandler",
+  .function = {
+    .dfree = xml_encoding_handler_dealloc,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
 
 /*
  * call-seq: Nokogiri::EncodingHandler.[](name)
@@ -23,7 +31,7 @@ rb_xml_encoding_handler_s_get(VALUE klass, VALUE key)
 
   handler = xmlFindCharEncodingHandler(StringValueCStr(key));
   if (handler) {
-    return Data_Wrap_Struct(klass, NULL, _xml_encoding_handler_dealloc, handler);
+    return TypedData_Wrap_Struct(klass, &xml_encoding_handler_type, handler);
   }
 
   return Qnil;
@@ -82,7 +90,7 @@ rb_xml_encoding_handler_name(VALUE self)
 {
   xmlCharEncodingHandlerPtr handler;
 
-  Data_Get_Struct(self, xmlCharEncodingHandler, handler);
+  TypedData_Get_Struct(self, xmlCharEncodingHandler, &xml_encoding_handler_type, handler);
 
   return NOKOGIRI_STR_NEW2(handler->name);
 }

data/ext/nokogiri/xml_entity_reference.c

@@ -20,7 +20,7 @@ new (int argc, VALUE *argv, VALUE klass)
 
   rb_scan_args(argc, argv, "2*", &document, &name, &rest);
 
-  Data_Get_Struct(document, xmlDoc, xml_doc);
+  xml_doc = noko_xml_document_unwrap(document);
 
   node = xmlNewReference(
            xml_doc,

data/ext/nokogiri/xml_namespace.c

@@ -56,21 +56,20 @@ _xml_namespace_update_references(void *ptr)
 #endif
 
 static const rb_data_type_t nokogiri_xml_namespace_type_with_dealloc = {
-  "Nokogiri/XMLNamespace/WithDealloc",
-  {0, _xml_namespace_dealloc, 0, _xml_namespace_update_references},
-  0, 0,
-#ifdef RUBY_TYPED_FREE_IMMEDIATELY
-  RUBY_TYPED_FREE_IMMEDIATELY,
-#endif
+  .wrap_struct_name = "Nokogiri::XML::Namespace#with_dealloc",
+  .function = {
+    .dfree = _xml_namespace_dealloc,
+    .dcompact = _xml_namespace_update_references,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 static const rb_data_type_t nokogiri_xml_namespace_type_without_dealloc = {
-  "Nokogiri/XMLNamespace/WithoutDealloc",
-  {0, 0, 0, _xml_namespace_update_references},
-  0, 0,
-#ifdef RUBY_TYPED_FREE_IMMEDIATELY
-  RUBY_TYPED_FREE_IMMEDIATELY,
-#endif
+  .wrap_struct_name = "Nokogiri::XML::Namespace#without_dealloc",
+  .function = {
+    .dcompact = _xml_namespace_update_references,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 /*

data/ext/nokogiri/xml_node.c

@@ -43,12 +43,12 @@ _xml_node_update_references(void *ptr)
 #endif
 
 static const rb_data_type_t nokogiri_node_type = {
-  "Nokogiri/XMLNode",
-  {_xml_node_mark, 0, 0, _xml_node_update_references},
-  0, 0,
-#ifdef RUBY_TYPED_FREE_IMMEDIATELY
-  RUBY_TYPED_FREE_IMMEDIATELY,
-#endif
+  .wrap_struct_name = "Nokogiri::XML::Node",
+  .function = {
+    .dmark = _xml_node_mark,
+    .dcompact = _xml_node_update_references,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
 static void
@@ -984,7 +984,7 @@ duplicate_node(int argc, VALUE *argv, VALUE self)
   if (n_args < 2) {
     new_parent_doc = node->doc;
   } else {
-    Data_Get_Struct(r_new_parent_doc, xmlDoc, new_parent_doc);
+    new_parent_doc = noko_xml_document_unwrap(r_new_parent_doc);
   }
 
   dup = xmlDocCopyNode(node, new_parent_doc, level);