nokogiri 1.14.3-arm64-darwin → 1.15.0-arm64-darwin

data/ext/nokogiri/xslt_stylesheet.c

@@ -3,19 +3,30 @@
 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;
   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, ...)
@@ -42,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;
@@ -64,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);
@@ -91,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;
@@ -99,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);
@@ -221,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);
+  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);
+
+  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);
 
-  result = xsltApplyStylesheet(wrapper->ss, xml, 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
@@ -290,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 *
@@ -306,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);
 
@@ -324,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(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);
@@ -358,6 +411,6 @@ noko_init_xslt_stylesheet(void)
   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/lib/nokogiri/css/xpath_visitor.rb

@@ -133,7 +133,7 @@ module Nokogiri
           args += node.value[1..-1].map do |n|
             n.is_a?(Nokogiri::CSS::Node) ? n.accept(self) : n
           end
-          "#{node.value.first}#{args.join(",")})"
+          "nokogiri:#{node.value.first}#{args.join(",")})"
         end
       end
 
@@ -207,7 +207,7 @@ module Nokogiri
           when "parent" then "node()"
           when "root" then "not(parent::*)"
           else
-            node.value.first + "(.)"
+            "nokogiri:#{node.value.first}(.)"
           end
         end
       end

data/lib/nokogiri/extension.rb

@@ -6,7 +6,7 @@ begin
   RUBY_VERSION =~ /(\d+\.\d+)/
   require_relative "#{Regexp.last_match(1)}/nokogiri"
 rescue LoadError => e
-  if /GLIBC/.match?(e.message)
+  if e.message.include?("GLIBC")
     warn(<<~EOM)
 
       ERROR: It looks like you're trying to use Nokogiri as a precompiled native gem on a system

data/lib/nokogiri/html4/document_fragment.rb

@@ -24,7 +24,7 @@ module Nokogiri
         new(doc, tags, nil, options, &block)
       end
 
-      def initialize(document, tags = nil, ctx = nil, options = XML::ParseOptions::DEFAULT_HTML)
+      def initialize(document, tags = nil, ctx = nil, options = XML::ParseOptions::DEFAULT_HTML) # rubocop:disable Lint/MissingSuper
         return self unless tags
 
         options = Nokogiri::XML::ParseOptions.new(options) if Integer === options