nokogiri 1.11.0.rc3 → 1.11.0.rc4

data/lib/nokogiri/version/constant.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+module Nokogiri
+  # The version of Nokogiri you are using
+  VERSION = "1.11.0.rc4"
+end

data/lib/nokogiri/version/info.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+require "singleton"
+require "shellwords"
+
+module Nokogiri
+  class VersionInfo # :nodoc:
+    include Singleton
+
+    def jruby?
+      ::JRUBY_VERSION if ::RUBY_PLATFORM == "java"
+    end
+
+    def engine
+      defined?(::RUBY_ENGINE) ? ::RUBY_ENGINE : "mri"
+    end
+
+    def loaded_libxml_version
+      Gem::Version.new(Nokogiri::LIBXML_LOADED_VERSION
+        .scan(/^(\d+)(\d\d)(\d\d)(?!\d)/).first
+        .collect(&:to_i)
+        .join("."))
+    end
+
+    def compiled_libxml_version
+      Gem::Version.new(Nokogiri::LIBXML_COMPILED_VERSION)
+    end
+
+    def loaded_libxslt_version
+      Gem::Version.new(Nokogiri::LIBXSLT_LOADED_VERSION
+        .scan(/^(\d+)(\d\d)(\d\d)(?!\d)/).first
+        .collect(&:to_i)
+        .join("."))
+    end
+
+    def compiled_libxslt_version
+      Gem::Version.new(Nokogiri::LIBXSLT_COMPILED_VERSION)
+    end
+
+    def libxml2?
+      defined?(Nokogiri::LIBXML_COMPILED_VERSION)
+    end
+
+    def libxml2_has_iconv?
+      defined?(Nokogiri::LIBXML_ICONV_ENABLED) && Nokogiri::LIBXML_ICONV_ENABLED
+    end
+
+    def libxml2_using_packaged?
+      libxml2? && Nokogiri::PACKAGED_LIBRARIES
+    end
+
+    def libxml2_using_system?
+      libxml2? && !libxml2_using_packaged?
+    end
+
+    def libxml2_precompiled?
+      libxml2_using_packaged? && Nokogiri::PRECOMPILED_LIBRARIES
+    end
+
+    def warnings
+      warnings = []
+
+      if libxml2?
+        if compiled_libxml_version != loaded_libxml_version
+          warnings << "Nokogiri was built against libxml version #{compiled_libxml_version}, but has dynamically loaded #{loaded_libxml_version}"
+        end
+
+        if compiled_libxslt_version != loaded_libxslt_version
+          warnings << "Nokogiri was built against libxslt version #{compiled_libxslt_version}, but has dynamically loaded #{loaded_libxslt_version}"
+        end
+      end
+
+      warnings
+    end
+
+    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?
+            cppflags = ["-I#{header_directory.shellescape}"]
+            if libxml2_using_packaged?
+              cppflags << "-I#{File.join(header_directory, "include").shellescape}"
+              cppflags << "-I#{File.join(header_directory, "include/libxml2").shellescape}"
+            end
+            nokogiri["cppflags"] = cppflags
+          end
+        end
+        vi["ruby"] = {}.tap do |ruby|
+          ruby["version"] = ::RUBY_VERSION
+          ruby["platform"] = ::RUBY_PLATFORM
+          ruby["gem_platform"] = ::Gem::Platform.local.to_s
+          ruby["description"] = ::RUBY_DESCRIPTION
+          ruby["engine"] = engine
+          ruby["jruby"] = jruby? if jruby?
+        end
+
+        if libxml2?
+          vi["libxml"] = {}.tap do |libxml|
+            if libxml2_using_packaged?
+              libxml["source"] = "packaged"
+              libxml["precompiled"] = libxml2_precompiled?
+              libxml["patches"] = Nokogiri::LIBXML2_PATCHES
+
+              # this is for nokogumbo and shouldn't be forever
+              libxml["libxml2_path"] = header_directory
+            else
+              libxml["source"] = "system"
+            end
+            libxml["iconv_enabled"] = libxml2_has_iconv?
+            libxml["compiled"] = compiled_libxml_version.to_s
+            libxml["loaded"] = loaded_libxml_version.to_s
+          end
+
+          vi["libxslt"] = {}.tap do |libxslt|
+            if libxml2_using_packaged?
+              libxslt["source"] = "packaged"
+              libxslt["precompiled"] = libxml2_precompiled?
+              libxslt["patches"] = Nokogiri::LIBXSLT_PATCHES
+            else
+              libxslt["source"] = "system"
+            end
+            libxslt["compiled"] = compiled_libxslt_version.to_s
+            libxslt["loaded"] = loaded_libxslt_version.to_s
+          end
+
+          vi["warnings"] = warnings
+        end
+
+        if defined?(Nokogiri::OTHER_LIBRARY_VERSIONS)
+          # see extconf for how this string is assembled: "lib1name:lib1version,lib2name:lib2version"
+          vi["other_libraries"] = Hash[*Nokogiri::OTHER_LIBRARY_VERSIONS.split(/[,:]/)]
+        elsif jruby?
+          vi["other_libraries"] = {}.tap do |ol|
+            ol["xerces"] = Nokogiri::XERCES_VERSION
+            ol["nekohtml"] = Nokogiri::NEKO_VERSION
+          end
+        end
+      end
+    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
+    end
+
+    instance.warnings.each do |warning|
+      warn "WARNING: #{warning}"
+    end
+  end
+
+  def self.uses_libxml?(requirement = nil) # :nodoc:
+    return false unless VersionInfo.instance.libxml2?
+    return true unless requirement
+    Gem::Requirement.new(requirement).satisfied_by?(VersionInfo.instance.loaded_libxml_version)
+  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"
+  end
+
+  # More complete version information about libxml
+  VERSION_INFO = VersionInfo.instance.to_hash
+end

data/lib/nokogiri/xml/document.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
+require 'pathname'
+
 module Nokogiri
   module XML
     ##
@@ -44,9 +47,11 @@ module Nokogiri
       #
       def self.parse string_or_io, url = nil, encoding = nil, options = ParseOptions::DEFAULT_XML
         options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
-        # Give the options to the user
+
         yield options if block_given?
 
+        url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
+
         if empty_doc?(string_or_io)
           if options.strict?
             raise Nokogiri::XML::SyntaxError.new("Empty document")
@@ -56,12 +61,17 @@ module Nokogiri
         end
 
         doc = if string_or_io.respond_to?(:read)
-          url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
-          read_io(string_or_io, url, encoding, options.to_i)
-        else
-          # read_memory pukes on empty docs
-          read_memory(string_or_io, url, encoding, options.to_i)
-        end
+                if string_or_io.is_a?(Pathname)
+                  # resolve the Pathname to the file and open it as an IO object, see #2110
+                  string_or_io = string_or_io.expand_path.open
+                  url ||= string_or_io.path
+                end
+
+                read_io(string_or_io, url, encoding, options.to_i)
+              else
+                # read_memory pukes on empty docs
+                read_memory(string_or_io, url, encoding, options.to_i)
+              end
 
         # do xinclude processing
         doc.do_xinclude(options) if options.xinclude?

data/lib/nokogiri/xml/document_fragment.rb

@@ -141,6 +141,10 @@ module Nokogiri
         document.errors = things
       end
 
+      def fragment(data)
+        document.fragment(data)
+      end
+
       private
 
       # fix for issue 770
@@ -150,12 +154,6 @@ module Nokogiri
           %Q{xmlns#{prefix}="#{namespace.href}"}
         end.join ' '
       end
-
-      def coerce data
-        return super unless String === data
-
-        document.fragment(data).children
-      end
     end
   end
 end

data/lib/nokogiri/xml/node.rb

@@ -267,6 +267,8 @@ module Nokogiri
       #
       # Also see related method +swap+.
       def replace(node_or_tags)
+        raise("Cannot replace a node with no parent") unless parent
+
         # We cannot replace a text node directly, otherwise libxml will return
         # an internal error at parser.c:13031, I don't know exactly why
         # libxml is trying to find a parent node that is an element or document
@@ -278,7 +280,7 @@ module Nokogiri
           return replacee.replace node_or_tags
         end
 
-        node_or_tags = coerce(node_or_tags)
+        node_or_tags = parent.coerce(node_or_tags)
 
         if node_or_tags.is_a?(XML::NodeSet)
           node_or_tags.each { |n| add_previous_sibling n }
@@ -819,13 +821,30 @@ module Nokogiri
 
         return Nokogiri::XML::NodeSet.new(document) if contents.empty?
 
-        ##
-        # This is a horrible hack, but I don't care. See #313 for background.
+        # libxml2 does not obey the `recover` option after encountering errors during `in_context`
+        # parsing, and so this horrible hack is here to try to emulate recovery behavior.
+        #
+        # Unfortunately, this means we're no longer parsing "in context" and so namespaces that
+        # would have been inherited from the context node won't be handled correctly. This hack was
+        # written in 2010, and I regret it, because it's silently degrading functionality in a way
+        # that's not easily prevented (or even detected).
+        #
+        # I think preferable behavior would be to either:
+        #
+        # a. add an error noting that we "fell back" and pointing the user to turning off the `recover` option
+        # b. don't recover, but raise a sensible exception
+        #
+        # For context and background: https://github.com/sparklemotion/nokogiri/issues/313
+        # FIXME bug report: https://github.com/sparklemotion/nokogiri/issues/2092
         error_count = document.errors.length
         node_set = in_context(contents, options.to_i)
-        if node_set.empty? and document.errors.length > error_count and options.recover?
-          fragment = Nokogiri::HTML::DocumentFragment.parse contents
-          node_set = fragment.children
+        if (node_set.empty? && (document.errors.length > error_count))
+          if options.recover?
+            fragment = Nokogiri::HTML::DocumentFragment.parse contents
+            node_set = fragment.children
+          else
+            raise document.errors[error_count]
+          end
         end
         node_set
       end
@@ -1128,6 +1147,28 @@ module Nokogiri
 
       # @!endgroup
 
+      protected
+
+      def coerce(data)
+        case data
+        when XML::NodeSet
+          return data
+        when XML::DocumentFragment
+          return data.children
+        when String
+          return fragment(data).children
+        when Document, XML::Attr
+          # unacceptable
+        when XML::Node
+          return data
+        end
+
+        raise ArgumentError, <<-EOERR
+Requires a Node, NodeSet or String argument, and cannot accept a #{data.class}.
+(You probably want to select a node from the Document with at() or search(), or create a new Node via Node.new().)
+        EOERR
+      end
+
       private
 
       def keywordify(keywords)
@@ -1142,10 +1183,12 @@ module Nokogiri
       end
 
       def add_sibling(next_or_previous, node_or_tags)
+        raise("Cannot add sibling to a node with no parent") unless parent
+
         impl = (next_or_previous == :next) ? :add_next_sibling_node : :add_previous_sibling_node
         iter = (next_or_previous == :next) ? :reverse_each : :each
 
-        node_or_tags = coerce node_or_tags
+        node_or_tags = parent.coerce(node_or_tags)
         if node_or_tags.is_a?(XML::NodeSet)
           if text?
             pivot = Nokogiri::XML::Node.new "dummy", document
@@ -1182,26 +1225,6 @@ module Nokogiri
         [:name, :namespace, :attribute_nodes, :children]
       end
 
-      def coerce(data)
-        case data
-        when XML::NodeSet
-          return data
-        when XML::DocumentFragment
-          return data.children
-        when String
-          return fragment(data).children
-        when Document, XML::Attr
-          # unacceptable
-        when XML::Node
-          return data
-        end
-
-        raise ArgumentError, <<-EOERR
-Requires a Node, NodeSet or String argument, and cannot accept a #{data.class}.
-(You probably want to select a node from the Document with at() or search(), or create a new Node via Node.new().)
-        EOERR
-      end
-
       # @private
       IMPLIED_XPATH_CONTEXTS = [".//".freeze].freeze
 

data/lib/nokogiri/xml/parse_options.rb

@@ -73,6 +73,8 @@ module Nokogiri
       DEFAULT_XML  = RECOVER | NONET
       # the default options used for parsing HTML documents
       DEFAULT_HTML = RECOVER | NOERROR | NOWARNING | NONET
+      # the default options used for parsing XML schemas
+      DEFAULT_SCHEMA = NONET
 
       attr_accessor :options
       def initialize options = STRICT
@@ -107,6 +109,10 @@ module Nokogiri
         @options & RECOVER == STRICT
       end
 
+      def ==(other)
+        other.to_i == to_i
+      end
+
       alias :to_i :options
 
       def inspect

data/lib/nokogiri/xml/relax_ng.rb

@@ -5,8 +5,8 @@ module Nokogiri
       ###
       # Create a new Nokogiri::XML::RelaxNG document from +string_or_io+.
       # See Nokogiri::XML::RelaxNG for an example.
-      def RelaxNG string_or_io
-        RelaxNG.new(string_or_io)
+      def RelaxNG(string_or_io, options = ParseOptions::DEFAULT_SCHEMA)
+        RelaxNG.new(string_or_io, options)
       end
     end
 
@@ -27,6 +27,10 @@ module Nokogiri
     #   end
     #
     # The list of errors are Nokogiri::XML::SyntaxError objects.
+    #
+    # NOTE: RelaxNG input is always treated as TRUSTED documents, meaning that they will cause the
+    # underlying parsing libraries to access network resources. This is counter to Nokogiri's
+    # "untrusted by default" security policy, but is a limitation of the underlying libraries.
     class RelaxNG < Nokogiri::XML::Schema
     end
   end

data/lib/nokogiri/xml/schema.rb

@@ -5,8 +5,8 @@ module Nokogiri
       ###
       # Create a new Nokogiri::XML::Schema object using a +string_or_io+
       # object.
-      def Schema string_or_io
-        Schema.new(string_or_io)
+      def Schema(string_or_io, options = ParseOptions::DEFAULT_SCHEMA)
+        Schema.new(string_or_io, options)
       end
     end
 
@@ -27,15 +27,23 @@ module Nokogiri
     #   end
     #
     # The list of errors are Nokogiri::XML::SyntaxError objects.
+    #
+    # NOTE: As of v1.11.0, Schema treats inputs as UNTRUSTED by default, and so external entities
+    # are not resolved from the network (`http://` or `ftp://`). Previously, parsing treated
+    # documents as "trusted" by default which was counter to Nokogiri's "untrusted by default"
+    # security policy. If a document is trusted, then the caller may turn off the NONET option via
+    # the ParseOptions to re-enable external entity resolution over a network connection.
     class Schema
       # Errors while parsing the schema file
       attr_accessor :errors
+      # The Nokogiri::XML::ParseOptions used to parse the schema
+      attr_accessor :parse_options
 
       ###
       # Create a new Nokogiri::XML::Schema object using a +string_or_io+
       # object.
-      def self.new string_or_io
-        from_document Nokogiri::XML(string_or_io)
+      def self.new string_or_io, options = ParseOptions::DEFAULT_SCHEMA
+        from_document(Nokogiri::XML(string_or_io), options)
       end
 
       ###