Class: REXML::Attribute

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Instance Chain: self, `Namespace`, `XMLTokens`, `Node`
Inherits:	Object
Defined in:	lib/rexml/attribute.rb

Overview

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.

Constant Summary

NEEDS_A_SECOND_CHECK =
# File 'lib/rexml/attribute.rb', line 18

/(<|&((#{Entity::NAME});|(#0*((?:\d)|(?:x[a-fA-F0-9])));)?)/um

PATTERN =
# File 'lib/rexml/attribute.rb', line 16
```
/\s*(#{NAME_STR})\s*=\s*(["'])(.*?)\2/um
```

`XMLTokens` - Included

NAME, NAMECHAR, NAME_CHAR, NAME_START_CHAR, NAME_STR, NCNAME_STR, NMTOKEN, NMTOKENS, REFERENCE

`Namespace` - Included

NAMESPLIT, NAME_WITHOUT_NAMESPACE

Class Method Summary

.new(first, second = nil, parent = nil) ⇒ Attribute constructor

Constructor.

Instance Attribute Summary

#element rw

The element to which this attribute belongs.
#element=(element) rw

Sets the element of which this object is an attribute.
#normalized=(new_normalized) writeonly

The normalized value of this attribute.

`Namespace` - Included

#expanded_name	The name of the object, valid if set.
#local_name	Alias for Namespace#name.
#name	The name of the object, valid if set.
#name=	Sets the name and the expanded name.
#prefix	The expanded name of the object, valid if name is set.

`Node` - Included

#parent?

Instance Method Summary

#==(other)

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

Returns a copy of this attribute.
#doctype
#hash

Creates (and returns) a hash from both the name and value.
#inspect
#namespace(arg = nil)

Returns the namespace URL, if defined, or nil otherwise.
#node_type
#prefix

Returns the namespace of the attribute.
#remove

Removes this Attribute from the tree, and returns true if successful.
#to_s

Returns the attribute value, with entities replaced.
#to_string

Returns this attribute out as XML source, expanding the name.
#value

Returns the UNNORMALIZED value of this attribute.
#write(output, indent = -1 ))

Writes this attribute (EG, puts ‘key=“value”’ to the output).
#xpath

`Namespace` - Included

#fully_expanded_name	Fully expand the name, even if the prefix wasn’t specified in the source file.
#has_name?	Compares names optionally WITH namespaces.

`Node` - Included

#each_recursive	Visit all subnodes of `self` recursively.
#find_first_recursive	Find (and return) first subnode (recursively) for which the block evaluates to true.
#indent,
#index_in_parent	Returns the position that `self` holds in its parent’s array, indexed from 1.
#next_sibling_node, #previous_sibling_node,
#to_s	indent

Constructor Details

.new(first, second = nil, parent = nil) ⇒ `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 )

[ GitHub ]

# File 'lib/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

Instance Attribute Details

#element (rw)

The element to which this attribute belongs

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 15


attr_reader :element

#element=(element) (rw)

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

Returns this attribute

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 172


def element=( element )
  @element = element

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

  self
end

#normalized=(new_normalized) (writeonly)

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

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 158


def normalized=(new_normalized)
  @normalized = new_normalized
  @unnormalized = nil
end

Instance Method Details

#==(other)

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

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 106


def ==( other )
  other.kind_of?(Attribute) and other.name==name and other.value==value
end

#clone

Returns a copy of this attribute

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 164


def clone
  Attribute.new self
end

#doctype

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 132


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

#hash

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

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 111


def hash
  name.hash + value.hash
end

#inspect

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 198


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

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 95


def namespace arg=nil
  arg = prefix if arg.nil?
  if arg == ""
    ""
  else
    @element.namespace(arg)
  end
end

#node_type

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 194


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

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 70


def prefix
  super
end

#remove

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

This method is usually not called directly.

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 185


def remove
  @element.attributes.delete self.name unless @element.nil?
end

#to_s

Returns the attribute value, with entities replaced

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 140


def to_s
  return @normalized if @normalized

  @normalized = Text::normalize( @unnormalized, doctype )
  @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'"

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 121


def to_string
  value = to_s
  if @element and @element.context and @element.context[:attribute_quote] == :quote
    value = value.gsub('"', '&quot;') if value.include?('"')
    %Q^#@expanded_name="#{value}"^
  else
    value = value.gsub("'", '&apos;') if value.include?("'")
    "#@expanded_name='#{value}'"
  end
end

#value

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

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 149


def value
  return @unnormalized if @unnormalized

  @unnormalized = Text::unnormalize(@normalized, doctype,
                                    entity_expansion_text_limit: @element&.document&.entity_expansion_text_limit)
end

#write(output, indent = -1 ))

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

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 190


def write( output, indent=-1 )
  output << to_string
end

#xpath

[ GitHub ]

# File 'lib/rexml/attribute.rb', line 204


def xpath
  path = @element.xpath
  path += "/@#{self.expanded_name}"
  return path
end

Class: REXML::Attribute

Overview

Constant Summary

XMLTokens - Included

Namespace - Included

Class Method Summary

Instance Attribute Summary

Namespace - Included

Node - Included

Instance Method Summary

Namespace - Included

Node - Included

Constructor Details

.new(first, second = nil, parent = nil) ⇒ Attribute

Instance Attribute Details

#element (rw)

#element=(element) (rw)

#normalized=(new_normalized) (writeonly)

Instance Method Details

#==(other)

#clone

#doctype

#hash

#inspect

#namespace(arg = nil)

#node_type

#prefix

#remove

#to_s

#to_string

#value

#write(output, indent = -1 ))

#xpath

`XMLTokens` - Included

`Namespace` - Included

`Namespace` - Included

`Node` - Included

`Namespace` - Included

`Node` - Included

.new(first, second = nil, parent = nil) ⇒ `Attribute`