lib/soap/rpc/element.rb
# encoding: UTF-8
# SOAP4R - RPC element definition.
# 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/baseData'
require 'soap/rpc/methodDef'
module SOAP
# Add method definitions for RPC to common definition in element.rb
class SOAPBody < SOAPStruct
public
def request
root_node
end
def response
root = root_node
if !@is_fault
if root.nil?
nil
elsif root.is_a?(SOAPBasetype)
root
else
# Initial element is [retval].
root[0]
end
else
root
end
end
def outparams
root = root_node
if !@is_fault and !root.nil? and !root.is_a?(SOAPBasetype)
op = root[1..-1]
op = nil if op && op.empty?
op
else
nil
end
end
def fault
if @is_fault
self['fault']
else
nil
end
end
def fault=(fault)
@is_fault = true
add('fault', fault)
end
end
module RPC
class RPCError < Error; end
class MethodDefinitionError < RPCError; end
class ParameterError < RPCError; end
class SOAPMethod < SOAPStruct
RETVAL = :retval
IN = :in
OUT = :out
INOUT = :inout
attr_reader :param_def
attr_reader :inparam
attr_reader :outparam
attr_reader :retval_name
attr_reader :retval_class_name
def initialize(qname, param_def = nil)
super(nil)
@elename = qname
@encodingstyle = nil
@param_def = param_def
@signature = []
@inparam_names = []
@inoutparam_names = []
@outparam_names = []
@inparam = {}
@outparam = {}
@retval_name = nil
@retval_class_name = nil
init_params(@param_def) if @param_def
end
def have_member
true
end
def have_outparam?
@outparam_names.size > 0
end
def input_params
collect_params(IN, INOUT)
end
def output_params
collect_params(OUT, INOUT)
end
def input_param_types
collect_param_types(IN, INOUT)
end
def output_param_types
collect_param_types(OUT, INOUT)
end
def set_param(params)
params.each do |param, data|
@inparam[param] = data
data.elename = XSD::QName.new(data.elename.namespace, param)
data.parent = self
end
end
def set_outparam(params)
params.each do |param, data|
@outparam[param] = data
data.elename = XSD::QName.new(data.elename.namespace, param)
end
end
def get_paramtypes(names)
types = []
@signature.each do |io_type, name, type_qname|
if type_qname && idx = names.index(name)
types[idx] = type_qname
end
end
types
end
def SOAPMethod.param_count(param_def, *type)
count = 0
param_def.each do |param|
param = MethodDef.to_param(param)
if type.include?(param.io_type.to_sym)
count += 1
end
end
count
end
def SOAPMethod.derive_rpc_param_def(obj, name, *param)
if param.size == 1 and param[0].is_a?(Array)
return param[0]
end
if param.empty?
method = obj.method(name)
param_names = (1..method.arity.abs).collect { |i| "p#{i}" }
else
param_names = param
end
create_rpc_param_def(param_names)
end
def SOAPMethod.create_rpc_param_def(param_names)
param_def = []
param_names.each do |param_name|
param_def.push([IN, param_name, nil])
end
param_def.push([RETVAL, 'return', nil])
param_def
end
def SOAPMethod.create_doc_param_def(req_qnames, res_qnames)
req_qnames = [req_qnames] if req_qnames.is_a?(XSD::QName)
res_qnames = [res_qnames] if res_qnames.is_a?(XSD::QName)
param_def = []
# req_qnames and res_qnames can be nil
if req_qnames
req_qnames.each do |qname|
param_def << [IN, qname.name, [nil, qname.namespace, qname.name]]
end
end
if res_qnames
res_qnames.each do |qname|
param_def << [OUT, qname.name, [nil, qname.namespace, qname.name]]
end
end
param_def
end
private
def collect_param_types(*type)
names = []
@signature.each do |io_type, name, type_qname|
names << type_qname if type.include?(io_type)
end
names
end
def collect_params(*type)
names = []
@signature.each do |io_type, name, type_qname|
names << name if type.include?(io_type)
end
names
end
def init_params(param_def)
param_def.each do |param|
param = MethodDef.to_param(param)
init_param(param)
end
end
def init_param(param)
mapped_class = SOAPMethod.parse_mapped_class(param.mapped_class)
qname = param.qname
if qname.nil? and mapped_class
qname = TypeMap.respond_to?(:key) ? TypeMap.key(mapped_class) : TypeMap.index(mapped_class) # RubyJedi: compatible with Ruby 1.8.6 and above
end
case param.io_type
when IN
@signature.push([IN, param.name, qname])
@inparam_names.push(param.name)
when OUT
@signature.push([OUT, param.name, qname])
@outparam_names.push(param.name)
when INOUT
@signature.push([INOUT, param.name, qname])
@inoutparam_names.push(param.name)
when RETVAL
if @retval_name
raise MethodDefinitionError.new('duplicated retval')
end
@retval_name = param.name
@retval_class_name = mapped_class
else
raise MethodDefinitionError.new("unknown type: #{param.io_type}")
end
end
def self.parse_mapped_class(mapped_class)
# the first element of typedef in param_def can be a String like
# "::SOAP::SOAPStruct" or "CustomClass[]". turn this String to a class if
# we can.
if mapped_class.is_a?(String)
if /\[\]\Z/ =~ mapped_class
# when '[]' is added, ignore this.
mapped_class = nil
else
mapped_class = Mapping.class_from_name(mapped_class)
end
end
mapped_class
end
end
class SOAPMethodRequest < SOAPMethod
attr_accessor :soapaction
def SOAPMethodRequest.create_request(qname, *params)
param_def = []
param_value = []
i = 0
params.each do |param|
param_name = "p#{i}"
i += 1
param_def << [IN, param_name, nil]
param_value << [param_name, param]
end
param_def << [RETVAL, 'return', nil]
o = new(qname, param_def)
o.set_param(param_value)
o
end
def initialize(qname, param_def = nil, soapaction = nil)
super(qname, param_def)
@soapaction = soapaction
end
def each
input_params.each do |name|
unless @inparam[name]
raise ParameterError.new("parameter: #{name} was not given")
end
yield(name, @inparam[name])
end
end
def dup
req = self.class.new(@elename.dup, @param_def, @soapaction)
req.encodingstyle = @encodingstyle
req
end
def create_method_response(response_name = nil)
response_name ||=
XSD::QName.new(@elename.namespace, @elename.name + 'Response')
SOAPMethodResponse.new(response_name, @param_def)
end
end
class SOAPMethodResponse < SOAPMethod
def initialize(qname, param_def = nil)
super(qname, param_def)
@retval = nil
end
def retval
@retval
end
def retval=(retval)
@retval = retval
@retval.elename = @retval.elename.dup_name(@retval_name || 'return')
retval.parent = self
retval
end
def each
if @retval_name and !@retval.is_a?(SOAPVoid)
yield(@retval_name, @retval)
end
output_params.each do |name|
unless @outparam[name]
raise ParameterError.new("parameter: #{name} was not given")
end
yield(name, @outparam[name])
end
end
end
# To return(?) void explicitly.
# def foo(input_var)
# ...
# return SOAP::RPC::SOAPVoid.new
# end
class SOAPVoid < XSD::XSDAnySimpleType
include SOAPBasetype
extend SOAPModuleUtils
Name = XSD::QName.new(Mapping::RubyCustomTypeNamespace, nil)
public
def initialize()
@elename = Name
@id = nil
@precedents = []
@parent = nil
end
end
end
end