class LibXML::XML::Node
Nodes are the primary objects that make up an XML
document. The node class represents most node types that are found in an XML
document (but not LibXML::XML::Attributes
, see LibXML::XML::Attr
). It exposes libxml’s full API for creating, querying moving and deleting node objects. Many of these methods are documented in the DOM Level 3 specification found at: www.w3.org/TR/DOM-Level-3-Core/.
Constants
- ATTRIBUTE_DECL
- ATTRIBUTE_NODE
- CDATA_SECTION_NODE
- COMMENT_NODE
- DOCB_DOCUMENT_NODE
- DOCUMENT_FRAG_NODE
- DOCUMENT_NODE
- DOCUMENT_TYPE_NODE
- DTD_NODE
- ELEMENT_DECL
- ELEMENT_NODE
- ENTITY_DECL
- ENTITY_NODE
- ENTITY_REF_NODE
- HTML_DOCUMENT_NODE
- NAMESPACE_DECL
- NOTATION_NODE
- PI_NODE
- SPACE_DEFAULT
- SPACE_NOT_INHERIT
- SPACE_PRESERVE
- TEXT_NODE
- XINCLUDE_END
- XINCLUDE_START
- XLINK_ACTUATE_AUTO
- XLINK_ACTUATE_NONE
- XLINK_ACTUATE_ONREQUEST
- XLINK_SHOW_EMBED
- XLINK_SHOW_NEW
- XLINK_SHOW_NONE
- XLINK_SHOW_REPLACE
- XLINK_TYPE_EXTENDED
- XLINK_TYPE_EXTENDED_SET
- XLINK_TYPE_NONE
- XLINK_TYPE_SIMPLE
Public Class Methods
Source
static VALUE rxml_node_initialize(int argc, VALUE *argv, VALUE self) { VALUE name; VALUE content; VALUE ns; xmlNodePtr xnode = NULL; xmlNsPtr xns = NULL; rb_scan_args(argc, argv, "12", &name, &content, &ns); name = rb_obj_as_string(name); if (!NIL_P(ns)) Data_Get_Struct(ns, xmlNs, xns); xnode = xmlNewNode(xns, (xmlChar*) StringValuePtr(name)); if (xnode == NULL) rxml_raise(xmlGetLastError()); // Link the ruby wrapper to the underlying libxml node RDATA(self)->data = xnode; // Ruby is in charge of managing this node's memory rxml_node_manage(xnode, self); if (!NIL_P(content)) rxml_node_content_set(self, content); return self; }
Creates a new element with the specified name, content and namespace. The content and namespace may be nil.
Source
static VALUE rxml_node_new_cdata(int argc, VALUE *argv, VALUE klass) { VALUE content = Qnil; xmlNodePtr xnode; rb_scan_args(argc, argv, "01", &content); if (NIL_P(content)) { xnode = xmlNewCDataBlock(NULL, NULL, 0); } else { content = rb_obj_as_string(content); xnode = xmlNewCDataBlock(NULL, (xmlChar*) StringValuePtr(content), (int)RSTRING_LEN(content)); } if (xnode == NULL) rxml_raise(xmlGetLastError()); return rxml_node_wrap(xnode); }
Create a new CDATA node, optionally setting the node’s content.
Source
static VALUE rxml_node_new_comment(int argc, VALUE *argv, VALUE klass) { VALUE content = Qnil; xmlNodePtr xnode; rb_scan_args(argc, argv, "01", &content); if (NIL_P(content)) { xnode = xmlNewComment(NULL); } else { content = rb_obj_as_string(content); xnode = xmlNewComment((xmlChar*) StringValueCStr(content)); } if (xnode == NULL) rxml_raise(xmlGetLastError()); return rxml_node_wrap(xnode); }
Create a new comment node, optionally setting the node’s content.
Source
static VALUE rxml_node_new_pi(int argc, VALUE *argv, VALUE klass) { VALUE name = Qnil; VALUE content = Qnil; xmlNodePtr xnode; rb_scan_args(argc, argv, "11", &name, &content); if (NIL_P(name)) { rb_raise(rb_eRuntimeError, "You must provide me with a name for a PI."); } name = rb_obj_as_string(name); if (NIL_P(content)) { xnode = xmlNewPI((xmlChar*) StringValuePtr(name), NULL); } else { content = rb_obj_as_string(content); xnode = xmlNewPI((xmlChar*) StringValuePtr(name), (xmlChar*) StringValueCStr(content)); } if (xnode == NULL) rxml_raise(xmlGetLastError()); return rxml_node_wrap(xnode); }
Create a new pi node, optionally setting the node’s content.
Source
static VALUE rxml_node_new_text(VALUE klass, VALUE content) { xmlNodePtr xnode; Check_Type(content, T_STRING); content = rb_obj_as_string(content); xnode = xmlNewText((xmlChar*) StringValueCStr(content)); if (xnode == NULL) rxml_raise(xmlGetLastError()); return rxml_node_wrap(xnode); }
Create a new text node.
Public Instance Methods
Source
static VALUE rxml_node_content_add(VALUE self, VALUE obj) { xmlNodePtr xnode; VALUE str; xnode = rxml_get_xnode(self); /* XXX This should only be legal for a CDATA type node, I think, * resulting in a merge of content, as if a string were passed * danj 070827 */ if (rb_obj_is_kind_of(obj, cXMLNode)) { rxml_node_modify_dom(self, obj, xmlAddChild); } else { str = rb_obj_as_string(obj); if (NIL_P(str) || TYPE(str) != T_STRING) rb_raise(rb_eTypeError, "invalid argument: must be string or XML::Node"); xmlNodeAddContent(xnode, (xmlChar*) StringValuePtr(str)); } return self; }
Add the specified text or XML::Node
as a new child node to the current node.
If the specified argument is a string, it should be a raw string that contains unescaped XML
special characters. Entity references are not supported.
The method will return the current node.
Source
static VALUE rxml_node_attribute_get(VALUE self, VALUE name) { VALUE attributes = rxml_node_attributes_get(self); return rxml_attributes_attribute_get(attributes, name); }
Obtain the named property.
Source
static VALUE rxml_node_property_set(VALUE self, VALUE name, VALUE value) { VALUE attributes = rxml_node_attributes_get(self); return rxml_attributes_attribute_set(attributes, name, value); }
Set the named property.
Source
# File lib/libxml/node.rb, line 207 def attribute? node_type == ATTRIBUTE_NODE end
Specifies if this is an attribute node
Source
# File lib/libxml/node.rb, line 212 def attribute_decl? node_type == ATTRIBUTE_DECL end
Specifies if this is an attribute declaration node
Source
static VALUE rxml_node_attributes_get(VALUE self) { xmlNodePtr xnode; xnode = rxml_get_xnode(self); return rxml_attributes_new(xnode); }
Returns the XML::Attributes
for this node.
Source
# File lib/libxml/node.rb, line 9 def attributes? attributes.length > 0 end
Determines whether this node has attributes
Source
static VALUE rxml_node_base_uri_get(VALUE self) { xmlNodePtr xnode; xmlChar* base_uri; VALUE result = Qnil; xnode = rxml_get_xnode(self); if (xnode->doc == NULL) return (result); base_uri = xmlNodeGetBase(xnode->doc, xnode); if (base_uri) { result = rxml_new_cstr( base_uri, NULL); xmlFree(base_uri); } return (result); }
Obtain this node’s base URI.
Source
static VALUE rxml_node_base_uri_set(VALUE self, VALUE uri) { xmlNodePtr xnode; Check_Type(uri, T_STRING); xnode = rxml_get_xnode(self); if (xnode->doc == NULL) return (Qnil); xmlNodeSetBase(xnode, (xmlChar*) StringValuePtr(uri)); return (Qtrue); }
Set this node’s base URI.
Source
# File lib/libxml/node.rb, line 217 def cdata? node_type == CDATA_SECTION_NODE end
Specifies if this is an CDATA node
Source
# File lib/libxml/node.rb, line 131 def children entries end
Returns this node’s children as an array.
Source
# File lib/libxml/node.rb, line 15 def clone copy(false) end
Create a shallow copy of the node. To create a deep copy call Node#copy(true)
Source
# File lib/libxml/node.rb, line 222 def comment? node_type == COMMENT_NODE end
Specifies if this is an comment node
Source
static VALUE rxml_node_content_get(VALUE self) { xmlNodePtr xnode; xmlChar *content; VALUE result = Qnil; xnode = rxml_get_xnode(self); content = xmlNodeGetContent(xnode); if (content) { result = rxml_new_cstr(content, NULL); xmlFree(content); } return result; }
Obtain this node’s content as a string.
Source
static VALUE rxml_node_content_set(VALUE self, VALUE content) { xmlNodePtr xnode; xmlChar* encoded_content; Check_Type(content, T_STRING); xnode = rxml_get_xnode(self); encoded_content = xmlEncodeSpecialChars(xnode->doc, (xmlChar*) StringValuePtr(content)); xmlNodeSetContent(xnode, encoded_content); xmlFree(encoded_content); return (Qtrue); }
Set this node’s content to the specified string.
Source
# File lib/libxml/node.rb, line 53 def context(nslist = nil) if not self.doc raise(TypeError, "A node must belong to a document before a xpath context can be created") end context = XPath::Context.new(self.doc) context.node = self context.register_namespaces_from_node(self) context.register_namespaces_from_node(self.doc.root) context.register_namespaces(nslist) if nslist context end
Returns a new XML::XPathContext for the current node.
Namespaces
is an optional array of XML::NS objects
Source
static VALUE rxml_node_copy(VALUE self, VALUE deep) { xmlNodePtr xnode; xmlNodePtr xcopy; int recursive = (deep == Qnil || deep == Qfalse) ? 0 : 1; xnode = rxml_get_xnode(self); xcopy = xmlCopyNode(xnode, recursive); if (xcopy) return rxml_node_wrap(xcopy); else return Qnil; }
Creates a copy of this node. To create a shallow copy set the deep parameter to false. To create a deep copy set the deep parameter to true.
Source
static VALUE rxml_node_debug(VALUE self) { #ifdef LIBXML_DEBUG_ENABLED xmlNodePtr xnode; xnode = rxml_get_xnode(self); xmlDebugDumpNode(NULL, xnode, 2); return Qtrue; #else rb_warn("libxml was compiled without debugging support."); return Qfalse; #endif }
Print libxml debugging information to stdout. Requires that libxml was compiled with debugging enabled.
Source
static VALUE rxml_node_doc(VALUE self) { xmlDocPtr xdoc = NULL; xmlNodePtr xnode = rxml_get_xnode(self); switch (xnode->type) { case XML_DOCUMENT_NODE: #ifdef LIBXML_DOCB_ENABLED case XML_DOCB_DOCUMENT_NODE: #endif case XML_HTML_DOCUMENT_NODE: case XML_NAMESPACE_DECL: break; case XML_ATTRIBUTE_NODE: xdoc = (xmlDocPtr)((xmlAttrPtr) xnode->doc); break; default: xdoc = xnode->doc; } if (xdoc == NULL) return (Qnil); return (VALUE)xdoc->_private; }
Obtain the XML::Document
this node belongs to.
Source
# File lib/libxml/node.rb, line 227 def docbook_doc? node_type == DOCB_DOCUMENT_NODE end
Specifies if this is an docbook node
Source
# File lib/libxml/node.rb, line 232 def doctype? node_type == DOCUMENT_TYPE_NODE end
Specifies if this is an doctype node
Source
# File lib/libxml/node.rb, line 237 def document? node_type == DOCUMENT_NODE end
Specifies if this is an document node
Source
# File lib/libxml/node.rb, line 242 def dtd? node_type == DTD_NODE end
Specifies if this is an DTD node
Source
# File lib/libxml/node.rb, line 43 def dup copy(false) end
Create a shallow copy of the node. To create a deep copy call Node#copy(true)
Source
static VALUE rxml_node_each(VALUE self) { xmlNodePtr xnode; xmlNodePtr xcurrent; xnode = rxml_get_xnode(self); xcurrent = xnode->children; while (xcurrent) { /* The user could remove this node, so first stache away the next node. */ xmlNodePtr xnext = xcurrent->next; rb_yield(rxml_node_wrap(xcurrent)); xcurrent = xnext; } return Qnil; }
Iterates over this node’s children, including text nodes, element nodes, etc. If you wish to iterate only over child elements, use XML::Node#each_element
.
doc = XML::Document.new('model/books.xml') doc.root.each {|node| puts node}
Source
# File lib/libxml/node.rb, line 103 def each_attr attributes.each do |attr| yield(attr) end end
——- Traversal —————- Iterates over this node’s attributes.
doc = XML::Document.new('model/books.xml') doc.root.each_attr {|attr| puts attr}
Source
# File lib/libxml/node.rb, line 114 def each_element each do |node| yield(node) if node.node_type == ELEMENT_NODE end end
Iterates over this node’s child elements (nodes that have a node_type
== ELEMENT_NODE
).
doc = XML::Document.new('model/books.xml') doc.root.each_element {|element| puts element}
Source
# File lib/libxml/node.rb, line 247 def element? node_type == ELEMENT_NODE end
Specifies if this is an element node
Source
# File lib/libxml/node.rb, line 257 def element_decl? node_type == ELEMENT_DECL end
Specifies if this is an element declaration node
Determine whether this node is an empty or whitespace only text-node.
Source
# File lib/libxml/node.rb, line 252 def entity? node_type == ENTITY_NODE end
Specifies if this is an entity node
Source
# File lib/libxml/node.rb, line 262 def entity_ref? node_type == ENTITY_REF_NODE end
Specifies if this is an entity reference node
Source
static VALUE rxml_node_eql_q(VALUE self, VALUE other) { if (self == other) { return Qtrue; } else if (NIL_P(other)) { return Qfalse; } else { xmlNodePtr xnode = rxml_get_xnode(self); xmlNodePtr xnode_other = rxml_get_xnode(other); return xnode == xnode_other ? Qtrue : Qfalse; } }
Test equality between the two nodes. Two nodes are equal if they are the same node.
Source
# File lib/libxml/node.rb, line 74 def find(xpath, nslist = nil) self.context(nslist).find(xpath) end
Return nodes matching the specified xpath expression. For more information, please refer to the documentation for XML::Document#find
.
Namespaces
is an optional array of XML::NS objects
Source
# File lib/libxml/node.rb, line 84 def find_first(xpath, nslist = nil) find(xpath, nslist).first end
Return the first node matching the specified xpath expression. For more information, please refer to the documentation for the find
method.
Source
static VALUE rxml_node_first_get(VALUE self) { xmlNodePtr xnode; xnode = rxml_get_xnode(self); if (xnode->children) return (rxml_node_wrap(xnode->children)); else return (Qnil); }
Returns this node’s first child node if any.
Source
# File lib/libxml/node.rb, line 126 def first? not first.nil? end
Determines whether this node has a first node
Source
# File lib/libxml/node.rb, line 267 def fragment? node_type == DOCUMENT_FRAG_NODE end
Specifies if this is a fragment node
Source
# File lib/libxml/node.rb, line 272 def html_doc? node_type == HTML_DOCUMENT_NODE end
Specifies if this is a html document node
Source
# File lib/libxml/node.rb, line 26 def inner_xml(options = Hash.new) io = nil self.each do |node| xml = node.to_s(options) # Create the string IO here since we now know the encoding io = create_string_io(xml) unless io io << xml end io ? io.string : nil end
Converts a node’s children to a string representation. To include the node, use XML::Node#to_s
. For more information about the supported options, see XML::Node#to_s
.
Source
static VALUE rxml_node_lang_get(VALUE self) { xmlNodePtr xnode; xmlChar *lang; VALUE result = Qnil; xnode = rxml_get_xnode(self); lang = xmlNodeGetLang(xnode); if (lang) { result = rxml_new_cstr( lang, NULL); xmlFree(lang); } return (result); }
Obtain the language set for this node, if any. This is set in XML
via the xml:lang attribute.
Source
static VALUE rxml_node_lang_set(VALUE self, VALUE lang) { xmlNodePtr xnode; Check_Type(lang, T_STRING); xnode = rxml_get_xnode(self); xmlNodeSetLang(xnode, (xmlChar*) StringValuePtr(lang)); return (Qtrue); }
Set the language for this node. This affects the value of the xml:lang attribute.
Source
static VALUE rxml_node_last_get(VALUE self) { xmlNodePtr xnode; xnode = rxml_get_xnode(self); if (xnode->last) return (rxml_node_wrap(xnode->last)); else return (Qnil); }
Obtain the last child node of this node, if any.
Source
# File lib/libxml/node.rb, line 146 def last? not last.nil? end
Determines whether this node has a last node
Source
static VALUE rxml_node_line_num(VALUE self) { xmlNodePtr xnode; long line_num; xnode = rxml_get_xnode(self); line_num = xmlGetLineNo(xnode); if (line_num == -1) return (Qnil); else return (LONG2NUM((long) line_num)); }
Obtain the line number (in the XML
document) that this node was read from. If default_line_numbers
is set false (the default), this method returns zero.
Source
static VALUE rxml_node_name_get(VALUE self) { xmlNodePtr xnode; const xmlChar *name; xnode = rxml_get_xnode(self); switch (xnode->type) { case XML_DOCUMENT_NODE: #ifdef LIBXML_DOCB_ENABLED case XML_DOCB_DOCUMENT_NODE: #endif case XML_HTML_DOCUMENT_NODE: { xmlDocPtr doc = (xmlDocPtr) xnode; name = doc->URL; break; } case XML_ATTRIBUTE_NODE: { xmlAttrPtr attr = (xmlAttrPtr) xnode; name = attr->name; break; } case XML_NAMESPACE_DECL: { xmlNsPtr ns = (xmlNsPtr) xnode; name = ns->prefix; break; } default: name = xnode->name; break; } if (xnode->name == NULL) return (Qnil); else return (rxml_new_cstr( name, NULL)); }
Obtain this node’s name.
Source
static VALUE rxml_node_name_set(VALUE self, VALUE name) { xmlNodePtr xnode; const xmlChar *xname; Check_Type(name, T_STRING); xnode = rxml_get_xnode(self); xname = (const xmlChar*)StringValuePtr(name); /* Note: calling xmlNodeSetName() for a text node is ignored by libXML. */ xmlNodeSetName(xnode, xname); return (Qtrue); }
Set this node’s name.
Source
# File lib/libxml/node.rb, line 278 def namespace? node_type == NAMESPACE_DECL end
Specifies if this is a namespace node (not if it has a namepsace)
Source
# File lib/libxml/node.rb, line 94 def namespaces @namespaces ||= XML::Namespaces.new(self) end
Returns this node’s XML::Namespaces
object, which is used to access the namespaces associated with this node.
Source
static VALUE rxml_node_next_get(VALUE self) { xmlNodePtr xnode; xnode = rxml_get_xnode(self); if (xnode->next) return (rxml_node_wrap(xnode->next)); else return (Qnil); }
Returns the next sibling node if one exists.
Source
static VALUE rxml_node_next_set(VALUE self, VALUE next) { return rxml_node_modify_dom(self, next, xmlAddNextSibling); }
Adds the specified node as the next sibling of the current node. If the node already exists in the document, it is first removed from its existing context. Any adjacent text nodes will be merged together, meaning the returned node may be different than the original node.
Source
# File lib/libxml/node.rb, line 136 def next? not self.next.nil? end
Determines whether this node has a next node
Source
static VALUE rxml_node_type(VALUE self) { xmlNodePtr xnode; xnode = rxml_get_xnode(self); return (INT2NUM(xnode->type)); }
Obtain this node’s type identifier.
Source
# File lib/libxml/node.rb, line 154 def node_type_name case node_type # Most common choices first when ATTRIBUTE_NODE 'attribute' when DOCUMENT_NODE 'document_xml' when ELEMENT_NODE 'element' when TEXT_NODE 'text' # Now the rest when ATTRIBUTE_DECL 'attribute_decl' when CDATA_SECTION_NODE 'cdata' when COMMENT_NODE 'comment' when DOCB_DOCUMENT_NODE 'document_docbook' when DOCUMENT_FRAG_NODE 'fragment' when DOCUMENT_TYPE_NODE 'doctype' when DTD_NODE 'dtd' when ELEMENT_DECL 'elem_decl' when ENTITY_DECL 'entity_decl' when ENTITY_NODE 'entity' when ENTITY_REF_NODE 'entity_ref' when HTML_DOCUMENT_NODE 'document_html' when NAMESPACE_DECL 'namespace' when NOTATION_NODE 'notation' when PI_NODE 'pi' when XINCLUDE_START 'xinclude_start' when XINCLUDE_END 'xinclude_end' else raise(UnknownType, "Unknown node type: %n", node.node_type); end end
Returns this node’s type name
Source
# File lib/libxml/node.rb, line 283 def notation? node_type == NOTATION_NODE end
Specifies if this is a notation node
Source
static VALUE rxml_node_output_escaping_set(VALUE self, VALUE value) { xmlNodePtr xnode; xnode = rxml_get_xnode(self); switch (xnode->type) { case XML_TEXT_NODE: xnode->name = (value != Qfalse && value != Qnil) ? xmlStringText : xmlStringTextNoenc; break; case XML_ELEMENT_NODE: case XML_ATTRIBUTE_NODE: { const xmlChar *name = (value != Qfalse && value != Qnil) ? xmlStringText : xmlStringTextNoenc; xmlNodePtr tmp; for (tmp = xnode->children; tmp; tmp = tmp->next) if (tmp->type == XML_TEXT_NODE) tmp->name = name; } break; default: return Qnil; } return (value!=Qfalse && value!=Qnil) ? Qtrue : Qfalse; }
Controls whether this text node or the immediate text node children of an element or attribute node escapes their output. Any other type of node will simply ignore this operation.
Text nodes which are added to an element or attribute node will be affected by any previous setting of this property.
Source
static VALUE rxml_node_output_escaping_q(VALUE self) { xmlNodePtr xnode; xnode = rxml_get_xnode(self); switch (xnode->type) { case XML_TEXT_NODE: return xnode->name==xmlStringTextNoenc ? Qfalse : Qtrue; case XML_ELEMENT_NODE: case XML_ATTRIBUTE_NODE: { xmlNodePtr tmp = xnode->children; const xmlChar *match = NULL; /* Find the first text node and use it as the reference. */ while (tmp && tmp->type != XML_TEXT_NODE) tmp = tmp->next; if (! tmp) return Qnil; match = tmp->name; /* Walk the remaining text nodes until we run out or one doesn't match. */ while (tmp && (tmp->type != XML_TEXT_NODE || match == tmp->name)) tmp = tmp->next; /* We're left with either the mismatched node or the aggregate result. */ return tmp ? Qnil : (match==xmlStringTextNoenc ? Qfalse : Qtrue); } break; default: return Qnil; } }
Determine whether this node escapes it’s output or not.
Text nodes return only true
or false
. Element and attribute nodes examine their immediate text node children to determine the value. Any other type of node always returns nil
.
If an element or attribute node has at least one immediate child text node and all the immediate text node children have the same output_escaping?
value, that value is returned. Otherwise, nil
is returned.
Source
static VALUE rxml_node_parent_get(VALUE self) { xmlNodePtr xnode; xnode = rxml_get_xnode(self); if (xnode->parent) return (rxml_node_wrap(xnode->parent)); else return (Qnil); }
Obtain this node’s parent node, if any.
Source
# File lib/libxml/node.rb, line 121 def parent? not parent.nil? end
Determines whether this node has a parent node
Source
static VALUE rxml_node_path(VALUE self) { xmlNodePtr xnode; xmlChar *path; VALUE result = Qnil; xnode = rxml_get_xnode(self); path = xmlGetNodePath(xnode); if (path) { result = rxml_new_cstr( path, NULL); xmlFree(path); } return result; }
Obtain this node’s path.
Source
# File lib/libxml/node.rb, line 288 def pi? node_type == PI_NODE end
Specifies if this is a processiong instruction node
Source
static VALUE rxml_node_prev_get(VALUE self) { xmlNodePtr xnode; xmlNodePtr node; xnode = rxml_get_xnode(self); switch (xnode->type) { case XML_DOCUMENT_NODE: #ifdef LIBXML_DOCB_ENABLED case XML_DOCB_DOCUMENT_NODE: #endif case XML_HTML_DOCUMENT_NODE: case XML_NAMESPACE_DECL: node = NULL; break; case XML_ATTRIBUTE_NODE: { xmlAttrPtr attr = (xmlAttrPtr) xnode; node = (xmlNodePtr) attr->prev; } break; default: node = xnode->prev; break; } if (node == NULL) return (Qnil); else return (rxml_node_wrap(node)); }
Obtain the previous sibling, if any.
Source
static VALUE rxml_node_prev_set(VALUE self, VALUE prev) { return rxml_node_modify_dom(self, prev, xmlAddPrevSibling); }
Adds the specified node as the previous sibling of the current node. If the node already exists in the document, it is first removed from its existing context. Any adjacent text nodes will be merged together, meaning the returned node may be different than the original node.
Source
# File lib/libxml/node.rb, line 141 def prev? not prev.nil? end
Determines whether this node has a previous node
Source
static VALUE rxml_node_remove_ex(VALUE self) { xmlNodePtr xnode = rxml_get_xnode(self); // Now unlink the node from its parent xmlUnlinkNode(xnode); // Ruby now manages this node rxml_node_manage(xnode, self); // Now return the removed node so the user can do something with it return self; }
Removes this node and its children from the document tree by setting its document, parent and siblings to nil. You can add the returned node back into a document. Otherwise, the node will be freed once any references to it go out of scope.
Source
static VALUE rxml_node_sibling_set(VALUE self, VALUE sibling) { return rxml_node_modify_dom(self, sibling, xmlAddSibling); }
Adds the specified node as the end of the current node’s list of siblings. If the node already exists in the document, it is first removed from its existing context. Any adjacent text nodes will be merged together, meaning the returned node may be different than the original node.
Source
static VALUE rxml_node_space_preserve_get(VALUE self) { xmlNodePtr xnode; xnode = rxml_get_xnode(self); return (INT2NUM(xmlNodeGetSpacePreserve(xnode))); }
Determine whether this node preserves whitespace.
Source
static VALUE rxml_node_space_preserve_set(VALUE self, VALUE value) { xmlNodePtr xnode; xnode = rxml_get_xnode(self); if (value == Qfalse) xmlNodeSetSpacePreserve(xnode, 0); else xmlNodeSetSpacePreserve(xnode, 1); return (Qnil); }
Control whether this node preserves whitespace.
Source
# File lib/libxml/node.rb, line 293 def text? node_type == TEXT_NODE end
Specifies if this is a text node
Source
static VALUE rxml_node_to_s(int argc, VALUE *argv, VALUE self) { VALUE result = Qnil; VALUE options = Qnil; xmlNodePtr xnode; xmlCharEncodingHandlerPtr encodingHandler; xmlOutputBufferPtr output; int level = 0; int indent = 1; const xmlChar *xencoding = (const xmlChar*)"UTF-8"; rb_scan_args(argc, argv, "01", &options); if (!NIL_P(options)) { VALUE rencoding, rindent, rlevel; Check_Type(options, T_HASH); rencoding = rb_hash_aref(options, ID2SYM(rb_intern("encoding"))); rindent = rb_hash_aref(options, ID2SYM(rb_intern("indent"))); rlevel = rb_hash_aref(options, ID2SYM(rb_intern("level"))); if (rindent == Qfalse) indent = 0; if (rlevel != Qnil) level = NUM2INT(rlevel); if (rencoding != Qnil) { xencoding = (const xmlChar*)xmlGetCharEncodingName((xmlCharEncoding)NUM2INT(rencoding)); if (!xencoding) rb_raise(rb_eArgError, "Unknown encoding value: %d", NUM2INT(rencoding)); } } encodingHandler = xmlFindCharEncodingHandler((const char*)xencoding); output = xmlAllocOutputBuffer(encodingHandler); xnode = rxml_get_xnode(self); xmlNodeDumpOutput(output, xnode->doc, xnode, level, indent, (const char*)xencoding); xmlOutputBufferFlush(output); #ifdef LIBXML2_NEW_BUFFER if (output->conv) result = rxml_new_cstr(xmlBufContent(output->conv), xencoding); else result = rxml_new_cstr(xmlBufContent(output->buffer), xencoding); #else if (output->conv) result = rxml_new_cstr(xmlBufferContent(output->conv), xencoding); else result = rxml_new_cstr(xmlBufferContent(output->buffer), xencoding); #endif xmlOutputBufferClose(output); return result; }
Converts a node, and all of its children, to a string representation. To include only the node’s children, use the the XML::Node#inner_xml
method.
You may provide an optional hash table to control how the string is generated. Valid options are:
:indent - Specifies if the string should be indented. The default value is true. Note that indentation is only added if both :indent is true and XML.indent_tree_output
is true. If :indent is set to false, then both indentation and line feeds are removed from the result.
:level - Specifies the indentation level. The amount of indentation is equal to the (level * number_spaces) + number_spaces, where libxml defaults the number of spaces to 2. Thus a level of 0 results in 2 spaces, level 1 results in 4 spaces, level 2 results in 6 spaces, etc.
:encoding - Specifies the output encoding of the string. It defaults to XML::Encoding::UTF8. To change it, use one of the XML::Encoding
encoding constants.
Source
# File lib/libxml/node.rb, line 298 def xinclude_end? node_type == XINCLUDE_END end
Specifies if this is an xinclude end node
Source
# File lib/libxml/node.rb, line 303 def xinclude_start? node_type == XINCLUDE_START end
Specifies if this is an xinclude start node
Source
static VALUE rxml_node_xlink_q(VALUE self) { xmlNodePtr xnode; xlinkType xlt; xnode = rxml_get_xnode(self); xlt = xlinkIsLink(xnode->doc, xnode); if (xlt == XLINK_TYPE_NONE) return (Qfalse); else return (Qtrue); }
Determine whether this node is an xlink node.
Source
static VALUE rxml_node_xlink_type(VALUE self) { xmlNodePtr xnode; xlinkType xlt; xnode = rxml_get_xnode(self); xlt = xlinkIsLink(xnode->doc, xnode); if (xlt == XLINK_TYPE_NONE) return (Qnil); else return (INT2NUM(xlt)); }
Obtain the type identifier for this xlink, if applicable. If this is not an xlink node (see xlink?
), will return nil.
Source
static VALUE rxml_node_xlink_type_name(VALUE self) { xmlNodePtr xnode; xlinkType xlt; xnode = rxml_get_xnode(self); xlt = xlinkIsLink(xnode->doc, xnode); switch (xlt) { case XLINK_TYPE_NONE: return (Qnil); case XLINK_TYPE_SIMPLE: return (rxml_new_cstr((const xmlChar*)"simple", NULL)); case XLINK_TYPE_EXTENDED: return (rxml_new_cstr((const xmlChar*)"extended", NULL)); case XLINK_TYPE_EXTENDED_SET: return (rxml_new_cstr((const xmlChar*)"extended_set", NULL)); default: rb_fatal("Unknowng xlink type, %d", xlt); } }
Obtain the type name for this xlink, if applicable. If this is not an xlink node (see xlink?
), will return nil.
Private Instance Methods
Source
# File lib/libxml/node.rb, line 314 def create_string_io(xml) result = StringIO.new("") if defined?(::Encoding) result.set_encoding(xml.encoding) end result end