nokogiri 1.11.1 → 1.12.0.rc1

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:

data/lib/nokogiri/version/constant.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module Nokogiri
   # The version of Nokogiri you are using
-  VERSION = "1.11.1"
+  VERSION = "1.12.0.rc1"
 end

data/lib/nokogiri/version/info.rb

@@ -10,6 +10,14 @@ module Nokogiri
       ::JRUBY_VERSION if ::RUBY_PLATFORM == "java"
     end
 
+    def windows?
+      ::RUBY_PLATFORM =~ /mingw|mswin/
+    end
+
+    def ruby_minor
+      Gem::Version.new(::RUBY_VERSION).segments[0..1].join(".")
+    end
+
     def engine
       defined?(::RUBY_ENGINE) ? ::RUBY_ENGINE : "mri"
     end
@@ -44,6 +52,10 @@ module Nokogiri
       defined?(Nokogiri::LIBXML_ICONV_ENABLED) && Nokogiri::LIBXML_ICONV_ENABLED
     end
 
+    def libxslt_has_datetime?
+      defined?(Nokogiri::LIBXSLT_DATETIME_ENABLED) && Nokogiri::LIBXSLT_DATETIME_ENABLED
+    end
+
     def libxml2_using_packaged?
       libxml2? && Nokogiri::PACKAGED_LIBRARIES
     end
@@ -74,18 +86,38 @@ module Nokogiri
 
     def to_hash
       header_directory = File.expand_path(File.join(File.dirname(__FILE__), "../../../ext/nokogiri"))
+
       {}.tap do |vi|
         vi["warnings"] = []
         vi["nokogiri"] = {}.tap do |nokogiri|
           nokogiri["version"] = Nokogiri::VERSION
 
           unless jruby?
+            #  enable gems like nokogumbo to build with the following in their extconf.rb:
+            #
+            #    append_cflags(Nokogiri::VERSION_INFO["nokogiri"]["cppflags"])
+            #    append_ldflags(Nokogiri::VERSION_INFO["nokogiri"]["ldflags"])
+            #
             cppflags = ["-I#{header_directory.shellescape}"]
+            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
+                lib_directory = File.expand_path(File.join(File.dirname(__FILE__), "../#{ruby_minor}"))
+                unless File.exist?(lib_directory)
+                  lib_directory = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+                end
+                ldflags << "-L#{lib_directory.shellescape}"
+                ldflags << "-l:nokogiri.so"
+              end
             end
+
             nokogiri["cppflags"] = cppflags
+            nokogiri["ldflags"] = ldflags
           end
         end
         vi["ruby"] = {}.tap do |ruby|
@@ -109,6 +141,7 @@ module Nokogiri
             else
               libxml["source"] = "system"
             end
+            libxml["memory_management"] = Nokogiri::LIBXML_MEMORY_MANAGEMENT
             libxml["iconv_enabled"] = libxml2_has_iconv?
             libxml["compiled"] = compiled_libxml_version.to_s
             libxml["loaded"] = loaded_libxml_version.to_s
@@ -122,6 +155,7 @@ module Nokogiri
             else
               libxslt["source"] = "system"
             end
+            libxslt["datetime_enabled"] = libxslt_has_datetime?
             libxslt["compiled"] = compiled_libxslt_version.to_s
             libxslt["loaded"] = loaded_libxslt_version.to_s
           end
@@ -162,20 +196,19 @@ module Nokogiri
     Gem::Requirement.new(requirement).satisfied_by?(VersionInfo.instance.loaded_libxml_version)
   end
 
+  def self.uses_gumbo?
+    uses_libxml? # TODO: replace with Gumbo functionality
+  end
+
   def self.jruby? # :nodoc:
     VersionInfo.instance.jruby?
   end
 
   # Ensure constants used in this file are loaded - see #1896
   if Nokogiri.jruby?
-    require "nokogiri/jruby/dependencies"
-  end
-  begin
-    ::RUBY_VERSION =~ /(\d+\.\d+)/
-    require "nokogiri/#{Regexp.last_match(1)}/nokogiri"
-  rescue LoadError
-    require "nokogiri/nokogiri"
+    require_relative "../jruby/dependencies"
   end
+  require_relative "../extension"
 
   # More complete version information about libxml
   VERSION_INFO = VersionInfo.instance.to_hash

data/lib/nokogiri/xml.rb

@@ -1,38 +1,9 @@
 # frozen_string_literal: true
-require 'nokogiri/xml/pp'
-require 'nokogiri/xml/parse_options'
-require 'nokogiri/xml/sax'
-require 'nokogiri/xml/searchable'
-require 'nokogiri/xml/node'
-require 'nokogiri/xml/attribute_decl'
-require 'nokogiri/xml/element_decl'
-require 'nokogiri/xml/element_content'
-require 'nokogiri/xml/character_data'
-require 'nokogiri/xml/namespace'
-require 'nokogiri/xml/attr'
-require 'nokogiri/xml/dtd'
-require 'nokogiri/xml/cdata'
-require 'nokogiri/xml/text'
-require 'nokogiri/xml/document'
-require 'nokogiri/xml/document_fragment'
-require 'nokogiri/xml/processing_instruction'
-require 'nokogiri/xml/node_set'
-require 'nokogiri/xml/syntax_error'
-require 'nokogiri/xml/xpath'
-require 'nokogiri/xml/xpath_context'
-require 'nokogiri/xml/builder'
-require 'nokogiri/xml/reader'
-require 'nokogiri/xml/notation'
-require 'nokogiri/xml/entity_decl'
-require 'nokogiri/xml/entity_reference'
-require 'nokogiri/xml/schema'
-require 'nokogiri/xml/relax_ng'
-
 module Nokogiri
   class << self
     ###
     # Parse XML.  Convenience method for Nokogiri::XML::Document.parse
-    def XML thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_XML, &block
+    def XML(thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_XML, &block)
       Nokogiri::XML::Document.parse(thing, url, encoding, options, &block)
     end
   end
@@ -41,20 +12,19 @@ module Nokogiri
     # Original C14N 1.0 spec canonicalization
     XML_C14N_1_0 =       0
     # Exclusive C14N 1.0 spec canonicalization
-    XML_C14N_EXCLUSIVE_1_0 =     1
+    XML_C14N_EXCLUSIVE_1_0 = 1
     # C14N 1.1 spec canonicalization
     XML_C14N_1_1 = 2
     class << self
       ###
       # Parse an XML document using the Nokogiri::XML::Reader API.  See
       # Nokogiri::XML::Reader for mor information
-      def Reader string_or_io, url = nil, encoding = nil, options = ParseOptions::STRICT
-
+      def Reader(string_or_io, url = nil, encoding = nil, options = ParseOptions::STRICT)
         options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
         # Give the options to the user
         yield options if block_given?
 
-        if string_or_io.respond_to? :read
+        if string_or_io.respond_to?(:read)
           return Reader.from_io(string_or_io, url, encoding, options.to_i)
         end
         Reader.from_memory(string_or_io, url, encoding, options.to_i)
@@ -62,15 +32,44 @@ module Nokogiri
 
       ###
       # Parse XML.  Convenience method for Nokogiri::XML::Document.parse
-      def parse thing, url = nil, encoding = nil, options = ParseOptions::DEFAULT_XML, &block
+      def parse(thing, url = nil, encoding = nil, options = ParseOptions::DEFAULT_XML, &block)
         Document.parse(thing, url, encoding, options, &block)
       end
 
       ####
       # Parse a fragment from +string+ in to a NodeSet.
-      def fragment string
+      def fragment(string)
         XML::DocumentFragment.parse(string)
       end
     end
   end
 end
+
+require_relative "xml/pp"
+require_relative "xml/parse_options"
+require_relative "xml/sax"
+require_relative "xml/searchable"
+require_relative "xml/node"
+require_relative "xml/attribute_decl"
+require_relative "xml/element_decl"
+require_relative "xml/element_content"
+require_relative "xml/character_data"
+require_relative "xml/namespace"
+require_relative "xml/attr"
+require_relative "xml/dtd"
+require_relative "xml/cdata"
+require_relative "xml/text"
+require_relative "xml/document"
+require_relative "xml/document_fragment"
+require_relative "xml/processing_instruction"
+require_relative "xml/node_set"
+require_relative "xml/syntax_error"
+require_relative "xml/xpath"
+require_relative "xml/xpath_context"
+require_relative "xml/builder"
+require_relative "xml/reader"
+require_relative "xml/notation"
+require_relative "xml/entity_decl"
+require_relative "xml/entity_reference"
+require_relative "xml/schema"
+require_relative "xml/relax_ng"