class SOAP::RPC::Router::Operation

Attributes

faults[R]
name[R]
request_style[R]
request_use[R]
response_style[R]
response_use[R]
soapaction[R]

Public Class Methods

new(soapaction, name, param_def, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 408
def initialize(soapaction, name, param_def, opt)
  @soapaction = soapaction
  @name = name
  @request_style = opt[:request_style]
  @response_style = opt[:response_style]
  @request_use = opt[:request_use]
  @response_use = opt[:response_use]
  @faults = opt[:faults]
  check_style(@request_style)
  check_style(@response_style)
  check_use(@request_use)
  check_use(@response_use)
  if @response_style == :rpc
    request_qname = opt[:request_qname] or raise
    @rpc_method_factory =
      RPC::SOAPMethodRequest.new(request_qname, param_def, @soapaction)
    @rpc_response_qname = opt[:response_qname]
  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 ArgumentError.new(
          "illegal inout definition for document style: #{param.io_type}")
      end
    end
  end
end

Public Instance Methods

call(body, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 451
def call(body, mapping_registry, literal_mapping_registry, opt)
  if @request_style == :rpc
    values = request_rpc(body, mapping_registry, literal_mapping_registry,
      opt)
  else
    values = request_document(body, mapping_registry,
      literal_mapping_registry, opt)
  end
  result = receiver.method(@name.intern).call(*values)
  return result if result.is_a?(SOAPFault)
  if @response_style == :rpc
    response_rpc(result, mapping_registry, literal_mapping_registry, opt)
  elsif @doc_response_qnames.empty?
    # nothing to do
  else
    response_doc(result, mapping_registry, literal_mapping_registry, opt)
  end
end
request_default_encodingstyle() click to toggle source
# File lib/soap/rpc/router.rb, line 443
def request_default_encodingstyle
  (@request_use == :encoded) ? EncodingNamespace : LiteralNamespace
end
response_default_encodingstyle() click to toggle source
# File lib/soap/rpc/router.rb, line 447
def response_default_encodingstyle
  (@response_use == :encoded) ? EncodingNamespace : LiteralNamespace
end

Private Instance Methods

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

nil means oneway

# File lib/soap/rpc/router.rb, line 624
def check_use(use)
  unless [:encoded, :literal, nil].include?(use)
    raise ArgumentError.new("unknown use: #{use}")
  end
end
receiver() click to toggle source
# File lib/soap/rpc/router.rb, line 472
def receiver
  raise NotImplementedError.new('must be defined in derived class')
end
request_doc_enc(body, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 515
def request_doc_enc(body, mapping_registry, opt)
  body.collect { |key, value|
    Mapping.soap2obj(value, mapping_registry, nil, opt)
  }
end
request_doc_lit(body, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 521
def request_doc_lit(body, mapping_registry, opt)
  body.collect { |key, value|
    Mapping.soap2obj(value, mapping_registry, nil, opt)
  }
end
request_document(body, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 493
def request_document(body, mapping_registry, literal_mapping_registry, opt)
  # ToDo: compare names with @doc_request_qnames
  if @request_use == :encoded
    request_doc_enc(body, mapping_registry, opt)
  else
    request_doc_lit(body, literal_mapping_registry, opt)
  end
end
request_rpc(body, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 476
def request_rpc(body, mapping_registry, literal_mapping_registry, opt)
  request = body.request
  unless request.is_a?(SOAPNameAccessible)
    if request.is_a?(SOAPNil)
      # SOAP::Lite/0.69 seems to send xsi:nil="true" element as a request.
      request = SOAPStruct.new(request.elename)
    else
      raise RPCRoutingError.new("not an RPC style")
    end
  end
  if @request_use == :encoded
    request_rpc_enc(request, mapping_registry, opt)
  else
    request_rpc_lit(request, literal_mapping_registry, opt)
  end
end
request_rpc_enc(request, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 502
def request_rpc_enc(request, mapping_registry, opt)
  param = Mapping.soap2obj(request, mapping_registry, nil, opt)
  request.collect { |key, value|
    param[key]
  }
end
request_rpc_lit(request, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 509
def request_rpc_lit(request, mapping_registry, opt)
  request.collect { |key, value|
    Mapping.soap2obj(value, mapping_registry, nil, opt)
  }
end
response_doc(result, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 535
def response_doc(result, mapping_registry, literal_mapping_registry, opt)
  if @doc_response_qnames.size == 0
    result = []
  elsif @doc_response_qnames.size == 1
    result = [result]
  end
  if result.size != @doc_response_qnames.size
    raise "required #{@doc_response_qnames.size} responses " +
      "but #{result.size} given"
  end
  if @response_use == :encoded
    response_doc_enc(result, mapping_registry, opt)
  else
    response_doc_lit(result, literal_mapping_registry, opt)
  end
end
response_doc_enc(result, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 600
def response_doc_enc(result, mapping_registry, opt)
  (0...result.size).collect { |idx|
    ele = Mapping.obj2soap(result[idx], mapping_registry, nil, opt)
    ele.elename = @doc_response_qnames[idx]
    ele
  }
end
response_doc_lit(result, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 608
def response_doc_lit(result, mapping_registry, opt)
  (0...result.size).collect { |idx|
    ele = Mapping.obj2soap(result[idx], mapping_registry,
      @doc_response_qnames[idx])
    ele.encodingstyle = LiteralNamespace
    ele
  }
end
response_rpc(result, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 527
def response_rpc(result, mapping_registry, literal_mapping_registry, opt)
  if @response_use == :encoded
    response_rpc_enc(result, mapping_registry, opt)
  else
    response_rpc_lit(result, literal_mapping_registry, opt)
  end
end
response_rpc_enc(result, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 552
def response_rpc_enc(result, mapping_registry, opt)
  soap_response =
    @rpc_method_factory.create_method_response(@rpc_response_qname)
  if soap_response.have_outparam?
    unless result.is_a?(Array)
      raise RPCRoutingError.new("out parameter was not returned")
    end
    outparams = {}
    i = 1
    soap_response.output_params.each do |outparam|
      outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry,
        nil, opt)
      i += 1
    end
    soap_response.set_outparam(outparams)
    soap_response.retval = Mapping.obj2soap(result[0], mapping_registry,
      nil, opt)
  else
    soap_response.retval = Mapping.obj2soap(result, mapping_registry, nil,
      opt)
  end
  soap_response
end
response_rpc_lit(result, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/router.rb, line 576
def response_rpc_lit(result, mapping_registry, opt)
  soap_response =
    @rpc_method_factory.create_method_response(@rpc_response_qname)
  if soap_response.have_outparam?
    unless result.is_a?(Array)
      raise RPCRoutingError.new("out parameter was not returned")
    end
    outparams = {}
    i = 1
    soap_response.output_params.each do |outparam|
      outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry,
        XSD::QName.new(nil, outparam), opt)
      i += 1
    end
    soap_response.set_outparam(outparams)
    soap_response.retval = Mapping.obj2soap(result[0], mapping_registry,
      soap_response.elename, opt)
  else
    soap_response.retval = Mapping.obj2soap(result, mapping_registry,
      soap_response.elename, opt)
  end
  soap_response
end