nokogiri 1.11.4 → 1.12.5

data/lib/nokogiri/css.rb

@@ -1,28 +1,28 @@
 # frozen_string_literal: true
-require 'nokogiri/css/node'
-require 'nokogiri/css/xpath_visitor'
-x = $-w
-$-w = false
-require 'nokogiri/css/parser'
-$-w = x
-
-require 'nokogiri/css/tokenizer'
-require 'nokogiri/css/syntax_error'
-
 module Nokogiri
   module CSS
     class << self
       ###
       # Parse this CSS selector in +selector+.  Returns an AST.
-      def parse selector
-        Parser.new.parse selector
+      def parse(selector)
+        Parser.new.parse(selector)
       end
 
       ###
       # Get the XPath for +selector+.
-      def xpath_for selector, options={}
-        Parser.new(options[:ns] || {}).xpath_for selector, options
+      def xpath_for(selector, options = {})
+        Parser.new(options[:ns] || {}).xpath_for(selector, options)
       end
     end
   end
 end
+
+require_relative "css/node"
+require_relative "css/xpath_visitor"
+x = $-w
+$-w = false
+require_relative "css/parser"
+$-w = x
+
+require_relative "css/tokenizer"
+require_relative "css/syntax_error"

data/lib/nokogiri/extension.rb

@@ -2,8 +2,9 @@
 
 # load the C or Java extension
 begin
+  # native precompiled gems package shared libraries in <gem_dir>/lib/nokogiri/<ruby_version>
   ::RUBY_VERSION =~ /(\d+\.\d+)/
-  require "nokogiri/#{Regexp.last_match(1)}/nokogiri"
+  require_relative "#{Regexp.last_match(1)}/nokogiri"
 rescue LoadError => e
   if e.message =~ /GLIBC/
     warn(<<~EOM)
@@ -22,5 +23,9 @@ rescue LoadError => e
     EOM
     raise e
   end
-  require 'nokogiri/nokogiri'
+
+  # use "require" instead of "require_relative" because non-native gems will place C extension files
+  # in Gem::BasicSpecification#extension_dir after compilation (during normal installation), which
+  # is in $LOAD_PATH but not necessarily relative to this file (see #2300)
+  require "nokogiri/nokogiri"
 end

data/lib/nokogiri/gumbo.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Nokogiri
+  module Gumbo
+    # The default maximum number of attributes per element.
+    DEFAULT_MAX_ATTRIBUTES = 400
+
+    # The default maximum number of errors for parsing a document or a fragment.
+    DEFAULT_MAX_ERRORS = 0
+
+    # The default maximum depth of the DOM tree produced by parsing a document
+    # or fragment.
+    DEFAULT_MAX_TREE_DEPTH = 400
+  end
+end

data/lib/nokogiri/html.rb

@@ -1,38 +1,42 @@
 # frozen_string_literal: true
-require 'nokogiri/html/entity_lookup'
-require 'nokogiri/html/document'
-require 'nokogiri/html/document_fragment'
-require 'nokogiri/html/sax/parser_context'
-require 'nokogiri/html/sax/parser'
-require 'nokogiri/html/sax/push_parser'
-require 'nokogiri/html/element_description'
-require 'nokogiri/html/element_description_defaults'
+require_relative "html4"
 
 module Nokogiri
-  class << self
-    ###
-    # Parse HTML.  Convenience method for Nokogiri::HTML::Document.parse
-    def HTML thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block
-      Nokogiri::HTML::Document.parse(thing, url, encoding, options, &block)
-    end
-  end
+  HTML = Nokogiri::HTML4
+
+  # @!method HTML(input, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block)
+  # Parse HTML. Convenience method for Nokogiri::HTML4::Document.parse
+  # @!scope class
+  define_singleton_method(:HTML, Nokogiri.method(:HTML4))
 
+  # @note This module/namespace is an alias for {Nokogiri::HTML4} as of v1.12.0. Before v1.12.0,
+  #   {Nokogiri::HTML4} did not exist, and this was the module/namespace for all HTML-related
+  #   classes.
   module HTML
-    class << self
-      ###
-      # Parse HTML.  Convenience method for Nokogiri::HTML::Document.parse
-      def parse thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block
-        Document.parse(thing, url, encoding, options, &block)
+    # @note This class is an alias for {Nokogiri::HTML4::Document} as of v1.12.0.
+    class Document < Nokogiri::XML::Document
+    end
+
+    # @note This class is an alias for {Nokogiri::HTML4::DocumentFragment} as of v1.12.0.
+    class DocumentFragment < Nokogiri::XML::DocumentFragment
+    end
+
+    # @note This class is an alias for {Nokogiri::HTML4::Builder} as of v1.12.0.
+    class Builder < Nokogiri::XML::Builder
+    end
+
+    module SAX
+      # @note This class is an alias for {Nokogiri::HTML4::SAX::Parser} as of v1.12.0.
+      class Parser < Nokogiri::XML::SAX::Parser
       end
 
-      ####
-      # Parse a fragment from +string+ in to a NodeSet.
-      def fragment string, encoding = nil
-        HTML::DocumentFragment.parse string, encoding
+      # @note This class is an alias for {Nokogiri::HTML4::SAX::ParserContext} as of v1.12.0.
+      class ParserContext < Nokogiri::XML::SAX::ParserContext
       end
-    end
 
-    # Instance of Nokogiri::HTML::EntityLookup
-    NamedCharacters = EntityLookup.new
+      # @note This class is an alias for {Nokogiri::HTML4::SAX::PushParser} as of v1.12.0.
+      class PushParser
+      end
+    end
   end
 end

data/lib/nokogiri/{html → html4}/builder.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module Nokogiri
-  module HTML
+  module HTML4
     ###
     # Nokogiri HTML builder is used for building HTML documents.  It is very
     # similar to the Nokogiri::XML::Builder.  In fact, you should go read the
@@ -12,7 +12,7 @@ module Nokogiri
     # Create an HTML document with a body that has an onload attribute, and a
     # span tag with a class of "bold" that has content of "Hello world".
     #
-    #   builder = Nokogiri::HTML::Builder.new do |doc|
+    #   builder = Nokogiri::HTML4::Builder.new do |doc|
     #     doc.html {
     #       doc.body(:onload => 'some_func();') {
     #         doc.span.bold {

data/lib/nokogiri/{html → html4}/document.rb

@@ -3,7 +3,7 @@
 require 'pathname'
 
 module Nokogiri
-  module HTML
+  module HTML4
     class Document < Nokogiri::XML::Document
       ###
       # Get the meta tag encoding for this document.  If there is no meta tag,
@@ -268,12 +268,12 @@ module Nokogiri
             m = chunk.match(/(<meta\s)(.*)(charset\s*=\s*([\w-]+))(.*)/i) and
               return m[4]
             catch(:encoding_found) {
-              Nokogiri::HTML::SAX::Parser.new(JumpSAXHandler.new(:encoding_found)).parse(chunk)
+              Nokogiri::HTML4::SAX::Parser.new(JumpSAXHandler.new(:encoding_found)).parse(chunk)
               nil
             }
           else
             handler = SAXHandler.new
-            parser = Nokogiri::HTML::SAX::PushParser.new(handler)
+            parser = Nokogiri::HTML4::SAX::PushParser.new(handler)
             parser << chunk rescue Nokogiri::SyntaxError
             handler.encoding
           end
@@ -286,7 +286,7 @@ module Nokogiri
         end
 
         # This method is used by the C extension so that
-        # Nokogiri::HTML::Document#read_io() does not leak memory when
+        # Nokogiri::HTML4::Document#read_io() does not leak memory when
         # EncodingFound is raised.
         attr_reader :encoding_found
 

data/lib/nokogiri/{html → html4}/document_fragment.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 module Nokogiri
-  module HTML
+  module HTML4
     class DocumentFragment < Nokogiri::XML::DocumentFragment
       ####
       # Create a Nokogiri::XML::DocumentFragment from +tags+, using +encoding+
       def self.parse(tags, encoding = nil)
-        doc = HTML::Document.new
+        doc = HTML4::Document.new
 
         encoding ||= if tags.respond_to?(:encoding)
           encoding = tags.encoding
@@ -39,7 +39,7 @@ module Nokogiri
             "/html/body/node()"
           end
 
-          temp_doc = HTML::Document.parse("<html><body>#{tags}", nil, document.encoding)
+          temp_doc = HTML4::Document.parse("<html><body>#{tags}", nil, document.encoding)
           temp_doc.xpath(path).each { |child| child.parent = self }
           self.errors = temp_doc.errors
         end

data/lib/nokogiri/{html → html4}/element_description.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module Nokogiri
-  module HTML
+  module HTML4
     class ElementDescription
       ###
       # Is this element a block element?

data/lib/nokogiri/{html → html4}/element_description_defaults.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module Nokogiri
-  module HTML
+  module HTML4
     class ElementDescription
 
       # Methods are defined protected by method_defined? because at

data/lib/nokogiri/{html → html4}/entity_lookup.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module Nokogiri
-  module HTML
+  module HTML4
     class EntityDescription < Struct.new(:value, :name, :description); end
 
     class EntityLookup

data/lib/nokogiri/{html → html4}/sax/parser.rb

@@ -1,18 +1,15 @@
 # frozen_string_literal: true
 module Nokogiri
-  module HTML
+  module HTML4
     ###
-    # Nokogiri lets you write a SAX parser to process HTML but get HTML
-    # correction features.
+    # Nokogiri lets you write a SAX parser to process HTML but get HTML correction features.
     #
-    # See Nokogiri::HTML::SAX::Parser for a basic example of using a
-    # SAX parser with HTML.
+    # See Nokogiri::HTML4::SAX::Parser for a basic example of using a SAX parser with HTML.
     #
     # For more information on SAX parsers, see Nokogiri::XML::SAX
     module SAX
       ###
-      # This class lets you perform SAX style parsing on HTML with HTML
-      # error correction.
+      # This class lets you perform SAX style parsing on HTML with HTML error correction.
       #
       # Here is a basic usage example:
       #
@@ -22,40 +19,40 @@ module Nokogiri
       #     end
       #   end
       #
-      #   parser = Nokogiri::HTML::SAX::Parser.new(MyDoc.new)
+      #   parser = Nokogiri::HTML4::SAX::Parser.new(MyDoc.new)
       #   parser.parse(File.read(ARGV[0], mode: 'rb'))
       #
       # For more information on SAX parsers, see Nokogiri::XML::SAX
       class Parser < Nokogiri::XML::SAX::Parser
         ###
         # Parse html stored in +data+ using +encoding+
-        def parse_memory data, encoding = 'UTF-8'
+        def parse_memory(data, encoding = "UTF-8")
           raise ArgumentError unless data
           return unless data.length > 0
           ctx = ParserContext.memory(data, encoding)
           yield ctx if block_given?
-          ctx.parse_with self
+          ctx.parse_with(self)
         end
 
         ###
         # Parse given +io+
-        def parse_io io, encoding = 'UTF-8'
+        def parse_io(io, encoding = "UTF-8")
           check_encoding(encoding)
           @encoding = encoding
           ctx = ParserContext.io(io, ENCODINGS[encoding])
           yield ctx if block_given?
-          ctx.parse_with self
+          ctx.parse_with(self)
         end
 
         ###
         # Parse a file with +filename+
-        def parse_file filename, encoding = 'UTF-8'
+        def parse_file(filename, encoding = "UTF-8")
           raise ArgumentError unless filename
           raise Errno::ENOENT unless File.exist?(filename)
           raise Errno::EISDIR if File.directory?(filename)
           ctx = ParserContext.file(filename, encoding)
           yield ctx if block_given?
-          ctx.parse_with self
+          ctx.parse_with(self)
         end
       end
     end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Nokogiri
+  module HTML4
+    module SAX
+      ###
+      # Context for HTML SAX parsers. This class is usually not instantiated by the user. Instead,
+      # you should be looking at Nokogiri::HTML4::SAX::Parser
+      class ParserContext < Nokogiri::XML::SAX::ParserContext
+        def self.new(thing, encoding = "UTF-8")
+          if [:read, :close].all? { |x| thing.respond_to?(x) }
+            super
+          else
+            memory(thing, encoding)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/{html → html4}/sax/push_parser.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 module Nokogiri
-  module HTML
+  module HTML4
     module SAX
       class PushParser
         
-        # The Nokogiri::HTML::SAX::Document on which the PushParser will be
+        # The Nokogiri::HTML4::SAX::Document on which the PushParser will be
         # operating
         attr_accessor :document
         
-        def initialize(doc = HTML::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 = HTML::SAX::Parser.new(doc, @encoding)
+          @sax_parser = HTML4::SAX::Parser.new(doc, @encoding)
 
           ## Create our push parser context
           initialize_native(@sax_parser, file_name, encoding)
@@ -27,7 +27,7 @@ module Nokogiri
 
         ###
         # Finish the parsing.  This method is only necessary for
-        # Nokogiri::HTML::SAX::Document#end_document to be called.
+        # Nokogiri::HTML4::SAX::Document#end_document to be called.
         def finish
           write '', true
         end

data/lib/nokogiri/html4.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module Nokogiri
+  class << self
+    ###
+    # 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.
+  module HTML4
+    class << self
+      ###
+      # Parse HTML. Convenience method for Nokogiri::HTML4::Document.parse
+      def parse(input, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block)
+        Document.parse(input, url, encoding, options, &block)
+      end
+
+      ####
+      # Parse a fragment from +string+ in to a NodeSet.
+      def fragment(string, encoding = nil)
+        HTML4::DocumentFragment.parse(string, encoding)
+      end
+    end
+
+    # Instance of Nokogiri::HTML4::EntityLookup
+    NamedCharacters = EntityLookup.new
+  end
+end
+
+require_relative "html4/entity_lookup"
+require_relative "html4/document"
+require_relative "html4/document_fragment"
+require_relative "html4/sax/parser_context"
+require_relative "html4/sax/parser"
+require_relative "html4/sax/push_parser"
+require_relative "html4/element_description"
+require_relative "html4/element_description_defaults"

data/lib/nokogiri/html5/document.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+#
+#  Copyright 2013-2021 Sam Ruby, Stephen Checkoway
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+require_relative "../html4/document"
+
+module Nokogiri
+  module HTML5
+    # @since v1.12.0
+    # @note 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
+
+        if string_or_io.respond_to?(:encoding) && string_or_io.encoding.name != '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.new("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)
+        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)
+        do_parse(string, url, encoding, options)
+      end
+
+      def fragment(tags = nil)
+        DocumentFragment.new(self, tags, self.root)
+      end
+
+      def to_xml(options = {}, &block)
+        # 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)
+      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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+#
+#  Copyright 2013-2021 Sam Ruby, Stephen Checkoway
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+require_relative "../html4/document_fragment"
+
+module Nokogiri
+  module HTML5
+    # @since v1.12.0
+    # @note HTML5 functionality is not available when running JRuby.
+    class DocumentFragment < Nokogiri::HTML4::DocumentFragment
+      attr_accessor :document
+      attr_accessor :errors
+
+      # Create a document fragment.
+      def initialize(doc, tags = nil, ctx = nil, options = {})
+        self.document = doc
+        self.errors = []
+        return self unless tags
+
+        max_attributes = options[:max_attributes] || Nokogiri::Gumbo::DEFAULT_MAX_ATTRIBUTES
+        max_errors = options[:max_errors] || Nokogiri::Gumbo::DEFAULT_MAX_ERRORS
+        max_depth = options[:max_tree_depth] || Nokogiri::Gumbo::DEFAULT_MAX_TREE_DEPTH
+        tags = Nokogiri::HTML5.read_and_encode(tags, nil)
+        Nokogiri::Gumbo.fragment(self, tags, ctx, max_attributes, max_errors, max_depth)
+      end
+
+      def serialize(options = {}, &block)
+        # 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)
+      end
+
+      # Parse a document fragment from +tags+, returning a Nodeset.
+      def self.parse(tags, encoding = nil, options = {})
+        doc = HTML5::Document.new
+        tags = HTML5.read_and_encode(tags, encoding)
+        doc.encoding = "UTF-8"
+        new(doc, tags, nil, options)
+      end
+
+      def extract_params(params) # :nodoc:
+        handler = params.find do |param|
+          ![Hash, String, Symbol].include?(param.class)
+        end
+        params -= [handler] if handler
+
+        hashes = []
+        while Hash === params.last || params.last.nil?
+          hashes << params.pop
+          break if params.empty?
+        end
+        ns, binds = hashes.reverse
+
+        ns ||=
+          begin
+            ns = {}
+            children.each { |child| ns.merge!(child.namespaces) }
+            ns
+          end
+
+        [params, handler, ns, binds]
+      end
+    end
+  end
+end
+# vim: set shiftwidth=2 softtabstop=2 tabstop=8 expandtab:

data/lib/nokogiri/html5/node.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+#
+#  Copyright 2013-2021 Sam Ruby, Stephen Checkoway
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+require_relative "../xml/node"
+
+module Nokogiri
+  module HTML5
+    # @since v1.12.0
+    # @note 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 << children.map { |child| child.to_html(options) }.join
+        result
+      end
+
+      def write_to(io, *options)
+        return super(io, *options) unless document.is_a?(HTML5::Document)
+        options = options.first.is_a?(Hash) ? options.shift : {}
+        encoding = options[:encoding] || options[0]
+        if Nokogiri.jruby?
+          save_options = options[:save_with] || options[1]
+          indent_times = options[:indent] || 0
+        else
+          save_options = options[:save_with] || options[1] || XML::Node::SaveOptions::FORMAT
+          indent_times = options[:indent] || 2
+        end
+        indent_string = (options[:indent_text] || " ") * indent_times
+
+        config = XML::Node::SaveOptions.new(save_options.to_i)
+        yield config if block_given?
+
+        config_options = config.options
+        if config_options & (XML::Node::SaveOptions::AS_XML | XML::Node::SaveOptions::AS_XHTML) != 0
+          # Use Nokogiri's serializing code.
+          native_write_to(io, encoding, indent_string, config_options)
+        else
+          # Serialize including the current node.
+          encoding ||= document.encoding || Encoding::UTF_8
+          internal_ops = {
+            preserve_newline: options[:preserve_newline] || false,
+          }
+          HTML5.serialize_node_internal(self, io, encoding, internal_ops)
+        end
+      end
+
+      def fragment(tags)
+        return super(tags) unless document.is_a?(HTML5::Document)
+        DocumentFragment.new(document, tags, self)
+      end
+
+      private
+
+      # HTML elements can have attributes that contain colons.
+      # Nokogiri::XML::Node#[]= treats names with colons as a prefixed QName
+      # and tries to create an attribute in a namespace. This is especially
+      # annoying with attribute names like xml:lang since libxml2 will
+      # actually create the xml namespace if it doesn't exist already.
+      def add_child_node_and_reparent_attrs(node)
+        return super(node) unless document.is_a?(HTML5::Document)
+        # I'm not sure what this method is supposed to do. Reparenting
+        # namespaces is handled by libxml2, including child namespaces which
+        # this method wouldn't handle.
+        # https://github.com/sparklemotion/nokogiri/issues/1790
+        add_child_node(node)
+        # node.attribute_nodes.find_all { |a| a.namespace }.each do |attr|
+        #  attr.remove
+        #  ns = attr.namespace
+        #  a["#{ns.prefix}:#{attr.name}"] = attr.value
+        # end
+      end
+    end
+    # Monkey patch
+    XML::Node.prepend(HTML5::Node)
+  end
+end
+
+# vim: set shiftwidth=2 softtabstop=2 tabstop=8 expandtab: