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
#
C
D
E
H
I
N
P
R
T
V
W
X
Included Modules
Constants
PATTERN = /\s*(#{NAME_STR})\s*=\s*(["'])(.*?)\2/um
 
NEEDS_A_SECOND_CHECK = /(<|&((#{Entity::NAME});|(#0*((?:\d+)|(?:x[a-fA-F0-9]+)));)?)/um
 
Attributes
[R] element

The element to which this attribute belongs

[W] normalized

The normalized value of this attribute. That is, the attribute with entities intact.

Class Public methods
new( first, second=nil, parent=nil )

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 firstis 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 firstis 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 44
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
Instance Public methods
==( other )

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

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

Returns a copy of this attribute

# File lib/rexml/attribute.rb, line 141
def clone
  Attribute.new self
end
doctype()
# File lib/rexml/attribute.rb, line 115
def doctype
  if @element
    doc = @element.document
    doc.doctype if doc
  end
end
element=( element )

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 149
def element=( element )
  @element = element

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

  self
end
hash()

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

# File lib/rexml/attribute.rb, line 97
def hash
  name.hash + value.hash
end
inspect()
# File lib/rexml/attribute.rb, line 175
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"
# File lib/rexml/attribute.rb, line 85
def namespace arg=nil
  arg = prefix if arg.nil?
  @element.namespace arg
end
node_type()
# File lib/rexml/attribute.rb, line 171
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                                   # -> ""
# File lib/rexml/attribute.rb, line 72
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.

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

Returns the attribute value, with entities replaced

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

  @normalized = Text::normalize( @unnormalized, doctype )
  @unnormalized = nil
  @normalized
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'"
# File lib/rexml/attribute.rb, line 107
def to_string
  if @element and @element.context and @element.context[:attribute_quote] == :quote
    %Q#@expanded_name="#{to_s().gsub(/"/, '&quote;')}"^
  else
    "#@expanded_name='#{to_s().gsub(/'/, '&apos;')}'"
  end
end
value()

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

# File lib/rexml/attribute.rb, line 133
def value
  return @unnormalized if @unnormalized
  @unnormalized = Text::unnormalize( @normalized, doctype )
  @normalized = nil
  @unnormalized
end
write( output, indent=-1 )

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

# File lib/rexml/attribute.rb, line 167
def write( output, indent=-1 )
  output << to_string
end
xpath()
# File lib/rexml/attribute.rb, line 181
def xpath
  path = @element.xpath
  path += "/@#{self.expanded_name}"
  return path
end