← Back to branch summary

~ubuntu-branches/ubuntu/lucid/jruby/lucid

« back to all changes in this revision

Viewing changes to lib/ruby/1.9/rexml/entity.rb

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Delafond
  • Date: 2009-12-09 17:30:55 UTC
  • Revision ID: james.westby@ubuntu.com-20091209173055-8ffzikq1768gywux
Tags: upstream-1.3.1
Import upstream version 1.3.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/ruby/1.9/rexml/entity.rb
 
1
require 'rexml/child'
 
2
require 'rexml/source'
 
3
require 'rexml/xmltokens'
 
4
 
 
5
module REXML
 
6
  # God, I hate DTDs.  I really do.  Why this idiot standard still
 
7
  # plagues us is beyond me.
 
8
  class Entity < Child
 
9
    include XMLTokens
 
10
    PUBIDCHAR = "\x20\x0D\x0Aa-zA-Z0-9\\-()+,./:=?;!*@$_%#"
 
11
    SYSTEMLITERAL = %Q{((?:"[^"]*")|(?:'[^']*'))}
 
12
    PUBIDLITERAL = %Q{("[#{PUBIDCHAR}']*"|'[#{PUBIDCHAR}]*')}
 
13
    EXTERNALID = "(?:(?:(SYSTEM)\\s+#{SYSTEMLITERAL})|(?:(PUBLIC)\\s+#{PUBIDLITERAL}\\s+#{SYSTEMLITERAL}))"
 
14
    NDATADECL = "\\s+NDATA\\s+#{NAME}"
 
15
    PEREFERENCE = "%#{NAME};"
 
16
    ENTITYVALUE = %Q{((?:"(?:[^%&"]|#{PEREFERENCE}|#{REFERENCE})*")|(?:'([^%&']|#{PEREFERENCE}|#{REFERENCE})*'))}
 
17
    PEDEF = "(?:#{ENTITYVALUE}|#{EXTERNALID})"
 
18
    ENTITYDEF = "(?:#{ENTITYVALUE}|(?:#{EXTERNALID}(#{NDATADECL})?))"
 
19
    PEDECL = "<!ENTITY\\s+(%)\\s+#{NAME}\\s+#{PEDEF}\\s*>"
 
20
    GEDECL = "<!ENTITY\\s+#{NAME}\\s+#{ENTITYDEF}\\s*>"
 
21
    ENTITYDECL = /\s*(?:#{GEDECL})|(?:#{PEDECL})/um
 
22
 
 
23
    attr_reader :name, :external, :ref, :ndata, :pubid
 
24
 
 
25
    # Create a new entity.  Simple entities can be constructed by passing a
 
26
    # name, value to the constructor; this creates a generic, plain entity
 
27
    # reference. For anything more complicated, you have to pass a Source to
 
28
    # the constructor with the entity definiton, or use the accessor methods.
 
29
    # +WARNING+: There is no validation of entity state except when the entity
 
30
    # is read from a stream.  If you start poking around with the accessors,
 
31
    # you can easily create a non-conformant Entity.  The best thing to do is
 
32
    # dump the stupid DTDs and use XMLSchema instead.
 
33
    # 
 
34
    #  e = Entity.new( 'amp', '&' )
 
35
    def initialize stream, value=nil, parent=nil, reference=false
 
36
      super(parent)
 
37
      @ndata = @pubid = @value = @external = nil
 
38
      if stream.kind_of? Array
 
39
        @name = stream[1]
 
40
        if stream[-1] == '%'
 
41
          @reference = true 
 
42
          stream.pop
 
43
        else
 
44
          @reference = false
 
45
        end
 
46
        if stream[2] =~ /SYSTEM|PUBLIC/
 
47
          @external = stream[2]
 
48
          if @external == 'SYSTEM'
 
49
            @ref = stream[3]
 
50
            @ndata = stream[4] if stream.size == 5
 
51
          else
 
52
            @pubid = stream[3]
 
53
            @ref = stream[4]
 
54
          end
 
55
        else
 
56
          @value = stream[2]
 
57
        end
 
58
      else
 
59
        @reference = reference
 
60
        @external = nil
 
61
        @name = stream
 
62
        @value = value
 
63
      end
 
64
    end
 
65
 
 
66
    # Evaluates whether the given string matchs an entity definition,
 
67
    # returning true if so, and false otherwise.
 
68
    def Entity::matches? string
 
69
      (ENTITYDECL =~ string) == 0
 
70
    end
 
71
 
 
72
    # Evaluates to the unnormalized value of this entity; that is, replacing
 
73
    # all entities -- both %ent; and &ent; entities.  This differs from
 
74
    # +value()+ in that +value+ only replaces %ent; entities.
 
75
    def unnormalized
 
76
      document.record_entity_expansion unless document.nil?
 
77
      v = value()
 
78
      return nil if v.nil?
 
79
      @unnormalized = Text::unnormalize(v, parent)
 
80
      @unnormalized
 
81
    end
 
82
 
 
83
    #once :unnormalized
 
84
 
 
85
    # Returns the value of this entity unprocessed -- raw.  This is the
 
86
    # normalized value; that is, with all %ent; and &ent; entities intact
 
87
    def normalized
 
88
      @value
 
89
    end
 
90
 
 
91
    # Write out a fully formed, correct entity definition (assuming the Entity
 
92
    # object itself is valid.)
 
93
    #
 
94
    # out::
 
95
    #   An object implementing <TT>&lt;&lt;<TT> to which the entity will be
 
96
    #   output
 
97
    # indent::
 
98
    #   *DEPRECATED* and ignored
 
99
    def write out, indent=-1
 
100
      out << '<!ENTITY '
 
101
      out << '% ' if @reference
 
102
      out << @name
 
103
      out << ' '
 
104
      if @external
 
105
        out << @external << ' '
 
106
        if @pubid
 
107
          q = @pubid.include?('"')?"'":'"'
 
108
          out << q << @pubid << q << ' '
 
109
        end
 
110
        q = @ref.include?('"')?"'":'"'
 
111
        out << q << @ref << q
 
112
        out << ' NDATA ' << @ndata if @ndata
 
113
      else
 
114
        q = @value.include?('"')?"'":'"'
 
115
        out << q << @value << q
 
116
      end
 
117
      out << '>'
 
118
    end
 
119
 
 
120
    # Returns this entity as a string.  See write().
 
121
    def to_s
 
122
      rv = ''
 
123
      write rv
 
124
      rv
 
125
    end
 
126
 
 
127
    PEREFERENCE_RE = /#{PEREFERENCE}/um
 
128
    # Returns the value of this entity.  At the moment, only internal entities
 
129
    # are processed.  If the value contains internal references (IE,
 
130
    # %blah;), those are replaced with their values.  IE, if the doctype
 
131
    # contains:
 
132
    #  <!ENTITY % foo "bar">
 
133
    #  <!ENTITY yada "nanoo %foo; nanoo>
 
134
    # then:
 
135
    #  doctype.entity('yada').value   #-> "nanoo bar nanoo"
 
136
    def value
 
137
      if @value
 
138
        matches = @value.scan(PEREFERENCE_RE)
 
139
        rv = @value.clone
 
140
        if @parent
 
141
          matches.each do |entity_reference|
 
142
            entity_value = @parent.entity( entity_reference[0] )
 
143
            rv.gsub!( /%#{entity_reference.join};/um, entity_value )
 
144
          end
 
145
        end
 
146
        return rv
 
147
      end
 
148
      nil
 
149
    end
 
150
  end
 
151
 
 
152
  # This is a set of entity constants -- the ones defined in the XML
 
153
  # specification.  These are +gt+, +lt+, +amp+, +quot+ and +apos+.
 
154
  module EntityConst
 
155
    # +>+
 
156
    GT = Entity.new( 'gt', '>' )
 
157
    # +<+
 
158
    LT = Entity.new( 'lt', '<' )
 
159
    # +&+
 
160
    AMP = Entity.new( 'amp', '&' )
 
161
    # +"+
 
162
    QUOT = Entity.new( 'quot', '"' )
 
163
    # +'+
 
164
    APOS = Entity.new( 'apos', "'" )
 
165
  end
 
166
end