nokogiri 1.13.8 → 1.15.7

data/ext/nokogiri/xslt_stylesheet.c

@@ -3,36 +3,48 @@
 VALUE cNokogiriXsltStylesheet ;
 
 static void
-mark(nokogiriXsltStylesheetTuple *wrapper)
+mark(void *data)
 {
+  nokogiriXsltStylesheetTuple *wrapper = (nokogiriXsltStylesheetTuple *)data;
   rb_gc_mark(wrapper->func_instances);
 }
 
 static void
-dealloc(nokogiriXsltStylesheetTuple *wrapper)
+dealloc(void *data)
 {
+  nokogiriXsltStylesheetTuple *wrapper = (nokogiriXsltStylesheetTuple *)data;
   xsltStylesheetPtr doc = wrapper->ss;
-
-  NOKOGIRI_DEBUG_START(doc);
-  xsltFreeStylesheet(doc); /* commented out for now. */
-  NOKOGIRI_DEBUG_END(doc);
-
-  free(wrapper);
+  xsltFreeStylesheet(doc);
+  ruby_xfree(wrapper);
 }
 
+static const rb_data_type_t xslt_stylesheet_type = {
+  .wrap_struct_name = "Nokogiri::XSLT::Stylesheet",
+  .function = {
+    .dmark = mark,
+    .dfree = dealloc,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+PRINTFLIKE_DECL(2, 3)
 static void
 xslt_generic_error_handler(void *ctx, const char *msg, ...)
 {
-  char *message;
+  VALUE message;
 
+#ifdef TRUFFLERUBY_NOKOGIRI_SYSTEM_LIBRARIES
+  /* It is not currently possible to pass var args from native
+     functions to sulong, so we work around the issue here. */
+  message = rb_sprintf("xslt_generic_error_handler: %s", msg);
+#else
   va_list args;
   va_start(args, msg);
-  vasprintf(&message, msg, args);
+  message = rb_vsprintf(msg, args);
   va_end(args);
+#endif
 
-  rb_str_cat2((VALUE)ctx, message);
-
-  free(message);
+  rb_str_concat((VALUE)ctx, message);
 }
 
 VALUE
@@ -41,8 +53,12 @@ Nokogiri_wrap_xslt_stylesheet(xsltStylesheetPtr ss)
   VALUE self;
   nokogiriXsltStylesheetTuple *wrapper;
 
-  self = Data_Make_Struct(cNokogiriXsltStylesheet, nokogiriXsltStylesheetTuple,
-                          mark, dealloc, wrapper);
+  self = TypedData_Make_Struct(
+           cNokogiriXsltStylesheet,
+           nokogiriXsltStylesheetTuple,
+           &xslt_stylesheet_type,
+           wrapper
+         );
 
   ss->_private = (void *)self;
   wrapper->ss = ss;
@@ -63,7 +79,8 @@ parse_stylesheet_doc(VALUE klass, VALUE xmldocobj)
   xmlDocPtr xml, xml_cpy;
   VALUE errstr, exception;
   xsltStylesheetPtr ss ;
-  Data_Get_Struct(xmldocobj, xmlDoc, xml);
+
+  xml = noko_xml_document_unwrap(xmldocobj);
 
   errstr = rb_str_new(0, 0);
   xsltSetGenericErrorFunc((void *)errstr, xslt_generic_error_handler);
@@ -90,7 +107,7 @@ parse_stylesheet_doc(VALUE klass, VALUE xmldocobj)
  * Serialize +document+ to an xml string.
  */
 static VALUE
-serialize(VALUE self, VALUE xmlobj)
+rb_xslt_stylesheet_serialize(VALUE self, VALUE xmlobj)
 {
   xmlDocPtr xml ;
   nokogiriXsltStylesheetTuple *wrapper;
@@ -98,8 +115,13 @@ serialize(VALUE self, VALUE xmlobj)
   int doc_len ;
   VALUE rval ;
 
-  Data_Get_Struct(xmlobj, xmlDoc, xml);
-  Data_Get_Struct(self, nokogiriXsltStylesheetTuple, wrapper);
+  xml = noko_xml_document_unwrap(xmlobj);
+  TypedData_Get_Struct(
+    self,
+    nokogiriXsltStylesheetTuple,
+    &xslt_stylesheet_type,
+    wrapper
+  );
   xsltSaveResultToString(&doc_ptr, &doc_len, xml, wrapper->ss);
   rval = NOKOGIRI_STR_NEW(doc_ptr, doc_len);
   xmlFree(doc_ptr);
@@ -220,60 +242,74 @@ serialize(VALUE self, VALUE xmlobj)
  * See: Nokogiri::XSLT.quote_params
  */
 static VALUE
-transform(int argc, VALUE *argv, VALUE self)
+rb_xslt_stylesheet_transform(int argc, VALUE *argv, VALUE self)
 {
-  VALUE xmldoc, paramobj, errstr, exception ;
-  xmlDocPtr xml ;
-  xmlDocPtr result ;
+  VALUE rb_document, rb_param, rb_error_str;
+  xmlDocPtr c_document ;
+  xmlDocPtr c_result_document ;
   nokogiriXsltStylesheetTuple *wrapper;
   const char **params ;
   long param_len, j ;
   int parse_error_occurred ;
+  int defensive_copy_p = 0;
 
-  rb_scan_args(argc, argv, "11", &xmldoc, &paramobj);
-  if (NIL_P(paramobj)) { paramobj = rb_ary_new2(0L) ; }
-  if (!rb_obj_is_kind_of(xmldoc, cNokogiriXmlDocument)) {
+  rb_scan_args(argc, argv, "11", &rb_document, &rb_param);
+  if (NIL_P(rb_param)) { rb_param = rb_ary_new2(0L) ; }
+  if (!rb_obj_is_kind_of(rb_document, cNokogiriXmlDocument)) {
     rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::Document");
   }
 
   /* handle hashes as arguments. */
-  if (T_HASH == TYPE(paramobj)) {
-    paramobj = rb_funcall(paramobj, rb_intern("to_a"), 0);
-    paramobj = rb_funcall(paramobj, rb_intern("flatten"), 0);
+  if (T_HASH == TYPE(rb_param)) {
+    rb_param = rb_funcall(rb_param, rb_intern("to_a"), 0);
+    rb_param = rb_funcall(rb_param, rb_intern("flatten"), 0);
   }
 
-  Check_Type(paramobj, T_ARRAY);
+  Check_Type(rb_param, T_ARRAY);
 
-  Data_Get_Struct(xmldoc, xmlDoc, xml);
-  Data_Get_Struct(self, nokogiriXsltStylesheetTuple, wrapper);
+  c_document = noko_xml_document_unwrap(rb_document);
+  TypedData_Get_Struct(self, nokogiriXsltStylesheetTuple, &xslt_stylesheet_type, wrapper);
 
-  param_len = RARRAY_LEN(paramobj);
-  params = calloc((size_t)param_len + 1, sizeof(char *));
+  param_len = RARRAY_LEN(rb_param);
+  params = ruby_xcalloc((size_t)param_len + 1, sizeof(char *));
   for (j = 0 ; j < param_len ; j++) {
-    VALUE entry = rb_ary_entry(paramobj, j);
+    VALUE entry = rb_ary_entry(rb_param, j);
     const char *ptr = StringValueCStr(entry);
     params[j] = ptr;
   }
   params[param_len] = 0 ;
 
-  errstr = rb_str_new(0, 0);
-  xsltSetGenericErrorFunc((void *)errstr, xslt_generic_error_handler);
-  xmlSetGenericErrorFunc((void *)errstr, xslt_generic_error_handler);
+  xsltTransformContextPtr c_transform_context = xsltNewTransformContext(wrapper->ss, c_document);
+  if (xsltNeedElemSpaceHandling(c_transform_context) &&
+      noko_xml_document_has_wrapped_blank_nodes_p(c_document)) {
+    // see https://github.com/sparklemotion/nokogiri/issues/2800
+    c_document = xmlCopyDoc(c_document, 1);
+    defensive_copy_p = 1;
+  }
+  xsltFreeTransformContext(c_transform_context);
 
-  result = xsltApplyStylesheet(wrapper->ss, xml, params);
-  free(params);
+  rb_error_str = rb_str_new(0, 0);
+  xsltSetGenericErrorFunc((void *)rb_error_str, xslt_generic_error_handler);
+  xmlSetGenericErrorFunc((void *)rb_error_str, xslt_generic_error_handler);
+
+  c_result_document = xsltApplyStylesheet(wrapper->ss, c_document, params);
+
+  ruby_xfree(params);
+  if (defensive_copy_p) {
+    xmlFreeDoc(c_document);
+    c_document = NULL;
+  }
 
   xsltSetGenericErrorFunc(NULL, NULL);
   xmlSetGenericErrorFunc(NULL, NULL);
 
-  parse_error_occurred = (Qfalse == rb_funcall(errstr, rb_intern("empty?"), 0));
+  parse_error_occurred = (Qfalse == rb_funcall(rb_error_str, rb_intern("empty?"), 0));
 
   if (parse_error_occurred) {
-    exception = rb_exc_new3(rb_eRuntimeError, errstr);
-    rb_exc_raise(exception);
+    rb_exc_raise(rb_exc_new3(rb_eRuntimeError, rb_error_str));
   }
 
-  return noko_xml_document_wrap((VALUE)0, result) ;
+  return noko_xml_document_wrap((VALUE)0, c_result_document) ;
 }
 
 static void
@@ -289,7 +325,12 @@ method_caller(xmlXPathParserContextPtr ctxt, int nargs)
   handler = (VALUE)xsltGetExtData(transform, functionURI);
   function_name = (const char *)(ctxt->context->function);
 
-  Nokogiri_marshal_xpath_funcall_and_return_values(ctxt, nargs, handler, (const char *)function_name);
+  Nokogiri_marshal_xpath_funcall_and_return_values(
+    ctxt,
+    nargs,
+    handler,
+    (const char *)function_name
+  );
 }
 
 static void *
@@ -305,12 +346,20 @@ initFunc(xsltTransformContextPtr ctxt, const xmlChar *uri)
 
   for (i = 0; i < RARRAY_LEN(methods); i++) {
     VALUE method_name = rb_obj_as_string(rb_ary_entry(methods, i));
-    xsltRegisterExtFunction(ctxt,
-                            (unsigned char *)StringValueCStr(method_name), uri, method_caller);
+    xsltRegisterExtFunction(
+      ctxt,
+      (unsigned char *)StringValueCStr(method_name),
+      uri,
+      method_caller
+    );
   }
 
-  Data_Get_Struct((VALUE)ctxt->style->_private, nokogiriXsltStylesheetTuple,
-                  wrapper);
+  TypedData_Get_Struct(
+    (VALUE)ctxt->style->_private,
+    nokogiriXsltStylesheetTuple,
+    &xslt_stylesheet_type,
+    wrapper
+  );
   inst = rb_class_new_instance(0, NULL, obj);
   rb_ary_push(wrapper->func_instances, inst);
 
@@ -323,33 +372,38 @@ shutdownFunc(xsltTransformContextPtr ctxt,
 {
   nokogiriXsltStylesheetTuple *wrapper;
 
-  Data_Get_Struct((VALUE)ctxt->style->_private, nokogiriXsltStylesheetTuple,
-                  wrapper);
+  TypedData_Get_Struct(
+    (VALUE)ctxt->style->_private,
+    nokogiriXsltStylesheetTuple,
+    &xslt_stylesheet_type,
+    wrapper
+  );
 
   rb_ary_clear(wrapper->func_instances);
 }
 
-/*
- *  call-seq:
- *    register(uri, custom_handler_class)
- *
- *  Register a class that implements custom XSLT transformation functions.
- */
+/* docstring is in lib/nokogiri/xslt.rb */
 static VALUE
-registr(VALUE self, VALUE uri, VALUE obj)
+rb_xslt_s_register(VALUE self, VALUE uri, VALUE obj)
 {
   VALUE modules = rb_iv_get(self, "@modules");
-  if (NIL_P(modules)) { rb_raise(rb_eRuntimeError, "wtf! @modules isn't set"); }
+  if (NIL_P(modules)) {
+    rb_raise(rb_eRuntimeError, "internal error: @modules not set");
+  }
 
   rb_hash_aset(modules, uri, obj);
-  xsltRegisterExtModule((unsigned char *)StringValueCStr(uri), initFunc, shutdownFunc);
+  xsltRegisterExtModule(
+    (unsigned char *)StringValueCStr(uri),
+    initFunc,
+    shutdownFunc
+  );
   return self;
 }
 
 void
-noko_init_xslt_stylesheet()
+noko_init_xslt_stylesheet(void)
 {
-  rb_define_singleton_method(mNokogiriXslt, "register", registr, 2);
+  rb_define_singleton_method(mNokogiriXslt, "register", rb_xslt_s_register, 2);
   rb_iv_set(mNokogiriXslt, "@modules", rb_hash_new());
 
   cNokogiriXsltStylesheet = rb_define_class_under(mNokogiriXslt, "Stylesheet", rb_cObject);
@@ -357,6 +411,6 @@ noko_init_xslt_stylesheet()
   rb_undef_alloc_func(cNokogiriXsltStylesheet);
 
   rb_define_singleton_method(cNokogiriXsltStylesheet, "parse_stylesheet_doc", parse_stylesheet_doc, 1);
-  rb_define_method(cNokogiriXsltStylesheet, "serialize", serialize, 1);
-  rb_define_method(cNokogiriXsltStylesheet, "transform", transform, -1);
+  rb_define_method(cNokogiriXsltStylesheet, "serialize", rb_xslt_stylesheet_serialize, 1);
+  rb_define_method(cNokogiriXsltStylesheet, "transform", rb_xslt_stylesheet_transform, -1);
 }

data/gumbo-parser/Makefile

@@ -13,8 +13,18 @@ LDFLAGS := -pthread
 
 all: check
 
+# don't try to regenerate ragel or gperf files in CI, that should be a development-only action and
+# the generated files should be committed to SCM
+ifneq ($(CI),true)
+src/foreign_attrs.c: src/foreign_attrs.gperf
+	gperf -m100 -n $< | ./gperf-filter.sed > $@
+
+src/%.c: src/%.gperf
+	gperf -m100 $< | ./gperf-filter.sed > $@
+
 src/%.c: src/%.rl
 	ragel -F1 -o $@ $<
+endif
 
 build/src:
 	mkdir -p $@

data/gumbo-parser/src/attribute.h

@@ -1,7 +1,7 @@
 #ifndef GUMBO_ATTRIBUTE_H_
 #define GUMBO_ATTRIBUTE_H_
 
-#include "gumbo.h"
+#include "nokogiri_gumbo.h"
 
 #ifdef __cplusplus
 extern "C" {

data/gumbo-parser/src/error.c

@@ -21,7 +21,7 @@
 #include <string.h>
 #include "ascii.h"
 #include "error.h"
-#include "gumbo.h"
+#include "nokogiri_gumbo.h"
 #include "macros.h"
 #include "parser.h"
 #include "string_buffer.h"
@@ -91,12 +91,12 @@ static void print_tag_stack (
   const GumboParserError* error,
   GumboStringBuffer* output
 ) {
-  print_message(output, "  Currently open tags: ");
+  print_message(output, " Currently open tags: ");
   for (unsigned int i = 0; i < error->tag_stack.length; ++i) {
     if (i) {
       print_message(output, ", ");
     }
-    GumboTag tag = (GumboTag) error->tag_stack.data[i];
+    GumboTag tag = (GumboTag)(intptr_t) error->tag_stack.data[i];
     print_message(output, "%s", gumbo_normalized_tagname(tag));
   }
   gumbo_string_buffer_append_codepoint('.', output);
@@ -347,15 +347,19 @@ static void handle_parser_error (
       if (error->parser_state == GUMBO_INSERTION_MODE_INITIAL) {
         print_message(output, "You must provide a doctype");
       } else {
-        print_message(output, "Premature end of file");
+        print_message(output, "Premature end of file.");
         print_tag_stack(error, output);
       }
       return;
     case GUMBO_TOKEN_START_TAG:
+      print_message(output, "Start tag '%s' isn't allowed here.",
+                    gumbo_normalized_tagname(error->input_tag));
+      print_tag_stack(error, output);
+      return;
     case GUMBO_TOKEN_END_TAG:
-      print_message(output, "That tag isn't allowed here");
+      print_message(output, "End tag '%s' isn't allowed here.",
+                    gumbo_normalized_tagname(error->input_tag));
       print_tag_stack(error, output);
-      // TODO(jdtang): Give more specific messaging.
       return;
   }
 }

data/gumbo-parser/src/error.h

@@ -3,7 +3,7 @@
 
 #include <stdint.h>
 
-#include "gumbo.h"
+#include "nokogiri_gumbo.h"
 #include "insertion_mode.h"
 #include "string_buffer.h"
 #include "token_type.h"

data/gumbo-parser/src/foreign_attrs.c

@@ -1,7 +1,7 @@
 /* ANSI-C code produced by gperf version 3.1 */
-/* Command-line: gperf -m100 -n lib/foreign_attrs.gperf  */
-/* Computed positions: -k'2,8' */
-/* Filtered by: mk/gperf-filter.sed */
+/* Command-line: gperf -m100 -n src/foreign_attrs.gperf  */
+/* Computed positions: -k'8-9' */
+/* Filtered by: gperf-filter.sed */
 
 #include "replacement.h"
 #include "macros.h"
@@ -29,9 +29,9 @@ hash (register const char *str, register size_t len)
       11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
       11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
       11, 11, 11, 11, 11, 11, 11, 11, 11,  2,
-      11, 10, 11,  9,  7,  6, 11, 11,  1,  0,
-      11,  5, 11, 11,  4, 11, 11, 11, 11, 11,
-      11,  3, 11, 11, 11, 11, 11, 11, 11, 11,
+      11,  1, 11, 10,  4,  4, 11, 11,  3, 11,
+      11,  5,  3, 11,  0, 11,  2, 11, 11, 11,
+      11,  2, 11, 11, 11, 11, 11, 11, 11, 11,
       11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
       11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
       11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
@@ -51,15 +51,14 @@ hash (register const char *str, register size_t len)
   switch (len)
     {
       default:
+        hval += asso_values[(unsigned char)str[8]];
+      /*FALLTHROUGH*/
+      case 8:
         hval += asso_values[(unsigned char)str[7]];
       /*FALLTHROUGH*/
       case 7:
       case 6:
       case 5:
-      case 4:
-      case 3:
-      case 2:
-        hval += asso_values[(unsigned char)str[1]];
         break;
     }
   return hval;
@@ -70,21 +69,21 @@ gumbo_get_foreign_attr_replacement (register const char *str, register size_t le
 {
   static const unsigned char lengthtable[] =
     {
-       5, 11,  9, 13, 10, 10, 10, 11, 10,  8,  8
+       5, 10, 13,  9, 13, 10, 11, 11, 10, 10,  8
     };
   static const ForeignAttrReplacement wordlist[] =
     {
       {"xmlns", "xmlns", GUMBO_ATTR_NAMESPACE_XMLNS},
-      {"xmlns:xlink", "xlink", GUMBO_ATTR_NAMESPACE_XMLNS},
+      {"xlink:href", "href", GUMBO_ATTR_NAMESPACE_XLINK},
+      {"xlink:arcrole", "arcrole", GUMBO_ATTR_NAMESPACE_XLINK},
       {"xml:space", "space", GUMBO_ATTR_NAMESPACE_XML},
       {"xlink:actuate", "actuate", GUMBO_ATTR_NAMESPACE_XLINK},
       {"xlink:type", "type", GUMBO_ATTR_NAMESPACE_XLINK},
-      {"xlink:href", "href", GUMBO_ATTR_NAMESPACE_XLINK},
-      {"xlink:role", "role", GUMBO_ATTR_NAMESPACE_XLINK},
       {"xlink:title", "title", GUMBO_ATTR_NAMESPACE_XLINK},
+      {"xmlns:xlink", "xlink", GUMBO_ATTR_NAMESPACE_XMLNS},
+      {"xlink:role", "role", GUMBO_ATTR_NAMESPACE_XLINK},
       {"xlink:show", "show", GUMBO_ATTR_NAMESPACE_XLINK},
-      {"xml:lang", "lang", GUMBO_ATTR_NAMESPACE_XML},
-      {"xml:base", "base", GUMBO_ATTR_NAMESPACE_XML}
+      {"xml:lang", "lang", GUMBO_ATTR_NAMESPACE_XML}
     };
 
   if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)

data/gumbo-parser/src/foreign_attrs.gperf

@@ -15,12 +15,12 @@ ForeignAttrReplacement;
 
 %%
 "xlink:actuate", "actuate", GUMBO_ATTR_NAMESPACE_XLINK
+"xlink:arcrole", "arcrole", GUMBO_ATTR_NAMESPACE_XLINK
 "xlink:href", "href", GUMBO_ATTR_NAMESPACE_XLINK
 "xlink:role", "role", GUMBO_ATTR_NAMESPACE_XLINK
 "xlink:show", "show", GUMBO_ATTR_NAMESPACE_XLINK
 "xlink:title", "title", GUMBO_ATTR_NAMESPACE_XLINK
 "xlink:type", "type", GUMBO_ATTR_NAMESPACE_XLINK
-"xml:base", "base", GUMBO_ATTR_NAMESPACE_XML
 "xml:lang", "lang", GUMBO_ATTR_NAMESPACE_XML
 "xml:space", "space", GUMBO_ATTR_NAMESPACE_XML
 "xmlns", "xmlns", GUMBO_ATTR_NAMESPACE_XMLNS

data/gumbo-parser/src/{gumbo.h → nokogiri_gumbo.h}

@@ -292,6 +292,7 @@ typedef enum {
   GUMBO_TAG_TT,
   GUMBO_TAG_RTC,
   GUMBO_TAG_DIALOG,
+  GUMBO_TAG_SEARCH,
   // Used for all tags that don't have special handling in HTML.
   GUMBO_TAG_UNKNOWN,
   // A marker value to indicate the end of the enum, for iterating over it.

data/gumbo-parser/src/parser.c

@@ -24,7 +24,7 @@
 #include "ascii.h"
 #include "attribute.h"
 #include "error.h"
-#include "gumbo.h"
+#include "nokogiri_gumbo.h"
 #include "insertion_mode.h"
 #include "macros.h"
 #include "parser.h"
@@ -537,7 +537,7 @@ static GumboInsertionMode get_current_template_insertion_mode (
   if (modes->length == 0) {
     return GUMBO_INSERTION_MODE_INITIAL;
   }
-  return (GumboInsertionMode) modes->data[(modes->length - 1)];
+  return (GumboInsertionMode)(intptr_t) modes->data[(modes->length - 1)];
 }
 
 // Returns true if the specified token is either a start or end tag
@@ -2678,6 +2678,7 @@ static void handle_in_head(GumboParser* parser, GumboToken* token) {
 static void handle_in_head_noscript(GumboParser* parser, GumboToken* token) {
   if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
+    ignore_token(parser);
     return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
@@ -2940,7 +2941,7 @@ static void handle_in_body(GumboParser* parser, GumboToken* token) {
       TAG(DETAILS), TAG(DIALOG), TAG(DIR), TAG(DIV), TAG(DL), TAG(FIELDSET),
       TAG(FIGCAPTION), TAG(FIGURE), TAG(FOOTER), TAG(HEADER), TAG(HGROUP),
       TAG(MAIN), TAG(MENU), TAG(NAV), TAG(OL), TAG(P), TAG(SECTION),
-      TAG(SUMMARY), TAG(UL)
+      TAG(SUMMARY), TAG(UL), TAG(SEARCH)
     })
   ) {
     maybe_implicitly_close_p_tag(parser, token);
@@ -3018,7 +3019,7 @@ static void handle_in_body(GumboParser* parser, GumboToken* token) {
       TAG(CENTER), TAG(DETAILS), TAG(DIALOG), TAG(DIR), TAG(DIV), TAG(DL),
       TAG(FIELDSET), TAG(FIGCAPTION), TAG(FIGURE), TAG(FOOTER), TAG(HEADER),
       TAG(HGROUP), TAG(LISTING), TAG(MAIN), TAG(MENU), TAG(NAV), TAG(OL),
-      TAG(PRE), TAG(SECTION), TAG(SUMMARY), TAG(UL)
+      TAG(PRE), TAG(SECTION), TAG(SUMMARY), TAG(UL), TAG(SEARCH)
     })
   ) {
     GumboTag tag = token->v.end_tag.tag;
@@ -3057,6 +3058,9 @@ static void handle_in_body(GumboParser* parser, GumboToken* token) {
         ignore_token(parser);
         return;
       }
+      // Since we remove the form node without popping, we need to make sure
+      // that we flush any text nodes at the end of the form.
+      maybe_flush_text_node_buffer(parser);
       // This differs from implicitly_close_tags because we remove *only* the
       // <form> element; other nodes are left in scope.
       generate_implied_end_tags(parser, GUMBO_TAG_LAST, NULL);
@@ -3434,7 +3438,7 @@ static void handle_in_table(GumboParser* parser, GumboToken* token) {
      || token->type == GUMBO_TOKEN_WHITESPACE
      || token->type == GUMBO_TOKEN_NULL)
     && node_tag_in_set(get_current_node(parser), &(const TagSet) {
-      TAG(TABLE), TAG(TBODY), TAG(TFOOT), TAG(THEAD), TAG(TR)
+      TAG(TABLE), TAG(TBODY), TAG(TEMPLATE), TAG(TFOOT), TAG(THEAD), TAG(TR)
     })
   ) {
     // The "pending table character tokens" list described in the spec is
@@ -3960,6 +3964,18 @@ static void handle_in_select(GumboParser* parser, GumboToken* token) {
     insert_element_from_token(parser, token);
     return;
   }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HR)) {
+    if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTION)) {
+      pop_current_node(parser);
+    }
+    if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTGROUP)) {
+      pop_current_node(parser);
+    }
+    insert_element_from_token(parser, token);
+    pop_current_node(parser);
+    acknowledge_self_closing_tag(parser);
+    return;
+  }
   if (tag_is(token, kEndTag, GUMBO_TAG_OPTGROUP)) {
     GumboVector* open_elements = &parser->_parser_state->_open_elements;
     if (

data/gumbo-parser/src/replacement.h

@@ -2,7 +2,7 @@
 #define GUMBO_REPLACEMENT_H_
 
 #include <stddef.h>
-#include "gumbo.h"
+#include "nokogiri_gumbo.h"
 
 typedef struct {
   const char *const from;

data/gumbo-parser/src/string_buffer.h

@@ -4,7 +4,7 @@
 #include <stdbool.h>
 #include <stddef.h>
 
-#include "gumbo.h"
+#include "nokogiri_gumbo.h"
 
 #ifdef __cplusplus
 extern "C" {

data/gumbo-parser/src/string_piece.c

@@ -17,7 +17,7 @@
 
 #include <stddef.h>
 #include <string.h>
-#include "gumbo.h"
+#include "nokogiri_gumbo.h"
 #include "ascii.h"
 
 bool gumbo_string_equals (

data/gumbo-parser/src/svg_attrs.c

@@ -1,7 +1,7 @@
 /* ANSI-C code produced by gperf version 3.1 */
-/* Command-line: gperf -m100 lib/svg_attrs.gperf  */
+/* Command-line: gperf -m100 src/svg_attrs.gperf  */
 /* Computed positions: -k'1,10,$' */
-/* Filtered by: mk/gperf-filter.sed */
+/* Filtered by: gperf-filter.sed */
 
 #include "replacement.h"
 #include "macros.h"

data/gumbo-parser/src/svg_tags.c

@@ -1,7 +1,7 @@
 /* ANSI-C code produced by gperf version 3.1 */
-/* Command-line: gperf -m100 lib/svg_tags.gperf  */
+/* Command-line: gperf -m100 src/svg_tags.gperf  */
 /* Computed positions: -k'3,7' */
-/* Filtered by: mk/gperf-filter.sed */
+/* Filtered by: gperf-filter.sed */
 
 #include "replacement.h"
 #include "macros.h"

data/gumbo-parser/src/tag.c

@@ -14,7 +14,7 @@
  limitations under the License.
 */
 
-#include "gumbo.h"
+#include "nokogiri_gumbo.h"
 #include "util.h"
 #include "tag_lookup.h"
 
@@ -172,6 +172,7 @@ static const char kGumboTagNames[GUMBO_TAG_LAST+1][15] = {
     [GUMBO_TAG_TT] = "tt",
     [GUMBO_TAG_RTC] = "rtc",
     [GUMBO_TAG_DIALOG] = "dialog",
+    [GUMBO_TAG_SEARCH] = "search",
 
     [GUMBO_TAG_UNKNOWN] = "",
     [GUMBO_TAG_LAST] = "",