# class REXML::Attribute

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.

### Constants

NEEDS_A_SECOND_CHECK
PATTERN

### 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 ) click to toggle source

Constructor. FIXME: The parser doesn't catch illegal characters in attributes

first

  Either: an `Attribute`, which this new attribute will become a clone of; or a `String`, which is the name of this attribute

second

  If `first` is an `Attribute`, then this may be an `Element`, or nil. If nil, then the `Element` parent of this attribute is the parent of the `first` `Attribute`. If the first argument is a `String`, then this must also be a `String`, and is the content of the attribute. If this is the content, it must be fully normalized (contain no illegal characters).

parent

  Ignored unless `first` is a `String`; otherwise, may be the `Element` parent of this attribute, or nil.

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

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

### Public Instance Methods

==( other ) click to toggle source

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

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

clone() click to toggle source

Returns a copy of this attribute

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

doctype() click to toggle source

    # File lib/rexml/attribute.rb, line 132
    def doctype
      if @element
        doc = @element.document
        doc.doctype if doc
      end
    end

element=( element ) click to toggle source

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

Returns this attribute

    # File lib/rexml/attribute.rb, line 166
    def element=( element )
      @element = element

      if @normalized
        Text.check( @normalized, NEEDS_A_SECOND_CHECK, doctype )
      end

      self
    end

hash() click to toggle source

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

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

inspect() click to toggle source

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

namespace(arg=nil) click to toggle source

Returns the namespace URL, if defined, or nil otherwise

    e = Element.new("el")
    e.add_namespace("ns", "http://url")
    e.add_attribute("ns:a", "b")
    e.add_attribute("nsx:a", "c")
    e.attribute("ns:a").namespace # => "http://url"
    e.attribute("nsx:a").namespace # => nil

This method always returns “” for no namespace attribute. Because the default namespace doesn't apply to attribute names.

From www.w3.org/TR/xml-names/#uniqAttrs

> the default namespace does not apply to attribute names

    e = REXML::Element.new("el")
    e.add_namespace("", "http://example.com/")
    e.namespace # => "http://example.com/"
    e.add_attribute("a", "b")
    e.attribute("a").namespace # => ""

    # File lib/rexml/attribute.rb, line 98
    def namespace arg=nil
      arg = prefix if arg.nil?
      if arg == ""
        ""
      else
        @element.namespace(arg)
      end
    end

node_type() click to toggle source

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

prefix() click to toggle source

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   # -> ""
    a = Attribute.new( "x", "y" )
    a.prefix                                   # -> ""

Calls superclass method

    # File lib/rexml/attribute.rb, line 73
    def prefix
      super
    end

remove() click to toggle source

Removes this `Attribute` from the tree, and returns true if successful

This method is usually not called directly.

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

to_s() click to toggle source

Returns the attribute value, with entities replaced

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

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

to_string() click to toggle source

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'"

    # File lib/rexml/attribute.rb, line 124
    def to_string
      if @element and @element.context and @element.context[:attribute_quote] == :quote
        %Q^#@expanded_name="#{to_s().gsub(/"/, '&quot;')}"^
      else
        "#@expanded_name='#{to_s().gsub(/'/, '&apos;')}'"
      end
    end

value() click to toggle source

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

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

write( output, indent=-1 ) click to toggle source

Writes this attribute (EG, puts 'key=“value”' to the output)

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

xpath() click to toggle source

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