Class: REXML::Attribute

Class | REXML::Attribute
In: | rexml/attribute.rb
Parent: | Object

Defines an Element Attribute; IE, a attribute=value pair, as in: <element attribute="value"/>. Attributes can be in their own namespaces. General users of REXML will not interact with the Attribute class much.

### Methods

== clone element= hash inspect namespace new node_type prefix remove to_s to_string value write xpath

### Included Modules

Node Namespace

### Constants

PATTERN | = | /\s*(#{NAME_STR})\s*=\s*(["'])(.*?)\2/um

### Attributes

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

### Public Class methods

new( first, second=nil, parent=nil )

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

### Public Instance methods

==( 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

[Validate]