nokogiri 1.11.0.rc3 → 1.11.3

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.3"
+end

data/lib/nokogiri/version/info.rb

@@ -0,0 +1,205 @@
+# 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 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
+
+    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?
+            #  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}"
+
+              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|
+          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
+  require "nokogiri/extension"
+
+  # More complete version information about libxml
+  VERSION_INFO = VersionInfo.instance.to_hash
+end

data/lib/nokogiri/xml/document.rb

@@ -1,4 +1,8 @@
+# coding: utf-8
 # frozen_string_literal: true
+
+require 'pathname'
+
 module Nokogiri
   module XML
     ##
@@ -10,11 +14,12 @@ module Nokogiri
     # Nokogiri::XML::Searchable#xpath
     #
     class Document < Nokogiri::XML::Node
-      # I'm ignoring unicode characters here.
-      # See http://www.w3.org/TR/REC-xml-names/#ns-decl for more details.
+      # See http://www.w3.org/TR/REC-xml-names/#ns-decl for more details. Note that we're not
+      # attempting to handle unicode characters partly because libxml2 doesn't handle unicode
+      # characters in NCNAMEs.
       NCNAME_START_CHAR = "A-Za-z_"
-      NCNAME_CHAR       = NCNAME_START_CHAR + "\\-.0-9"
-      NCNAME_RE         = /^xmlns(:[#{NCNAME_START_CHAR}][#{NCNAME_CHAR}]*)?$/
+      NCNAME_CHAR       = NCNAME_START_CHAR + "\\-\\.0-9"
+      NCNAME_RE         = /^xmlns(?::([#{NCNAME_START_CHAR}][#{NCNAME_CHAR}]*))?$/
 
       ##
       # Parse an XML file.
@@ -44,9 +49,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 +63,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?
@@ -69,6 +81,35 @@ module Nokogiri
         return doc
       end
 
+      ##
+      # @!method wrap(java_document)
+      # @!scope class
+      #
+      # Create a {Document} using an existing Java DOM document object.
+      #
+      # The returned {Document} shares the same underlying data structure as the Java object, so
+      # changes in one are reflected in the other.
+      #
+      # @param java_document [Java::OrgW3cDom::Document]
+      # @return [Nokogiri::XML::Document]
+      # @note This method is only available when running JRuby.
+      # @note The class +Java::OrgW3cDom::Document+ is also accessible as +org.w3c.dom.Document+.
+      # @see #to_java
+
+      ##
+      # @!method to_java()
+      #
+      # Returns the underlying Java DOM document object for the {Document}.
+      #
+      # The returned Java object shares the same underlying data structure as the {Document}, so
+      # changes in one are reflected in the other.
+      #
+      # @return [Java::OrgW3cDom::Document]
+      # @note This method is only available when running JRuby.
+      # @note The class +Java::OrgW3cDom::Document+ is also accessible as +org.w3c.dom.Document+.
+      # @see .wrap
+
+
       # A list of Nokogiri::XML::SyntaxError found when parsing a document
       attr_accessor :errors
 
@@ -78,33 +119,58 @@ module Nokogiri
       end
 
       ##
-      # Create an element with +name+, and optionally setting the content and attributes.
+      # Create a new +Element+ with +name+ sharing GC lifecycle with the document, optionally
+      # setting contents or attributes.
+      #
+      # Arguments may be passed to initialize the element:
+      # - a +Hash+ argument will be used to set attributes
+      # - a non-Hash object that responds to +#to_s+ will be used to set the new node's contents
+      #
+      # A block may be passed to mutate the node.
+      #
+      # @param name [String]
+      # @param contents_or_attrs [#to_s,Hash]
+      # @yieldparam node [Nokogiri::XML::Element]
+      # @return [Nokogiri::XML::Element]
+      #
+      # @example An empty element without attributes
+      #   doc.create_element("div")
+      #   # => <div></div>
       #
-      #   doc.create_element "div" # <div></div>
-      #   doc.create_element "div", :class => "container" # <div class='container'></div>
-      #   doc.create_element "div", "contents" # <div>contents</div>
-      #   doc.create_element "div", "contents", :class => "container" # <div class='container'>contents</div>
-      #   doc.create_element "div" { |node| node['class'] = "container" } # <div class='container'></div>
+      # @example An element with contents
+      #   doc.create_element("div", "contents")
+      #   # => <div>contents</div>
       #
-      def create_element name, *args, &block
+      # @example An element with attributes
+      #   doc.create_element("div", {"class" => "container"})
+      #   # => <div class='container'></div>
+      #
+      # @example An element with contents and attributes
+      #   doc.create_element("div", "contents", {"class" => "container"})
+      #   # => <div class='container'>contents</div>
+      #
+      # @example Passing a block to mutate the element
+      #   doc.create_element("div") { |node| node["class"] = "blue" if before_noon? }
+      #
+      def create_element(name, *contents_or_attrs, &block)
         elm = Nokogiri::XML::Element.new(name, self, &block)
-        args.each do |arg|
+        contents_or_attrs.each do |arg|
           case arg
           when Hash
-            arg.each { |k,v|
+            arg.each do |k, v|
               key = k.to_s
               if key =~ NCNAME_RE
-                ns_name = key.split(":", 2)[1]
-                elm.add_namespace_definition ns_name, v
+                ns_name = Regexp.last_match(1)
+                elm.add_namespace_definition(ns_name, v)
               else
                 elm[k.to_s] = v.to_s
               end
-            }
+            end
           else
             elm.content = arg
           end
         end
-        if ns = elm.namespace_definitions.find { |n| n.prefix.nil? or n.prefix == '' }
+        if ns = elm.namespace_definitions.find { |n| n.prefix.nil? || (n.prefix == '') }
           elm.namespace = ns
         end
         elm
@@ -252,24 +318,14 @@ module Nokogiri
       end
       alias :<< :add_child
 
-      ##
-      # +JRuby+
-      # Wraps Java's org.w3c.dom.document and returns Nokogiri::XML::Document
-      def self.wrap(document) end if false # native-ext provides Document.wrap
-
-      ##
-      # +JRuby+
-      # Returns Java's org.w3c.dom.document of this Document.
-      def to_java; end if false # JRuby provides #to_java
-
       private
+
       def self.empty_doc? string_or_io
         string_or_io.nil? ||
           (string_or_io.respond_to?(:empty?) && string_or_io.empty?) ||
           (string_or_io.respond_to?(:eof?) && string_or_io.eof?)
       end
 
-      # @private
       IMPLIED_XPATH_CONTEXTS = [ '//'.freeze ].freeze # :nodoc:
 
       def inspect_attributes

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

@@ -5,64 +5,54 @@ require "nokogiri/xml/node/save_options"
 
 module Nokogiri
   module XML
-    ####
-    # Nokogiri::XML::Node is your window to the fun filled world of dealing
-    # with XML and HTML tags.  A Nokogiri::XML::Node may be treated similarly
-    # to a hash with regard to attributes.  For example (from irb):
+    ##
+    # {Nokogiri::XML::Node} is your window to the fun filled world of dealing with XML and HTML
+    # tags. A {Nokogiri::XML::Node} may be treated similarly to a hash with regard to attributes. For
+    # example:
     #
-    #   irb(main):004:0> node
-    #   => <a href="#foo" id="link">link</a>
-    #   irb(main):005:0> node['href']
-    #   => "#foo"
-    #   irb(main):006:0> node.keys
-    #   => ["href", "id"]
-    #   irb(main):007:0> node.values
-    #   => ["#foo", "link"]
-    #   irb(main):008:0> node['class'] = 'green'
-    #   => "green"
-    #   irb(main):009:0> node
-    #   => <a href="#foo" id="link" class="green">link</a>
-    #   irb(main):010:0>
+    #   node = Nokogiri::XML::DocumentFragment.parse("<a href='#foo' id='link'>link</a>").at_css("a")
+    #   node.to_html # => "<a href=\"#foo\" id=\"link\">link</a>"
+    #   node['href'] # => "#foo"
+    #   node.keys # => ["href", "id"]
+    #   node.values # => ["#foo", "link"]
+    #   node['class'] = 'green' # => "green"
+    #   node.to_html # => "<a href=\"#foo\" id=\"link\" class=\"green\">link</a>"
     #
-    # See Nokogiri::XML::Node#[] and Nokogiri::XML#[]= for more information.
+    # See the method group entitled "Working With Node Attributes" for the full set of methods.
     #
-    # Nokogiri::XML::Node also has methods that let you move around your
+    # {Nokogiri::XML::Node} also has methods that let you move around your
     # tree.  For navigating your tree, see:
     #
-    # * Nokogiri::XML::Node#parent
-    # * Nokogiri::XML::Node#children
-    # * Nokogiri::XML::Node#next
-    # * Nokogiri::XML::Node#previous
-    #
+    # * {#parent}
+    # * {#children}
+    # * {#next}
+    # * {#previous}
     #
     # When printing or otherwise emitting a document or a node (and
     # its subtree), there are a few methods you might want to use:
     #
-    # * content, text, inner_text, to_str: emit plaintext
-    #
-    #   These methods will all emit the plaintext version of your
-    #   document, meaning that entities will be replaced (e.g., "&lt;"
-    #   will be replaced with "<"), meaning that any sanitizing will
-    #   likely be un-done in the output.
+    # * {#content}, {#text}, {#inner_text}, {#to_str}: These methods will all <b>emit plaintext</b>,
+    #   meaning that entities will be replaced (e.g., "&lt;" will be replaced with "<"), meaning
+    #   that any sanitizing will likely be un-done in the output.
     #
-    # * to_s, to_xml, to_html, inner_html: emit well-formed markup
+    # * {#to_s}, {#to_xml}, {#to_html}, {#inner_html}: These methods will all <b>emit
+    #   properly-escaped markup</b>, meaning that it's suitable for consumption by browsers,
+    #   parsers, etc.
     #
-    #   These methods will all emit properly-escaped markup, meaning
-    #   that it's suitable for consumption by browsers, parsers, etc.
+    # You may search this node's subtree using {#xpath} and {#css}
     #
-    # You may search this node's subtree using Searchable#xpath and Searchable#css
     class Node
       include Nokogiri::XML::PP::Node
       include Nokogiri::XML::Searchable
       include Enumerable
 
-      # Element node type, see Nokogiri::XML::Node#element?
+      # Element node type, see {Nokogiri::XML::Node#element?}
       ELEMENT_NODE = 1
       # Attribute node type
       ATTRIBUTE_NODE = 2
-      # Text node type, see Nokogiri::XML::Node#text?
+      # Text node type, see {Nokogiri::XML::Node#text?}
       TEXT_NODE = 3
-      # CDATA node type, see Nokogiri::XML::Node#cdata?
+      # CDATA node type, see {Nokogiri::XML::Node#cdata?}
       CDATA_SECTION_NODE = 4
       # Entity reference node type
       ENTITY_REF_NODE = 5
@@ -70,9 +60,9 @@ module Nokogiri
       ENTITY_NODE = 6
       # PI node type
       PI_NODE = 7
-      # Comment node type, see Nokogiri::XML::Node#comment?
+      # Comment node type, see {Nokogiri::XML::Node#comment?}
       COMMENT_NODE = 8
-      # Document node type, see Nokogiri::XML::Node#xml?
+      # Document node type, see {Nokogiri::XML::Node#xml?}
       DOCUMENT_NODE = 9
       # Document type node type
       DOCUMENT_TYPE_NODE = 10
@@ -80,7 +70,7 @@ module Nokogiri
       DOCUMENT_FRAG_NODE = 11
       # Notation node type
       NOTATION_NODE = 12
-      # HTML document node type, see Nokogiri::XML::Node#html?
+      # HTML document node type, see {Nokogiri::XML::Node#html?}
       HTML_DOCUMENT_NODE = 13
       # DTD node type
       DTD_NODE = 14
@@ -99,8 +89,15 @@ module Nokogiri
       # DOCB document node type
       DOCB_DOCUMENT_NODE = 21
 
-      def initialize(name, document) # :nodoc:
-        # ... Ya.  This is empty on purpose.
+      ##
+      # Create a new node with +name+ sharing GC lifecycle with +document+.
+      # @param name [String]
+      # @param document [Nokogiri::XML::Document]
+      # @yieldparam node [Nokogiri::XML::Node]
+      # @return [Nokogiri::XML::Node]
+      # @see Nokogiri::XML::Node.new
+      def initialize(name, document)
+        # This is intentionally empty.
       end
 
       ###
@@ -267,6 +264,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 +277,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 +818,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 +1144,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 +1180,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 +1222,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