Class | REXML::Entity
In: | temp/entity.rb
Parent: | Child

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

### Methods

matches? new normalized to_s unnormalized value write

### Included Modules

XMLTokens

### Constants

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

### Attributes

external | [R] |
name | [R] |
ndata | [R] |
pubid | [R] |
ref | [R] |

### Public Class methods

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', '&' )

### Public Instance methods

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

[Validate]