Class REXML::Attributes
In: temp/element.rb
Parent: Hash

A class that defines the set of Attributes of an Element and provides operations for accessing elements in that set.

Methods

<<   []   []=   add   delete   delete_all   each   each_attribute   get_attribute   get_attribute_ns   length   namespaces   new   prefixes   size   to_a  

Public Class methods

new(element)

Constructor

element:the Element of which this is an Attribute

Public Instance methods

<<( attribute )

Alias for add

[](name)

Fetches an attribute value. If you want to get the Attribute itself, use get_attribute()

name:an XPath attribute name. Namespaces are relevant here.
Returns:the String value of the matching attribute, or nil if no matching attribute was found. This is the unnormalized value (with entities expanded). 
 doc = Document.new "<a foo:att='1' bar:att='2' att='&lt;'/>"
 doc.root.attributes['att']         #-> '<'
 doc.root.attributes['bar:att']     #-> '2'
[]=( name, value )

Sets an attribute, overwriting any existing attribute value by the same name. Namespace is significant.

name:the name of the attribute
value:(optional) If supplied, the value of the attribute. If nil, any existing matching attribute is deleted.
Returns:Owning element 
 doc = Document.new "<a x:foo='1' foo='3'/>"
 doc.root.attributes['y:foo'] = '2'
 doc.root.attributes['foo'] = '4'
 doc.root.attributes['x:foo'] = nil
add( attribute )

Adds an attribute, overriding any existing attribute by the same name. Namespaces are significant.

attribute:An Attribute
delete( attribute )

Removes an attribute

attribute:either a String, which is the name of the attribute to remove — namespaces are significant here — or the attribute to remove.
Returns:the owning element 
 doc = Document.new "<a y:foo='0' x:foo='1' foo='3' z:foo='4'/>"
 doc.root.attributes.delete 'foo'   #-> <a y:foo='0' x:foo='1' z:foo='4'/>"
 doc.root.attributes.delete 'x:foo' #-> <a y:foo='0' z:foo='4'/>"
 attr = doc.root.attributes.get_attribute('y:foo')
 doc.root.attributes.delete attr    #-> <a z:foo='4'/>"
delete_all( name )

Deletes all attributes matching a name. Namespaces are significant.

name:A String; all attributes that match this path will be removed
Returns:an Array of the Attributes that were removed
each() {|[attr.expanded_name, attr.value]| ...}

Itterates over each attribute of an Element, yielding the expanded name and value as a pair of Strings. 

 doc = Document.new '<a x="1" y="2"/>'
 doc.root.attributes.each {|name, value| p name+" => "+value }
each_attribute( {|attribute| ...}

Itterates over the attributes of an Element. Yields actual Attribute nodes, not String values. 

 doc = Document.new '<a x="1" y="2"/>'
 doc.root.attributes.each_attribute {|attr|
   p attr.expanded_name+" => "+attr.value
 }
get_attribute( name )

Fetches an attribute

name:the name by which to search for the attribute. Can be a prefix:name namespace name.
Returns:The first matching attribute, or nil if there was none. This

value is an Attribute node, not the String value of the attribute. 

 doc = Document.new '<a x:foo="1" foo="2" bar="3"/>'
 doc.root.attributes.get_attribute("foo").value    #-> "2"
 doc.root.attributes.get_attribute("x:foo").value  #-> "1"
get_attribute_ns(namespace, name)

The get_attribute_ns method retrieves a method by its namespace and name. Thus it is possible to reliably identify an attribute even if an XML processor has changed the prefix.

Method contributed by Henrik Martensson

length()

Returns the number of attributes the owning Element contains. 

 doc = Document "<a x='1' y='2' foo:x='3'/>"
 doc.root.attributes.length        #-> 3
prefixes()

Returns an array of Strings containing all of the prefixes declared by this set of # attributes. The array does not include the default namespace declaration, if one exists. 

 doc = Document.new("<a xmlns='foo' xmlns:x='bar' xmlns:y='twee' "+
       "z='glorp' p:k='gru'/>")
 prefixes = doc.root.attributes.prefixes    #-> ['x', 'y']
size()

Alias for length

[Validate]