nokogiri 1.11.0.rc1-x64-mingw32 → 1.11.0.rc2-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ce7fb87f24cd35d7a9a649cabe5cc1ce48d5e8f67411584911223bfe53935c0
-  data.tar.gz: '09b812276bd345594649f6c1c1fc840b26c4402b384983f9f9e014084900cac1'
+  metadata.gz: 6e766ba6d8adc09585de3696e3517001d17766fad516d68f28e1ffb4396f3df3
+  data.tar.gz: 43d58540e8e3311264f99b6416e005c30066d8375cd8f406e4938732642bcaa8
 SHA512:
-  metadata.gz: 8684e860a4e799e9806184b2366f2fb7742428323849a3f66012f9e0145a55d945c3f71df208e67d22c3d871aff8f30fe81f2621ac50ab3014c45f1284ed2ca0
-  data.tar.gz: f26d82e26577abff0f6da8547a14e570452b7a6b15ba17925f9dbffa349c15cee561de9c2a90058e856ccf4cde3b1ebb69b96849727e144fc08f2b1541f91473
+  metadata.gz: f3daad577b52a86f8b7c0906edb49de90933ab6cccabfef7b3b76e849f602e2216404458589df3e7a00d8f3afc966c0219b95c879920bfa7767e34c74fa56239
+  data.tar.gz: ba56fdff35cd1c313161128ae09f3d1e7c7a9a222bb1beea47e3140c7e91dd1fa52f66c778dc2fe5c04483857f4f481a45c6fae23769f10d9556dbc445c9629d

data/README.md

@@ -11,7 +11,7 @@ or CSS3 selectors.
 
 * https://nokogiri.org
 * [Installation Help](https://nokogiri.org/tutorials/installing_nokogiri.html)
-* [Tutorials](https://nokogiri.org)
+* [Tutorials](https://nokogiri.org/tutorials/toc.html)
 * [Cheat Sheet](https://github.com/sparklemotion/nokogiri/wiki/Cheat-sheet)
 * [GitHub](https://github.com/sparklemotion/nokogiri)
 * [Mailing List](https://groups.google.com/group/nokogiri-talk)

data/ext/nokogiri/extconf.rb

@@ -24,6 +24,10 @@ def openbsd?
   RbConfig::CONFIG['target_os'] =~ /openbsd/
 end
 
+def aix?
+  RbConfig::CONFIG["target_os"] =~ /aix/
+end
+
 def nix?
   ! (windows? || solaris? || darwin?)
 end
@@ -419,7 +423,7 @@ if windows?
   $CFLAGS << " -DXP_WIN -DXP_WIN32 -DUSE_INCLUDED_VASPRINTF"
 end
 
-if solaris?
+if solaris? || aix?
   $CFLAGS << " -DUSE_INCLUDED_VASPRINTF"
 end
 
@@ -466,7 +470,7 @@ else
   # The gem version constraint in the Rakefile is not respected at install time.
   # Keep this version in sync with the one in the Rakefile !
   require 'rubygems'
-  gem 'mini_portile2', '~> 2.4.0'
+  gem 'mini_portile2', '~> 2.5.0'
   require 'mini_portile2'
   message "Using mini_portile version #{MiniPortile::VERSION}\n"
 

data/ext/nokogiri/nokogiri.h

@@ -1,6 +1,18 @@
 #ifndef NOKOGIRI_NATIVE
 #define NOKOGIRI_NATIVE
 
+#if _MSC_VER
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif /* WIN32_LEAN_AND_MEAN */
+#ifndef WIN32
+#define WIN32
+#endif /* WIN32 */
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+#endif
+
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>

data/ext/nokogiri/xml_reader.c

@@ -28,35 +28,24 @@ static int has_attributes(xmlTextReaderPtr reader)
 static void Nokogiri_xml_node_namespaces(xmlNodePtr node, VALUE attr_hash)
 {
   xmlNsPtr ns;
-  static char buffer[XMLNS_BUFFER_LEN] ;
-  char *key ;
-  size_t keylen ;
+  VALUE key;
 
   if (node->type != XML_ELEMENT_NODE) return ;
 
   ns = node->nsDef;
   while (ns != NULL) {
 
-    keylen = XMLNS_PREFIX_LEN + (ns->prefix ? (strlen((const char*)ns->prefix) + 1) : 0) ;
-    if (keylen > XMLNS_BUFFER_LEN) {
-      key = (char*)malloc(keylen) ;
-    } else {
-      key = buffer ;
-    }
-
+    key = rb_enc_str_new_cstr(XMLNS_PREFIX, rb_utf8_encoding());
     if (ns->prefix) {
-      sprintf(key, "%s:%s", XMLNS_PREFIX, ns->prefix);
-    } else {
-      sprintf(key, "%s", XMLNS_PREFIX);
+      rb_str_cat_cstr(key, ":");
+      rb_str_cat_cstr(key, (const char*)ns->prefix);
     }
 
+    key = rb_str_conv_enc(key, rb_utf8_encoding(), rb_default_internal_encoding());
     rb_hash_aset(attr_hash,
-        NOKOGIRI_STR_NEW2(key),
+        key,
         (ns->href ? NOKOGIRI_STR_NEW2(ns->href) : Qnil)
     );
-    if (key != buffer) {
-      free(key);
-    }
     ns = ns->next ;
   }
 }

data/ext/nokogiri/xml_schema.c

@@ -133,6 +133,31 @@ static VALUE read_memory(VALUE klass, VALUE content)
   return rb_schema;
 }
 
+/* Schema creation will remove and deallocate "blank" nodes.
+ * If those blank nodes have been exposed to Ruby, they could get freed
+ * out from under the VALUE pointer.  This function checks to see if any of
+ * those nodes have been exposed to Ruby, and if so we should raise an exception.
+ */
+static int has_blank_nodes_p(VALUE cache)
+{
+    long i;
+
+    if (NIL_P(cache)) {
+        return 0;
+    }
+
+    for (i = 0; i < RARRAY_LEN(cache); i++) {
+        xmlNodePtr node;
+        VALUE element = rb_ary_entry(cache, i);
+        Data_Get_Struct(element, xmlNode, node);
+        if (xmlIsBlankNode(node)) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
 /*
  * call-seq:
  *  from_document(doc)
@@ -152,6 +177,10 @@ static VALUE from_document(VALUE klass, VALUE document)
   /* In case someone passes us a node. ugh. */
   doc = doc->doc;
 
+  if (has_blank_nodes_p(DOC_NODE_CACHE(doc))) {
+    rb_raise(rb_eArgError, "Creating a schema from a document that has blank nodes exposed to Ruby is dangerous");
+  }
+
   ctx = xmlSchemaNewDocParserCtxt(doc);
 
   errors = rb_ary_new();

data/lib/nokogiri/css/parser_extras.rb

@@ -1,64 +1,66 @@
 # frozen_string_literal: true
-require 'thread'
+require "thread"
 
 module Nokogiri
   module CSS
     class Parser < Racc::Parser
-      @cache_on = true
-      @cache    = {}
-      @mutex    = Mutex.new
+      CACHE_SWITCH_NAME = :nokogiri_css_parser_cache_is_off
+
+      @cache = {}
+      @mutex = Mutex.new
 
       class << self
-        # Turn on CSS parse caching
-        attr_accessor :cache_on
-        alias :cache_on? :cache_on
-        alias :set_cache :cache_on=
+        # Return a thread-local boolean indicating whether the CSS-to-XPath cache is active. (Default is `true`.)
+        def cache_on?
+          !Thread.current[CACHE_SWITCH_NAME]
+        end
+
+        # Set a thread-local boolean to turn cacheing on and off. Truthy values turn the cache on, falsey values turn the cache off.
+        def set_cache(value)
+          Thread.current[CACHE_SWITCH_NAME] = !value
+        end
 
         # Get the css selector in +string+ from the cache
-        def [] string
-          return unless @cache_on
+        def [](string)
+          return unless cache_on?
           @mutex.synchronize { @cache[string] }
         end
 
         # Set the css selector in +string+ in the cache to +value+
-        def []= string, value
-          return value unless @cache_on
+        def []=(string, value)
+          return value unless cache_on?
           @mutex.synchronize { @cache[string] = value }
         end
 
         # Clear the cache
-        def clear_cache
-          @mutex.synchronize { @cache = {} }
+        def clear_cache(create_new_object = false)
+          @mutex.synchronize do
+            if create_new_object
+              @cache = {}
+            else
+              @cache.clear
+            end
+          end
         end
 
         # Execute +block+ without cache
-        def without_cache &block
-          tmp = @cache_on
-          @cache_on = false
+        def without_cache(&block)
+          original_cache_setting = cache_on?
+          set_cache false
           block.call
-          @cache_on = tmp
-        end
-
-        ###
-        # Parse this CSS selector in +selector+.  Returns an AST.
-        def parse selector
-          @warned ||= false
-          unless @warned
-            $stderr.puts('Nokogiri::CSS::Parser.parse is deprecated, call Nokogiri::CSS.parse(), this will be removed August 1st or version 1.4.0 (whichever is first)')
-            @warned = true
-          end
-          new.parse selector
+        ensure
+          set_cache original_cache_setting
         end
       end
 
       # Create a new CSS parser with respect to +namespaces+
-      def initialize namespaces = {}
-        @tokenizer  = Tokenizer.new
+      def initialize(namespaces = {})
+        @tokenizer = Tokenizer.new
         @namespaces = namespaces
         super()
       end
 
-      def parse string
+      def parse(string)
         @tokenizer.scan_setup string
         do_parse
       end
@@ -68,14 +70,14 @@ module Nokogiri
       end
 
       # Get the xpath for +string+ using +options+
-      def xpath_for string, options={}
+      def xpath_for(string, options = {})
         key = "#{string}#{options[:ns]}#{options[:prefix]}"
         v = self.class[key]
         return v if v
 
         args = [
-          options[:prefix] || '//',
-          options[:visitor] || XPathVisitor.new
+          options[:prefix] || "//",
+          options[:visitor] || XPathVisitor.new,
         ]
         self.class[key] = parse(string).map { |ast|
           ast.to_xpath(*args)
@@ -83,7 +85,7 @@ module Nokogiri
       end
 
       # On CSS parser error, raise an exception
-      def on_error error_token_id, error_value, value_stack
+      def on_error(error_token_id, error_value, value_stack)
         after = value_stack.compact.last
         raise SyntaxError.new("unexpected '#{error_value}' after '#{after}'")
       end

data/lib/nokogiri/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module Nokogiri
   # The version of Nokogiri you are using
-  VERSION = "1.11.0.rc1"
+  VERSION = "1.11.0.rc2"
 
   class VersionInfo # :nodoc:
     def jruby?
@@ -133,7 +133,7 @@ module Nokogiri
     VersionInfo.instance.jruby?
   end
 
-  # Ensure constants used in this file are loaded
+  # Ensure constants used in this file are loaded - see #1896
   if Nokogiri.jruby?
     require "nokogiri/jruby/dependencies"
   end

data/lib/nokogiri/xml/node.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 # frozen_string_literal: true
-require 'stringio'
-require 'nokogiri/xml/node/save_options'
+require "stringio"
+require "nokogiri/xml/node/save_options"
 
 module Nokogiri
   module XML
@@ -57,49 +57,49 @@ module Nokogiri
       include Enumerable
 
       # Element node type, see Nokogiri::XML::Node#element?
-      ELEMENT_NODE =       1
+      ELEMENT_NODE = 1
       # Attribute node type
-      ATTRIBUTE_NODE =     2
+      ATTRIBUTE_NODE = 2
       # Text node type, see Nokogiri::XML::Node#text?
-      TEXT_NODE =          3
+      TEXT_NODE = 3
       # CDATA node type, see Nokogiri::XML::Node#cdata?
       CDATA_SECTION_NODE = 4
       # Entity reference node type
-      ENTITY_REF_NODE =    5
+      ENTITY_REF_NODE = 5
       # Entity node type
-      ENTITY_NODE =        6
+      ENTITY_NODE = 6
       # PI node type
-      PI_NODE =            7
+      PI_NODE = 7
       # Comment node type, see Nokogiri::XML::Node#comment?
-      COMMENT_NODE =       8
+      COMMENT_NODE = 8
       # Document node type, see Nokogiri::XML::Node#xml?
-      DOCUMENT_NODE =      9
+      DOCUMENT_NODE = 9
       # Document type node type
       DOCUMENT_TYPE_NODE = 10
       # Document fragment node type
       DOCUMENT_FRAG_NODE = 11
       # Notation node type
-      NOTATION_NODE =      12
+      NOTATION_NODE = 12
       # HTML document node type, see Nokogiri::XML::Node#html?
       HTML_DOCUMENT_NODE = 13
       # DTD node type
-      DTD_NODE =           14
+      DTD_NODE = 14
       # Element declaration type
-      ELEMENT_DECL =       15
+      ELEMENT_DECL = 15
       # Attribute declaration type
-      ATTRIBUTE_DECL =     16
+      ATTRIBUTE_DECL = 16
       # Entity declaration type
-      ENTITY_DECL =        17
+      ENTITY_DECL = 17
       # Namespace declaration type
-      NAMESPACE_DECL =     18
+      NAMESPACE_DECL = 18
       # XInclude start type
-      XINCLUDE_START =     19
+      XINCLUDE_START = 19
       # XInclude end type
-      XINCLUDE_END =       20
+      XINCLUDE_END = 20
       # DOCB document node type
       DOCB_DOCUMENT_NODE = 21
 
-      def initialize name, document # :nodoc:
+      def initialize(name, document) # :nodoc:
         # ... Ya.  This is empty on purpose.
       end
 
@@ -109,24 +109,18 @@ module Nokogiri
         document.decorate(self)
       end
 
+      # @!group Searching via XPath or CSS Queries
+
       ###
       # Search this node's immediate children using CSS selector +selector+
-      def > selector
+      def >(selector)
         ns = document.root.namespaces
         xpath CSS.xpath_for(selector, :prefix => "./", :ns => ns).first
       end
 
-      ###
-      # Get the attribute value for the attribute +name+
-      def [] name
-        get(name.to_s)
-      end
+      # @!endgroup
 
-      ###
-      # Set the attribute value for the attribute +name+ to +value+
-      def []= name, value
-        set name.to_s, value.to_s
-      end
+      # @!group Manipulating Document Structure
 
       ###
       # Add +node_or_tags+ as a child of this Node.
@@ -135,7 +129,7 @@ module Nokogiri
       # Returns the reparented node (if +node_or_tags+ is a Node), or NodeSet (if +node_or_tags+ is a DocumentFragment, NodeSet, or string).
       #
       # Also see related method +<<+.
-      def add_child node_or_tags
+      def add_child(node_or_tags)
         node_or_tags = coerce(node_or_tags)
         if node_or_tags.is_a?(XML::NodeSet)
           node_or_tags.each { |n| add_child_node_and_reparent_attrs n }
@@ -152,7 +146,7 @@ module Nokogiri
       # Returns the reparented node (if +node_or_tags+ is a Node), or NodeSet (if +node_or_tags+ is a DocumentFragment, NodeSet, or string).
       #
       # Also see related method +add_child+.
-      def prepend_child node_or_tags
+      def prepend_child(node_or_tags)
         if first = children.first
           # Mimic the error add_child would raise.
           raise RuntimeError, "Document already has a root node" if document? && !(node_or_tags.comment? || node_or_tags.processing_instruction?)
@@ -162,7 +156,6 @@ module Nokogiri
         end
       end
 
-
       ###
       # Add html around this node
       #
@@ -181,7 +174,7 @@ module Nokogiri
       # Returns self, to support chaining of calls (e.g., root << child1 << child2)
       #
       # Also see related method +add_child+.
-      def << node_or_tags
+      def <<(node_or_tags)
         add_child node_or_tags
         self
       end
@@ -193,7 +186,7 @@ module Nokogiri
       # Returns the reparented node (if +node_or_tags+ is a Node), or NodeSet (if +node_or_tags+ is a DocumentFragment, NodeSet, or string).
       #
       # Also see related method +before+.
-      def add_previous_sibling node_or_tags
+      def add_previous_sibling(node_or_tags)
         raise ArgumentError.new("A document may not have multiple root nodes.") if (parent && parent.document?) && !(node_or_tags.comment? || node_or_tags.processing_instruction?)
 
         add_sibling :previous, node_or_tags
@@ -206,7 +199,7 @@ module Nokogiri
       # Returns the reparented node (if +node_or_tags+ is a Node), or NodeSet (if +node_or_tags+ is a DocumentFragment, NodeSet, or string).
       #
       # Also see related method +after+.
-      def add_next_sibling node_or_tags
+      def add_next_sibling(node_or_tags)
         raise ArgumentError.new("A document may not have multiple root nodes.") if (parent && parent.document?) && !(node_or_tags.comment? || node_or_tags.processing_instruction?)
 
         add_sibling :next, node_or_tags
@@ -219,7 +212,7 @@ module Nokogiri
       # Returns self, to support chaining of calls.
       #
       # Also see related method +add_previous_sibling+.
-      def before node_or_tags
+      def before(node_or_tags)
         add_previous_sibling node_or_tags
         self
       end
@@ -231,7 +224,7 @@ module Nokogiri
       # Returns self, to support chaining of calls.
       #
       # Also see related method +add_next_sibling+.
-      def after node_or_tags
+      def after(node_or_tags)
         add_next_sibling node_or_tags
         self
       end
@@ -243,7 +236,7 @@ module Nokogiri
       # Returns self.
       #
       # Also see related method +children=+
-      def inner_html= node_or_tags
+      def inner_html=(node_or_tags)
         self.children = node_or_tags
         self
       end
@@ -255,7 +248,7 @@ module Nokogiri
       # Returns the reparented node (if +node_or_tags+ is a Node), or NodeSet (if +node_or_tags+ is a DocumentFragment, NodeSet, or string).
       #
       # Also see related method +inner_html=+
-      def children= node_or_tags
+      def children=(node_or_tags)
         node_or_tags = coerce(node_or_tags)
         children.unlink
         if node_or_tags.is_a?(XML::NodeSet)
@@ -273,13 +266,13 @@ module Nokogiri
       # Returns the reparented node (if +node_or_tags+ is a Node), or NodeSet (if +node_or_tags+ is a DocumentFragment, NodeSet, or string).
       #
       # Also see related method +swap+.
-      def replace node_or_tags
+      def replace(node_or_tags)
         # 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
         # so I can't tell if this is bug in libxml or not. issue #775.
         if text?
-          replacee = Nokogiri::XML::Node.new 'dummy', document
+          replacee = Nokogiri::XML::Node.new "dummy", document
           add_previous_sibling_node replacee
           unlink
           return replacee.replace node_or_tags
@@ -303,33 +296,98 @@ module Nokogiri
       # Returns self, to support chaining of calls.
       #
       # Also see related method +replace+.
-      def swap node_or_tags
+      def swap(node_or_tags)
         replace node_or_tags
         self
       end
 
-      alias :next           :next_sibling
-      alias :previous       :previous_sibling
+      ####
+      # Set the Node's content to a Text node containing +string+. The string gets XML escaped, not interpreted as markup.
+      def content=(string)
+        self.native_content = encode_special_chars(string.to_s)
+      end
 
-      # :stopdoc:
-      # HACK: This is to work around an RDoc bug
-      alias :next=          :add_next_sibling
-      # :startdoc:
+      ###
+      # Set the parent Node for this Node
+      def parent=(parent_node)
+        parent_node.add_child(self)
+        parent_node
+      end
 
-      alias :previous=      :add_previous_sibling
-      alias :remove         :unlink
-      alias :get_attribute  :[]
-      alias :attr           :[]
-      alias :set_attribute  :[]=
-      alias :text           :content
-      alias :inner_text     :content
-      alias :has_attribute? :key?
-      alias :name           :node_name
-      alias :name=          :node_name=
-      alias :type           :node_type
-      alias :to_str         :text
-      alias :clone          :dup
-      alias :elements       :element_children
+      ###
+      # Adds a default namespace supplied as a string +url+ href, to self.
+      # The consequence is as an xmlns attribute with supplied argument were
+      # present in parsed XML.  A default namespace set with this method will
+      # now show up in #attributes, but when this node is serialized to XML an
+      # "xmlns" attribute will appear. See also #namespace and #namespace=
+      def default_namespace=(url)
+        add_namespace_definition(nil, url)
+      end
+
+      ###
+      # Set the default namespace on this node (as would be defined with an
+      # "xmlns=" attribute in XML source), as a Namespace object +ns+. Note that
+      # a Namespace added this way will NOT be serialized as an xmlns attribute
+      # for this node. You probably want #default_namespace= instead, or perhaps
+      # #add_namespace_definition with a nil prefix argument.
+      def namespace=(ns)
+        return set_namespace(ns) unless ns
+
+        unless Nokogiri::XML::Namespace === ns
+          raise TypeError, "#{ns.class} can't be coerced into Nokogiri::XML::Namespace"
+        end
+        if ns.document != document
+          raise ArgumentError, "namespace must be declared on the same document"
+        end
+
+        set_namespace ns
+      end
+
+      ###
+      # Do xinclude substitution on the subtree below node. If given a block, a
+      # Nokogiri::XML::ParseOptions object initialized from +options+, will be
+      # passed to it, allowing more convenient modification of the parser options.
+      def do_xinclude(options = XML::ParseOptions::DEFAULT_XML)
+        options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
+
+        # give options to user
+        yield options if block_given?
+
+        # call c extension
+        process_xincludes(options.to_i)
+      end
+
+      alias :next :next_sibling
+      alias :previous :previous_sibling
+      alias :next= :add_next_sibling
+      alias :previous= :add_previous_sibling
+      alias :remove :unlink
+      alias :name= :node_name=
+      alias :add_namespace :add_namespace_definition
+
+      # @!endgroup
+
+      alias :text :content
+      alias :inner_text :content
+      alias :name :node_name
+      alias :type :node_type
+      alias :to_str :text
+      alias :clone :dup
+      alias :elements :element_children
+
+      # @!group Working With Node Attributes
+
+      ###
+      # Get the attribute value for the attribute +name+
+      def [](name)
+        get(name.to_s)
+      end
+
+      ###
+      # Set the attribute value for the attribute +name+ to +value+
+      def []=(name, value)
+        set name.to_s, value.to_s
+      end
 
       ####
       # Returns a hash containing the node's attributes.  The key is
@@ -370,82 +428,366 @@ module Nokogiri
       end
 
       ###
-      # Get the list of class names of this Node, without
-      # deduplication or sorting.
+      # Remove the attribute named +name+
+      def remove_attribute(name)
+        attr = attributes[name].remove if key? name
+        clear_xpath_context if Nokogiri.jruby?
+        attr
+      end
+
+      # Get the CSS class names of a Node.
+      #
+      # This is a convenience function and is equivalent to:
+      #   node.kwattr_values("class")
+      #
+      # @see #kwattr_values
+      # @see #add_class
+      # @see #append_class
+      # @see #remove_class
+      #
+      # @return [Array<String>]
+      #
+      #   The CSS classes present in the Node's +class+ attribute. If
+      #   the attribute is empty or non-existent, the return value is
+      #   an empty array.
+      #
+      # @example
+      #   node         # => <div class="section title header"></div>
+      #   node.classes # => ["section", "title", "header"]
+      #
       def classes
-        self['class'].to_s.scan(/\S+/)
+        kwattr_values("class")
       end
 
-      ###
-      # Add +name+ to the "class" attribute value of this Node and
-      # return self.  If the value is already in the current value, it
-      # is not added.  If no "class" attribute exists yet, one is
-      # created with the given value.
+      # Ensure HTML CSS classes are present on a +Node+. Any CSS
+      # classes in +names+ that already exist in the +Node+'s +class+
+      # attribute are _not_ added. Note that any existing duplicates
+      # in the +class+ attribute are not removed. Compare with
+      # {#append_class}.
+      #
+      # This is a convenience function and is equivalent to:
+      #   node.kwattr_add("class", names)
+      #
+      # @see #kwattr_add
+      # @see #classes
+      # @see #append_class
+      # @see #remove_class
+      #
+      # @param names [String, Array<String>]
+      #
+      #   CSS class names to be added to the Node's +class+
+      #   attribute. May be a string containing whitespace-delimited
+      #   names, or an Array of String names. Any class names already
+      #   present will not be added. Any class names not present will
+      #   be added. If no +class+ attribute exists, one is created.
+      #
+      # @return [Node] Returns +self+ for ease of chaining method calls.
+      #
+      # @example Ensure that a +Node+ has CSS class "section"
+      #   node                      # => <div></div>
+      #   node.add_class("section") # => <div class="section"></div>
+      #   node.add_class("section") # => <div class="section"></div> # duplicate not added
+      #
+      # @example Ensure that a +Node+ has CSS classes "section" and "header", via a String argument.
+      #   node                             # => <div class="section section"></div>
+      #   node.add_class("section header") # => <div class="section section header"></div>
+      #   # Note that the CSS class "section" is not added because it is already present.
+      #   # Note also that the pre-existing duplicate CSS class "section" is not removed.
+      #
+      # @example Ensure that a +Node+ has CSS classes "section" and "header", via an Array argument.
+      #   node                                  # => <div></div>
+      #   node.add_class(["section", "header"]) # => <div class="section header"></div>
+      #
+      def add_class(names)
+        kwattr_add("class", names)
+      end
+
+      # Add HTML CSS classes to a +Node+, regardless of
+      # duplication. Compare with {#add_class}.
+      #
+      # This is a convenience function and is equivalent to:
+      #   node.kwattr_append("class", names)
+      #
+      # @see #kwattr_append
+      # @see #classes
+      # @see #add_class
+      # @see #remove_class
+      #
+      # @param names [String, Array<String>]
+      #
+      #   CSS class names to be appended to the Node's +class+
+      #   attribute. May be a string containing whitespace-delimited
+      #   names, or an Array of String names. All class names passed
+      #   in will be appended to the +class+ attribute even if they
+      #   are already present in the attribute value. If no +class+
+      #   attribute exists, one is created.
+      #
+      # @return [Node] Returns +self+ for ease of chaining method calls.
+      #
+      # @example Append "section" to a +Node+'s CSS +class+ attriubute
+      #   node                         # => <div></div>
+      #   node.append_class("section") # => <div class="section"></div>
+      #   node.append_class("section") # => <div class="section section"></div> # duplicate added!
+      #
+      # @example Append "section" and "header" to a +Node+'s CSS +class+ attribute, via a String argument.
+      #   node                                # => <div class="section section"></div>
+      #   node.append_class("section header") # => <div class="section section section header"></div>
+      #   # Note that the CSS class "section" is appended even though it is already present.
+      #
+      # @example Append "section" and "header" to a +Node+'s CSS +class+ attribute, via an Array argument.
+      #   node                                     # => <div></div>
+      #   node.append_class(["section", "header"]) # => <div class="section header"></div>
+      #   node.append_class(["section", "header"]) # => <div class="section header section header"></div>
+      #
+      def append_class(names)
+        kwattr_append("class", names)
+      end
+
+      # Remove HTML CSS classes from a +Node+. Any CSS classes in +names+ that
+      # exist in the +Node+'s +class+ attribute are removed, including any
+      # multiple entries.
+      #
+      # If no CSS classes remain after this operation, or if +names+ is
+      # +nil+, the +class+ attribute is deleted from the node.
+      #
+      # This is a convenience function and is equivalent to:
+      #   node.kwattr_remove("class", names)
+      #
+      # @see #kwattr_remove
+      # @see #classes
+      # @see #add_class
+      # @see #append_class
+      #
+      # @param names [String, Array<String>]
+      #
+      #   CSS class names to be removed from the Node's +class+ attribute. May
+      #   be a string containing whitespace-delimited names, or an Array of
+      #   String names. Any class names already present will be removed. If no
+      #   CSS classes remain, the +class+ attribute is deleted.
+      #
+      # @return [Node] Returns +self+ for ease of chaining method calls.
+      #
+      # @example
+      #   node                         # => <div class="section header"></div>
+      #   node.remove_class("section") # => <div class="header"></div>
+      #   node.remove_class("header")  # => <div></div> # attribute is deleted when empty
+      #
+      def remove_class(names = nil)
+        kwattr_remove("class", names)
+      end
+
+      # Retrieve values from a keyword attribute of a Node.
+      #
+      # A "keyword attribute" is a node attribute that contains a set
+      # of space-delimited values. Perhaps the most familiar example
+      # of this is the HTML +class+ attribute used to contain CSS
+      # classes. But other keyword attributes exist, for instance
+      # [`rel`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel).
+      #
+      # @see #classes
+      # @see #kwattr_add
+      # @see #kwattr_append
+      # @see #kwattr_remove
+      #
+      # @param attribute_name [String] The name of the keyword attribute to be inspected.
+      #
+      # @return [Array<String>]
+      #
+      #   The values present in the Node's +attribute_name+
+      #   attribute. If the attribute is empty or non-existent, the
+      #   return value is an empty array.
       #
-      # More than one class may be added at a time, separated by a
-      # space.
-      def add_class name
-        names = classes
-        self['class'] = (names + (name.scan(/\S+/) - names)).join(' ')
+      # @example
+      #   node                      # => <a rel="nofollow noopener external">link</a>
+      #   node.kwattr_values("rel") # => ["nofollow", "noopener", "external"]
+      #
+      # @since v1.11.0
+      #
+      def kwattr_values(attribute_name)
+        keywordify(get_attribute(attribute_name) || [])
+      end
+
+      # Ensure that values are present in a keyword attribute.
+      #
+      # Any values in +keywords+ that already exist in the +Node+'s
+      # attribute values are _not_ added. Note that any existing
+      # duplicates in the attribute values are not removed. Compare
+      # with {#kwattr_append}.
+      #
+      # A "keyword attribute" is a node attribute that contains a set
+      # of space-delimited values. Perhaps the most familiar example
+      # of this is the HTML +class+ attribute used to contain CSS
+      # classes. But other keyword attributes exist, for instance
+      # [`rel`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel).
+      #
+      # @see #add_class
+      # @see #kwattr_values
+      # @see #kwattr_append
+      # @see #kwattr_remove
+      #
+      # @param attribute_name [String] The name of the keyword attribute to be modified.
+      #
+      # @param keywords [String, Array<String>]
+      #
+      #   Keywords to be added to the attribute named
+      #   +attribute_name+. May be a string containing
+      #   whitespace-delimited values, or an Array of String
+      #   values. Any values already present will not be added. Any
+      #   values not present will be added. If the named attribute
+      #   does not exist, it is created.
+      #
+      # @return [Node] Returns +self+ for ease of chaining method calls.
+      #
+      # @example Ensure that a +Node+ has "nofollow" in its +rel+ attribute.
+      #   node                               # => <a></a>
+      #   node.kwattr_add("rel", "nofollow") # => <a rel="nofollow"></a>
+      #   node.kwattr_add("rel", "nofollow") # => <a rel="nofollow"></a> # duplicate not added
+      #
+      # @example Ensure that a +Node+ has "nofollow" and "noreferrer" in its +rel+ attribute, via a String argument.
+      #   node                                          # => <a rel="nofollow nofollow"></a>
+      #   node.kwattr_add("rel", "nofollow noreferrer") # => <a rel="nofollow nofollow noreferrer"></a>
+      #   # Note that "nofollow" is not added because it is already present.
+      #   # Note also that the pre-existing duplicate "nofollow" is not removed.
+      #
+      # @example Ensure that a +Node+ has "nofollow" and "noreferrer" in its +rel+ attribute, via an Array argument.
+      #   node                                               # => <a></a>
+      #   node.kwattr_add("rel", ["nofollow", "noreferrer"]) # => <a rel="nofollow noreferrer"></a>
+      #
+      # @since v1.11.0
+      #
+      def kwattr_add(attribute_name, keywords)
+        keywords = keywordify(keywords)
+        current_kws = kwattr_values(attribute_name)
+        new_kws = (current_kws + (keywords - current_kws)).join(" ")
+        set_attribute(attribute_name, new_kws)
         self
       end
 
-      ###
-      # Append +name+ to the "class" attribute value of this Node and
-      # return self.  The value is simply appended without checking if
-      # it is already in the current value.  If no "class" attribute
-      # exists yet, one is created with the given value.
+      # Add keywords to a Node's keyword attribute, regardless of
+      # duplication. Compare with {#kwattr_add}.
+      #
+      # A "keyword attribute" is a node attribute that contains a set
+      # of space-delimited values. Perhaps the most familiar example
+      # of this is the HTML +class+ attribute used to contain CSS
+      # classes. But other keyword attributes exist, for instance
+      # [`rel`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel).
+      #
+      # @see #append_class
+      # @see #kwattr_values
+      # @see #kwattr_add
+      # @see #kwattr_remove
+      #
+      # @param attribute_name [String] The name of the keyword attribute to be modified.
+      #
+      # @param keywords [String, Array<String>]
+      #
+      #   Keywords to be added to the attribute named
+      #   +attribute_name+. May be a string containing
+      #   whitespace-delimited values, or an Array of String
+      #   values. All values passed in will be appended to the named
+      #   attribute even if they are already present in the
+      #   attribute. If the named attribute does not exist, it is
+      #   created.
+      #
+      # @return [Node] Returns +self+ for ease of chaining method calls.
+      #
+      # @example Append "nofollow" to the +rel+ attribute.
+      #   node                                  # => <a></a>
+      #   node.kwattr_append("rel", "nofollow") # => <a rel="nofollow"></a>
+      #   node.kwattr_append("rel", "nofollow") # => <a rel="nofollow nofollow"></a> # duplicate added!
       #
-      # More than one class may be appended at a time, separated by a
-      # space.
-      def append_class name
-        self['class'] = (classes + name.scan(/\S+/)).join(' ')
+      # @example Append "nofollow" and "noreferrer" to the +rel+ attribute, via a String argument.
+      #   node                                             # => <a rel="nofollow"></a>
+      #   node.kwattr_append("rel", "nofollow noreferrer") # => <a rel="nofollow nofollow noreferrer"></a>
+      #   # Note that "nofollow" is appended even though it is already present.
+      #
+      # @example Append "nofollow" and "noreferrer" to the +rel+ attribute, via an Array argument.
+      #   node                                                  # => <a></a>
+      #   node.kwattr_append("rel", ["nofollow", "noreferrer"]) # => <a rel="nofollow noreferrer"></a>
+      #
+      # @since v1.11.0
+      #
+      def kwattr_append(attribute_name, keywords)
+        keywords = keywordify(keywords)
+        current_kws = kwattr_values(attribute_name)
+        new_kws = (current_kws + keywords).join(" ")
+        set_attribute(attribute_name, new_kws)
         self
       end
 
-      ###
-      # Remove +name+ from the "class" attribute value of this Node
-      # and return self.  If there are many occurrences of the name,
-      # they are all removed.
+      # Remove keywords from a keyword attribute. Any matching
+      # keywords that exist in the named attribute are removed,
+      # including any multiple entries.
       #
-      # More than one class may be removed at a time, separated by a
-      # space.
+      # If no keywords remain after this operation, or if +keywords+
+      # is +nil+, the attribute is deleted from the node.
       #
-      # If no class name is left after removal, or when +name+ is nil,
-      # the "class" attribute is removed from this Node.
-      def remove_class name = nil
-        if name
-          names = classes - name.scan(/\S+/)
-          if names.empty?
-            delete 'class'
-          else
-            self['class'] = names.join(' ')
-          end
+      # A "keyword attribute" is a node attribute that contains a set
+      # of space-delimited values. Perhaps the most familiar example
+      # of this is the HTML +class+ attribute used to contain CSS
+      # classes. But other keyword attributes exist, for instance
+      # [`rel`](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel).
+      #
+      # @see #remove_class
+      # @see #kwattr_values
+      # @see #kwattr_add
+      # @see #kwattr_append
+      #
+      # @param attribute_name [String] The name of the keyword attribute to be modified.
+      #
+      # @param keywords [String, Array<String>]
+      #
+      #   Keywords to be removed from the attribute named
+      #   +attribute_name+. May be a string containing
+      #   whitespace-delimited values, or an Array of String
+      #   values. Any keywords present in the named attribute will be
+      #   removed. If no keywords remain, or if +keywords+ is nil, the
+      #   attribute is deleted.
+      #
+      # @return [Node] Returns +self+ for ease of chaining method calls.
+      #
+      # @example
+      #   node                                    # => <a rel="nofollow noreferrer">link</a>
+      #   node.kwattr_remove("rel", "nofollow")   # => <a rel="noreferrer">link</a>
+      #   node.kwattr_remove("rel", "noreferrer") # => <a>link</a> # attribute is deleted when empty
+      #
+      # @since v1.11.0
+      #
+      def kwattr_remove(attribute_name, keywords)
+        if keywords.nil?
+          remove_attribute(attribute_name)
+          return self
+        end
+
+        keywords = keywordify(keywords)
+        current_kws = kwattr_values(attribute_name)
+        new_kws = current_kws - keywords
+        if new_kws.empty?
+          remove_attribute(attribute_name)
         else
-          delete "class"
+          set_attribute(attribute_name, new_kws.join(" "))
         end
         self
       end
 
-      ###
-      # Remove the attribute named +name+
-      def remove_attribute name
-        attr = attributes[name].remove if key? name
-        clear_xpath_context if Nokogiri.jruby?
-        attr
-      end
       alias :delete :remove_attribute
+      alias :get_attribute :[]
+      alias :attr :[]
+      alias :set_attribute :[]=
+      alias :has_attribute? :key?
+
+      # @!endgroup
 
       ###
       # Returns true if this Node matches +selector+
-      def matches? selector
+      def matches?(selector)
         ancestors.last.search(selector).include?(self)
       end
 
       ###
       # Create a DocumentFragment containing +tags+ that is relative to _this_
       # context node.
-      def fragment tags
+      def fragment(tags)
         type = document.html? ? Nokogiri::HTML : Nokogiri::XML
         type::DocumentFragment.new(document, tags, self)
       end
@@ -454,7 +796,7 @@ module Nokogiri
       # Parse +string_or_io+ as a document fragment within the context of
       # *this* node.  Returns a XML::NodeSet containing the nodes parsed from
       # +string_or_io+.
-      def parse string_or_io, options = nil
+      def parse(string_or_io, options = nil)
         ##
         # When the current node is unparented and not an element node, use the
         # document as the parsing context instead. Otherwise, the in-context
@@ -488,19 +830,6 @@ module Nokogiri
         node_set
       end
 
-      ####
-      # Set the Node's content to a Text node containing +string+. The string gets XML escaped, not interpreted as markup.
-      def content= string
-        self.native_content = encode_special_chars(string.to_s)
-      end
-
-      ###
-      # Set the parent Node for this Node
-      def parent= parent_node
-        parent_node.add_child(self)
-        parent_node
-      end
-
       ###
       # Returns a Hash of +{prefix => value}+ for all namespaces on this
       # node and its ancestors.
@@ -582,6 +911,7 @@ module Nokogiri
       def element?
         type == ELEMENT_NODE
       end
+
       alias :elem? :element?
 
       ###
@@ -592,7 +922,7 @@ module Nokogiri
       end
 
       # Get the inner_html for this node's Node#children
-      def inner_html *args
+      def inner_html(*args)
         children.map { |x| x.to_html(*args) }.join
       end
 
@@ -600,13 +930,13 @@ module Nokogiri
       def css_path
         path.split(/\//).map { |part|
           part.length == 0 ? nil : part.gsub(/\[(\d+)\]/, ':nth-of-type(\1)')
-        }.compact.join(' > ')
+        }.compact.join(" > ")
       end
 
       ###
       # Get a list of ancestor Node for this Node.  If +selector+ is given,
       # the ancestors must match +selector+
-      def ancestors selector = nil
+      def ancestors(selector = nil)
         return NodeSet.new(document) unless respond_to?(:parent)
         return NodeSet.new(document) unless parent
 
@@ -627,57 +957,38 @@ module Nokogiri
         })
       end
 
-      ###
-      # Adds a default namespace supplied as a string +url+ href, to self.
-      # The consequence is as an xmlns attribute with supplied argument were
-      # present in parsed XML.  A default namespace set with this method will
-      # now show up in #attributes, but when this node is serialized to XML an
-      # "xmlns" attribute will appear. See also #namespace and #namespace=
-      def default_namespace= url
-        add_namespace_definition(nil, url)
-      end
-      alias :add_namespace :add_namespace_definition
-
-      ###
-      # Set the default namespace on this node (as would be defined with an
-      # "xmlns=" attribute in XML source), as a Namespace object +ns+. Note that
-      # a Namespace added this way will NOT be serialized as an xmlns attribute
-      # for this node. You probably want #default_namespace= instead, or perhaps
-      # #add_namespace_definition with a nil prefix argument.
-      def namespace= ns
-        return set_namespace(ns) unless ns
-
-        unless Nokogiri::XML::Namespace === ns
-          raise TypeError, "#{ns.class} can't be coerced into Nokogiri::XML::Namespace"
-        end
-        if ns.document != document
-          raise ArgumentError, 'namespace must be declared on the same document'
-        end
-
-        set_namespace ns
-      end
-
       ####
       # Yields self and all children to +block+ recursively.
-      def traverse &block
-        children.each{|j| j.traverse(&block) }
+      def traverse(&block)
+        children.each { |j| j.traverse(&block) }
         block.call(self)
       end
 
       ###
       # Accept a visitor.  This method calls "visit" on +visitor+ with self.
-      def accept visitor
+      def accept(visitor)
         visitor.visit(self)
       end
 
       ###
       # Test to see if this Node is equal to +other+
-      def == other
+      def ==(other)
         return false unless other
         return false unless other.respond_to?(:pointer_id)
         pointer_id == other.pointer_id
       end
 
+      ###
+      # Compare two Node objects with respect to their Document.  Nodes from
+      # different documents cannot be compared.
+      def <=>(other)
+        return nil unless other.is_a?(Nokogiri::XML::Node)
+        return nil unless document == other.document
+        compare other
+      end
+
+      # @!group Serialization and Generating Output
+
       ###
       # Serialize Node using +options+.  Save options can also be set using a
       # block. See SaveOptions.
@@ -692,17 +1003,17 @@ module Nokogiri
       #     config.format.as_xml
       #   end
       #
-      def serialize *args, &block
+      def serialize(*args, &block)
         options = args.first.is_a?(Hash) ? args.shift : {
-          :encoding   => args[0],
-          :save_with  => args[1]
+          :encoding => args[0],
+          :save_with => args[1],
         }
 
         encoding = options[:encoding] || document.encoding
         options[:encoding] = encoding
 
         outstring = String.new
-        outstring.force_encoding(Encoding.find(encoding || 'utf-8'))
+        outstring.force_encoding(Encoding.find(encoding || "utf-8"))
         io = StringIO.new(outstring)
         write_to io, options, &block
         io.string
@@ -715,7 +1026,7 @@ module Nokogiri
       #
       # See Node#write_to for a list of +options+.  For formatted output,
       # use Node#to_xhtml instead.
-      def to_html options = {}
+      def to_html(options = {})
         to_format SaveOptions::DEFAULT_HTML, options
       end
 
@@ -725,7 +1036,7 @@ module Nokogiri
       #   doc.to_xml(:indent => 5, :encoding => 'UTF-8')
       #
       # See Node#write_to for a list of +options+
-      def to_xml options = {}
+      def to_xml(options = {})
         options[:save_with] ||= SaveOptions::DEFAULT_XML
         serialize(options)
       end
@@ -736,7 +1047,7 @@ module Nokogiri
       #   doc.to_xhtml(:indent => 5, :encoding => 'UTF-8')
       #
       # See Node#write_to for a list of +options+
-      def to_xhtml options = {}
+      def to_xhtml(options = {})
         to_format SaveOptions::DEFAULT_XHTML, options
       end
 
@@ -757,22 +1068,22 @@ module Nokogiri
       #
       #   node.write_to(io, :indent_text => '-', :indent => 2)
       #
-      def write_to io, *options
-        options       = options.first.is_a?(Hash) ? options.shift : {}
-        encoding      = options[:encoding] || options[0]
+      def write_to(io, *options)
+        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
+          save_options = options[:save_with] || options[1]
+          indent_times = options[:indent] || 0
         else
-          save_options  = options[:save_with] || options[1] || SaveOptions::FORMAT
-          indent_times  = options[:indent] || 2
+          save_options = options[:save_with] || options[1] || SaveOptions::FORMAT
+          indent_times = options[:indent] || 2
         end
-        indent_text   = options[:indent_text] || ' '
+        indent_text = options[:indent_text] || " "
 
         # Any string times 0 returns an empty string. Therefore, use the same
         # string instead of generating a new empty string for every node with
         # zero indentation.
-        indentation = indent_times.zero? ? '' : (indent_text * indent_times)
+        indentation = indent_times.zero? ? "" : (indent_text * indent_times)
 
         config = SaveOptions.new(save_options.to_i)
         yield config if block_given?
@@ -784,7 +1095,7 @@ module Nokogiri
       # Write Node as HTML to +io+ with +options+
       #
       # See Node#write_to for a list of +options+
-      def write_html_to io, options = {}
+      def write_html_to(io, options = {})
         write_format_to SaveOptions::DEFAULT_HTML, io, options
       end
 
@@ -792,7 +1103,7 @@ module Nokogiri
       # Write Node as XHTML to +io+ with +options+
       #
       # See Node#write_to for a list of +options+
-      def write_xhtml_to io, options = {}
+      def write_xhtml_to(io, options = {})
         write_format_to SaveOptions::DEFAULT_XHTML, io, options
       end
 
@@ -802,35 +1113,12 @@ module Nokogiri
       #   doc.write_xml_to io, :encoding => 'UTF-8'
       #
       # See Node#write_to for a list of options
-      def write_xml_to io, options = {}
+      def write_xml_to(io, options = {})
         options[:save_with] ||= SaveOptions::DEFAULT_XML
         write_to io, options
       end
 
-      ###
-      # Compare two Node objects with respect to their Document.  Nodes from
-      # different documents cannot be compared.
-      def <=> other
-        return nil unless other.is_a?(Nokogiri::XML::Node)
-        return nil unless document == other.document
-        compare other
-      end
-
-      ###
-      # Do xinclude substitution on the subtree below node. If given a block, a
-      # Nokogiri::XML::ParseOptions object initialized from +options+, will be
-      # passed to it, allowing more convenient modification of the parser options.
-      def do_xinclude options = XML::ParseOptions::DEFAULT_XML
-        options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
-
-        # give options to user
-        yield options if block_given?
-
-        # call c extension
-        process_xincludes(options.to_i)
-      end
-
-      def canonicalize(mode=XML::XML_C14N_1_0,inclusive_namespaces=nil,with_comments=false)
+      def canonicalize(mode = XML::XML_C14N_1_0, inclusive_namespaces = nil, with_comments = false)
         c14n_root = self
         document.canonicalize(mode, inclusive_namespaces, with_comments) do |node, parent|
           tn = node.is_a?(XML::Node) ? node : parent
@@ -838,16 +1126,29 @@ module Nokogiri
         end
       end
 
+      # @!endgroup
+
       private
 
-      def add_sibling next_or_previous, node_or_tags
+      def keywordify(keywords)
+        case keywords
+        when Enumerable
+          return keywords
+        when String
+          return keywords.scan(/\S+/)
+        else
+          raise ArgumentError.new("Keyword attributes must be passed as either a String or an Enumerable, but received #{keywords.class}")
+        end
+      end
+
+      def add_sibling(next_or_previous, node_or_tags)
         impl = (next_or_previous == :next) ? :add_next_sibling_node : :add_previous_sibling_node
-        iter = (next_or_previous == :next) ? :reverse_each          : :each
+        iter = (next_or_previous == :next) ? :reverse_each : :each
 
         node_or_tags = coerce node_or_tags
         if node_or_tags.is_a?(XML::NodeSet)
           if text?
-            pivot = Nokogiri::XML::Node.new 'dummy', document
+            pivot = Nokogiri::XML::Node.new "dummy", document
             send impl, pivot
           else
             pivot = self
@@ -863,14 +1164,14 @@ module Nokogiri
       USING_LIBXML_WITH_BROKEN_SERIALIZATION = Nokogiri.uses_libxml?("~> 2.6.0").freeze
       private_constant :USING_LIBXML_WITH_BROKEN_SERIALIZATION
 
-      def to_format save_option, options
+      def to_format(save_option, options)
         return dump_html if USING_LIBXML_WITH_BROKEN_SERIALIZATION
 
         options[:save_with] = save_option unless options[:save_with]
         serialize(options)
       end
 
-      def write_format_to save_option, io, options
+      def write_format_to(save_option, io, options)
         return (io << dump_html) if USING_LIBXML_WITH_BROKEN_SERIALIZATION
 
         options[:save_with] ||= save_option
@@ -881,7 +1182,7 @@ module Nokogiri
         [:name, :namespace, :attribute_nodes, :children]
       end
 
-      def coerce data # :nodoc:
+      def coerce(data)
         case data
         when XML::NodeSet
           return data
@@ -902,9 +1203,9 @@ Requires a Node, NodeSet or String argument, and cannot accept a #{data.class}.
       end
 
       # @private
-      IMPLIED_XPATH_CONTEXTS = [ './/'.freeze ].freeze # :nodoc:
+      IMPLIED_XPATH_CONTEXTS = [".//".freeze].freeze
 
-      def add_child_node_and_reparent_attrs node # :nodoc:
+      def add_child_node_and_reparent_attrs(node)
         add_child_node node
         node.attribute_nodes.find_all { |a| a.name =~ /:/ }.each do |attr_node|
           attr_node.remove