nokogiri 1.13.8 → 1.14.5

data/lib/nokogiri/html5/document.rb

@@ -21,48 +21,137 @@ require_relative "../html4/document"
 
 module Nokogiri
   module HTML5
+    # Enum for the HTML5 parser quirks mode values. Values returned by HTML5::Document#quirks_mode
+    #
+    # See https://dom.spec.whatwg.org/#concept-document-quirks for more information on HTML5 quirks
+    # mode.
+    #
+    # Since v1.14.0
+    module QuirksMode
+      NO_QUIRKS = 0 # The document was parsed in "no-quirks" mode
+      QUIRKS = 1 # The document was parsed in "quirks" mode
+      LIMITED_QUIRKS = 2 # The document was parsed in "limited-quirks" mode
+    end
+
     # 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
-        string_or_io = "" unless string_or_io
+      # Get the url name for this document, as passed into Document.parse, Document.read_io, or
+      # Document.read_memory
+      attr_reader :url
 
-        if string_or_io.respond_to?(:encoding) && string_or_io.encoding.name != "ASCII-8BIT"
-          encoding ||= string_or_io.encoding.name
-        end
+      # Get the parser's quirks mode value. See HTML5::QuirksMode.
+      #
+      # This method returns `nil` if the parser was not invoked (e.g., `Nokogiri::HTML5::Document.new`).
+      #
+      # Since v1.14.0
+      attr_reader :quirks_mode
 
-        if string_or_io.respond_to?(:read) && string_or_io.respond_to?(:path)
-          url ||= string_or_io.path
+      class << self
+        # :call-seq:
+        #   parse(input)
+        #   parse(input, url=nil, encoding=nil, **options)
+        #   parse(input, url=nil, encoding=nil) { |options| ... }
+        #
+        # Parse HTML5 input.
+        #
+        # [Parameters]
+        # - +input+ may be a String, or any object that responds to _read_ and _close_ such as an
+        #   IO, or StringIO.
+        #
+        # - +url+ (optional) is a String indicating the canonical URI where this document is located.
+        #
+        # - +encoding+ (optional) is the encoding that should be used when processing
+        #   the document.
+        #
+        # - +options+ (optional) is a configuration Hash (or keyword arguments) to set options
+        #   during parsing. The three currently supported options are +:max_errors+,
+        #   +:max_tree_depth+ and +:max_attributes+, described at Nokogiri::HTML5.
+        #
+        #   ⚠ Note that these options are different than those made available by
+        #   Nokogiri::XML::Document and Nokogiri::HTML4::Document.
+        #
+        # - +block+ (optional) is passed a configuration Hash on which parse options may be set. See
+        #   Nokogiri::HTML5 for more information and usage.
+        #
+        # [Returns] Nokogiri::HTML5::Document
+        #
+        def parse(string_or_io, url = nil, encoding = nil, **options, &block)
+          yield options if block
+          string_or_io = "" unless string_or_io
+
+          if string_or_io.respond_to?(:encoding) && string_or_io.encoding != Encoding::ASCII_8BIT
+            encoding ||= string_or_io.encoding.name
+          end
+
+          if string_or_io.respond_to?(:read) && string_or_io.respond_to?(:path)
+            url ||= string_or_io.path
+          end
+          unless string_or_io.respond_to?(:read) || string_or_io.respond_to?(:to_str)
+            raise ArgumentError, "not a string or IO object"
+          end
+
+          do_parse(string_or_io, url, encoding, options)
         end
-        unless string_or_io.respond_to?(:read) || string_or_io.respond_to?(:to_str)
-          raise ArgumentError, "not a string or IO object"
+
+        # Create a new document from an IO object.
+        #
+        # 💡 Most users should prefer Document.parse to this method.
+        def read_io(io, url = nil, encoding = nil, **options)
+          raise ArgumentError, "io object doesn't respond to :read" unless io.respond_to?(:read)
+
+          do_parse(io, url, encoding, options)
         end
 
-        do_parse(string_or_io, url, encoding, options)
-      end
+        # Create a new document from a String.
+        #
+        # 💡 Most users should prefer Document.parse to this method.
+        def read_memory(string, url = nil, encoding = nil, **options)
+          raise ArgumentError, "string object doesn't respond to :to_str" unless string.respond_to?(:to_str)
 
-      def self.read_io(io, url = nil, encoding = nil, **options)
-        raise ArgumentError, "io object doesn't respond to :read" unless io.respond_to?(:read)
+          do_parse(string, url, encoding, options)
+        end
 
-        do_parse(io, url, encoding, options)
-      end
+        private
 
-      def self.read_memory(string, url = nil, encoding = nil, **options)
-        raise ArgumentError, "string object doesn't respond to :to_str" unless string.respond_to?(:to_str)
+        def 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, self)
+          doc.encoding = "UTF-8"
+          doc
+        end
+      end
 
-        do_parse(string, url, encoding, options)
+      def initialize(*args) # :nodoc:
+        super
+        @url = nil
+        @quirks_mode = nil
       end
 
-      def fragment(tags = nil)
-        DocumentFragment.new(self, tags, root)
+      # :call-seq:
+      #   fragment() → Nokogiri::HTML5::DocumentFragment
+      #   fragment(markup) → Nokogiri::HTML5::DocumentFragment
+      #
+      # Parse a HTML5 document fragment from +markup+, returning a Nokogiri::HTML5::DocumentFragment.
+      #
+      # [Properties]
+      # - +markup+ (String) The HTML5 markup fragment to be parsed
+      #
+      # [Returns]
+      #   Nokogiri::HTML5::DocumentFragment. This object's children will be empty if `markup` is not passed, is empty, or is `nil`.
+      #
+      def fragment(markup = nil)
+        DocumentFragment.new(self, markup)
       end
 
-      def to_xml(options = {}, &block)
+      def to_xml(options = {}, &block) # :nodoc:
         # Bypass XML::Document#to_xml which doesn't add
         # XML::Node::SaveOptions::AS_XML like XML::Node#to_xml does.
-        XML::Node.instance_method(:to_xml).bind(self).call(options, &block)
+        XML::Node.instance_method(:to_xml).bind_call(self, options, &block)
       end
 
       # :call-seq:
@@ -70,22 +159,10 @@ module Nokogiri
       #
       # [Returns] The document type which determines CSS-to-XPath translation.
       #
-      # See XPathVisitor for more information.
+      # See CSS::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
-      end
     end
   end
 end

data/lib/nokogiri/html5/document_fragment.rb

@@ -28,6 +28,13 @@ module Nokogiri
       attr_accessor :document
       attr_accessor :errors
 
+      # Get the parser's quirks mode value. See HTML5::QuirksMode.
+      #
+      # This method returns `nil` if the parser was not invoked (e.g., `Nokogiri::HTML5::DocumentFragment.new(doc)`).
+      #
+      # Since v1.14.0
+      attr_reader :quirks_mode
+
       # Create a document fragment.
       def initialize(doc, tags = nil, ctx = nil, options = {})
         self.document = doc
@@ -41,10 +48,10 @@ module Nokogiri
         Nokogiri::Gumbo.fragment(self, tags, ctx, max_attributes, max_errors, max_depth)
       end
 
-      def serialize(options = {}, &block)
+      def serialize(options = {}, &block) # :nodoc:
         # Bypass XML::Document.serialize which doesn't support options even
         # though XML::Node.serialize does!
-        XML::Node.instance_method(:serialize).bind(self).call(options, &block)
+        XML::Node.instance_method(:serialize).bind_call(self, options, &block)
       end
 
       # Parse a document fragment from +tags+, returning a Nodeset.

data/lib/nokogiri/html5/node.rb

@@ -28,7 +28,7 @@ module Nokogiri
       def inner_html(options = {})
         return super(options) unless document.is_a?(HTML5::Document)
 
-        result = options[:preserve_newline] && HTML5.prepend_newline?(self) ? +"\n" : +""
+        result = options[:preserve_newline] && prepend_newline? ? +"\n" : +""
         result << children.map { |child| child.to_html(options) }.join
         result
       end
@@ -56,11 +56,9 @@ module Nokogiri
           native_write_to(io, encoding, indent_string, config_options)
         else
           # Serialize including the current node.
+          html = html_standard_serialize(options[:preserve_newline] || false)
           encoding ||= document.encoding || Encoding::UTF_8
-          internal_ops = {
-            preserve_newline: options[:preserve_newline] || false,
-          }
-          HTML5.serialize_node_internal(self, io, encoding, internal_ops)
+          io << html.encode(encoding, fallback: lambda { |c| "&#x#{c.ord.to_s(16)};" })
         end
       end
 

data/lib/nokogiri/html5.rb

@@ -227,250 +227,161 @@ module Nokogiri
   #
   # Since v1.12.0
   module HTML5
-    # HTML uses the XHTML namespace.
-    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/"
+    class << self
+      # Parse an HTML 5 document. Convenience method for {Nokogiri::HTML5::Document.parse}
+      def parse(string, url = nil, encoding = nil, **options, &block)
+        Document.parse(string, url, encoding, **options, &block)
+      end
 
-    # Parse an HTML 5 document. Convenience method for {Nokogiri::HTML5::Document.parse}
-    def self.parse(string, url = nil, encoding = nil, **options, &block)
-      Document.parse(string, url, encoding, **options, &block)
-    end
+      # Parse a fragment from +string+. Convenience method for
+      # {Nokogiri::HTML5::DocumentFragment.parse}.
+      def fragment(string, encoding = nil, **options)
+        DocumentFragment.parse(string, encoding, options)
+      end
 
-    # Parse a fragment from +string+. Convenience method for
-    # {Nokogiri::HTML5::DocumentFragment.parse}.
-    def self.fragment(string, encoding = nil, **options)
-      DocumentFragment.parse(string, encoding, options)
-    end
+      # Fetch and parse a HTML document from the web, following redirects,
+      # handling https, and determining the character encoding using HTML5
+      # rules.  +uri+ may be a +String+ or a +URI+.  +options+ contains
+      # http headers and special options.  Everything which is not a
+      # special option is considered a header.  Special options include:
+      #  * :follow_limit => number of redirects which are followed
+      #  * :basic_auth => [username, password]
+      def 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)
+        get_impl(uri, options)
+      end
 
-    # Fetch and parse a HTML document from the web, following redirects,
-    # handling https, and determining the character encoding using HTML5
-    # rules.  +uri+ may be a +String+ or a +URI+.  +options+ contains
-    # http headers and special options.  Everything which is not a
-    # 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 = {})
-      # TODO: deprecate
-      warn("Nokogiri::HTML5.get is deprecated and will be removed in a future version of Nokogiri.",
-        uplevel: 1, category: :deprecated)
-      get_impl(uri, options)
-    end
+      # :nodoc:
+      def read_and_encode(string, encoding)
+        # Read the string with the given encoding.
+        if string.respond_to?(:read)
+          string = if encoding.nil?
+            string.read
+          else
+            string.read(encoding: encoding)
+          end
+        else
+          # Otherwise the string has the given encoding.
+          string = string.to_s
+          if encoding
+            string = string.dup
+            string.force_encoding(encoding)
+          end
+        end
 
-    private
+        # convert to UTF-8
+        if string.encoding != Encoding::UTF_8
+          string = reencode(string)
+        end
+        string
+      end
 
-    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
+      private
 
-      require "net/http"
-      uri = URI(uri) unless URI === uri
+      def 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
 
-      http = Net::HTTP.new(uri.host, uri.port)
+        require "net/http"
+        uri = URI(uri) unless URI === uri
 
-      # TLS / SSL support
-      http.use_ssl = true if uri.scheme == "https"
+        http = Net::HTTP.new(uri.host, uri.port)
 
-      # 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}=")
-      end
+        # TLS / SSL support
+        http.use_ssl = true if uri.scheme == "https"
 
-      request = Net::HTTP::Get.new(uri.request_uri)
+        # 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}=")
+        end
 
-      # 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 = Net::HTTP::Get.new(uri.request_uri)
 
-      # remaining options are treated as headers
-      headers.each { |key, value| request[key.to_s] = value.to_s }
+        # 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
 
-      response = http.request(request)
+        # remaining options are treated as headers
+        headers.each { |key, value| request[key.to_s] = value.to_s }
 
-      case response
-      when Net::HTTPSuccess
-        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))
-      else
-        response.value
-      end
-    end
+        response = http.request(request)
 
-    def self.read_and_encode(string, encoding)
-      # Read the string with the given encoding.
-      if string.respond_to?(:read)
-        string = if encoding.nil?
-          string.read
+        case response
+        when Net::HTTPSuccess
+          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))
         else
-          string.read(encoding: encoding)
-        end
-      else
-        # Otherwise the string has the given encoding.
-        string = string.to_s
-        if encoding
-          string = string.dup
-          string.force_encoding(encoding)
+          response.value
         end
       end
 
-      # convert to UTF-8
-      if string.encoding != Encoding::UTF_8
-        string = reencode(string)
-      end
-      string
-    end
-
-    # Charset sniffing is a complex and controversial topic that understandably isn't done _by
-    # default_ by the Ruby Net::HTTP library.  This being said, it is a very real problem for
-    # consumers of HTML as the default for HTML is iso-8859-1, most "good" producers use utf-8, and
-    # the Gumbo parser *only* supports utf-8.
-    #
-    # Accordingly, Nokogiri::HTML4::Document.parse provides limited encoding detection.  Following
-    # this lead, Nokogiri::HTML5 attempts to do likewise, while attempting to more closely follow
-    # the HTML5 standard.
-    #
-    # 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)
-      if body.encoding == Encoding::ASCII_8BIT
-        encoding = nil
-
-        # look for a Byte Order Mark (BOM)
-        initial_bytes = body[0..2].bytes
-        if initial_bytes[0..2] == [0xEF, 0xBB, 0xBF]
-          encoding = Encoding::UTF_8
-        elsif initial_bytes[0..1] == [0xFE, 0xFF]
-          encoding = Encoding::UTF_16BE
-        elsif initial_bytes[0..1] == [0xFF, 0xFE]
-          encoding = Encoding::UTF_16LE
-        end
-
-        # look for a charset in a content-encoding header
-        if content_type
-          encoding ||= content_type[/charset=["']?(.*?)($|["';\s])/i, 1]
-        end
-
-        # look for a charset in a meta tag in the first 1024 bytes
-        unless encoding
-          data = body[0..1023].gsub(/<!--.*?(-->|\Z)/m, "")
-          data.scan(/<meta.*?>/m).each do |meta|
-            encoding ||= meta[/charset=["']?([^>]*?)($|["'\s>])/im, 1]
+      # Charset sniffing is a complex and controversial topic that understandably isn't done _by
+      # default_ by the Ruby Net::HTTP library.  This being said, it is a very real problem for
+      # consumers of HTML as the default for HTML is iso-8859-1, most "good" producers use utf-8, and
+      # the Gumbo parser *only* supports utf-8.
+      #
+      # Accordingly, Nokogiri::HTML4::Document.parse provides limited encoding detection.  Following
+      # this lead, Nokogiri::HTML5 attempts to do likewise, while attempting to more closely follow
+      # the HTML5 standard.
+      #
+      # http://bugs.ruby-lang.org/issues/2567
+      # http://www.w3.org/TR/html5/syntax.html#determining-the-character-encoding
+      #
+      def reencode(body, content_type = nil)
+        if body.encoding == Encoding::ASCII_8BIT
+          encoding = nil
+
+          # look for a Byte Order Mark (BOM)
+          initial_bytes = body[0..2].bytes
+          if initial_bytes[0..2] == [0xEF, 0xBB, 0xBF]
+            encoding = Encoding::UTF_8
+          elsif initial_bytes[0..1] == [0xFE, 0xFF]
+            encoding = Encoding::UTF_16BE
+          elsif initial_bytes[0..1] == [0xFF, 0xFE]
+            encoding = Encoding::UTF_16LE
           end
-        end
-
-        # if all else fails, default to the official default encoding for HTML
-        encoding ||= Encoding::ISO_8859_1
-
-        # change the encoding to match the detected or inferred encoding
-        body = body.dup
-        begin
-          body.force_encoding(encoding)
-        rescue ArgumentError
-          body.force_encoding(Encoding::ISO_8859_1)
-        end
-      end
 
-      body.encode(Encoding::UTF_8)
-    end
+          # look for a charset in a content-encoding header
+          if content_type
+            encoding ||= content_type[/charset=["']?(.*?)($|["';\s])/i, 1]
+          end
 
-    def self.serialize_node_internal(current_node, io, encoding, options)
-      case current_node.type
-      when XML::Node::ELEMENT_NODE
-        ns = current_node.namespace
-        ns_uri = ns.nil? ? nil : ns.href
-        # XXX(sfc): attach namespaces to all nodes, even html?
-        tagname = if ns_uri.nil? || ns_uri == HTML_NAMESPACE || ns_uri == MATHML_NAMESPACE || ns_uri == SVG_NAMESPACE
-          current_node.name
-        else
-          "#{ns.prefix}:#{current_node.name}"
-        end
-        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
-            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
-              "xmlns:" + attr.name.sub(/^[^:]*:/, "")
-            elsif ns_uri == XLINK_NAMESPACE
-              "xlink:" + attr.name.sub(/^[^:]*:/, "")
-            else
-              "#{attr_ns.prefix}:#{attr.name}"
+          # look for a charset in a meta tag in the first 1024 bytes
+          unless encoding
+            data = body[0..1023].gsub(/<!--.*?(-->|\Z)/m, "")
+            data.scan(/<meta.*?>/im).each do |meta|
+              encoding ||= meta[/charset=["']?([^>]*?)($|["'\s>])/im, 1]
             end
           end
-          io << " " << attr_name << '="' << escape_text(attr.content, encoding, true) << '"'
-        end
-        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)
+
+          # if all else fails, default to the official default encoding for HTML
+          encoding ||= Encoding::ISO_8859_1
+
+          # change the encoding to match the detected or inferred encoding
+          body = body.dup
+          begin
+            body.force_encoding(encoding)
+          rescue ArgumentError
+            body.force_encoding(Encoding::ISO_8859_1)
           end
-          io << "</" << tagname << ">"
-        end
-      when XML::Node::TEXT_NODE
-        parent = current_node.parent
-        io << if parent.element? && ["style", "script", "xmp", "iframe", "noembed", "noframes", "plaintext", "noscript"].include?(parent.name)
-          current_node.content
-        else
-          escape_text(current_node.content, encoding, false)
-        end
-      when XML::Node::CDATA_SECTION_NODE
-        io << "<![CDATA[" << current_node.content << "]]>"
-      when XML::Node::COMMENT_NODE
-        io << "<!--" << current_node.content << "-->"
-      when XML::Node::PI_NODE
-        io << "<?" << current_node.content << ">"
-      when XML::Node::DOCUMENT_TYPE_NODE, XML::Node::DTD_NODE
-        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)
         end
-      else
-        raise "Unexpected node '#{current_node.name}' of type #{current_node.type}"
-      end
-    end
 
-    def self.escape_text(text, encoding, attribute_mode)
-      text = if attribute_mode
-        text.gsub(/[&\u00a0"]/,
-          "&" => "&amp;", "\u00a0" => "&nbsp;", '"' => "&quot;")
-      else
-        text.gsub(/[&\u00a0<>]/,
-          "&" => "&amp;", "\u00a0" => "&nbsp;", "<" => "&lt;", ">" => "&gt;")
+        body.encode(Encoding::UTF_8)
       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 ["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

data/lib/nokogiri/jruby/dependencies.rb

@@ -1,21 +1,3 @@
 # frozen_string_literal: true
 
-# The line below caused a problem on non-GAE rack environment.
-# unless defined?(JRuby::Rack::VERSION) || defined?(AppEngine::ApiProxy)
-#
-# However, simply cutting defined?(JRuby::Rack::VERSION) off resulted in
-# an unable-to-load-nokogiri problem. Thus, now, Nokogiri checks the presense
-# of appengine-rack.jar in $LOAD_PATH. If Nokogiri is on GAE, Nokogiri
-# 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"
-end
+require_relative "nokogiri_jars"