Parent

Included Modules

Files

Class Index [+]

Quicksearch

SOAP::Parser

Attributes

envelopenamespace[RW]
default_encodingstyle[RW]
decode_typemap[RW]
allow_unqualified_element[RW]

Public Class Methods

new(opt = {}) click to toggle source
    # File lib/soap/parser.rb, line 77
77:   def initialize(opt = {})
78:     @opt = opt
79:     @parser = XSD::XMLParser.create_parser(self, opt)
80:     @parsestack = nil
81:     @recycleframe = nil
82:     @lastnode = nil
83:     @handlers = {}
84:     @envelopenamespace = opt[:envelopenamespace] || EnvelopeNamespace
85:     @default_encodingstyle = opt[:default_encodingstyle] || EncodingNamespace
86:     @decode_typemap = opt[:decode_typemap] || nil
87:     @allow_unqualified_element = opt[:allow_unqualified_element] || false
88:   end

Public Instance Methods

characters(text) click to toggle source
     # File lib/soap/parser.rb, line 152
152:   def characters(text)
153:     # Ignore Text outside of SOAP Envelope.
154:     if lastframe = @parsestack.last
155:       # Need not to be cloned because character does not have attr.
156:       decode_text(lastframe.ns, text, lastframe.handler)
157:     end
158:   end
charset() click to toggle source
    # File lib/soap/parser.rb, line 90
90:   def charset
91:     @parser.charset
92:   end
end_element(name) click to toggle source
     # File lib/soap/parser.rb, line 160
160:   def end_element(name)
161:     lastframe = @parsestack.pop
162:     unless name == lastframe.name
163:       raise UnexpectedElementError.new("Closing element name '#{ name }' does not match with opening element '#{ lastframe.name }'.")
164:     end
165:     decode_tag_end(lastframe.ns, lastframe.node, lastframe.handler)
166:     @lastnode = lastframe.node.node
167:     @recycleframe = lastframe
168:   end
parse(string_or_readable) click to toggle source
     # File lib/soap/parser.rb, line 94
 94:   def parse(string_or_readable)
 95:     @parsestack = []
 96:     @lastnode = nil
 97: 
 98:     @handlers.each do |uri, handler|
 99:       handler.decode_prologue
100:     end
101: 
102:     @parser.do_parse(string_or_readable)
103: 
104:     unless @parsestack.empty?
105:       raise FormatDecodeError.new("Unbalanced tag in XML.")
106:     end
107: 
108:     @handlers.each do |uri, handler|
109:       handler.decode_epilogue
110:     end
111: 
112:     @lastnode
113:   end
start_element(name, raw_attrs) click to toggle source
     # File lib/soap/parser.rb, line 115
115:   def start_element(name, raw_attrs)
116:     lastframe = @parsestack.last
117:     ns = parent = parent_encodingstyle = nil
118:     if lastframe
119:       ns = lastframe.ns
120:       parent = lastframe.node
121:       parent_encodingstyle = lastframe.encodingstyle
122:     else
123:       ns = SOAP::NS.new
124:       parent = ParseFrame::NodeContainer.new(nil)
125:       parent_encodingstyle = nil
126:     end
127:     # ns might be the same
128:     ns, raw_attrs = XSD::XMLParser.filter_ns(ns, raw_attrs)
129:     attrs = decode_attrs(ns, raw_attrs)
130:     encodingstyle = attrs[AttrEncodingStyleName]
131:     # Children's encodingstyle is derived from its parent.
132:     if encodingstyle.nil?
133:       if parent.node.is_a?(SOAPHeader)
134:         encodingstyle = LiteralNamespace
135:       else
136:         encodingstyle = parent_encodingstyle || @default_encodingstyle
137:       end
138:     end
139:     handler = find_handler(encodingstyle)
140:     unless handler
141:       raise FormatDecodeError.new("Unknown encodingStyle: #{ encodingstyle }.")
142:     end
143:     node = decode_tag(ns, name, attrs, parent, handler)
144:     if @recycleframe
145:       @parsestack << @recycleframe.update(ns, name, node, encodingstyle, handler)
146:       @recycleframe = nil
147:     else
148:       @parsestack << ParseFrame.new(ns, name, node, encodingstyle, handler)
149:     end
150:   end

Private Instance Methods

decode_attrs(ns, attrs) click to toggle source
     # File lib/soap/parser.rb, line 188
188:   def decode_attrs(ns, attrs)
189:     extraattr = {}
190:     attrs.each do |key, value|
191:       qname = ns.parse_local(key)
192:       extraattr[qname] = value
193:     end
194:     extraattr
195:   end
decode_soap_envelope(ns, ele, attrs, parent) click to toggle source
     # File lib/soap/parser.rb, line 201
201:   def decode_soap_envelope(ns, ele, attrs, parent)
202:     o = nil
203:     if ele.name == EleEnvelope
204:       o = SOAPEnvelope.new
205:       if ext = @opt[:external_content]
206:         ext.each do |k, v|
207:           o.external_content[k] = v
208:         end
209:       end
210:     elsif ele.name == EleHeader
211:       return nil unless parent.node.is_a?(SOAPEnvelope)
212:       o = SOAPHeader.new
213:       parent.node.header = o
214:     elsif ele.name == EleBody
215:       return nil unless parent.node.is_a?(SOAPEnvelope)
216:       o = SOAPBody.new
217:       parent.node.body = o
218:     elsif ele.name == EleFault
219:       if parent.node.is_a?(SOAPBody)
220:         o = SOAPFault.new
221:         parent.node.fault = o
222:       elsif parent.node.is_a?(SOAPEnvelope)
223:         # live.com server returns SOAPFault as a direct child of SOAPEnvelope.
224:         # support it even if it's not spec compliant.
225:         warn("Fault must be a child of Body.")
226:         body = SOAPBody.new
227:         parent.node.body = body
228:         o = SOAPFault.new
229:         body.fault = o
230:       else
231:         return nil
232:       end
233:     end
234:     o.extraattr.update(attrs) if o
235:     o
236:   end
decode_tag(ns, name, attrs, parent, handler) click to toggle source
     # File lib/soap/parser.rb, line 172
172:   def decode_tag(ns, name, attrs, parent, handler)
173:     ele = ns.parse(name)
174:     # Envelope based parsing.
175:     if ((ele.namespace == @envelopenamespace) ||
176:         (@allow_unqualified_element && ele.namespace.nil?))
177:       o = decode_soap_envelope(ns, ele, attrs, parent)
178:       return o if o
179:     end
180:     # Encoding based parsing.
181:     return handler.decode_tag(ns, ele, attrs, parent)
182:   end
decode_tag_end(ns, node, handler) click to toggle source
     # File lib/soap/parser.rb, line 184
184:   def decode_tag_end(ns, node, handler)
185:     return handler.decode_tag_end(ns, node)
186:   end
decode_text(ns, text, handler) click to toggle source
     # File lib/soap/parser.rb, line 197
197:   def decode_text(ns, text, handler)
198:     handler.decode_text(ns, text)
199:   end
find_handler(encodingstyle) click to toggle source
     # File lib/soap/parser.rb, line 238
238:   def find_handler(encodingstyle)
239:     unless @handlers.key?(encodingstyle)
240:       handler_factory = SOAP::EncodingStyle::Handler.handler(encodingstyle) ||
241:         SOAP::EncodingStyle::Handler.handler(EncodingNamespace)
242:       handler = handler_factory.new(@parser.charset)
243:       handler.decode_typemap = @decode_typemap
244:       handler.decode_prologue
245:       @handlers[encodingstyle] = handler
246:     end
247:     @handlers[encodingstyle]
248:   end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.