nokogiri 1.12.5-x86-mingw32 → 1.13.3-x86-mingw32

data/lib/nokogiri/html4/entity_lookup.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Nokogiri
   module HTML4
     class EntityDescription < Struct.new(:value, :name, :description); end
@@ -6,7 +7,7 @@ module Nokogiri
     class EntityLookup
       ###
       # Look up entity with +name+
-      def [] name
+      def [](name)
         (val = get(name)) && val.value
       end
     end

data/lib/nokogiri/html4/sax/parser.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Nokogiri
   module HTML4
     ###
@@ -28,7 +29,7 @@ module Nokogiri
         # Parse html stored in +data+ using +encoding+
         def parse_memory(data, encoding = "UTF-8")
           raise ArgumentError unless data
-          return unless data.length > 0
+          return if data.empty?
           ctx = ParserContext.memory(data, encoding)
           yield ctx if block_given?
           ctx.parse_with(self)

data/lib/nokogiri/html4/sax/parser_context.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Nokogiri
   module HTML4
     module SAX

data/lib/nokogiri/html4/sax/push_parser.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
+
 module Nokogiri
   module HTML4
     module SAX
       class PushParser
-        
         # The Nokogiri::HTML4::SAX::Document on which the PushParser will be
         # operating
         attr_accessor :document
-        
-        def initialize(doc = HTML4::SAX::Document.new, file_name = nil, encoding = 'UTF-8')
+
+        def initialize(doc = HTML4::SAX::Document.new, file_name = nil, encoding = "UTF-8")
           @document = doc
           @encoding = encoding
           @sax_parser = HTML4::SAX::Parser.new(doc, @encoding)
@@ -16,20 +16,20 @@ module Nokogiri
           ## Create our push parser context
           initialize_native(@sax_parser, file_name, encoding)
         end
-        
+
         ###
         # Write a +chunk+ of HTML to the PushParser.  Any callback methods
         # that can be called will be called immediately.
-        def write chunk, last_chunk = false
+        def write(chunk, last_chunk = false)
           native_write(chunk, last_chunk)
         end
-        alias :<< :write
+        alias_method :<<, :write
 
         ###
         # Finish the parsing.  This method is only necessary for
         # Nokogiri::HTML4::SAX::Document#end_document to be called.
         def finish
-          write '', true
+          write("", true)
         end
       end
     end

data/lib/nokogiri/html4.rb

@@ -1,15 +1,21 @@
+# coding: utf-8
 # frozen_string_literal: true
+
 module Nokogiri
   class << self
-    ###
+    # :call-seq:
+    #   HTML4(input, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block) → Nokogiri::HTML4::Document
+    #
     # Parse HTML. Convenience method for Nokogiri::HTML4::Document.parse
     def HTML4(input, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block)
       Nokogiri::HTML4::Document.parse(input, url, encoding, options, &block)
     end
   end
 
-  # @since v1.12.0
-  # @note Before v1.12.0, {Nokogiri::HTML4} did not exist, and {Nokogiri::HTML} was the module/namespace for parsing HTML.
+  # Since v1.12.0
+  #
+  # 💡 Before v1.12.0, Nokogiri::HTML4 did not exist, and Nokogiri::HTML was the module/namespace
+  # for parsing HTML.
   module HTML4
     class << self
       ###
@@ -20,8 +26,8 @@ module Nokogiri
 
       ####
       # Parse a fragment from +string+ in to a NodeSet.
-      def fragment(string, encoding = nil)
-        HTML4::DocumentFragment.parse(string, encoding)
+      def fragment(string, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block)
+        HTML4::DocumentFragment.parse(string, encoding, options, &block)
       end
     end
 

data/lib/nokogiri/html5/document.rb

@@ -1,4 +1,6 @@
+# coding: utf-8
 # frozen_string_literal: true
+
 #
 #  Copyright 2013-2021 Sam Ruby, Stephen Checkoway
 #
@@ -19,14 +21,15 @@ require_relative "../html4/document"
 
 module Nokogiri
   module HTML5
-    # @since v1.12.0
-    # @note HTML5 functionality is not available when running JRuby.
+    # Since v1.12.0
+    #
+    # 💡 HTML5 functionality is not available when running JRuby.
     class Document < Nokogiri::HTML4::Document
       def self.parse(string_or_io, url = nil, encoding = nil, **options, &block)
-        yield options if block_given?
-	string_or_io = '' unless string_or_io
+        yield options if block
+        string_or_io = "" unless string_or_io
 
-        if string_or_io.respond_to?(:encoding) && string_or_io.encoding.name != 'ASCII-8BIT'
+        if string_or_io.respond_to?(:encoding) && string_or_io.encoding.name != "ASCII-8BIT"
           encoding ||= string_or_io.encoding.name
         end
 
@@ -34,23 +37,23 @@ module Nokogiri
           url ||= string_or_io.path
         end
         unless string_or_io.respond_to?(:read) || string_or_io.respond_to?(:to_str)
-          raise ArgumentError.new("not a string or IO object")
+          raise ArgumentError, "not a string or IO object"
         end
         do_parse(string_or_io, url, encoding, options)
       end
 
       def self.read_io(io, url = nil, encoding = nil, **options)
-        raise ArgumentError.new("io object doesn't respond to :read") unless io.respond_to?(:read)
+        raise ArgumentError, "io object doesn't respond to :read" unless io.respond_to?(:read)
         do_parse(io, url, encoding, options)
       end
 
       def self.read_memory(string, url = nil, encoding = nil, **options)
-        raise ArgumentError.new("string object doesn't respond to :to_str") unless string.respond_to?(:to_str)
+        raise ArgumentError, "string object doesn't respond to :to_str" unless string.respond_to?(:to_str)
         do_parse(string, url, encoding, options)
       end
 
       def fragment(tags = nil)
-        DocumentFragment.new(self, tags, self.root)
+        DocumentFragment.new(self, tags, root)
       end
 
       def to_xml(options = {}, &block)
@@ -59,14 +62,25 @@ module Nokogiri
         XML::Node.instance_method(:to_xml).bind(self).call(options, &block)
       end
 
+      # :call-seq:
+      #   xpath_doctype() → Nokogiri::CSS::XPathVisitor::DoctypeConfig
+      #
+      # [Returns] The document type which determines CSS-to-XPath translation.
+      #
+      # See XPathVisitor for more information.
+      def xpath_doctype
+        Nokogiri::CSS::XPathVisitor::DoctypeConfig::HTML5
+      end
+
       private
+
       def self.do_parse(string_or_io, url, encoding, options)
         string = HTML5.read_and_encode(string_or_io, encoding)
         max_attributes = options[:max_attributes] || Nokogiri::Gumbo::DEFAULT_MAX_ATTRIBUTES
         max_errors = options[:max_errors] || options[:max_parse_errors] || Nokogiri::Gumbo::DEFAULT_MAX_ERRORS
         max_depth = options[:max_tree_depth] || Nokogiri::Gumbo::DEFAULT_MAX_TREE_DEPTH
         doc = Nokogiri::Gumbo.parse(string, url, max_attributes, max_errors, max_depth)
-        doc.encoding = 'UTF-8'
+        doc.encoding = "UTF-8"
         doc
       end
     end

data/lib/nokogiri/html5/document_fragment.rb

@@ -1,4 +1,6 @@
+# coding: utf-8
 # frozen_string_literal: true
+
 #
 #  Copyright 2013-2021 Sam Ruby, Stephen Checkoway
 #
@@ -19,8 +21,9 @@ require_relative "../html4/document_fragment"
 
 module Nokogiri
   module HTML5
-    # @since v1.12.0
-    # @note HTML5 functionality is not available when running JRuby.
+    # Since v1.12.0
+    #
+    # 💡 HTML5 functionality is not available when running JRuby.
     class DocumentFragment < Nokogiri::HTML4::DocumentFragment
       attr_accessor :document
       attr_accessor :errors

data/lib/nokogiri/html5/node.rb

@@ -1,4 +1,6 @@
+# coding: utf-8
 # frozen_string_literal: true
+
 #
 #  Copyright 2013-2021 Sam Ruby, Stephen Checkoway
 #
@@ -19,12 +21,13 @@ require_relative "../xml/node"
 
 module Nokogiri
   module HTML5
-    # @since v1.12.0
-    # @note HTML5 functionality is not available when running JRuby.
+    # Since v1.12.0
+    #
+    # 💡 HTML5 functionality is not available when running JRuby.
     module Node
       def inner_html(options = {})
         return super(options) unless document.is_a?(HTML5::Document)
-        result = options[:preserve_newline] && HTML5.prepend_newline?(self) ? String.new("\n") : String.new
+        result = options[:preserve_newline] && HTML5.prepend_newline?(self) ? +"\n" : +""
         result << children.map { |child| child.to_html(options) }.join
         result
       end

data/lib/nokogiri/html5.rb

@@ -1,5 +1,6 @@
 # coding: utf-8
 # frozen_string_literal: true
+
 #
 #  Copyright 2013-2021 Sam Ruby, Stephen Checkoway
 #
@@ -16,13 +17,15 @@
 #  limitations under the License.
 #
 
-require_relative 'html5/document'
-require_relative 'html5/document_fragment'
-require_relative 'html5/node'
+require_relative "html5/document"
+require_relative "html5/document_fragment"
+require_relative "html5/node"
 
 module Nokogiri
-  # @since v1.12.0
-  # @note HTML5 functionality is not available when running JRuby.
+  # Since v1.12.0
+  #
+  # ⚠ HTML5 functionality is not available when running JRuby.
+  #
   # Parse an HTML5 document. Convenience method for {Nokogiri::HTML5::Document.parse}
   def self.HTML5(input, url = nil, encoding = nil, **options, &block)
     Nokogiri::HTML5::Document.parse(input, url, encoding, **options, &block)
@@ -30,6 +33,8 @@ module Nokogiri
 
   # == Usage
   #
+  # ⚠ HTML5 functionality is not available when running JRuby.
+  #
   # Parse an HTML5 document:
   #
   #   doc = Nokogiri.HTML5(string)
@@ -220,16 +225,15 @@ module Nokogiri
   # * Instead of returning +unknown+ as the element name for unknown tags, the
   #   original tag name is returned verbatim.
   #
-  # @since v1.12.0
-  # @note HTML5 functionality is not available when running JRuby.
+  # Since v1.12.0
   module HTML5
     # HTML uses the XHTML namespace.
-    HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml'.freeze
-    MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML'.freeze
-    SVG_NAMESPACE = 'http://www.w3.org/2000/svg'.freeze
-    XLINK_NAMESPACE = 'http://www.w3.org/1999/xlink'.freeze
-    XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace'.freeze
-    XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/'.freeze
+    HTML_NAMESPACE = "http://www.w3.org/1999/xhtml"
+    MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML"
+    SVG_NAMESPACE = "http://www.w3.org/2000/svg"
+    XLINK_NAMESPACE = "http://www.w3.org/1999/xlink"
+    XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace"
+    XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/"
 
     # Parse an HTML 5 document. Convenience method for {Nokogiri::HTML5::Document.parse}
     def self.parse(string, url = nil, encoding = nil, **options, &block)
@@ -249,34 +253,35 @@ module Nokogiri
     # special option is considered a header.  Special options include:
     #  * :follow_limit => number of redirects which are followed
     #  * :basic_auth => [username, password]
-    def self.get(uri, options={})
+    def self.get(uri, options = {})
+      # TODO: deprecate
       warn("Nokogiri::HTML5.get is deprecated and will be removed in a future version of Nokogiri.",
-           uplevel: 1, category: :deprecated)
+        uplevel: 1, category: :deprecated)
       get_impl(uri, options)
     end
 
     private
 
-    def self.get_impl(uri, options={})
+    def self.get_impl(uri, options = {})
       headers = options.clone
-      headers = {:follow_limit => headers} if Numeric === headers # deprecated
-      limit=headers[:follow_limit] ? headers.delete(:follow_limit).to_i : 10
+      headers = { follow_limit: headers } if Numeric === headers # deprecated
+      limit = headers[:follow_limit] ? headers.delete(:follow_limit).to_i : 10
 
-      require 'net/http'
+      require "net/http"
       uri = URI(uri) unless URI === uri
 
       http = Net::HTTP.new(uri.host, uri.port)
 
       # TLS / SSL support
-      http.use_ssl = true if uri.scheme == 'https'
+      http.use_ssl = true if uri.scheme == "https"
 
       # Pass through Net::HTTP override values, which currently include:
       #   :ca_file, :ca_path, :cert, :cert_store, :ciphers,
       #   :close_on_empty_response, :continue_timeout, :key, :open_timeout,
       #   :read_timeout, :ssl_timeout, :ssl_version, :use_ssl,
       #   :verify_callback, :verify_depth, :verify_mode
-      options.each do |key, value|
-        http.send "#{key}=", headers.delete(key) if http.respond_to? "#{key}="
+      options.each do |key, _value|
+        http.send("#{key}=", headers.delete(key)) if http.respond_to?("#{key}=")
       end
 
       request = Net::HTTP::Get.new(uri.request_uri)
@@ -284,23 +289,23 @@ module Nokogiri
       # basic authentication
       auth = headers.delete(:basic_auth)
       auth ||= [uri.user, uri.password] if uri.user && uri.password
-      request.basic_auth auth.first, auth.last if auth
+      request.basic_auth(auth.first, auth.last) if auth
 
       # remaining options are treated as headers
-      headers.each {|key, value| request[key.to_s] = value.to_s}
+      headers.each { |key, value| request[key.to_s] = value.to_s }
 
       response = http.request(request)
 
       case response
       when Net::HTTPSuccess
-        doc = parse(reencode(response.body, response['content-type']), options)
-        doc.instance_variable_set('@response', response)
+        doc = parse(reencode(response.body, response["content-type"]), options)
+        doc.instance_variable_set("@response", response)
         doc.class.send(:attr_reader, :response)
         doc
       when Net::HTTPRedirection
         response.value if limit <= 1
-        location = URI.join(uri, response['location'])
-        get_impl(location, options.merge(:follow_limit => limit-1))
+        location = URI.join(uri, response["location"])
+        get_impl(location, options.merge(follow_limit: limit - 1))
       else
         response.value
       end
@@ -309,10 +314,10 @@ module Nokogiri
     def self.read_and_encode(string, encoding)
       # Read the string with the given encoding.
       if string.respond_to?(:read)
-        if encoding.nil?
-          string = string.read
+        string = if encoding.nil?
+          string.read
         else
-          string = string.read(encoding: encoding)
+          string.read(encoding: encoding)
         end
       else
         # Otherwise the string has the given encoding.
@@ -342,7 +347,7 @@ module Nokogiri
     # http://bugs.ruby-lang.org/issues/2567
     # http://www.w3.org/TR/html5/syntax.html#determining-the-character-encoding
     #
-    def self.reencode(body, content_type=nil)
+    def self.reencode(body, content_type = nil)
       if body.encoding == Encoding::ASCII_8BIT
         encoding = nil
 
@@ -362,8 +367,8 @@ module Nokogiri
         end
 
         # look for a charset in a meta tag in the first 1024 bytes
-        if not encoding
-          data = body[0..1023].gsub(/<!--.*?(-->|\Z)/m, '')
+        unless encoding
+          data = body[0..1023].gsub(/<!--.*?(-->|\Z)/m, "")
           data.scan(/<meta.*?>/m).each do |meta|
             encoding ||= meta[/charset=["']?([^>]*?)($|["'\s>])/im, 1]
           end
@@ -390,57 +395,56 @@ module Nokogiri
         ns = current_node.namespace
         ns_uri = ns.nil? ? nil : ns.href
         # XXX(sfc): attach namespaces to all nodes, even html?
-        if ns_uri.nil? || ns_uri == HTML_NAMESPACE || ns_uri == MATHML_NAMESPACE || ns_uri == SVG_NAMESPACE
-          tagname = current_node.name
+        tagname = if ns_uri.nil? || ns_uri == HTML_NAMESPACE || ns_uri == MATHML_NAMESPACE || ns_uri == SVG_NAMESPACE
+          current_node.name
         else
-          tagname = "#{ns.prefix}:#{current_node.name}"
+          "#{ns.prefix}:#{current_node.name}"
         end
-        io << '<' << tagname
+        io << "<" << tagname
         current_node.attribute_nodes.each do |attr|
           attr_ns = attr.namespace
           if attr_ns.nil?
             attr_name = attr.name
           else
             ns_uri = attr_ns.href
-            if ns_uri == XML_NAMESPACE
-              attr_name = 'xml:' + attr.name.sub(/^[^:]*:/, '')
-            elsif ns_uri == XMLNS_NAMESPACE && attr.name.sub(/^[^:]*:/, '') == 'xmlns'
-              attr_name = 'xmlns'
+            attr_name = if ns_uri == XML_NAMESPACE
+              "xml:" + attr.name.sub(/^[^:]*:/, "")
+            elsif ns_uri == XMLNS_NAMESPACE && attr.name.sub(/^[^:]*:/, "") == "xmlns"
+              "xmlns"
             elsif ns_uri == XMLNS_NAMESPACE
-              attr_name = 'xmlns:' + attr.name.sub(/^[^:]*:/, '')
+              "xmlns:" + attr.name.sub(/^[^:]*:/, "")
             elsif ns_uri == XLINK_NAMESPACE
-              attr_name = 'xlink:' + attr.name.sub(/^[^:]*:/, '')
+              "xlink:" + attr.name.sub(/^[^:]*:/, "")
             else
-              attr_name = "#{attr_ns.prefix}:#{attr.name}"
+              "#{attr_ns.prefix}:#{attr.name}"
             end
           end
-          io << ' ' << attr_name << '="' << escape_text(attr.content, encoding, true) << '"'
+          io << " " << attr_name << '="' << escape_text(attr.content, encoding, true) << '"'
         end
-        io << '>'
-        if !%w[area base basefont bgsound br col embed frame hr img input keygen
-               link meta param source track wbr].include?(current_node.name)
+        io << ">"
+        unless ["area", "base", "basefont", "bgsound", "br", "col", "embed", "frame", "hr", "img", "input", "keygen", "link", "meta", "param", "source", "track", "wbr"].include?(current_node.name)
           io << "\n" if options[:preserve_newline] && prepend_newline?(current_node)
           current_node.children.each do |child|
             # XXX(sfc): Templates handled specially?
             serialize_node_internal(child, io, encoding, options)
           end
-          io << '</' << tagname << '>'
+          io << "</" << tagname << ">"
         end
       when XML::Node::TEXT_NODE
         parent = current_node.parent
-        if parent.element? && %w[style script xmp iframe noembed noframes plaintext noscript].include?(parent.name)
-          io << current_node.content
+        io << if parent.element? && ["style", "script", "xmp", "iframe", "noembed", "noframes", "plaintext", "noscript"].include?(parent.name)
+          current_node.content
         else
-          io << escape_text(current_node.content, encoding, false)
+          escape_text(current_node.content, encoding, false)
         end
       when XML::Node::CDATA_SECTION_NODE
-        io << '<![CDATA[' << current_node.content << ']]>'
+        io << "<![CDATA[" << current_node.content << "]]>"
       when XML::Node::COMMENT_NODE
-        io << '<!--' << current_node.content << '-->'
+        io << "<!--" << current_node.content << "-->"
       when XML::Node::PI_NODE
-        io << '<?' << current_node.content << '>'
+        io << "<?" << current_node.content << ">"
       when XML::Node::DOCUMENT_TYPE_NODE, XML::Node::DTD_NODE
-          io << '<!DOCTYPE ' << current_node.name << '>'
+        io << "<!DOCTYPE " << current_node.name << ">"
       when XML::Node::HTML_DOCUMENT_NODE, XML::Node::DOCUMENT_FRAG_NODE
         current_node.children.each do |child|
           serialize_node_internal(child, io, encoding, options)
@@ -451,23 +455,23 @@ module Nokogiri
     end
 
     def self.escape_text(text, encoding, attribute_mode)
-      if attribute_mode
-        text = text.gsub(/[&\u00a0"]/,
-                           '&' => '&amp;', "\u00a0" => '&nbsp;', '"' => '&quot;')
+      text = if attribute_mode
+        text.gsub(/[&\u00a0"]/,
+          "&" => "&amp;", "\u00a0" => "&nbsp;", '"' => "&quot;")
       else
-        text = text.gsub(/[&\u00a0<>]/,
-                           '&' => '&amp;', "\u00a0" => '&nbsp;',  '<' => '&lt;', '>' => '&gt;')
+        text.gsub(/[&\u00a0<>]/,
+          "&" => "&amp;", "\u00a0" => "&nbsp;", "<" => "&lt;", ">" => "&gt;")
       end
       # Not part of the standard
       text.encode(encoding, fallback: lambda { |c| "&\#x#{c.ord.to_s(16)};" })
     end
 
     def self.prepend_newline?(node)
-      return false unless %w[pre textarea listing].include?(node.name) && !node.children.empty?
+      return false unless ["pre", "textarea", "listing"].include?(node.name) && !node.children.empty?
       first_child = node.children[0]
       first_child.text? && first_child.content.start_with?("\n")
     end
   end
 end
 
-require_relative 'gumbo'
+require_relative "gumbo"

data/lib/nokogiri/jruby/dependencies.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # The line below caused a problem on non-GAE rack environment.
 # unless defined?(JRuby::Rack::VERSION) || defined?(AppEngine::ApiProxy)
 #
@@ -8,13 +9,13 @@
 # should skip loading xml jars. This is because those are in WEB-INF/lib and
 # already set in the classpath.
 unless $LOAD_PATH.to_s.include?("appengine-rack")
-  require 'stringio'
-  require 'isorelax.jar'
-  require 'jing.jar'
-  require 'nekohtml.jar'
-  require 'nekodtd.jar'
-  require 'xercesImpl.jar'
-  require 'serializer.jar'
-  require 'xalan.jar'
-  require 'xml-apis.jar'
+  require "stringio"
+  require "isorelax.jar"
+  require "jing.jar"
+  require "nekohtml.jar"
+  require "nekodtd.jar"
+  require "xercesImpl.jar"
+  require "serializer.jar"
+  require "xalan.jar"
+  require "xml-apis.jar"
 end

data/lib/nokogiri/syntax_error.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Nokogiri
   class SyntaxError < ::StandardError
   end

data/lib/nokogiri/version/constant.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
+
 module Nokogiri
   # The version of Nokogiri you are using
-  VERSION = "1.12.5"
+  VERSION = "1.13.3"
 end

data/lib/nokogiri/version/info.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "singleton"
 require "shellwords"
 
@@ -102,8 +103,8 @@ module Nokogiri
             ldflags = []
 
             if libxml2_using_packaged?
-              cppflags << "-I#{File.join(header_directory, 'include').shellescape}"
-              cppflags << "-I#{File.join(header_directory, 'include/libxml2').shellescape}"
+              cppflags << "-I#{File.join(header_directory, "include").shellescape}"
+              cppflags << "-I#{File.join(header_directory, "include/libxml2").shellescape}"
 
               if windows?
                 # on windows, nokogumbo needs to link against nokogiri.so to resolve symbols. see #2167
@@ -176,13 +177,9 @@ module Nokogiri
     end
 
     def to_markdown
-      begin
-        require "psych"
-      rescue LoadError
-      end
       require "yaml"
       "# Nokogiri (#{Nokogiri::VERSION})\n" +
-      YAML.dump(to_hash).each_line.map { |line| "    #{line}" }.join
+        YAML.dump(to_hash).each_line.map { |line| "    #{line}" }.join
     end
 
     instance.warnings.each do |warning|
@@ -190,26 +187,35 @@ module Nokogiri
     end
   end
 
-  def self.uses_libxml?(requirement = nil) # :nodoc:
+  # :nodoc:
+  def self.uses_libxml?(requirement = nil)
     return false unless VersionInfo.instance.libxml2?
     return true unless requirement
     Gem::Requirement.new(requirement).satisfied_by?(VersionInfo.instance.loaded_libxml_version)
   end
 
+  # :nodoc:
   def self.uses_gumbo?
     uses_libxml? # TODO: replace with Gumbo functionality
   end
 
-  def self.jruby? # :nodoc:
+  # :nodoc:
+  def self.jruby?
     VersionInfo.instance.jruby?
   end
 
-  # Ensure constants used in this file are loaded - see #1896
-  if Nokogiri.jruby?
-    require_relative "../jruby/dependencies"
+  # :nodoc:
+  def self.libxml2_patches
+    if VersionInfo.instance.libxml2_using_packaged?
+      Nokogiri::VERSION_INFO["libxml"]["patches"]
+    else
+      []
+    end
   end
+
+  require_relative "../jruby/dependencies" if Nokogiri.jruby?
   require_relative "../extension"
 
-  # More complete version information about libxml
+  # Detailed version info about Nokogiri and the installed extension dependencies.
   VERSION_INFO = VersionInfo.instance.to_hash
 end

data/lib/nokogiri/version.rb

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
+
 require_relative "version/constant"
 require_relative "version/info"