class Nokogiri::XML::Node

Nokogiri::XML::Node is the primary API you’ll use to interact with your Document.

Attributes¶ ↑

A Nokogiri::XML::Node may be treated similarly to a hash with regard to attributes. For example:

node = Nokogiri::XML::DocumentFragment.parse("<a href='#foo' id='link'>link</a>").at_css("a")
node.to_html # => "<a href=\"#foo\" id=\"link\">link</a>"
node['href'] # => "#foo"
node.keys # => ["href", "id"]
node.values # => ["#foo", "link"]
node['class'] = 'green' # => "green"
node.to_html # => "<a href=\"#foo\" id=\"link\" class=\"green\">link</a>"

See the method group entitled Working With Node Attributes at Node for the full set of methods.

Nokogiri::XML::Node also has methods that let you move around your tree:

parent, children, next, previous: Navigate up, down, or through siblings.

See the method group entitled Traversing Document Structure at Node for the full set of methods.

Serialization¶ ↑

When printing or otherwise emitting a document or a node (and its subtree), there are a few methods you might want to use:

content, text, inner_text, to_str: These methods will all **emit plaintext**, meaning that entities will be replaced (e.g., +<+ will be replaced with +<+), meaning that any sanitizing will likely be un-done in the output.
to_s, to_xml, to_html, inner_html: These methods will all **emit properly-escaped markup**, meaning that it’s suitable for consumption by browsers, parsers, etc.

See the method group entitled Serialization and Generating Output at Node for the full set of methods.

Searching¶ ↑

You may search this node’s subtree using methods like xpath and css.

See the method group entitled Searching via XPath or CSS Queries at Node for the full set of methods.

Constants

ATTRIBUTE_DECL: Attribute declaration type
ATTRIBUTE_NODE: Attribute node type
CDATA_SECTION_NODE: CDATA node type, see Nokogiri::XML::Node#cdata?
COMMENT_NODE: Comment node type, see Nokogiri::XML::Node#comment?
DOCB_DOCUMENT_NODE: DOCB document node type
DOCUMENT_FRAG_NODE: Document fragment node type
DOCUMENT_NODE: Document node type, see Nokogiri::XML::Node#xml?
DOCUMENT_TYPE_NODE: Document type node type
DTD_NODE: DTD node type
ELEMENT_DECL: Element declaration type
ELEMENT_NODE: Element node type, see Nokogiri::XML::Node#element?
ENTITY_DECL: Entity declaration type
ENTITY_NODE: Entity node type
ENTITY_REF_NODE: Entity reference node type
HTML_DOCUMENT_NODE: HTML document node type, see Nokogiri::XML::Node#html?
IMPLIED_XPATH_CONTEXTS
NAMESPACE_DECL: Namespace declaration type
NOTATION_NODE: Notation node type
PI_NODE: PI node type
TEXT_NODE: Text node type, see Nokogiri::XML::Node#text?
XINCLUDE_END: XInclude end type
XINCLUDE_START: XInclude start type

Public Class Methods

new(name, document) → Nokogiri::XML::Node

new(name, document) { |node| ... } → Nokogiri::XML::Node

Create a new node with name that belongs to document.

If you intend to add a node to a document tree, it’s likely that you will prefer one of the Nokogiri::XML::Node methods like add_child, add_next_sibling, replace, etc. which will both create an element (or subtree) and place it in the document tree.

Another alternative, if you are concerned about performance, is Nokogiri::XML::Document#create_element which accepts additional arguments for contents or attributes but (like this method) avoids parsing markup.

Parameters

name (String)
document (Nokogiri::XML::Document) The document to which the the returned node will belong.

Yields: Nokogiri::XML::Node
Returns: Nokogiri::XML::Node

# File lib/nokogiri/xml/node.rb, line 126
def initialize(name, document)
  # This is intentionally empty, and sets the method signature for subclasses.
end

Public Instance Methods

<=> (other)

Compare two Node objects with respect to their Document. Nodes from different documents cannot be compared.

# File lib/nokogiri/xml/node.rb, line 1340
def <=>(other)
  return unless other.is_a?(Nokogiri::XML::Node)
  return unless document == other.document

  compare(other)
end

== (other)

Test to see if this Node is equal to other

# File lib/nokogiri/xml/node.rb, line 1330
def ==(other)
  return false unless other
  return false unless other.respond_to?(:pointer_id)

  pointer_id == other.pointer_id
end

accept (visitor)

Accept a visitor. This method calls “visit” on visitor with self.

# File lib/nokogiri/xml/node.rb, line 1324
def accept(visitor)
  visitor.visit(self)
end

ancestors (selector = nil)

Get a list of ancestor Node for this Node. If selector is given, the ancestors must match selector

# File lib/nokogiri/xml/node.rb, line 1293
def ancestors(selector = nil)
  return NodeSet.new(document) unless respond_to?(:parent)
  return NodeSet.new(document) unless parent

  parents = [parent]

  while parents.last.respond_to?(:parent)
    break unless (ctx_parent = parents.last.parent)

    parents << ctx_parent
  end

  return NodeSet.new(document, parents) unless selector

  root = parents.last
  search_results = root.search(selector)

  NodeSet.new(document, parents.find_all do |parent|
    search_results.include?(parent)
  end)
end

blank? → Boolean

Returns: true if the node is an empty or whitespace-only text or cdata node, else false.

Example:

Nokogiri("<root><child/></root>").root.child.blank? # => false
Nokogiri("<root>\t \n</root>").root.child.blank? # => true
Nokogiri("<root><![CDATA[\t \n]]></root>").root.child.blank? # => true
Nokogiri("<root>not-blank</root>").root.child
  .tap { |n| n.content = "" }.blank # => true

static VALUE
rb_xml_node_blank_eh(VALUE self)
{
  xmlNodePtr node;
  Noko_Node_Get_Struct(self, xmlNode, node);
  return (1 == xmlIsBlankNode(node)) ? Qtrue : Qfalse ;
}

cdata? ()

Returns true if this is a CDATA

# File lib/nokogiri/xml/node.rb, line 1214
def cdata?
  type == CDATA_SECTION_NODE
end

clone → Nokogiri::XML::Node

clone(level) → Nokogiri::XML::Node

clone(level, new_parent_doc) → Nokogiri::XML::Node

Clone this node.

Parameters

level (optional Integer). 0 is a shallow copy, 1 (the default) is a deep copy.
new_parent_doc The new node’s parent Document. Defaults to the the Document of the current node.

Returns: The new Nokogiri::XML::Node

Calls superclass method

# File lib/nokogiri/xml/node.rb, line 162
def clone(level = 1, new_parent_doc = document)
  super().initialize_copy_with_args(self, level, new_parent_doc)
end

comment? ()

Returns true if this is a Comment

# File lib/nokogiri/xml/node.rb, line 1209
def comment?
  type == COMMENT_NODE
end

content() → String

Returns: Contents of all the text nodes in this node’s subtree, concatenated together into a single String.

⚠ Note that entities will always be expanded in the returned String.

See related: inner_html

Example of how entities are handled:

Note that < becomes < in the returned String.

doc = Nokogiri::XML.fragment("<child>a &lt; b</child>")
doc.at_css("child").content
# => "a < b"

Example of how a subtree is handled:

Note that the <span> tags are omitted and only the text node contents are returned, concatenated into a single string.

doc = Nokogiri::XML.fragment("<child><span>first</span> <span>second</span></child>")
doc.at_css("child").content
# => "first second"

static VALUE
rb_xml_node_content(VALUE self)
{
  xmlNodePtr node;
  xmlChar *content;

  Noko_Node_Get_Struct(self, xmlNode, node);

  content = xmlNodeGetContent(node);
  if (content) {
    VALUE rval = NOKOGIRI_STR_NEW2(content);
    xmlFree(content);
    return rval;
  }
  return Qnil;
}

Also aliased as: inner_text, text, to_str

create_external_subset(name, external_id, system_id)

Create an external subset

static VALUE
create_external_subset(VALUE self, VALUE name, VALUE external_id, VALUE system_id)
{
  xmlNodePtr node;
  xmlDocPtr doc;
  xmlDtdPtr dtd;

  Noko_Node_Get_Struct(self, xmlNode, node);

  doc = node->doc;

  if (doc->extSubset) {
    rb_raise(rb_eRuntimeError, "Document already has an external subset");
  }

  dtd = xmlNewDtd(
          doc,
          NIL_P(name)        ? NULL : (const xmlChar *)StringValueCStr(name),
          NIL_P(external_id) ? NULL : (const xmlChar *)StringValueCStr(external_id),
          NIL_P(system_id)   ? NULL : (const xmlChar *)StringValueCStr(system_id)
        );

  if (!dtd) { return Qnil; }

  return noko_xml_node_wrap(Qnil, (xmlNodePtr)dtd);
}

create_internal_subset(name, external_id, system_id)

Create the internal subset of a document.

doc.create_internal_subset("chapter", "-//OASIS//DTD DocBook XML//EN", "chapter.dtd")
# => <!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML//EN" "chapter.dtd">

doc.create_internal_subset("chapter", nil, "chapter.dtd")
# => <!DOCTYPE chapter SYSTEM "chapter.dtd">

static VALUE
create_internal_subset(VALUE self, VALUE name, VALUE external_id, VALUE system_id)
{
  xmlNodePtr node;
  xmlDocPtr doc;
  xmlDtdPtr dtd;

  Noko_Node_Get_Struct(self, xmlNode, node);

  doc = node->doc;

  if (xmlGetIntSubset(doc)) {
    rb_raise(rb_eRuntimeError, "Document already has an internal subset");
  }

  dtd = xmlCreateIntSubset(
          doc,
          NIL_P(name)        ? NULL : (const xmlChar *)StringValueCStr(name),
          NIL_P(external_id) ? NULL : (const xmlChar *)StringValueCStr(external_id),
          NIL_P(system_id)   ? NULL : (const xmlChar *)StringValueCStr(system_id)
        );

  if (!dtd) { return Qnil; }

  return noko_xml_node_wrap(Qnil, (xmlNodePtr)dtd);
}

css_path ()

Get the path to this node as a CSS expression

# File lib/nokogiri/xml/node.rb, line 1284
def css_path
  path.split(%r{/}).filter_map do |part|
    part.empty? ? nil : part.gsub(/\[(\d+)\]/, ':nth-of-type(\1)')
  end.join(" > ")
end

decorate! ()

Decorate this node with the decorators set up in this node’s Document

# File lib/nokogiri/xml/node.rb, line 168
def decorate!
  document.decorate(self)
end

description ()

Fetch the Nokogiri::HTML4::ElementDescription for this node. Returns nil on XML documents and on unknown tags.

# File lib/nokogiri/xml/node.rb, line 1251
def description
  return if document.xml?

  Nokogiri::HTML4::ElementDescription[name]
end

document? ()

Returns true if this is a Document

# File lib/nokogiri/xml/node.rb, line 1229
def document?
  is_a?(XML::Document)
end

dup → Nokogiri::XML::Node

dup(level) → Nokogiri::XML::Node

dup(level, new_parent_doc) → Nokogiri::XML::Node

Duplicate this node.

Parameters

level (optional Integer). 0 is a shallow copy, 1 (the default) is a deep copy.
new_parent_doc (optional Nokogiri::XML::Document) The new node’s parent Document. Defaults to the the Document of the current node.

Returns: The new Nokogiri::XML::Node

Calls superclass method

# File lib/nokogiri/xml/node.rb, line 144
def dup(level = 1, new_parent_doc = document)
  super().initialize_copy_with_args(self, level, new_parent_doc)
end

elem? ()

Alias for: element?

element? ()

Returns true if this is an Element node

# File lib/nokogiri/xml/node.rb, line 1265
def element?
  type == ELEMENT_NODE
end

Also aliased as: elem?

element_children() → NodeSet

Returns: The node’s child elements as a NodeSet. Only children that are elements will be returned, which notably excludes Text nodes.

Example:

Note that children returns the Text node “hello” while element_children does not.

div = Nokogiri::HTML5("<div>hello<span>world</span>").at_css("div")
div.element_children
# => [#<Nokogiri::XML::Element:0x50 name="span" children=[#<Nokogiri::XML::Text:0x3c "world">]>]
div.children
# => [#<Nokogiri::XML::Text:0x64 "hello">,
#     #<Nokogiri::XML::Element:0x50 name="span" children=[#<Nokogiri::XML::Text:0x3c "world">]>]

static VALUE
rb_xml_node_element_children(VALUE self)
{
  xmlNodePtr node;
  xmlNodePtr child;
  xmlNodeSetPtr set;
  VALUE document;
  VALUE node_set;

  Noko_Node_Get_Struct(self, xmlNode, node);

  child = xmlFirstElementChild(node);
  set = xmlXPathNodeSetCreate(child);

  document = DOC_RUBY_OBJECT(node->doc);

  if (!child) { return noko_xml_node_set_wrap(set, document); }

  child = xmlNextElementSibling(child);
  while (NULL != child) {
    xmlXPathNodeSetAddUnique(set, child);
    child = xmlNextElementSibling(child);
  }

  node_set = noko_xml_node_set_wrap(set, document);

  return node_set;
}

Also aliased as: elements

elements() → NodeSet

Alias for: element_children

encode_special_chars(string) → String

Encode any special characters in string

static VALUE
encode_special_chars(VALUE self, VALUE string)
{
  xmlNodePtr node;
  xmlChar *encoded;
  VALUE encoded_str;

  Noko_Node_Get_Struct(self, xmlNode, node);
  encoded = xmlEncodeSpecialChars(
              node->doc,
              (const xmlChar *)StringValueCStr(string)
            );

  encoded_str = NOKOGIRI_STR_NEW2(encoded);
  xmlFree(encoded);

  return encoded_str;
}

external_subset()

Get the external subset

static VALUE
external_subset(VALUE self)
{
  xmlNodePtr node;
  xmlDocPtr doc;
  xmlDtdPtr dtd;

  Noko_Node_Get_Struct(self, xmlNode, node);

  if (!node->doc) { return Qnil; }

  doc = node->doc;
  dtd = doc->extSubset;

  if (!dtd) { return Qnil; }

  return noko_xml_node_wrap(Qnil, (xmlNodePtr)dtd);
}

first_element_child() → Node

Returns: The first child Node that is an element.

Example:

Note that the “hello” child, which is a Text node, is skipped and the <span> element is returned.

div = Nokogiri::HTML5("<div>hello<span>world</span>").at_css("div")
div.first_element_child
# => #(Element:0x3c { name = "span", children = [ #(Text "world")] })

static VALUE
rb_xml_node_first_element_child(VALUE self)
{
  xmlNodePtr node, child;
  Noko_Node_Get_Struct(self, xmlNode, node);

  child = xmlFirstElementChild(node);
  if (!child) { return Qnil; }

  return noko_xml_node_wrap(Qnil, child);
}

fragment (tags)

Create a DocumentFragment containing tags that is relative to this context node.

# File lib/nokogiri/xml/node.rb, line 1097
def fragment(tags)
  document.related_class("DocumentFragment").new(document, tags, self)
end

fragment? ()

Returns true if this is a DocumentFragment

# File lib/nokogiri/xml/node.rb, line 1244
def fragment?
  type == DOCUMENT_FRAG_NODE
end

html? ()

Returns true if this is an HTML4::Document or HTML5::Document node

# File lib/nokogiri/xml/node.rb, line 1224
def html?
  type == HTML_DOCUMENT_NODE
end

inner_html (*args)

Get the inner_html for this node’s Node#children

# File lib/nokogiri/xml/node.rb, line 1279
def inner_html(*args)
  children.map { |x| x.to_html(*args) }.join
end

inner_text

Alias for: content

internal_subset()

Get the internal subset

static VALUE
internal_subset(VALUE self)
{
  xmlNodePtr node;
  xmlDocPtr doc;
  xmlDtdPtr dtd;

  Noko_Node_Get_Struct(self, xmlNode, node);

  if (!node->doc) { return Qnil; }

  doc = node->doc;
  dtd = xmlGetIntSubset(doc);

  if (!dtd) { return Qnil; }

  return noko_xml_node_wrap(Qnil, (xmlNodePtr)dtd);
}

key?(attribute)

Returns true if attribute is set

static VALUE
key_eh(VALUE self, VALUE attribute)
{
  xmlNodePtr node;
  Noko_Node_Get_Struct(self, xmlNode, node);
  if (xmlHasProp(node, (xmlChar *)StringValueCStr(attribute))) {
    return Qtrue;
  }
  return Qfalse;
}

Also aliased as: has_attribute?

lang

Searches the language of a node, i.e. the values of the xml:lang attribute or the one carried by the nearest ancestor.

static VALUE
get_lang(VALUE self_rb)
{
  xmlNodePtr self ;
  xmlChar *lang ;
  VALUE lang_rb ;

  Noko_Node_Get_Struct(self_rb, xmlNode, self);

  lang = xmlNodeGetLang(self);
  if (lang) {
    lang_rb = NOKOGIRI_STR_NEW2(lang);
    xmlFree(lang);
    return lang_rb ;
  }

  return Qnil ;
}

lang=

Set the language of a node, i.e. the values of the xml:lang attribute.

static VALUE
set_lang(VALUE self_rb, VALUE lang_rb)
{
  xmlNodePtr self ;
  xmlChar *lang ;

  Noko_Node_Get_Struct(self_rb, xmlNode, self);
  lang = (xmlChar *)StringValueCStr(lang_rb);

  xmlNodeSetLang(self, lang);

  return Qnil ;
}

last_element_child() → Node

Returns: The last child Node that is an element.

Example:

Note that the “hello” child, which is a Text node, is skipped and the <span>yes</span> element is returned.

div = Nokogiri::HTML5("<div><span>no</span><span>yes</span>skip</div>").at_css("div")
div.last_element_child
# => #(Element:0x3c { name = "span", children = [ #(Text "yes")] })

static VALUE
rb_xml_node_last_element_child(VALUE self)
{
  xmlNodePtr node, child;
  Noko_Node_Get_Struct(self, xmlNode, node);

  child = xmlLastElementChild(node);
  if (!child) { return Qnil; }

  return noko_xml_node_wrap(Qnil, child);
}

line() → Integer

Returns: The line number of this Node.

⚠ The CRuby and JRuby implementations differ in important ways!

Semantic differences:

The CRuby method reflects the node’s line number in the parsed string
The JRuby method reflects the node’s line number in the final DOM structure after corrections have been applied

Performance differences:

The CRuby method is O(1) (constant time)
The JRuby method is O(n) (linear time, where n is the number of nodes before/above the element in the DOM)

If you’d like to help improve the JRuby implementation, please review these issues and reach out to the maintainers:

static VALUE
rb_xml_node_line(VALUE rb_node)
{
  xmlNodePtr c_node;
  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);

  return LONG2NUM(xmlGetLineNo(c_node));
}

line=(num)

Sets the line for this Node. num must be less than 65535.

static VALUE
rb_xml_node_line_set(VALUE rb_node, VALUE rb_line_number)
{
  xmlNodePtr c_node;
  int line_number = NUM2INT(rb_line_number);

  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);

  // libxml2 optionally uses xmlNode.psvi to store longer line numbers, but only for text nodes.
  // search for "psvi" in SAX2.c and tree.c to learn more.
  if (line_number < 65535) {
    c_node->line = (short unsigned)line_number;
  } else {
    c_node->line = 65535;
    if (c_node->type == XML_TEXT_NODE) {
      c_node->psvi = (void *)(ptrdiff_t)line_number;
    }
  }

  return rb_line_number;
}

matches? (selector)

Returns true if this Node matches selector

# File lib/nokogiri/xml/node.rb, line 1090
def matches?(selector)
  ancestors.last.search(selector).include?(self)
end

name

Alias for: node_name

namespace() → Namespace

Returns: The Namespace of the element or attribute node, or nil if there is no namespace.

Example:

doc = Nokogiri::XML(<<~EOF)
  <root>
    <first/>
    <second xmlns="http://example.com/child"/>
    <foo:third xmlns:foo="http://example.com/foo"/>
  </root>
EOF
doc.at_xpath("//first").namespace
# => nil
doc.at_xpath("//xmlns:second", "xmlns" => "http://example.com/child").namespace
# => #(Namespace:0x3c { href = "http://example.com/child" })
doc.at_xpath("//foo:third", "foo" => "http://example.com/foo").namespace
# => #(Namespace:0x50 { prefix = "foo", href = "http://example.com/foo" })

static VALUE
rb_xml_node_namespace(VALUE rb_node)
{
  xmlNodePtr c_node ;
  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);

  if (c_node->ns) {
    return noko_xml_namespace_wrap(c_node->ns, c_node->doc);
  }

  return Qnil ;
}

namespace_definitions() → Array<Nokogiri::XML::Namespace>

Returns: Namespaces that are defined directly on this node, as an Array of Namespace objects. The array will be empty if no namespaces are defined on this node.

Example:

doc = Nokogiri::XML(<<~EOF)
  <root xmlns="http://example.com/root">
    <first/>
    <second xmlns="http://example.com/child" xmlns:unused="http://example.com/unused"/>
    <foo:third xmlns:foo="http://example.com/foo"/>
  </root>
EOF
doc.at_xpath("//root:first", "root" => "http://example.com/root").namespace_definitions
# => []
doc.at_xpath("//xmlns:second", "xmlns" => "http://example.com/child").namespace_definitions
# => [#(Namespace:0x3c { href = "http://example.com/child" }),
#     #(Namespace:0x50 {
#       prefix = "unused",
#       href = "http://example.com/unused"
#       })]
doc.at_xpath("//foo:third", "foo" => "http://example.com/foo").namespace_definitions
# => [#(Namespace:0x64 { prefix = "foo", href = "http://example.com/foo" })]

static VALUE
namespace_definitions(VALUE rb_node)
{
  /* this code in the mode of xmlHasProp() */
  xmlNodePtr c_node ;
  xmlNsPtr c_namespace;
  VALUE definitions = rb_ary_new();

  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);

  c_namespace = c_node->nsDef;
  if (!c_namespace) {
    return definitions;
  }

  while (c_namespace != NULL) {
    rb_ary_push(definitions, noko_xml_namespace_wrap(c_namespace, c_node->doc));
    c_namespace = c_namespace->next;
  }

  return definitions;
}

namespace_scopes() → Array<Nokogiri::XML::Namespace>

Returns: Array of all the Namespaces on this node and its ancestors.

Protected Instance Methods

coerce (data)

# File lib/nokogiri/xml/node.rb, line 1567
      def coerce(data)
        case data
        when XML::NodeSet
          return data
        when XML::DocumentFragment
          return data.children
        when String
          return fragment(data).children
        when Document, XML::Attr
          # unacceptable
        when XML::Node
          return data
        end

        raise ArgumentError, <<~EOERR
          Requires a Node, NodeSet or String argument, and cannot accept a #{data.class}.
          (You probably want to select a node from the Document with at() or search(), or create a new Node via Node.new().)
        EOERR
      end

Manipulating Document Structure

Public Instance Methods

<< (node_or_tags)

Add node_or_tags as a child of this Node.

node_or_tags can be a Nokogiri::XML::Node, a ::DocumentFragment, a ::NodeSet, or a String containing markup.

Returns self, to support chaining of calls (e.g., root << child1 << child2)

Also see related method add_child.

# File lib/nokogiri/xml/node.rb, line 292
def <<(node_or_tags)
  add_child(node_or_tags)
  self
end

add_child (node_or_tags)

Add node_or_tags as a child of this Node.

node_or_tags can be a Nokogiri::XML::Node, a ::DocumentFragment, a ::NodeSet, or a String containing markup.

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 +<<+.

# File lib/nokogiri/xml/node.rb, line 184
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) }
  else
    add_child_node_and_reparent_attrs(node_or_tags)
  end
  node_or_tags
end

add_namespace(prefix, href) → Nokogiri::XML::Namespace

Alias for: add_namespace_definition

add_namespace_definition(prefix, href) → Nokogiri::XML::Namespace

Adds a namespace definition to this node with prefix using href value, as if this node had included an attribute “xmlns:prefix=href”.

A default namespace definition for this node can be added by passing nil for prefix.

Parameters

prefix (String, nil) An XML Name
href (String) The URI reference

Returns: The new Nokogiri::XML::Namespace

Example: adding a non-default namespace definition

doc = Nokogiri::XML("<store><inventory></inventory></store>")
inventory = doc.at_css("inventory")
inventory.add_namespace_definition("automobile", "http://alices-autos.com/")
inventory.add_namespace_definition("bicycle", "http://bobs-bikes.com/")
inventory.add_child("<automobile:tire>Michelin model XGV, size 75R</automobile:tire>")
doc.to_xml
# => "<?xml version=\"1.0\"?>\n" +
#    "<store>\n" +
#    "  <inventory xmlns:automobile=\"http://alices-autos.com/\" xmlns:bicycle=\"http://bobs-bikes.com/\">\n" +
#    "    <automobile:tire>Michelin model XGV, size 75R</automobile:tire>\n" +
#    "  </inventory>\n" +
#    "</store>\n"

Example: adding a default namespace definition

doc = Nokogiri::XML("<store><inventory><tire>Michelin model XGV, size 75R</tire></inventory></store>")
doc.at_css("tire").add_namespace_definition(nil, "http://bobs-bikes.com/")
doc.to_xml
# => "<?xml version=\"1.0\"?>\n" +
#    "<store>\n" +
#    "  <inventory>\n" +
#    "    <tire xmlns=\"http://bobs-bikes.com/\">Michelin model XGV, size 75R</tire>\n" +
#    "  </inventory>\n" +
#    "</store>\n"

static VALUE
rb_xml_node_add_namespace_definition(VALUE rb_node, VALUE rb_prefix, VALUE rb_href)
{
  xmlNodePtr c_node, element;
  xmlNsPtr c_namespace;
  const xmlChar *c_prefix = (const xmlChar *)(NIL_P(rb_prefix) ? NULL : StringValueCStr(rb_prefix));

  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
  element = c_node ;

  c_namespace = xmlSearchNs(c_node->doc, c_node, c_prefix);

  if (!c_namespace) {
    if (c_node->type != XML_ELEMENT_NODE) {
      element = c_node->parent;
    }
    c_namespace = xmlNewNs(element, (const xmlChar *)StringValueCStr(rb_href), c_prefix);
  }

  if (!c_namespace) {
    return Qnil ;
  }

  if (NIL_P(rb_prefix) || c_node != element) {
    xmlSetNs(c_node, c_namespace);
  }

  return noko_xml_namespace_wrap(c_namespace, c_node->doc);
}

Also aliased as: add_namespace

add_next_sibling (node_or_tags)

Insert node_or_tags after this Node (as a sibling).

node_or_tags can be a Nokogiri::XML::Node, a ::DocumentFragment, a ::NodeSet, or a String containing markup.

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.

# File lib/nokogiri/xml/node.rb, line 324
def add_next_sibling(node_or_tags)
  raise ArgumentError,
    "A document may not have multiple root nodes." if parent&.document? && !(node_or_tags.comment? || node_or_tags.processing_instruction?)

  add_sibling(:next, node_or_tags)
end

Also aliased as: next=

add_previous_sibling (node_or_tags)

Insert node_or_tags before this Node (as a sibling).

node_or_tags can be a Nokogiri::XML::Node, a ::DocumentFragment, a ::NodeSet, or a String containing markup.

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.

# File lib/nokogiri/xml/node.rb, line 307
def add_previous_sibling(node_or_tags)
  raise ArgumentError,
    "A document may not have multiple root nodes." if parent&.document? && !(node_or_tags.comment? || node_or_tags.processing_instruction?)

  add_sibling(:previous, node_or_tags)
end

Also aliased as: previous=

after (node_or_tags)

Insert node_or_tags after this node (as a sibling).

node_or_tags can be a Nokogiri::XML::Node, a Nokogiri::XML::DocumentFragment, or a String containing markup.

Returns self, to support chaining of calls.

Also see related method add_next_sibling.

# File lib/nokogiri/xml/node.rb, line 354
def after(node_or_tags)
  add_next_sibling(node_or_tags)
  self
end

before (node_or_tags)

Insert node_or_tags before this node (as a sibling).

node_or_tags can be a Nokogiri::XML::Node, a ::DocumentFragment, a ::NodeSet, or a String containing markup.

Returns self, to support chaining of calls.

Also see related method add_previous_sibling.

# File lib/nokogiri/xml/node.rb, line 340
def before(node_or_tags)
  add_previous_sibling(node_or_tags)
  self
end

children= (node_or_tags)

Set the content for this Node node_or_tags

node_or_tags can be a Nokogiri::XML::Node, a Nokogiri::XML::DocumentFragment, or a String containing markup.

Also see related method inner_html=

# File lib/nokogiri/xml/node.rb, line 385
def children=(node_or_tags)
  node_or_tags = coerce(node_or_tags)
  children.unlink
  if node_or_tags.is_a?(XML::NodeSet)
    node_or_tags.each { |n| add_child_node_and_reparent_attrs(n) }
  else
    add_child_node_and_reparent_attrs(node_or_tags)
  end
end

content=(input)

Set the content of this node to input.

Parameters

input (String) The new content for this node. Input is considered to be raw content, and so will be entity-escaped in the final DOM string.

Example

Note how entities are handled:

doc = Nokogiri::HTML::Document.parse(<<~HTML)
  <html>
    <body>
      <div id="first">asdf</div>
      <div id="second">asdf</div>
HTML

text_node = doc.at_css("div#first").children.first
div_node = doc.at_css("div#second")

value = "You &amp; Me"

text_node.content = value
div_node.content = value

doc.css("div").to_html
# => "<div id=\"first\">You &amp;amp; Me</div>
#     <div id=\"second\">You &amp;amp; Me</div>"

For content that is already entity-escaped, use CGI::unescapeHTML to decode it:

text_node.content = CGI::unescapeHTML(value)
div_node.content = CGI::unescapeHTML(value)

doc.css("div").to_html
# => "<div id=\"first\">You &amp; Me</div>
#     <div id=\"second\">You &amp; Me</div>"

Serialization and Generating Output

Public Instance Methods

canonicalize (mode = XML::XML_C14N_1_0, inclusive_namespaces = nil, with_comments = false)

# File lib/nokogiri/xml/node.rb, line 1492
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
    tn == c14n_root || tn.ancestors.include?(c14n_root)
  end
end

deconstruct_keys(array_of_names) → Hash

Returns a hash describing the Node, to use in pattern matching.

Valid keys and their values:

name → (String) The name of this node, or “text” if it is a Text node.
namespace → (Namespace, nil) The namespace of this node, or nil if there is no namespace.
attributes → (Array<Attr>) The attributes of this node.
children → (Array<Node>) The children of this node. 💡 Note this includes text nodes.
elements → (Array<Node>) The child elements of this node. 💡 Note this does not include text nodes.
content → (String) The contents of all the text nodes in this node’s subtree. See content.
inner_html → (String) The inner markup for the children of this node. See inner_html.

Example

doc = Nokogiri::XML.parse(<<~XML)
  <?xml version="1.0"?>
  <parent xmlns="http://nokogiri.org/ns/default" xmlns:noko="http://nokogiri.org/ns/noko">
    <child1 foo="abc" noko:bar="def">First</child1>
    <noko:child2 foo="qwe" noko:bar="rty">Second</noko:child2>
  </parent>
XML

doc.root.deconstruct_keys([:name, :namespace])
# => {:name=>"parent",
#     :namespace=>
#      #(Namespace:0x35c { href = "http://nokogiri.org/ns/default" })}

doc.root.deconstruct_keys([:inner_html, :content])
# => {:content=>"\n" + "  First\n" + "  Second\n",
#     :inner_html=>
#      "\n" +
#      "  <child1 foo=\"abc\" noko:bar=\"def\">First</child1>\n" +
#      "  <noko:child2 foo=\"qwe\" noko:bar=\"rty\">Second</noko:child2>\n"}

doc.root.elements.first.deconstruct_keys([:attributes])
# => {:attributes=>
#      [#(Attr:0x370 { name = "foo", value = "abc" }),
#       #(Attr:0x384 {
#         name = "bar",
#         namespace = #(Namespace:0x398 {
#           prefix = "noko",
#           href = "http://nokogiri.org/ns/noko"
#           }),
#         value = "def"
#         })]}

Since v1.14.0

# File lib/nokogiri/xml/node.rb, line 1553
def deconstruct_keys(keys)
  requested_keys = DECONSTRUCT_KEYS & keys
  {}.tap do |values|
    requested_keys.each do |key|
      method = DECONSTRUCT_METHODS[key] || key
      values[key] = send(method)
    end
  end
end

serialize (*args, &block)

Serialize Node using options. Save options can also be set using a block.

These two statements are equivalent:

node.serialize(encoding: 'UTF-8', save_with: FORMAT | AS_XML)

node.serialize(encoding: 'UTF-8') do |config|
  config.format.as_xml
end

# File lib/nokogiri/xml/node.rb, line 1364
def serialize(*args, &block)
  # TODO: deprecate non-hash options, see 46c68ed 2009-06-20 for context
  options = if args.first.is_a?(Hash)
    args.shift
  else
    {
      encoding: args[0],
      save_with: args[1],
    }
  end

  options[:encoding] ||= document.encoding
  encoding = Encoding.find(options[:encoding] || "UTF-8")

  io = StringIO.new(String.new(encoding: encoding))

  write_to(io, options, &block)
  io.string
end

to_html (options = {})

Serialize this Node to HTML

doc.to_html

See Node#write_to for a list of options. For formatted output, use Node#to_xhtml instead.

# File lib/nokogiri/xml/node.rb, line 1391
def to_html(options = {})
  to_format(SaveOptions::DEFAULT_HTML, options)
end

to_xhtml (options = {})

Serialize this Node to XHTML using options

doc.to_xhtml(indent: 5, encoding: 'UTF-8')

See Node#write_to for a list of options

# File lib/nokogiri/xml/node.rb, line 1412
def to_xhtml(options = {})
  to_format(SaveOptions::DEFAULT_XHTML, options)
end

to_xml (options = {})

Serialize this Node to XML using options

doc.to_xml(indent: 5, encoding: 'UTF-8')

See Node#write_to for a list of options

# File lib/nokogiri/xml/node.rb, line 1401
def to_xml(options = {})
  options[:save_with] ||= SaveOptions::DEFAULT_XML
  serialize(options)
end

write_html_to (io, options = {})

Write Node as HTML to io with options

See Node#write_to for a list of options

# File lib/nokogiri/xml/node.rb, line 1469
def write_html_to(io, options = {})
  write_format_to(SaveOptions::DEFAULT_HTML, io, options)
end

write_to(io, *options)

Serialize this node or document to io.

Parameters

io (IO) An IO-like object to which the serialized content will be written.
options (Hash) See below

Options

:encoding (String or Encoding) specify the encoding of the output (defaults to document encoding)
:indent_text (String) the indentation text (defaults to " ")
:indent (Integer) the number of :indent_text to use (defaults to 2)
:save_with (Integer) a combination of SaveOptions constants

To save with UTF-8 indented twice:

node.write_to(io, encoding: 'UTF-8', indent: 2)

To save indented with two dashes:

node.write_to(io, indent_text: '-', indent: 2)

# File lib/nokogiri/xml/node.rb, line 1440
def write_to(io, *options)
  options = options.first.is_a?(Hash) ? options.shift : {}
  encoding = options[:encoding] || options[0] || document.encoding
  if Nokogiri.jruby?
    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
  end
  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?

  encoding = encoding.is_a?(Encoding) ? encoding.name : encoding

  native_write_to(io, encoding, indentation, config.options)
end

write_xhtml_to (io, options = {})

Write Node as XHTML to io with options

See Node#write_to for a list of options

# File lib/nokogiri/xml/node.rb, line 1477
def write_xhtml_to(io, options = {})
  write_format_to(SaveOptions::DEFAULT_XHTML, io, options)
end

write_xml_to (io, options = {})

Write Node as XML to io with options

doc.write_xml_to io, :encoding => 'UTF-8'

See Node#write_to for a list of options

# File lib/nokogiri/xml/node.rb, line 1487
def write_xml_to(io, options = {})
  options[:save_with] ||= SaveOptions::DEFAULT_XML
  write_to(io, options)
end

Traversing Document Structure

Public Instance Methods

child() → Nokogiri::XML::Node

Returns: First of this node’s children, or nil if there are no children

This is a convenience method and is equivalent to:

node.children.first

See related: children

static VALUE
rb_xml_node_child(VALUE self)
{
  xmlNodePtr node, child;
  Noko_Node_Get_Struct(self, xmlNode, node);

  child = node->children;
  if (!child) { return Qnil; }

  return noko_xml_node_wrap(Qnil, child);
}

children() → Nokogiri::XML::NodeSet

Returns: Nokogiri::XML::NodeSet containing this node’s children.

static VALUE
rb_xml_node_children(VALUE self)
{
  xmlNodePtr node;
  xmlNodePtr child;
  xmlNodeSetPtr set;
  VALUE document;
  VALUE node_set;

  Noko_Node_Get_Struct(self, xmlNode, node);

  child = node->children;
  set = xmlXPathNodeSetCreate(child);

  document = DOC_RUBY_OBJECT(node->doc);

  if (!child) { return noko_xml_node_set_wrap(set, document); }

  child = child->next;
  while (NULL != child) {
    xmlXPathNodeSetAddUnique(set, child);
    child = child->next;
  }

  node_set = noko_xml_node_set_wrap(set, document);

  return node_set;
}

document() → Nokogiri::XML::Document

Returns: Parent Nokogiri::XML::Document for this node

static VALUE
rb_xml_node_document(VALUE self)
{
  xmlNodePtr node;
  Noko_Node_Get_Struct(self, xmlNode, node);
  return DOC_RUBY_OBJECT(node->doc);
}

Working With Node Attributes

Public Instance Methods

[](name) → (String, nil)

Fetch an attribute from this node.

⚠ Note that attributes with namespaces cannot be accessed with this method. To access namespaced attributes, use attribute_with_ns.

Returns: (String, nil) value of the attribute name, or nil if no matching attribute exists

Example

doc = Nokogiri::XML("<root><child size='large' class='big wide tall'/></root>")
child = doc.at_css("child")
child["size"] # => "large"
child["class"] # => "big wide tall"

Example: Namespaced attributes will not be returned.

⚠ Note namespaced attributes may be accessed with attribute or attribute_with_ns

doc = Nokogiri::XML(<<~EOF)
  <root xmlns:width='http://example.com/widths'>
    <child width:size='broad'/>
  </root>
EOF
doc.at_css("child")["size"] # => nil
doc.at_css("child").attribute("size").value # => "broad"
doc.at_css("child").attribute_with_ns("size", "http://example.com/widths").value
# => "broad"

# File lib/nokogiri/xml/node.rb, line 587
def [](name)
  get(name.to_s)
end

Also aliased as: get_attribute, attr

[]=(name, value) → value

Update the attribute name to value, or create the attribute if it does not exist.

⚠ Note that attributes with namespaces cannot be accessed with this method. To access namespaced attributes for update, use attribute_with_ns. To add a namespaced attribute, see the example below.

Returns: value

Example

doc = Nokogiri::XML("<root><child/></root>")
child = doc.at_css("child")
child["size"] = "broad"
child.to_html
# => "<child size=\"broad\"></child>"

Example: Add a namespaced attribute.

doc = Nokogiri::XML(<<~EOF)
  <root xmlns:width='http://example.com/widths'>
    <child/>
  </root>
EOF
child = doc.at_css("child")
child["size"] = "broad"
ns = doc.root.namespace_definitions.find { |ns| ns.prefix == "width" }
child.attribute("size").namespace = ns
doc.to_html
# => "<root xmlns:width=\"http://example.com/widths\">\n" +
#    "  <child width:size=\"broad\"></child>\n" +
#    "</root>\n"

# File lib/nokogiri/xml/node.rb, line 625
def []=(name, value)
  set(name.to_s, value.to_s)
end

Also aliased as: set_attribute

add_class(names) → self

Ensure HTML CSS classes are present on self. Any CSS classes in names that already exist in the “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)

Parameters

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.

Returns: self (Node) for ease of chaining method calls.

Example: Ensure that the 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 the node has CSS classes “section” and “header”, via a String argument

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.

node                             # => <div class="section section"></div>
node.add_class("section header") # => <div class="section section header"></div>

Example: Ensure that the node has CSS classes “section” and “header”, via an Array argument

node                                  # => <div></div>
node.add_class(["section", "header"]) # => <div class="section header"></div>

# File lib/nokogiri/xml/node.rb, line 790
def add_class(names)
  kwattr_add("class", names)
end

append_class(names) → self

Add HTML CSS classes to self, regardless of duplication. Compare with add_class.

This is a convenience function and is equivalent to:

node.kwattr_append("class", names)

Parameters

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.

Returns: self (Node) for ease of chaining method calls.

Example: Append “section” to the node’s CSS “class” attribute

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 the noded’s CSS “class” attribute, via a String argument

Note that the CSS class “section” is appended even though it is already present

node                                # => <div class="section section"></div>
node.append_class("section header") # => <div class="section section section header"></div>

Example: Append “section” and “header” to the 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>

# File lib/nokogiri/xml/node.rb, line 834
def append_class(names)
  kwattr_append("class", names)
end

attr

Alias for: []

attribute(name) → Nokogiri::XML::Attr

Returns: Attribute (Nokogiri::XML::Attr) belonging to this node with name name.

⚠ Note that attribute namespaces are ignored and only the simple (non-namespace-prefixed) name is used to find a matching attribute. In case of a simple name collision, only one of the matching attributes will be returned. In this case, you will need to use attribute_with_ns.

Example:

doc = Nokogiri::XML("<root><child size='large' class='big wide tall'/></root>")
child = doc.at_css("child")
child.attribute("size") # => #<Nokogiri::XML::Attr:0x550 name="size" value="large">
child.attribute("class") # => #<Nokogiri::XML::Attr:0x564 name="class" value="big wide tall">

Example showing that namespaced attributes will not be returned:

⚠ Note that only one of the two matching attributes is returned.

doc = Nokogiri::XML(<<~EOF)
  <root xmlns:width='http://example.com/widths'
        xmlns:height='http://example.com/heights'>
    <child width:size='broad' height:size='tall'/>
  </root>
EOF
doc.at_css("child").attribute("size")
# => #(Attr:0x550 {
#      name = "size",
#      namespace = #(Namespace:0x564 {
#        prefix = "width",
#        href = "http://example.com/widths"
#        }),
#      value = "broad"
#      })

static VALUE
rb_xml_node_attribute(VALUE self, VALUE name)
{
  xmlNodePtr node;
  xmlAttrPtr prop;
  Noko_Node_Get_Struct(self, xmlNode, node);
  prop = xmlHasProp(node, (xmlChar *)StringValueCStr(name));

  if (! prop) { return Qnil; }
  return noko_xml_node_wrap(Qnil, (xmlNodePtr)prop);
}

attribute_nodes() → Array<Nokogiri::XML::Attr>

Returns: Attributes (an Array of Nokogiri::XML::Attr) belonging to this node.

Note that this is the preferred alternative to attributes when the simple (non-namespace-prefixed) attribute names may collide.

Example:

Contrast this with the colliding-name example from attributes.

doc = Nokogiri::XML(<<~EOF)
  <root xmlns:width='http://example.com/widths'
        xmlns:height='http://example.com/heights'>
    <child width:size='broad' height:size='tall'/>
  </root>
EOF
doc.at_css("child").attribute_nodes
# => [#(Attr:0x550 {
#       name = "size",
#       namespace = #(Namespace:0x564 {
#         prefix = "width",
#         href = "http://example.com/widths"
#         }),
#       value = "broad"
#       }),
#     #(Attr:0x578 {
#       name = "size",
#       namespace = #(Namespace:0x58c {
#         prefix = "height",
#         href = "http://example.com/heights"
#         }),
#       value = "tall"
#       })]

static VALUE
rb_xml_node_attribute_nodes(VALUE rb_node)
{
  xmlNodePtr c_node;

  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);

  return noko_xml_node_attrs(c_node);
}

attribute_with_ns(name, namespace) → Nokogiri::XML::Attr

Returns: Attribute (Nokogiri::XML::Attr) belonging to this node with matching name and namespace.

name (String): the simple (non-namespace-prefixed) name of the attribute
namespace (String): the URI of the attribute’s namespace

See related: attribute

Example:

doc = Nokogiri::XML(<<~EOF)
  <root xmlns:width='http://example.com/widths'
        xmlns:height='http://example.com/heights'>
    <child width:size='broad' height:size='tall'/>
  </root>
EOF
doc.at_css("child").attribute_with_ns("size", "http://example.com/widths")
# => #(Attr:0x550 {
#      name = "size",
#      namespace = #(Namespace:0x564 {
#        prefix = "width",
#        href = "http://example.com/widths"
#        }),
#      value = "broad"
#      })
doc.at_css("child").attribute_with_ns("size", "http://example.com/heights")
# => #(Attr:0x578 {
#      name = "size",
#      namespace = #(Namespace:0x58c {
#        prefix = "height",
#        href = "http://example.com/heights"
#        }),
#      value = "tall"
#      })

static VALUE
rb_xml_node_attribute_with_ns(VALUE self, VALUE name, VALUE namespace)
{
  xmlNodePtr node;
  xmlAttrPtr prop;
  Noko_Node_Get_Struct(self, xmlNode, node);
  prop = xmlHasNsProp(node, (xmlChar *)StringValueCStr(name),
                      NIL_P(namespace) ? NULL : (xmlChar *)StringValueCStr(namespace));

  if (! prop) { return Qnil; }
  return noko_xml_node_wrap(Qnil, (xmlNodePtr)prop);
}

attributes() → Hash<String ⇒ Nokogiri::XML::Attr>

Fetch this node’s attributes.

⚠ Because the keys do not include any namespace information for the attribute, in case of a simple name collision, not all attributes will be returned. In this case, you will need to use attribute_nodes.

Returns: Hash containing attributes belonging to self. The hash keys are String attribute names (without the namespace), and the hash values are Nokogiri::XML::Attr.

Example with no namespaces:

doc = Nokogiri::XML("<root><child size='large' class='big wide tall'/></root>")
doc.at_css("child").attributes
# => {"size"=>#(Attr:0x550 { name = "size", value = "large" }),
#     "class"=>#(Attr:0x564 { name = "class", value = "big wide tall" })}

Example with a namespace:

doc = Nokogiri::XML("<root xmlns:desc='http://example.com/sizes'><child desc:size='large'/></root>")
doc.at_css("child").attributes
# => {"size"=>
#      #(Attr:0x550 {
#        name = "size",
#        namespace = #(Namespace:0x564 {
#          prefix = "desc",
#          href = "http://example.com/sizes"
#          }),
#        value = "large"
#        })}

Example with an attribute name collision:

⚠ Note that only one of the attributes is returned in the Hash.

doc = Nokogiri::XML(<<~EOF)
  <root xmlns:width='http://example.com/widths'
        xmlns:height='http://example.com/heights'>
    <child width:size='broad' height:size='tall'/>
  </root>
EOF
doc.at_css("child").attributes
# => {"size"=>
#      #(Attr:0x550 {
#        name = "size",
#        namespace = #(Namespace:0x564 {
#          prefix = "height",
#          href = "http://example.com/heights"
#          }),
#        value = "tall"
#        })}

# File lib/nokogiri/xml/node.rb, line 684
def attributes
  attribute_nodes.each_with_object({}) do |node, hash|
    hash[node.node_name] = node
  end
end

classes() → Array<String>

Fetch CSS class names of a Node.

This is a convenience function and is equivalent to:

node.kwattr_values("class")

Returns: The CSS classes (Array of String) 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"]

# File lib/nokogiri/xml/node.rb, line 744
def classes
  kwattr_values("class")
end

delete (name)

Alias for: remove_attribute

each () { |node_name, value| ... }

Iterate over each attribute name and value pair for this Node.

# File lib/nokogiri/xml/node.rb, line 710
def each
  attribute_nodes.each do |node|
    yield [node.node_name, node.value]
  end
end

get_attribute

Alias for: []

has_attribute?

Alias for: key?

keys ()

Get the attribute names for this Node.

# File lib/nokogiri/xml/node.rb, line 704
def keys
  attribute_nodes.map(&:node_name)
end

kwattr_add(attribute_name, keywords) → self

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 the “rel” attribute.

Parameters

attribute_name (String) The name of the keyword attribute to be modified.
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.

Returns: self (Nokogiri::XML::Node) for ease of chaining method calls.

Example: Ensure that a Node has “nofollow” in its rel attribute.

Note that duplicates are not added.

node                               # => <a></a>
node.kwattr_add("rel", "nofollow") # => <a rel="nofollow"></a>
node.kwattr_add("rel", "nofollow") # => <a rel="nofollow"></a>

Example: Ensure that a Node has “nofollow” and “noreferrer” in its rel attribute, via a String argument.

Note that "nofollow" is not added because it is already present. Note also that the
pre-existing duplicate "nofollow" is not removed.

 node                                          # => <a rel="nofollow nofollow"></a>
 node.kwattr_add("rel", "nofollow noreferrer") # => <a rel="nofollow nofollow noreferrer"></a>

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

# File lib/nokogiri/xml/node.rb, line 967
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

kwattr_append(attribute_name, keywords) → self

Add keywords to a Node’s keyword attribute, regardless of duplication. Compare with kwattr_add.

Parameters

attribute_name (String) The name of the keyword attribute to be modified.
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.

Returns: self (Node) for ease of chaining method calls.

Example: Append “nofollow” to the rel attribute.

Note that duplicates are added.

node                                  # => <a></a>
node.kwattr_append("rel", "nofollow") # => <a rel="nofollow"></a>
node.kwattr_append("rel", "nofollow") # => <a rel="nofollow nofollow"></a>

Example: Append “nofollow” and “noreferrer” to the rel attribute, via a String argument.

Note that “nofollow” is appended even though it is already present.

node                                             # => <a rel="nofollow"></a>
node.kwattr_append("rel", "nofollow noreferrer") # => <a rel="nofollow nofollow noreferrer"></a>

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

# File lib/nokogiri/xml/node.rb, line 1020
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

kwattr_remove(attribute_name, keywords) → self

Remove keywords from a keyword attribute. Any matching keywords that exist in the named attribute are removed, including any multiple entries.

If no keywords remain after this operation, or if keywords is nil, the attribute is deleted from the node.

Parameters

attribute_name (String) The name of the keyword attribute to be modified.
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.

Returns: self (Node) for ease of chaining method calls.

Example:

Note that the rel attribute is deleted when empty.

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>

Since v1.11.0

# File lib/nokogiri/xml/node.rb, line 1063
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
    set_attribute(attribute_name, new_kws.join(" "))
  end
  self
end

kwattr_values(attribute_name) → Array<String>

Fetch values from a keyword attribute of a Node.

Parameters

attribute_name (String) The name of the keyword attribute to be inspected.

Returns: (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.

Example:

node                      # => <a rel="nofollow noopener external">link</a>
node.kwattr_values("rel") # => ["nofollow", "noopener", "external"]

Since v1.11.0

# File lib/nokogiri/xml/node.rb, line 913
def kwattr_values(attribute_name)
  keywordify(get_attribute(attribute_name) || [])
end

remove_attribute (name)

Remove the attribute named name

# File lib/nokogiri/xml/node.rb, line 718
def remove_attribute(name)
  attr = attributes[name].remove if key?(name)
  clear_xpath_context if Nokogiri.jruby?
  attr
end

Also aliased as: delete

remove_class(css_classes) → self

Remove HTML CSS classes from this node. Any CSS class names in css_classes that exist in this node’s “class” attribute are removed, including any multiple entries.

If no CSS classes remain after this operation, or if css_classes is nil, the “class” attribute is deleted from the node.

This is a convenience function and is equivalent to:

node.kwattr_remove("class", css_classes)

Also see kwattr_remove, classes, add_class, append_class

Parameters

css_classes (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.

Returns: self (Nokogiri::XML::Node) for ease of chaining method calls.

Example: Deleting a CSS class

Note that all instances of the class “section” are removed from the “class” attribute.

node                         # => <div class="section header section"></div>
node.remove_class("section") # => <div class="header"></div>

Example: Deleting the only remaining CSS class

Note that the attribute is removed once there are no remaining classes.

node                         # => <div class="section"></div>
node.remove_class("section") # => <div></div>

Example: Deleting multiple CSS classes

Note that the “class” attribute is deleted once it’s empty.

node                                    # => <div class="section header float"></div>
node.remove_class(["section", "float"]) # => <div class="header"></div>

# File lib/nokogiri/xml/node.rb, line 884
def remove_class(names = nil)
  kwattr_remove("class", names)
end

[]=(name, value) → value

Alias for: []=

value? (value)

Does this Node’s attributes include <value>

# File lib/nokogiri/xml/node.rb, line 698
def value?(value)
  values.include?(value)
end

values ()

Get the attribute values for this Node.

# File lib/nokogiri/xml/node.rb, line 692
def values
  attribute_nodes.map(&:value)
end

class Nokogiri::XML::Node

Attributes¶ ↑

Navigation¶ ↑

Serialization¶ ↑

Searching¶ ↑

Manipulating Document Structure

Serialization and Generating Output

Traversing Document Structure

Working With Node Attributes