Class | Nokogiri::XML::Node
In: | lib/nokogiri/ffi/xml/node.rb lib/nokogiri/xml/node.rb lib/nokogiri/xml/node/save_options.rb ext/nokogiri/html_document.c
Parent: | Object

### Methods

% / <=> == [] []= accept add_child add_namespace_definition add_next_sibling add_previous_sibling after ancestors at attribute attribute_nodes attribute_with_ns attributes before blank? cdata? child children collect_namespaces comment? compare content content= css css_path decorate! default_namespace= delete description document document dump_html dup each elem? element? encode_special_chars get get_attribute html? inner_html inner_html= internal_subset key? keys line matches? namespace namespace= namespace_definitions namespaced_key? namespaces native_content= native_write_to new new next_sibling node_name node_name= node_type parent parent= path pointer_id previous_sibling read_only? remove_attribute replace search serialize set_namespace set_namespace swap text? to_html to_s to_xhtml to_xml traverse unlink values write_html_to write_to write_xhtml_to write_xml_to xml? xpath

### Classes and Modules

Class Nokogiri::XML::Node::SaveOptions

### Constants

ELEMENT_NODE | = | 1 |  | Element node type, see Nokogiri::XML::Node#element?
ATTRIBUTE_NODE | = | 2 |  | Attribute node type
TEXT_NODE | = | 3 |  | Text node type, see Nokogiri::XML::Node#text?
CDATA_SECTION_NODE | = | 4 |  | CDATA node type, see Nokogiri::XML::Node#cdata?
ENTITY_REF_NODE | = | 5 |  | Entity reference node type
ENTITY_NODE | = | 6 |  | Entity node type
PI_NODE | = | 7 |  | PI node type
COMMENT_NODE | = | 8 |  | Comment node type, see Nokogiri::XML::Node#comment?
DOCUMENT_NODE | = | 9 |  | Document node type, see Nokogiri::XML::Node#xml?
DOCUMENT_TYPE_NODE | = | 10 |  | Document type node type
DOCUMENT_FRAG_NODE | = | 11 |  | Document fragment node type
NOTATION_NODE | = | 12 |  | Notation node type
HTML_DOCUMENT_NODE | = | 13 |  | HTML document node type, see Nokogiri::XML::Node#html?
DTD_NODE | = | 14 |  | DTD node type
ELEMENT_DECL | = | 15 |  | Element declaration type
ATTRIBUTE_DECL | = | 16 |  | Attribute declaration type
ENTITY_DECL | = | 17 |  | Entity declaration type
NAMESPACE_DECL | = | 18 |  | Namespace declaration type
XINCLUDE_START | = | 19 |  | XInclude start type
XINCLUDE_END | = | 20 |  | XInclude end type
DOCB_DOCUMENT_NODE | = | 21 |  | DOCB document node type

### External Aliases

next_sibling | -> | next
previous_sibling | -> | previous
unlink | -> | remove
set_attribute | -> | :
content | -> | text
content | -> | inner_text
key? | -> | has_attribute?
add_child | -> | <<
node_name | -> | name
node_name= | -> | name=
node_type | -> | type
text | -> | to_str
dup | -> | clone
add_namespace_definition | -> | add_namespace

### Public Class methods

new(name, document)
new(name, document)

Create a new node with `name` sharing GC lifecycle with `document`

### Public Instance methods

%(path, ns = document.root ? document.root.namespaces : {})

Alias for at

/(*paths)

Alias for search

<=>(other)

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

==(other)

Test to see if this Node is equal to `other`

[](name)

Get the attribute value for the attribute `name`

[]=(property, value)

Set the `property` to `value`

accept(visitor)

Accept a visitor. This method calls "visit" on `visitor` with self.

add_child(node)

Add `node` as a child of this node. Returns the new child node.

add_namespace_definition(prefix, href)

Adds a namespace definition with `prefix` using `href`

add_next_sibling(node)

Insert `node` after this node (as a sibling).

add_previous_sibling(node)

Insert `node` before this node (as a sibling).

after(data)

Create nodes from `data` and insert them after this node (as a sibling).

ancestors(selector = nil)

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

at(path, ns = document.root ? document.root.namespaces : {})

Search for the first occurrence of `path`. Returns nil if nothing is found, otherwise a Node.

attribute(name)

Get the attribute node with `name`

attribute_nodes()

returns a list containing the Node attributes.

attribute_with_ns(name, namespace)

Get the attribute node with `name` and `namespace`

attributes()

Returns a hash containing the node‘s attributes. The key is the attribute name, the value is the string value of the attribute.

before(data)

Create nodes from `data` and insert them before this node (as a sibling).

blank?

Is this node blank?

cdata?()

Returns true if this is a CDATA

child

Returns the child node

children

Get the list of children for this node as a NodeSet

collect_namespaces()

recursively get all namespaces from this node and its subtree

comment?()

Returns true if this is a Comment

compare(other)

Compare this Node to `other` with respect to their Document

content

Returns the content for this Node

content=(string)

Set the Node content to `string`. The content gets XML escaped.

css(*rules)

Search this node for CSS `rules`. `rules` must be one or more CSS selectors. For example:

      node.css('title')
      node.css('body h1.bold')
      node.css('div + p.green', 'div#one')

Custom CSS pseudo classes may also be defined. To define custom pseudo classes, create a class and implement the custom pseudo class you want defined. The first argument to the method will be the current matching NodeSet. Any other arguments are ones that you pass in. For example:

      node.css('title:regex("\w+")', Class.new {
        def regex node_set, regex
          node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
        end
      }.new)

css_path()

Get the path to this node as a CSS expression

decorate!()

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

default_namespace=(url)

Set the default namespace for this node to `url`

delete(name)

Alias for remove_attribute

description()

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

document()
document

Get the document for this Node

dump_html

Returns the Node as html.

dup

Copy this node. An optional depth may be passed in, but it defaults to a deep copy. 0 is a shallow copy, 1 is a deep copy.

each(&block)

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

elem?()

Alias for element?

element?()

Returns true if this is an Element node

encode_special_chars(string)

Encode any special characters in `string`

get(attribute)

Get the value for `attribute`

get_attribute(name)

Alias for #[]

html?()

Returns true if this is an HTML::Document node

inner_html()

Get the inner_html for this node‘s Node#children

inner_html=(tags)

Set the inner_html for this Node to `tags`

internal_subset

Get the internal subset

key?(attribute)

Returns true if `attribute` is set

keys()

Get the attribute names for this Node.

line

Returns the line for this Node

matches?(selector)

Returns true if this Node matches `selector`

namespace()

returns the Nokogiri::XML::Namespace for the node, if one exists.

namespace=(ns)

Set the namespace for this node to `ns`

namespace_definitions()

returns a list of Namespace nodes defined on self

namespaced_key?(attribute, namespace)

Returns true if `attribute` is set with `namespace`

namespaces()

Get a hash containing the Namespace definitions for this Node

content=

Set the content for this Node

native_write_to(io, encoding, options)

Write this Node to `io` with `encoding` and `options`

next_sibling

Returns the next sibling node

name

Returns the name for this Node

name=(new_name)

Set the name for this Node

node_type

Get the type for this Node

parent

Get the parent Node for this Node

parent=(parent_node)

Set the parent Node for this Node

path

Returns the path associated with this Node

pointer_id

Get the internal pointer number

previous_sibling

Returns the previous sibling node

read_only?()

Is this a read only node?

remove_attribute(name)

Remove the attribute named `name`

replace(new_node)

replace this Node with the `new_node` in the Document.

search(*paths)

Search this node for `paths`. `paths` can be XPath or CSS, and an optional hash of namespaces may be appended. See Node#xpath and Node#css.

serialize(*args, &block)

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

These two statements are equivalent:

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

or

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

set_namespace(namespace)

Set the namespace to `namespace`

set_namespace(namespace)
swap(data)

Swap this Node for new nodes made from `data`

text?()

Returns true if this is a Text node

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.

to_s()

Turn this node in to a string. If the document is HTML, this method returns html. If the document is XML, this method returns XML.

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`

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`

traverse(&block)

Yields self and all children to `block` recursively.

unlink

Unlink this node from its current context.

values()

Get the attribute values for this Node.

write_html_to(io, options = {})

Write Node as HTML to `io` with `options`

See Node#write_to for a list of `options`

write_to(io, *options) {|config if block_given?| ...}

Write Node to `io` with `options`. `options` modify the output of this method. Valid options are:

- +:encoding+ for changing the encoding
- +:indent_text+ the indentation text, defaults to one space
- +:indent+ the number of +:indent_text+ to use, defaults to 2
- +:save_with+ 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

write_xhtml_to(io, options = {})

Write Node as XHTML to `io` with `options`

See Node#write_to for a list of `options`

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

xml?()

Returns true if this is an XML::Document node

xpath(*paths)

Search this node for XPath `paths`. `paths` must be one or more XPath queries. A hash of namespaces may be appended. For example:

      node.xpath('.//title')
      node.xpath('.//foo:name', { 'foo' => 'http://example.org/' })
      node.xpath('.//xmlns:name', node.root.namespaces)

Custom XPath functions may also be defined. To define custom functions create a class and implement the # function you want to define. For example:

      node.xpath('.//title[regex(., "\w+")]', Class.new {
        def regex node_set, regex
          node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
        end
      }.new)

[Validate]