class SOAP::RPC::Proxy::Operation

Attributes

request_style[R]
request_use[R]
response_style[R]
response_use[R]
soapaction[R]
use_default_namespace[R]

Public Class Methods

new(soapaction, param_def, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 363
def initialize(soapaction, param_def, opt)
  @soapaction = soapaction
  @request_style = opt[:request_style]
  @response_style = opt[:response_style]
  @request_use = opt[:request_use]
  @response_use = opt[:response_use]
  @use_default_namespace =
    opt[:use_default_namespace] || opt[:elementformdefault]
  if opt.key?(:elementformdefault)
    warn("option :elementformdefault is deprecated.  use :use_default_namespace instead")
  end
  check_style(@request_style)
  check_style(@response_style)
  check_use(@request_use)
  check_use(@response_use)
  if @request_style == :rpc
    @rpc_request_qname = opt[:request_qname]
    if @rpc_request_qname.nil?
      raise MethodDefinitionError.new("rpc_request_qname must be given")
    end
    @rpc_method_factory =
      RPC::SOAPMethodRequest.new(@rpc_request_qname, param_def, @soapaction)
  else
    @doc_request_qnames = []
    @doc_response_qnames = []
    param_def.each do |param|
      param = MethodDef.to_param(param)
      case param.io_type
      when SOAPMethod::IN
        @doc_request_qnames << param.qname
      when SOAPMethod::OUT
        @doc_response_qnames << param.qname
      else
        raise MethodDefinitionError.new(
          "illegal inout definition for document style: #{param.io_type}")
      end
    end
  end
end

Public Instance Methods

raise_fault(e, mapping_registry, literal_mapping_registry) click to toggle source
# File lib/soap/rpc/proxy.rb, line 428
def raise_fault(e, mapping_registry, literal_mapping_registry)
  if @response_style == :rpc
    Mapping.fault2exception(e, mapping_registry)
  else
    Mapping.fault2exception(e, literal_mapping_registry)
  end
end
request_body(values, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 411
def request_body(values, mapping_registry, literal_mapping_registry, opt)
  if @request_style == :rpc
    request_rpc(values, mapping_registry, literal_mapping_registry, opt)
  else
    request_doc(values, mapping_registry, literal_mapping_registry, opt)
  end
end
request_default_encodingstyle() click to toggle source
# File lib/soap/rpc/proxy.rb, line 403
def request_default_encodingstyle
  (@request_use == :encoded) ? EncodingNamespace : LiteralNamespace
end
response_default_encodingstyle() click to toggle source
# File lib/soap/rpc/proxy.rb, line 407
def response_default_encodingstyle
  (@response_use == :encoded) ? EncodingNamespace : LiteralNamespace
end
response_obj(body, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 419
def response_obj(body, mapping_registry, literal_mapping_registry, opt)
  if @response_style == :rpc
    response_rpc(body, mapping_registry, literal_mapping_registry, opt)
  else
    unique_result_for_one_element_array(
      response_doc(body, mapping_registry, literal_mapping_registry, opt))
  end
end

Private Instance Methods

check_style(style) click to toggle source
# File lib/soap/rpc/proxy.rb, line 443
def check_style(style)
  unless [:rpc, :document].include?(style)
    raise MethodDefinitionError.new("unknown style: #{style}")
  end
end
check_use(use) click to toggle source

nil means oneway

# File lib/soap/rpc/proxy.rb, line 450
def check_use(use)
  unless [:encoded, :literal, nil].include?(use)
    raise MethodDefinitionError.new("unknown use: #{use}")
  end
end
request_doc(values, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 464
def request_doc(values, mapping_registry, literal_mapping_registry, opt)
  if @request_use == :encoded
    request_doc_enc(values, mapping_registry, opt)
  else
    request_doc_lit(values, literal_mapping_registry, opt)
  end
end
request_doc_enc(values, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 501
def request_doc_enc(values, mapping_registry, opt)
  (0...values.size).collect { |idx|
    ele = Mapping.obj2soap(values[idx], mapping_registry, nil, opt)
    ele.elename = @doc_request_qnames[idx]
    ele
  }
end
request_doc_lit(values, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 509
def request_doc_lit(values, mapping_registry, opt)
  (0...values.size).collect { |idx|
    ele = Mapping.obj2soap(values[idx], mapping_registry,
      @doc_request_qnames[idx], opt)
    ele.encodingstyle = LiteralNamespace
    ele
  }
end
request_rpc(values, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 456
def request_rpc(values, mapping_registry, literal_mapping_registry, opt)
  if @request_use == :encoded
    request_rpc_enc(values, mapping_registry, opt)
  else
    request_rpc_lit(values, literal_mapping_registry, opt)
  end
end
request_rpc_enc(values, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 472
def request_rpc_enc(values, mapping_registry, opt)
  method = @rpc_method_factory.dup
  names = method.input_params
  types = method.input_param_types
  ary = Mapping.objs2soap(values, mapping_registry, types, opt)
  soap = {}
  0.upto(ary.length - 1) do |idx|
    soap[names[idx]] = ary[idx]
  end
  method.set_param(soap)
  method
end
request_rpc_lit(values, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 485
def request_rpc_lit(values, mapping_registry, opt)
  method = @rpc_method_factory.dup
  names = method.input_params
  types = method.get_paramtypes(names)
  params = {}
  idx = 0
  names.each do |name|
    params[name] = Mapping.obj2soap(values[idx], mapping_registry, 
      types[idx], opt)
    params[name].elename = XSD::QName.new(nil, name)
    idx += 1
  end
  method.set_param(params)
  method
end
response_doc(body, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 526
def response_doc(body, mapping_registry, literal_mapping_registry, opt)
  if @response_use == :encoded
    response_doc_enc(body, mapping_registry, opt)
  else
    response_doc_lit(body, literal_mapping_registry, opt)
  end
end
response_doc_enc(body, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 557
def response_doc_enc(body, mapping_registry, opt)
  body.collect { |key, value|
    Mapping.soap2obj(value, mapping_registry, nil, opt)
  }
end
response_doc_lit(body, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 563
def response_doc_lit(body, mapping_registry, opt)
  body.collect { |key, value|
    Mapping.soap2obj(value, mapping_registry)
  }
end
response_rpc(body, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 518
def response_rpc(body, mapping_registry, literal_mapping_registry, opt)
  if @response_use == :encoded
    response_rpc_enc(body, mapping_registry, opt)
  else
    response_rpc_lit(body, literal_mapping_registry, opt)
  end
end
response_rpc_enc(body, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 534
def response_rpc_enc(body, mapping_registry, opt)
  ret = nil
  if body.response
    ret = Mapping.soap2obj(body.response, mapping_registry,
      @rpc_method_factory.retval_class_name, opt)
  end
  if body.outparams
    outparams = body.outparams.collect { |outparam|
      Mapping.soap2obj(outparam, mapping_registry, nil, opt)
    }
    [ret].concat(outparams)
  else
    ret
  end
end
response_rpc_lit(body, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 550
def response_rpc_lit(body, mapping_registry, opt)
  body.root_node.collect { |key, value|
    Mapping.soap2obj(value, mapping_registry,
      @rpc_method_factory.retval_class_name, opt)
  }
end
unique_result_for_one_element_array(ary) click to toggle source

nil for [] / 1 for [1] / [1, 2] for [1, 2]

# File lib/soap/rpc/proxy.rb, line 439
def unique_result_for_one_element_array(ary)
  ary.size <= 1 ? ary[0] : ary
end