nokogiri 1.17.2 → 1.18.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a915fe582aabad2932ced42915cdb777c64c1a3f3ea8bfd89341fa222c022d62
-  data.tar.gz: 90301f89de7232df132f7f6d664fe7c1e490ffcd18ceaf517b614581ec34eaac
+  metadata.gz: 625a018bc3e4890d78d52e0c234d168e187a6d3cb6f9611da04fe9f5b887cc46
+  data.tar.gz: 3f542a6448b1134ae485801ef959e59978499b557792f7a73436735d0dc03681
 SHA512:
-  metadata.gz: 8ffd386186555f7dd6ea54d30f82a902e6fafc4c15a1cf7fc181964bf85f8d69043f2289133ca1ae3f294889e03841056963486897b947d05eefa389735ca2d8
-  data.tar.gz: 2582576f9d51851a2bf41ecd9c18ec972c4e909b51590dc46503b484ca3a91a6999dd5bcff943a4be9f899346405217b56431d9d554d5b198ad62b382e286cbd
+  metadata.gz: 9a59c6ea78b7d5ad1e48a280a3bc8d04b39ce5e10b4b717a1aa53935136450acd4439d9315a534b2146a73ef601e1da043de57aa1a6bebc24157f29350003121
+  data.tar.gz: b3352ba9ed567401f272920bb3e5aedc1e488f9e1014bdf4929cada908d716223324275115e4e8453ac2706d9553b3030f339a40a148b4d185baadd530887659

data/Gemfile

@@ -11,20 +11,20 @@ group :development do
 
   # building extensions
   gem "rake-compiler", "1.2.8"
-  gem "rake-compiler-dock", "1.5.2"
+  gem "rake-compiler-dock", "1.7.0"
 
   # parser generator
   gem "rexical", "1.0.8"
 
   # tests
-  gem "minitest", "5.25.2"
+  gem "minitest", "5.25.4"
   gem "minitest-parallel_fork", "2.0.0"
   gem "ruby_memcheck", "3.0.0"
   gem "rubyzip", "~> 2.3.2"
   gem "simplecov", "= 0.21.2"
 
   # rubocop
-  gem "standard", "1.42.1"
+  gem "standard", "1.43.0"
   gem "rubocop-minitest", "0.36.0"
   gem "rubocop-packaging", "0.5.2"
   gem "rubocop-rake", "0.6.0"
@@ -33,6 +33,8 @@ end
 # If Psych doesn't build, you can disable this group locally by running
 # `bundle config set --local without rdoc`
 # Then re-run `bundle install`.
-group :rdoc do
-  gem "rdoc", "6.8.1"
+unless RUBY_PLATFORM == "java" # see #3391 and https://github.com/jruby/jruby/issues/7262
+  group :rdoc do
+    gem "rdoc", "6.10.0"
+  end
 end

data/LICENSE-DEPENDENCIES.md

@@ -10,9 +10,9 @@ Note that this document is broken into multiple sections, each of which describe
 
 - [Platform Releases](#platform-releases)
   * [Default platform release ("ruby")](#default-platform-release-ruby)
-  * [Native LinuxⓇ platform releases ("x86_64-linux", "arm64-linux", "aarch64-linux", and "arm-linux")](#native-linux%E2%93%A1-platform-releases-x86_64-linux-arm64-linux-aarch64-linux-and-arm-linux)
+  * [Native LinuxⓇ platform releases ("x86_64-linux", "aarch64-linux", and "arm-linux")](#native-linux%E2%93%A1-platform-releases-x86_64-linux-aarch64-linux-and-arm-linux)
   * [Native Darwin (macOSⓇ) platform releases ("x86_64-darwin" and "arm64-darwin")](#native-darwin-macos%E2%93%A1-platform-releases-x86_64-darwin-and-arm64-darwin)
-  * [Native WindowsⓇ platform releases ("x86-mingw32" and "x64-mingw32")](#native-windows%E2%93%A1-platform-releases-x86-mingw32-and-x64-mingw32)
+  * [Native WindowsⓇ platform releases ("x64-mingw-ucrt")](#native-windows%E2%93%A1-platform-releases-x64-mingw-ucrt)
   * [JavaⓇ (JRuby) platform release ("java")](#java%E2%93%A1-jruby-platform-release-java)
 - [Appendix: Dependencies' License Texts](#appendix-dependencies-license-texts)
   * [libgumbo](#libgumbo)
@@ -51,7 +51,7 @@ The default platform release distributes the following dependencies in source fo
 This distribution can be identified by inspecting the included Gem::Specification, which will have the value "ruby" for its "platform" attribute.
 
 
-### Native LinuxⓇ platform releases ("x86_64-linux", "arm64-linux", "aarch64-linux", and "arm-linux")
+### Native LinuxⓇ platform releases ("x86_64-linux", "aarch64-linux", and "arm-linux")
 
 The native LinuxⓇ platform release distributes the following dependencies in source form:
 
@@ -60,7 +60,7 @@ The native LinuxⓇ platform release distributes the following dependencies in s
 * [libgumbo](#libgumbo)
 * [zlib](#zlib)
 
-This distribution can be identified by inspecting the included Gem::Specification, which will have a value similar to "x86_64-linux" or "arm64-linux" for its "platform.cpu" attribute.
+This distribution can be identified by inspecting the included Gem::Specification, which will have a value similar to "x86_64-linux" or "aarch64-linux" for its "platform.cpu" attribute.
 
 
 ### Native Darwin (macOSⓇ) platform releases ("x86_64-darwin" and "arm64-darwin")
@@ -76,7 +76,7 @@ The native Darwin platform release distributes the following dependencies in sou
 This distribution can be identified by inspecting the included Gem::Specification, which will have a value similar to "x86_64-darwin" or "arm64-darwin" for its "platform.cpu" attribute. Darwin is also known more familiarly as "OSX" or "macOSⓇ" and is the operating system for many AppleⓇ computers.
 
 
-### Native WindowsⓇ platform releases ("x86-mingw32" and "x64-mingw32")
+### Native WindowsⓇ platform releases ("x64-mingw-ucrt")
 
 The native WindowsⓇ platform release distributes the following dependencies in source form:
 
@@ -86,7 +86,7 @@ The native WindowsⓇ platform release distributes the following dependencies in
 * [zlib](#zlib)
 * [libiconv](#libiconv)
 
-This distribution can be identified by inspecting the included Gem::Specification, which will have a value similar to "x64-mingw32" or "x86-mingw32" for its "platform.cpu" attribute.
+This distribution can be identified by inspecting the included Gem::Specification, which will have a value similar to "x64-mingw-ucrt" for its "platform.cpu" attribute.
 
 
 ### JavaⓇ (JRuby) platform release ("java")

data/README.md

@@ -114,7 +114,7 @@ You can help sponsor the maintainers of this software through one of these organ
 
 Requirements:
 
-- Ruby >= 3.0
+- Ruby >= 3.1
 - JRuby >= 9.4.0.0
 
 If you are compiling the native extension against a system version of libxml2:
@@ -131,11 +131,10 @@ If you are compiling the native extension against a system version of libxml2:
 Nokogiri ships pre-compiled, "native" gems for the following platforms:
 
 - Linux:
-  - `x86-linux` and `x86_64-linux` (req: `glibc >= 2.17`)
-  - `aarch64-linux` and `arm-linux` (req: `glibc >= 2.29`)
-  - Note that musl platforms like Alpine **are** supported
+  - `x86_64-linux-gnu`, `aarch64-linux-gnu`, and `arm-linux-gnu` (req: `glibc >= 2.29`)
+  - `x86_64-linux-musl`, `aarch64-linux-musl`, and `arm-linux-musl`
 - Darwin/MacOS: `x86_64-darwin` and `arm64-darwin`
-- Windows: `x86-mingw32`, `x64-mingw32`, and `x64-mingw-ucrt`
+- Windows: `x64-mingw-ucrt`
 - Java: any platform running JRuby 9.4 or higher
 
 To determine whether your system supports one of these gems, look at the output of `bundle platform` or `ruby -e 'puts Gem::Platform.local.to_s'`.

data/ext/nokogiri/extconf.rb

@@ -847,7 +847,7 @@ else
         # The libiconv configure script doesn't accept "arm64" host string but "aarch64"
         recipe.host = recipe.host.gsub("arm64-apple-darwin", "aarch64-apple-darwin")
 
-        cflags = concat_flags(ENV["CFLAGS"], "-O2", "-U_FORTIFY_SOURCE", "-g")
+        cflags = concat_flags(ENV["CFLAGS"], "-O2", "-g")
 
         recipe.configure_options += [
           "--disable-dependency-tracking",
@@ -911,7 +911,7 @@ else
     end
 
     cppflags = concat_flags(ENV["CPPFLAGS"])
-    cflags = concat_flags(ENV["CFLAGS"], "-O2", "-U_FORTIFY_SOURCE", "-g")
+    cflags = concat_flags(ENV["CFLAGS"], "-O2", "-g")
 
     if cross_build_p
       cppflags = concat_flags(cppflags, "-DNOKOGIRI_PRECOMPILED_LIBRARIES")
@@ -952,7 +952,6 @@ else
       "--with-c14n",
       "--with-debug",
       "--with-threads",
-      "--without-tls", # see https://github.com/sparklemotion/nokogiri/issues/3031
       "CPPFLAGS=#{cppflags}",
       "CFLAGS=#{cflags}",
     ]
@@ -971,7 +970,7 @@ else
       recipe.patch_files = Dir[File.join(PACKAGE_ROOT_DIR, "patches", "libxslt", "*.patch")].sort
     end
 
-    cflags = concat_flags(ENV["CFLAGS"], "-O2", "-U_FORTIFY_SOURCE", "-g")
+    cflags = concat_flags(ENV["CFLAGS"], "-O2", "-g")
 
     if darwin? && !cross_build_p
       recipe.configure_options << "RANLIB=/usr/bin/ranlib" unless ENV.key?("RANLIB")
@@ -1117,14 +1116,7 @@ else
           end
           env["RANLIB"] = "#{host}-ranlib"
           if windows?
-            # NOTE: that in any particular windows gem package, we only ever compile against either
-            # msvcrt (ruby <= 3.0) or ucrt (ruby > 3.0), so even though this gets evaluated only once
-            # per gem (and not per-version-of-ruby), it's OK.
-            env["CFLAGS"] = if RbConfig::CONFIG["RUBY_SO_NAME"].include?("msvcrt")
-              concat_flags(env["CFLAGS"], "-D_RUBY_MSVCRT")
-            else
-              concat_flags(env["CFLAGS"], "-D_RUBY_UCRT")
-            end
+            concat_flags(env["CFLAGS"], "-D_RUBY_UCRT")
           end
         end
 
@@ -1141,7 +1133,7 @@ end
 have_func("xmlCtxtSetOptions") # introduced in libxml2 2.13.0
 have_func("xmlCtxtGetOptions") # introduced in libxml2 2.14.0
 have_func("xmlSwitchEncodingName") # introduced in libxml2 2.13.0
-have_func("rb_category_warning") # introduced in Ruby 3.0
+have_func("rb_category_warning") # introduced in Ruby 3.0 but had trouble resolving this symbol in truffleruby
 
 other_library_versions_string = OTHER_LIBRARY_VERSIONS.map { |k, v| [k, v].join(":") }.join(",")
 append_cppflags(%[-DNOKOGIRI_OTHER_LIBRARY_VERSIONS="\\"#{other_library_versions_string}\\""])

data/ext/nokogiri/xml_sax_parser_context.c

@@ -102,7 +102,10 @@ noko_xml_sax_parser_context_s_native_io(VALUE rb_class, VALUE rb_io, VALUE rb_en
     c_context->sax = NULL;
   }
 
-  return noko_xml_sax_parser_context_wrap(rb_class, c_context);
+  VALUE rb_context = noko_xml_sax_parser_context_wrap(rb_class, c_context);
+  rb_iv_set(rb_context, "@input", rb_io);
+
+  return rb_context;
 }
 
 /* :nodoc: */
@@ -154,7 +157,10 @@ noko_xml_sax_parser_context_s_native_memory(VALUE rb_class, VALUE rb_input, VALU
     c_context->sax = NULL;
   }
 
-  return noko_xml_sax_parser_context_wrap(rb_class, c_context);
+  VALUE rb_context = noko_xml_sax_parser_context_wrap(rb_class, c_context);
+  rb_iv_set(rb_context, "@input", rb_input);
+
+  return rb_context;
 }
 
 /*

data/ext/nokogiri/xml_xpath_context.c

@@ -12,23 +12,23 @@ static const xmlChar *NOKOGIRI_BUILTIN_PREFIX = (const xmlChar *)"nokogiri-built
 static const xmlChar *NOKOGIRI_BUILTIN_URI = (const xmlChar *)"https://www.nokogiri.org/default_ns/ruby/builtins";
 
 static void
-xml_xpath_context_deallocate(void *data)
+_noko_xml_xpath_context_dfree(void *data)
 {
   xmlXPathContextPtr c_context = data;
   xmlXPathFreeContext(c_context);
 }
 
-static const rb_data_type_t xml_xpath_context_type = {
+static const rb_data_type_t _noko_xml_xpath_context_type = {
   .wrap_struct_name = "xmlXPathContext",
   .function = {
-    .dfree = xml_xpath_context_deallocate,
+    .dfree = _noko_xml_xpath_context_dfree,
   },
   .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 /* find a CSS class in an HTML element's `class` attribute */
 static const xmlChar *
-builtin_css_class(const xmlChar *str, const xmlChar *val)
+_noko_xml_xpath_context__css_class(const xmlChar *str, const xmlChar *val)
 {
   int val_len;
 
@@ -62,9 +62,9 @@ builtin_css_class(const xmlChar *str, const xmlChar *val)
   return (NULL);
 }
 
-/* xmlXPathFunction to wrap builtin_css_class() */
+/* xmlXPathFunction to wrap _noko_xml_xpath_context__css_class() */
 static void
-xpath_builtin_css_class(xmlXPathParserContextPtr ctxt, int nargs)
+noko_xml_xpath_context_xpath_func_css_class(xmlXPathParserContextPtr ctxt, int nargs)
 {
   xmlXPathObjectPtr hay, needle;
 
@@ -85,7 +85,7 @@ xpath_builtin_css_class(xmlXPathParserContextPtr ctxt, int nargs)
     XP_ERROR(XPATH_INVALID_TYPE);
   }
 
-  if (builtin_css_class(hay->stringval, needle->stringval)) {
+  if (_noko_xml_xpath_context__css_class(hay->stringval, needle->stringval)) {
     valuePush(ctxt, xmlXPathNewBoolean(1));
   } else {
     valuePush(ctxt, xmlXPathNewBoolean(0));
@@ -99,7 +99,7 @@ xpath_builtin_css_class(xmlXPathParserContextPtr ctxt, int nargs)
 /* 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)
+noko_xml_xpath_context_xpath_func_local_name_is(xmlXPathParserContextPtr ctxt, int nargs)
 {
   xmlXPathObjectPtr element_name;
 
@@ -124,25 +124,26 @@ xpath_builtin_local_name_is(xmlXPathParserContextPtr ctxt, int nargs)
  *   register_ns(prefix, uri) → Nokogiri::XML::XPathContext
  *
  * Register the namespace with +prefix+ and +uri+ for use in future queries.
+ * Passing a uri of +nil+ will unregister the namespace.
  *
  * [Returns] +self+
  */
 static VALUE
-rb_xml_xpath_context_register_ns(VALUE rb_context, VALUE prefix, VALUE uri)
+noko_xml_xpath_context_register_ns(VALUE rb_context, VALUE prefix, VALUE uri)
 {
   xmlXPathContextPtr c_context;
+  const xmlChar *ns_uri;
 
-  TypedData_Get_Struct(
-    rb_context,
-    xmlXPathContext,
-    &xml_xpath_context_type,
-    c_context
-  );
+  TypedData_Get_Struct(rb_context, xmlXPathContext, &_noko_xml_xpath_context_type, c_context);
+
+  if (NIL_P(uri)) {
+    ns_uri = NULL;
+  } else {
+    ns_uri = (const xmlChar *)StringValueCStr(uri);
+  }
+
+  xmlXPathRegisterNs(c_context, (const xmlChar *)StringValueCStr(prefix), ns_uri);
 
-  xmlXPathRegisterNs(c_context,
-                     (const xmlChar *)StringValueCStr(prefix),
-                     (const xmlChar *)StringValueCStr(uri)
-                    );
   return rb_context;
 }
 
@@ -151,29 +152,25 @@ rb_xml_xpath_context_register_ns(VALUE rb_context, VALUE prefix, VALUE uri)
  *   register_variable(name, value) → Nokogiri::XML::XPathContext
  *
  * Register the variable +name+ with +value+ for use in future queries.
+ * Passing a value of +nil+ will unregister the variable.
  *
  * [Returns] +self+
  */
 static VALUE
-rb_xml_xpath_context_register_variable(VALUE rb_context, VALUE name, VALUE value)
+noko_xml_xpath_context_register_variable(VALUE rb_context, VALUE name, VALUE value)
 {
   xmlXPathContextPtr c_context;
   xmlXPathObjectPtr xmlValue;
 
-  TypedData_Get_Struct(
-    rb_context,
-    xmlXPathContext,
-    &xml_xpath_context_type,
-    c_context
-  );
+  TypedData_Get_Struct(rb_context, xmlXPathContext, &_noko_xml_xpath_context_type, c_context);
 
-  xmlValue = xmlXPathNewCString(StringValueCStr(value));
+  if (NIL_P(value)) {
+    xmlValue = NULL;
+  } else {
+    xmlValue = xmlXPathNewCString(StringValueCStr(value));
+  }
 
-  xmlXPathRegisterVariable(
-    c_context,
-    (const xmlChar *)StringValueCStr(name),
-    xmlValue
-  );
+  xmlXPathRegisterVariable(c_context, (const xmlChar *)StringValueCStr(name), xmlValue);
 
   return rb_context;
 }
@@ -184,7 +181,7 @@ rb_xml_xpath_context_register_variable(VALUE rb_context, VALUE name, VALUE value
  *  returns Qundef if no conversion was possible.
  */
 static VALUE
-xpath2ruby(xmlXPathObjectPtr c_xpath_object, xmlXPathContextPtr c_context)
+_noko_xml_xpath_context__xpath2ruby(xmlXPathObjectPtr c_xpath_object, xmlXPathContextPtr c_context)
 {
   VALUE rb_retval;
 
@@ -238,7 +235,7 @@ Nokogiri_marshal_xpath_funcall_and_return_values(
 
   for (int j = argc - 1 ; j >= 0 ; --j) {
     c_xpath_object = valuePop(ctxt);
-    argv[j] = xpath2ruby(c_xpath_object, ctxt->context);
+    argv[j] = _noko_xml_xpath_context__xpath2ruby(c_xpath_object, ctxt->context);
     if (argv[j] == Qundef) {
       argv[j] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(c_xpath_object));
     }
@@ -294,7 +291,7 @@ Nokogiri_marshal_xpath_funcall_and_return_values(
 }
 
 static void
-method_caller(xmlXPathParserContextPtr ctxt, int argc)
+_noko_xml_xpath_context__handler_invoker(xmlXPathParserContextPtr ctxt, int argc)
 {
   VALUE rb_xpath_handler = Qnil;
   const char *method_name = NULL ;
@@ -316,15 +313,15 @@ method_caller(xmlXPathParserContextPtr ctxt, int argc)
 }
 
 static xmlXPathFunction
-handler_lookup(void *data, const xmlChar *c_name, const xmlChar *c_ns_uri)
+_noko_xml_xpath_context_handler_lookup(void *data, const xmlChar *c_name, const xmlChar *c_ns_uri)
 {
   VALUE rb_handler = (VALUE)data;
   if (rb_respond_to(rb_handler, rb_intern((const char *)c_name))) {
     if (c_ns_uri == NULL) {
       NOKO_WARN_DEPRECATION("A custom XPath or CSS handler function named '%s' is being invoked without a namespace. Please update your query to reference this function as 'nokogiri:%s'. Invoking custom handler functions without a namespace is deprecated and will become an error in Nokogiri v1.17.0.",
-                            c_name, c_name); // deprecated in v1.15.0, remove in v1.17.0
+                            c_name, c_name); // TODO deprecated in v1.15.0, remove in v1.19.0
     }
-    return method_caller;
+    return _noko_xml_xpath_context__handler_invoker;
   }
 
   return NULL;
@@ -332,7 +329,7 @@ handler_lookup(void *data, const xmlChar *c_name, const xmlChar *c_ns_uri)
 
 PRINTFLIKE_DECL(2, 3)
 static void
-generic_exception_pusher(void *data, const char *msg, ...)
+_noko_xml_xpath_context__generic_exception_pusher(void *data, const char *msg, ...)
 {
   VALUE rb_errors = (VALUE)data;
   VALUE rb_message;
@@ -343,7 +340,7 @@ generic_exception_pusher(void *data, const char *msg, ...)
 #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);
+  rb_message = rb_sprintf("_noko_xml_xpath_context__generic_exception_pusher: %s", msg);
 #else
   va_list args;
   va_start(args, msg);
@@ -365,58 +362,55 @@ generic_exception_pusher(void *data, const char *msg, ...)
  * a +Float+, or a boolean.
  */
 static VALUE
-rb_xml_xpath_context_evaluate(int argc, VALUE *argv, VALUE rb_context)
+noko_xml_xpath_context_evaluate(int argc, VALUE *argv, VALUE rb_context)
 {
-  VALUE search_path, xpath_handler;
-  VALUE retval = Qnil;
   xmlXPathContextPtr c_context;
-  xmlXPathObjectPtr xpath;
-  xmlChar *query;
-  VALUE errors = rb_ary_new();
-
-  TypedData_Get_Struct(
-    rb_context,
-    xmlXPathContext,
-    &xml_xpath_context_type,
-    c_context
-  );
+  VALUE rb_expression = Qnil;
+  VALUE rb_function_lookup_handler = Qnil;
+  xmlChar *c_expression_str = NULL;
+  VALUE rb_errors = rb_ary_new();
+  xmlXPathObjectPtr c_xpath_object;
+  VALUE rb_xpath_object = Qnil;
 
-  if (rb_scan_args(argc, argv, "11", &search_path, &xpath_handler) == 1) {
-    xpath_handler = Qnil;
-  }
+  TypedData_Get_Struct(rb_context, xmlXPathContext, &_noko_xml_xpath_context_type, c_context);
+
+  rb_scan_args(argc, argv, "11", &rb_expression, &rb_function_lookup_handler);
 
-  query = (xmlChar *)StringValueCStr(search_path);
+  c_expression_str = (xmlChar *)StringValueCStr(rb_expression);
 
-  if (Qnil != xpath_handler) {
+  if (Qnil != rb_function_lookup_handler) {
     /* FIXME: not sure if this is the correct place to shove private data. */
-    c_context->userData = (void *)xpath_handler;
+    c_context->userData = (void *)rb_function_lookup_handler;
     xmlXPathRegisterFuncLookup(
       c_context,
-      handler_lookup,
-      (void *)xpath_handler
+      _noko_xml_xpath_context_handler_lookup,
+      (void *)rb_function_lookup_handler
     );
   }
 
-  xmlSetStructuredErrorFunc((void *)errors, noko__error_array_pusher);
-  xmlSetGenericErrorFunc((void *)errors, generic_exception_pusher);
+  /* TODO: use xmlXPathSetErrorHandler (as of 2.13.0) */
+  xmlSetStructuredErrorFunc((void *)rb_errors, noko__error_array_pusher);
+  xmlSetGenericErrorFunc((void *)rb_errors, _noko_xml_xpath_context__generic_exception_pusher);
 
-  xpath = xmlXPathEvalExpression(query, c_context);
+  c_xpath_object = xmlXPathEvalExpression(c_expression_str, c_context);
 
   xmlSetStructuredErrorFunc(NULL, NULL);
   xmlSetGenericErrorFunc(NULL, NULL);
 
-  if (xpath == NULL) {
-    rb_exc_raise(rb_ary_entry(errors, 0));
+  xmlXPathRegisterFuncLookup(c_context, NULL, NULL);
+
+  if (c_xpath_object == NULL) {
+    rb_exc_raise(rb_ary_entry(rb_errors, 0));
   }
 
-  retval = xpath2ruby(xpath, c_context);
-  if (retval == Qundef) {
-    retval = noko_xml_node_set_wrap(NULL, DOC_RUBY_OBJECT(c_context->doc));
+  rb_xpath_object = _noko_xml_xpath_context__xpath2ruby(c_xpath_object, c_context);
+  if (rb_xpath_object == Qundef) {
+    rb_xpath_object = noko_xml_node_set_wrap(NULL, DOC_RUBY_OBJECT(c_context->doc));
   }
 
-  xmlXPathFreeNodeSetList(xpath);
+  xmlXPathFreeNodeSetList(c_xpath_object);
 
-  return retval;
+  return rb_xpath_object;
 }
 
 /*
@@ -426,45 +420,53 @@ rb_xml_xpath_context_evaluate(int argc, VALUE *argv, VALUE rb_context)
  * Create a new XPathContext with +node+ as the context node.
  */
 static VALUE
-rb_xml_xpath_context_new(VALUE klass, VALUE rb_node)
+noko_xml_xpath_context_new(VALUE klass, VALUE rb_node)
 {
-  xmlNodePtr node;
+  xmlNodePtr c_node;
   xmlXPathContextPtr c_context;
   VALUE rb_context;
 
-  Noko_Node_Get_Struct(rb_node, xmlNode, node);
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
 
 #if LIBXML_VERSION < 21000
-  /* deprecated in 40483d0 */
-  xmlXPathInit();
+  xmlXPathInit(); /* deprecated in 40483d0 */
 #endif
 
-  c_context = xmlXPathNewContext(node->doc);
-  c_context->node = node;
+  c_context = xmlXPathNewContext(c_node->doc);
+  c_context->node = c_node;
 
   xmlXPathRegisterNs(c_context, NOKOGIRI_PREFIX, NOKOGIRI_URI);
   xmlXPathRegisterNs(c_context, NOKOGIRI_BUILTIN_PREFIX, NOKOGIRI_BUILTIN_URI);
-  xmlXPathRegisterFuncNS(
-    c_context,
-    (const xmlChar *)"css-class",
-    NOKOGIRI_BUILTIN_URI,
-    xpath_builtin_css_class
-  );
-  xmlXPathRegisterFuncNS(
-    c_context,
-    (const xmlChar *)"local-name-is",
-    NOKOGIRI_BUILTIN_URI,
-    xpath_builtin_local_name_is
-  );
 
-  rb_context = TypedData_Wrap_Struct(
-                 klass,
-                 &xml_xpath_context_type,
-                 c_context
-               );
+  xmlXPathRegisterFuncNS(c_context,
+                         (const xmlChar *)"css-class", NOKOGIRI_BUILTIN_URI,
+                         noko_xml_xpath_context_xpath_func_css_class);
+  xmlXPathRegisterFuncNS(c_context,
+                         (const xmlChar *)"local-name-is", NOKOGIRI_BUILTIN_URI,
+                         noko_xml_xpath_context_xpath_func_local_name_is);
+
+  rb_context = TypedData_Wrap_Struct(klass, &_noko_xml_xpath_context_type, c_context);
+
   return rb_context;
 }
 
+
+/* :nodoc: */
+static VALUE
+noko_xml_xpath_context_set_node(VALUE rb_context, VALUE rb_node)
+{
+  xmlNodePtr c_node;
+  xmlXPathContextPtr c_context;
+
+  TypedData_Get_Struct(rb_context, xmlXPathContext, &_noko_xml_xpath_context_type, c_context);
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
+
+  c_context->doc = c_node->doc;
+  c_context->node = c_node;
+
+  return rb_node;
+}
+
 void
 noko_init_xml_xpath_context(void)
 {
@@ -475,9 +477,10 @@ noko_init_xml_xpath_context(void)
 
   rb_undef_alloc_func(cNokogiriXmlXpathContext);
 
-  rb_define_singleton_method(cNokogiriXmlXpathContext, "new", rb_xml_xpath_context_new, 1);
+  rb_define_singleton_method(cNokogiriXmlXpathContext, "new", noko_xml_xpath_context_new, 1);
 
-  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);
+  rb_define_method(cNokogiriXmlXpathContext, "evaluate", noko_xml_xpath_context_evaluate, -1);
+  rb_define_method(cNokogiriXmlXpathContext, "register_variable", noko_xml_xpath_context_register_variable, 2);
+  rb_define_method(cNokogiriXmlXpathContext, "register_ns", noko_xml_xpath_context_register_ns, 2);
+  rb_define_method(cNokogiriXmlXpathContext, "node=", noko_xml_xpath_context_set_node, 1);
 }

data/gumbo-parser/src/ascii.c

@@ -44,8 +44,8 @@ const unsigned char _gumbo_ascii_table[0x80] = {
 };
 
 // Table generation code.
-// clang -DGUMBO_GEN_TABLE=1 ascii.c && ./a.out && rm a.out
-#if GUMBO_GEN_TABLE
+// clang -DGUMBO_GEN_TABLE ascii.c && ./a.out && rm a.out
+#ifdef GUMBO_GEN_TABLE
 #include <stdio.h>
 
 int main() {

data/gumbo-parser/src/parser.c

@@ -318,7 +318,7 @@ static GumboNode* create_node(GumboNodeType type) {
   return node;
 }
 
-static GumboNode* new_document_node() {
+static GumboNode* new_document_node(void) {
   GumboNode* document_node = create_node(GUMBO_NODE_DOCUMENT);
   document_node->parse_flags = GUMBO_INSERTION_BY_PARSER;
   gumbo_vector_init(1, &document_node->v.document.children);
@@ -1997,7 +1997,7 @@ static void adjust_svg_tag(GumboToken* token) {
   assert(token->type == GUMBO_TOKEN_START_TAG);
   if (token->v.start_tag.tag == GUMBO_TAG_FOREIGNOBJECT) {
     assert(token->v.start_tag.name == NULL);
-    token->v.start_tag.name = "foreignObject";
+    token->v.start_tag.name = (char *)"foreignObject";
   } else if (token->v.start_tag.tag == GUMBO_TAG_UNKNOWN) {
     assert(token->v.start_tag.name);
     const StringReplacement *replacement = gumbo_get_svg_tag_replacement(

data/lib/nokogiri/version/constant.rb

@@ -2,5 +2,5 @@
 
 module Nokogiri
   # The version of Nokogiri you are using
-  VERSION = "1.17.2"
+  VERSION = "1.18.1"
 end

data/lib/nokogiri/xml/searchable.rb

@@ -207,35 +207,26 @@ module Nokogiri
 
       private
 
-      def css_internal(node, rules, handler, ns)
-        xpath_internal(node, css_rules_to_xpath(rules, ns), handler, ns, nil)
-      end
-
-      def xpath_internal(node, paths, handler, ns, binds)
-        document = node.document
-        return NodeSet.new(document) unless document
-
-        if paths.length == 1
-          return xpath_impl(node, paths.first, handler, ns, binds)
+      def extract_params(params) # :nodoc:
+        handler = params.find do |param|
+          ![Hash, String, Symbol].include?(param.class)
         end
+        params -= [handler] if handler
 
-        NodeSet.new(document) do |combined|
-          paths.each do |path|
-            xpath_impl(node, path, handler, ns, binds).each { |set| combined << set }
-          end
+        hashes = []
+        while Hash === params.last || params.last.nil?
+          hashes << params.pop
+          break if params.empty?
         end
-      end
+        ns, binds = hashes.reverse
 
-      def xpath_impl(node, path, handler, ns, binds)
-        ctx = XPathContext.new(node)
-        ctx.register_namespaces(ns)
-        path = path.gsub("xmlns:", " :") unless Nokogiri.uses_libxml?
+        ns ||= document.root&.namespaces || {}
 
-        binds&.each do |key, value|
-          ctx.register_variable(key.to_s, value)
-        end
+        [params, handler, ns, binds]
+      end
 
-        ctx.evaluate(path, handler)
+      def css_internal(node, rules, handler, ns)
+        xpath_internal(node, css_rules_to_xpath(rules, ns), handler, ns, nil)
       end
 
       def css_rules_to_xpath(rules, ns)
@@ -254,22 +245,29 @@ module Nokogiri
         end.join(" | ")
       end
 
-      def extract_params(params) # :nodoc:
-        handler = params.find do |param|
-          ![Hash, String, Symbol].include?(param.class)
+      def xpath_internal(node, paths, handler, ns, binds)
+        document = node.document
+        return NodeSet.new(document) unless document
+
+        if paths.length == 1
+          return xpath_impl(node, paths.first, handler, ns, binds)
         end
-        params -= [handler] if handler
 
-        hashes = []
-        while Hash === params.last || params.last.nil?
-          hashes << params.pop
-          break if params.empty?
+        NodeSet.new(document) do |combined|
+          paths.each do |path|
+            xpath_impl(node, path, handler, ns, binds).each { |set| combined << set }
+          end
         end
-        ns, binds = hashes.reverse
+      end
 
-        ns ||= document.root&.namespaces || {}
+      def xpath_impl(node, path, handler, ns, binds)
+        context = XPathContext.new(node)
+        context.register_namespaces(ns)
+        context.register_variables(binds)
 
-        [params, handler, ns, binds]
+        path = path.gsub("xmlns:", " :") unless Nokogiri.uses_libxml?
+
+        context.evaluate(path, handler)
       end
     end
   end

data/lib/nokogiri/xml/xpath_context.rb

@@ -6,9 +6,20 @@ module Nokogiri
       ###
       # Register namespaces in +namespaces+
       def register_namespaces(namespaces)
-        namespaces.each do |k, v|
-          k = k.to_s.gsub(/.*:/, "") # strip off 'xmlns:' or 'xml:'
-          register_ns(k, v)
+        namespaces.each do |key, value|
+          key = key.to_s.gsub(/.*:/, "") # strip off 'xmlns:' or 'xml:'
+
+          register_ns(key, value)
+        end
+      end
+
+      def register_variables(binds)
+        return if binds.nil?
+
+        binds.each do |key, value|
+          key = key.to_s
+
+          register_variable(key, value)
         end
       end
     end

data/patches/libxml2/0019-xpath-Use-separate-static-hash-table-for-standard-fu.patch

@@ -0,0 +1,244 @@
+From d3e3526111097560cf7c002613e2cb1d469b59e0 Mon Sep 17 00:00:00 2001
+From: Nick Wellnhofer <wellnhofer@aevum.de>
+Date: Sat, 21 Dec 2024 16:03:46 +0100
+Subject: [PATCH] xpath: Use separate static hash table for standard functions
+
+This avoids registering standard functions when creating an XPath
+context.
+
+Lookup of extension functions is a bit slower now, but ultimately, all
+function lookups should be moved to the compilation phase.
+
+(cherry picked from commit bf5fcf6e646bb51a0f6a3655a1d64bea97274867)
+---
+ xpath.c | 170 ++++++++++++++++++++++++++++++++------------------------
+ 1 file changed, 98 insertions(+), 72 deletions(-)
+
+diff --git a/xpath.c b/xpath.c
+index 485d7747..21711653 100644
+--- a/xpath.c
++++ b/xpath.c
+@@ -136,11 +136,48 @@
+ 
+ #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
+ 
+-/************************************************************************
+- *									*
+- *			Floating point stuff				*
+- *									*
+- ************************************************************************/
++static void
++xmlXPathNameFunction(xmlXPathParserContextPtr ctxt, int nargs);
++
++static const struct {
++    const char *name;
++    xmlXPathFunction func;
++} xmlXPathStandardFunctions[] = {
++    { "boolean", xmlXPathBooleanFunction },
++    { "ceiling", xmlXPathCeilingFunction },
++    { "count", xmlXPathCountFunction },
++    { "concat", xmlXPathConcatFunction },
++    { "contains", xmlXPathContainsFunction },
++    { "id", xmlXPathIdFunction },
++    { "false", xmlXPathFalseFunction },
++    { "floor", xmlXPathFloorFunction },
++    { "last", xmlXPathLastFunction },
++    { "lang", xmlXPathLangFunction },
++    { "local-name", xmlXPathLocalNameFunction },
++    { "not", xmlXPathNotFunction },
++    { "name", xmlXPathNameFunction },
++    { "namespace-uri", xmlXPathNamespaceURIFunction },
++    { "normalize-space", xmlXPathNormalizeFunction },
++    { "number", xmlXPathNumberFunction },
++    { "position", xmlXPathPositionFunction },
++    { "round", xmlXPathRoundFunction },
++    { "string", xmlXPathStringFunction },
++    { "string-length", xmlXPathStringLengthFunction },
++    { "starts-with", xmlXPathStartsWithFunction },
++    { "substring", xmlXPathSubstringFunction },
++    { "substring-before", xmlXPathSubstringBeforeFunction },
++    { "substring-after", xmlXPathSubstringAfterFunction },
++    { "sum", xmlXPathSumFunction },
++    { "true", xmlXPathTrueFunction },
++    { "translate", xmlXPathTranslateFunction }
++};
++
++#define NUM_STANDARD_FUNCTIONS \
++    (sizeof(xmlXPathStandardFunctions) / sizeof(xmlXPathStandardFunctions[0]))
++
++#define SF_HASH_SIZE 64
++
++static unsigned char xmlXPathSFHash[SF_HASH_SIZE];
+ 
+ double xmlXPathNAN = 0.0;
+ double xmlXPathPINF = 0.0;
+@@ -156,6 +193,18 @@ xmlXPathInit(void) {
+     xmlInitParser();
+ }
+ 
++ATTRIBUTE_NO_SANITIZE_INTEGER
++static unsigned
++xmlXPathSFComputeHash(const xmlChar *name) {
++    unsigned hashValue = 5381;
++    const xmlChar *ptr;
++
++    for (ptr = name; *ptr; ptr++)
++        hashValue = hashValue * 33 + *ptr;
++
++    return(hashValue);
++}
++
+ /**
+  * xmlInitXPathInternal:
+  *
+@@ -164,6 +213,8 @@ xmlXPathInit(void) {
+ ATTRIBUTE_NO_SANITIZE("float-divide-by-zero")
+ void
+ xmlInitXPathInternal(void) {
++    size_t i;
++
+ #if defined(NAN) && defined(INFINITY)
+     xmlXPathNAN = NAN;
+     xmlXPathPINF = INFINITY;
+@@ -175,8 +226,34 @@ xmlInitXPathInternal(void) {
+     xmlXPathPINF = 1.0 / zero;
+     xmlXPathNINF = -xmlXPathPINF;
+ #endif
++
++    /*
++     * Initialize hash table for standard functions
++     */
++
++    for (i = 0; i < SF_HASH_SIZE; i++)
++        xmlXPathSFHash[i] = UCHAR_MAX;
++
++    for (i = 0; i < NUM_STANDARD_FUNCTIONS; i++) {
++        const char *name = xmlXPathStandardFunctions[i].name;
++        int bucketIndex = xmlXPathSFComputeHash(BAD_CAST name) % SF_HASH_SIZE;
++
++        while (xmlXPathSFHash[bucketIndex] != UCHAR_MAX) {
++            bucketIndex += 1;
++            if (bucketIndex >= SF_HASH_SIZE)
++                bucketIndex = 0;
++        }
++
++        xmlXPathSFHash[bucketIndex] = i;
++    }
+ }
+ 
++/************************************************************************
++ *									*
++ *			Floating point stuff				*
++ *									*
++ ************************************************************************/
++
+ /**
+  * xmlXPathIsNaN:
+  * @val:  a double value
+@@ -3979,18 +4056,6 @@ xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt,
+  */
+ xmlXPathFunction
+ xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
+-    if (ctxt == NULL)
+-	return (NULL);
+-
+-    if (ctxt->funcLookupFunc != NULL) {
+-	xmlXPathFunction ret;
+-	xmlXPathFuncLookupFunc f;
+-
+-	f = ctxt->funcLookupFunc;
+-	ret = f(ctxt->funcLookupData, name, NULL);
+-	if (ret != NULL)
+-	    return(ret);
+-    }
+     return(xmlXPathFunctionLookupNS(ctxt, name, NULL));
+ }
+ 
+@@ -4015,6 +4080,22 @@ xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
+     if (name == NULL)
+ 	return(NULL);
+ 
++    if (ns_uri == NULL) {
++        int bucketIndex = xmlXPathSFComputeHash(name) % SF_HASH_SIZE;
++
++        while (xmlXPathSFHash[bucketIndex] != UCHAR_MAX) {
++            int funcIndex = xmlXPathSFHash[bucketIndex];
++
++            if (strcmp(xmlXPathStandardFunctions[funcIndex].name,
++                       (char *) name) == 0)
++                return(xmlXPathStandardFunctions[funcIndex].func);
++
++            bucketIndex += 1;
++            if (bucketIndex >= SF_HASH_SIZE)
++                bucketIndex = 0;
++        }
++    }
++
+     if (ctxt->funcLookupFunc != NULL) {
+ 	xmlXPathFuncLookupFunc f;
+ 
+@@ -13494,61 +13575,6 @@ xmlXPathEscapeUriFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+ void
+ xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt)
+ {
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"boolean",
+-                         xmlXPathBooleanFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"ceiling",
+-                         xmlXPathCeilingFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"count",
+-                         xmlXPathCountFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"concat",
+-                         xmlXPathConcatFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"contains",
+-                         xmlXPathContainsFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"id",
+-                         xmlXPathIdFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"false",
+-                         xmlXPathFalseFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"floor",
+-                         xmlXPathFloorFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"last",
+-                         xmlXPathLastFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"lang",
+-                         xmlXPathLangFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"local-name",
+-                         xmlXPathLocalNameFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"not",
+-                         xmlXPathNotFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"name",
+-                         xmlXPathNameFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"namespace-uri",
+-                         xmlXPathNamespaceURIFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"normalize-space",
+-                         xmlXPathNormalizeFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"number",
+-                         xmlXPathNumberFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"position",
+-                         xmlXPathPositionFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"round",
+-                         xmlXPathRoundFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string",
+-                         xmlXPathStringFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string-length",
+-                         xmlXPathStringLengthFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"starts-with",
+-                         xmlXPathStartsWithFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring",
+-                         xmlXPathSubstringFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-before",
+-                         xmlXPathSubstringBeforeFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-after",
+-                         xmlXPathSubstringAfterFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"sum",
+-                         xmlXPathSumFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"true",
+-                         xmlXPathTrueFunction);
+-    xmlXPathRegisterFunc(ctxt, (const xmlChar *)"translate",
+-                         xmlXPathTranslateFunction);
+-
+     xmlXPathRegisterFuncNS(ctxt, (const xmlChar *)"escape-uri",
+ 	 (const xmlChar *)"http://www.w3.org/2002/08/xquery-functions",
+                          xmlXPathEscapeUriFunction);
+-- 
+2.47.1
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nokogiri
 version: !ruby/object:Gem::Version
-  version: 1.17.2
+  version: 1.18.1
 platform: ruby
 authors:
 - Mike Dalessio
@@ -17,10 +17,9 @@ authors:
 - Sergio Arbeo
 - Timothy Elliott
 - Nobuyoshi Nakada
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-12 00:00:00.000000000 Z
+date: 2024-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mini_portile2
@@ -272,6 +271,7 @@ files:
 - patches/libxml2/0009-allow-wildcard-namespaces.patch
 - patches/libxml2/0010-update-config.guess-and-config.sub-for-libxml2.patch
 - patches/libxml2/0011-rip-out-libxml2-s-libc_single_threaded-support.patch
+- patches/libxml2/0019-xpath-Use-separate-static-hash-table-for-standard-fu.patch
 - patches/libxslt/0001-update-config.guess-and-config.sub-for-libxslt.patch
 - ports/archives/libxml2-2.13.5.tar.xz
 - ports/archives/libxslt-1.1.42.tar.xz
@@ -285,7 +285,6 @@ metadata:
   changelog_uri: https://nokogiri.org/CHANGELOG.html
   source_code_uri: https://github.com/sparklemotion/nokogiri
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options:
 - "--main"
 - README.md
@@ -295,15 +294,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.22
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Nokogiri (鋸) makes it easy and painless to work with XML and HTML from Ruby.
 test_files: []