Class: Nokogiri::XML::Node
- Inherits:
-
Object
- Object
- Nokogiri::XML::Node
- Includes:
- Enumerable, ClassResolver, HTML5::Node, PP::Node, Searchable
- Defined in:
- lib/nokogiri/xml/node.rb,
lib/nokogiri/xml/node/save_options.rb,
ext/nokogiri/xml_node.c
Overview
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 Node@Working+With+Node+Attributes for the full set of methods.
Navigation
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 Node@Traversing+Document+Structure 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 Node@Serialization+and+Generating+Output 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 Node@Searching+via+XPath+or+CSS+Queries for the full set of methods.
Direct Known Subclasses
AttributeDecl, DTD, Document, DocumentFragment, ElementDecl, EntityDecl, EntityReference, ProcessingInstruction
Defined Under Namespace
Classes: SaveOptions
Constant Summary collapse
- ELEMENT_NODE =
Element node type, see Nokogiri::XML::Node#element?
1
- ATTRIBUTE_NODE =
Attribute node type
2
- TEXT_NODE =
Text node type, see Nokogiri::XML::Node#text?
3
- CDATA_SECTION_NODE =
CDATA node type, see Nokogiri::XML::Node#cdata?
4
- ENTITY_REF_NODE =
Entity reference node type
5
- ENTITY_NODE =
Entity node type
6
- PI_NODE =
PI node type
7
- COMMENT_NODE =
Comment node type, see Nokogiri::XML::Node#comment?
8
- DOCUMENT_NODE =
Document node type, see Nokogiri::XML::Node#xml?
9
- DOCUMENT_TYPE_NODE =
Document type node type
10
- DOCUMENT_FRAG_NODE =
Document fragment node type
11
- NOTATION_NODE =
Notation node type
12
- HTML_DOCUMENT_NODE =
HTML document node type, see Nokogiri::XML::Node#html?
13
- DTD_NODE =
DTD node type
14
- ELEMENT_DECL =
Element declaration type
15
- ATTRIBUTE_DECL =
Attribute declaration type
16
- ENTITY_DECL =
Entity declaration type
17
- NAMESPACE_DECL =
Namespace declaration type
18
- XINCLUDE_START =
XInclude start type
19
- XINCLUDE_END =
XInclude end type
20
- DOCB_DOCUMENT_NODE =
DOCB document node type
21
- DECONSTRUCT_KEYS =
:nodoc:
[:name, :attributes, :children, :namespace, :content, :elements, :inner_html].freeze
- DECONSTRUCT_METHODS =
:nodoc:
{ attributes: :attribute_nodes }.freeze
Constants included from ClassResolver
ClassResolver::VALID_NAMESPACES
Constants included from Searchable
Constants included from PP::Node
Class Method Summary collapse
-
.new(*args) ⇒ Object
:nodoc: documented in lib/nokogiri/xml/node.rb.
Instance Method Summary collapse
-
#<<(node_or_tags) ⇒ Object
Add
node_or_tags
as a child of this Node. -
#<=>(other) ⇒ Object
Compare two Node objects with respect to their Document.
-
#==(other) ⇒ Object
Test to see if this Node is equal to
other
. -
#[](name) ⇒ Object
(also: #get_attribute, #attr)
:call-seq: [](name) → (String, nil).
-
#[]=(name, value) ⇒ Object
(also: #set_attribute)
:call-seq: []=(name, value) → value.
-
#accept(visitor) ⇒ Object
Accept a visitor.
-
#add_child(node_or_tags) ⇒ Object
Add
node_or_tags
as a child of this Node. -
#add_class(names) ⇒ Object
:call-seq: add_class(names) → self.
-
#add_namespace_definition(rb_prefix, rb_href) ⇒ Object
(also: #add_namespace)
:call-seq: add_namespace_definition(prefix, href) → Nokogiri::XML::Namespace add_namespace(prefix, href) → Nokogiri::XML::Namespace.
-
#add_next_sibling(node_or_tags) ⇒ Object
(also: #next=)
Insert
node_or_tags
after this Node (as a sibling). -
#add_previous_sibling(node_or_tags) ⇒ Object
(also: #previous=)
Insert
node_or_tags
before this Node (as a sibling). -
#after(node_or_tags) ⇒ Object
Insert
node_or_tags
after this node (as a sibling). -
#ancestors(selector = nil) ⇒ Object
Get a list of ancestor Node for this Node.
-
#append_class(names) ⇒ Object
:call-seq: append_class(names) → self.
-
#attribute(name) ⇒ Object
:call-seq: attribute(name) → Nokogiri::XML::Attr.
-
#attribute_nodes ⇒ Object
:call-seq: attribute_nodes() → Array<Nokogiri::XML::Attr>.
-
#attribute_with_ns(name, namespace) ⇒ Object
:call-seq: attribute_with_ns(name, namespace) → Nokogiri::XML::Attr.
-
#attributes ⇒ Object
:call-seq: attributes() → Hash<String ⇒ Nokogiri::XML::Attr>.
-
#before(node_or_tags) ⇒ Object
Insert
node_or_tags
before this node (as a sibling). -
#blank? ⇒ Boolean
- Returns
-
true
if the node is an empty or whitespace-only text or cdata node, elsefalse
.
- #canonicalize(mode = XML::XML_C14N_1_0, inclusive_namespaces = nil, with_comments = false) ⇒ Object
-
#cdata? ⇒ Boolean
Returns true if this is a CDATA.
-
#child ⇒ Object
:call-seq: child() → Nokogiri::XML::Node.
-
#children ⇒ Object
:call-seq: children() → Nokogiri::XML::NodeSet.
-
#children=(node_or_tags) ⇒ Object
Set the content for this Node
node_or_tags
. -
#classes ⇒ Object
:call-seq: classes() → Array<String>.
-
#comment? ⇒ Boolean
Returns true if this is a Comment.
-
#content ⇒ Object
(also: #inner_text, #text, #to_str)
:call-seq: content() → String inner_text() → String text() → String to_str() → String.
-
#content=(string) ⇒ Object
Set the Node’s content to a Text node containing
string
. -
#create_external_subset(name, external_id, system_id) ⇒ Object
:call-seq: create_external_subset(name, external_id, system_id).
-
#create_internal_subset(name, external_id, system_id) ⇒ Object
:call-seq: create_internal_subset(name, external_id, system_id).
-
#css_path ⇒ Object
Get the path to this node as a CSS expression.
-
#deconstruct_keys(keys) ⇒ Object
:call-seq: deconstruct_keys(array_of_names) → Hash.
-
#decorate! ⇒ Object
Decorate this node with the decorators set up in this node’s Document.
-
#default_namespace=(url) ⇒ Object
Adds a default namespace supplied as a string
url
href, to self. -
#description ⇒ Object
Fetch the Nokogiri::HTML4::ElementDescription for this node.
-
#do_xinclude(options = XML::ParseOptions::DEFAULT_XML) {|options| ... } ⇒ Object
Do xinclude substitution on the subtree below node.
-
#document ⇒ Object
:call-seq: document() → Nokogiri::XML::Document.
-
#document? ⇒ Boolean
Returns true if this is a Document.
-
#dup(*args) ⇒ Object
(also: #clone)
:call-seq: dup → Nokogiri::XML::Node dup(depth) → Nokogiri::XML::Node dup(depth, new_parent_doc) → Nokogiri::XML::Node.
-
#each ⇒ Object
Iterate over each attribute name and value pair for this Node.
-
#element? ⇒ Boolean
(also: #elem?)
Returns true if this is an Element node.
-
#element_children ⇒ Object
(also: #elements)
:call-seq: element_children() → NodeSet elements() → NodeSet.
-
#encode_special_chars(string) ⇒ Object
:call-seq: encode_special_chars(string) → String.
-
#external_subset ⇒ Object
:call-seq: external_subset().
-
#first_element_child ⇒ Object
:call-seq: first_element_child() → Node.
-
#fragment(tags) ⇒ Object
Create a DocumentFragment containing
tags
that is relative to this context node. -
#fragment? ⇒ Boolean
Returns true if this is a DocumentFragment.
-
#html? ⇒ Boolean
Returns true if this is an HTML4::Document or HTML5::Document node.
-
#initialize(name, document) ⇒ Node
constructor
:call-seq: new(name, document) -> Nokogiri::XML::Node new(name, document) { |node| … } -> Nokogiri::XML::Node.
-
#inner_html(*args) ⇒ Object
Get the inner_html for this node’s Node#children.
-
#inner_html=(node_or_tags) ⇒ Object
Set the content for this Node to
node_or_tags
. -
#internal_subset ⇒ Object
:call-seq: internal_subset().
-
#key?(attribute) ⇒ Boolean
(also: #has_attribute?)
Returns true if
attribute
is set. -
#keys ⇒ Object
Get the attribute names for this Node.
-
#kwattr_add(attribute_name, keywords) ⇒ Object
:call-seq: kwattr_add(attribute_name, keywords) → self.
-
#kwattr_append(attribute_name, keywords) ⇒ Object
:call-seq: kwattr_append(attribute_name, keywords) → self.
-
#kwattr_remove(attribute_name, keywords) ⇒ Object
:call-seq: kwattr_remove(attribute_name, keywords) → self.
-
#kwattr_values(attribute_name) ⇒ Object
:call-seq: kwattr_values(attribute_name) → Array<String>.
-
#lang ⇒ Object
Searches the language of a node, i.e.
-
#lang= ⇒ Object
Set the language of a node, i.e.
-
#last_element_child ⇒ Object
:call-seq: last_element_child() → Node.
-
#line ⇒ Object
:call-seq: line() → Integer.
-
#line=(num) ⇒ Object
Sets the line for this Node.
-
#matches?(selector) ⇒ Boolean
Returns true if this Node matches
selector
. -
#namespace ⇒ Object
:call-seq: namespace() → Namespace.
-
#namespace=(ns) ⇒ Object
Set the default namespace on this node (as would be defined with an “xmlns=” attribute in XML source), as a Namespace object
ns
. -
#namespace_definitions ⇒ Object
:call-seq: namespace_definitions() → Array<Nokogiri::XML::Namespace>.
-
#namespace_scopes ⇒ Object
:call-seq: namespace_scopes() → Array<Nokogiri::XML::Namespace>.
-
#namespaced_key?(attribute, namespace) ⇒ Boolean
Returns true if
attribute
is set withnamespace
. -
#namespaces ⇒ Object
:call-seq: namespaces() → Hash<String(Namespace#prefix) ⇒ String(Namespace#href)>.
-
#content= ⇒ Object
Set the content for this Node.
-
#next_element ⇒ Object
Returns the next Nokogiri::XML::Element type sibling node.
-
#next_sibling ⇒ Object
(also: #next)
Returns the next sibling node.
-
#name ⇒ Object
(also: #name)
Returns the name for this Node.
-
#name=(new_name) ⇒ Object
(also: #name=)
Set the name for this Node.
-
#node_type ⇒ Object
(also: #type)
Get the type for this Node.
-
#parent ⇒ Object
Get the parent Node for this Node.
-
#parent=(parent_node) ⇒ Object
Set the parent Node for this Node.
-
#parse(string_or_io, options = nil) {|options| ... } ⇒ Object
Parse
string_or_io
as a document fragment within the context of this node. -
#path ⇒ Object
Returns the path associated with this Node.
-
#pointer_id ⇒ Object
:call-seq: pointer_id() → Integer.
-
#prepend_child(node_or_tags) ⇒ Object
Add
node_or_tags
as the first child of this Node. -
#previous_element ⇒ Object
Returns the previous Nokogiri::XML::Element type sibling node.
-
#previous_sibling ⇒ Object
(also: #previous)
Returns the previous sibling node.
-
#processing_instruction? ⇒ Boolean
Returns true if this is a ProcessingInstruction node.
-
#read_only? ⇒ Boolean
Is this a read only node?.
-
#remove_attribute(name) ⇒ Object
(also: #delete)
Remove the attribute named
name
. -
#remove_class(names = nil) ⇒ Object
:call-seq: remove_class(css_classes) → self.
-
#replace(node_or_tags) ⇒ Object
Replace this Node with
node_or_tags
. -
#serialize(*args, &block) ⇒ Object
Serialize Node using
options
. -
#swap(node_or_tags) ⇒ Object
Swap this Node for
node_or_tags
. -
#text? ⇒ Boolean
Returns true if this is a Text node.
-
#to_html(options = {}) ⇒ Object
Serialize this Node to HTML.
-
#to_s ⇒ Object
Turn this node in to a string.
-
#to_xhtml(options = {}) ⇒ Object
Serialize this Node to XHTML using
options
. -
#to_xml(options = {}) ⇒ Object
Serialize this Node to XML using
options
. -
#traverse {|_self| ... } ⇒ Object
Yields self and all children to
block
recursively. -
#unlink ⇒ Object
(also: #remove)
:call-seq: unlink() → self.
-
#value?(value) ⇒ Boolean
Does this Node’s attributes include <value>.
-
#values ⇒ Object
Get the attribute values for this Node.
-
#wrap(node_or_tags) ⇒ Object
:call-seq: wrap(markup) -> self wrap(node) -> self.
-
#write_html_to(io, options = {}) ⇒ Object
Write Node as HTML to
io
withoptions
. -
#write_to(io, *options) {|config| ... } ⇒ Object
:call-seq: write_to(io, *options).
-
#write_xhtml_to(io, options = {}) ⇒ Object
Write Node as XHTML to
io
withoptions
. -
#write_xml_to(io, options = {}) ⇒ Object
Write Node as XML to
io
withoptions
. -
#xml? ⇒ Boolean
Returns true if this is an XML::Document node.
Methods included from ClassResolver
Methods included from Searchable
#>, #at, #at_css, #at_xpath, #css, #search, #xpath
Methods included from PP::Node
Constructor Details
#initialize(name, document) ⇒ Node
:call-seq:
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
126 127 128 |
# File 'lib/nokogiri/xml/node.rb', line 126 def initialize(name, document) # This is intentionally empty, and sets the method signature for subclasses. end |
Class Method Details
.new(*args) ⇒ Object
:nodoc: documented in lib/nokogiri/xml/node.rb
2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 |
# File 'ext/nokogiri/xml_node.c', line 2045
static VALUE
rb_xml_node_new(int argc, VALUE *argv, VALUE klass)
{
xmlNodePtr c_document_node;
xmlNodePtr c_node;
VALUE rb_name;
VALUE rb_document_node;
VALUE rest;
VALUE rb_node;
rb_scan_args(argc, argv, "2*", &rb_name, &rb_document_node, &rest);
if (!rb_obj_is_kind_of(rb_document_node, cNokogiriXmlNode)) {
rb_raise(rb_eArgError, "document must be a Nokogiri::XML::Node");
}
if (!rb_obj_is_kind_of(rb_document_node, cNokogiriXmlDocument)) {
// TODO: deprecate allowing Node
NOKO_WARN_DEPRECATION("Passing a Node as the second parameter to Node.new is deprecated. Please pass a Document instead, or prefer an alternative constructor like Node#add_child. This will become an error in a future release of Nokogiri.");
}
Noko_Node_Get_Struct(rb_document_node, xmlNode, c_document_node);
c_node = xmlNewNode(NULL, (xmlChar *)StringValueCStr(rb_name));
c_node->doc = c_document_node->doc;
noko_xml_document_pin_node(c_node);
rb_node = noko_xml_node_wrap(
klass == cNokogiriXmlNode ? (VALUE)NULL : klass,
c_node
);
rb_obj_call_init(rb_node, argc, argv);
if (rb_block_given_p()) { rb_yield(rb_node); }
return rb_node;
}
|
Instance Method Details
#<<(node_or_tags) ⇒ Object
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
.
256 257 258 259 |
# File 'lib/nokogiri/xml/node.rb', line 256 def <<() add_child() self end |
#<=>(other) ⇒ Object
Compare two Node objects with respect to their Document. Nodes from different documents cannot be compared.
1256 1257 1258 1259 1260 1261 |
# File 'lib/nokogiri/xml/node.rb', line 1256 def <=>(other) return unless other.is_a?(Nokogiri::XML::Node) return unless document == other.document compare(other) end |
#==(other) ⇒ Object
Test to see if this Node is equal to other
1246 1247 1248 1249 1250 1251 |
# File 'lib/nokogiri/xml/node.rb', line 1246 def ==(other) return false unless other return false unless other.respond_to?(:pointer_id) pointer_id == other.pointer_id end |
#[](name) ⇒ Object Also known as: get_attribute, attr
:call-seq: [](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
, ornil
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"
512 513 514 |
# File 'lib/nokogiri/xml/node.rb', line 512 def [](name) get(name.to_s) end |
#[]=(name, value) ⇒ Object Also known as: set_attribute
:call-seq: []=(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"
550 551 552 |
# File 'lib/nokogiri/xml/node.rb', line 550 def []=(name, value) set(name.to_s, value.to_s) end |
#accept(visitor) ⇒ Object
Accept a visitor. This method calls “visit” on visitor
with self.
1240 1241 1242 |
# File 'lib/nokogiri/xml/node.rb', line 1240 def accept(visitor) visitor.visit(self) end |
#add_child(node_or_tags) ⇒ Object
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 <<.
148 149 150 151 152 153 154 155 156 |
# File 'lib/nokogiri/xml/node.rb', line 148 def add_child() = coerce() if .is_a?(XML::NodeSet) .each { |n| add_child_node_and_reparent_attrs(n) } else add_child_node_and_reparent_attrs() end end |
#add_class(names) ⇒ Object
:call-seq: 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)
See related: #kwattr_add, #classes, #append_class, #remove_class
- 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>
715 716 717 |
# File 'lib/nokogiri/xml/node.rb', line 715 def add_class(names) kwattr_add("class", names) end |
#add_namespace_definition(rb_prefix, rb_href) ⇒ Object Also known as: add_namespace
:call-seq:
add_namespace_definition(prefix, href) → Nokogiri::XML::Namespace
add_namespace(prefix, href) → Nokogiri::XML::Namespace
:category: Manipulating Document Structure
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"
452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 |
# File 'ext/nokogiri/xml_node.c', line 452
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);
}
|
#add_next_sibling(node_or_tags) ⇒ Object Also known as: next=
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
.
288 289 290 291 292 293 |
# File 'lib/nokogiri/xml/node.rb', line 288 def add_next_sibling() raise ArgumentError, "A document may not have multiple root nodes." if parent&.document? && !(.comment? || .processing_instruction?) add_sibling(:next, ) end |
#add_previous_sibling(node_or_tags) ⇒ Object Also known as: previous=
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
.
271 272 273 274 275 276 |
# File 'lib/nokogiri/xml/node.rb', line 271 def add_previous_sibling() raise ArgumentError, "A document may not have multiple root nodes." if parent&.document? && !(.comment? || .processing_instruction?) add_sibling(:previous, ) end |
#after(node_or_tags) ⇒ Object
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
.
318 319 320 321 |
# File 'lib/nokogiri/xml/node.rb', line 318 def after() add_next_sibling() self end |
#ancestors(selector = nil) ⇒ Object
Get a list of ancestor Node for this Node. If selector
is given, the ancestors must match selector
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 |
# File 'lib/nokogiri/xml/node.rb', line 1209 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 |
#append_class(names) ⇒ Object
:call-seq: 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)
See related: #kwattr_append, #classes, #add_class, #remove_class
- 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>
759 760 761 |
# File 'lib/nokogiri/xml/node.rb', line 759 def append_class(names) kwattr_append("class", names) end |
#attribute(name) ⇒ Object
:call-seq: attribute(name) → Nokogiri::XML::Attr
:category: Working With Node Attributes
- 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"
# })
521 522 523 524 525 526 527 528 529 530 531 |
# File 'ext/nokogiri/xml_node.c', line 521
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 ⇒ Object
:call-seq: attribute_nodes() → Array<Nokogiri::XML::Attr>
:category: Working With Node Attributes
- 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"
# })]
572 573 574 575 576 577 578 579 580 |
# File 'ext/nokogiri/xml_node.c', line 572
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) ⇒ Object
:call-seq: attribute_with_ns(name, namespace) → Nokogiri::XML::Attr
:category: Working With Node Attributes
- Returns
-
Attribute (Nokogiri::XML::Attr) belonging to this node with matching
name
andnamespace
.
-
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"
# })
624 625 626 627 628 629 630 631 632 633 634 635 |
# File 'ext/nokogiri/xml_node.c', line 624
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 ⇒ Object
:call-seq: 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"
# })}
609 610 611 612 613 |
# File 'lib/nokogiri/xml/node.rb', line 609 def attributes attribute_nodes.each_with_object({}) do |node, hash| hash[node.node_name] = node end end |
#before(node_or_tags) ⇒ Object
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
.
304 305 306 307 |
# File 'lib/nokogiri/xml/node.rb', line 304 def before() add_previous_sibling() self end |
#blank? ⇒ Boolean
- Returns
-
true
if the node is an empty or whitespace-only text or cdata node, elsefalse
.
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
652 653 654 655 656 657 658 |
# File 'ext/nokogiri/xml_node.c', line 652
static VALUE
rb_xml_node_blank_eh(VALUE self)
{
xmlNodePtr node;
Noko_Node_Get_Struct(self, xmlNode, node);
return (1 == xmlIsBlankNode(node)) ? Qtrue : Qfalse ;
}
|
#canonicalize(mode = XML::XML_C14N_1_0, inclusive_namespaces = nil, with_comments = false) ⇒ Object
1408 1409 1410 1411 1412 1413 1414 |
# File 'lib/nokogiri/xml/node.rb', line 1408 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 |
#cdata? ⇒ Boolean
Returns true if this is a CDATA
1130 1131 1132 |
# File 'lib/nokogiri/xml/node.rb', line 1130 def cdata? type == CDATA_SECTION_NODE end |
#child ⇒ Object
:call-seq: child() → Nokogiri::XML::Node
:category: Traversing Document Structure
- 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
674 675 676 677 678 679 680 681 682 683 684 |
# File 'ext/nokogiri/xml_node.c', line 674
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 ⇒ Object
:call-seq: children() → Nokogiri::XML::NodeSet
:category: Traversing Document Structure
- Returns
-
Nokogiri::XML::NodeSet containing this node’s children.
694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 |
# File 'ext/nokogiri/xml_node.c', line 694
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;
}
|
#children=(node_or_tags) ⇒ Object
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=
349 350 351 352 353 354 355 356 357 |
# File 'lib/nokogiri/xml/node.rb', line 349 def children=() = coerce() children.unlink if .is_a?(XML::NodeSet) .each { |n| add_child_node_and_reparent_attrs(n) } else add_child_node_and_reparent_attrs() end end |
#classes ⇒ Object
:call-seq: classes() → Array<String>
Fetch CSS class names of a Node.
This is a convenience function and is equivalent to:
node.kwattr_values("class")
See related: #kwattr_values, #add_class, #append_class, #remove_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"]
669 670 671 |
# File 'lib/nokogiri/xml/node.rb', line 669 def classes kwattr_values("class") end |
#comment? ⇒ Boolean
Returns true if this is a Comment
1125 1126 1127 |
# File 'lib/nokogiri/xml/node.rb', line 1125 def comment? type == COMMENT_NODE end |
#content ⇒ Object Also known as: inner_text, text, to_str
:call-seq:
content() → String
inner_text() → String
text() → String
to_str() → 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 < 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"
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 |
# File 'ext/nokogiri/xml_node.c', line 756
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;
}
|
#content=(string) ⇒ Object
Set the Node’s content to a Text node containing string
. The string gets XML escaped, not interpreted as markup.
411 412 413 |
# File 'lib/nokogiri/xml/node.rb', line 411 def content=(string) self.native_content = encode_special_chars(string.to_s) end |
#create_external_subset(name, external_id, system_id) ⇒ Object
:call-seq:
create_external_subset(name, external_id, system_id)
Create an external subset
874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 |
# File 'ext/nokogiri/xml_node.c', line 874
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) ⇒ Object
:call-seq:
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">
841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 |
# File 'ext/nokogiri/xml_node.c', line 841
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 ⇒ Object
Get the path to this node as a CSS expression
1200 1201 1202 1203 1204 |
# File 'lib/nokogiri/xml/node.rb', line 1200 def css_path path.split(%r{/}).filter_map do |part| part.empty? ? nil : part.gsub(/\[(\d+)\]/, ':nth-of-type(\1)') end.join(" > ") end |
#deconstruct_keys(keys) ⇒ Object
:call-seq: 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
1469 1470 1471 1472 1473 1474 1475 1476 1477 |
# File 'lib/nokogiri/xml/node.rb', line 1469 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 |
#decorate! ⇒ Object
Decorate this node with the decorators set up in this node’s Document
132 133 134 |
# File 'lib/nokogiri/xml/node.rb', line 132 def decorate! document.decorate(self) end |
#default_namespace=(url) ⇒ Object
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=
427 428 429 |
# File 'lib/nokogiri/xml/node.rb', line 427 def default_namespace=(url) add_namespace_definition(nil, url) end |
#description ⇒ Object
Fetch the Nokogiri::HTML4::ElementDescription for this node. Returns nil on XML documents and on unknown tags.
1167 1168 1169 1170 1171 |
# File 'lib/nokogiri/xml/node.rb', line 1167 def description return if document.xml? Nokogiri::HTML4::ElementDescription[name] end |
#do_xinclude(options = XML::ParseOptions::DEFAULT_XML) {|options| ... } ⇒ Object
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.
454 455 456 457 458 459 460 |
# File 'lib/nokogiri/xml/node.rb', line 454 def do_xinclude( = XML::ParseOptions::DEFAULT_XML) = Nokogiri::XML::ParseOptions.new() if Integer === yield if block_given? # call c extension process_xincludes(.to_i) end |
#document ⇒ Object
:call-seq: document() → Nokogiri::XML::Document
:category: Traversing Document Structure
- Returns
-
Parent Nokogiri::XML::Document for this node
781 782 783 784 785 786 787 |
# File 'ext/nokogiri/xml_node.c', line 781
static VALUE
rb_xml_node_document(VALUE self)
{
xmlNodePtr node;
Noko_Node_Get_Struct(self, xmlNode, node);
return DOC_RUBY_OBJECT(node->doc);
}
|
#document? ⇒ Boolean
Returns true if this is a Document
1145 1146 1147 |
# File 'lib/nokogiri/xml/node.rb', line 1145 def document? is_a?(XML::Document) end |
#dup(*args) ⇒ Object Also known as: clone
:call-seq:
dup → Nokogiri::XML::Node
dup(depth) → Nokogiri::XML::Node
dup(depth, new_parent_doc) → Nokogiri::XML::Node
Copy this node.
- Parameters
-
depth
0 is a shallow copy, 1 (the default) is a deep copy. -
new_parent_doc
The new node’s parent Document. Defaults to the this node’s document.
- Returns
-
The new Nokogiri::XML::Node
966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 |
# File 'ext/nokogiri/xml_node.c', line 966
static VALUE
duplicate_node(int argc, VALUE *argv, VALUE self)
{
VALUE r_level, r_new_parent_doc;
int level;
int n_args;
xmlDocPtr new_parent_doc;
xmlNodePtr node, dup;
Noko_Node_Get_Struct(self, xmlNode, node);
n_args = rb_scan_args(argc, argv, "02", &r_level, &r_new_parent_doc);
if (n_args < 1) {
r_level = INT2NUM((long)1);
}
level = (int)NUM2INT(r_level);
if (n_args < 2) {
new_parent_doc = node->doc;
} else {
new_parent_doc = noko_xml_document_unwrap(r_new_parent_doc);
}
dup = xmlDocCopyNode(node, new_parent_doc, level);
if (dup == NULL) { return Qnil; }
noko_xml_document_pin_node(dup);
return noko_xml_node_wrap(rb_obj_class(self), dup);
}
|
#each ⇒ Object
Iterate over each attribute name and value pair for this Node.
635 636 637 638 639 |
# File 'lib/nokogiri/xml/node.rb', line 635 def each attribute_nodes.each do |node| yield [node.node_name, node.value] end end |
#element? ⇒ Boolean Also known as: elem?
Returns true if this is an Element node
1181 1182 1183 |
# File 'lib/nokogiri/xml/node.rb', line 1181 def element? type == ELEMENT_NODE end |
#element_children ⇒ Object Also known as: elements
:call-seq:
element_children() → NodeSet
elements() → 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">]>]
1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 |
# File 'ext/nokogiri/xml_node.c', line 1127
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;
}
|
#encode_special_chars(string) ⇒ Object
:call-seq: encode_special_chars(string) → String
Encode any special characters in string
810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 |
# File 'ext/nokogiri/xml_node.c', line 810
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 ⇒ Object
:call-seq:
external_subset()
Get the external subset
907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 |
# File 'ext/nokogiri/xml_node.c', line 907
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 ⇒ Object
:call-seq:
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")] })
1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 |
# File 'ext/nokogiri/xml_node.c', line 1171
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) ⇒ Object
Create a DocumentFragment containing tags
that is relative to this context node.
1022 1023 1024 |
# File 'lib/nokogiri/xml/node.rb', line 1022 def fragment() document.("DocumentFragment").new(document, , self) end |
#fragment? ⇒ Boolean
Returns true if this is a DocumentFragment
1160 1161 1162 |
# File 'lib/nokogiri/xml/node.rb', line 1160 def fragment? type == DOCUMENT_FRAG_NODE end |
#html? ⇒ Boolean
Returns true if this is an HTML4::Document or HTML5::Document node
1140 1141 1142 |
# File 'lib/nokogiri/xml/node.rb', line 1140 def html? type == HTML_DOCUMENT_NODE end |
#inner_html(*args) ⇒ Object
Get the inner_html for this node’s Node#children
1195 1196 1197 |
# File 'lib/nokogiri/xml/node.rb', line 1195 def inner_html(*args) children.map { |x| x.to_html(*args) }.join end |
#inner_html=(node_or_tags) ⇒ Object
Set the content for this Node to node_or_tags
.
node_or_tags
can be a Nokogiri::XML::Node, a Nokogiri::XML::DocumentFragment, or a String containing markup.
⚠ Please note that despite the name, this method will not always parse a String argument as HTML. A String argument will be parsed with the DocumentFragment
parser related to this node’s document.
For example, if the document is an HTML4::Document then the string will be parsed as HTML4 using HTML4::DocumentFragment; but if the document is an XML::Document then it will parse the string as XML using XML::DocumentFragment.
Also see related method children=
338 339 340 |
# File 'lib/nokogiri/xml/node.rb', line 338 def inner_html=() self.children = end |
#internal_subset ⇒ Object
:call-seq:
internal_subset()
Get the internal subset
932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 |
# File 'ext/nokogiri/xml_node.c', line 932
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) ⇒ Boolean Also known as: has_attribute?
Returns true if attribute
is set
1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 |
# File 'ext/nokogiri/xml_node.c', line 1216
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;
}
|
#keys ⇒ Object
Get the attribute names for this Node.
629 630 631 |
# File 'lib/nokogiri/xml/node.rb', line 629 def keys attribute_nodes.map(&:node_name) end |
#kwattr_add(attribute_name, keywords) ⇒ Object
:call-seq:
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.
See also #add_class, #kwattr_values, #kwattr_append, #kwattr_remove
- Parameters
-
attribute_name
(String) The name of the keyword attribute to be modified. -
keywords
(String, Array<String>) Keywords to be added to the attribute namedattribute_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
892 893 894 895 896 897 898 |
# File 'lib/nokogiri/xml/node.rb', line 892 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) ⇒ Object
:call-seq:
kwattr_append(attribute_name, keywords) → self
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 the “rel” attribute.
See also #append_class, #kwattr_values, #kwattr_add, #kwattr_remove
- Parameters
-
attribute_name
(String) The name of the keyword attribute to be modified. -
keywords
(String, Array<String>) Keywords to be added to the attribute namedattribute_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
945 946 947 948 949 950 951 |
# File 'lib/nokogiri/xml/node.rb', line 945 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) ⇒ Object
:call-seq:
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.
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.
See also #remove_class, #kwattr_values, #kwattr_add, #kwattr_append
- Parameters
-
attribute_name
(String) The name of the keyword attribute to be modified. -
keywords
(String, Array<String>) Keywords to be removed from the attribute namedattribute_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 ifkeywords
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
988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 |
# File 'lib/nokogiri/xml/node.rb', line 988 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) ⇒ Object
:call-seq:
kwattr_values(attribute_name) → Array<String>
Fetch 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 the “rel” attribute.
See also #classes, #kwattr_add, #kwattr_append, #kwattr_remove
- 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
838 839 840 |
# File 'lib/nokogiri/xml/node.rb', line 838 def kwattr_values(attribute_name) keywordify(get_attribute(attribute_name) || []) end |
#lang ⇒ Object
Searches the language of a node, i.e. the values of the xml:lang attribute or the one carried by the nearest ancestor.
1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 |
# File 'ext/nokogiri/xml_node.c', line 1556
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= ⇒ Object
Set the language of a node, i.e. the values of the xml:lang attribute.
1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 |
# File 'ext/nokogiri/xml_node.c', line 1535
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 ⇒ Object
:call-seq:
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")] })
1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 |
# File 'ext/nokogiri/xml_node.c', line 1198
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 ⇒ Object
:call-seq:
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:
2007 2008 2009 2010 2011 2012 2013 2014 |
# File 'ext/nokogiri/xml_node.c', line 2007
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) ⇒ Object
Sets the line for this Node. num must be less than 65535.
2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 |
# File 'ext/nokogiri/xml_node.c', line 2022
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) 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) ⇒ Boolean
Returns true if this Node matches selector
1015 1016 1017 |
# File 'lib/nokogiri/xml/node.rb', line 1015 def matches?(selector) ancestors.last.search(selector).include?(self) end |
#namespace ⇒ Object
:call-seq:
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" })
1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 |
# File 'ext/nokogiri/xml_node.c', line 1376
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=(ns) ⇒ Object
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.
437 438 439 440 441 442 443 444 445 446 447 448 |
# File 'lib/nokogiri/xml/node.rb', line 437 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 |
#namespace_definitions ⇒ Object
:call-seq:
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" })]
1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 |
# File 'ext/nokogiri/xml_node.c', line 1417
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 ⇒ Object
:call-seq:
namespace_scopes() → Array<Nokogiri::XML::Namespace>
- Returns
-
Array of all the Namespaces on this node and its ancestors.
See also #namespaces
Example:
doc = Nokogiri::XML(<<~EOF)
<root xmlns="http://example.com/root" xmlns:bar="http://example.com/bar">
<first/>
<second xmlns="http://example.com/child"/>
<third xmlns:foo="http://example.com/foo"/>
</root>
EOF
doc.at_xpath("//root:first", "root" => "http://example.com/root").namespace_scopes
# => [#(Namespace:0x3c { href = "http://example.com/root" }),
# #(Namespace:0x50 { prefix = "bar", href = "http://example.com/bar" })]
doc.at_xpath("//child:second", "child" => "http://example.com/child").namespace_scopes
# => [#(Namespace:0x64 { href = "http://example.com/child" }),
# #(Namespace:0x50 { prefix = "bar", href = "http://example.com/bar" })]
doc.at_xpath("//root:third", "root" => "http://example.com/root").namespace_scopes
# => [#(Namespace:0x78 { prefix = "foo", href = "http://example.com/foo" }),
# #(Namespace:0x3c { href = "http://example.com/root" }),
# #(Namespace:0x50 { prefix = "bar", href = "http://example.com/bar" })]
1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 |
# File 'ext/nokogiri/xml_node.c', line 1468
static VALUE
rb_xml_node_namespace_scopes(VALUE rb_node)
{
xmlNodePtr c_node ;
xmlNsPtr *namespaces;
VALUE scopes = rb_ary_new();
int j;
Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
namespaces = xmlGetNsList(c_node->doc, c_node);
if (!namespaces) {
return scopes;
}
for (j = 0 ; namespaces[j] != NULL ; ++j) {
rb_ary_push(scopes, noko_xml_namespace_wrap(namespaces[j], c_node->doc));
}
xmlFree(namespaces);
return scopes;
}
|
#namespaced_key?(attribute, namespace) ⇒ Boolean
Returns true if attribute
is set with namespace
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 |
# File 'ext/nokogiri/xml_node.c', line 1233
static VALUE
namespaced_key_eh(VALUE self, VALUE attribute, VALUE namespace)
{
xmlNodePtr node;
Noko_Node_Get_Struct(self, xmlNode, node);
if (xmlHasNsProp(node, (xmlChar *)StringValueCStr(attribute),
NIL_P(namespace) ? NULL : (xmlChar *)StringValueCStr(namespace))) {
return Qtrue;
}
return Qfalse;
}
|
#namespaces ⇒ Object
:call-seq:
namespaces() → Hash<String(Namespace#prefix) ⇒ String(Namespace#href)>
Fetch all the namespaces on this node and its ancestors.
Note that the keys in this hash XML attributes that would be used to define this namespace, such as “xmlns:prefix”, not just the prefix.
The default namespace for this node will be included with key “xmlns”.
See also #namespace_scopes
- Returns
-
Hash containing all the namespaces on this node and its ancestors. The hash keys are the namespace prefix, and the hash value for each key is the namespace URI.
Example:
doc = Nokogiri::XML(<<~EOF)
<root xmlns="http://example.com/root" xmlns:in_scope="http://example.com/in_scope">
<first/>
<second xmlns="http://example.com/child"/>
<third xmlns:foo="http://example.com/foo"/>
</root>
EOF
doc.at_xpath("//root:first", "root" => "http://example.com/root").namespaces
# => {"xmlns"=>"http://example.com/root",
# "xmlns:in_scope"=>"http://example.com/in_scope"}
doc.at_xpath("//child:second", "child" => "http://example.com/child").namespaces
# => {"xmlns"=>"http://example.com/child",
# "xmlns:in_scope"=>"http://example.com/in_scope"}
doc.at_xpath("//root:third", "root" => "http://example.com/root").namespaces
# => {"xmlns:foo"=>"http://example.com/foo",
# "xmlns"=>"http://example.com/root",
# "xmlns:in_scope"=>"http://example.com/in_scope"}
1116 1117 1118 1119 1120 1121 1122 |
# File 'lib/nokogiri/xml/node.rb', line 1116 def namespaces namespace_scopes.each_with_object({}) do |ns, hash| prefix = ns.prefix key = prefix ? "xmlns:#{prefix}" : "xmlns" hash[key] = ns.href end end |
#content= ⇒ Object
Set the content for this Node
1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 |
# File 'ext/nokogiri/xml_node.c', line 1511
static VALUE
set_native_content(VALUE self, VALUE content)
{
xmlNodePtr node, child, next ;
Noko_Node_Get_Struct(self, xmlNode, node);
child = node->children;
while (NULL != child) {
next = child->next ;
xmlUnlinkNode(child) ;
noko_xml_document_pin_node(child);
child = next ;
}
xmlNodeSetContent(node, (xmlChar *)StringValueCStr(content));
return content;
}
|
#next_element ⇒ Object
Returns the next Nokogiri::XML::Element type sibling node.
1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 |
# File 'ext/nokogiri/xml_node.c', line 1057
static VALUE
next_element(VALUE self)
{
xmlNodePtr node, sibling;
Noko_Node_Get_Struct(self, xmlNode, node);
sibling = xmlNextElementSibling(node);
if (!sibling) { return Qnil; }
return noko_xml_node_wrap(Qnil, sibling);
}
|
#next_sibling ⇒ Object Also known as: next
Returns the next sibling node
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 |
# File 'ext/nokogiri/xml_node.c', line 1021
static VALUE
next_sibling(VALUE self)
{
xmlNodePtr node, sibling;
Noko_Node_Get_Struct(self, xmlNode, node);
sibling = node->next;
if (!sibling) { return Qnil; }
return noko_xml_node_wrap(Qnil, sibling) ;
}
|
#name ⇒ Object Also known as: name
Returns the name for this Node
1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 |
# File 'ext/nokogiri/xml_node.c', line 1621
static VALUE
get_name(VALUE self)
{
xmlNodePtr node;
Noko_Node_Get_Struct(self, xmlNode, node);
if (node->name) {
return NOKOGIRI_STR_NEW2(node->name);
}
return Qnil;
}
|
#name=(new_name) ⇒ Object Also known as: name=
Set the name for this Node
1606 1607 1608 1609 1610 1611 1612 1613 |
# File 'ext/nokogiri/xml_node.c', line 1606
static VALUE
set_name(VALUE self, VALUE new_name)
{
xmlNodePtr node;
Noko_Node_Get_Struct(self, xmlNode, node);
xmlNodeSetName(node, (xmlChar *)StringValueCStr(new_name));
return new_name;
}
|
#node_type ⇒ Object Also known as: type
Get the type for this Node
1497 1498 1499 1500 1501 1502 1503 |
# File 'ext/nokogiri/xml_node.c', line 1497
static VALUE
node_type(VALUE self)
{
xmlNodePtr node;
Noko_Node_Get_Struct(self, xmlNode, node);
return INT2NUM(node->type);
}
|
#parent ⇒ Object
Get the parent Node for this Node
1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 |
# File 'ext/nokogiri/xml_node.c', line 1588
static VALUE
get_parent(VALUE self)
{
xmlNodePtr node, parent;
Noko_Node_Get_Struct(self, xmlNode, node);
parent = node->parent;
if (!parent) { return Qnil; }
return noko_xml_node_wrap(Qnil, parent) ;
}
|
#parent=(parent_node) ⇒ Object
Set the parent Node for this Node
417 418 419 |
# File 'lib/nokogiri/xml/node.rb', line 417 def parent=(parent_node) parent_node.add_child(self) end |
#parse(string_or_io, options = nil) {|options| ... } ⇒ Object
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
.
1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 |
# File 'lib/nokogiri/xml/node.rb', line 1030 def parse(string_or_io, = nil) ## # When the current node is unparented and not an element node, use the # document as the parsing context instead. Otherwise, the in-context # parser cannot find an element or a document node. # Document Fragments are also not usable by the in-context parser. if !element? && !document? && (!parent || parent.fragment?) return document.parse(string_or_io, ) end ||= (document.html? ? ParseOptions::DEFAULT_HTML : ParseOptions::DEFAULT_XML) = Nokogiri::XML::ParseOptions.new() if Integer === yield if block_given? contents = if string_or_io.respond_to?(:read) string_or_io.read else string_or_io end return Nokogiri::XML::NodeSet.new(document) if contents.empty? # libxml2 does not obey the +recover+ option after encountering errors during +in_context+ # parsing, and so this horrible hack is here to try to emulate recovery behavior. # # Unfortunately, this means we're no longer parsing "in context" and so namespaces that # would have been inherited from the context node won't be handled correctly. This hack was # written in 2010, and I regret it, because it's silently degrading functionality in a way # that's not easily prevented (or even detected). # # I think preferable behavior would be to either: # # a. add an error noting that we "fell back" and pointing the user to turning off the +recover+ option # b. don't recover, but raise a sensible exception # # For context and background: https://github.com/sparklemotion/nokogiri/issues/313 # FIXME bug report: https://github.com/sparklemotion/nokogiri/issues/2092 error_count = document.errors.length node_set = in_context(contents, .to_i) if node_set.empty? && (document.errors.length > error_count) if .recover? fragment = document.("DocumentFragment").parse(contents) node_set = fragment.children else raise document.errors[error_count] end end node_set end |
#path ⇒ Object
Returns the path associated with this Node
1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 |
# File 'ext/nokogiri/xml_node.c', line 1638
static VALUE
rb_xml_node_path(VALUE rb_node)
{
xmlNodePtr c_node;
xmlChar *c_path ;
VALUE rval;
Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
c_path = xmlGetNodePath(c_node);
if (c_path == NULL) {
// see https://github.com/sparklemotion/nokogiri/issues/2250
// this behavior is clearly undesirable, but is what libxml <= 2.9.10 returned, and so we
// do this for now to preserve the behavior across libxml2 versions.
rval = NOKOGIRI_STR_NEW2("?");
} else {
rval = NOKOGIRI_STR_NEW2(c_path);
xmlFree(c_path);
}
return rval ;
}
|
#pointer_id ⇒ Object
:call-seq: pointer_id() → Integer
- Returns
-
A unique id for this node based on the internal memory structures. This method is used by #== to determine node identity.
796 797 798 799 800 801 802 803 |
# File 'ext/nokogiri/xml_node.c', line 796
static VALUE
rb_xml_node_pointer_id(VALUE self)
{
xmlNodePtr node;
Noko_Node_Get_Struct(self, xmlNode, node);
return rb_uint2inum((uintptr_t)(node));
}
|
#prepend_child(node_or_tags) ⇒ Object
Add node_or_tags
as the first 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 add_child
.
168 169 170 171 172 173 174 175 176 177 |
# File 'lib/nokogiri/xml/node.rb', line 168 def prepend_child() if (first = children.first) # Mimic the error add_child would raise. raise "Document already has a root node" if document? && !(.comment? || .processing_instruction?) first.__send__(:add_sibling, :previous, ) else add_child() end end |
#previous_element ⇒ Object
Returns the previous Nokogiri::XML::Element type sibling node.
1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 |
# File 'ext/nokogiri/xml_node.c', line 1075
static VALUE
previous_element(VALUE self)
{
xmlNodePtr node, sibling;
Noko_Node_Get_Struct(self, xmlNode, node);
/*
* note that we don't use xmlPreviousElementSibling here because it's buggy pre-2.7.7.
*/
sibling = node->prev;
if (!sibling) { return Qnil; }
while (sibling && sibling->type != XML_ELEMENT_NODE) {
sibling = sibling->prev;
}
return sibling ? noko_xml_node_wrap(Qnil, sibling) : Qnil ;
}
|
#previous_sibling ⇒ Object Also known as: previous
Returns the previous sibling node
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 |
# File 'ext/nokogiri/xml_node.c', line 1039
static VALUE
previous_sibling(VALUE self)
{
xmlNodePtr node, sibling;
Noko_Node_Get_Struct(self, xmlNode, node);
sibling = node->prev;
if (!sibling) { return Qnil; }
return noko_xml_node_wrap(Qnil, sibling);
}
|
#processing_instruction? ⇒ Boolean
Returns true if this is a ProcessingInstruction node
1150 1151 1152 |
# File 'lib/nokogiri/xml/node.rb', line 1150 def processing_instruction? type == PI_NODE end |
#read_only? ⇒ Boolean
Is this a read only node?
1175 1176 1177 1178 |
# File 'lib/nokogiri/xml/node.rb', line 1175 def read_only? # According to gdome2, these are read-only node types [NOTATION_NODE, ENTITY_NODE, ENTITY_DECL].include?(type) end |
#remove_attribute(name) ⇒ Object Also known as: delete
Remove the attribute named name
643 644 645 646 647 |
# File 'lib/nokogiri/xml/node.rb', line 643 def remove_attribute(name) attr = attributes[name].remove if key?(name) clear_xpath_context if Nokogiri.jruby? attr end |
#remove_class(names = nil) ⇒ Object
:call-seq:
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>
809 810 811 |
# File 'lib/nokogiri/xml/node.rb', line 809 def remove_class(names = nil) kwattr_remove("class", names) end |
#replace(node_or_tags) ⇒ Object
Replace this Node with node_or_tags
.
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 swap
.
369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 |
# File 'lib/nokogiri/xml/node.rb', line 369 def replace() raise("Cannot replace a node with no parent") unless parent # We cannot replace a text node directly, otherwise libxml will return # an internal error at parser.c:13031, I don't know exactly why # libxml is trying to find a parent node that is an element or document # so I can't tell if this is bug in libxml or not. issue #775. if text? replacee = Nokogiri::XML::Node.new("dummy", document) add_previous_sibling_node(replacee) unlink return replacee.replace() end = parent.coerce() if .is_a?(XML::NodeSet) .each { |n| add_previous_sibling(n) } unlink else replace_node() end end |
#serialize(*args, &block) ⇒ Object
Serialize Node using options
. Save options can also be set using a block.
See also Nokogiri::XML::Node::SaveOptions and Node@Serialization+and+Generating+Output.
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
1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 |
# File 'lib/nokogiri/xml/node.rb', line 1280 def serialize(*args, &block) # TODO: deprecate non-hash options, see 46c68ed 2009-06-20 for context = if args.first.is_a?(Hash) args.shift else { encoding: args[0], save_with: args[1], } end [:encoding] ||= document.encoding encoding = Encoding.find([:encoding] || "UTF-8") io = StringIO.new(String.new(encoding: encoding)) write_to(io, , &block) io.string end |
#swap(node_or_tags) ⇒ Object
Swap this Node for node_or_tags
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 replace
.
403 404 405 406 |
# File 'lib/nokogiri/xml/node.rb', line 403 def swap() replace() self end |
#text? ⇒ Boolean
Returns true if this is a Text node
1155 1156 1157 |
# File 'lib/nokogiri/xml/node.rb', line 1155 def text? type == TEXT_NODE end |
#to_html(options = {}) ⇒ Object
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.
1307 1308 1309 |
# File 'lib/nokogiri/xml/node.rb', line 1307 def to_html( = {}) to_format(SaveOptions::DEFAULT_HTML, ) end |
#to_s ⇒ Object
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.
1190 1191 1192 |
# File 'lib/nokogiri/xml/node.rb', line 1190 def to_s document.xml? ? to_xml : to_html end |
#to_xhtml(options = {}) ⇒ Object
Serialize this Node to XHTML using options
doc.to_xhtml(indent: 5, encoding: 'UTF-8')
See Node#write_to for a list of options
1328 1329 1330 |
# File 'lib/nokogiri/xml/node.rb', line 1328 def to_xhtml( = {}) to_format(SaveOptions::DEFAULT_XHTML, ) end |
#to_xml(options = {}) ⇒ Object
Serialize this Node to XML using options
doc.to_xml(indent: 5, encoding: 'UTF-8')
See Node#write_to for a list of options
1317 1318 1319 1320 |
# File 'lib/nokogiri/xml/node.rb', line 1317 def to_xml( = {}) [:save_with] ||= SaveOptions::DEFAULT_XML serialize() end |
#traverse {|_self| ... } ⇒ Object
Yields self and all children to block
recursively.
1233 1234 1235 1236 |
# File 'lib/nokogiri/xml/node.rb', line 1233 def traverse(&block) children.each { |j| j.traverse(&block) } yield(self) end |
#unlink ⇒ Object Also known as: remove
:call-seq:
unlink() → self
Unlink this node from its current context.
1004 1005 1006 1007 1008 1009 1010 1011 1012 |
# File 'ext/nokogiri/xml_node.c', line 1004
static VALUE
unlink_node(VALUE self)
{
xmlNodePtr node;
Noko_Node_Get_Struct(self, xmlNode, node);
xmlUnlinkNode(node);
noko_xml_document_pin_node(node);
return self;
}
|
#value?(value) ⇒ Boolean
Does this Node’s attributes include <value>
623 624 625 |
# File 'lib/nokogiri/xml/node.rb', line 623 def value?(value) values.include?(value) end |
#values ⇒ Object
Get the attribute values for this Node.
617 618 619 |
# File 'lib/nokogiri/xml/node.rb', line 617 def values attribute_nodes.map(&:value) end |
#wrap(node_or_tags) ⇒ Object
:call-seq:
wrap(markup) -> self
wrap(node) -> self
Wrap this Node with the node parsed from markup
or a dup of the node
.
- Parameters
-
markup (String) Markup that is parsed and used as the wrapper. This node’s parent, if it exists, is used as the context node for parsing; otherwise the associated document is used. If the parsed fragment has multiple roots, the first root node is used as the wrapper.
-
node (Nokogiri::XML::Node) An element that is ‘#dup`ed and used as the wrapper.
- Returns
-
self
, to support chaining.
Also see NodeSet#wrap
Example with a String
argument:
doc = Nokogiri::HTML5(<<~HTML)
<html><body>
<a>asdf</a>
</body></html>
HTML
doc.at_css("a").wrap("<div></div>")
doc.to_html
# => <html><head></head><body>
# <div><a>asdf</a></div>
# </body></html>
Example with a Node
argument:
doc = Nokogiri::HTML5(<<~HTML)
<html><body>
<a>asdf</a>
</body></html>
HTML
doc.at_css("a").wrap(doc.create_element("div"))
doc.to_html
# <html><head></head><body>
# <div><a>asdf</a></div>
# </body></html>
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 |
# File 'lib/nokogiri/xml/node.rb', line 223 def wrap() case when String context_node = parent || document new_parent = context_node.coerce().first if new_parent.nil? raise "Failed to parse '#{}' in the context of a '#{context_node.name}' element" end when XML::Node new_parent = .dup else raise ArgumentError, "Requires a String or Node argument, and cannot accept a #{.class}" end if parent add_next_sibling(new_parent) else new_parent.unlink end new_parent.add_child(self) self end |
#write_html_to(io, options = {}) ⇒ Object
Write Node as HTML to io
with options
See Node#write_to for a list of options
1385 1386 1387 |
# File 'lib/nokogiri/xml/node.rb', line 1385 def write_html_to(io, = {}) write_format_to(SaveOptions::DEFAULT_HTML, io, ) end |
#write_to(io, *options) {|config| ... } ⇒ Object
:call-seq:
write_to(io, *)
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 to2
) -
: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)
1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 |
# File 'lib/nokogiri/xml/node.rb', line 1356 def write_to(io, *) = .first.is_a?(Hash) ? .shift : {} encoding = [:encoding] || [0] || document.encoding if Nokogiri.jruby? = [:save_with] || [1] indent_times = [:indent] || 0 else = [:save_with] || [1] || SaveOptions::FORMAT indent_times = [:indent] || 2 end indent_text = [: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(.to_i) yield config if block_given? encoding = encoding.is_a?(Encoding) ? encoding.name : encoding native_write_to(io, encoding, indentation, config.) end |
#write_xhtml_to(io, options = {}) ⇒ Object
Write Node as XHTML to io
with options
See Node#write_to for a list of options
1393 1394 1395 |
# File 'lib/nokogiri/xml/node.rb', line 1393 def write_xhtml_to(io, = {}) write_format_to(SaveOptions::DEFAULT_XHTML, io, ) end |
#write_xml_to(io, options = {}) ⇒ Object
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
1403 1404 1405 1406 |
# File 'lib/nokogiri/xml/node.rb', line 1403 def write_xml_to(io, = {}) [:save_with] ||= SaveOptions::DEFAULT_XML write_to(io, ) end |
#xml? ⇒ Boolean
Returns true if this is an XML::Document node
1135 1136 1137 |
# File 'lib/nokogiri/xml/node.rb', line 1135 def xml? type == DOCUMENT_NODE end |