Class: REXML::Entity

Class REXML::Entity |
In: | rexml/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 parse_stream pull to_s unnormalized value write

Attributes

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

Included modules

XMLTokens

Public Class methods

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

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

matches?(string)

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

parse_stream(source, listener)

Parse an entity from a source stream, notifying a listener of the event

pull(source)

Pull an entity from a source stream, and return an array describing the parsed entity. The format of the array is completely dependant on the entity type, but in general, internal entities will return:

          [ String entity_name, String entity_value ]

Public Instance methods

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.

normalized()

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

write(out, indent=-1)

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

to_s()

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

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"