nokogiri 1.14.2 → 1.16.5

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;
@@ -56,7 +71,12 @@ Nokogiri_wrap_xslt_stylesheet(xsltStylesheetPtr ss)
  * call-seq:
  *   parse_stylesheet_doc(document)
  *
- * Parse a stylesheet from +document+.
+ * Parse an XSLT::Stylesheet from +document+.
+ *
+ * [Parameters]
+ * - +document+ (Nokogiri::XML::Document) the document to be parsed.
+ *
+ * [Returns] Nokogiri::XSLT::Stylesheet
  */
 static VALUE
 parse_stylesheet_doc(VALUE klass, VALUE xmldocobj)
@@ -64,7 +84,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);
@@ -88,10 +109,10 @@ parse_stylesheet_doc(VALUE klass, VALUE xmldocobj)
  * call-seq:
  *   serialize(document)
  *
- * Serialize +document+ to an xml string.
+ * Serialize +document+ to an xml string, as specified by the +method+ parameter in the Stylesheet.
  */
 static VALUE
-serialize(VALUE self, VALUE xmlobj)
+rb_xslt_stylesheet_serialize(VALUE self, VALUE xmlobj)
 {
   xmlDocPtr xml ;
   nokogiriXsltStylesheetTuple *wrapper;
@@ -99,8 +120,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);
@@ -112,7 +138,7 @@ serialize(VALUE self, VALUE xmlobj)
  *   transform(document)
  *   transform(document, params = {})
  *
- * Apply an XSLT stylesheet to an XML::Document.
+ * Transform an XML::Document as defined by an XSLT::Stylesheet.
  *
  * [Parameters]
  * - +document+ (Nokogiri::XML::Document) the document to be transformed.
@@ -221,60 +247,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 +330,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 +351,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 +377,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 +416,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/gumbo-parser/Makefile

@@ -13,6 +13,23 @@ LDFLAGS := -pthread
 
 all: check
 
+oss-fuzz:
+	./fuzzer/build-ossfuzz.sh
+
+fuzzers: fuzzer-normal fuzzer-asan fuzzer-ubsan fuzzer-msan
+
+fuzzer-normal:
+	./fuzzer/build.sh
+
+fuzzer-asan:
+	SANITIZER=asan ./fuzzer/build.sh
+
+fuzzer-ubsan:
+	SANITIZER=ubsan ./fuzzer/build.sh
+
+fuzzer-msan:
+	SANITIZER=msan ./fuzzer/build.sh
+
 # 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)
@@ -81,6 +98,7 @@ coverage:
 
 clean:
 	$(RM) -r build
+	$(RM) -r fuzzer/build fuzzer/src-* fuzzer/gumbo_corpus
 
 build/src/flags: | build/src
 	@echo 'old_CC := $(CC)' > $@

data/gumbo-parser/src/error.c

@@ -91,7 +91,7 @@ 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, ", ");
@@ -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/foreign_attrs.c

@@ -1,6 +1,6 @@
 /* ANSI-C code produced by gperf version 3.1 */
 /* Command-line: gperf -m100 -n src/foreign_attrs.gperf  */
-/* Computed positions: -k'2,8' */
+/* Computed positions: -k'8-9' */
 /* Filtered by: gperf-filter.sed */
 
 #include "replacement.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/parser.c

@@ -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)) {
@@ -3963,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 (
@@ -4813,14 +4826,17 @@ GumboOutput* gumbo_parse_with_options (
       // to a token.
       if (token.type == GUMBO_TOKEN_END_TAG &&
           token.v.end_tag.tag == GUMBO_TAG_UNKNOWN)
+      {
         gumbo_free(token.v.end_tag.name);
+        token.v.end_tag.name = NULL;
+      }
+      if (unlikely(state->_open_elements.length > max_tree_depth)) {
+        parser._output->status = GUMBO_STATUS_TREE_TOO_DEEP;
+        gumbo_debug("Tree depth limit exceeded.\n");
+        break;
+      }
     }
 
-    if (unlikely(state->_open_elements.length > max_tree_depth)) {
-      parser._output->status = GUMBO_STATUS_TREE_TOO_DEEP;
-      gumbo_debug("Tree depth limit exceeded.\n");
-      break;
-    }
 
     ++loop_count;
     assert(loop_count < 1000000000UL);

data/gumbo-parser/src/tokenizer.c

@@ -506,6 +506,7 @@ static void abandon_current_tag(GumboParser* parser) {
   for (unsigned int i = 0; i < tag_state->_attributes.length; ++i) {
     gumbo_destroy_attribute(tag_state->_attributes.data[i]);
   }
+  gumbo_free(tag_state->_name);
   gumbo_free(tag_state->_attributes.data);
   mark_tag_state_as_empty(tag_state);
   gumbo_string_buffer_destroy(&tag_state->_buffer);

data/lib/nokogiri/css/parser_extras.rb

@@ -23,7 +23,7 @@ module Nokogiri
 
         # Get the css selector in +string+ from the cache
         def [](string)
-          return nil unless cache_on?
+          return unless cache_on?
 
           @mutex.synchronize { @cache[string] }
         end

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
@@ -302,7 +302,7 @@ module Nokogiri
       end
 
       def read_a_and_positive_b(values)
-        op = values[2]
+        op = values[2].strip
         if op == "+"
           a = values[0].to_i
           b = values[3].to_i
@@ -335,25 +335,5 @@ module Nokogiri
         end
       end
     end
-
-    module XPathVisitorAlwaysUseBuiltins # :nodoc:
-      def self.new
-        warn(
-          "Nokogiri::CSS::XPathVisitorAlwaysUseBuiltins is deprecated and will be removed in a future version of Nokogiri",
-          { uplevel: 1 },
-        )
-        XPathVisitor.new(builtins: :always)
-      end
-    end
-
-    module XPathVisitorOptimallyUseBuiltins # :nodoc:
-      def self.new
-        warn(
-          "Nokogiri::CSS::XPathVisitorOptimallyUseBuiltins is deprecated and will be removed in a future version of Nokogiri",
-          { uplevel: 1 },
-        )
-        XPathVisitor.new(builtins: :optimal)
-      end
-    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.rb

@@ -92,7 +92,7 @@ module Nokogiri
         title = XML::Node.new("title", self) << tnode
         if (head = at_xpath("//head"))
           head << title
-        elsif (meta = (at_xpath("//meta[@charset]") || meta_content_type))
+        elsif (meta = at_xpath("//meta[@charset]") || meta_content_type)
           # better put after charset declaration
           meta.add_next_sibling(title)
         else

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