# class REXML::Entity

### Constants

ENTITYDECL
ENTITYDEF
ENTITYVALUE
EXTERNALID
GEDECL
NDATADECL
PEDECL
PEDEF
PEREFERENCE
PEREFERENCE_RE
PUBIDCHAR
PUBIDLITERAL
SYSTEMLITERAL

### Attributes

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

### Public Class Methods

matches?(string) click to toggle source

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

    # File lib/rexml/entity.rb, line 66
    def Entity::matches? string
      (ENTITYDECL =~ string) == 0
    end

new(stream, value=nil, parent=nil, reference=false) click to toggle source

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 definition, 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`.

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

Calls superclass method `REXML::Child::new`

    # File lib/rexml/entity.rb, line 33
    def initialize stream, value=nil, parent=nil, reference=false
      super(parent)
      @ndata = @pubid = @value = @external = nil
      if stream.kind_of? Array
        @name = stream[1]
        if stream[-1] == '%'
          @reference = true
          stream.pop
        else
          @reference = false
        end
        if stream[2] =~ /SYSTEM|PUBLIC/
          @external = stream[2]
          if @external == 'SYSTEM'
            @ref = stream[3]
            @ndata = stream[4] if stream.size == 5
          else
            @pubid = stream[3]
            @ref = stream[4]
          end
        else
          @value = stream[2]
        end
      else
        @reference = reference
        @external = nil
        @name = stream
        @value = value
      end
    end

### Public Instance Methods

normalized() click to toggle source

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

    # File lib/rexml/entity.rb, line 85
    def normalized
      @value
    end

to_s() click to toggle source

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

    # File lib/rexml/entity.rb, line 119
    def to_s
      rv = ''
      write rv
      rv
    end

unnormalized() click to toggle source

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.

    # File lib/rexml/entity.rb, line 73
    def unnormalized
      document.record_entity_expansion unless document.nil?
      v = value()
      return nil if v.nil?
      @unnormalized = Text::unnormalize(v, parent)
      @unnormalized
    end

value() click to toggle source

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"

    # File lib/rexml/entity.rb, line 134
    def value
      if @value
        matches = @value.scan(PEREFERENCE_RE)
        rv = @value.clone
        if @parent
          sum = 0
          matches.each do |entity_reference|
            entity_value = @parent.entity( entity_reference[0] )
            if sum + entity_value.bytesize > Security.entity_expansion_text_limit
              raise "entity expansion has grown too large"
            else
              sum += entity_value.bytesize
            end
            rv.gsub!( /%#{entity_reference.join};/um, entity_value )
          end
        end
        return rv
      end
      nil
    end

write(out, indent=-1) click to toggle source

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

    # File lib/rexml/entity.rb, line 97
    def write out, indent=-1
      out << '<!ENTITY '
      out << '% ' if @reference
      out << @name
      out << ' '
      if @external
        out << @external << ' '
        if @pubid
          q = @pubid.include?('"')?"'":'"'
          out << q << @pubid << q << ' '
        end
        q = @ref.include?('"')?"'":'"'
        out << q << @ref << q
        out << ' NDATA ' << @ndata if @ndata
      else
        q = @value.include?('"')?"'":'"'
        out << q << @value << q
      end
      out << '>'
    end