Class: REXML::Attribute

Inherits:
Object show all
Includes:
Namespace, Node
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 collapse

PATTERN =
/\s*(#{NAME_STR})\s*=\s*(["'])(.*?)\2/um
NEEDS_A_SECOND_CHECK =
/(<|&((#{Entity::NAME});|(#0*((?:\d+)|(?:x[a-fA-F0-9]+)));)?)/um

Constants included from Namespace

Namespace::NAMESPLIT

Constants included from XMLTokens

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

Instance Attribute Summary collapse

Attributes included from Namespace

#expanded_name, #name

Instance Method Summary collapse

Methods included from Namespace

#fully_expanded_name, #has_name?

Methods included from Node

#each_recursive, #find_first_recursive, #indent, #index_in_parent, #next_sibling_node, #parent?, #previous_sibling_node

Constructor Details

#initialize(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 )

44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
# 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 Attribute Details

#elementObject

The element to which this attribute belongs


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

def element
  @element
end

#normalized=(value) ⇒ Object (writeonly)

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


17
18
19
# File 'lib/rexml/attribute.rb', line 17

def normalized=(value)
  @normalized = value
end

Instance Method Details

#==(other) ⇒ Object

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


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

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

#cloneObject

Returns a copy of this attribute


144
145
146
# File 'lib/rexml/attribute.rb', line 144

def clone
  Attribute.new self
end

#doctypeObject


118
119
120
121
122
123
# File 'lib/rexml/attribute.rb', line 118

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

#hashObject

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


100
101
102
# File 'lib/rexml/attribute.rb', line 100

def hash
  name.hash + value.hash
end

#inspectObject


178
179
180
181
182
# File 'lib/rexml/attribute.rb', line 178

def inspect
  rv = ""
  write( rv )
  rv
end

#namespace(arg = nil) ⇒ Object

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

88
89
90
91
# File 'lib/rexml/attribute.rb', line 88

def namespace arg=nil
  arg = prefix if arg.nil?
  @element.namespace arg
end

#node_typeObject


174
175
176
# File 'lib/rexml/attribute.rb', line 174

def node_type
  :attribute
end

#prefixObject

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

72
73
74
75
76
77
78
# File 'lib/rexml/attribute.rb', line 72

def prefix
  pf = super
  if pf == ""
    pf = @element.prefix if @element
  end
  pf
end

#removeObject

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

This method is usually not called directly.


165
166
167
# File 'lib/rexml/attribute.rb', line 165

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

#to_sObject

Returns the attribute value, with entities replaced


126
127
128
129
130
131
132
# File 'lib/rexml/attribute.rb', line 126

def to_s
  return @normalized if @normalized

  @normalized = Text::normalize( @unnormalized, doctype )
  @unnormalized = nil
  @normalized
end

#to_stringObject

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

110
111
112
113
114
115
116
# File 'lib/rexml/attribute.rb', line 110

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

#valueObject

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


136
137
138
139
140
141
# File 'lib/rexml/attribute.rb', line 136

def value
  return @unnormalized if @unnormalized
  @unnormalized = Text::unnormalize( @normalized, doctype )
  @normalized = nil
  @unnormalized
end

#write(output, indent = -1 )) ⇒ Object

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


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

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

#xpathObject


184
185
186
187
188
# File 'lib/rexml/attribute.rb', line 184

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