# File lib/soap/parser.rb, line 68
68:   def initialize(opt = {})
69:     @opt = opt
70:     @parser = XSD::XMLParser.create_parser(self, opt)
71:     @parsestack = nil
72:     @lastnode = nil
73:     @handlers = {}
74:     @envelopenamespace = opt[:envelopenamespace] || EnvelopeNamespace
75:     @default_encodingstyle = opt[:default_encodingstyle] || EncodingNamespace
76:     @decode_typemap = opt[:decode_typemap] || nil
77:     @allow_unqualified_element = opt[:allow_unqualified_element] || false
78:   end

     # File lib/soap/parser.rb, line 135
135:   def characters(text)
136:     lastframe = @parsestack.last
137:     if lastframe
138:       # Need not to be cloned because character does not have attr.
139:       decode_text(lastframe.ns, text, lastframe.encodingstyle)
140:     else
141:       # Ignore Text outside of SOAP Envelope.
142:       p text if $DEBUG
143:     end
144:   end

    # File lib/soap/parser.rb, line 80
80:   def charset
81:     @parser.charset
82:   end

     # File lib/soap/parser.rb, line 146
146:   def end_element(name)
147:     lastframe = @parsestack.pop
148:     unless name == lastframe.name
149:       raise UnexpectedElementError.new("Closing element name '#{ name }' does not match with opening element '#{ lastframe.name }'.")
150:     end
151:     decode_tag_end(lastframe.ns, lastframe.node, lastframe.encodingstyle)
152:     @lastnode = lastframe.node.node
153:   end

     # File lib/soap/parser.rb, line 84
 84:   def parse(string_or_readable)
 85:     @parsestack = []
 86:     @lastnode = nil
 87: 
 88:     @handlers.each do |uri, handler|
 89:       handler.decode_prologue
 90:     end
 91: 
 92:     @parser.do_parse(string_or_readable)
 93: 
 94:     unless @parsestack.empty?
 95:       raise FormatDecodeError.new("Unbalanced tag in XML.")
 96:     end
 97: 
 98:     @handlers.each do |uri, handler|
 99:       handler.decode_epilogue
100:     end
101: 
102:     @lastnode
103:   end

     # File lib/soap/parser.rb, line 105
105:   def start_element(name, attrs)
106:     lastframe = @parsestack.last
107:     ns = parent = parent_encodingstyle = nil
108:     if lastframe
109:       ns = lastframe.ns.clone_ns
110:       parent = lastframe.node
111:       parent_encodingstyle = lastframe.encodingstyle
112:     else
113:       ns = XSD::NS.new
114:       parent = ParseFrame::NodeContainer.new(nil)
115:       parent_encodingstyle = nil
116:     end
117: 
118:     attrs = XSD::XMLParser.filter_ns(ns, attrs)
119:     encodingstyle = find_encodingstyle(ns, attrs)
120: 
121:     # Children's encodingstyle is derived from its parent.
122:     if encodingstyle.nil?
123:       if parent.node.is_a?(SOAPHeader)
124:         encodingstyle = LiteralNamespace
125:       else
126:         encodingstyle = parent_encodingstyle || @default_encodingstyle
127:       end
128:     end
129: 
130:     node = decode_tag(ns, name, attrs, parent, encodingstyle)
131: 
132:     @parsestack << ParseFrame.new(ns, name, node, encodingstyle)
133:   end

     # File lib/soap/parser.rb, line 206
206:   def decode_soap_envelope(ns, ele, attrs, parent)
207:     o = nil
208:     if ele.name == EleEnvelope
209:       o = SOAPEnvelope.new
210:       if ext = @opt[:external_content]
211:         ext.each do |k, v|
212:           o.external_content[k] = v
213:         end
214:       end
215:     elsif ele.name == EleHeader
216:       unless parent.node.is_a?(SOAPEnvelope)
217:         raise FormatDecodeError.new("Header should be a child of Envelope.")
218:       end
219:       o = SOAPHeader.new
220:       parent.node.header = o
221:     elsif ele.name == EleBody
222:       unless parent.node.is_a?(SOAPEnvelope)
223:         raise FormatDecodeError.new("Body should be a child of Envelope.")
224:       end
225:       o = SOAPBody.new
226:       parent.node.body = o
227:     elsif ele.name == EleFault
228:       unless parent.node.is_a?(SOAPBody)
229:         raise FormatDecodeError.new("Fault should be a child of Body.")
230:       end
231:       o = SOAPFault.new
232:       parent.node.fault = o
233:     end
234:     o
235:   end

     # File lib/soap/parser.rb, line 166
166:   def decode_tag(ns, name, attrs, parent, encodingstyle)
167:     ele = ns.parse(name)
168: 
169:     # Envelope based parsing.
170:     if ((ele.namespace == @envelopenamespace) ||
171:         (@allow_unqualified_element && ele.namespace.nil?))
172:       o = decode_soap_envelope(ns, ele, attrs, parent)
173:       return o if o
174:     end
175: 
176:     # Encoding based parsing.
177:     handler = find_handler(encodingstyle)
178:     if handler
179:       return handler.decode_tag(ns, ele, attrs, parent)
180:     else
181:       raise FormatDecodeError.new("Unknown encodingStyle: #{ encodingstyle }.")
182:     end
183:   end

     # File lib/soap/parser.rb, line 185
185:   def decode_tag_end(ns, node, encodingstyle)
186:     return unless encodingstyle
187: 
188:     handler = find_handler(encodingstyle)
189:     if handler
190:       return handler.decode_tag_end(ns, node)
191:     else
192:       raise FormatDecodeError.new("Unknown encodingStyle: #{ encodingstyle }.")
193:     end
194:   end

     # File lib/soap/parser.rb, line 196
196:   def decode_text(ns, text, encodingstyle)
197:     handler = find_handler(encodingstyle)
198: 
199:     if handler
200:       handler.decode_text(ns, text)
201:     else
202:       # How should I do?
203:     end
204:   end

     # File lib/soap/parser.rb, line 157
157:   def find_encodingstyle(ns, attrs)
158:     attrs.each do |key, value|
159:       if (ns.compare(@envelopenamespace, AttrEncodingStyle, key))
160:         return value
161:       end
162:     end
163:     nil
164:   end

     # File lib/soap/parser.rb, line 237
237:   def find_handler(encodingstyle)
238:     unless @handlers.key?(encodingstyle)
239:       handler_factory = SOAP::EncodingStyle::Handler.handler(encodingstyle) ||
240:         SOAP::EncodingStyle::Handler.handler(EncodingNamespace)
241:       handler = handler_factory.new(@parser.charset)
242:       handler.decode_typemap = @decode_typemap
243:       handler.decode_prologue
244:       @handlers[encodingstyle] = handler
245:     end
246:     @handlers[encodingstyle]
247:   end