lib/soap/encodingstyle/soapHandler.rb
# encoding: UTF-8
# SOAP4R - SOAP EncodingStyle handler library
# Copyright (C) 2000-2007 NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
# This program is copyrighted free software by NAKAMURA, Hiroshi. You can
# redistribute it and/or modify it under the same terms of Ruby's license;
# either the dual license version in 2003, or any later version.
require 'soap/encodingstyle/handler'
require 'soap/mapping/registry'
module SOAP
module EncodingStyle
class SOAPHandler < Handler
Namespace = SOAP::EncodingNamespace
add_handler
def initialize(charset = nil)
super(charset)
@refpool = []
@idpool = []
@textbuf = []
@is_first_top_ele = true
end
###
## encode interface.
#
def encode_data(generator, ns, data, parent)
attrs = encode_attrs(generator, ns, data, parent)
if parent && parent.is_a?(SOAPArray) && parent.position
attrs[ns.name(AttrPositionName)] = "[#{parent.position.join(',')}]"
end
name = generator.encode_name(ns, data, attrs)
case data
when SOAPReference
attrs['href'] = data.refidstr
generator.encode_tag(name, attrs)
when SOAPExternalReference
data.referred
attrs['href'] = data.refidstr
generator.encode_tag(name, attrs)
when SOAPRawString
generator.encode_tag(name, attrs)
generator.encode_rawstring(data.to_s)
when XSD::XSDString
generator.encode_tag(name, attrs)
generator.encode_string(@charset ?
XSD::Charset.encoding_to_xml(data.to_s, @charset) : data.to_s)
when XSD::XSDAnySimpleType
generator.encode_tag(name, attrs)
generator.encode_string(data.to_s)
when SOAPStruct
generator.encode_tag(name, attrs)
data.each do |key, value|
generator.encode_child(ns, value, data)
end
when SOAPArray
generator.encode_tag(name, attrs)
data.traverse do |child, *rank|
data.position = data.sparse ? rank : nil
generator.encode_child(ns, child, data)
end
else
raise EncodingStyleError.new(
"unknown object:#{data} in this encodingStyle")
end
end
def encode_data_end(generator, ns, data, parent)
name = generator.encode_name_end(ns, data)
cr = (data.is_a?(SOAPCompoundtype) and data.have_member)
generator.encode_tag_end(name, cr)
end
###
## decode interface.
#
class SOAPTemporalObject
attr_accessor :parent
attr_accessor :position
attr_accessor :id
attr_accessor :root
def initialize
@parent = nil
@position = nil
@id = nil
@root = nil
end
end
class SOAPUnknown < SOAPTemporalObject
attr_reader :type
attr_accessor :definedtype
attr_reader :extraattr
def initialize(handler, elename, type, extraattr)
super()
@handler = handler
@elename = elename
@type = type
@extraattr = extraattr
@definedtype = nil
end
def as_struct
if @extraattr[XSD::AttrNilName] == 'true'
return as_nil
end
o = SOAPStruct.decode(@elename, @type)
o.id = @id
o.root = @root
o.parent = @parent
o.position = @position
o.extraattr.update(@extraattr)
@handler.decode_parent(@parent, o)
o
end
def as_string
if @extraattr[XSD::AttrNilName] == 'true'
return as_nil
end
o = SOAPString.decode(@elename)
o.id = @id
o.root = @root
o.parent = @parent
o.position = @position
o.extraattr.update(@extraattr)
@handler.decode_parent(@parent, o)
o
end
def as_nil
o = SOAPNil.decode(@elename)
o.id = @id
o.root = @root
o.parent = @parent
o.position = @position
o.extraattr.update(@extraattr)
@handler.decode_parent(@parent, o)
o
end
end
def decode_tag(ns, elename, attrs, parent)
@textbuf.clear
is_nil, type, arytype, root, offset, position, href, id =
extract_attrs(ns, attrs)
o = nil
if is_nil
o = SOAPNil.decode(elename)
elsif href
o = SOAPReference.decode(elename, href)
@refpool << o
elsif @decode_typemap
o = decode_tag_by_wsdl(ns, elename, type, parent.node, arytype, attrs)
else
o = decode_tag_by_type(ns, elename, type, parent.node, arytype, attrs)
end
if o.is_a?(SOAPArray)
if offset
o.offset = decode_arypos(offset)
o.sparse = true
else
o.sparse = false
end
end
o.parent = parent
o.id = id
o.root = root
o.position = position
unless o.is_a?(SOAPTemporalObject)
@idpool << o if o.id
decode_parent(parent, o)
end
o
end
def decode_tag_end(ns, node)
textbufstr = @textbuf.join
@textbuf.clear
o = node.node
if o.is_a?(SOAPUnknown)
newnode = if /\A\s*\z/ =~ textbufstr
o.as_struct
else
o.as_string
end
if newnode.id
@idpool << newnode
end
node.replace_node(newnode)
o = node.node
end
decode_textbuf(o, textbufstr)
# unlink definedtype
o.definedtype = nil
end
def decode_text(ns, text)
@textbuf << text
end
def decode_prologue
@refpool.clear
@idpool.clear
@is_first_top_ele = true
end
def decode_epilogue
decode_resolve_id
end
def decode_parent(parent, node)
return unless parent.node
case parent.node
when SOAPUnknown
newparent = parent.node.as_struct
node.parent = newparent
if newparent.id
@idpool << newparent
end
parent.replace_node(newparent)
decode_parent(parent, node)
when SOAPStruct
parent.node.add(node.elename.name, node)
node.parent = parent.node
when SOAPArray
if node.position
parent.node[*(decode_arypos(node.position))] = node
parent.node.sparse = true
else
parent.node.add(node)
end
node.parent = parent.node
else
raise EncodingStyleError.new("illegal parent: #{parent.node}")
end
end
private
def content_ranksize(typename)
typename.scan(/\[[\d,]*\]$/)[0]
end
def content_typename(typename)
typename.sub(/\[,*\]$/, '')
end
def create_arytype(ns, data)
XSD::QName.new(data.arytype.namespace,
content_typename(data.arytype.name) + "[#{data.size.join(',')}]")
end
def encode_attrs(generator, ns, data, parent)
attrs = {}
return attrs if data.is_a?(SOAPReference)
if !parent || parent.encodingstyle != EncodingNamespace
if @generate_explicit_type
Generator.assign_ns(attrs, ns, EnvelopeNamespace)
attrs[ns.name(AttrEncodingStyleName)] = EncodingNamespace
end
data.encodingstyle = EncodingNamespace
end
if data.is_a?(SOAPNil)
attrs[ns.name(XSD::AttrNilName)] = XSD::NilValue
elsif @generate_explicit_type
if data.type.namespace
Generator.assign_ns(attrs, ns, data.type.namespace)
end
if data.is_a?(SOAPArray)
if data.arytype.namespace
Generator.assign_ns(attrs, ns, data.arytype.namespace)
end
Generator.assign_ns(attrs, ns, EncodingNamespace)
attrs[ns.name(AttrArrayTypeName)] = ns.name(create_arytype(ns, data))
if data.type.name
attrs[ns.name(XSD::AttrTypeName)] = ns.name(data.type)
end
elsif parent && parent.is_a?(SOAPArray) && (parent.arytype == data.type)
# No need to add.
elsif !data.type.namespace
# No need to add.
else
attrs[ns.name(XSD::AttrTypeName)] = ns.name(data.type)
end
end
data.extraattr.each do |key, value|
keytag = key
if key.is_a?(XSD::QName)
keytag = encode_attr_key(attrs, ns, key)
end
if value.is_a?(XSD::QName)
value = encode_qname(attrs, ns, value)
else
value = encode_attr_value(generator, ns, key, value)
end
attrs[keytag] = value
end
if data.id
attrs['id'] = data.id
end
attrs
end
def encode_attr_value(generator, ns, qname, value)
case value
when SOAPType
ref = SOAPReference.new(value)
generator.add_reftarget(qname.name, value)
ref.refidstr
else
value.to_s
end
end
def decode_tag_by_wsdl(ns, elename, typestr, parent, arytypestr, attrs)
o = nil
if parent.class == SOAPBody
# root element: should branch by root attribute?
if @is_first_top_ele
# Unqualified name is allowed here.
@is_first_top_ele = false
type = @decode_typemap[elename] ||
@decode_typemap.find_name(elename.name)
if type
o = SOAPStruct.new(elename)
o.elename = elename
o.definedtype = type
return o
end
end
# multi-ref element.
if typestr
typename = ns.parse(typestr)
typedef = @decode_typemap[typename]
if typedef
return decode_definedtype(elename, typename, typedef, arytypestr)
end
end
return decode_tag_by_type(ns, elename, typestr, parent, arytypestr, attrs)
end
if parent.type == XSD::AnyTypeName
return decode_tag_by_type(ns, elename, typestr, parent, arytypestr, attrs)
end
# parent.definedtype == nil means the parent is SOAPUnknown. SOAPUnknown
# is generated by decode_tag_by_type when its type is anyType.
parenttype = parent.definedtype || @decode_typemap[parent.type]
unless parenttype
return decode_tag_by_type(ns, elename, typestr, parent, arytypestr, attrs)
end
definedtype_name = parenttype.child_type(elename)
if definedtype_name and (klass = TypeMap[definedtype_name])
return decode_basetype(klass, elename)
elsif definedtype_name == XSD::AnyTypeName
return decode_tag_by_type(ns, elename, typestr, parent, arytypestr, attrs)
end
if definedtype_name
typedef = @decode_typemap[definedtype_name]
else
typedef = parenttype.child_defined_complextype(elename)
end
decode_definedtype(elename, definedtype_name, typedef, arytypestr)
end
def decode_definedtype(elename, typename, typedef, arytypestr)
unless typedef
raise EncodingStyleError.new("unknown type '#{typename}'")
end
if typedef.is_a?(::WSDL::XMLSchema::SimpleType)
decode_defined_simpletype(elename, typename, typedef, arytypestr)
else
decode_defined_complextype(elename, typename, typedef, arytypestr)
end
end
def decode_basetype(klass, elename)
klass.decode(elename)
end
def decode_defined_simpletype(elename, typename, typedef, arytypestr)
if typedef.base
o = decode_basetype(TypeMap[typedef.base], elename)
o.definedtype = typedef
o
else
raise RuntimeError.new("unsupported simpleType: #{typedef}")
end
end
def decode_defined_complextype(elename, typename, typedef, arytypestr)
case typedef.compoundtype
when :TYPE_STRUCT, :TYPE_MAP
o = SOAPStruct.decode(elename, typename)
o.definedtype = typedef
return o
when :TYPE_ARRAY
expected_arytype = typedef.find_arytype
if arytypestr
actual_arytype = XSD::QName.new(expected_arytype.namespace,
content_typename(expected_arytype.name) <<
content_ranksize(arytypestr))
o = SOAPArray.decode(elename, typename, actual_arytype)
else
o = SOAPArray.new(typename, 1, expected_arytype)
o.elename = elename
end
o.definedtype = typedef
return o
when :TYPE_EMPTY
o = SOAPNil.decode(elename)
o.definedtype = typedef
return o
else
raise RuntimeError.new(
"Unknown kind of complexType: #{typedef.compoundtype}")
end
nil
end
def decode_tag_by_type(ns, elename, typestr, parent, arytypestr, attrs)
if arytypestr
type = typestr ? ns.parse(typestr) : ValueArrayName
node = SOAPArray.decode(elename, type, ns.parse(arytypestr))
node.extraattr.update(attrs)
return node
end
type = nil
if typestr
type = ns.parse(typestr)
elsif parent.is_a?(SOAPArray)
type = parent.arytype
else
# Since it's in dynamic(without any type) encoding process,
# assumes entity as its type itself.
# <SOAP-ENC:Array ...> => type Array in SOAP-ENC.
# <Country xmlns="foo"> => type Country in foo.
type = elename
end
if klass = TypeMap[type]
node = decode_basetype(klass, elename)
node.extraattr.update(attrs)
return node
end
# Unknown type... Struct or String
SOAPUnknown.new(self, elename, type, attrs)
end
def decode_textbuf(node, textbufstr)
case node
when XSD::XSDHexBinary, XSD::XSDBase64Binary
node.set_encoded(textbufstr)
when XSD::XSDString
if @charset
textbufstr = XSD::Charset.encoding_from_xml(textbufstr, @charset)
end
if node.definedtype
node.definedtype.check_lexical_format(textbufstr)
end
node.set(textbufstr)
when SOAPNil
# Nothing to do.
when SOAPBasetype
node.set(textbufstr)
else
# Nothing to do...
end
end
NilLiteralMap = {
'true' => true,
'1' => true,
'false' => false,
'0' => false
}
RootLiteralMap = {
'1' => 1,
'0' => 0
}
def extract_attrs(ns, attrs)
is_nil = NilLiteralMap[attrs[XSD::AttrNilName]]
type = attrs[XSD::AttrTypeName]
arytype = attrs[AttrArrayTypeName]
root = attrs[AttrRootName]
offset = attrs[AttrOffsetName]
position = attrs[AttrPositionName]
href = attrs[AttrHrefName]
id = attrs[AttrIdName]
if attrs.key?(Mapping::RubyIVarName)
attrs[Mapping::RubyIVarName] =
decode_ref_value(ns, attrs[Mapping::RubyIVarName])
end
return is_nil, type, arytype, root, offset, position, href, id
end
def decode_ref_value(ns, value)
if /\A#/ =~ value
o = SOAPReference.decode(nil, value)
@refpool << o
o
else
value
end
end
def decode_arypos(position)
/^\[(.+)\]$/ =~ position
$1.split(',').collect { |s| s.to_i }
end
def decode_resolve_id
count = @refpool.length # To avoid infinite loop
while !@refpool.empty? && count > 0
@refpool = @refpool.find_all { |ref|
o = @idpool.find { |item|
item.id == ref.refid
}
if o.is_a?(SOAPReference)
true # link of link.
elsif o
ref.__setobj__(o)
false
elsif o = ref.rootnode.external_content[ref.refid]
ref.__setobj__(o)
false
else
raise EncodingStyleError.new("unresolved reference: #{ref.refid}")
end
}
count -= 1
end
end
end
SOAPHandler.new
end
end