class REXML::Attribute

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

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

Returns a copy of this attribute

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

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

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

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

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

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

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

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

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(/"/, '"')}"^
  else
    "#@expanded_name='#{to_s().gsub(/'/, ''')}'"
  end
end

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

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