constants | attributes | methods
Class

REXML::Entity

Inheritance
< REXML::Child < Object
Included Modules
XMLTokens

God, I hate DTDs. I really do. Why this idiot standard still plagues us is beyond me.

Constants

Name   Description
ENTITYDECL = /\s*(?:#{GEDECL})|(?:#{PEDECL})/um
ENTITYDEF = "(?:#{ENTITYVALUE}|(?:#{EXTERNALID}(#{NDATADECL})?))"
ENTITYVALUE = %Q{((?:"(?:[^%&"]|#{PEREFERENCE}|#{REFERENCE})*")|(?:'([^%&']|#{PEREFERENCE}|#{REFERENCE})*'))}
EXTERNALID = "(?:(?:(SYSTEM)\\s+#{SYSTEMLITERAL})|(?:(PUBLIC)\\s+#{PUBIDLITERAL}\\s+#{SYSTEMLITERAL}))"
GEDECL = "<!ENTITY\\s+#{NAME}\\s+#{ENTITYDEF}\\s*>"
NDATADECL = "\\s+NDATA\\s+#{NAME}"
PEDECL = "<!ENTITY\\s+(%)\\s+#{NAME}\\s+#{PEDEF}\\s*>"
PEDEF = "(?:#{ENTITYVALUE}|#{EXTERNALID})"
PEREFERENCE = "%#{NAME};"
PEREFERENCE_RE = /#{PEREFERENCE}/um
PUBIDCHAR = "\x20\x0D\x0Aa-zA-Z0-9\\-()+,./:=?;!*@$_%#"
PUBIDLITERAL = %Q{("[#{PUBIDCHAR}']*"|'[#{PUBIDCHAR}]*')}
SYSTEMLITERAL = %Q{((?:"[^"]*")|(?:'[^']*'))}

Attributes

Name Visibility R/W Description
external public R
name public R
ndata public R
pubid public R
ref public R

Methods

Class

Visibility Signature
public matches? (string)
public new (stream, value=nil, parent=nil, reference=false)

Instance

Visibility Signature
public normalized ()
public to_s ()
public unnormalized ()
public value ()
public write (out, indent=-1)

Class Method Detail

matches?(string)

Evaluates whether the given string matchs an entity definition, returning true if so, and false otherwise.

new(stream, value=nil, parent=nil, reference=false)

Create a new entity. Simple entities can be constructed by passing a name, value to the constructor; this creates a generic, plain entity reference. For anything more complicated, you have to pass a Source to the constructor with the entity definiton, or use the accessor methods. WARNING: There is no validation of entity state except when the entity is read from a stream. If you start poking around with the accessors, you can easily create a non-conformant Entity. The best thing to do is dump the stupid DTDs and use XMLSchema instead. 

 e = Entity.new( 'amp', '&' )

Instance Method Detail

normalized()

Returns the value of this entity unprocessed — raw. This is the normalized value; that is, with all %ent; and &ent; entities intact

to_s()

Returns this entity as a string. See write().

unnormalized()

Evaluates to the unnormalized value of this entity; that is, replacing all entities — both %ent; and &ent; entities. This differs from +value()+ in that value only replaces %ent; entities.

value()

Returns the value of this entity. At the moment, only internal entities are processed. If the value contains internal references (IE, %blah;), those are replaced with their values. IE, if the doctype contains: 

 <!ENTITY % foo "bar">
 <!ENTITY yada "nanoo %foo; nanoo>

then: 

 doctype.entity('yada').value   #-> "nanoo bar nanoo"

write(out, indent=-1)

Write out a fully formed, correct entity definition (assuming the Entity object itself is valid.)

out:An object implementing <TT>&lt;&lt;<TT> to which the entity will be output
indent:DEPRECATED and ignored