File: C:/Ruby27-x64/share/doc/ruby/html/REXML/Element.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>class REXML::Element - RDoc Documentation</title>
<script type="text/javascript">
var rdoc_rel_prefix = "../";
var index_rel_prefix = "../";
</script>
<script src="../js/navigation.js" defer></script>
<script src="../js/search.js" defer></script>
<script src="../js/search_index.js" defer></script>
<script src="../js/searcher.js" defer></script>
<script src="../js/darkfish.js" defer></script>
<link href="../css/fonts.css" rel="stylesheet">
<link href="../css/rdoc.css" rel="stylesheet">
<body id="top" role="document" class="class">
<nav role="navigation">
<div id="project-navigation">
<div id="home-section" role="region" title="Quick navigation" class="nav-section">
<h2>
<a href="../index.html" rel="home">Home</a>
</h2>
<div id="table-of-contents-navigation">
<a href="../table_of_contents.html#pages">Pages</a>
<a href="../table_of_contents.html#classes">Classes</a>
<a href="../table_of_contents.html#methods">Methods</a>
</div>
</div>
<div id="search-section" role="search" class="project-section initially-hidden">
<form action="#" method="get" accept-charset="utf-8">
<div id="search-field-wrapper">
<input id="search-field" role="combobox" aria-label="Search"
aria-autocomplete="list" aria-controls="search-results"
type="text" name="search" placeholder="Search" spellcheck="false"
title="Type to search, Up and Down to navigate, Enter to load">
</div>
<ul id="search-results" aria-label="Search Results"
aria-busy="false" aria-expanded="false"
aria-atomic="false" class="initially-hidden"></ul>
</form>
</div>
</div>
<div id="class-metadata">
<div id="parent-class-section" class="nav-section">
<h3>Parent</h3>
<p class="link">Parent
</div>
<div id="includes-section" class="nav-section">
<h3>Included Modules</h3>
<ul class="link-list">
<li><a class="include" href="Namespace.html">REXML::Namespace</a>
</ul>
</div>
<!-- Method Quickref -->
<div id="method-list-section" class="nav-section">
<h3>Methods</h3>
<ul class="link-list" role="directory">
<li class="calls-super" ><a href="#method-c-new">::new</a>
<li class="calls-super" ><a href="#method-i-5B-5D">#[]</a>
<li ><a href="#method-i-__to_xpath_helper">#__to_xpath_helper</a>
<li ><a href="#method-i-add_attribute">#add_attribute</a>
<li ><a href="#method-i-add_attributes">#add_attributes</a>
<li ><a href="#method-i-add_element">#add_element</a>
<li ><a href="#method-i-add_namespace">#add_namespace</a>
<li ><a href="#method-i-add_text">#add_text</a>
<li ><a href="#method-i-attribute">#attribute</a>
<li ><a href="#method-i-cdatas">#cdatas</a>
<li ><a href="#method-i-clone">#clone</a>
<li ><a href="#method-i-comments">#comments</a>
<li ><a href="#method-i-delete_attribute">#delete_attribute</a>
<li ><a href="#method-i-delete_element">#delete_element</a>
<li ><a href="#method-i-delete_namespace">#delete_namespace</a>
<li ><a href="#method-i-document">#document</a>
<li ><a href="#method-i-each_element">#each_element</a>
<li ><a href="#method-i-each_element_with_attribute">#each_element_with_attribute</a>
<li ><a href="#method-i-each_element_with_text">#each_element_with_text</a>
<li ><a href="#method-i-each_with_something">#each_with_something</a>
<li ><a href="#method-i-get_elements">#get_elements</a>
<li ><a href="#method-i-get_text">#get_text</a>
<li ><a href="#method-i-has_attributes-3F">#has_attributes?</a>
<li ><a href="#method-i-has_elements-3F">#has_elements?</a>
<li ><a href="#method-i-has_text-3F">#has_text?</a>
<li ><a href="#method-i-ignore_whitespace_nodes">#ignore_whitespace_nodes</a>
<li ><a href="#method-i-inspect">#inspect</a>
<li ><a href="#method-i-instructions">#instructions</a>
<li ><a href="#method-i-namespace">#namespace</a>
<li ><a href="#method-i-namespaces">#namespaces</a>
<li ><a href="#method-i-next_element">#next_element</a>
<li ><a href="#method-i-node_type">#node_type</a>
<li ><a href="#method-i-prefixes">#prefixes</a>
<li ><a href="#method-i-previous_element">#previous_element</a>
<li ><a href="#method-i-raw">#raw</a>
<li ><a href="#method-i-root">#root</a>
<li ><a href="#method-i-root_node">#root_node</a>
<li ><a href="#method-i-text">#text</a>
<li ><a href="#method-i-text-3D">#text=</a>
<li ><a href="#method-i-texts">#texts</a>
<li ><a href="#method-i-whitespace">#whitespace</a>
<li ><a href="#method-i-write">#write</a>
<li ><a href="#method-i-xpath">#xpath</a>
</ul>
</div>
</div>
</nav>
<main role="main" aria-labelledby="class-REXML::Element">
<h1 id="class-REXML::Element" class="class">
class REXML::Element
</h1>
<section class="description">
<p>Represents a tagged <a href="../XML.html"><code>XML</code></a> element. <a href="Elements.html"><code>Elements</code></a> are characterized by having children, attributes, and names, and can themselves be children.</p>
</section>
<section id="5Buntitled-5D" class="documentation-section">
<section class="constants-list">
<header>
<h3>Constants</h3>
</header>
<dl>
<dt id="UNDEFINED">UNDEFINED
<dd>
</dl>
</section>
<section class="attribute-method-details" class="method-section">
<header>
<h3>Attributes</h3>
</header>
<div id="attribute-i-attributes" class="method-detail">
<div class="method-heading attribute-method-heading">
<span class="method-name">attributes</span><span
class="attribute-access-type">[R]</span>
</div>
<div class="method-description">
<p>Mechanisms for accessing attributes and child elements of this element.</p>
</div>
</div>
<div id="attribute-i-context" class="method-detail">
<div class="method-heading attribute-method-heading">
<span class="method-name">context</span><span
class="attribute-access-type">[RW]</span>
</div>
<div class="method-description">
<p>The context holds information about the processing environment, such as whitespace handling.</p>
</div>
</div>
<div id="attribute-i-elements" class="method-detail">
<div class="method-heading attribute-method-heading">
<span class="method-name">elements</span><span
class="attribute-access-type">[R]</span>
</div>
<div class="method-description">
<p>Mechanisms for accessing attributes and child elements of this element.</p>
</div>
</div>
</section>
<section id="public-class-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Public Class Methods</h3>
</header>
<div id="method-c-new" class="method-detail ">
<div class="method-heading">
<span class="method-name">new</span><span
class="method-args">( arg = UNDEFINED, parent=nil, context=nil )</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Constructor</p>
<dl class="rdoc-list note-list"><dt>arg
<dd>
<p>if not supplied, will be set to the default value. If a <a href="../String.html"><code>String</code></a>, the name of this object will be set to the argument. If an <a href="Element.html"><code>Element</code></a>, the object will be shallowly cloned; name, attributes, and namespaces will be copied. Children will <code>not</code> be copied.</p>
</dd><dt>parent
<dd>
<p>if supplied, must be a <a href="Parent.html"><code>Parent</code></a>, and will be used as the parent of this object.</p>
</dd><dt>context
<dd>
<p>If supplied, must be a hash containing context items. Context items include:</p>
</dd></dl>
<ul><li>
<p><code>:respect_whitespace</code> the value of this is :<code>all</code> or an array of strings being the names of the elements to respect whitespace for. Defaults to :<code>all</code>.</p>
</li><li>
<p><code>:compress_whitespace</code> the value can be :<code>all</code> or an array of strings being the names of the elements to ignore whitespace on. Overrides :<code>respect_whitespace</code>.</p>
</li><li>
<p><code>:ignore_whitespace_nodes</code> the value can be :<code>all</code> or an array of strings being the names of the elements in which to ignore whitespace-only nodes. If this is set, <a href="Text.html"><code>Text</code></a> nodes which contain only whitespace will not be added to the document tree.</p>
</li><li>
<p><code>:raw</code> can be :<code>all</code>, or an array of strings being the names of the elements to process in raw mode. In raw mode, special characters in text is not converted to or from entities.</p>
</li></ul>
<div class="method-calls-super">
Calls superclass method
</div>
<div class="method-source-code" id="new-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 59</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize</span>( <span class="ruby-identifier">arg</span> = <span class="ruby-constant">UNDEFINED</span>, <span class="ruby-identifier">parent</span>=<span class="ruby-keyword">nil</span>, <span class="ruby-identifier">context</span>=<span class="ruby-keyword">nil</span> )
<span class="ruby-keyword">super</span>(<span class="ruby-identifier">parent</span>)
<span class="ruby-ivar">@elements</span> = <span class="ruby-constant">Elements</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword">self</span>)
<span class="ruby-ivar">@attributes</span> = <span class="ruby-constant">Attributes</span>.<span class="ruby-identifier">new</span>(<span class="ruby-keyword">self</span>)
<span class="ruby-ivar">@context</span> = <span class="ruby-identifier">context</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">arg</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">String</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">name</span> = <span class="ruby-identifier">arg</span>
<span class="ruby-keyword">elsif</span> <span class="ruby-identifier">arg</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Element</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">name</span> = <span class="ruby-identifier">arg</span>.<span class="ruby-identifier">expanded_name</span>
<span class="ruby-identifier">arg</span>.<span class="ruby-identifier">attributes</span>.<span class="ruby-identifier">each_attribute</span>{ <span class="ruby-operator">|</span><span class="ruby-identifier">attribute</span><span class="ruby-operator">|</span>
<span class="ruby-ivar">@attributes</span> <span class="ruby-operator"><<</span> <span class="ruby-constant">Attribute</span>.<span class="ruby-identifier">new</span>( <span class="ruby-identifier">attribute</span> )
}
<span class="ruby-ivar">@context</span> = <span class="ruby-identifier">arg</span>.<span class="ruby-identifier">context</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
</section>
<section id="public-instance-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Public Instance Methods</h3>
</header>
<div id="method-i-5B-5D" class="method-detail ">
<div class="method-heading">
<span class="method-name">[]</span><span
class="method-args">(name_or_index)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Fetches an attribute value or a child.</p>
<p>If <a href="../String.html"><code>String</code></a> or <a href="../Symbol.html"><code>Symbol</code></a> is specified, it's treated as attribute name. <a href="Attribute.html"><code>Attribute</code></a> value as <a href="../String.html"><code>String</code></a> or <code>nil</code> is returned. This case is shortcut of +<a href="name">attributes</a>+.</p>
<p>If <a href="../Integer.html"><code>Integer</code></a> is specified, it's treated as the index of child. It returns Nth child.</p>
<pre class="ruby"><span class="ruby-identifier">doc</span> = <span class="ruby-constant">REXML</span><span class="ruby-operator">::</span><span class="ruby-constant">Document</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">"<a attr='1'><b/><c/></a>"</span>)
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>[<span class="ruby-string">"attr"</span>] <span class="ruby-comment"># => "1"</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">attributes</span>[<span class="ruby-string">"attr"</span>] <span class="ruby-comment"># => "1"</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>[<span class="ruby-value">1</span>] <span class="ruby-comment"># => <c/></span>
</pre>
<div class="method-calls-super">
Calls superclass method
</div>
<div class="method-source-code" id="5B-5D-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 567</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">[]</span>(<span class="ruby-identifier">name_or_index</span>)
<span class="ruby-keyword">case</span> <span class="ruby-identifier">name_or_index</span>
<span class="ruby-keyword">when</span> <span class="ruby-constant">String</span>
<span class="ruby-identifier">attributes</span>[<span class="ruby-identifier">name_or_index</span>]
<span class="ruby-keyword">when</span> <span class="ruby-constant">Symbol</span>
<span class="ruby-identifier">attributes</span>[<span class="ruby-identifier">name_or_index</span>.<span class="ruby-identifier">to_s</span>]
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">super</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-add_attribute" class="method-detail ">
<div class="method-heading">
<span class="method-name">add_attribute</span><span
class="method-args">( key, value=nil )</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Adds an attribute to this element, overwriting any existing attribute by the same name.</p>
<dl class="rdoc-list note-list"><dt>key
<dd>
<p>can be either an <a href="Attribute.html"><code>Attribute</code></a> or a <a href="../String.html"><code>String</code></a>. If an <a href="Attribute.html"><code>Attribute</code></a>, the attribute is added to the list of <a href="Element.html"><code>Element</code></a> attributes. If <a href="../String.html"><code>String</code></a>, the argument is used as the name of the new attribute, and the value parameter must be supplied.</p>
</dd><dt>value
<dd>
<p>Required if <code>key</code> is a <a href="../String.html"><code>String</code></a>, and ignored if the first argument is an <a href="Attribute.html"><code>Attribute</code></a>. This is a <a href="../String.html"><code>String</code></a>, and is used as the value of the new <a href="Attribute.html"><code>Attribute</code></a>. This should be the unnormalized value of the attribute (without entities).</p>
</dd><dt>Returns
<dd>
<p>the <a href="Attribute.html"><code>Attribute</code></a> added</p>
</dd></dl>
<pre class="ruby"><span class="ruby-identifier">e</span> = <span class="ruby-constant">Element</span>.<span class="ruby-identifier">new</span> <span class="ruby-string">'e'</span>
<span class="ruby-identifier">e</span>.<span class="ruby-identifier">add_attribute</span>( <span class="ruby-string">'a'</span>, <span class="ruby-string">'b'</span> ) <span class="ruby-comment">#-> <e a='b'/></span>
<span class="ruby-identifier">e</span>.<span class="ruby-identifier">add_attribute</span>( <span class="ruby-string">'x:a'</span>, <span class="ruby-string">'c'</span> ) <span class="ruby-comment">#-> <e a='b' x:a='c'/></span>
<span class="ruby-identifier">e</span>.<span class="ruby-identifier">add_attribute</span> <span class="ruby-constant">Attribute</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'b'</span>, <span class="ruby-string">'d'</span>) <span class="ruby-comment">#-> <e a='b' x:a='c' b='d'/></span>
</pre>
<div class="method-source-code" id="add_attribute-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 624</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">add_attribute</span>( <span class="ruby-identifier">key</span>, <span class="ruby-identifier">value</span>=<span class="ruby-keyword">nil</span> )
<span class="ruby-keyword">if</span> <span class="ruby-identifier">key</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Attribute</span>
<span class="ruby-ivar">@attributes</span> <span class="ruby-operator"><<</span> <span class="ruby-identifier">key</span>
<span class="ruby-keyword">else</span>
<span class="ruby-ivar">@attributes</span>[<span class="ruby-identifier">key</span>] = <span class="ruby-identifier">value</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-add_attributes" class="method-detail ">
<div class="method-heading">
<span class="method-name">add_attributes</span><span
class="method-args">(hash)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Add multiple attributes to this element.</p>
<dl class="rdoc-list note-list"><dt>hash
<dd>
<p>is either a hash, or array of arrays</p>
</dd></dl>
<pre class="ruby"><span class="ruby-identifier">el</span>.<span class="ruby-identifier">add_attributes</span>( {<span class="ruby-string">"name1"</span><span class="ruby-operator">=></span><span class="ruby-string">"value1"</span>, <span class="ruby-string">"name2"</span><span class="ruby-operator">=></span><span class="ruby-string">"value2"</span>} )
<span class="ruby-identifier">el</span>.<span class="ruby-identifier">add_attributes</span>( [ [<span class="ruby-string">"name1"</span>,<span class="ruby-string">"value1"</span>], [<span class="ruby-string">"name2"</span><span class="ruby-operator">=></span><span class="ruby-string">"value2"</span>] ] )
</pre>
<div class="method-source-code" id="add_attributes-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 636</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">add_attributes</span> <span class="ruby-identifier">hash</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">hash</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Hash</span>
<span class="ruby-identifier">hash</span>.<span class="ruby-identifier">each_pair</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">key</span>, <span class="ruby-identifier">value</span><span class="ruby-operator">|</span> <span class="ruby-ivar">@attributes</span>[<span class="ruby-identifier">key</span>] = <span class="ruby-identifier">value</span> }
<span class="ruby-keyword">elsif</span> <span class="ruby-identifier">hash</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Array</span>
<span class="ruby-identifier">hash</span>.<span class="ruby-identifier">each</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">value</span><span class="ruby-operator">|</span> <span class="ruby-ivar">@attributes</span>[ <span class="ruby-identifier">value</span>[<span class="ruby-value">0</span>] ] = <span class="ruby-identifier">value</span>[<span class="ruby-value">1</span>] }
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-add_element" class="method-detail ">
<div class="method-heading">
<span class="method-name">add_element</span><span
class="method-args">(element, attrs=nil)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Adds a child to this element, optionally setting attributes in the element.</p>
<dl class="rdoc-list note-list"><dt>element
<dd>
<p>optional. If <a href="Element.html"><code>Element</code></a>, the element is added. Otherwise, a new <a href="Element.html"><code>Element</code></a> is constructed with the argument (see Element.initialize).</p>
</dd><dt>attrs
<dd>
<p>If supplied, must be a <a href="../Hash.html"><code>Hash</code></a> containing <a href="../String.html"><code>String</code></a> name,value pairs, which will be used to set the attributes of the new <a href="Element.html"><code>Element</code></a>.</p>
</dd><dt>Returns
<dd>
<p>the <a href="Element.html"><code>Element</code></a> that was added</p>
</dd></dl>
<pre class="ruby"><span class="ruby-identifier">el</span> = <span class="ruby-identifier">doc</span>.<span class="ruby-identifier">add_element</span> <span class="ruby-string">'my-tag'</span>
<span class="ruby-identifier">el</span> = <span class="ruby-identifier">doc</span>.<span class="ruby-identifier">add_element</span> <span class="ruby-string">'my-tag'</span>, {<span class="ruby-string">'attr1'</span><span class="ruby-operator">=></span><span class="ruby-string">'val1'</span>, <span class="ruby-string">'attr2'</span><span class="ruby-operator">=></span><span class="ruby-string">'val2'</span>}
<span class="ruby-identifier">el</span> = <span class="ruby-constant">Element</span>.<span class="ruby-identifier">new</span> <span class="ruby-string">'my-tag'</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">add_element</span> <span class="ruby-identifier">el</span>
</pre>
<div class="method-source-code" id="add_element-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 296</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">add_element</span> <span class="ruby-identifier">element</span>, <span class="ruby-identifier">attrs</span>=<span class="ruby-keyword">nil</span>
<span class="ruby-identifier">raise</span> <span class="ruby-string">"First argument must be either an element name, or an Element object"</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">element</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-identifier">el</span> = <span class="ruby-ivar">@elements</span>.<span class="ruby-identifier">add</span>(<span class="ruby-identifier">element</span>)
<span class="ruby-identifier">attrs</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">key</span>, <span class="ruby-identifier">value</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">el</span>.<span class="ruby-identifier">attributes</span>[<span class="ruby-identifier">key</span>]=<span class="ruby-identifier">value</span>
<span class="ruby-keyword">end</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">attrs</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Hash</span>
<span class="ruby-identifier">el</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-add_namespace" class="method-detail ">
<div class="method-heading">
<span class="method-name">add_namespace</span><span
class="method-args">( prefix, uri=nil )</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Adds a namespace to this element.</p>
<dl class="rdoc-list note-list"><dt>prefix
<dd>
<p>the prefix string, or the namespace <a href="../URI.html"><code>URI</code></a> if <code>uri</code> is not supplied</p>
</dd><dt>uri
<dd>
<p>the namespace <a href="../URI.html"><code>URI</code></a>. May be nil, in which <code>prefix</code> is used as the <a href="../URI.html"><code>URI</code></a></p>
</dd></dl>
<p>Evaluates to: this <a href="Element.html"><code>Element</code></a></p>
<pre class="ruby"><span class="ruby-identifier">a</span> = <span class="ruby-constant">Element</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">"a"</span>)
<span class="ruby-identifier">a</span>.<span class="ruby-identifier">add_namespace</span>(<span class="ruby-string">"xmlns:foo"</span>, <span class="ruby-string">"bar"</span> )
<span class="ruby-identifier">a</span>.<span class="ruby-identifier">add_namespace</span>(<span class="ruby-string">"foo"</span>, <span class="ruby-string">"bar"</span>) <span class="ruby-comment"># shorthand for previous line</span>
<span class="ruby-identifier">a</span>.<span class="ruby-identifier">add_namespace</span>(<span class="ruby-string">"twiddle"</span>)
<span class="ruby-identifier">puts</span> <span class="ruby-identifier">a</span> <span class="ruby-comment">#-> <a xmlns:foo='bar' xmlns='twiddle'/></span>
</pre>
<div class="method-source-code" id="add_namespace-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 251</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">add_namespace</span>( <span class="ruby-identifier">prefix</span>, <span class="ruby-identifier">uri</span>=<span class="ruby-keyword">nil</span> )
<span class="ruby-keyword">unless</span> <span class="ruby-identifier">uri</span>
<span class="ruby-ivar">@attributes</span>[<span class="ruby-string">"xmlns"</span>] = <span class="ruby-identifier">prefix</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">prefix</span> = <span class="ruby-node">"xmlns:#{prefix}"</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">prefix</span> <span class="ruby-operator">=~</span> <span class="ruby-regexp">/^xmlns:/</span>
<span class="ruby-ivar">@attributes</span>[ <span class="ruby-identifier">prefix</span> ] = <span class="ruby-identifier">uri</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-add_text" class="method-detail ">
<div class="method-heading">
<span class="method-name">add_text</span><span
class="method-args">( text )</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>A helper method to add a <a href="Text.html"><code>Text</code></a> child. Actual <a href="Text.html"><code>Text</code></a> instances can be added with regular <a href="Parent.html"><code>Parent</code></a> methods, such as add() and <<()</p>
<dl class="rdoc-list note-list"><dt>text
<dd>
<p>if a <a href="../String.html"><code>String</code></a>, a new <a href="Text.html"><code>Text</code></a> instance is created and added to the parent. If <a href="Text.html"><code>Text</code></a>, the object is added directly.</p>
</dd><dt>Returns
<dd>
<p>this <a href="Element.html"><code>Element</code></a></p>
</dd></dl>
<pre class="ruby"><span class="ruby-identifier">e</span> = <span class="ruby-constant">Element</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'a'</span>) <span class="ruby-comment">#-> <e/></span>
<span class="ruby-identifier">e</span>.<span class="ruby-identifier">add_text</span> <span class="ruby-string">'foo'</span> <span class="ruby-comment">#-> <e>foo</e></span>
<span class="ruby-identifier">e</span>.<span class="ruby-identifier">add_text</span> <span class="ruby-constant">Text</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">' bar'</span>) <span class="ruby-comment">#-> <e>foo bar</e></span>
</pre>
<p>Note that at the end of this example, the branch has <strong>3</strong> nodes; the 'e' element and <strong>2</strong> <a href="Text.html"><code>Text</code></a> node children.</p>
<div class="method-source-code" id="add_text-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 523</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">add_text</span>( <span class="ruby-identifier">text</span> )
<span class="ruby-keyword">if</span> <span class="ruby-identifier">text</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">String</span>
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@children</span>[<span class="ruby-value">-1</span>].<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Text</span>
<span class="ruby-ivar">@children</span>[<span class="ruby-value">-1</span>] <span class="ruby-operator"><<</span> <span class="ruby-identifier">text</span>
<span class="ruby-keyword">return</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">text</span> = <span class="ruby-constant">Text</span>.<span class="ruby-identifier">new</span>( <span class="ruby-identifier">text</span>, <span class="ruby-identifier">whitespace</span>(), <span class="ruby-keyword">nil</span>, <span class="ruby-identifier">raw</span>() )
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">self</span> <span class="ruby-operator"><<</span> <span class="ruby-identifier">text</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">text</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-attribute" class="method-detail ">
<div class="method-heading">
<span class="method-name">attribute</span><span
class="method-args">( name, namespace=nil )</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="attribute-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 578</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">attribute</span>( <span class="ruby-identifier">name</span>, <span class="ruby-identifier">namespace</span>=<span class="ruby-keyword">nil</span> )
<span class="ruby-identifier">prefix</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">namespaces</span>.<span class="ruby-identifier">respond_to?</span> <span class="ruby-value">:key</span>
<span class="ruby-identifier">prefix</span> = <span class="ruby-identifier">namespaces</span>.<span class="ruby-identifier">key</span>(<span class="ruby-identifier">namespace</span>) <span class="ruby-keyword">if</span> <span class="ruby-identifier">namespace</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">prefix</span> = <span class="ruby-identifier">namespaces</span>.<span class="ruby-identifier">index</span>(<span class="ruby-identifier">namespace</span>) <span class="ruby-keyword">if</span> <span class="ruby-identifier">namespace</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">prefix</span> = <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">prefix</span> <span class="ruby-operator">==</span> <span class="ruby-string">'xmlns'</span>
<span class="ruby-identifier">ret_val</span> =
<span class="ruby-identifier">attributes</span>.<span class="ruby-identifier">get_attribute</span>( <span class="ruby-node">"#{prefix ? prefix + ':' : ''}#{name}"</span> )
<span class="ruby-keyword">return</span> <span class="ruby-identifier">ret_val</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">ret_val</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">prefix</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-comment"># now check that prefix'es namespace is not the same as the</span>
<span class="ruby-comment"># default namespace</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">nil</span> <span class="ruby-keyword">unless</span> ( <span class="ruby-identifier">namespaces</span>[ <span class="ruby-identifier">prefix</span> ] <span class="ruby-operator">==</span> <span class="ruby-identifier">namespaces</span>[ <span class="ruby-string">'xmlns'</span> ] )
<span class="ruby-identifier">attributes</span>.<span class="ruby-identifier">get_attribute</span>( <span class="ruby-identifier">name</span> )
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-cdatas" class="method-detail ">
<div class="method-heading">
<span class="method-name">cdatas</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Get an array of all <a href="CData.html"><code>CData</code></a> children. IMMUTABLE</p>
<div class="method-source-code" id="cdatas-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 668</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">cdatas</span>
<span class="ruby-identifier">find_all</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">child</span><span class="ruby-operator">|</span> <span class="ruby-identifier">child</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">CData</span> }.<span class="ruby-identifier">freeze</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-clone" class="method-detail ">
<div class="method-heading">
<span class="method-name">clone</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Creates a shallow copy of self.</p>
<pre class="ruby"><span class="ruby-identifier">d</span> = <span class="ruby-constant">Document</span>.<span class="ruby-identifier">new</span> <span class="ruby-string">"<a><b/><b/><c><d/></c></a>"</span>
<span class="ruby-identifier">new_a</span> = <span class="ruby-identifier">d</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">clone</span>
<span class="ruby-identifier">puts</span> <span class="ruby-identifier">new_a</span> <span class="ruby-comment"># => "<a/>"</span>
</pre>
<div class="method-source-code" id="clone-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 97</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">clone</span>
<span class="ruby-keyword">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span> <span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-comments" class="method-detail ">
<div class="method-heading">
<span class="method-name">comments</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Get an array of all <a href="Comment.html"><code>Comment</code></a> children. IMMUTABLE</p>
<div class="method-source-code" id="comments-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 674</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">comments</span>
<span class="ruby-identifier">find_all</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">child</span><span class="ruby-operator">|</span> <span class="ruby-identifier">child</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Comment</span> }.<span class="ruby-identifier">freeze</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-delete_attribute" class="method-detail ">
<div class="method-heading">
<span class="method-name">delete_attribute</span><span
class="method-args">(key)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Removes an attribute</p>
<dl class="rdoc-list note-list"><dt>key
<dd>
<p>either an <a href="Attribute.html"><code>Attribute</code></a> or a <a href="../String.html"><code>String</code></a>. In either case, the attribute is found by matching the attribute name to the argument, and then removed. If no attribute is found, no action is taken.</p>
</dd><dt>Returns
<dd>
<p>the attribute removed, or nil if this <a href="Element.html"><code>Element</code></a> did not contain a matching attribute</p>
</dd></dl>
<pre class="ruby"><span class="ruby-identifier">e</span> = <span class="ruby-constant">Element</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">'E'</span>)
<span class="ruby-identifier">e</span>.<span class="ruby-identifier">add_attribute</span>( <span class="ruby-string">'name'</span>, <span class="ruby-string">'Sean'</span> ) <span class="ruby-comment">#-> <E name='Sean'/></span>
<span class="ruby-identifier">r</span> = <span class="ruby-identifier">e</span>.<span class="ruby-identifier">add_attribute</span>( <span class="ruby-string">'sur:name'</span>, <span class="ruby-string">'Russell'</span> ) <span class="ruby-comment">#-> <E name='Sean' sur:name='Russell'/></span>
<span class="ruby-identifier">e</span>.<span class="ruby-identifier">delete_attribute</span>( <span class="ruby-string">'name'</span> ) <span class="ruby-comment">#-> <E sur:name='Russell'/></span>
<span class="ruby-identifier">e</span>.<span class="ruby-identifier">delete_attribute</span>( <span class="ruby-identifier">r</span> ) <span class="ruby-comment">#-> <E/></span>
</pre>
<div class="method-source-code" id="delete_attribute-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 657</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">delete_attribute</span>(<span class="ruby-identifier">key</span>)
<span class="ruby-identifier">attr</span> = <span class="ruby-ivar">@attributes</span>.<span class="ruby-identifier">get_attribute</span>(<span class="ruby-identifier">key</span>)
<span class="ruby-identifier">attr</span>.<span class="ruby-identifier">remove</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">attr</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-delete_element" class="method-detail ">
<div class="method-heading">
<span class="method-name">delete_element</span><span
class="method-args">(element)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Deletes a child element.</p>
<dl class="rdoc-list note-list"><dt>element
<dd>
<p>Must be an <code>Element</code>, <code>String</code>, or <code>Integer</code>. If <a href="Element.html"><code>Element</code></a>, the element is removed. If <a href="../String.html"><code>String</code></a>, the element is found (via <a href="XPath.html"><code>XPath</code></a>) and removed. <em>This means that any parent can remove any descendant.<em> If <a href="../Integer.html"><code>Integer</code></a>, the <a href="Element.html"><code>Element</code></a> indexed by that number will be removed.</p>
</dd><dt>Returns
<dd>
<p>the element that was removed.</p>
</dd></dl>
<pre class="ruby"><span class="ruby-identifier">doc</span>.<span class="ruby-identifier">delete_element</span> <span class="ruby-string">"/a/b/c[@id='4']"</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">delete_element</span> <span class="ruby-identifier">doc</span>.<span class="ruby-identifier">elements</span>[<span class="ruby-string">"//k"</span>]
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">delete_element</span> <span class="ruby-value">1</span>
</pre>
<div class="method-source-code" id="delete_element-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 316</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">delete_element</span> <span class="ruby-identifier">element</span>
<span class="ruby-ivar">@elements</span>.<span class="ruby-identifier">delete</span> <span class="ruby-identifier">element</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-delete_namespace" class="method-detail ">
<div class="method-heading">
<span class="method-name">delete_namespace</span><span
class="method-args">(namespace="xmlns")</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Removes a namespace from this node. This only works if the namespace is actually declared in this node. If no argument is passed, deletes the default namespace.</p>
<p>Evaluates to: this element</p>
<pre class="ruby"><span class="ruby-identifier">doc</span> = <span class="ruby-constant">Document</span>.<span class="ruby-identifier">new</span> <span class="ruby-string">"<a xmlns:foo='bar' xmlns='twiddle'/>"</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">delete_namespace</span>
<span class="ruby-identifier">puts</span> <span class="ruby-identifier">doc</span> <span class="ruby-comment"># -> <a xmlns:foo='bar'/></span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">delete_namespace</span> <span class="ruby-string">'foo'</span>
<span class="ruby-identifier">puts</span> <span class="ruby-identifier">doc</span> <span class="ruby-comment"># -> <a/></span>
</pre>
<div class="method-source-code" id="delete_namespace-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 271</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">delete_namespace</span> <span class="ruby-identifier">namespace</span>=<span class="ruby-string">"xmlns"</span>
<span class="ruby-identifier">namespace</span> = <span class="ruby-node">"xmlns:#{namespace}"</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">namespace</span> <span class="ruby-operator">==</span> <span class="ruby-string">'xmlns'</span>
<span class="ruby-identifier">attribute</span> = <span class="ruby-identifier">attributes</span>.<span class="ruby-identifier">get_attribute</span>(<span class="ruby-identifier">namespace</span>)
<span class="ruby-identifier">attribute</span>.<span class="ruby-identifier">remove</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">attribute</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-document" class="method-detail ">
<div class="method-heading">
<span class="method-name">document</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Evaluates to the document to which this element belongs, or nil if this element doesn't belong to a document.</p>
<div class="method-source-code" id="document-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 132</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">document</span>
<span class="ruby-identifier">rt</span> = <span class="ruby-identifier">root</span>
<span class="ruby-identifier">rt</span>.<span class="ruby-identifier">parent</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">rt</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-each_element" class="method-detail ">
<div class="method-heading">
<span class="method-name">each_element</span><span
class="method-args">( xpath=nil ) { |Element| ... }</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Synonym for <a href="Element.html#attribute-i-elements"><code>Element.elements</code></a>.each</p>
<div class="method-source-code" id="each_element-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 393</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">each_element</span>( <span class="ruby-identifier">xpath</span>=<span class="ruby-keyword">nil</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span> ) <span class="ruby-comment"># :yields: Element</span>
<span class="ruby-ivar">@elements</span>.<span class="ruby-identifier">each</span>( <span class="ruby-identifier">xpath</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span> )
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-each_element_with_attribute" class="method-detail ">
<div class="method-heading">
<span class="method-name">each_element_with_attribute</span><span
class="method-args">( key, value=nil, max=0, name=nil ) { |Element| ... }</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Iterates through the child elements, yielding for each <a href="Element.html"><code>Element</code></a> that has a particular attribute set.</p>
<dl class="rdoc-list note-list"><dt>key
<dd>
<p>the name of the attribute to search for</p>
</dd><dt>value
<dd>
<p>the value of the attribute</p>
</dd><dt>max
<dd>
<p>(optional) causes this method to return after yielding for this number of matching children</p>
</dd><dt>name
<dd>
<p>(optional) if supplied, this is an <a href="XPath.html"><code>XPath</code></a> that filters the children to check.</p>
</dd></dl>
<pre class="ruby"><span class="ruby-identifier">doc</span> = <span class="ruby-constant">Document</span>.<span class="ruby-identifier">new</span> <span class="ruby-string">"<a><b @id='1'/><c @id='2'/><d @id='1'/><e/></a>"</span>
<span class="ruby-comment"># Yields b, c, d</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">each_element_with_attribute</span>( <span class="ruby-string">'id'</span> ) {<span class="ruby-operator">|</span><span class="ruby-identifier">e</span><span class="ruby-operator">|</span> <span class="ruby-identifier">p</span> <span class="ruby-identifier">e</span>}
<span class="ruby-comment"># Yields b, d</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">each_element_with_attribute</span>( <span class="ruby-string">'id'</span>, <span class="ruby-string">'1'</span> ) {<span class="ruby-operator">|</span><span class="ruby-identifier">e</span><span class="ruby-operator">|</span> <span class="ruby-identifier">p</span> <span class="ruby-identifier">e</span>}
<span class="ruby-comment"># Yields b</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">each_element_with_attribute</span>( <span class="ruby-string">'id'</span>, <span class="ruby-string">'1'</span>, <span class="ruby-value">1</span> ) {<span class="ruby-operator">|</span><span class="ruby-identifier">e</span><span class="ruby-operator">|</span> <span class="ruby-identifier">p</span> <span class="ruby-identifier">e</span>}
<span class="ruby-comment"># Yields d</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">each_element_with_attribute</span>( <span class="ruby-string">'id'</span>, <span class="ruby-string">'1'</span>, <span class="ruby-value">0</span>, <span class="ruby-string">'d'</span> ) {<span class="ruby-operator">|</span><span class="ruby-identifier">e</span><span class="ruby-operator">|</span> <span class="ruby-identifier">p</span> <span class="ruby-identifier">e</span>}
</pre>
<div class="method-source-code" id="each_element_with_attribute-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 351</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">each_element_with_attribute</span>( <span class="ruby-identifier">key</span>, <span class="ruby-identifier">value</span>=<span class="ruby-keyword">nil</span>, <span class="ruby-identifier">max</span>=<span class="ruby-value">0</span>, <span class="ruby-identifier">name</span>=<span class="ruby-keyword">nil</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span> ) <span class="ruby-comment"># :yields: Element</span>
<span class="ruby-identifier">each_with_something</span>( <span class="ruby-identifier">proc</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">child</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-identifier">child</span>.<span class="ruby-identifier">attributes</span>[<span class="ruby-identifier">key</span>] <span class="ruby-operator">!=</span> <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">child</span>.<span class="ruby-identifier">attributes</span>[<span class="ruby-identifier">key</span>]<span class="ruby-operator">==</span><span class="ruby-identifier">value</span>
<span class="ruby-keyword">end</span>
}, <span class="ruby-identifier">max</span>, <span class="ruby-identifier">name</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span> )
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-each_element_with_text" class="method-detail ">
<div class="method-heading">
<span class="method-name">each_element_with_text</span><span
class="method-args">( text=nil, max=0, name=nil ) { |Element| ... }</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Iterates through the children, yielding for each <a href="Element.html"><code>Element</code></a> that has a particular text set.</p>
<dl class="rdoc-list note-list"><dt>text
<dd>
<p>the text to search for. If nil, or not supplied, will iterate over all <code>Element</code> children that contain at least one <code>Text</code> node.</p>
</dd><dt>max
<dd>
<p>(optional) causes this method to return after yielding for this number of matching children</p>
</dd><dt>name
<dd>
<p>(optional) if supplied, this is an <a href="XPath.html"><code>XPath</code></a> that filters the children to check.</p>
</dd></dl>
<pre class="ruby"><span class="ruby-identifier">doc</span> = <span class="ruby-constant">Document</span>.<span class="ruby-identifier">new</span> <span class="ruby-string">'<a><b>b</b><c>b</c><d>d</d><e/></a>'</span>
<span class="ruby-comment"># Yields b, c, d</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">each_element_with_text</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">e</span><span class="ruby-operator">|</span><span class="ruby-identifier">p</span> <span class="ruby-identifier">e</span>}
<span class="ruby-comment"># Yields b, c</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">each_element_with_text</span>(<span class="ruby-string">'b'</span>){<span class="ruby-operator">|</span><span class="ruby-identifier">e</span><span class="ruby-operator">|</span><span class="ruby-identifier">p</span> <span class="ruby-identifier">e</span>}
<span class="ruby-comment"># Yields b</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">each_element_with_text</span>(<span class="ruby-string">'b'</span>, <span class="ruby-value">1</span>){<span class="ruby-operator">|</span><span class="ruby-identifier">e</span><span class="ruby-operator">|</span><span class="ruby-identifier">p</span> <span class="ruby-identifier">e</span>}
<span class="ruby-comment"># Yields d</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">each_element_with_text</span>(<span class="ruby-keyword">nil</span>, <span class="ruby-value">0</span>, <span class="ruby-string">'d'</span>){<span class="ruby-operator">|</span><span class="ruby-identifier">e</span><span class="ruby-operator">|</span><span class="ruby-identifier">p</span> <span class="ruby-identifier">e</span>}
</pre>
<div class="method-source-code" id="each_element_with_text-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 382</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">each_element_with_text</span>( <span class="ruby-identifier">text</span>=<span class="ruby-keyword">nil</span>, <span class="ruby-identifier">max</span>=<span class="ruby-value">0</span>, <span class="ruby-identifier">name</span>=<span class="ruby-keyword">nil</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span> ) <span class="ruby-comment"># :yields: Element</span>
<span class="ruby-identifier">each_with_something</span>( <span class="ruby-identifier">proc</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">child</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">text</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-identifier">child</span>.<span class="ruby-identifier">has_text?</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">child</span>.<span class="ruby-identifier">text</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">text</span>
<span class="ruby-keyword">end</span>
}, <span class="ruby-identifier">max</span>, <span class="ruby-identifier">name</span>, <span class="ruby-operator">&</span><span class="ruby-identifier">block</span> )
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-get_elements" class="method-detail ">
<div class="method-heading">
<span class="method-name">get_elements</span><span
class="method-args">( xpath )</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Synonym for Element.to_a This is a little slower than calling elements.each directly.</p>
<dl class="rdoc-list note-list"><dt>xpath
<dd>
<p>any <a href="XPath.html"><code>XPath</code></a> by which to search for elements in the tree</p>
</dd><dt>Returns
<dd>
<p>an array of <a href="Elements.html"><code>Elements</code></a> that match the supplied path</p>
</dd></dl>
<div class="method-source-code" id="get_elements-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 401</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">get_elements</span>( <span class="ruby-identifier">xpath</span> )
<span class="ruby-ivar">@elements</span>.<span class="ruby-identifier">to_a</span>( <span class="ruby-identifier">xpath</span> )
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-get_text" class="method-detail ">
<div class="method-heading">
<span class="method-name">get_text</span><span
class="method-args">(path = nil)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the first child <a href="Text.html"><code>Text</code></a> node, if any, or <code>nil</code> otherwise. This method returns the actual <code>Text</code> node, rather than the <a href="../String.html"><code>String</code></a> content.</p>
<pre class="ruby"><span class="ruby-identifier">doc</span> = <span class="ruby-constant">Document</span>.<span class="ruby-identifier">new</span> <span class="ruby-string">"<p>some text <b>this is bold!</b> more text</p>"</span>
<span class="ruby-comment"># The element 'p' has two text elements, "some text " and " more text".</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">get_text</span>.<span class="ruby-identifier">value</span> <span class="ruby-comment">#-> "some text "</span>
</pre>
<div class="method-source-code" id="get_text-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 462</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">get_text</span> <span class="ruby-identifier">path</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-identifier">rv</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">path</span>
<span class="ruby-identifier">element</span> = <span class="ruby-ivar">@elements</span>[ <span class="ruby-identifier">path</span> ]
<span class="ruby-identifier">rv</span> = <span class="ruby-identifier">element</span>.<span class="ruby-identifier">get_text</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">element</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">rv</span> = <span class="ruby-ivar">@children</span>.<span class="ruby-identifier">find</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">node</span><span class="ruby-operator">|</span> <span class="ruby-identifier">node</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Text</span> }
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">rv</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-has_attributes-3F" class="method-detail ">
<div class="method-heading">
<span class="method-name">has_attributes?</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Evaluates to <code>true</code> if this element has any attributes set, false otherwise.</p>
<div class="method-source-code" id="has_attributes-3F-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 603</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">has_attributes?</span>
<span class="ruby-keyword">return</span> <span class="ruby-operator">!</span><span class="ruby-ivar">@attributes</span>.<span class="ruby-identifier">empty?</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-has_elements-3F" class="method-detail ">
<div class="method-heading">
<span class="method-name">has_elements?</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Evaluates to <code>true</code> if this element has at least one child <a href="Element.html"><code>Element</code></a></p>
<pre class="ruby"><span class="ruby-identifier">doc</span> = <span class="ruby-constant">Document</span>.<span class="ruby-identifier">new</span> <span class="ruby-string">"<a><b/><c>Text</c></a>"</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">has_elements</span> <span class="ruby-comment"># -> true</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">elements</span>[<span class="ruby-string">"/a/b"</span>].<span class="ruby-identifier">has_elements</span> <span class="ruby-comment"># -> false</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">elements</span>[<span class="ruby-string">"/a/c"</span>].<span class="ruby-identifier">has_elements</span> <span class="ruby-comment"># -> false</span>
</pre>
<div class="method-source-code" id="has_elements-3F-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 325</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">has_elements?</span>
<span class="ruby-operator">!</span><span class="ruby-ivar">@elements</span>.<span class="ruby-identifier">empty?</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-has_text-3F" class="method-detail ">
<div class="method-heading">
<span class="method-name">has_text?</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Evaluates to <code>true</code> if this element has at least one <a href="Text.html"><code>Text</code></a> child</p>
<div class="method-source-code" id="has_text-3F-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 433</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">has_text?</span>
<span class="ruby-keyword">not</span> <span class="ruby-identifier">text</span>().<span class="ruby-identifier">nil?</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-ignore_whitespace_nodes" class="method-detail ">
<div class="method-heading">
<span class="method-name">ignore_whitespace_nodes</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="ignore_whitespace_nodes-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 162</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">ignore_whitespace_nodes</span>
<span class="ruby-ivar">@ignore_whitespace_nodes</span> = <span class="ruby-keyword">false</span>
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@context</span>
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@context</span>[<span class="ruby-value">:ignore_whitespace_nodes</span>]
<span class="ruby-ivar">@ignore_whitespace_nodes</span> =
(<span class="ruby-ivar">@context</span>[<span class="ruby-value">:ignore_whitespace_nodes</span>] <span class="ruby-operator">==</span> <span class="ruby-value">:all</span> <span class="ruby-keyword">or</span>
<span class="ruby-ivar">@context</span>[<span class="ruby-value">:ignore_whitespace_nodes</span>].<span class="ruby-identifier">include?</span> <span class="ruby-identifier">expanded_name</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-inspect" class="method-detail ">
<div class="method-heading">
<span class="method-name">inspect</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="inspect-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 77</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">inspect</span>
<span class="ruby-identifier">rv</span> = <span class="ruby-string">"<#@expanded_name"</span>
<span class="ruby-ivar">@attributes</span>.<span class="ruby-identifier">each_attribute</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">attr</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">rv</span> <span class="ruby-operator"><<</span> <span class="ruby-string">" "</span>
<span class="ruby-identifier">attr</span>.<span class="ruby-identifier">write</span>( <span class="ruby-identifier">rv</span>, <span class="ruby-value">0</span> )
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">children</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">></span> <span class="ruby-value">0</span>
<span class="ruby-identifier">rv</span> <span class="ruby-operator"><<</span> <span class="ruby-string">"> ... </>"</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">rv</span> <span class="ruby-operator"><<</span> <span class="ruby-string">"/>"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-instructions" class="method-detail ">
<div class="method-heading">
<span class="method-name">instructions</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Get an array of all <a href="Instruction.html"><code>Instruction</code></a> children. IMMUTABLE</p>
<div class="method-source-code" id="instructions-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 680</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">instructions</span>
<span class="ruby-identifier">find_all</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">child</span><span class="ruby-operator">|</span> <span class="ruby-identifier">child</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Instruction</span> }.<span class="ruby-identifier">freeze</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-namespace" class="method-detail ">
<div class="method-heading">
<span class="method-name">namespace</span><span
class="method-args">(prefix=nil)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Evaluates to the <a href="../URI.html"><code>URI</code></a> for a prefix, or the empty string if no such namespace is declared for this element. Evaluates recursively for ancestors. Returns the default namespace, if there is one.</p>
<dl class="rdoc-list note-list"><dt>prefix
<dd>
<p>the prefix to search for. If not supplied, returns the default namespace if one exists</p>
</dd><dt>Returns
<dd>
<p>the namespace <a href="../URI.html"><code>URI</code></a> as a <a href="../String.html"><code>String</code></a>, or nil if no such namespace exists. If the namespace is undefined, returns an empty string</p>
</dd></dl>
<pre class="ruby"><span class="ruby-identifier">doc</span> = <span class="ruby-constant">Document</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">"<a xmlns='1' xmlns:y='2'><b/><c xmlns:z='3'/></a>"</span>)
<span class="ruby-identifier">b</span> = <span class="ruby-identifier">doc</span>.<span class="ruby-identifier">elements</span>[<span class="ruby-string">'//b'</span>]
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">namespace</span> <span class="ruby-comment"># -> '1'</span>
<span class="ruby-identifier">b</span>.<span class="ruby-identifier">namespace</span>(<span class="ruby-string">"y"</span>) <span class="ruby-comment"># -> '2'</span>
</pre>
<div class="method-source-code" id="namespace-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 223</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">namespace</span>(<span class="ruby-identifier">prefix</span>=<span class="ruby-keyword">nil</span>)
<span class="ruby-keyword">if</span> <span class="ruby-identifier">prefix</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-identifier">prefix</span> = <span class="ruby-identifier">prefix</span>()
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">prefix</span> <span class="ruby-operator">==</span> <span class="ruby-string">''</span>
<span class="ruby-identifier">prefix</span> = <span class="ruby-string">"xmlns"</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">prefix</span> = <span class="ruby-node">"xmlns:#{prefix}"</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">prefix</span>[<span class="ruby-value">0</span>,<span class="ruby-value">5</span>] <span class="ruby-operator">==</span> <span class="ruby-string">'xmlns'</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">ns</span> = <span class="ruby-identifier">attributes</span>[ <span class="ruby-identifier">prefix</span> ]
<span class="ruby-identifier">ns</span> = <span class="ruby-identifier">parent</span>.<span class="ruby-identifier">namespace</span>(<span class="ruby-identifier">prefix</span>) <span class="ruby-keyword">if</span> <span class="ruby-identifier">ns</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-keyword">and</span> <span class="ruby-identifier">parent</span>
<span class="ruby-identifier">ns</span> = <span class="ruby-string">''</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">ns</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-keyword">and</span> <span class="ruby-identifier">prefix</span> <span class="ruby-operator">==</span> <span class="ruby-string">'xmlns'</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">ns</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-namespaces" class="method-detail ">
<div class="method-heading">
<span class="method-name">namespaces</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="namespaces-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 203</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">namespaces</span>
<span class="ruby-identifier">namespaces</span> = {}
<span class="ruby-identifier">namespaces</span> = <span class="ruby-identifier">parent</span>.<span class="ruby-identifier">namespaces</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">parent</span>
<span class="ruby-identifier">namespaces</span> = <span class="ruby-identifier">namespaces</span>.<span class="ruby-identifier">merge</span>( <span class="ruby-identifier">attributes</span>.<span class="ruby-identifier">namespaces</span> )
<span class="ruby-keyword">return</span> <span class="ruby-identifier">namespaces</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-next_element" class="method-detail ">
<div class="method-heading">
<span class="method-name">next_element</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the next sibling that is an element, or nil if there is no <a href="Element.html"><code>Element</code></a> sibling after this one</p>
<pre class="ruby"><span class="ruby-identifier">doc</span> = <span class="ruby-constant">Document</span>.<span class="ruby-identifier">new</span> <span class="ruby-string">'<a><b/>text<c/></a>'</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">elements</span>[<span class="ruby-string">'b'</span>].<span class="ruby-identifier">next_element</span> <span class="ruby-comment">#-> <c/></span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">elements</span>[<span class="ruby-string">'c'</span>].<span class="ruby-identifier">next_element</span> <span class="ruby-comment">#-> nil</span>
</pre>
<div class="method-source-code" id="next_element-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 410</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">next_element</span>
<span class="ruby-identifier">element</span> = <span class="ruby-identifier">next_sibling</span>
<span class="ruby-identifier">element</span> = <span class="ruby-identifier">element</span>.<span class="ruby-identifier">next_sibling</span> <span class="ruby-keyword">until</span> <span class="ruby-identifier">element</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-keyword">or</span> <span class="ruby-identifier">element</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Element</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">element</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-node_type" class="method-detail ">
<div class="method-heading">
<span class="method-name">node_type</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="node_type-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 535</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">node_type</span>
<span class="ruby-value">:element</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-prefixes" class="method-detail ">
<div class="method-heading">
<span class="method-name">prefixes</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Evaluates to an <code>Array</code> containing the prefixes (names) of all defined namespaces at this context node.</p>
<pre class="ruby"><span class="ruby-identifier">doc</span> = <span class="ruby-constant">Document</span>.<span class="ruby-identifier">new</span>(<span class="ruby-string">"<a xmlns:x='1' xmlns:y='2'><b/><c xmlns:z='3'/></a>"</span>)
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">elements</span>[<span class="ruby-string">'//b'</span>].<span class="ruby-identifier">prefixes</span> <span class="ruby-comment"># -> ['x', 'y']</span>
</pre>
<div class="method-source-code" id="prefixes-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 196</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">prefixes</span>
<span class="ruby-identifier">prefixes</span> = []
<span class="ruby-identifier">prefixes</span> = <span class="ruby-identifier">parent</span>.<span class="ruby-identifier">prefixes</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">parent</span>
<span class="ruby-identifier">prefixes</span> <span class="ruby-operator">|=</span> <span class="ruby-identifier">attributes</span>.<span class="ruby-identifier">prefixes</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">prefixes</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-previous_element" class="method-detail ">
<div class="method-heading">
<span class="method-name">previous_element</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Returns the previous sibling that is an element, or nil if there is no <a href="Element.html"><code>Element</code></a> sibling prior to this one</p>
<pre class="ruby"><span class="ruby-identifier">doc</span> = <span class="ruby-constant">Document</span>.<span class="ruby-identifier">new</span> <span class="ruby-string">'<a><b/>text<c/></a>'</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">elements</span>[<span class="ruby-string">'c'</span>].<span class="ruby-identifier">previous_element</span> <span class="ruby-comment">#-> <b/></span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">elements</span>[<span class="ruby-string">'b'</span>].<span class="ruby-identifier">previous_element</span> <span class="ruby-comment">#-> nil</span>
</pre>
<div class="method-source-code" id="previous_element-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 421</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">previous_element</span>
<span class="ruby-identifier">element</span> = <span class="ruby-identifier">previous_sibling</span>
<span class="ruby-identifier">element</span> = <span class="ruby-identifier">element</span>.<span class="ruby-identifier">previous_sibling</span> <span class="ruby-keyword">until</span> <span class="ruby-identifier">element</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-keyword">or</span> <span class="ruby-identifier">element</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Element</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">element</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-raw" class="method-detail ">
<div class="method-heading">
<span class="method-name">raw</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Evaluates to <code>true</code> if raw mode is set for this element. This is the case if the context has :<code>raw</code> set to :<code>all</code> or an array containing the name of this element.</p>
<p>The evaluation is tested against <code>expanded_name</code>, and so is namespace sensitive.</p>
<div class="method-source-code" id="raw-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 179</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">raw</span>
<span class="ruby-ivar">@raw</span> = (<span class="ruby-ivar">@context</span> <span class="ruby-keyword">and</span> <span class="ruby-ivar">@context</span>[<span class="ruby-value">:raw</span>] <span class="ruby-keyword">and</span>
(<span class="ruby-ivar">@context</span>[<span class="ruby-value">:raw</span>] <span class="ruby-operator">==</span> <span class="ruby-value">:all</span> <span class="ruby-keyword">or</span>
<span class="ruby-ivar">@context</span>[<span class="ruby-value">:raw</span>].<span class="ruby-identifier">include?</span> <span class="ruby-identifier">expanded_name</span>))
<span class="ruby-ivar">@raw</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-root" class="method-detail ">
<div class="method-heading">
<span class="method-name">root</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="root-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 124</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">root</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">elements</span>[<span class="ruby-value">1</span>] <span class="ruby-keyword">if</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Document</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">self</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">parent</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Document</span> <span class="ruby-keyword">or</span> <span class="ruby-identifier">parent</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">parent</span>.<span class="ruby-identifier">root</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-root_node" class="method-detail ">
<div class="method-heading">
<span class="method-name">root_node</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Evaluates to the root node of the document that this element belongs to. If this element doesn't belong to a document, but does belong to another <a href="Element.html"><code>Element</code></a>, the parent's root will be returned, until the earliest ancestor is found.</p>
<p>Note that this is not the same as the document element. In the following example, <a> is the document element, and the root node is the parent node of the document element. You may ask yourself why the root node is useful: consider the doctype and <a href="../XML.html"><code>XML</code></a> declaration, and any processing instructions before the document element… they are children of the root node, or siblings of the document element. The only time this isn't true is when an <a href="Element.html"><code>Element</code></a> is created that is not part of any <a href="Document.html"><code>Document</code></a>. In this case, the ancestor that has no parent acts as the root node.</p>
<pre class="ruby"><span class="ruby-identifier">d</span> = <span class="ruby-constant">Document</span>.<span class="ruby-identifier">new</span> <span class="ruby-string">'<a><b><c/></b></a>'</span>
<span class="ruby-identifier">a</span> = <span class="ruby-identifier">d</span>[<span class="ruby-value">1</span>] ; <span class="ruby-identifier">c</span> = <span class="ruby-identifier">a</span>[<span class="ruby-value">1</span>][<span class="ruby-value">1</span>]
<span class="ruby-identifier">d</span>.<span class="ruby-identifier">root_node</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">d</span> <span class="ruby-comment"># TRUE</span>
<span class="ruby-identifier">a</span>.<span class="ruby-identifier">root_node</span> <span class="ruby-comment"># namely, d</span>
<span class="ruby-identifier">c</span>.<span class="ruby-identifier">root_node</span> <span class="ruby-comment"># again, d</span>
</pre>
<div class="method-source-code" id="root_node-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 120</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">root_node</span>
<span class="ruby-identifier">parent</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-operator">?</span> <span class="ruby-keyword">self</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">parent</span>.<span class="ruby-identifier">root_node</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-text" class="method-detail ">
<div class="method-heading">
<span class="method-name">text</span><span
class="method-args">( path = nil )</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>A convenience method which returns the <a href="../String.html"><code>String</code></a> value of the <em>first</em> child text element, if one exists, and <code>nil</code> otherwise.</p>
<p><em>Note that an element may have multiple <a href="Text.html"><code>Text</code></a> elements, perhaps separated by other children</em>. Be aware that this method only returns the first <a href="Text.html"><code>Text</code></a> node.</p>
<p>This method returns the <code>value</code> of the first text child node, which ignores the <code>raw</code> setting, so always returns normalized text. See the Text::value documentation.</p>
<pre class="ruby"><span class="ruby-identifier">doc</span> = <span class="ruby-constant">Document</span>.<span class="ruby-identifier">new</span> <span class="ruby-string">"<p>some text <b>this is bold!</b> more text</p>"</span>
<span class="ruby-comment"># The element 'p' has two text elements, "some text " and " more text".</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">text</span> <span class="ruby-comment">#-> "some text "</span>
</pre>
<div class="method-source-code" id="text-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 451</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">text</span>( <span class="ruby-identifier">path</span> = <span class="ruby-keyword">nil</span> )
<span class="ruby-identifier">rv</span> = <span class="ruby-identifier">get_text</span>(<span class="ruby-identifier">path</span>)
<span class="ruby-keyword">return</span> <span class="ruby-identifier">rv</span>.<span class="ruby-identifier">value</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">rv</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-keyword">nil</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-text-3D" class="method-detail ">
<div class="method-heading">
<span class="method-name">text=</span><span
class="method-args">( text )</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Sets the first <a href="Text.html"><code>Text</code></a> child of this object. See text() for a discussion about <a href="Text.html"><code>Text</code></a> children.</p>
<p>If a <a href="Text.html"><code>Text</code></a> child already exists, the child is replaced by this content. This means that <a href="Text.html"><code>Text</code></a> content can be deleted by calling this method with a nil argument. In this case, the next <a href="Text.html"><code>Text</code></a> child becomes the first <a href="Text.html"><code>Text</code></a> child. In no case is the order of any siblings disturbed.</p>
<dl class="rdoc-list note-list"><dt>text
<dd>
<p>If a <a href="../String.html"><code>String</code></a>, a new <a href="Text.html"><code>Text</code></a> child is created and added to this <a href="Element.html"><code>Element</code></a> as the first <a href="Text.html"><code>Text</code></a> child. If <a href="Text.html"><code>Text</code></a>, the text is set as the first <a href="Child.html"><code>Child</code></a> element. If nil, then any existing first <a href="Text.html"><code>Text</code></a> child is removed.</p>
</dd><dt>Returns
<dd>
<p>this <a href="Element.html"><code>Element</code></a>.</p>
</dd></dl>
<pre class="ruby"><span class="ruby-identifier">doc</span> = <span class="ruby-constant">Document</span>.<span class="ruby-identifier">new</span> <span class="ruby-string">'<a><b/></a>'</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">text</span> = <span class="ruby-string">'Sean'</span> <span class="ruby-comment">#-> '<a><b/>Sean</a>'</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">text</span> = <span class="ruby-string">'Elliott'</span> <span class="ruby-comment">#-> '<a><b/>Elliott</a>'</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">add_element</span> <span class="ruby-string">'c'</span> <span class="ruby-comment">#-> '<a><b/>Elliott<c/></a>'</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">text</span> = <span class="ruby-string">'Russell'</span> <span class="ruby-comment">#-> '<a><b/>Russell<c/></a>'</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">root</span>.<span class="ruby-identifier">text</span> = <span class="ruby-keyword">nil</span> <span class="ruby-comment">#-> '<a><b/><c/></a>'</span>
</pre>
<div class="method-source-code" id="text-3D-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 493</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">text=</span>( <span class="ruby-identifier">text</span> )
<span class="ruby-keyword">if</span> <span class="ruby-identifier">text</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">String</span>
<span class="ruby-identifier">text</span> = <span class="ruby-constant">Text</span>.<span class="ruby-identifier">new</span>( <span class="ruby-identifier">text</span>, <span class="ruby-identifier">whitespace</span>(), <span class="ruby-keyword">nil</span>, <span class="ruby-identifier">raw</span>() )
<span class="ruby-keyword">elsif</span> <span class="ruby-operator">!</span><span class="ruby-identifier">text</span>.<span class="ruby-identifier">nil?</span> <span class="ruby-keyword">and</span> <span class="ruby-operator">!</span><span class="ruby-identifier">text</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Text</span>
<span class="ruby-identifier">text</span> = <span class="ruby-constant">Text</span>.<span class="ruby-identifier">new</span>( <span class="ruby-identifier">text</span>.<span class="ruby-identifier">to_s</span>, <span class="ruby-identifier">whitespace</span>(), <span class="ruby-keyword">nil</span>, <span class="ruby-identifier">raw</span>() )
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">old_text</span> = <span class="ruby-identifier">get_text</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">text</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-identifier">old_text</span>.<span class="ruby-identifier">remove</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">old_text</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-keyword">else</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">old_text</span>.<span class="ruby-identifier">nil?</span>
<span class="ruby-keyword">self</span> <span class="ruby-operator"><<</span> <span class="ruby-identifier">text</span>
<span class="ruby-keyword">else</span>
<span class="ruby-identifier">old_text</span>.<span class="ruby-identifier">replace_with</span>( <span class="ruby-identifier">text</span> )
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">self</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-texts" class="method-detail ">
<div class="method-heading">
<span class="method-name">texts</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Get an array of all <a href="Text.html"><code>Text</code></a> children. IMMUTABLE</p>
<div class="method-source-code" id="texts-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 686</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">texts</span>
<span class="ruby-identifier">find_all</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">child</span><span class="ruby-operator">|</span> <span class="ruby-identifier">child</span>.<span class="ruby-identifier">kind_of?</span> <span class="ruby-constant">Text</span> }.<span class="ruby-identifier">freeze</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-whitespace" class="method-detail ">
<div class="method-heading">
<span class="method-name">whitespace</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>Evaluates to <code>true</code> if whitespace is respected for this element. This is the case if:</p>
<ol><li>
<p>Neither :<code>respect_whitespace</code> nor :<code>compress_whitespace</code> has any value</p>
</li><li>
<p>The context has :<code>respect_whitespace</code> set to :<code>all</code> or an array containing the name of this element, and :<code>compress_whitespace</code> isn't set to :<code>all</code> or an array containing the name of this element.</p>
</li></ol>
<p>The evaluation is tested against <code>expanded_name</code>, and so is namespace sensitive.</p>
<div class="method-source-code" id="whitespace-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 146</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">whitespace</span>
<span class="ruby-ivar">@whitespace</span> = <span class="ruby-keyword">nil</span>
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@context</span>
<span class="ruby-keyword">if</span> <span class="ruby-ivar">@context</span>[<span class="ruby-value">:respect_whitespace</span>]
<span class="ruby-ivar">@whitespace</span> = (<span class="ruby-ivar">@context</span>[<span class="ruby-value">:respect_whitespace</span>] <span class="ruby-operator">==</span> <span class="ruby-value">:all</span> <span class="ruby-keyword">or</span>
<span class="ruby-ivar">@context</span>[<span class="ruby-value">:respect_whitespace</span>].<span class="ruby-identifier">include?</span> <span class="ruby-identifier">expanded_name</span>)
<span class="ruby-keyword">end</span>
<span class="ruby-ivar">@whitespace</span> = <span class="ruby-keyword">false</span> <span class="ruby-keyword">if</span> (<span class="ruby-ivar">@context</span>[<span class="ruby-value">:compress_whitespace</span>] <span class="ruby-keyword">and</span>
(<span class="ruby-ivar">@context</span>[<span class="ruby-value">:compress_whitespace</span>] <span class="ruby-operator">==</span> <span class="ruby-value">:all</span> <span class="ruby-keyword">or</span>
<span class="ruby-ivar">@context</span>[<span class="ruby-value">:compress_whitespace</span>].<span class="ruby-identifier">include?</span> <span class="ruby-identifier">expanded_name</span>)
)
<span class="ruby-keyword">end</span>
<span class="ruby-ivar">@whitespace</span> = <span class="ruby-keyword">true</span> <span class="ruby-keyword">unless</span> <span class="ruby-ivar">@whitespace</span> <span class="ruby-operator">==</span> <span class="ruby-keyword">false</span>
<span class="ruby-ivar">@whitespace</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-write" class="method-detail ">
<div class="method-heading">
<span class="method-name">write</span><span
class="method-args">(output=$stdout, indent=-1, transitive=false, ie_hack=false)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<h2 id="method-i-write-label-DEPRECATED">DEPRECATED<span><a href="#method-i-write-label-DEPRECATED">¶</a> <a href="#top">↑</a></span></h2>
<p>See <a href="Formatters.html"><code>REXML::Formatters</code></a></p>
<p>Writes out this element, and recursively, all children.</p>
<dl class="rdoc-list note-list"><dt>output
<dd>
<p>output an object which supports '<< string'; this is where the</p>
</dd></dl>
<pre>document will be written.</pre>
<dl class="rdoc-list note-list"><dt>indent
<dd>
<p>An integer. If -1, no indenting will be used; otherwise, the indentation will be this number of spaces, and children will be indented an additional amount. Defaults to -1</p>
</dd><dt>transitive
<dd>
<p>If transitive is true and indent is >= 0, then the output will be pretty-printed in such a way that the added whitespace does not affect the parse tree of the document</p>
</dd><dt>ie_hack
<dd>
<p>This hack inserts a space before the /> on empty tags to address a limitation of Internet Explorer. Defaults to false</p>
</dd></dl>
<pre class="ruby"><span class="ruby-identifier">out</span> = <span class="ruby-string">''</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">write</span>( <span class="ruby-identifier">out</span> ) <span class="ruby-comment">#-> doc is written to the string 'out'</span>
<span class="ruby-identifier">doc</span>.<span class="ruby-identifier">write</span>( <span class="ruby-identifier">$stdout</span> ) <span class="ruby-comment">#-> doc written to the console</span>
</pre>
<div class="method-source-code" id="write-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 712</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">write</span>(<span class="ruby-identifier">output</span>=<span class="ruby-identifier">$stdout</span>, <span class="ruby-identifier">indent</span>=<span class="ruby-value">-1</span>, <span class="ruby-identifier">transitive</span>=<span class="ruby-keyword">false</span>, <span class="ruby-identifier">ie_hack</span>=<span class="ruby-keyword">false</span>)
<span class="ruby-constant">Kernel</span>.<span class="ruby-identifier">warn</span>(<span class="ruby-node">"#{self.class.name}.write is deprecated. See REXML::Formatters"</span>, <span class="ruby-value">uplevel:</span> <span class="ruby-value">1</span>)
<span class="ruby-identifier">formatter</span> = <span class="ruby-keyword">if</span> <span class="ruby-identifier">indent</span> <span class="ruby-operator">></span> <span class="ruby-value">-1</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">transitive</span>
<span class="ruby-identifier">require_relative</span> <span class="ruby-string">"formatters/transitive"</span>
<span class="ruby-constant">REXML</span><span class="ruby-operator">::</span><span class="ruby-constant">Formatters</span><span class="ruby-operator">::</span><span class="ruby-constant">Transitive</span>.<span class="ruby-identifier">new</span>( <span class="ruby-identifier">indent</span>, <span class="ruby-identifier">ie_hack</span> )
<span class="ruby-keyword">else</span>
<span class="ruby-constant">REXML</span><span class="ruby-operator">::</span><span class="ruby-constant">Formatters</span><span class="ruby-operator">::</span><span class="ruby-constant">Pretty</span>.<span class="ruby-identifier">new</span>( <span class="ruby-identifier">indent</span>, <span class="ruby-identifier">ie_hack</span> )
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">else</span>
<span class="ruby-constant">REXML</span><span class="ruby-operator">::</span><span class="ruby-constant">Formatters</span><span class="ruby-operator">::</span><span class="ruby-constant">Default</span>.<span class="ruby-identifier">new</span>( <span class="ruby-identifier">ie_hack</span> )
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">formatter</span>.<span class="ruby-identifier">write</span>( <span class="ruby-keyword">self</span>, <span class="ruby-identifier">output</span> )
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-xpath" class="method-detail ">
<div class="method-heading">
<span class="method-name">xpath</span><span
class="method-args">()</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="xpath-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 539</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">xpath</span>
<span class="ruby-identifier">path_elements</span> = []
<span class="ruby-identifier">cur</span> = <span class="ruby-keyword">self</span>
<span class="ruby-identifier">path_elements</span> <span class="ruby-operator"><<</span> <span class="ruby-identifier">__to_xpath_helper</span>( <span class="ruby-keyword">self</span> )
<span class="ruby-keyword">while</span> <span class="ruby-identifier">cur</span>.<span class="ruby-identifier">parent</span>
<span class="ruby-identifier">cur</span> = <span class="ruby-identifier">cur</span>.<span class="ruby-identifier">parent</span>
<span class="ruby-identifier">path_elements</span> <span class="ruby-operator"><<</span> <span class="ruby-identifier">__to_xpath_helper</span>( <span class="ruby-identifier">cur</span> )
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">return</span> <span class="ruby-identifier">path_elements</span>.<span class="ruby-identifier">reverse</span>.<span class="ruby-identifier">join</span>( <span class="ruby-string">"/"</span> )
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
</section>
<section id="private-instance-5Buntitled-5D-method-details" class="method-section">
<header>
<h3>Private Instance Methods</h3>
</header>
<div id="method-i-__to_xpath_helper" class="method-detail ">
<div class="method-heading">
<span class="method-name">__to_xpath_helper</span><span
class="method-args">(node)</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<div class="method-source-code" id="__to_xpath_helper-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 729</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">__to_xpath_helper</span> <span class="ruby-identifier">node</span>
<span class="ruby-identifier">rv</span> = <span class="ruby-identifier">node</span>.<span class="ruby-identifier">expanded_name</span>.<span class="ruby-identifier">clone</span>
<span class="ruby-keyword">if</span> <span class="ruby-identifier">node</span>.<span class="ruby-identifier">parent</span>
<span class="ruby-identifier">results</span> = <span class="ruby-identifier">node</span>.<span class="ruby-identifier">parent</span>.<span class="ruby-identifier">find_all</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">n</span><span class="ruby-operator">|</span>
<span class="ruby-identifier">n</span>.<span class="ruby-identifier">kind_of?</span>(<span class="ruby-constant">REXML</span><span class="ruby-operator">::</span><span class="ruby-constant">Element</span>) <span class="ruby-keyword">and</span> <span class="ruby-identifier">n</span>.<span class="ruby-identifier">expanded_name</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">node</span>.<span class="ruby-identifier">expanded_name</span>
}
<span class="ruby-keyword">if</span> <span class="ruby-identifier">results</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">></span> <span class="ruby-value">1</span>
<span class="ruby-identifier">idx</span> = <span class="ruby-identifier">results</span>.<span class="ruby-identifier">index</span>( <span class="ruby-identifier">node</span> )
<span class="ruby-identifier">rv</span> <span class="ruby-operator"><<</span> <span class="ruby-node">"[#{idx+1}]"</span>
<span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span>
<span class="ruby-identifier">rv</span>
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
<div id="method-i-each_with_something" class="method-detail ">
<div class="method-heading">
<span class="method-name">each_with_something</span><span
class="method-args">( test, max=0, name=nil ) { |child| ... }</span>
<span class="method-click-advice">click to toggle source</span>
</div>
<div class="method-description">
<p>A private helper method</p>
<div class="method-source-code" id="each_with_something-source">
<pre><span class="ruby-comment"># File lib/rexml/element.rb, line 744</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">each_with_something</span>( <span class="ruby-identifier">test</span>, <span class="ruby-identifier">max</span>=<span class="ruby-value">0</span>, <span class="ruby-identifier">name</span>=<span class="ruby-keyword">nil</span> )
<span class="ruby-identifier">num</span> = <span class="ruby-value">0</span>
<span class="ruby-ivar">@elements</span>.<span class="ruby-identifier">each</span>( <span class="ruby-identifier">name</span> ){ <span class="ruby-operator">|</span><span class="ruby-identifier">child</span><span class="ruby-operator">|</span>
<span class="ruby-keyword">yield</span> <span class="ruby-identifier">child</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">test</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">child</span>) <span class="ruby-keyword">and</span> <span class="ruby-identifier">num</span> <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
<span class="ruby-keyword">return</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">max</span><span class="ruby-operator">></span><span class="ruby-value">0</span> <span class="ruby-keyword">and</span> <span class="ruby-identifier">num</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">max</span>
}
<span class="ruby-keyword">end</span></pre>
</div>
</div>
</div>
</section>
</section>
</main>
<footer id="validator-badges" role="contentinfo">
<p><a href="https://validator.w3.org/check/referer">Validate</a>
<p>Generated by <a href="https://ruby.github.io/rdoc/">RDoc</a> 6.2.1.1.
<p>Based on <a href="http://deveiate.org/projects/Darkfish-RDoc/">Darkfish</a> by <a href="http://deveiate.org">Michael Granger</a>.
</footer>