class SOAP::Parser

Attributes

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

Public Class Methods

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

Public Instance Methods

characters(text) click to toggle source
# File lib/soap/parser.rb, line 152
def characters(text)
  # Ignore Text outside of SOAP Envelope.
  if lastframe = @parsestack.last
    # Need not to be cloned because character does not have attr.
    decode_text(lastframe.ns, text, lastframe.handler)
  end
end
charset() click to toggle source
# File lib/soap/parser.rb, line 90
def charset
  @parser.charset
end
end_element(name) click to toggle source
# File lib/soap/parser.rb, line 160
def end_element(name)
  lastframe = @parsestack.pop
  unless name == lastframe.name
    raise UnexpectedElementError.new("Closing element name '#{ name }' does not match with opening element '#{ lastframe.name }'.")
  end
  decode_tag_end(lastframe.ns, lastframe.node, lastframe.handler)
  @lastnode = lastframe.node.node
  @recycleframe = lastframe
end
parse(string_or_readable) click to toggle source
# File lib/soap/parser.rb, line 94
def parse(string_or_readable)
  @parsestack = []
  @lastnode = nil

  @handlers.each do |uri, handler|
    handler.decode_prologue
  end

  @parser.do_parse(string_or_readable)

  unless @parsestack.empty?
    raise FormatDecodeError.new("Unbalanced tag in XML.")
  end

  @handlers.each do |uri, handler|
    handler.decode_epilogue
  end

  @lastnode
end
start_element(name, raw_attrs) click to toggle source
# File lib/soap/parser.rb, line 115
def start_element(name, raw_attrs)
  lastframe = @parsestack.last
  ns = parent = parent_encodingstyle = nil
  if lastframe
    ns = lastframe.ns
    parent = lastframe.node
    parent_encodingstyle = lastframe.encodingstyle
  else
    ns = SOAP::NS.new
    parent = ParseFrame::NodeContainer.new(nil)
    parent_encodingstyle = nil
  end
  # ns might be the same
  ns, raw_attrs = XSD::XMLParser.filter_ns(ns, raw_attrs)
  attrs = decode_attrs(ns, raw_attrs)
  encodingstyle = attrs[AttrEncodingStyleName]
  # Children's encodingstyle is derived from its parent.
  if encodingstyle.nil?
    if parent.node.is_a?(SOAPHeader)
      encodingstyle = LiteralNamespace
    else
      encodingstyle = parent_encodingstyle || @default_encodingstyle
    end
  end
  handler = find_handler(encodingstyle)
  unless handler
    raise FormatDecodeError.new("Unknown encodingStyle: #{ encodingstyle }.")
  end
  node = decode_tag(ns, name, attrs, parent, handler)
  if @recycleframe
    @parsestack << @recycleframe.update(ns, name, node, encodingstyle, handler)
    @recycleframe = nil
  else
    @parsestack << ParseFrame.new(ns, name, node, encodingstyle, handler)
  end
end

Private Instance Methods

decode_attrs(ns, attrs) click to toggle source
# File lib/soap/parser.rb, line 188
def decode_attrs(ns, attrs)
  extraattr = {}
  attrs.each do |key, value|
    qname = ns.parse_local(key)
    extraattr[qname] = value
  end
  extraattr
end
decode_soap_envelope(ns, ele, attrs, parent) click to toggle source
# File lib/soap/parser.rb, line 201
def decode_soap_envelope(ns, ele, attrs, parent)
  o = nil
  if ele.name == EleEnvelope
    o = SOAPEnvelope.new
    if ext = @opt[:external_content]
      ext.each do |k, v|
        o.external_content[k] = v
      end
    end
  elsif ele.name == EleHeader
    return nil unless parent.node.is_a?(SOAPEnvelope)
    o = SOAPHeader.new
    parent.node.header = o
  elsif ele.name == EleBody
    return nil unless parent.node.is_a?(SOAPEnvelope)
    o = SOAPBody.new
    parent.node.body = o
  elsif ele.name == EleFault
    if parent.node.is_a?(SOAPBody)
      o = SOAPFault.new
      parent.node.fault = o
    elsif parent.node.is_a?(SOAPEnvelope)
      # live.com server returns SOAPFault as a direct child of SOAPEnvelope.
      # support it even if it's not spec compliant.
      warn("Fault must be a child of Body.")
      body = SOAPBody.new
      parent.node.body = body
      o = SOAPFault.new
      body.fault = o
    else
      return nil
    end
  end
  o.extraattr.update(attrs) if o
  o
end
decode_tag(ns, name, attrs, parent, handler) click to toggle source
# File lib/soap/parser.rb, line 172
def decode_tag(ns, name, attrs, parent, handler)
  ele = ns.parse(name)
  # Envelope based parsing.
  if ((ele.namespace == @envelopenamespace) ||
      (@allow_unqualified_element && ele.namespace.nil?))
    o = decode_soap_envelope(ns, ele, attrs, parent)
    return o if o
  end
  # Encoding based parsing.
  return handler.decode_tag(ns, ele, attrs, parent)
end
decode_tag_end(ns, node, handler) click to toggle source
# File lib/soap/parser.rb, line 184
def decode_tag_end(ns, node, handler)
  return handler.decode_tag_end(ns, node)
end
decode_text(ns, text, handler) click to toggle source
# File lib/soap/parser.rb, line 197
def decode_text(ns, text, handler)
  handler.decode_text(ns, text)
end
find_handler(encodingstyle) click to toggle source
# File lib/soap/parser.rb, line 238
def find_handler(encodingstyle)
  unless @handlers.key?(encodingstyle)
    handler_factory = SOAP::EncodingStyle::Handler.handler(encodingstyle) ||
      SOAP::EncodingStyle::Handler.handler(EncodingNamespace)
    handler = handler_factory.new(@parser.charset)
    handler.decode_typemap = @decode_typemap
    handler.decode_prologue
    @handlers[encodingstyle] = handler
  end
  @handlers[encodingstyle]
end