* lib/{soap,wsdl,xsd}, test/{soap,wsdl,xsd}: imported soap4r/1.5.5.

          #nnn is a ticket number at http://dev.ctor.org/soap4r

          * SOAP

            * allow to configure an envelope namespace of SOAP request. (#124)
                TemporaryNamespace = 'http://www.w3.org/2003/05/soap-envelope'
                @client.options["soap.envelope.requestnamespace"] =
                  TemporaryNamespace
                @client.options["soap.envelope.responsenamespace"] =
                  TemporaryNamespace
                @client.do_proc(...)

            * let SOAP request XML indent space configuable.  see
              "soap.envelope.no_indent" option. (#130)

            * let external CES configuable.
              ex. client["soap.mapping.external_ces"] = 'SJIS'.  $KCODE is used
              by default. (#133)
                external CES ::= CES used in Ruby object of client and server
                internal CES ::= CES used in SOAP/OM

            * add iso-8859-1 external CES support. (#106)

            * fixed illegal 'qualified' handling of elements.  it caused
              ASP.NET inteoperability problem. (#144)

            * added 'soap.envelope.use_numeric_character_reference' (boolean)
              option to let query XML use numeric character reference in XML,
              not plain UTF-8 character.  !GoogleSearch server seems to not
              allow plain UTF-8 character since 2005-08-15 update. (#147)

            * SOAP::Header::SimpleHeader (de)serialization throws an exception
              on !SimpleHeader.on_(in|out)bound when header is a String.  so we
              could not use a simple single element headerItem.  fixed.  thanks
              to emil. (#129)

            * out parameter of rpc operation did not work.  (#132)

            * follow HTTP redirect only if using http-access2.  (#125) (#145)

            * add a workaround for importing an WSDL whose path begins with
              drive letter.  (#115)

          * WSDL

            * SOAP Data which is defined as a simpletype was not mapped
              correctly to Ruby obj when using wsdl2ruby.rb generated classdef
              file. (#123)

            * rpc/literal support. (#118)

            * re-implemented local element qualify/unqualify control.  handles
              elementFormDefault and form in WSDL.  (#119)

            * Array of an element which has simpleType causes a crash. (#128)

            * prarmeterOrder may not contain return part so it can be shorter
              than parts size.  Thanks to Hugh.  (#139)

          * Samples

            * added !BasicAuth client sample. (#117)

            * added Base64 client/server sample.

            * added Flickr SOAP interface client sample. (#122)

            * added !SalesForce client sample. (#135)

            * updated Thawte CA certificate for !GoogleAdWords sample.

            * updated a client script with the newer version made by Johan.
              thanks!

            * shortened long file names. (#120)

            * fixed typo in authheader sample. (#129)

            * updated deprecated method usage.  (#138)


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9169 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

4 files changed, 183 insertions, 95 deletions

diff --git a/lib/soap/rpc/driver.rb b/lib/soap/rpc/driver.rb
index 096a54f01a..0fb4e82488 100644
--- a/lib/soap/rpc/driver.rb
+++ b/lib/soap/rpc/driver.rb
@@ -205,7 +205,7 @@ private
     opt.add_hook("protocol.wiredump_file_base") do |key, value|
       @wiredump_file_base = value
     end
-    opt["protocol.http.charset"] ||= XSD::Charset.encoding_label
+    opt["protocol.http.charset"] ||= XSD::Charset.xml_encoding_label
     opt["protocol.http.proxy"] ||= Env::HTTP_PROXY
     opt["protocol.http.no_proxy"] ||= Env::NO_PROXY
     opt
diff --git a/lib/soap/rpc/element.rb b/lib/soap/rpc/element.rb
index e6cae2f7e0..c224b03d0d 100644
--- a/lib/soap/rpc/element.rb
+++ b/lib/soap/rpc/element.rb
@@ -20,21 +20,25 @@ class SOAPBody < SOAPStruct
   end
 
   def response
+    root = root_node
     if !@is_fault
-      if void?
+      if root.nil?
         nil
+      elsif root.is_a?(SOAPBasetype)
+        root
       else
         # Initial element is [retval].
-        root_node[0]
+        root[0]
       end
     else
-      root_node
+      root
     end
   end
 
   def outparams
-    if !@is_fault and !void?
-      op = root_node[1..-1]
+    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
@@ -42,10 +46,6 @@ class SOAPBody < SOAPStruct
     end
   end
 
-  def void?
-    root_node.nil?
-  end
-
   def fault
     if @is_fault
       self['fault']
diff --git a/lib/soap/rpc/proxy.rb b/lib/soap/rpc/proxy.rb
index b9d80541af..7dfda62006 100644
--- a/lib/soap/rpc/proxy.rb
+++ b/lib/soap/rpc/proxy.rb
@@ -92,6 +92,14 @@ public
     opt[:response_style] ||= :document
     opt[:request_use] ||= :literal
     opt[:response_use] ||= :literal
+    # default values of these values are unqualified in XML Schema.
+    # set true for backward compatibility.
+    unless opt.key?(:elementformdefault)
+      opt[:elementformdefault] = true
+    end
+    unless opt.key?(:attributeformdefault)
+      opt[:attributeformdefault] = true
+    end
     @operation[name] = Operation.new(soapaction, param_def, opt)
   end
 
@@ -101,7 +109,7 @@ public
   alias add_document_method add_document_operation
 
   def invoke(req_header, req_body, opt = nil)
-    opt ||= create_options
+    opt ||= create_encoding_opt
     route(req_header, req_body, opt, opt)
   end
 
@@ -109,15 +117,27 @@ public
     unless op_info = @operation[name]
       raise MethodDefinitionError, "method: #{name} not defined"
     end
+    mapping_opt = create_mapping_opt
     req_header = create_request_header
     req_body = SOAPBody.new(
-      op_info.request_body(params, @mapping_registry, @literal_mapping_registry)
+      op_info.request_body(params, @mapping_registry,
+        @literal_mapping_registry, mapping_opt)
     )
-    reqopt = create_options({
+    reqopt = create_encoding_opt(
       :soapaction => op_info.soapaction || @soapaction,
-      :default_encodingstyle => op_info.request_default_encodingstyle})
-    resopt = create_options({
-      :default_encodingstyle => op_info.response_default_encodingstyle})
+      :envelopenamespace => @options["soap.envelope.requestnamespace"],
+      :default_encodingstyle =>
+        @default_encodingstyle || op_info.request_default_encodingstyle,
+      :elementformdefault => op_info.elementformdefault,
+      :attributeformdefault => op_info.attributeformdefault
+    )
+    resopt = create_encoding_opt(
+      :envelopenamespace => @options["soap.envelope.responsenamespace"],
+      :default_encodingstyle =>
+        @default_encodingstyle || op_info.response_default_encodingstyle,
+      :elementformdefault => op_info.elementformdefault,
+      :attributeformdefault => op_info.attributeformdefault
+    )
     env = route(req_header, req_body, reqopt, resopt)
     raise EmptyResponseError unless env
     receive_headers(env.header)
@@ -126,11 +146,15 @@ public
     rescue ::SOAP::FaultError => e
       op_info.raise_fault(e, @mapping_registry, @literal_mapping_registry)
     end
-    op_info.response_obj(env.body, @mapping_registry, @literal_mapping_registry)
+    op_info.response_obj(env.body, @mapping_registry,
+      @literal_mapping_registry, mapping_opt)
   end
 
   def route(req_header, req_body, reqopt, resopt)
-    req_env = SOAPEnvelope.new(req_header, req_body)
+    req_env = ::SOAP::SOAPEnvelope.new(req_header, req_body)
+    unless reqopt[:envelopenamespace].nil?
+      set_envelopenamespace(req_env, reqopt[:envelopenamespace])
+    end
     reqopt[:external_content] = nil
     conn_data = marshal(req_env, reqopt)
     if ext = reqopt[:external_content]
@@ -159,6 +183,16 @@ public
 
 private
 
+  def set_envelopenamespace(env, namespace)
+    env.elename = XSD::QName.new(namespace, env.elename.name)
+    if env.header
+      env.header.elename = XSD::QName.new(namespace, env.header.elename.name)
+    end
+    if env.body
+      env.body.elename = XSD::QName.new(namespace, env.body.elename.name)
+    end
+  end
+
   def create_request_header
     headers = @headerhandler.on_outbound
     if headers.empty?
@@ -201,6 +235,10 @@ private
 	::SOAP::StreamHandler.parse_media_type(contenttype)
       env = Processor.unmarshal(conn_data.receive_string, opt)
     end
+    unless env.is_a?(::SOAP::SOAPEnvelope)
+      raise ResponseFormatError.new(
+        "response is not a SOAP envelope: #{conn_data.receive_string}")
+    end
     env
   end
 
@@ -212,11 +250,22 @@ private
     header
   end
 
-  def create_options(hash = nil)
+  def create_encoding_opt(hash = nil)
     opt = {}
     opt[:default_encodingstyle] = @default_encodingstyle
     opt[:allow_unqualified_element] = @allow_unqualified_element
     opt[:generate_explicit_type] = @generate_explicit_type
+    opt[:no_indent] = @options["soap.envelope.no_indent"]
+    opt[:use_numeric_character_reference] =
+      @options["soap.envelope.use_numeric_character_reference"]
+    opt.update(hash) if hash
+    opt
+  end
+
+  def create_mapping_opt(hash = nil)
+    opt = {
+      :external_ces => @options["soap.mapping.external_ces"]
+    }
     opt.update(hash) if hash
     opt
   end
@@ -227,6 +276,8 @@ private
     attr_reader :response_style
     attr_reader :request_use
     attr_reader :response_use
+    attr_reader :elementformdefault
+    attr_reader :attributeformdefault
 
     def initialize(soapaction, param_def, opt)
       @soapaction = soapaction
@@ -234,6 +285,9 @@ private
       @response_style = opt[:response_style]
       @request_use = opt[:request_use]
       @response_use = opt[:response_use]
+      # set nil(unqualified) by default
+      @elementformdefault = opt[:elementformdefault]
+      @attributeformdefault = opt[:attributeformdefault]
       check_style(@request_style)
       check_style(@response_style)
       check_use(@request_use)
@@ -247,17 +301,22 @@ private
           RPC::SOAPMethodRequest.new(@rpc_request_qname, param_def, @soapaction)
       else
         @doc_request_qnames = []
+        @doc_request_qualified = []
         @doc_response_qnames = []
-        param_def.each do |inout, paramname, typeinfo|
+        @doc_response_qualified = []
+        param_def.each do |inout, paramname, typeinfo, eleinfo|
           klass_not_used, nsdef, namedef = typeinfo
+          qualified = eleinfo
           if namedef.nil?
             raise MethodDefinitionError.new("qname must be given")
           end
           case inout
           when SOAPMethod::IN
             @doc_request_qnames << XSD::QName.new(nsdef, namedef)
+            @doc_request_qualified << qualified
           when SOAPMethod::OUT
             @doc_response_qnames << XSD::QName.new(nsdef, namedef)
+            @doc_response_qualified << qualified
           else
             raise MethodDefinitionError.new(
               "illegal inout definition for document style: #{inout}")
@@ -274,19 +333,19 @@ private
       (@response_use == :encoded) ? EncodingNamespace : LiteralNamespace
     end
 
-    def request_body(values, mapping_registry, literal_mapping_registry)
+    def request_body(values, mapping_registry, literal_mapping_registry, opt)
       if @request_style == :rpc
-        request_rpc(values, mapping_registry, literal_mapping_registry)
+        request_rpc(values, mapping_registry, literal_mapping_registry, opt)
       else
-        request_doc(values, mapping_registry, literal_mapping_registry)
+        request_doc(values, mapping_registry, literal_mapping_registry, opt)
       end
     end
 
-    def response_obj(body, mapping_registry, literal_mapping_registry)
+    def response_obj(body, mapping_registry, literal_mapping_registry, opt)
       if @response_style == :rpc
-        response_rpc(body, mapping_registry, literal_mapping_registry)
+        response_rpc(body, mapping_registry, literal_mapping_registry, opt)
       else
-        response_doc(body, mapping_registry, literal_mapping_registry)
+        response_doc(body, mapping_registry, literal_mapping_registry, opt)
       end
     end
 
@@ -312,86 +371,89 @@ private
       end
     end
 
-    def request_rpc(values, mapping_registry, literal_mapping_registry)
+    def request_rpc(values, mapping_registry, literal_mapping_registry, opt)
       if @request_use == :encoded
-        request_rpc_enc(values, mapping_registry)
+        request_rpc_enc(values, mapping_registry, opt)
       else
-        request_rpc_lit(values, literal_mapping_registry)
+        request_rpc_lit(values, literal_mapping_registry, opt)
       end
     end
 
-    def request_doc(values, mapping_registry, literal_mapping_registry)
+    def request_doc(values, mapping_registry, literal_mapping_registry, opt)
       if @request_use == :encoded
-        request_doc_enc(values, mapping_registry)
+        request_doc_enc(values, mapping_registry, opt)
       else
-        request_doc_lit(values, literal_mapping_registry)
+        request_doc_lit(values, literal_mapping_registry, opt)
       end
     end
 
-    def request_rpc_enc(values, mapping_registry)
+    def request_rpc_enc(values, mapping_registry, opt)
       method = @rpc_method_factory.dup
       names = method.input_params
       obj = create_request_obj(names, values)
-      soap = Mapping.obj2soap(obj, mapping_registry, @rpc_request_qname)
+      soap = Mapping.obj2soap(obj, mapping_registry, @rpc_request_qname, opt)
       method.set_param(soap)
       method
     end
 
-    def request_rpc_lit(values, mapping_registry)
+    def request_rpc_lit(values, mapping_registry, opt)
       method = @rpc_method_factory.dup
       params = {}
       idx = 0
       method.input_params.each do |name|
         params[name] = Mapping.obj2soap(values[idx], mapping_registry, 
-          XSD::QName.new(nil, name))
+          XSD::QName.new(nil, name), opt)
         idx += 1
       end
       method.set_param(params)
       method
     end
 
-    def request_doc_enc(values, mapping_registry)
+    def request_doc_enc(values, mapping_registry, opt)
       (0...values.size).collect { |idx|
-        ele = Mapping.obj2soap(values[idx], mapping_registry)
+        ele = Mapping.obj2soap(values[idx], mapping_registry, nil, opt)
         ele.elename = @doc_request_qnames[idx]
         ele
       }
     end
 
-    def request_doc_lit(values, mapping_registry)
+    def request_doc_lit(values, mapping_registry, opt)
       (0...values.size).collect { |idx|
         ele = Mapping.obj2soap(values[idx], mapping_registry,
-          @doc_request_qnames[idx])
+          @doc_request_qnames[idx], opt)
         ele.encodingstyle = LiteralNamespace
+        if ele.respond_to?(:qualified)
+          ele.qualified = @doc_request_qualified[idx]
+        end
         ele
       }
     end
 
-    def response_rpc(body, mapping_registry, literal_mapping_registry)
+    def response_rpc(body, mapping_registry, literal_mapping_registry, opt)
       if @response_use == :encoded
-        response_rpc_enc(body, mapping_registry)
+        response_rpc_enc(body, mapping_registry, opt)
       else
-        response_rpc_lit(body, literal_mapping_registry)
+        response_rpc_lit(body, literal_mapping_registry, opt)
       end
     end
 
-    def response_doc(body, mapping_registry, literal_mapping_registry)
+    def response_doc(body, mapping_registry, literal_mapping_registry, opt)
       if @response_use == :encoded
-        return *response_doc_enc(body, mapping_registry)
+        return *response_doc_enc(body, mapping_registry, opt)
       else
-        return *response_doc_lit(body, literal_mapping_registry)
+        return *response_doc_lit(body, literal_mapping_registry, opt)
       end
     end
 
-    def response_rpc_enc(body, mapping_registry)
+    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)
+          @rpc_method_factory.retval_class_name, opt)
       end
       if body.outparams
         outparams = body.outparams.collect { |outparam|
-          Mapping.soap2obj(outparam, mapping_regisry)
+          Mapping.soap2obj(outparam, mapping_registry, nil, opt)
         }
         [ret].concat(outparams)
       else
@@ -399,20 +461,20 @@ private
       end
     end
 
-    def response_rpc_lit(body, mapping_registry)
+    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)
+          @rpc_method_factory.retval_class_name, opt)
       }
     end
 
-    def response_doc_enc(body, mapping_registry)
+    def response_doc_enc(body, mapping_registry, opt)
       body.collect { |key, value|
-        Mapping.soap2obj(value, mapping_registry)
+        Mapping.soap2obj(value, mapping_registry, nil, opt)
       }
     end
 
-    def response_doc_lit(body, mapping_registry)
+    def response_doc_lit(body, mapping_registry, opt)
       body.collect { |key, value|
         Mapping.soap2obj(value, mapping_registry)
       }
@@ -420,8 +482,10 @@ private
 
     def create_request_obj(names, params)
       o = Object.new
-      for idx in 0 ... params.length
+      idx = 0
+      while idx < params.length
         o.instance_variable_set('@' + names[idx], params[idx])
+        idx += 1
       end
       o
     end
diff --git a/lib/soap/rpc/router.rb b/lib/soap/rpc/router.rb
index 1d11bc17dc..71c6eb625b 100644
--- a/lib/soap/rpc/router.rb
+++ b/lib/soap/rpc/router.rb
@@ -28,6 +28,7 @@ class Router
   attr_accessor :mapping_registry
   attr_accessor :literal_mapping_registry
   attr_accessor :generate_explicit_type
+  attr_accessor :external_ces
 
   def initialize(actor)
     @actor = actor
@@ -35,6 +36,7 @@ class Router
     @headerhandler = Header::HandlerSet.new
     @literal_mapping_registry = ::SOAP::Mapping::WSDLLiteralRegistry.new
     @generate_explicit_type = true
+    @external_ces = nil
     @operation_by_soapaction = {}
     @operation_by_qname = {}
     @headerhandlerfactory = []
@@ -163,7 +165,8 @@ class Router
     soap_response = default_encodingstyle = nil
     begin
       soap_response =
-        op.call(env.body, @mapping_registry, @literal_mapping_registry)
+        op.call(env.body, @mapping_registry, @literal_mapping_registry,
+          create_mapping_opt)
       default_encodingstyle = op.response_default_encodingstyle
     rescue Exception
       soap_response = fault($!)
@@ -240,7 +243,8 @@ private
       return op
     end
     if soapaction
-      raise RPCRoutingError.new("operation: #{soapaction} not supported")
+      raise RPCRoutingError.new(
+        "operation: #{soapaction} #{qname} not supported")
     else
       raise RPCRoutingError.new("operation: #{qname} not supported")
     end
@@ -323,6 +327,10 @@ private
       Mapping.obj2soap(detail, @mapping_registry))
   end
 
+  def create_mapping_opt
+    { :external_ces => @external_ces }
+  end
+
   class Operation
     attr_reader :name
     attr_reader :soapaction
@@ -349,14 +357,19 @@ private
         @rpc_response_qname = opt[:response_qname]
       else
         @doc_request_qnames = []
+        @doc_request_qualified = []
         @doc_response_qnames = []
-        param_def.each do |inout, paramname, typeinfo|
+        @doc_response_qualified = []
+        param_def.each do |inout, paramname, typeinfo, eleinfo|
           klass, nsdef, namedef = typeinfo
+          qualified = eleinfo
           case inout
           when SOAPMethod::IN
             @doc_request_qnames << XSD::QName.new(nsdef, namedef)
+            @doc_request_qualified << qualified
           when SOAPMethod::OUT
             @doc_response_qnames << XSD::QName.new(nsdef, namedef)
+            @doc_response_qualified << qualified
           else
             raise ArgumentError.new(
               "illegal inout definition for document style: #{inout}")
@@ -373,18 +386,20 @@ private
       (@response_use == :encoded) ? EncodingNamespace : LiteralNamespace
     end
 
-    def call(body, mapping_registry, literal_mapping_registry)
+    def call(body, mapping_registry, literal_mapping_registry, opt)
       if @request_style == :rpc
-        values = request_rpc(body, mapping_registry, literal_mapping_registry)
+        values = request_rpc(body, mapping_registry, literal_mapping_registry,
+          opt)
       else
-        values = request_document(body, mapping_registry, literal_mapping_registry)
+        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)
+        response_rpc(result, mapping_registry, literal_mapping_registry, opt)
       else
-        response_doc(result, mapping_registry, literal_mapping_registry)
+        response_doc(result, mapping_registry, literal_mapping_registry, opt)
       end
     end
 
@@ -394,61 +409,61 @@ private
       raise NotImplementedError.new('must be defined in derived class')
     end
 
-    def request_rpc(body, mapping_registry, literal_mapping_registry)
+    def request_rpc(body, mapping_registry, literal_mapping_registry, opt)
       request = body.request
       unless request.is_a?(SOAPStruct)
         raise RPCRoutingError.new("not an RPC style")
       end
       if @request_use == :encoded
-        request_rpc_enc(request, mapping_registry)
+        request_rpc_enc(request, mapping_registry, opt)
       else
-        request_rpc_lit(request, literal_mapping_registry)
+        request_rpc_lit(request, literal_mapping_registry, opt)
       end
     end
 
-    def request_document(body, mapping_registry, literal_mapping_registry)
+    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)
+        request_doc_enc(body, mapping_registry, opt)
       else
-        request_doc_lit(body, literal_mapping_registry)
+        request_doc_lit(body, literal_mapping_registry, opt)
       end
     end
 
-    def request_rpc_enc(request, mapping_registry)
-      param = Mapping.soap2obj(request, mapping_registry)
+    def request_rpc_enc(request, mapping_registry, opt)
+      param = Mapping.soap2obj(request, mapping_registry, nil, opt)
       request.collect { |key, value|
         param[key]
       }
     end
 
-    def request_rpc_lit(request, mapping_registry)
+    def request_rpc_lit(request, mapping_registry, opt)
       request.collect { |key, value|
-        Mapping.soap2obj(value, mapping_registry)
+        Mapping.soap2obj(value, mapping_registry, nil, opt)
       }
     end
 
-    def request_doc_enc(body, mapping_registry)
+    def request_doc_enc(body, mapping_registry, opt)
       body.collect { |key, value|
-        Mapping.soap2obj(value, mapping_registry)
+        Mapping.soap2obj(value, mapping_registry, nil, opt)
       }
     end
 
-    def request_doc_lit(body, mapping_registry)
+    def request_doc_lit(body, mapping_registry, opt)
       body.collect { |key, value|
-        Mapping.soap2obj(value, mapping_registry)
+        Mapping.soap2obj(value, mapping_registry, nil, opt)
       }
     end
 
-    def response_rpc(result, mapping_registry, literal_mapping_registry)
+    def response_rpc(result, mapping_registry, literal_mapping_registry, opt)
       if @response_use == :encoded
-        response_rpc_enc(result, mapping_registry)
+        response_rpc_enc(result, mapping_registry, opt)
       else
-        response_rpc_lit(result, literal_mapping_registry)
+        response_rpc_lit(result, literal_mapping_registry, opt)
       end
     end
     
-    def response_doc(result, mapping_registry, literal_mapping_registry)
+    def response_doc(result, mapping_registry, literal_mapping_registry, opt)
       if @doc_response_qnames.size == 1 and !result.is_a?(Array)
         result = [result]
       end
@@ -457,13 +472,13 @@ private
           "but #{result.size} given"
       end
       if @response_use == :encoded
-        response_doc_enc(result, mapping_registry)
+        response_doc_enc(result, mapping_registry, opt)
       else
-        response_doc_lit(result, literal_mapping_registry)
+        response_doc_lit(result, literal_mapping_registry, opt)
       end
     end
 
-    def response_rpc_enc(result, mapping_registry)
+    def response_rpc_enc(result, mapping_registry, opt)
       soap_response =
         @rpc_method_factory.create_method_response(@rpc_response_qname)
       if soap_response.have_outparam?
@@ -473,18 +488,21 @@ private
         outparams = {}
         i = 1
         soap_response.output_params.each do |outparam|
-          outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry)
+          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)
+        soap_response.retval = Mapping.obj2soap(result[0], mapping_registry,
+          nil, opt)
       else
-        soap_response.retval = Mapping.obj2soap(result, mapping_registry)
+        soap_response.retval = Mapping.obj2soap(result, mapping_registry, nil,
+          opt)
       end
       soap_response
     end
 
-    def response_rpc_lit(result, mapping_registry)
+    def response_rpc_lit(result, mapping_registry, opt)
       soap_response =
         @rpc_method_factory.create_method_response(@rpc_response_qname)
       if soap_response.have_outparam?
@@ -495,30 +513,36 @@ private
         i = 1
         soap_response.output_params.each do |outparam|
           outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry,
-            XSD::QName.new(nil, outparam))
+            XSD::QName.new(nil, outparam), opt)
           i += 1
         end
         soap_response.set_outparam(outparams)
         soap_response.retval = Mapping.obj2soap(result[0], mapping_registry,
-          XSD::QName.new(nil, soap_response.elename))
+          XSD::QName.new(nil, soap_response.elename), opt)
       else
         soap_response.retval = Mapping.obj2soap(result, mapping_registry,
-          XSD::QName.new(nil, soap_response.elename))
+          XSD::QName.new(nil, soap_response.elename), opt)
       end
       soap_response
     end
 
-    def response_doc_enc(result, mapping_registry)
+    def response_doc_enc(result, mapping_registry, opt)
       (0...result.size).collect { |idx|
-        ele = Mapping.obj2soap(result[idx], mapping_registry)
+        ele = Mapping.obj2soap(result[idx], mapping_registry, nil, opt)
         ele.elename = @doc_response_qnames[idx]
         ele
       }
     end
 
-    def response_doc_lit(result, mapping_registry)
+    def response_doc_lit(result, mapping_registry, opt)
       (0...result.size).collect { |idx|
-        mapping_registry.obj2soap(result[idx], @doc_response_qnames[idx])
+        ele = Mapping.obj2soap(result[idx], mapping_registry,
+          @doc_response_qnames[idx])
+        ele.encodingstyle = LiteralNamespace
+        if ele.respond_to?(:qualified)
+          ele.qualified = @doc_response_qualified[idx]
+        end
+        ele
       }
     end