In Files

  • rexml/attribute.rb

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

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 rexml/attribute.rb, line 42
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 rexml/attribute.rb, line 90
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 rexml/attribute.rb, line 143
def clone
        Attribute.new self
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 rexml/attribute.rb, line 151
def element=( element )
        @element = element
        self
end
            
hash() click to toggle source

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

 
               # File rexml/attribute.rb, line 95
def hash
        name.hash + value.hash
end
            
inspect() click to toggle source
 
               # File rexml/attribute.rb, line 172
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_attributes({"xmlns:ns", "http://url"})
e.namespace( "ns" )              # -> "http://url"
 
               # File rexml/attribute.rb, line 83
def namespace arg=nil
        arg = prefix if arg.nil?
        @element.namespace arg
end
            
node_type() click to toggle source
 
               # File rexml/attribute.rb, line 168
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   # -> "elns"
a = Attribute.new( "x", "y" )
a.prefix                                   # -> ""
 
               # File rexml/attribute.rb, line 70
def prefix
        pf = super
        if pf == ""
                pf = @element.prefix if @element
        end
        pf
end
            
remove() click to toggle source

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

This method is usually not called directly.

 
               # File rexml/attribute.rb, line 159
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 rexml/attribute.rb, line 114
          def to_s
                  return @normalized if @normalized

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

                  @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 rexml/attribute.rb, line 105
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() click to toggle source

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

 
               # File rexml/attribute.rb, line 130
          def value
                  return @unnormalized if @unnormalized
                  doctype = nil
                  if @element
                          doc = @element.document
                          doctype = doc.doctype if doc
                  end
                  @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 rexml/attribute.rb, line 164
def write( output, indent=-1 )
        output << to_string
end
            
xpath() click to toggle source
 
               # File rexml/attribute.rb, line 178
def xpath
  path = @element.xpath
  path += "/@#{self.expanded_name}"
  return path
end
            

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus