nokogiri 1.12.5 → 1.13.10

data/ext/nokogiri/xml_node_set.c

@@ -156,7 +156,7 @@ push(VALUE self, VALUE rb_node)
   Check_Node_Set_Node_Type(rb_node);
 
   Data_Get_Struct(self, xmlNodeSet, node_set);
-  Data_Get_Struct(rb_node, xmlNode, node);
+  Noko_Node_Get_Struct(rb_node, xmlNode, node);
 
   xmlXPathNodeSetAdd(node_set, node);
 
@@ -179,7 +179,7 @@ delete (VALUE self, VALUE rb_node)
   Check_Node_Set_Node_Type(rb_node);
 
   Data_Get_Struct(self, xmlNodeSet, node_set);
-  Data_Get_Struct(rb_node, xmlNode, node);
+  Noko_Node_Get_Struct(rb_node, xmlNode, node);
 
   if (xmlXPathNodeSetContains(node_set, node)) {
     xpath_node_set_del(node_set, node);
@@ -228,7 +228,7 @@ include_eh(VALUE self, VALUE rb_node)
   Check_Node_Set_Node_Type(rb_node);
 
   Data_Get_Struct(self, xmlNodeSet, node_set);
-  Data_Get_Struct(rb_node, xmlNode, node);
+  Noko_Node_Get_Struct(rb_node, xmlNode, node);
 
   return (xmlXPathNodeSetContains(node_set, node) ? Qtrue : Qfalse);
 }
@@ -430,7 +430,7 @@ unlink_nodeset(VALUE self)
       xmlNodePtr node_ptr;
       node = noko_xml_node_wrap(Qnil, 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);
+      Noko_Node_Get_Struct(node, xmlNode, node_ptr);
       node_set->nodeTab[j] = node_ptr ;
     }
   }

data/ext/nokogiri/xml_reader.c

@@ -31,6 +31,7 @@ has_attributes(xmlTextReaderPtr reader)
   return (0);
 }
 
+// TODO: merge this function into the `namespaces` method implementation
 static void
 Nokogiri_xml_node_namespaces(xmlNodePtr node, VALUE attr_hash)
 {
@@ -148,9 +149,13 @@ namespaces(VALUE self)
 }
 
 /*
- * @overload attribute_nodes()
- *   Get the attributes of the current node as an Array of Attr
- *   @return [Array<Nokogiri::XML::Attr>]
+  :call-seq: attribute_nodes() → Array<Nokogiri::XML::Attr>
+
+  Get the attributes of the current node as an Array of XML:Attr
+
+  ⚠ This method is deprecated and unsafe to use. It will be removed in a future version of Nokogiri.
+
+  See related: #attribute_hash, #attributes
  */
 static VALUE
 rb_xml_reader_attribute_nodes(VALUE rb_reader)
@@ -160,6 +165,10 @@ rb_xml_reader_attribute_nodes(VALUE rb_reader)
   VALUE attr_nodes;
   int j;
 
+  // TODO: deprecated, remove in Nokogiri v1.15, see https://github.com/sparklemotion/nokogiri/issues/2598
+  // After removal, we can also remove all the "node_has_a_document" special handling from xml_node.c
+  NOKO_WARN_DEPRECATION("Reader#attribute_nodes is deprecated and will be removed in a future version of Nokogiri. Please use Reader#attribute_hash instead.");
+
   Data_Get_Struct(rb_reader, xmlTextReader, c_reader);
 
   if (! has_attributes(c_reader)) {
@@ -181,6 +190,51 @@ rb_xml_reader_attribute_nodes(VALUE rb_reader)
   return attr_nodes;
 }
 
+/*
+  :call-seq: attribute_hash() → Hash<String ⇒ String>
+
+  Get the attributes of the current node as a Hash of names and values.
+
+  See related: #attributes and #namespaces
+ */
+static VALUE
+rb_xml_reader_attribute_hash(VALUE rb_reader)
+{
+  VALUE rb_attributes = rb_hash_new();
+  xmlTextReaderPtr c_reader;
+  xmlNodePtr c_node;
+  xmlAttrPtr c_property;
+
+  Data_Get_Struct(rb_reader, xmlTextReader, c_reader);
+
+  if (!has_attributes(c_reader)) {
+    return rb_attributes;
+  }
+
+  c_node = xmlTextReaderExpand(c_reader);
+  if (c_node == NULL) {
+    return Qnil;
+  }
+
+  c_property = c_node->properties;
+  while (c_property != NULL) {
+    VALUE rb_name = NOKOGIRI_STR_NEW2(c_property->name);
+    VALUE rb_value = Qnil;
+    xmlChar *c_value = xmlNodeGetContent((xmlNode *)c_property);
+
+    if (c_value) {
+      rb_value = NOKOGIRI_STR_NEW2(c_value);
+      xmlFree(c_value);
+    }
+
+    rb_hash_aset(rb_attributes, rb_name, rb_value);
+
+    c_property = c_property->next;
+  }
+
+  return rb_attributes;
+}
+
 /*
  * call-seq:
  *   attribute_at(index)
@@ -414,16 +468,23 @@ name(VALUE self)
  * Get the xml:base of the node
  */
 static VALUE
-base_uri(VALUE self)
+rb_xml_reader_base_uri(VALUE rb_reader)
 {
-  xmlTextReaderPtr reader;
-  const char *base_uri;
+  VALUE rb_base_uri;
+  xmlTextReaderPtr c_reader;
+  xmlChar *c_base_uri;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
-  base_uri = (const char *)xmlTextReaderBaseUri(reader);
-  if (base_uri == NULL) { return Qnil; }
+  Data_Get_Struct(rb_reader, xmlTextReader, c_reader);
 
-  return NOKOGIRI_STR_NEW2(base_uri);
+  c_base_uri = xmlTextReaderBaseUri(c_reader);
+  if (c_base_uri == NULL) {
+    return Qnil;
+  }
+
+  rb_base_uri = NOKOGIRI_STR_NEW2(c_base_uri);
+  xmlFree(c_base_uri);
+
+  return rb_base_uri;
 }
 
 /*
@@ -652,6 +713,24 @@ empty_element_p(VALUE self)
   return Qfalse;
 }
 
+static VALUE
+rb_xml_reader_encoding(VALUE rb_reader)
+{
+  xmlTextReaderPtr c_reader;
+  const char *parser_encoding;
+  VALUE constructor_encoding;
+
+  constructor_encoding = rb_iv_get(rb_reader, "@encoding");
+  if (RTEST(constructor_encoding)) {
+    return constructor_encoding;
+  }
+
+  Data_Get_Struct(rb_reader, xmlTextReader, c_reader);
+  parser_encoding = (const char *)xmlTextReaderConstEncoding(c_reader);
+  if (parser_encoding == NULL) { return Qnil; }
+  return NOKOGIRI_STR_NEW2(parser_encoding);
+}
+
 void
 noko_init_xml_reader()
 {
@@ -671,11 +750,13 @@ noko_init_xml_reader()
   rb_define_method(cNokogiriXmlReader, "attribute_at", attribute_at, 1);
   rb_define_method(cNokogiriXmlReader, "attribute_count", attribute_count, 0);
   rb_define_method(cNokogiriXmlReader, "attribute_nodes", rb_xml_reader_attribute_nodes, 0);
+  rb_define_method(cNokogiriXmlReader, "attribute_hash", rb_xml_reader_attribute_hash, 0);
   rb_define_method(cNokogiriXmlReader, "attributes?", attributes_eh, 0);
-  rb_define_method(cNokogiriXmlReader, "base_uri", base_uri, 0);
+  rb_define_method(cNokogiriXmlReader, "base_uri", rb_xml_reader_base_uri, 0);
   rb_define_method(cNokogiriXmlReader, "default?", default_eh, 0);
   rb_define_method(cNokogiriXmlReader, "depth", depth, 0);
   rb_define_method(cNokogiriXmlReader, "empty_element?", empty_element_p, 0);
+  rb_define_method(cNokogiriXmlReader, "encoding", rb_xml_reader_encoding, 0);
   rb_define_method(cNokogiriXmlReader, "inner_xml", inner_xml, 0);
   rb_define_method(cNokogiriXmlReader, "lang", lang, 0);
   rb_define_method(cNokogiriXmlReader, "local_name", local_name, 0);

data/ext/nokogiri/xml_sax_parser_context.c

@@ -2,6 +2,8 @@
 
 VALUE cNokogiriXmlSaxParserContext ;
 
+static ID id_read;
+
 static void
 deallocate(xmlParserCtxtPtr ctxt)
 {
@@ -26,6 +28,10 @@ parse_io(VALUE klass, VALUE io, VALUE encoding)
   xmlParserCtxtPtr ctxt;
   xmlCharEncoding enc = (xmlCharEncoding)NUM2INT(encoding);
 
+  if (!rb_respond_to(io, id_read)) {
+    rb_raise(rb_eTypeError, "argument expected to respond to :read");
+  }
+
   ctxt = xmlCreateIOParserCtxt(NULL, NULL,
                                (xmlInputReadCallback)noko_io_read,
                                (xmlInputCloseCallback)noko_io_close,
@@ -62,9 +68,8 @@ parse_memory(VALUE klass, VALUE data)
 {
   xmlParserCtxtPtr ctxt;
 
-  if (NIL_P(data)) {
-    rb_raise(rb_eArgError, "data cannot be nil");
-  }
+  Check_Type(data, T_STRING);
+
   if (!(int)RSTRING_LEN(data)) {
     rb_raise(rb_eRuntimeError, "data cannot be empty");
   }
@@ -278,4 +283,6 @@ noko_init_xml_sax_parser_context()
   rb_define_method(cNokogiriXmlSaxParserContext, "recovery", get_recovery, 0);
   rb_define_method(cNokogiriXmlSaxParserContext, "line", line, 0);
   rb_define_method(cNokogiriXmlSaxParserContext, "column", column, 0);
+
+  id_read = rb_intern("read");
 }

data/ext/nokogiri/xml_schema.c

@@ -25,7 +25,7 @@ validate_document(VALUE self, VALUE document)
   VALUE errors;
 
   Data_Get_Struct(self, xmlSchema, schema);
-  Data_Get_Struct(document, xmlDoc, doc);
+  Noko_Node_Get_Struct(document, xmlDoc, doc);
 
   errors = rb_ary_new();
 
@@ -179,7 +179,7 @@ has_blank_nodes_p(VALUE cache)
   for (i = 0; i < RARRAY_LEN(cache); i++) {
     xmlNodePtr node;
     VALUE element = rb_ary_entry(cache, i);
-    Data_Get_Struct(element, xmlNode, node);
+    Noko_Node_Get_Struct(element, xmlNode, node);
     if (xmlIsBlankNode(node)) {
       return 1;
     }
@@ -210,7 +210,7 @@ from_document(int argc, VALUE *argv, VALUE klass)
 
   scanned_args = rb_scan_args(argc, argv, "11", &document, &parse_options);
 
-  Data_Get_Struct(document, xmlDoc, doc);
+  Noko_Node_Get_Struct(document, xmlDoc, doc);
   doc = doc->doc; /* In case someone passes us a node. ugh. */
 
   if (scanned_args == 1) {

data/ext/nokogiri/xml_text.c

@@ -20,7 +20,7 @@ new (int argc, VALUE *argv, VALUE klass)
 
   rb_scan_args(argc, argv, "2*", &string, &document, &rest);
 
-  Data_Get_Struct(document, xmlDoc, doc);
+  Noko_Node_Get_Struct(document, xmlDoc, doc);
 
   node = xmlNewText((xmlChar *)StringValueCStr(string));
   node->doc = doc->doc;

data/ext/nokogiri/xml_xpath_context.c

@@ -86,6 +86,26 @@ xpath_builtin_css_class(xmlXPathParserContextPtr ctxt, int nargs)
   xmlXPathFreeObject(needle);
 }
 
+
+/* xmlXPathFunction to select nodes whose local name matches, for HTML5 CSS queries that should ignore namespaces */
+static void
+xpath_builtin_local_name_is(xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlXPathObjectPtr element_name;
+
+  assert(ctxt->context->node);
+
+  CHECK_ARITY(1);
+  CAST_TO_STRING;
+  CHECK_TYPE(XPATH_STRING);
+  element_name = valuePop(ctxt);
+
+  valuePush(ctxt, xmlXPathNewBoolean(xmlStrEqual(ctxt->context->node->name, element_name->stringval)));
+
+  xmlXPathFreeObject(element_name);
+}
+
+
 /*
  * call-seq:
  *  register_ns(prefix, uri)
@@ -128,11 +148,44 @@ register_variable(VALUE self, VALUE name, VALUE value)
   return self;
 }
 
+
+/*
+ *  convert an XPath object into a Ruby object of the appropriate type.
+ *  returns Qundef if no conversion was possible.
+ */
+static VALUE
+xpath2ruby(xmlXPathObjectPtr xobj, xmlXPathContextPtr xctx)
+{
+  VALUE retval;
+
+  assert(xctx->doc);
+  assert(DOC_RUBY_OBJECT_TEST(xctx->doc));
+
+  switch (xobj->type) {
+    case XPATH_STRING:
+      retval = NOKOGIRI_STR_NEW2(xobj->stringval);
+      xmlFree(xobj->stringval);
+      return retval;
+
+    case XPATH_NODESET:
+      return noko_xml_node_set_wrap(xobj->nodesetval,
+                                    DOC_RUBY_OBJECT(xctx->doc));
+
+    case XPATH_NUMBER:
+      return rb_float_new(xobj->floatval);
+
+    case XPATH_BOOLEAN:
+      return (xobj->boolval == 1) ? Qtrue : Qfalse;
+
+    default:
+      return Qundef;
+  }
+}
+
 void
 Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, int nargs, VALUE handler,
     const char *function_name)
 {
-  int i;
   VALUE result, doc;
   VALUE *argv;
   VALUE node_set = Qnil;
@@ -143,40 +196,25 @@ Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, i
   assert(DOC_RUBY_OBJECT_TEST(ctx->context->doc));
 
   argv = (VALUE *)calloc((size_t)nargs, sizeof(VALUE));
-  for (i = 0 ; i < nargs ; ++i) {
-    rb_gc_register_address(&argv[i]);
+  for (int j = 0 ; j < nargs ; ++j) {
+    rb_gc_register_address(&argv[j]);
   }
 
   doc = DOC_RUBY_OBJECT(ctx->context->doc);
 
-  if (nargs > 0) {
-    i = nargs - 1;
-    do {
-      obj = valuePop(ctx);
-      switch (obj->type) {
-        case XPATH_STRING:
-          argv[i] = NOKOGIRI_STR_NEW2(obj->stringval);
-          break;
-        case XPATH_BOOLEAN:
-          argv[i] = obj->boolval == 1 ? Qtrue : Qfalse;
-          break;
-        case XPATH_NUMBER:
-          argv[i] = rb_float_new(obj->floatval);
-          break;
-        case XPATH_NODESET:
-          argv[i] = noko_xml_node_set_wrap(obj->nodesetval, doc);
-          break;
-        default:
-          argv[i] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(obj));
-      }
-      xmlXPathFreeNodeSetList(obj);
-    } while (i-- > 0);
+  for (int j = nargs - 1 ; j >= 0 ; --j) {
+    obj = valuePop(ctx);
+    argv[j] = xpath2ruby(obj, ctx->context);
+    if (argv[j] == Qundef) {
+      argv[j] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(obj));
+    }
+    xmlXPathFreeNodeSetList(obj);
   }
 
   result = rb_funcall2(handler, rb_intern((const char *)function_name), nargs, argv);
 
-  for (i = 0 ; i < nargs ; ++i) {
-    rb_gc_unregister_address(&argv[i]);
+  for (int j = 0 ; j < nargs ; ++j) {
+    rb_gc_unregister_address(&argv[j]);
   }
   free(argv);
 
@@ -275,7 +313,7 @@ static VALUE
 evaluate(int argc, VALUE *argv, VALUE self)
 {
   VALUE search_path, xpath_handler;
-  VALUE thing = Qnil;
+  VALUE retval = Qnil;
   xmlXPathContextPtr ctx;
   xmlXPathObjectPtr xpath;
   xmlChar *query;
@@ -310,31 +348,14 @@ evaluate(int argc, VALUE *argv, VALUE self)
     rb_exc_raise(Nokogiri_wrap_xml_syntax_error(error));
   }
 
-  assert(ctx->doc);
-  assert(DOC_RUBY_OBJECT_TEST(ctx->doc));
-
-  switch (xpath->type) {
-    case XPATH_STRING:
-      thing = NOKOGIRI_STR_NEW2(xpath->stringval);
-      xmlFree(xpath->stringval);
-      break;
-    case XPATH_NODESET:
-      thing = noko_xml_node_set_wrap(xpath->nodesetval,
-                                     DOC_RUBY_OBJECT(ctx->doc));
-      break;
-    case XPATH_NUMBER:
-      thing = rb_float_new(xpath->floatval);
-      break;
-    case XPATH_BOOLEAN:
-      thing = xpath->boolval == 1 ? Qtrue : Qfalse;
-      break;
-    default:
-      thing = noko_xml_node_set_wrap(NULL, DOC_RUBY_OBJECT(ctx->doc));
+  retval = xpath2ruby(xpath, ctx);
+  if (retval == Qundef) {
+    retval = noko_xml_node_set_wrap(NULL, DOC_RUBY_OBJECT(ctx->doc));
   }
 
   xmlXPathFreeNodeSetList(xpath);
 
-  return thing;
+  return retval;
 }
 
 /*
@@ -350,9 +371,12 @@ new (VALUE klass, VALUE nodeobj)
   xmlXPathContextPtr ctx;
   VALUE self;
 
-  Data_Get_Struct(nodeobj, xmlNode, node);
+  Noko_Node_Get_Struct(nodeobj, xmlNode, node);
 
+#if LIBXML_VERSION < 21000
+  /* deprecated in 40483d0 */
   xmlXPathInit();
+#endif
 
   ctx = xmlXPathNewContext(node->doc);
   ctx->node = node;
@@ -360,6 +384,8 @@ new (VALUE klass, VALUE nodeobj)
   xmlXPathRegisterNs(ctx, NOKOGIRI_BUILTIN_PREFIX, NOKOGIRI_BUILTIN_URI);
   xmlXPathRegisterFuncNS(ctx, (const xmlChar *)"css-class", NOKOGIRI_BUILTIN_URI,
                          xpath_builtin_css_class);
+  xmlXPathRegisterFuncNS(ctx, (const xmlChar *)"local-name-is", NOKOGIRI_BUILTIN_URI,
+                         xpath_builtin_local_name_is);
 
   self = Data_Wrap_Struct(klass, 0, deallocate, ctx);
   return self;

data/ext/nokogiri/xslt_stylesheet.c

@@ -107,19 +107,117 @@ serialize(VALUE self, VALUE xmlobj)
 }
 
 /*
- *  call-seq:
- *    transform(document, params = [])
+ * call-seq:
+ *   transform(document)
+ *   transform(document, params = {})
+ *
+ * Apply an XSLT stylesheet to an XML::Document.
+ *
+ * [Parameters]
+ * - +document+ (Nokogiri::XML::Document) the document to be transformed.
+ * - +params+ (Hash, Array) strings used as XSLT parameters.
+ *
+ * [Returns] Nokogiri::XML::Document
+ *
+ * *Example* of basic transformation:
+ *
+ *   xslt = <<~XSLT
+ *     <xsl:stylesheet version="1.0"
+ *     xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+ *
+ *     <xsl:param name="title"/>
+ *
+ *     <xsl:template match="/">
+ *       <html>
+ *         <body>
+ *           <h1><xsl:value-of select="$title"/></h1>
+ *           <ol>
+ *             <xsl:for-each select="staff/employee">
+ *               <li><xsl:value-of select="employeeId"></li>
+ *             </xsl:for-each>
+ *           </ol>
+ *         </body>
+ *       </html>
+ *     </xsl:stylesheet>
+ *   XSLT
+ *
+ *   xml = <<~XML
+ *     <?xml version="1.0"?>
+ *     <staff>
+ *       <employee>
+ *         <employeeId>EMP0001</employeeId>
+ *         <position>Accountant</position>
+ *       </employee>
+ *       <employee>
+ *         <employeeId>EMP0002</employeeId>
+ *         <position>Developer</position>
+ *       </employee>
+ *     </staff>
+ *   XML
+ *
+ *   doc = Nokogiri::XML::Document.parse(xml)
+ *   stylesheet = Nokogiri::XSLT.parse(xslt)
+ *
+ * ⚠ Note that the +h1+ element is empty because no param has been provided!
+ *
+ *   stylesheet.transform(doc).to_xml
+ *   # => "<html><body>\n" +
+ *   #    "<h1></h1>\n" +
+ *   #    "<ol>\n" +
+ *   #    "<li>EMP0001</li>\n" +
+ *   #    "<li>EMP0002</li>\n" +
+ *   #    "</ol>\n" +
+ *   #    "</body></html>\n"
+ *
+ * *Example* of using an input parameter hash:
+ *
+ * ⚠ The title is populated, but note how we need to quote-escape the value.
+ *
+ *   stylesheet.transform(doc, { "title" => "'Employee List'" }).to_xml
+ *   # => "<html><body>\n" +
+ *   #    "<h1>Employee List</h1>\n" +
+ *   #    "<ol>\n" +
+ *   #    "<li>EMP0001</li>\n" +
+ *   #    "<li>EMP0002</li>\n" +
+ *   #    "</ol>\n" +
+ *   #    "</body></html>\n"
+ *
+ * *Example* using the XSLT.quote_params helper method to safely quote-escape strings:
+ *
+ *   stylesheet.transform(doc, Nokogiri::XSLT.quote_params({ "title" => "Aaron's List" })).to_xml
+ *   # => "<html><body>\n" +
+ *   #    "<h1>Aaron's List</h1>\n" +
+ *   #    "<ol>\n" +
+ *   #    "<li>EMP0001</li>\n" +
+ *   #    "<li>EMP0002</li>\n" +
+ *   #    "</ol>\n" +
+ *   #    "</body></html>\n"
+ *
+ * *Example* using an array of XSLT parameters
+ *
+ * You can also use an array if you want to.
  *
- *  Apply an XSLT stylesheet to an XML::Document.
- *  +params+ is an array of strings used as XSLT parameters.
- *  returns Nokogiri::XML::Document
+ *   stylesheet.transform(doc, ["title", "'Employee List'"]).to_xml
+ *   # => "<html><body>\n" +
+ *   #    "<h1>Employee List</h1>\n" +
+ *   #    "<ol>\n" +
+ *   #    "<li>EMP0001</li>\n" +
+ *   #    "<li>EMP0002</li>\n" +
+ *   #    "</ol>\n" +
+ *   #    "</body></html>\n"
  *
- *  Example:
+ * Or pass an array to XSLT.quote_params:
  *
- *    doc   = Nokogiri::XML(File.read(ARGV[0]))
- *    xslt  = Nokogiri::XSLT(File.read(ARGV[1]))
- *    puts xslt.transform(doc, ['key', 'value'])
+ *   stylesheet.transform(doc, Nokogiri::XSLT.quote_params(["title", "Aaron's List"])).to_xml
+ *   # => "<html><body>\n" +
+ *   #    "<h1>Aaron's List</h1>\n" +
+ *   #    "<ol>\n" +
+ *   #    "<li>EMP0001</li>\n" +
+ *   #    "<li>EMP0002</li>\n" +
+ *   #    "</ol>\n" +
+ *   #    "</body></html>\n"
  *
+ * See: Nokogiri::XSLT.quote_params
  */
 static VALUE
 transform(int argc, VALUE *argv, VALUE self)

data/gumbo-parser/src/parser.c

@@ -4423,11 +4423,6 @@ static void handle_in_foreign_content(GumboParser* parser, GumboToken* token) {
     /* Parse error */
     parser_add_parse_error(parser, token);
 
-    /*
-     * Fragment case: If the parser was originally created for the HTML
-     * fragment parsing algorithm, then act as described in the "any other
-     * start tag" entry below.
-     */
     while (
       !(
         is_mathml_integration_point(get_current_node(parser))
@@ -4437,12 +4432,6 @@ static void handle_in_foreign_content(GumboParser* parser, GumboToken* token) {
     ) {
       pop_current_node(parser);
     }
-    // XXX: The spec currently says to handle this using the in body insertion
-    // mode rules. That seems wrong. See
-    // <https://github.com/whatwg/html/issues/6808>. Instead, use the current
-    // insertion mode which seems like it works.
-    //
-    // handle_in_body(parser, token);
     handle_html_content(parser, token);
     return;
   }

data/lib/nokogiri/class_resolver.rb

@@ -0,0 +1,67 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require "set"
+
+module Nokogiri
+  #
+  # Some classes in Nokogiri are namespaced as a group, for example
+  # Document, DocumentFragment, and Builder.
+  #
+  # It's sometimes necessary to look up the related class, e.g.:
+  #
+  #   XML::Builder → XML::Document
+  #   HTML4::Builder → HTML4::Document
+  #   HTML5::Document → HTML5::DocumentFragment
+  #
+  # This module is included into those key classes who need to do this.
+  #
+  module ClassResolver
+    # #related_class restricts matching namespaces to those matching this set.
+    VALID_NAMESPACES = Set.new(["HTML", "HTML4", "HTML5", "XML"])
+
+    # :call-seq:
+    #   related_class(class_name) → Class
+    #
+    # Find a class constant within the
+    #
+    # Some examples:
+    #
+    #   Nokogiri::XML::Document.new.related_class("DocumentFragment")
+    #   # => Nokogiri::XML::DocumentFragment
+    #   Nokogiri::HTML4::Document.new.related_class("DocumentFragment")
+    #   # => Nokogiri::HTML4::DocumentFragment
+    #
+    # Note this will also work for subclasses that follow the same convention, e.g.:
+    #
+    #   Loofah::HTML::Document.new.related_class("DocumentFragment")
+    #   # => Loofah::HTML::DocumentFragment
+    #
+    # And even if it's a subclass, this will iterate through the superclasses:
+    #
+    #   class ThisIsATopLevelClass < Nokogiri::HTML4::Builder ; end
+    #   ThisIsATopLevelClass.new.related_class("Document")
+    #   # => Nokogiri::HTML4::Document
+    #
+    def related_class(class_name)
+      klass = nil
+      inspecting = self.class
+
+      while inspecting
+        namespace_path = inspecting.name.split("::")[0..-2]
+        inspecting = inspecting.superclass
+
+        next unless VALID_NAMESPACES.include?(namespace_path.last)
+
+        related_class_name = (namespace_path << class_name).join("::")
+        klass = begin
+          Object.const_get(related_class_name)
+        rescue NameError
+          nil
+        end
+        break if klass
+      end
+      klass
+    end
+  end
+end