nokogiri 1.10.8-x64-mingw32 → 1.11.0.rc3-x64-mingw32

data/lib/nokogiri/xml/cdata.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     class CDATA < Nokogiri::XML::Text

data/lib/nokogiri/xml/character_data.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     class CharacterData < Nokogiri::XML::Node

data/lib/nokogiri/xml/document.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     ##
@@ -254,18 +255,12 @@ module Nokogiri
       ##
       # +JRuby+
       # Wraps Java's org.w3c.dom.document and returns Nokogiri::XML::Document
-      def self.wrap document
-        raise "JRuby only method" unless Nokogiri.jruby?
-        return wrapJavaDocument(document)
-      end
+      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
-        raise "JRuby only method" unless Nokogiri.jruby?
-        return toJavaDocument()
-      end
+      def to_java; end if false # JRuby provides #to_java
 
       private
       def self.empty_doc? string_or_io

data/lib/nokogiri/xml/document_fragment.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     class DocumentFragment < Nokogiri::XML::Node

data/lib/nokogiri/xml/dtd.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     class DTD < Nokogiri::XML::Node

data/lib/nokogiri/xml/element_content.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     ###

data/lib/nokogiri/xml/element_decl.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     class ElementDecl < Nokogiri::XML::Node

data/lib/nokogiri/xml/entity_decl.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     class EntityDecl < Nokogiri::XML::Node

data/lib/nokogiri/xml/entity_reference.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     class EntityReference < Nokogiri::XML::Node

data/lib/nokogiri/xml/namespace.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Nokogiri
   module XML
     class Namespace

data/lib/nokogiri/xml/node.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
-require 'stringio'
-require 'nokogiri/xml/node/save_options'
+# frozen_string_literal: true
+require "stringio"
+require "nokogiri/xml/node/save_options"
 
 module Nokogiri
   module XML
@@ -56,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
 
@@ -108,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.
@@ -134,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 }
@@ -151,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?)
@@ -161,7 +156,6 @@ module Nokogiri
         end
       end
 
-
       ###
       # Add html around this node
       #
@@ -180,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
@@ -192,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
@@ -205,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
@@ -218,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
@@ -230,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
@@ -242,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
@@ -254,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)
@@ -272,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
@@ -302,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
+
+      ###
+      # Set the parent Node for this Node
+      def parent=(parent_node)
+        parent_node.add_child(self)
+        parent_node
+      end
 
-      # :stopdoc:
-      # HACK: This is to work around an RDoc bug
-      alias :next=          :add_next_sibling
-      # :startdoc:
+      ###
+      # 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 :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
+      ###
+      # 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
@@ -337,9 +396,9 @@ module Nokogiri
       # If you need to distinguish attributes with the same name, with different namespaces
       # use #attribute_nodes instead.
       def attributes
-        Hash[attribute_nodes.map { |node|
-          [node.node_name, node]
-        }]
+        attribute_nodes.each_with_object({}) do |node, hash|
+          hash[node.node_name] = node
+        end
       end
 
       ###
@@ -348,6 +407,12 @@ module Nokogiri
         attribute_nodes.map(&:value)
       end
 
+      ###
+      # Does this Node's attributes include <value>
+      def value?(value)
+        values.include? value
+      end
+
       ###
       # Get the attribute names for this Node.
       def keys
@@ -363,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
@@ -447,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
@@ -481,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.
@@ -509,10 +845,11 @@ module Nokogiri
       # default namespaces set on ancestor will NOT be, even if self
       # has no explicit default namespace.
       def namespaces
-        Hash[namespace_scopes.map { |nd|
-          key = ['xmlns', nd.prefix].compact.join(':')
-          [key, nd.href]
-        }]
+        namespace_scopes.each_with_object({}) do |ns, hash|
+          prefix = ns.prefix
+          key = prefix ? "xmlns:#{prefix}" : "xmlns"
+          hash[key] = ns.href
+        end
       end
 
       # Returns true if this is a Comment
@@ -574,6 +911,7 @@ module Nokogiri
       def element?
         type == ELEMENT_NODE
       end
+
       alias :elem? :element?
 
       ###
@@ -584,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
 
@@ -592,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
 
@@ -619,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.
@@ -684,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
@@ -707,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
 
@@ -717,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
@@ -728,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
 
@@ -749,29 +1068,34 @@ 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)
 
         config = SaveOptions.new(save_options.to_i)
         yield config if block_given?
 
-        native_write_to(io, encoding, indent_text * indent_times, config.options)
+        native_write_to(io, encoding, indentation, config.options)
       end
 
       ###
       # 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
 
@@ -779,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
 
@@ -789,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
@@ -825,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
@@ -847,17 +1161,18 @@ module Nokogiri
         node_or_tags
       end
 
-      def to_format save_option, options
-        # FIXME: this is a hack around broken libxml versions
-        return dump_html if Nokogiri.uses_libxml? && %w[2 6] === LIBXML_VERSION.split('.')[0..1]
+      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)
+        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
-        # FIXME: this is a hack around broken libxml versions
-        return (io << dump_html) if Nokogiri.uses_libxml? && %w[2 6] === LIBXML_VERSION.split('.')[0..1]
+      def write_format_to(save_option, io, options)
+        return (io << dump_html) if USING_LIBXML_WITH_BROKEN_SERIALIZATION
 
         options[:save_with] ||= save_option
         write_to io, options
@@ -867,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
@@ -888,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