nokogiri 1.12.5 → 1.14.3

data/ext/nokogiri/xml_xpath_context.c

@@ -6,15 +6,15 @@ VALUE cNokogiriXmlXpathContext;
  * these constants have matching declarations in
  * ext/java/nokogiri/internals/NokogiriNamespaceContext.java
  */
+static const xmlChar *NOKOGIRI_PREFIX = (const xmlChar *)"nokogiri";
+static const xmlChar *NOKOGIRI_URI = (const xmlChar *)"http://www.nokogiri.org/default_ns/ruby/extensions_functions";
 static const xmlChar *NOKOGIRI_BUILTIN_PREFIX = (const xmlChar *)"nokogiri-builtin";
 static const xmlChar *NOKOGIRI_BUILTIN_URI = (const xmlChar *)"https://www.nokogiri.org/default_ns/ruby/builtins";
 
 static void
-deallocate(xmlXPathContextPtr ctx)
+xml_xpath_context_deallocate(xmlXPathContextPtr ctx)
 {
-  NOKOGIRI_DEBUG_START(ctx);
   xmlXPathFreeContext(ctx);
-  NOKOGIRI_DEBUG_END(ctx);
 }
 
 /* find a CSS class in an HTML element's `class` attribute */
@@ -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)
@@ -93,7 +113,7 @@ xpath_builtin_css_class(xmlXPathParserContextPtr ctxt, int nargs)
  * Register the namespace with +prefix+ and +uri+.
  */
 static VALUE
-register_ns(VALUE self, VALUE prefix, VALUE uri)
+rb_xml_xpath_context_register_ns(VALUE self, VALUE prefix, VALUE uri)
 {
   xmlXPathContextPtr ctx;
   Data_Get_Struct(self, xmlXPathContext, ctx);
@@ -112,7 +132,7 @@ register_ns(VALUE self, VALUE prefix, VALUE uri)
  * Register the variable +name+ with +value+.
  */
 static VALUE
-register_variable(VALUE self, VALUE name, VALUE value)
+rb_xml_xpath_context_register_variable(VALUE self, VALUE name, VALUE value)
 {
   xmlXPathContextPtr ctx;
   xmlXPathObjectPtr xmlValue;
@@ -128,69 +148,86 @@ 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 c_xpath_object, xmlXPathContextPtr ctx)
+{
+  VALUE rb_retval;
+
+  assert(ctx->doc);
+  assert(DOC_RUBY_OBJECT_TEST(ctx->doc));
+
+  switch (c_xpath_object->type) {
+    case XPATH_STRING:
+      rb_retval = NOKOGIRI_STR_NEW2(c_xpath_object->stringval);
+      xmlFree(c_xpath_object->stringval);
+      return rb_retval;
+
+    case XPATH_NODESET:
+      return noko_xml_node_set_wrap(c_xpath_object->nodesetval,
+                                    DOC_RUBY_OBJECT(ctx->doc));
+
+    case XPATH_NUMBER:
+      return rb_float_new(c_xpath_object->floatval);
+
+    case XPATH_BOOLEAN:
+      return (c_xpath_object->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)
+Nokogiri_marshal_xpath_funcall_and_return_values(
+  xmlXPathParserContextPtr ctx,
+  int argc,
+  VALUE rb_xpath_handler,
+  const char *method_name
+)
 {
-  int i;
-  VALUE result, doc;
+  VALUE rb_retval;
   VALUE *argv;
-  VALUE node_set = Qnil;
-  xmlNodeSetPtr xml_node_set = NULL;
-  xmlXPathObjectPtr obj;
+  VALUE rb_node_set = Qnil;
+  xmlNodeSetPtr c_node_set = NULL;
+  xmlXPathObjectPtr c_xpath_object;
 
   assert(ctx->context->doc);
   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]);
+  argv = (VALUE *)ruby_xcalloc((size_t)argc, sizeof(VALUE));
+  for (int j = 0 ; j < argc ; ++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 = argc - 1 ; j >= 0 ; --j) {
+    c_xpath_object = valuePop(ctx);
+    argv[j] = xpath2ruby(c_xpath_object, ctx->context);
+    if (argv[j] == Qundef) {
+      argv[j] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(c_xpath_object));
+    }
+    xmlXPathFreeNodeSetList(c_xpath_object);
   }
 
-  result = rb_funcall2(handler, rb_intern((const char *)function_name), nargs, argv);
+  rb_retval = rb_funcall2(rb_xpath_handler, rb_intern((const char *)method_name), argc, argv);
 
-  for (i = 0 ; i < nargs ; ++i) {
-    rb_gc_unregister_address(&argv[i]);
+  for (int j = 0 ; j < argc ; ++j) {
+    rb_gc_unregister_address(&argv[j]);
   }
-  free(argv);
+  ruby_xfree(argv);
 
-  switch (TYPE(result)) {
+  switch (TYPE(rb_retval)) {
     case T_FLOAT:
     case T_BIGNUM:
     case T_FIXNUM:
-      xmlXPathReturnNumber(ctx, NUM2DBL(result));
+      xmlXPathReturnNumber(ctx, NUM2DBL(rb_retval));
       break;
     case T_STRING:
-      xmlXPathReturnString(
-        ctx,
-        xmlCharStrdup(StringValueCStr(result))
-      );
+      xmlXPathReturnString(ctx, xmlCharStrdup(StringValueCStr(rb_retval)));
       break;
     case T_TRUE:
       xmlXPathReturnTrue(ctx);
@@ -201,19 +238,17 @@ Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, i
     case T_NIL:
       break;
     case T_ARRAY: {
-      VALUE args[2];
-      args[0] = doc;
-      args[1] = result;
-      node_set = rb_class_new_instance(2, args, cNokogiriXmlNodeSet);
-      Data_Get_Struct(node_set, xmlNodeSet, xml_node_set);
-      xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
+      VALUE construct_args[2] = { DOC_RUBY_OBJECT(ctx->context->doc), rb_retval };
+      rb_node_set = rb_class_new_instance(2, construct_args, cNokogiriXmlNodeSet);
+      Data_Get_Struct(rb_node_set, xmlNodeSet, c_node_set);
+      xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, c_node_set));
     }
     break;
     case T_DATA:
-      if (rb_obj_is_kind_of(result, cNokogiriXmlNodeSet)) {
-        Data_Get_Struct(result, xmlNodeSet, xml_node_set);
+      if (rb_obj_is_kind_of(rb_retval, cNokogiriXmlNodeSet)) {
+        Data_Get_Struct(rb_retval, xmlNodeSet, c_node_set);
         /* Copy the node set, otherwise it will get GC'd. */
-        xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
+        xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, c_node_set));
         break;
       }
     default:
@@ -222,47 +257,56 @@ Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, i
 }
 
 static void
-ruby_funcall(xmlXPathParserContextPtr ctx, int nargs)
+method_caller(xmlXPathParserContextPtr ctx, int argc)
 {
-  VALUE handler = Qnil;
-  const char *function = NULL ;
+  VALUE rb_xpath_handler = Qnil;
+  const char *method_name = NULL ;
 
   assert(ctx);
   assert(ctx->context);
   assert(ctx->context->userData);
   assert(ctx->context->function);
 
-  handler = (VALUE)(ctx->context->userData);
-  function = (const char *)(ctx->context->function);
+  rb_xpath_handler = (VALUE)(ctx->context->userData);
+  method_name = (const char *)(ctx->context->function);
 
-  Nokogiri_marshal_xpath_funcall_and_return_values(ctx, nargs, handler, function);
+  Nokogiri_marshal_xpath_funcall_and_return_values(ctx, argc, rb_xpath_handler, method_name);
 }
 
 static xmlXPathFunction
-lookup(void *ctx,
-       const xmlChar *name,
-       const xmlChar *ns_uri)
+handler_lookup(void *ctx, const xmlChar *c_name, const xmlChar *c_ns_uri)
 {
-  VALUE xpath_handler = (VALUE)ctx;
-  if (rb_respond_to(xpath_handler, rb_intern((const char *)name))) {
-    return ruby_funcall;
+  VALUE rb_xpath_handler = (VALUE)ctx;
+  if (rb_respond_to(rb_xpath_handler, rb_intern((const char *)c_name))) {
+    return method_caller;
   }
 
   return NULL;
 }
 
-NORETURN(static void xpath_generic_exception_handler(void *ctx, const char *msg, ...));
+PRINTFLIKE_DECL(2, 3)
 static void
-xpath_generic_exception_handler(void *ctx, const char *msg, ...)
+generic_exception_pusher(void *ctx, const char *msg, ...)
 {
-  char *message;
+  VALUE rb_errors = (VALUE)ctx;
+  VALUE rb_message;
+  VALUE rb_exception;
 
+  Check_Type(rb_errors, T_ARRAY);
+
+#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. */
+  rb_message = rb_sprintf("generic_exception_pusher: %s", msg);
+#else
   va_list args;
   va_start(args, msg);
-  vasprintf(&message, msg, args);
+  rb_message = rb_vsprintf(msg, args);
   va_end(args);
+#endif
 
-  rb_raise(rb_eRuntimeError, "%s", message);
+  rb_exception = rb_exc_new_str(cNokogiriXmlXpathSyntaxError, rb_message);
+  rb_ary_push(rb_errors, rb_exception);
 }
 
 /*
@@ -272,13 +316,14 @@ xpath_generic_exception_handler(void *ctx, const char *msg, ...)
  * Evaluate the +search_path+ returning an XML::XPath object.
  */
 static VALUE
-evaluate(int argc, VALUE *argv, VALUE self)
+rb_xml_xpath_context_evaluate(int argc, VALUE *argv, VALUE self)
 {
   VALUE search_path, xpath_handler;
-  VALUE thing = Qnil;
+  VALUE retval = Qnil;
   xmlXPathContextPtr ctx;
   xmlXPathObjectPtr xpath;
   xmlChar *query;
+  VALUE errors = rb_ary_new();
 
   Data_Get_Struct(self, xmlXPathContext, ctx);
 
@@ -291,50 +336,29 @@ evaluate(int argc, VALUE *argv, VALUE self)
   if (Qnil != xpath_handler) {
     /* FIXME: not sure if this is the correct place to shove private data. */
     ctx->userData = (void *)xpath_handler;
-    xmlXPathRegisterFuncLookup(ctx, lookup, (void *)xpath_handler);
+    xmlXPathRegisterFuncLookup(ctx, handler_lookup, (void *)xpath_handler);
   }
 
-  xmlResetLastError();
-  xmlSetStructuredErrorFunc(NULL, Nokogiri_error_raise);
-
-  /* For some reason, xmlXPathEvalExpression will blow up with a generic error */
-  /* when there is a non existent function. */
-  xmlSetGenericErrorFunc(NULL, xpath_generic_exception_handler);
+  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+  xmlSetGenericErrorFunc((void *)errors, generic_exception_pusher);
 
   xpath = xmlXPathEvalExpression(query, ctx);
+
   xmlSetStructuredErrorFunc(NULL, NULL);
   xmlSetGenericErrorFunc(NULL, NULL);
 
   if (xpath == NULL) {
-    xmlErrorPtr error = xmlGetLastError();
-    rb_exc_raise(Nokogiri_wrap_xml_syntax_error(error));
+    rb_exc_raise(rb_ary_entry(errors, 0));
   }
 
-  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;
 }
 
 /*
@@ -344,24 +368,30 @@ evaluate(int argc, VALUE *argv, VALUE self)
  * Create a new XPathContext with +node+ as the reference point.
  */
 static VALUE
-new (VALUE klass, VALUE nodeobj)
+rb_xml_xpath_context_new(VALUE klass, VALUE nodeobj)
 {
   xmlNodePtr node;
   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;
 
+  xmlXPathRegisterNs(ctx, NOKOGIRI_PREFIX, NOKOGIRI_URI);
   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);
+  self = Data_Wrap_Struct(klass, 0, xml_xpath_context_deallocate, ctx);
   return self;
 }
 
@@ -375,9 +405,9 @@ noko_init_xml_xpath_context(void)
 
   rb_undef_alloc_func(cNokogiriXmlXpathContext);
 
-  rb_define_singleton_method(cNokogiriXmlXpathContext, "new", new, 1);
+  rb_define_singleton_method(cNokogiriXmlXpathContext, "new", rb_xml_xpath_context_new, 1);
 
-  rb_define_method(cNokogiriXmlXpathContext, "evaluate", evaluate, -1);
-  rb_define_method(cNokogiriXmlXpathContext, "register_variable", register_variable, 2);
-  rb_define_method(cNokogiriXmlXpathContext, "register_ns", register_ns, 2);
+  rb_define_method(cNokogiriXmlXpathContext, "evaluate", rb_xml_xpath_context_evaluate, -1);
+  rb_define_method(cNokogiriXmlXpathContext, "register_variable", rb_xml_xpath_context_register_variable, 2);
+  rb_define_method(cNokogiriXmlXpathContext, "register_ns", rb_xml_xpath_context_register_ns, 2);
 }

data/ext/nokogiri/xslt_stylesheet.c

@@ -12,27 +12,28 @@ static void
 dealloc(nokogiriXsltStylesheetTuple *wrapper)
 {
   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);
 }
 
+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
@@ -107,19 +108,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)
@@ -150,7 +249,7 @@ transform(int argc, VALUE *argv, VALUE self)
   Data_Get_Struct(self, nokogiriXsltStylesheetTuple, wrapper);
 
   param_len = RARRAY_LEN(paramobj);
-  params = calloc((size_t)param_len + 1, sizeof(char *));
+  params = ruby_xcalloc((size_t)param_len + 1, sizeof(char *));
   for (j = 0 ; j < param_len ; j++) {
     VALUE entry = rb_ary_entry(paramobj, j);
     const char *ptr = StringValueCStr(entry);
@@ -163,7 +262,7 @@ transform(int argc, VALUE *argv, VALUE self)
   xmlSetGenericErrorFunc((void *)errstr, xslt_generic_error_handler);
 
   result = xsltApplyStylesheet(wrapper->ss, xml, params);
-  free(params);
+  ruby_xfree(params);
 
   xsltSetGenericErrorFunc(NULL, NULL);
   xmlSetGenericErrorFunc(NULL, NULL);
@@ -249,7 +348,7 @@ registr(VALUE self, VALUE uri, VALUE obj)
 }
 
 void
-noko_init_xslt_stylesheet()
+noko_init_xslt_stylesheet(void)
 {
   rb_define_singleton_method(mNokogiriXslt, "register", registr, 2);
   rb_iv_set(mNokogiriXslt, "@modules", rb_hash_new());

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"
@@ -96,7 +96,7 @@ static void print_tag_stack (
     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);

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  */
+/* Command-line: gperf -m100 -n src/foreign_attrs.gperf  */
 /* Computed positions: -k'2,8' */
-/* Filtered by: mk/gperf-filter.sed */
+/* Filtered by: gperf-filter.sed */
 
 #include "replacement.h"
 #include "macros.h"

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.