Class: REXML::Attribute (Ruby 2.4.2)
Description: Class : REXML::Attribute - Ruby 2.4.2

Support for the Ruby 2.4 series has ended. See here for reference.

### Home Classes Methods

### In Files

- rexml/attribute.rb

### Parent

Object

### Methods

- ::new
- #==
- #clone
- #doctype
- #element=
- #hash
- #inspect
- #namespace
- #node_type
- #prefix
- #remove
- #to_s
- #to_string
- #value
- #write
- #xpath

### Included Modules

- REXML::Node
- REXML::Namespace

### Class/Module Index

Quicksearch

- Array
- Float
- Integer
- Object
- REXML
- REXML::AttlistDecl
- REXML::Attribute
- REXML::Attributes
- REXML::CData
- REXML::Child
- REXML::Comment
- REXML::DTD
- REXML::DTD::AttlistDecl
- REXML::DTD::ElementDecl
- REXML::DTD::EntityDecl
- REXML::DTD::NotationDecl
- REXML::DTD::Parser
- REXML::Declaration
- REXML::DocType
- REXML::Document
- REXML::Element
- REXML::ElementDecl
- REXML::Elements
- REXML::Encoding
- REXML::Entity
- REXML::EntityConst
- REXML::ExternalEntity
- REXML::Formatters
- REXML::Formatters::Default
- REXML::Formatters::Pretty
- REXML::Formatters::Transitive
- REXML::Functions
- REXML::IOSource
- REXML::Instruction
- REXML::Light
- REXML::Light::Node
- REXML::Namespace
- REXML::Node
- REXML::NotationDecl
- REXML::Output
- REXML::Parent
- REXML::ParseException
- REXML::Parsers
- REXML::Parsers::BaseParser
- REXML::Parsers::LightParser
- REXML::Parsers::PullEvent
- REXML::Parsers::PullParser
- REXML::Parsers::SAX2Parser
- REXML::Parsers::StreamParser
- REXML::Parsers::TreeParser
- REXML::Parsers::UltraLightParser
- REXML::Parsers::XPathParser
- REXML::QuickPath
- REXML::SAX2Listener
- REXML::Security
- REXML::Source
- REXML::SourceFactory
- REXML::StreamListener
- REXML::SyncEnumerator
- REXML::Text
- REXML::UndefinedNamespaceException
- REXML::Validation
- REXML::Validation::Choice
- REXML::Validation::Event
- REXML::Validation::Interleave
- REXML::Validation::OneOrMore
- REXML::Validation::Optional
- REXML::Validation::Ref
- REXML::Validation::RelaxNG
- REXML::Validation::Sequence
- REXML::Validation::State
- REXML::Validation::ValidationException
- REXML::Validation::Validator
- REXML::Validation::ZeroOrMore
- REXML::XMLDecl
- REXML::XMLTokens
- REXML::XPath
- REXML::XPathParser
- Symbol

No matching classes.

# 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 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 rexml/attribute.rb, line 96
    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 145
    def clone
      Attribute.new self
    end

doctype() click to toggle source

                   # File rexml/attribute.rb, line 119
    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 rexml/attribute.rb, line 153
    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 rexml/attribute.rb, line 101
    def hash
      name.hash + value.hash
    end

inspect() click to toggle source

                   # File rexml/attribute.rb, line 179
    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

                   # File rexml/attribute.rb, line 89
    def namespace arg=nil
      arg = prefix if arg.nil?
      @element.namespace arg
    end

node_type() click to toggle source

                   # File rexml/attribute.rb, line 175
    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 73
    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 successful

This method is usually not called directly.

                   # File rexml/attribute.rb, line 166
    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 127
    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 rexml/attribute.rb, line 111
    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 rexml/attribute.rb, line 137
    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 rexml/attribute.rb, line 171
    def write( output, indent=-1 )
      output << to_string
    end

xpath() click to toggle source

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