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

Constants included from Namespace

Namespace::NAMESPLIT

Constants included from XMLTokens

XMLTokens::NAME, XMLTokens::NAMECHAR, 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

Attribute.new( attribute_to_clone )

Attribute.new( attribute_to_clone, parent_element )
Attribute.new( "attr", "attr_value" )
Attribute.new( "attr", "attr_value", parent_element )



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# 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 ⇒ Object

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.



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

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

#clone ⇒ Object

Returns a copy of this attribute



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

def clone
	Attribute.new self
end

#hash ⇒ Object

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



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

def hash
	name.hash + value.hash
end

#inspect ⇒ Object 



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

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_attributes({"xmlns:ns", "http://url"})
e.namespace( "ns" )              # -> "http://url"



83
84
85
86
 
# File 'lib/rexml/attribute.rb', line 83

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

#node_type ⇒ Object 



168
169
170
 
# File 'lib/rexml/attribute.rb', line 168

def node_type
  :attribute
end

#prefix ⇒ Object

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



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

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

#remove ⇒ Object

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

This method is usually not called directly.



159
160
161
 
# File 'lib/rexml/attribute.rb', line 159

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

#to_s ⇒ Object

Returns the attribute value, with entities replaced



114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/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 ⇒ Object

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



105
106
107
108
109
110
111
 
# File 'lib/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 ⇒ Object

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



130
131
132
133
134
135
136
137
138
139
140
 
# File 'lib/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) ⇒ Object

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



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

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

#xpath ⇒ Object 



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

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