Class: REXML::Attribute

Constructor.

 Attribute.new( attribute_to_clone )
 Attribute.new( source )
 Attribute.new( "attr", "attr_value" )
 Attribute.new( "attr", "attr_value", parent_element )

[Source]

# File rexml/attribute.rb, line 26
                def initialize( first, second=nil, parent=nil )
                        @normalized = @unnormalized = @element = nil
                        if first.kind_of? Attribute
                                self.name = first.expanded_name
                                @value = first.value
                                if second.kind_of? Element
                                        @element = second
                                else
                                        @element = first.element
                                end
                        elsif first.kind_of? String
                                @element = parent if parent.kind_of? Element
                                self.name = first
                                @value = second.to_s
                        else
                                raise "illegal argument #{first.class.name} to Attribute constructor"
                        end
                end

==( other )

Returns true if other is an Attribute and has the same name and value, false otherwise.

[Source]

# File rexml/attribute.rb, line 74
                def ==( other )
                        other.kind_of?(Attribute) and other.name==name and other.value==@value
                end

clone()

Returns a copy of this attribute

[Source]

# File rexml/attribute.rb, line 121
                def clone
                        Attribute.new self
                end

element=( element )

Sets the element of which this object is an attribute. Normally, this is not directly called.

Returns this attribute

[Source]

# File rexml/attribute.rb, line 129
                def element=( element )
                        @element = element
                        self
                end

hash()

Creates (and returns) a hash from both the name and value

[Source]

# File rexml/attribute.rb, line 79
                def hash
                        name.hash + value.hash
                end

inspect()

[Source]

# File rexml/attribute.rb, line 150
    def inspect
      rv = ""
      write( rv )
      rv
    end

namespace(arg=nil)

Returns the namespace URL, if defined, or nil otherwise

 e = Element.new("el")
 e.add_attributes({"xmlns:ns", "http://url"})
 e.namespace( "ns" )              # -> "http://url"

[Source]

# File rexml/attribute.rb, line 67
                def namespace arg=nil
                        arg = prefix if arg.nil?
                        @element.namespace arg
                end

node_type()

[Source]

# File rexml/attribute.rb, line 146
    def node_type
      :attribute
    end

prefix()

Returns the namespace of the attribute.

 e = Element.new( "elns:myelement" )
 e.add_attribute( "nsa:a", "aval" )
 e.add_attribute( "b", "bval" )
 e.attributes.get_attribute( "a" ).prefix   # -> "nsa"
 e.attributes.get_attribute( "b" ).prefix   # -> "elns"
 a = Attribute.new( "x", "y" )
 a.prefix                                   # -> ""

[Source]

# File rexml/attribute.rb, line 54
                def prefix
                        pf = super
                        if pf == ""
                                pf = @element.prefix if @element
                        end
                        pf
                end

remove()

Removes this Attribute from the tree, and returns true if successfull

This method is usually not called directly.

[Source]

# File rexml/attribute.rb, line 137
                def remove
                        @element.attributes.delete self.name unless @element.nil?
                end

to_s()

Returns the attribute value, with entities replaced

[Source]

# File rexml/attribute.rb, line 94
                def to_s
                        return @normalized if @normalized

                        doctype = nil
                        if @element
                                doc = @element.document
                                doctype = doc.doctype if doc
                        end

                        @unnormalized = nil
                        @normalized = Text::normalize( @value, doctype )
                end

to_string()

Returns this attribute out as XML source, expanding the name

 a = Attribute.new( "x", "y" )
 a.to_string     # -> "x='y'"
 b = Attribute.new( "ns:x", "y" )
 b.to_string     # -> "ns:x='y'"

[Source]

# File rexml/attribute.rb, line 89
                def to_string
                        "#@expanded_name='#{to_s().gsub(/'/, '&apos;')}'"
                end

value()

Returns the UNNORMALIZED value of this attribute. That is, entities have been expanded to their values

[Source]

# File rexml/attribute.rb, line 109
                def value
                        return @unnormalized if @unnormalized
                        doctype = nil
                        if @element
                                doc = @element.document
                                doctype = doc.doctype if doc
                        end
                        @normalized = nil
                        @unnormalized = Text::unnormalize( @value, doctype )
                end

write( output, indent=-1 )

Writes this attribute (EG, puts ‘key="value"’ to the output)

[Source]

# File rexml/attribute.rb, line 142
                def write( output, indent=-1 )
                        output << to_string
                end

xpath()

[Source]

# File rexml/attribute.rb, line 156
    def xpath
      path = @element.xpath
      path += "/@#{self.expanded_name}"
      return path
    end

element	[R]	The element to which this attribute belongs
normalized	[W]	The normalized value of this attribute. That is, the attribute with entities intact.

Methods

Included Modules

Constants

Attributes

Public Class methods

Public Instance methods